Il est bien connu qu'une personne sur une grille sous l'influence de l'alcool a une chance égale d'aller dans toutes les directions disponibles. Cependant, cette affirmation de bon sens ne s’applique pas au domaine des très petits ivrognes, dont le comportement ressemble beaucoup à ceux qui empruntent tous les chemins disponibles en même temps, et les chemins possibles qu’ils empruntent peuvent se gêner. Votre tâche consiste à afficher les positions possibles d'un tel ivrogne après chaque nétape.

spécification

L’ivrogne en question occupe une grille carrée et peut être considéré comme un automate cellulaire à trois états utilisant un voisinage de Von Neumann (en forme de plus) qui suit ces règles simples:

• Emptyva à Awakesi elle est adjacente à exactement un Awake, et sinon va àEmpty
• Awake va à Sleeping
• Sleeping va à Sleeping

L’état initial du plateau est un simple Awakeentouré d’un champ infini de Emptys.

Défi

Étant donné un entier non négatif n, créez une représentation ASCII de l'ivrogne après les nétapes. Chaque état doit être représenté par un caractère différent et les solutions doivent indiquer quel caractère signifie quel état. Si vous utilisez des espaces pour Empty, vous n'avez pas besoin d'en inclure une série à la fin d'une ligne.

C'est du code-golf , donc la réponse la plus courte gagne. Des failles standard s'appliquent, les espaces de début et de fin sont autorisés, la sortie de tableau de chaînes / 2d est autorisée, etc.

Exemples

Ces exemples utilisent pour Empty, @pour Awakeet #pour Sleeping.

n=0
@

n = 1
 @
@#@
 @

n = 2
  @
  #
@###@
  #
  @

n = 3
   @
  @#@
 @ # @
@#####@
 @ # @
  @#@
   @

n=6

      @
      # 
    @###@
     @#@  
  @  ###  @
  #@# # #@#
@###########@
  #@# # #@#
  @  ###  @
     @#@
    @###@
      #
      @

n=10
          @
          #
        @###@
         @#@
         ###
        # # #
       #######
      #  ###  #
  @  ##  ###  ##  @
  #@# ### # ### #@#
@###################@
  #@# ### # ### #@#
  @  ##  ###  ##  @
      #  ###  #
       #######
        # # #
         ###
         @#@
        @###@
          #
          @

Note intéressante

En regardant la séquence du nombre de cellules occupées dans l'OEIS, j'ai découvert que l'ivrogne quantique était isomorphe à la séquence de cure - dents beaucoup mieux étudiée . Si vous pouvez intégrer cette connaissance à un meilleur golf, je serai bien impressionné.

Wolfram Language (Mathematica) , 92 91 octets

Print@@@CellularAutomaton[{7049487784884,{3,{a={0,3,0},3-2a/3,a}},{1,1}},{j={{1}},0},{j#}]&

Un défi parfait pour utiliser les fonctionnalités de Mathematica CellularAutomaton!

Essayez-le en ligne!

Vide = 0, éveillé = 1, en sommeil = 2

Animation des 256 premières itérations (blanc = vide, gris = réveillé, noir = en sommeil):

Explication

CellularAutomaton[ ... ]

Run CellularAutomatonavec des spécifications ...

{7049487784884,{3,{a={0,3,0},3-2a/3,a}},{1,1}}

Appliquez la règle totaliste 3 couleurs 7049487784884, avec le voisinage de Von Neumann ...

{j={{1}},0}

Sur un tableau avec un seul 1 au milieu, avec un fond de 0 ...

{j#}

Répétez <input>fois ( {j#}évalue à {{{#}}}). Le tableau se développe automatiquement si une cellule à l'extérieur de la bordure n'est pas identique à l'arrière-plan

7049487784884

Cette règle vient du numéro de base 3 220221220221220221220221220, ce qui signifie « changer tout 1ou 2à 2et changer 0de 1si et seulement s'il y a un nombre impair de 1s autour d' elle. »

Print@@@

Imprimer le tableau.

La demi-preuve de "'impair 1' 'équivaut à' exactement un 1'":

Considérez cette grille de pixels 5x5. Le blanc est un 0ou une 2cellule (pixels non éveillés) et le gris est une 1cellule.

Si une 1cellule a été générée autour de trois 0cellules, la grille doit alors ressembler à ceci: elle comporte trois 1colonnes disposées en forme de U (ou une version tournée) comme suit:

En raison de l'auto-similarité de cet automate cellulaire, tout motif apparaissant dans l'automate cellulaire doit apparaître sur la diagonale (par induction). Cependant, ce motif n'est pas symétrique en diagonale. c'est-à-dire qu'il ne peut pas apparaître sur la diagonale ni apparaître nulle part sur l'automate cellulaire.

Awake / Sleeping sont équivalents

Notez qu'une 0cellule ne peut pas être entourée par exactement une ou trois 2cellules et des cellules restantes 0, car cela impliquerait que certaines étapes précédentes, la cellule avait un voisin d'une ou trois 1cellules - et devait être 1déjà devenue une (contradiction). Par conséquent, il est normal d'ignorer la distinction entre 1et 2et l'état "change tout 1en un 1, et un 0en un 1si et seulement s'il a un nombre impair de voisins non nuls".

L’automate cellulaire qui en résulte est en effet identique à l’original, la seule différence étant qu’il n’ya pas de distinction entre les ivrognes "éveillés" et "endormis". Ce modèle est décrit dans le document OEIS A169707 .

Print@@@CellularAutomaton[{750,{2,{a={0,2,0},2-a/2,a}},{1,1}},{j={{1}},0},{j#}]&

Essayez-le en ligne!

Comparaison côte à côte des 16 premières itérations:

L'ajout de deux itérations consécutives donne un résultat conforme aux spécifications de défi (94 octets):

Print@@@Plus@@CellularAutomaton[{750,{2,{a={0,2,0},2-a/2,a}},{1,1}},{{{1}},0},{Ramp@{#-1,#}}]&

Essayez-le en ligne!

Python 2 , 192 octets

x=input()
o=c={x+x*1j}
R=range(x-~x)
exec"n=[C+k for k in-1j,1j,-1,1for C in c];n={k for k in n if(k in o)<2-n.count(k)};o|=c;c=n;"*x
print[[`(X+Y*1jin c)+(X+Y*1jin o|c)`for Y in R]for X in R]

Essayez-le en ligne!

-17 octets grâce à Mr. Xcoder
-9 octets utilisant le format de sortie de Jonathan
-11 octets grâce à Lynn
-3 octets grâce aux ovs

C, 360 354 343 319

#define A(i,b,e)for(int i=b;i<e;++i)
#define B(b,e)A(r,b,e){A(c,b,e)
#define W(n)(n<0?-(n):n)
#define C(r,c)b[W(r)*s+W(c)]
#define D C(r,c)

q(n){char N,s=n+2,(*b)[2]=calloc(s,2*s);C(0,0)
[1]=1;A(g,0,n+1){B(0,s)*D=D[1];}B(0,g+2){N=(*C
(r-1,c)+*C(r+1,c)+*C(r,c-1)+*C(r,c+1))&1;D[1]=
*D?2:N;}}}B(2-s,s-1)putchar(*D+32);puts("");}}

Les nouvelles #definelignes après les non- lignes sont juste pour la présentation ici, elles ne sont donc pas comptées. J'ai inclus une fonction wrapper, donc −6 (313) si la fonction n'est pas comptée et que vous supposez qu'elle nvient d'ailleurs. q(10)les sorties:

          !          
          "          
        !"""!        
         !"!         
         """         
        " " "        
       """""""       
      "  """  "      
  !  ""  """  ""  !  
  "!" """ " """ "!"  
!"""""""""""""""""""!
  "!" """ " """ "!"  
  !  ""  """  ""  !  
      "  """  "      
       """""""       
        " " "        
         """         
         !"!         
        !"""!        
          "          
          !          

Utilisation pour vide, "pour dormir et !pour dormir .

Cela fonctionne comme suit:

• A(i,b,e)est “i∈ [b, e).”, B(b,e)est “r∈ [b, e) .∀c∈ [b, e).”

• Remarquez qu'après n générations, le tableau est égal à 2 n + 1 carré.

• En raison de la symétrie du tableau, il suffit de simuler le quadrant inférieur droit. Nous allouons donc une matrice carrée n + 1 avec une ligne et une colonne de remplissage pour la recherche de voisin ultérieure (donc n + 2).

• Allouer avec callocnous permet de multiplier simultanément la largeur par la hauteur et de vider le tableau 0(vide).

• Lors de la recherche d'une cellule par ses coordonnées ( Cet D), il utilise la valeur absolue de la ligne et de la colonne ( W) pour refléter automatiquement les coordonnées.

• Le tableau est stocké sous la forme d'un tableau de paires d'entiers représentant les générations actuelle et précédente. Les entiers en question sont chardonc évitables sizeof.

• La génération la plus recherchée (par le test du voisin) est la génération précédente, elle est donc placée à l'index 0 de la paire pour pouvoir y accéder avec *.

• A chaque génération ( g), la génération actuelle est copiée sur la génération précédente à l'aide d'une Bboucle, puis la nouvelle génération est générée à partir de l'ancienne.

• Chaque cellule est représentée en utilisant 0pour vide, 1pour éveillé et 2pour dormir. Compter les voisins était à l’origine un calcul du nombre de bits définis dans les 4 bits les plus bas de la cellule lorsque les 4 voisins sont décalés et ordonnés ensemble en tant qu’indicateurs ( N), à utiliser 16pour dormir. Mais avec l'observation qu'un nombre impair de voisins équivaut à exactement 1 voisin, nous pouvons enregistrer plusieurs caractères en utilisant simplement un masque avec 1.

• À la fin, le tableau est entièrement imprimé en effectuant une itération sur le quadrant inférieur droit en utilisant la même astuce de coordonnées de valeur absolue, moins le remplissage, de sorte que nous n'imprimons pas le remplissage extérieur sur le tableau. C'est aussi pourquoi la Bboucle inclut une accolade d'ouverture, car nous avons l'instruction extra newline dans la boucle externe.

• Les codes ASCII mappent commodément 0 + 32 (vide) sur un espace, 2 "+ 32 (en veille) sur et 1 + 32 (éveillé) sur !.

Globalement, je pense qu’il s’agit d’un golf étonnamment lisible en raison de la belle structure du problème.

MATL , 39 octets

QtE:=&*G:"tt0=w1Y6Z+Xj1=*w|gJ*+]Q|U31+c

Cela affiche

• Emptycomme (espace)
• Awake comme #
• Sleepingcomme !.

Essayez-le en ligne! Vous pouvez également regarder le motif se développer dans l’art ASCII ou graphiquement (code modifié).

Explication

Le code utilise des nombres complexes 0, 1, jpour représenter les trois états: vide, réveil, sommeil respectivement.

Q         % Implicitly input n. Add 1
tE        % Duplicate and multiply by 2
:         % Range [1 2 ... 2*n]
=         % Test for equalty. Gives [0 ... 0 1 0... 0], with 1 at position n
&*        % Matrix of all pairwise products. Gives square matrix of size 2*n
          % filled with 0, except a 1 at position (n,n). This is the grid
          % where the walk will take place, initiallized with an awake cell
          % (value 1). The grid is 1 column and row too large (which saves a
          % byte)
G:"       % Do n times
  tt      %   Duplicate current grid state twice
  0=      %   Compare each entry with 0. Gives true for empty cells, false
          %   for the rest
  w       %   Swap: moves copy of current grid state to top
  1Y6     %   Push 3×3 matrix with Von Neumann's neighbourhood
  Z+      %   2D convolution, maintaining size
  Xj      %   Real part
  1=      %   Compare each entry with 1. This gives true for cells that
          %   have exactly 1 awake neighbour
  *       %   Multiply, element-wise. This corresponds to logical "and": 
          %   cells that are currently empty and have exactly one awake
          %   neighbour. These become 1, that is, awake
  w       %   Swap: moves copy of current grid state to top
  |g      %   Absolute value, convert to logical: gives true for awake or
          %   sleeping cells, false for empty cells
  J*+     %   Mulltiply by j and add, element-wise. This sets awake and 
          %   sleeping cells to sleeping. The grid is now in its new state
]         % End
Q         % Add 1, element-wise. Transforms empty, awake, sleeping 
          % respectively from 0, 1, j into 1, 2, 1+j
|U        % Abolute value and square, element-wose. Empty, awake, sleeping 
          % respectively give 1, 4, 2
31+c      % Add 31 element-wise and convert to char. Empty, awake, sleeping 
          % respectively give characters ' ' (codepoint 32), '#' (codepoint 
          % 35) and '!' (codepoint 33). Implicitly display

Befunge, 384 304 octets

&:00p->55+,000g->>00g30p:40p\:50p\5>>40g!50g!*vv0g05g04p03-<
@,+55_^#`g00:+1$_^>p:4+4g5%2-50g+5#^0#+p#1<v03_>30g:!#v_:1>^
#v_>$99g,1+:00g`^ ^04+g04-2%5g4:\g05\g04\p<>g!45*9+*3+v>p:5-
 >\50p\40p\30p:#v_>>0\99g48*`!>v >30g:1-30^>>**\!>#v_>v^9 9<
$0\\\\0$        >\99g88*-!+\:4->#^_\>1-!48>^       >$3>48*+^

Essayez-le en ligne!

Le problème pour essayer d'implémenter ce genre de chose dans Befunge est la taille de la mémoire limitée (2000 octets pour les données et le code). J'ai donc dû utiliser un algorithme qui calcule le caractère correct pour une coordonnée donnée sans faire référence aux calculs précédents. Il y parvient en regardant de manière récursive dans tous les chemins possibles que l'ivrogne aurait pu suivre pour atteindre ce point.

Malheureusement, ce n'est pas une solution particulièrement efficace. Cela fonctionne, mais il est incroyablement lent et devient d'autant plus lent que la valeur de n est grande . Ainsi, bien que cela puisse potentiellement fonctionner pour n n’importe quel nombre d’environ 127 (limite de cellules mémoire de Befunge de 7 bits), dans la pratique, vous perdrez inévitablement tout intérêt à attendre le résultat. Sur TIO, le délai d'attente de 60 secondes sera dépassé (au mieux, environ 6). Un compilateur fera beaucoup mieux, mais même dans ce cas, vous ne voudriez probablement pas aller beaucoup plus haut que 10.

Néanmoins, je pensais que cela valait la peine d'être soumis car c'est en fait une assez belle démonstration d'une "fonction" récursive dans Befunge.

Python 2 , 214 octets

def f(n):k=n-~n;N=k*k;A=[0]*N;A[N/2]=2;exec"A=[[2*([j%k>0and A[j-1],j%k<k-1and A[j+1],j/k>0and A[j-k],j/k<k-1and A[j+k]].count(2)==1),1,1][v]for j,v in enumerate(A)];"*n;print[map(str,A)[k*x:][:k]for x in range(k)]

Essayez-le en ligne!

Explication

Utilisations 0pour empty, 1pour sleepinget 2pour awake. Imprime une liste de caractères à deux dimensions (chaînes d'une longueur).
Définit une fonction qui prend un entier non négatif n. Avance successive de l'automate cellulaire jusqu'à atteindre l'état souhaité. Enfin, une conversion entre les valeurs entières internes et les caractères réels est appliquée.

Lua , 251 242 239 238 octets

-8 octets en simplifiant l'initialiseur de la matrice au prix de quelques espaces supplémentaires supplémentaires.
-1 octet en se transformant c=i==2+...and print(s)en c=i~=2+...or print(s).
-3 octets en construisant d'abord une chaîne complète et en imprimant une fois à la fin.
-1 octet grâce à Jonathan Frech en réécrivant en or(g(...)==1 andtant que or(1==g(...)and.

function g(x,y)return(a[x]or{})[y]or 0 end a={{1}}for i=2,2+...do n={}s=""for x=-i,i do n[x]=n[x]or{}q=a[x]or{}for y=-i,i do n[x][y]=q[y]and 0or(1==g(x+1,y)+g(x,y+1)+g(x-1,y)+g(x,y-1)and 1)s=s..(q[y]or" ")end s=s.."\n"end a=n end print(s)

Essayez-le en ligne!

Vide = Espace
éveillé = 1
Dormir =0

Prend une entrée à partir de la ligne de commande et imprime sur stdout.

En représentant les états comme false/ nil, 1et en 0interne, la détection « vide » n'a pas besoin de code et le contrôle « exactement éveillé » peut être fait avec un simple ajout.

APL (Dyalog) , 38 octets

((2∘∧⌈1={2⊃+/1=⍵,⍉⍵}⌺3 3)(⌽0,⍉)⍣4)⍣⎕⍪1

Essayez-le en ligne!

-4 grâce à Adám .
-8 grâce à ngn .

Gelée , 39 29 octets

-,1ṙ@€Sµ+Z
‘ṬŒḄ×þ`µÇ׬Ḃ+Ḃ+µ³¡

Essayez-le en ligne!

Utilisations 0, 1et 2pour vider éveillé et dormir. Le pied de page dans le lien convertit cela en , @et #.

• -1 octet en utilisant ṬŒḄau lieu de ḤḶ=¹.
• -2 octets en utilisant -au lieu de 1N. Rend également ¤inutile.
• -1 octet en utilisant Sau lieu de +/.
• -6 octets en utilisant Ḃ+Ḃ+au lieu de %3=1+=1Ḥ$+. Maintenant utilise 2pour dormir au lieu de 3.

Explication à venir ...

APL (Dyalog Classic) , 38 octets

((2∘∧⌈2|⍉∘g∘⍉+g←3+/0,,∘0)(⌽0,⍉)⍣4)⍣⎕⍪1

Essayez-le en ligne!

basé sur la solution d'Erik the Outgolfer

⍪1 est une matrice 1x1 contenant 1

⎕ entrée évaluée

( )⍣⎕ appliquer autant de fois

• (⌽0,⍉)⍣4entourez avec des 0, c’est-à-dire 4 fois: transposez ( ⍉), ajoutez des 0 à gauche ( 0,), inversez horizontalement ( ⌽)

• g←3+/0,,∘0 une fonction qui additionne les triples horizontaux, appelez-la g

• ⍉∘g∘⍉une fonction qui additionne les triples verticaux - en gcours de transposition

• 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 somme des deux sommes modulo 2

• ⌈ le plus grand entre ça et ...

• 2∘∧ le LCM de 2 et la matrice d'origine - cela transforme les 1 en 2, tout en préservant les 0 et les 2

Perl 5 , 192 + 1 ( -n) = 193 octets

for$i(1..2*$_+1){push@a,[()x$_]}$a[$_][$_]=1;map{@b=();for$i(0..$#a){map$b[$i][$_]=$a[$i][$_]?2:$a[$i-1][$_]+($_&&$a[$i][$_-1])+$a[$i+1][$_]+$a[$i][$_+1]==1?1:0,0..$#a}@a=@b}1..$_;say@$_ for@a

Essayez-le en ligne!

Utilise 0 pour vide, 1 pour éveillé et 2 pour endormi.

Ruby , ₁₆₄ 153 octets

->n{(r=([e=' ']*(l=2*n+1)<<"
")*l)[n+n*l+=1]=a=?@
n.times{r=r.map.with_index{|c,i|c==a ??#:c==e ?r.values_at(i-1,i+1,i-l,i+l).one?{|v|v==a}?a:e:c}}
r*""}

Essayez-le en ligne!

Utilise "" pour vide, "@" pour éveillé et "#" pour dormir (comme dans l'exemple). Je pourrais économiser 6 octets en utilisant des chiffres à la place, je suppose, mais ça a l'air mieux comme ça.

Pip , 69 61 octets

60 octets de code, +1 pour le -ldrapeau.

YZG2*a+1y@a@a:1LaY{y@a@b?2oN(y@(a+_)@(b+B)MP[0o0v0])=1}MC#yy

Prend ncomme argument de ligne de commande. Utilisations 0pour vide, 1pour éveillé et 2pour dormir. (Pour obtenir un meilleur art ASCII comme dans les exemples du défi, remplacez la finale ypar " @#"@y.)

Essayez-le en ligne!

Explication

Installer:

YZG2*a+1y@a@a:1

                 Implicit: a is 1st cmdline arg; o is 1; v is -1
 ZG2*a+1         Square grid (i.e. nested list) of 0's, with side length 2*a+1
Y                Yank into y variable
        y@a@a:1  Set the element at coordinates (a,a) to 1

Boucle principale:

LaY{...}MC#y

La            Loop (a) times:
          #y  Len(y) (i.e. 2*a+1)
   {   }MC    Map this function to the coordinate pairs in a 2*a+1 by 2*a+1 grid
  Y           and yank the resulting nested list back into y

où le corps de la fonction est:

y@a@b?2oN(y@(a+_)@(b+B)MP[0o0v0])=1

                                     The function args, representing the coords of the
                                     current cell, are a and b
y@a@b?                               Is the cell at these coords 0 or nonzero?
      2                              If nonzero (1 or 2), make it 2
                                     Else, if zero, we need to check the neighbors
                         [0o0v0]     List of [0; 1; 0; -1; 0]
                       MP            Map this function to each adjacent pair of values--
                                     i.e. call it four times with args (0; 1), (1; 0),
                                     (0; -1), and (-1; 0)
          y                           Index into the grid using
           @(a+_)                     a + the 1st item in the pair as the row and
                 @(b+B)               b + the 2nd item in the pair as the column
                                     The result of MP is a list of the values of the cells
                                     in the Von Neumann neighborhood
       oN(                      )    Get the number of 1's in that list
                                 =1  and test if it equals 1
                                     If so, the new value of this cell is 1; if not, it's 0

Après la boucle, nous imprimons simplement y. L' -lindicateur signifie que la liste imbriquée est imprimée en concaténant le contenu de chaque ligne et en séparant les lignes avec des nouvelles lignes.

Java (OpenJDK 8) , 220 octets

n->{int s=n*2+3,i=0,x,y;char[][]a=new char[s][s],b;for(a[s/2][s--/2]=61;i++<n;a=b)for(b=new char[s+1][s+1],x=0;++x<s;)for(y=0;++y<s;)b[x][y]=a[x][y]>32?'0':(a[x][y-1]+a[x][y+1]+a[x-1][y]+a[x+1][y])%8==5?61:' ';return a;}

Essayez-le en ligne!

Remarque: le tableau renvoyé contient une bordure ou des '\0'caractères. Puisque l'avion est supposé être infini, seul le non-frontière est utilisé.

Mappage de caractères:

• Vide: (espace)
• Éveillé: =
• En train de dormir: 0

Enregistre

• 29 octets sauvés grâce à Jonathan S.
• 9 octets supplémentaires grâce à Jonathan S. en échangeant des caractères avec d'autres et en "faisant de la magie avec des nombres premiers et de l'arithmétique modulaire"

Python, 199 192 octets

Ce code fonctionne à la fois sur Python 2 et Python 3, mais il utilise la bibliothèque Numpy tierce partie pour effectuer la gestion des tableaux.

from numpy import*
def f(n):
 m=2*n+1;g=zeros((m+2,)*2,'i');g[n+1,n+1]=1
 while n:a=g[1:-1,1:-1];a[:]=(a<1)*(sum(g[r:r+m,c:c+m]&1for r,c in((0,1),(1,0),(1,2),(2,1)))==1)+(a>0)*2;n-=1
 return g

Vide = 0
éveillé = 1
Dormir = 2

print(f(6)) les sorties

[[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 2 0 0 0 0 0 0 0]
 [0 0 0 0 0 1 2 2 2 1 0 0 0 0 0]
 [0 0 0 0 0 0 1 2 1 0 0 0 0 0 0]
 [0 0 0 1 0 0 2 2 2 0 0 1 0 0 0]
 [0 0 0 2 1 2 0 2 0 2 1 2 0 0 0]
 [0 1 2 2 2 2 2 2 2 2 2 2 2 1 0]
 [0 0 0 2 1 2 0 2 0 2 1 2 0 0 0]
 [0 0 0 1 0 0 2 2 2 0 0 1 0 0 0]
 [0 0 0 0 0 0 1 2 1 0 0 0 0 0 0]
 [0 0 0 0 0 1 2 2 2 1 0 0 0 0 0]
 [0 0 0 0 0 0 0 2 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]

Si vous voulez une impression plus jolie, vous pouvez l'appeler comme suit:

n=6;print('\n'.join(''.join(' @#'[v]for v in u)for u in f(n)))

qui imprime en utilisant les mêmes caractères que ceux donnés dans la question.