Es ist allgemein bekannt, dass eine Person, die unter dem Einfluss von Alkohol am Netz steht, die gleiche Chance hat, in eine beliebige Richtung zu gehen. Diese Erklärung des gesunden Menschenverstands gilt jedoch nicht für sehr kleine Betrunkene, deren Verhalten so ist, als würden sie jeden verfügbaren Weg auf einmal gehen, und die möglichen Wege, die sie einschlagen, können sich gegenseitig stören. Ihre Aufgabe ist es, die möglichen Positionen eines solchen Quantentrinkers nach nSchritten anzuzeigen .

Spezifikation

Der betreffende Betrunkene nimmt ein quadratisches Gitter ein und kann als ein 3-Zustands-Zellularautomat betrachtet werden, der eine von Neumann-Nachbarschaft (plus-förmig) verwendet, die diesen einfachen Regeln folgt:

• Emptygeht zu, Awakewenn es genau an eins angrenzt Awake, und geht ansonsten zuEmpty
• Awake geht zu Sleeping
• Sleeping geht zu Sleeping

Der Ausgangszustand der Karte ist eine einzelne, Awakedie von einem unendlichen Feld von Emptys umgeben ist.

Herausforderung

nErstellen Sie bei einer nichtnegativen Ganzzahl nach nSchritten eine ASCII-Darstellung des Betrunkenen . Jeder Zustand sollte durch ein anderes Zeichen dargestellt werden, und Lösungen sollten angeben, welches Zeichen welchen Zustand bedeutet. Wenn Sie Leerzeichen verwenden Empty, müssen Sie diese nicht am Ende einer Zeile einfügen.

Das ist Code-Golf , also gewinnt die kürzeste Antwort. Es gelten Standardlücken , führende und nachfolgende Leerzeichen sind zulässig, die Ausgabe von String-Arrays / 2D-Char-Arrays ist zulässig usw.

Beispiele

Diese Beispiele verwenden für Empty, @für Awakeund #für Sleeping.

n=0
@

n = 1
 @
@#@
 @

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

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

n=6

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

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

Interessante Anmerkung

Durch Nachschlagen der Sequenz der Anzahl der besetzten Zellen im OEIS stellte ich fest, dass der Quantentrinker isomorph zu der viel besser untersuchten Zahnstochersequenz ist . Wenn Sie dieses Wissen in ein besseres Golfspiel einfließen lassen, bin ich beeindruckt.

Wolfram Language (Mathematica) , 92 91 Bytes

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

Eine perfekte Herausforderung, um Mathematics eingebaute Funktionen zu nutzen CellularAutomaton!

Probieren Sie es online!

Leer = 0, Wach = 1, Schlafen = 2

Animation der ersten 256 Iterationen (weiß = leer, grau = wach, schwarz = schlafend):

Erläuterung

CellularAutomaton[ ... ]

Führen Sie CellularAutomatonmit Spezifikationen ...

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

Wenden Sie die totalistische 3-Farben-Regel 7049487784884 bei Von Neumann an.

{j={{1}},0}

Auf einem Brett mit einer 1 in der Mitte, mit einem Hintergrund von 0s ...

{j#}

Wiederholungszeiten <input>( {j#}ergibt {{{#}}}). Das Array wird automatisch erweitert, wenn eine Zelle außerhalb des Rahmens nicht mit dem Hintergrund identisch ist

7049487784884

Diese Regel kommt von der Basis-3 - Nummer 220221220221220221220221220, das bedeutet „alles ändern 1oder 2zu 2, und ändern Sie 0zu , 1wenn und nur wenn es eine ungerade Anzahl von 1s um ihn herum.“

Print@@@

Drucken Sie das Array.

Semi-Proof von "'ungerade 1s' ist gleichbedeutend mit 'genau eins 1'":

Betrachten Sie dieses 5x5-Pixelraster. Weiß ist eine 0oder eine 2Zelle (nicht wache Pixel) und Grau ist eine 1Zelle.

Wenn eine 1Zelle um drei 0Zellen erstellt wurde, muss das Raster folgendermaßen aussehen: Es hat drei 1s, die in einer U-Form (oder einer gedrehten Version) wie folgt angeordnet sind:

Aufgrund der Selbstähnlichkeit dieses zellularen Automaten muss jedes Muster, das im zellularen Automaten erscheint, auf der Diagonale erscheinen (durch Induktion). Dieses Muster ist jedoch nicht diagonal symmetrisch. dh es kann nicht auf der Diagonale auftreten und kann nirgends auf dem zellularen Automaten erscheinen.

Wach / Schlaf sind gleichwertig

Beachten Sie, dass eine 0Zelle nicht von genau einer oder drei 2Zellen und 0Ruhezellen umgeben sein kann, da dies bedeuten würde, dass die Zelle bei einigen vorherigen Schritten einen Nachbarn von einer oder drei 1Zellen hatte - und sich in eine 1bereits vorhandene Zelle verwandelt haben muss (Widerspruch). Daher ist es in Ordnung, die Unterscheidung zwischen 1und zu ignorieren 2und anzugeben, dass alle 1in 1und a 0in a geändert werden sollen , 1wenn eine ungerade Anzahl von Nachbarn ungleich Null vorhanden ist.

Der resultierende zellulare Automat ist in der Tat identisch mit dem Original, der einzige Unterschied besteht darin, dass es keinen Unterschied zwischen "wachen" und "schlafenden" Betrunkenen gibt. Dieses Muster ist in OEIS A169707 beschrieben .

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

Probieren Sie es online!

Nebeneinander Vergleich der ersten 16 Iterationen:

Das Hinzufügen von zwei aufeinanderfolgenden Iterationen ergibt ein Ergebnis, das den Herausforderungsspezifikationen (94 Bytes) folgt:

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

Probieren Sie es online!

Python 2 , 192 Bytes

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]

Probieren Sie es online!

-17 Bytes dank Mr. Xcoder
-9 Bytes mit Jonathans Ausgabeformat
-11 Bytes dank Lynn
-3 Bytes dank 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("");}}

Zeilenumbrüche nach Nichtzeilen #definedienen nur der Darstellung, werden also nicht gezählt. Ich habe eine Wrapper-Funktion eingefügt, also −6 (313), wenn die Funktion nicht gezählt wird und Sie davon ausgehen, dass sie nvon woanders stammt. q(10)Ausgänge:

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

Verwenden Sie für leer, "zum Schlafen und !für wach.

Das funktioniert so:

• A(i,b,e)ist "∀i∀ [b, e).", B(b,e)ist "∀r∀ [b, e) .∀c∀ [b, e)."

• Beachten Sie, dass die Karte nach n Generationen 2 n + 1 Quadrat hat.

• Aufgrund der Symmetrie der Karte muss hier nur der untere rechte Quadrant simuliert werden. Daher weisen wir eine n + 1-Quadratmatrix mit 1 Zeile und Spalte Abstand für die spätere Nachbarn-Suche zu (also n + 2).

• Wenn Sie mit calloczuweisen, multiplizieren Sie gleichzeitig die Breite mit der Höhe und löschen Sie das Brett auf 0(leer).

• Wenn eine Zelle anhand ihrer Koordinaten ( Cund D) Wnachgeschlagen wird, werden die Koordinaten automatisch anhand des Absolutwerts von Zeile und Spalte ( ) gespiegelt.

• Die Karte wird als Array von Paaren von Ganzzahlen gespeichert, die die aktuelle und vorherige Generation darstellen. Die fraglichen ganzen Zahlen sind charso, dass wir sie vermeiden können sizeof.

• Die Generation, nach der am häufigsten gesucht wurde (durch den Nachbarn-Test), ist die frühere Generation, daher wird sie im Paar auf Index 0 gesetzt, damit auf sie zugegriffen werden kann *.

• Bei jeder Generation ( g) wird die aktuelle Generation mit einer BSchleife über die vorherige Generation kopiert , dann wird die neue Generation aus der alten generiert.

• Jede Zelle wird mit 0leer, 1wach und 2schlafend dargestellt. Das Zählen der Nachbarn war ursprünglich eine Berechnung der Anzahl der Bits, die in den unteren 4 Bits der Zelle gesetzt wurden, wenn die 4 Nachbarn als Flags ( N) verschoben und ODER-verknüpft wurden und 16zum Schlafen verwendet wurden. Aber mit der Beobachtung, dass eine ungerade Anzahl von Nachbarn genau einem Nachbarn entspricht, können wir mehrere Zeichen speichern, indem wir nur eine Maske mit 1 verwenden.

• Am Ende wird die Platine vollständig gedruckt, indem über den unteren rechten Quadranten mit demselben Absolutwertkoordinatentrick minus Auffüllung iteriert wird, sodass die äußere Auffüllung auf der Platine nicht gedruckt wird. Aus diesem Grund enthält die BSchleife auch eine öffnende geschweifte Klammer, da die äußere Schleife die zusätzliche Anweisung newline enthält.

• Die ASCII-Codes ordnen 0 + 32 (leer) einem Leerzeichen, 2 + 32 (schlafen) einem Leerzeichen "und 1 + 32 (wach) einem Leerzeichen zu !.

Alles in allem denke ich, dass dies ein überraschend lesbarer Golf ist, wegen der schönen Struktur des Problems.

MATL , 39 Bytes

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

Dies wird angezeigt

• Emptyals (Leerzeichen)
• Awake wie #
• Sleepingals !.

Probieren Sie es online! Sie können das Muster auchin ASCII- Grafik oder grafisch (geänderter Code) vergrößern .

Erläuterung

Der Code verwendet komplexe Zahlen 0, 1, jdie drei Zustände darstellen: leer, wake, schlafen auf.

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 Bytes

&: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*+^

Probieren Sie es online!

Das Problem beim Versuch, solche Dinge in Befunge zu implementieren, ist die begrenzte Speichergröße (2000 Byte für Daten und Code). Daher musste ich einen Algorithmus verwenden, der das richtige Zeichen für eine bestimmte Koordinate ohne Bezugnahme auf vorherige Berechnungen berechnet. Dies wird erreicht, indem rekursiv über alle möglichen Wege in die Vergangenheit geblickt wird, denen der Betrunkene bis zu diesem Punkt möglicherweise gefolgt ist.

Leider ist dies keine besonders effiziente Lösung. Es funktioniert, ist aber unglaublich langsam und wird umso langsamer, je größer der Wert von n ist . Während es also möglicherweise für n bis zu 127 (Befunges 7-Bit-Speicherzellenlimit) funktionieren könnte, verlieren Sie in der Praxis unweigerlich das Interesse, auf das Ergebnis zu warten. Bei TIO wird das 60-Sekunden-Timeout bei etwas höherem als etwa 6 (bestenfalls) erreicht. Ein Compiler wird viel besser, aber selbst dann würden Sie wahrscheinlich nicht viel höher als 10 gehen wollen.

Trotzdem dachte ich, dass es sich lohnt, es einzureichen, weil es eigentlich eine nette Demonstration einer rekursiven "Funktion" in Befunge ist.

Python 2 , 214 Bytes

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)]

Probieren Sie es online!

Erläuterung

Verwendet 0für empty, 1für sleepingund 2für awake. Druckt eine Liste mit zweidimensionalen Zeichen (Strings mit einer Länge) aus.
Definiert eine Funktion, die eine nicht negative Ganzzahl akzeptiert n. Schiebt den Zellularautomaten sukzessive vorwärts, bis der gewünschte Zustand erreicht ist. Schließlich wird eine Konvertierung zwischen den internen Ganzzahlwerten und den tatsächlichen Zeichen durchgeführt.

Lua , 251 242 239 238 Bytes

-8 Bytes durch Vereinfachung des Array-Initialisierers auf Kosten eines zusätzlichen führenden Leerzeichens.
-1 Byte durch Ändern c=i==2+...and print(s)in c=i~=2+...or print(s).
-3 Bytes, indem Sie zuerst eine vollständige Zeichenfolge erstellen und am Ende einmal drucken.
-1 Byte Dank an Jonathan Frech durch Umschreiben or(g(...)==1 andals 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)

Probieren Sie es online!

Leer = Raum
Wach = 1
Schlafen =0

Nimmt Eingaben von der Befehlszeile und druckt auf stdout.

Durch die Darstellung der Zustände wie false/ nil, 1und 0intern, Erkennung „leer“ braucht keinen Code und die „genau eine wach“ Überprüfung kann mit nur einer Zugabe erfolgen.

APL (Dyalog) , 38 Bytes

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

Probieren Sie es online!

-4 Dank an Adám .
-8 danke an ngn .

Jelly , 39 29 Bytes

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

Probieren Sie es online!

Verwendet 0, 1und 2zum leeren wach und schlafen. Die Fußzeile in den Link wandelt diese in , @und #.

• -1 Byte mit ṬŒḄanstelle von ḤḶ=¹.
• -2 Bytes mit -anstelle von 1N. Macht auch ¤unnötig.
• -1 Byte mit Sanstelle von +/.
• -6 Bytes mit Ḃ+Ḃ+anstelle von %3=1+=1Ḥ$+. Jetzt 2zum Schlafen statt 3.

Erklärung kommt ...

APL (Dyalog Classic) , 38 Byte

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

Probieren Sie es online!

basierend auf Erik the Outgolfer's Lösung

⍪1 ist eine 1x1 Matrix mit 1

⎕ ausgewertete Eingabe

( )⍣⎕ so oft anwenden

• (⌽0,⍉)⍣4Surround mit 0s, also 4 mal tun: transponieren ( ⍉), 0s links addieren ( 0,), horizontal umkehren ( ⌽)

• g←3+/0,,∘0 Eine Funktion, die horizontale Tripel summiert, nennt man das g

• ⍉∘g∘⍉Eine Funktion, die vertikale Tripel summiert - das wird gumgesetzt

• 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 Summe der beiden Summen modulo 2

• ⌈ je größer zwischen dem und ...

• 2∘∧ das LCM von 2 und die ursprüngliche Matrix - dies macht 1s zu 2s, während 0s und 2s erhalten bleiben

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

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

Probieren Sie es online!

Verwendet 0 für leer, 1 für wach und 2 für schlafend.

Ruby , ₁₆₄ 153 Bytes

->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*""}

Probieren Sie es online!

Verwendet "" für Leer, "@" für Wach und "#" für Schlaf (wie im Beispiel). Ich könnte 6 Bytes einsparen, indem ich stattdessen Zahlen verwende, aber es sieht besser so aus.

Pip , 69 61 Bytes

60 Byte Code, +1 für -lFlag.

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

Dient nals Befehlszeilenargument. Verwendet 0für leer, 1für wach und 2zum Schlafen. (Um eine schönere ASCII-Grafik als in den Beispielen der Challenge zu erhalten, ersetzen Sie das Finale ydurch " @#"@y.)

Probieren Sie es online!

Erläuterung

Konfiguration:

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

Hauptschleife:

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

wo der Funktionskörper ist:

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

Nach der Schleife drucken wir einfach automatisch y. Das -lFlag bedeutet, dass die verschachtelte Liste gedruckt wird, indem der Inhalt jeder Zeile verkettet und die Zeilen durch Zeilenumbrüche getrennt werden.

Java (OpenJDK 8) , 220 Byte

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;}

Probieren Sie es online!

Hinweis: Das zurückgegebene Array enthält einen Rahmen oder '\0'Zeichen. Da das Flugzeug unendlich sein soll, wird nur grenzüberschreitend gearbeitet.

Zeichenzuordnung:

• Leer: (Leerzeichen)
• Erwachen: =
• Schlafen: 0

Speichert

• 29 Bytes gespart dank Jonathan S.
• 9 weitere Bytes dank Jonathan S. durch den Austausch von Zeichen mit anderen und "Zaubern mit Primzahlen und modularer Arithmetik"

Python, 199 192 Bytes

Dieser Code läuft sowohl auf Python 2 als auch auf Python 3, verwendet jedoch die beliebte Numpy-Bibliothek von Drittanbietern, um die Array-Verarbeitung durchzuführen.

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

Leer = 0
Wach = 1
Schlafen = 2

print(f(6)) Ausgänge

[[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]]

Wenn Sie schöner drucken möchten, können Sie dies folgendermaßen bezeichnen:

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

welche druckt mit den gleichen Zeichen wie in der Frage angegeben.