È noto che una persona su una griglia sotto l'influenza dell'alcol ha le stesse possibilità di andare in qualsiasi direzione disponibile. Tuttavia, questa affermazione di buon senso non vale nel regno di ubriaconi molto piccoli , il cui comportamento è molto simile a quello che prendono tutti i percorsi disponibili contemporaneamente, e i possibili percorsi che intraprendono possono interferire tra loro. Il tuo compito è quello di visualizzare le possibili posizioni di un tale ubriacone quantico dopo i npassaggi.

specificazione

L'ubriacone in questione occupa una griglia quadrata e può essere considerato un automa cellulare a 3 stati utilizzando un quartiere di Von Neumann (a forma di più) che segue queste semplici regole:

• Emptyva Awakese è adiacente esattamente a uno Awake, e altrimenti va aEmpty
• Awake va a Sleeping
• Sleeping va a Sleeping

Lo stato iniziale della scheda è un singolo Awakecircondato da un campo infinito di Emptys.

Sfida

Dato un numero intero non negativo n, creare una rappresentazione ASCII dell'ubriacone dopo i npassaggi. Ogni stato dovrebbe essere rappresentato da un carattere diverso e le soluzioni dovrebbero indicare quale carattere significa quale stato. Se usi gli spazi per Empty, non è necessario includerne una sequenza alla fine di una riga.

Questo è code-golf , quindi vince la risposta più breve. Si applicano scappatoie standard , è consentito lo spazio bianco iniziale e finale, è consentito l'output di array di stringhe / array di caratteri 2D, ecc.

Esempi

Questi esempi usano for Empty, @for Awakee #for Sleeping.

n=0
@

n = 1
 @
@#@
 @

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

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

n=6

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

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

Nota interessante

Osservando la sequenza del numero di cellule occupate nell'OEIS, ho scoperto che l'ubriacone quantico è isomorfo rispetto alla sequenza di stuzzicadenti molto meglio studiata . Se riesci a incorporare queste conoscenze in un golf migliore, rimarrò adeguatamente colpito.

Wolfram Language (Mathematica) , 92 91 byte

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

Una sfida perfetta per usare il software integrato di Mathematica CellularAutomaton!

Provalo online!

Vuoto = 0, Sveglia = 1, Dormire = 2

Animazione delle prime 256 iterazioni (bianco = vuoto, grigio = sveglio, nero = dormiente):

Spiegazione

CellularAutomaton[ ... ]

Esegui CellularAutomatoncon le specifiche ...

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

Applica la regola totalistica a 3 colori 7049487784884, con il quartiere Von Neumann ...

{j={{1}},0}

Su una tavola con un solo 1 nel mezzo, con uno sfondo di 0s ...

{j#}

Ripeti i <input>tempi ( {j#}valuta per {{{#}}}). L'array si espande automaticamente se una cella al di fuori del bordo non è uguale allo sfondo

7049487784884

Questa regola deriva dal numero base-3 220221220221220221220221220, che significa "cambia tutto 1o 2in 2, e cambia 0in 1se e solo se c'è un numero dispari di 1s attorno ad esso."

Print@@@

Stampa l'array.

La semi-prova di "'dispari 1' 'equivale a' esattamente uno 1'":

Considera questa griglia di pixel 5x5. Il bianco è una 0o una 2cella (pixel non attivi) e il grigio è una 1cella.

Se una 1cella è stata generata intorno a tre 0celle, la griglia deve apparire così: ha tre 1s disposte a forma di U (o versione ruotata) come segue:

A causa dell'auto-somiglianza di questo automa cellulare, qualsiasi modello che appare nell'automa cellulare deve apparire sulla diagonale (per induzione). Tuttavia, questo modello non è diagonalmente simmetrico. cioè non può verificarsi sulla diagonale e non può apparire in nessun punto dell'automa cellulare.

Sveglia / Dormire sono equivalenti

Si noti che una 0cella non può essere circondata esattamente da una o tre 2celle e celle di riposo 0, dal momento che ciò implicherebbe che alcuni passaggi precedenti, la cella aveva un vicino di una o tre 1celle - e deve essersi 1già trasformata in una (contraddizione). Pertanto, va bene ignorare la distinzione tra 1e 2e stato "cambia tutto 1in 1, e a 0in un 1se e solo se ha un numero dispari di vicini diversi da zero".

L'automa cellulare risultante è effettivamente identico all'originale, con l'unica differenza che non c'è distinzione tra ubriaconi "svegli" e "addormentati". Questo modello è descritto in OEIS A169707 .

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

Provalo online!

Confronto fianco a fianco delle prime 16 iterazioni:

L'aggiunta di due iterazioni consecutive produce un risultato che segue le specifiche della sfida (94 byte):

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

Provalo online!

Python 2 , 192 byte

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]

Provalo online!

-17 byte grazie a Mr. Xcoder
-9 byte usando il formato di output di Jonathan
-11 byte grazie a Lynn
-3 byte grazie a 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("");}}

Le nuove #definerighe dopo le non righe sono solo per la presentazione qui, quindi non vengono conteggiate. Ho incluso una funzione wrapper, quindi è −6 (313) se la funzione non viene conteggiata e si presume che nprovenga da altrove. q(10)uscite:

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

Usando per vuoto, "per dormire e !per sveglio.

Funziona così:

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

• Osservare che dopo n generazioni, la scacchiera è 2 n + 1 quadrato.

• A causa della simmetria della tavola, questo deve solo simulare il quadrante in basso a destra, quindi assegniamo una matrice quadrata n + 1 con 1 riga e colonna di riempimento per la successiva ricerca del vicino (quindi n + 2).

• L'allocazione con callocconsente di moltiplicare contemporaneamente la larghezza per l'altezza e di cancellare la scheda su 0(vuota).

• Quando si cerca una cella in base alle sue coordinate ( Ce D), utilizza il valore assoluto di riga e colonna ( W) per rispecchiare automaticamente le coordinate.

• La scheda è memorizzata come una matrice di coppie di numeri interi che rappresentano le generazioni attuali e precedenti. I numeri interi in questione sono charcosì che possiamo evitare sizeof.

• La generazione cercata più frequentemente (dal test del vicino) è la generazione passata, quindi è posizionata all'indice 0 nella coppia in modo che sia possibile accedervi *.

• Ad ogni generazione ( g), la generazione corrente viene copiata sulla generazione precedente usando un Bciclo, quindi la nuova generazione viene generata dalla vecchia.

• Ogni cella è rappresentata usando 0per vuoto, 1per sveglio e 2per dormire. Il conteggio dei vicini era originariamente un calcolo del numero di bit impostati nei 4 bit bassi della cella quando i 4 vicini venivano spostati e messi insieme come flag ( N), usando 16per dormire. Ma con l'osservazione che un numero dispari di vicini equivale esattamente a 1 vicino, possiamo salvare diversi personaggi semplicemente usando una maschera con 1.

• Alla fine, la scheda viene stampata per intero ripetendo il quadrante in basso a destra usando lo stesso trucco di coordinate di valore assoluto, meno imbottitura in modo da non stampare l'imbottitura esterna sulla scheda. Questo è anche il motivo per cui il Bloop include una parentesi graffa aperta, perché abbiamo l'istruzione newline extra nel loop esterno.

• I codici ASCII associano comodamente 0 + 32 (vuoto) a uno spazio, 2 + 32 (inattivo) a "e 1 + 32 (attivo) a !.

Tutto sommato penso che questo sia un golf sorprendentemente leggibile a causa della bella struttura del problema.

MATL , 39 byte

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

Questo visualizza

• Emptycome (spazio)
• Awake come #
• Sleepingcome !.

Provalo online! Puoi anche vedere crescere lo schemanell'arte ASCII o graficamente (codice modificato).

Spiegazione

Il codice utilizza numeri complessi 0, 1, jper rappresentare i tre stati: vuoto, scia, dormendo rispettivamente.

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 byte

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

Provalo online!

Il problema con il tentativo di implementare questo tipo di cose in Befunge è la dimensione della memoria limitata (2000 byte per dati e codice). Quindi ho dovuto usare un algoritmo che calcola il carattere corretto per ogni data coordinata senza riferimento ai calcoli precedenti. Raggiunge questo guardando ricorsivamente indietro nel tempo attraverso tutti i possibili percorsi che l'ubriacone avrebbe potuto seguire per raggiungere quel punto.

Purtroppo questa non è una soluzione particolarmente efficiente. Funziona, ma è incredibilmente lento e diventa esponenzialmente più lento quanto maggiore è il valore di n . Quindi, mentre potrebbe potenzialmente funzionare per qualsiasi n fino a circa 127 (limite della cella di memoria a 7 bit di Befunge), in pratica perderai inevitabilmente interesse in attesa del risultato. Su TIO, colpirà il timeout di 60 secondi su qualsiasi valore superiore a circa 6 (nella migliore delle ipotesi). Un compilatore farà molto meglio, ma anche allora probabilmente non vorresti andare molto più in alto di 10.

Tuttavia, ho pensato che valesse la pena presentarlo perché in realtà è una bella dimostrazione di una "funzione" ricorsiva in Befunge.

Python 2 , 214 byte

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

Provalo online!

Spiegazione

Utilizza 0per empty, 1per sleepinge 2per awake. Stampa un elenco di caratteri bidimensionali (stringhe di una lunghezza).
Definisce una funzione che accetta un numero intero non negativo n. Fa avanzare successivamente l'automa cellulare fino a raggiungere lo stato desiderato. Infine, viene applicata una conversione tra i valori interi interni e i caratteri effettivi.

Lua , 251 242 239 238 byte

-8 byte semplificando l'inizializzatore di array al costo di alcuni spazi bianchi iniziali aggiuntivi.
-1 byte cambiando c=i==2+...and print(s)in c=i~=2+...or print(s).
-3 byte creando prima una stringa completa e stampandola una volta alla fine.
-1 byte grazie a Jonathan Frech riscrivendo or(g(...)==1 andcome 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)

Provalo online!

Vuoto = Spazio
Sveglio = 1
Dormire =0

Riceve input dalla riga di comando e stampa su stdout.

Rappresentando gli stati come false/ nil, 1e 0internamente, il rilevamento di "vuoto" non richiede alcun codice e il controllo "esattamente uno sveglio" può essere eseguito con solo un'aggiunta.

APL (Dyalog) , 38 byte

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

Provalo online!

-4 grazie ad Adám .
-8 grazie a ngn .

Gelatina , 39 29 byte

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

Provalo online!

Usi 0, 1e 2per vuoto sveglio e dormire. Il piè di pagina nel collegamento lo converte in , @e #.

• -1 byte usando ṬŒḄinvece di ḤḶ=¹.
• -2 byte usando -invece di 1N. Inoltre rende ¤superfluo.
• -1 byte usando Sinvece di +/.
• -6 byte usando Ḃ+Ḃ+invece di %3=1+=1Ḥ$+. Ora usa 2per dormire invece di 3.

Spiegazione in arrivo ...

APL (Dyalog Classic) , 38 byte

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

Provalo online!

basato sulla soluzione di Erik the Outgolfer

⍪1 è una matrice 1x1 contenente 1

⎕ input valutato

( )⍣⎕ applicare più volte

• (⌽0,⍉)⍣4surround con 0s, ovvero 4 volte do: transpose ( ⍉), aggiungi 0s a sinistra ( 0,), inverti in senso orizzontale ( ⌽)

• g←3+/0,,∘0 una funzione che somma le triple orizzontali, chiamala g

• ⍉∘g∘⍉una funzione che somma le triple verticali - che è gin trasposizione

• 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 somma delle due somme modulo 2

• ⌈ il maggiore tra quello e ...

• 2∘∧ LCM di 2 e matrice originale - questo trasforma 1s in 2s, preservando 0s e 2s

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

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

Provalo online!

Usa 0 per vuoto, 1 per sveglio e 2 per addormentato.

Rubino , ₁₆₄ 153 byte

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

Provalo online!

Utilizza "" per Vuoto, "@" per Sveglia e "#" per Dormire (come nell'esempio). Potrei salvare 6 byte usando i numeri invece, suppongo, ma sembra meglio così.

Pip , 69 61 byte

60 byte di codice, +1 per la -lbandiera.

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

Prende ncome argomento da riga di comando. Utilizza 0per vuoto, 1per sveglio e 2per dormire. (Per ottenere una più bella arte ASCII come negli esempi della sfida, sostituisci la finale ycon " @#"@y.)

Provalo online!

Spiegazione

Impostare:

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

Anello 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

dove si trova il corpo della funzione:

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

Dopo il ciclo, eseguiamo semplicemente l'autoprint y. Il -lflag indica che l'elenco nidificato viene stampato concatenando il contenuto di ciascuna riga e separando le righe con nuove righe.

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

Provalo online!

Nota: l'array restituito contiene un bordo o '\0'caratteri. Poiché il piano dovrebbe essere infinito, viene utilizzato solo il non bordo.

Mappatura dei caratteri:

• Vuoto: (spazio)
• Sveglio: =
• Camere da letto: 0

Salva

• 29 byte salvati grazie a Jonathan S.
• 9 byte aggiuntivi grazie a Jonathan S. scambiando personaggi con gli altri e "facendo magie con numeri primi e aritmetica modulare"

Python, 199 192 byte

Questo codice funziona sia su Python 2 che su Python 3, ma utilizza la popolare libreria Numpy di terze parti per eseguire la gestione dell'array.

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

Vuoto = 0
Sveglia = 1
Dormire = 2

print(f(6)) uscite

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

Se vuoi una stampa più bella, puoi chiamarla in questo modo:

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

che stampa utilizzando gli stessi caratteri indicati nella domanda.