Spacer pijaka kwantowego

69

Powszechnie wiadomo, że osoba na siatce pod wpływem alkoholu ma równe szanse pójścia we wszystkich dostępnych kierunkach. Jednak to rozsądne stwierdzenie nie dotyczy królestwa bardzo małych pijaków, których zachowanie jest tak, jakby podejmowali oni każdą dostępną ścieżkę naraz, a możliwe ścieżki, które podążają, mogą kolidować ze sobą. Twoim zadaniem jest wyświetlenie możliwych pozycji takiego kwantowego pijaka po wykonaniu nkroków.

Specyfikacja

Wspomniany pijak zajmuje kwadratową siatkę i może być uważany za 3-stanowy automat komórkowy wykorzystujący sąsiedztwo von Neumanna (w kształcie plus), które przestrzega tych prostych zasad:

  • Emptyidzie do, Awakejeśli przylega do dokładnie jednego Awake, a w przeciwnym razie idzie doEmpty
  • Awake idzie do Sleeping
  • Sleeping idzie do Sleeping

Początkowy stan planszy to pojedynczy Awakeotoczony nieskończonym polem Emptys.

Wyzwanie

Biorąc pod uwagę nieujemną liczbę całkowitą n, po nkroku utwórz reprezentację ASCII pijaka . Każdy stan powinien być reprezentowany przez inny charakter, a rozwiązania powinny określać, który znak oznacza, który stan. Jeśli używasz spacji do Empty, nie musisz dołączać ich na końcu linii.

To jest , więc wygrywa najkrótsza odpowiedź. Obowiązują standardowe luki , dozwolone są początkowe i końcowe spacje, dozwolone są dane wyjściowe z tablicy znaków / tablicy znaków 2d itp.

Przykłady

Te przykłady używają dla Empty, @dla Awakei #dla Sleeping.

n=0
@

n = 1
 @
@#@
 @

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

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

n=6

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

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

Ciekawa uwaga

Analizując sekwencję liczby zajętych komórek w OEIS, odkryłem, że pijak kwantowy jest izomorficzny w stosunku do znacznie lepiej zbadanej sekwencji wykałaczek . Jeśli potrafisz włączyć tę wiedzę do lepszego golfa, będę pod wrażeniem.

stellatedHexahedron
źródło
1
Czy możesz sprawdzić, czy Twoja sprawa n=10jest poprawna? Wypróbowałem kilka podejść i wszystkie otrzymały tę samą (niewłaściwą) odpowiedź, więc chcę się tylko upewnić. Trochę to wygląda, ale nie wiem.
HyperNeutrino,
4
@HyperNeutrino Mogę zrobić ci coś lepszego
stellatedHexahedron
1
Czy dozwolona jest jednowymiarowa tablica znaków?
Jonathan Frech
4
Świetne pierwsze wyzwanie, BTW!
Luis Mendo
1
@ PM2Ring ważny. numpy tablicy liczy się tak samo jak native tablicy Pythona w mojej książce
stellatedHexahedron

Odpowiedzi:

34

Wolfram Language (Mathematica) , 92 91 bajtów

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

Idealne wyzwanie do korzystania z wbudowanego Mathematica CellularAutomaton!

Wypróbuj online!

Pusty = 0, Przebudź = 1, Spanie = 2

Animacja pierwszych 256 iteracji (biały = pusty, szary = przebudzony, czarny = spanie):

wprowadź opis zdjęcia tutaj

Wyjaśnienie

CellularAutomaton[ ... ]

Uruchom CellularAutomatonze specyfikacjami ...

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

Zastosuj 3-kolorową regułę totalistyczną 7049487784884 z sąsiedztwem von Neumanna ...

{j={{1}},0}

Na planszy z pojedynczym 1 na środku, z tłem 0 ...

{j#}

Powtórz <input>czasy ( {j#}ocenia na {{{#}}}). Macierz automatycznie się rozwija, jeśli komórka poza ramką nie jest taka sama jak tło

7049487784884

Ta reguła pochodzi od liczby podstawowej 3 220221220221220221220221220, co oznacza „zmień wszystko 1lub 2na 2i zmień 0na 1i tylko wtedy, gdy 1wokół niej jest nieparzysta liczba s”.

Print@@@

Wydrukuj tablicę.

Pół-dowód „nieparzystych 1” jest równoważny z „dokładnie jednym 1”:

Rozważ tę siatkę pikseli 5x5. Biały to komórka 0lub 2(nie obudzone piksele), a szary to 1komórka.

wprowadź opis zdjęcia tutaj

Jeśli 1komórka została wygenerowana wokół trzech 0komórek, siatka musi wyglądać następująco: ma trzy 1s ułożone w kształcie litery U (lub wersji obróconej) w następujący sposób:

wprowadź opis zdjęcia tutaj

Ze względu na samopodobieństwo tego automatu komórkowego, każdy wzór pojawiający się w automacie komórkowym musi pojawić się na przekątnej (przez indukcję). Jednak ten wzór nie jest ukośnie symetryczny. tzn. nie może wystąpić na przekątnej i nie może pojawić się nigdzie w automacie komórkowym.

Przebudzenie / spanie są równoważne

Zauważ, że 0komórka nie może być otoczona dokładnie jedną lub trzema 2komórkami i komórkami spoczynkowymi 0, ponieważ oznaczałoby to, że kilka kroków wcześniej komórka miała sąsiada z jedną lub trzema 1komórkami - i musiała zmienić się w 1już (sprzeczność). W związku z tym, że jest w porządku, aby ignorować różnicy między 1i 2a stan "zmienić wszystko 1, aby 1i 0do 1wtedy i tylko wtedy, gdy ma nieparzystą liczbę niezerowych sąsiadów.

Powstały automat komórkowy jest rzeczywiście identyczny z oryginałem, jedyną różnicą jest to, że nie ma rozróżnienia między „przebudzonymi” i „uśpionymi” pijakami. Ten wzór jest opisany w OEIS A169707 .

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

Wypróbuj online!

Bezpośrednie porównanie pierwszych 16 iteracji:

wprowadź opis zdjęcia tutaj

Dodanie dwóch kolejnych iteracji daje wynik zgodny ze specyfikacją wyzwania (94 bajty):

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

Wypróbuj online!

JungHwan Min
źródło
11

Python 2 , 192 bajty

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]

Wypróbuj online!

-17 bajtów dzięki Mr. Xcoder
-9 bajtów przy użyciu formatu wyjściowego Jonathana
-11 bajtów dzięki Lynn
-3 bajtów dzięki ovs

HyperNeutrino
źródło
Przejście do pełnego programu, w którym można używać, execzapisuje 9 bajtów i …for k in 0,1,2,3for…zapisuje jeszcze jeden: Link
Lynn
1
W rzeczywistości n=[C+k for k in-1j,1j,-1,1for C in c]oszczędza jeszcze jeden bajt!
Lynn
1
... ok, muszę przyznać, że X+Y*1jinjest to coś, co tak naprawdę nie wydawało mi się możliwe: P
ETHprodukcje
1
@ETHproductions Nie spodziewałem się, że to też zadziała, ale pomyślałem: „hej, możesz usunąć spacje po numerze przed identyfikatorem / słowem kluczowym, więc jeśli pasuje tak zachłannie, czy zadziałałoby z liczbami zespolonymi?: D Python jest niesamowity: P
HyperNeutrino,
10

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("");}}

Nowe #definelinie po nieliniach są tutaj tylko do prezentacji, więc nie są liczone. Dołączyłem funkcję otoki, więc jest to -6 (313), jeśli funkcja nie jest liczona i zakładasz, że npochodzi ona z innego miejsca. q(10)wyjścia:

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

Używanie do pustych, "do spania i !do przebudzenia.

Działa to tak:

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

  • Zauważ, że po n pokoleniach plansza ma 2 n + 1 kwadrat.

  • Ze względu na symetrię planszy, musi to tylko symulować prawą dolną ćwiartkę, więc przydzielamy macierz kwadratową n + 1 z 1 rzędem i kolumną wypełnienia dla późniejszego wyszukiwania sąsiada (więc n + 2).

  • Przydział za pomocą callocpozwala nam jednocześnie pomnożyć szerokość przez wysokość i wyczyścić planszę 0(pusta).

  • Podczas wyszukiwania komórki według jej współrzędnych ( Ci D) używa bezwzględnej wartości wiersza i kolumny ( W) do automatycznego odzwierciedlenia współrzędnych.

  • Tablica jest przechowywana jako tablica par liczb całkowitych reprezentujących obecne i poprzednie generacje. Liczby, o których mowa, są char, abyśmy mogli uniknąć sizeof.

  • Generacja najczęściej sprawdzana (test sąsiada) to generacja poprzednia, więc jest umieszczona w indeksie 0 w parze, aby można było uzyskać do niej dostęp *.

  • Przy każdej generacji ( g) bieżąca generacja jest kopiowana z poprzedniej generacji za pomocą Bpętli, a następnie nowa generacja jest generowana ze starej.

  • Każda komórka jest reprezentowana za pomocą 0pustych, 1przebudzonych i 2do spania. Zliczanie sąsiadów było pierwotnie obliczeniem liczby bitów ustawionych w niskich 4 bitach komórki, gdy 4 sąsiadów przesunięto i OR skasowano razem jako flagi ( N), używając 16do spania. Ale z obserwacją, że nieparzysta liczba sąsiadów odpowiada dokładnie 1 sąsiadowi, możemy zapisać kilka postaci, używając tylko maski z 1.

  • Na końcu plansza jest drukowana w całości przez iterację w prawym dolnym kwadrancie przy użyciu tej samej sztuczki współrzędnych wartości bezwzględnej, bez dopełniania, aby nie drukować zewnętrznego dopełniania na planszy. Z tego powodu Bpętla zawiera otwierający nawias klamrowy, ponieważ mamy dodatkową instrukcję nowego wiersza w zewnętrznej pętli.

  • Kody ASCII dogodnie mapują 0 + 32 (puste) na spację, 2 + 32 (spanie) na "i 1 + 32 (przebudzenie) na !.

Podsumowując, myślę, że jest to zaskakująco czytelny golf ze względu na ładną strukturę problemu.

Jon Purdy
źródło
Łał. Malutka rzecz, ale myślę, że można zaoszczędzić kilka bajtów więcej zastępując przesunięcia z mnożenia i putchar(10)zeputs("")
undercat
1
@undercat: Dzięki! Dodano do odpowiedzi. Czasami skupiam się na ograniczeniu niektórych rzeczy tak bardzo, że brakuje mi innych zwycięstw, które są oczywiste, gdy tylko ktoś je zauważy.
Jon Purdy,
343 bajty .
Jonathan Frech
@JathanathanFrech: Dzięki, dodano. Zapomniałem, że liczenie sąsiadów może używać NAND.
Jon Purdy,
@JathanathanFrech: Przepraszam, chyba nie było to jasne. &~Nie jest to NAND, miałem na myśli, że czasami myśleć !(a &~ b)w kategoriach a NAND (NOT b), choć w tym przypadku logiczny !nie jest taka sama jak bitowe ~ponieważ jesteśmy powołując się na 0lub 1wyniku !.
Jon Purdy,
6

MATL , 39 bajtów

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

Wyświetla się

  • Emptyjako (spacja)
  • Awake tak jak #
  • Sleepingjak !.

Wypróbuj online! Możesz także obserwować, jak wzorzec rośnie w sztuce ASCII lub graficznie (zmodyfikowany kod).

Wyjaśnienie

Kod wykorzystuje liczb zespolonych 0, 1, jaby reprezentować trzy stany: pusta, budzenie, spanie odpowiednio.

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
Luis Mendo
źródło
5

Befunge, 384 304 bajty

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

Wypróbuj online!

Problemem przy próbie zaimplementowania tego rodzaju funkcji w Befunge jest ograniczony rozmiar pamięci (2000 bajtów zarówno dla danych, jak i kodu). Musiałem więc użyć algorytmu, który oblicza poprawny znak dla dowolnej współrzędnej bez odniesienia do poprzednich obliczeń. Osiąga to poprzez rekurencyjne spoglądanie w przeszłość na wszystkie możliwe ścieżki, którymi pijak mógł podążać, aby osiągnąć ten punkt.

Niestety nie jest to szczególnie wydajne rozwiązanie. Działa, ale jest niesamowicie wolny i staje się wykładniczo wolniejszy wraz ze wzrostem wartości n . Więc chociaż może potencjalnie działać dla dowolnego n do około 127 (7-bitowy limit komórek pamięci Befunge), w praktyce nieuchronnie stracisz zainteresowanie czekaniem na wynik. W TIO osiągnie 60 sekundowy limit czasu na czymkolwiek większym niż około 6 (co najwyżej). Kompilator poradzi sobie znacznie lepiej, ale nawet wtedy prawdopodobnie nie chciałbyś iść dużo wyżej niż 10.

Mimo to pomyślałem, że warto go przesłać, ponieważ jest to całkiem niezła demonstracja rekurencyjnej „funkcji” w Befunge.

James Holderness
źródło
4

Python 2 , 214 bajtów

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

Wypróbuj online!

Wyjaśnienie

Zastosowania 0dla empty, 1dla sleepingi 2dla awake. Drukuje dwuwymiarową listę znaków (ciągi o jednej długości).
Definiuje funkcję, która przyjmuje nieujemną liczbę całkowitą n. Sukcesywnie przesuwa automat komórkowy do osiągnięcia pożądanego stanu. Na koniec stosowana jest konwersja między wewnętrznymi wartościami całkowitymi a rzeczywistymi znakami.

Jonathan Frech
źródło
4

Lua , 251 242 239 238 bajtów

-8 bajtów poprzez uproszczenie inicjalizatora tablicy kosztem dodatkowych wiodących białych znaków.
-1 bajt, zmieniając c=i==2+...and print(s)na c=i~=2+...or print(s).
-3 bajty, budując najpierw kompletny ciąg i drukując raz na końcu.
-1 bajt dzięki Jonathan Frech przepisując or(g(...)==1 andjako 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)

Wypróbuj online!

Empty = Space
Awake = 1
Sleeping =0

Pobiera dane z wiersza poleceń i drukuje na standardowe wyjście.

Reprezentując stany jak false/ nil, 1i 0wewnętrznie, wykrywanie „pusty” nie potrzeba żadnego kodu i „dokładnie jeden przebudzony” Kontrola może odbywać się tylko z dodatkiem.

Jonathan S.
źródło
Myślę, że or(g(...)==1 andmoże być or(1==g(...)and.
Jonathan Frech
4

Galaretka , 39 29 bajtów

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

Wypróbuj online!

Używa 0, 1a 2do pustego czuwania i spania. Stopka w linku konwertuje to na , @i #.

  • -1 bajt przy użyciu ṬŒḄzamiast ḤḶ=¹.
  • -2 bajty przy użyciu -zamiast 1N. Również czyni ¤niepotrzebnym.
  • -1 bajt przy użyciu Szamiast +/.
  • -6 bajtów przy użyciu Ḃ+Ḃ+zamiast %3=1+=1Ḥ$+. Teraz używa 2do spania zamiast 3.

Wyjaśnienie nadchodzi ...

dylnan
źródło
4

APL (Dyalog Classic) , 38 bajtów

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

Wypróbuj online!

oparty na rozwiązaniu Erika the Outgolfer

⍪1 to matryca 1x1 zawierająca 1

ewaluowane dane wejściowe

( )⍣⎕ zastosuj to wiele razy

  • (⌽0,⍉)⍣4surround 0s, czyli 4 razy do: transpose ( ), dodaj 0 po lewej stronie ( 0,), odwróć w poziomie ( )

  • g←3+/0,,∘0 nazywamy to funkcją sumującą potrójne poziome g

  • ⍉∘g∘⍉funkcja sumująca potrójne pionowe - gpodlegająca transpozycji

  • 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 suma dwóch sum modulo 2

  • tym większy między tym a ...

  • 2∘∧ LCM 2 i oryginalnej matrycy - zamienia 1s w 2s, zachowując 0s i 2s

ngn
źródło
3

Perl 5 , 192 + 1 ( -n) = 193 bajtów

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

Wypróbuj online!

Używa 0 dla pustych, 1 dla obudzonych i 2 dla uśpienia.

Xcali
źródło
3

Rubin , 164 153 bajty

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

Wypróbuj online!

Używa „” dla pustego, „@” dla wybudzania i „#” dla uśpienia (jak w przykładzie). Przypuszczam, że mógłbym zaoszczędzić 6 bajtów, używając liczb, ale wygląda to lepiej.

iamnotmaynard
źródło
2

Pip , 69 61 bajtów

60 bajtów kodu, +1 dla -lflagi.

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

Przyjmuje njako argument wiersza polecenia. Używa 0pustego, 1przebudzonego i 2do spania. (Aby uzyskać ładniejszy ASCII-art jak w przykładach Wyzwaniem jest, wymień końcowy yz " @#"@y).

Wypróbuj online!

Wyjaśnienie

Ustawiać:

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

Główna pętla:

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

gdzie treść funkcji to:

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

Po zakończeniu pętli po prostu drukujemy automatycznie y. -lFlaga oznacza, że lista jest zagnieżdżona drukowane przez złączenie zawartość każdego rzędu i oddzielenia rzędów ze znakami nowej linii.

DLosc
źródło
2

Java (OpenJDK 8) , 220 bajtów

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

Wypróbuj online!

Uwaga: zwrócona tablica zawiera ramkę lub '\0'znaki. Ponieważ samolot ma być nieskończony, używana jest tylko granica.

Mapowanie postaci:

  • Pusty: (spacja)
  • Obudzić: =
  • Spanie: 0

Oszczędza

  • 29 bajtów zaoszczędzonych dzięki Jonathanowi S.
  • 9 kolejnych bajtów dzięki Jonathanowi S. poprzez zamianę postaci na innych i „magię za pomocą liczb pierwszych i arytmetyki modułowej”
Olivier Grégoire
źródło
1
229 bajtów.
Jonathan S.,
Dzięki @JonathanS. Naprawdę ciężko szukałem ulepszenia mojej @kontroli, a ty znalazłeś klucz! Miły. char-Cast był całkowity nadzór ze mną.
Olivier Grégoire,
1
220 bajtów , wykonując magię za pomocą liczb pierwszych i arytmetyki modułowej.
Jonathan S.,
To bardzo miłe myślenie!
Olivier Grégoire,
1
Dzięki! Właśnie znalazłem ładniejszą wersję, która również ma 220 bajtów, inny moduł.
Jonathan S.,
2

Python, 199 192 bajtów

Ten kod działa zarówno w Pythonie 2, jak i Pythonie 3, ale używa popularnej biblioteki Numpy innej firmy do obsługi tablicy.

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

Pusty = 0
Przebudzony = 1
Śpiący = 2

print(f(6)) wyjścia

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

Jeśli chcesz ładniejszego drukowania, możesz to nazwać w ten sposób:

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

który drukuje przy użyciu tych samych znaków, jakie podano w pytaniu.

PM 2 Ring
źródło
Nie wiem, czy dozwolone jest wypisywanie macierzy liczb całkowitych, ponieważ [e]ach state should be represented by a different character(interpretuję characterjako rzeczywisty znak ASCII, a nie liczbę całkowitą).
Jonathan Frech,
@JathanathanFrech Uczciwe połączenie. Zapytam OP.
PM 2,