sfondo

Questa sfida è in onore degli apsillers , che hanno vinto la categoria Non così semplice come appare in Best of PPCG 2016 con la loro sfida Il mio carillon a 4 note può suonare quella canzone? Congratulazioni!

Sulla loro pagina "Informazioni personali", questo utente ha un simulatore davvero accurato per l' automa cellulare Game of Life . (Seriamente, vai a dare un'occhiata.) D'altra parte, la parola aspillera è spagnolo per "frecce". Alla luce di questi fatti, questa sfida riguarda le freccette in Game of Life.

Frecce di Game of Life

In GoL, rappresenteremo una freccia di un aliante e un muro di una sequenza di blocchi . Un singolo aliante si avvicina al muro dall'alto, e cerca di volare attraverso uno spazio nel muro (le frecce illuminate). Il tuo compito è controllare se l'aliante passa attraverso le frecce illuminate o si schianta contro il muro.

Ingresso

Il tuo input è una griglia di bit, che rappresenta una configurazione GoL. Puoi prenderlo in qualsiasi formato ragionevole (stringa multilinea di due caratteri ASCII stampabili distinti, elenco di stringhe, array 2D di numeri interi, array 2D di booleani ecc.). Per chiarezza, userò le stringhe multilinea dei caratteri .#nel seguito.

È garantito che l'input abbia diverse proprietà. Innanzitutto, la sua altezza è 2 N per alcuni N ≥ 6 e la sua larghezza è almeno 2 N + 2 . L'input sarà tutto .s, tranne che da qualche parte nelle prime tre file c'è un aliante, e nelle due file centrali c'è un muro di blocchi. L'aliante si dirige verso sud-ovest o sud-est e la sua posizione è tale che se le pareti vengono rimosse, non passerà attraverso un bordo laterale prima di raggiungere il bordo inferiore (ma potrebbe raggiungere un angolo della griglia). La vela è inizialmente separata dai bordi sinistro e destro di almeno un passo di .s. Può essere in qualsiasi fase.

Il muro è costituito da blocchi, che sono separati da una colonna di .s, tranne in un punto, dove saranno separati da almeno due colonne di .s. Come l'aliante, anche i blocchi più a sinistra e più a destra sono separati dai bordi di un passo di .s. Ci sarà sempre almeno un blocco sul bordo sinistro e un blocco sul bordo destro.

Ecco un esempio di una griglia di input valida:

....#......................
..#.#......................
...##......................
...........................
...........................
...........................
.##.##............##.##.##.
.##.##............##.##.##.
...........................
...........................
...........................
...........................
...........................
...........................

Produzione

Come detto, il tuo compito è determinare se l'aliante si schianta contro il muro o attraversa il bordo sud. Ai fini di questa sfida, si verifica un arresto anomalo se la configurazione non è più costituita da un singolo aliante e dal muro di blocchi, indipendentemente da ciò che accade più avanti nella simulazione. I seguenti diagrammi mostrano gli spazi più piccoli che un aliante sud-est può attraversare senza schiantarsi nelle due fasi distinte (la condizione per gli alianti sud-ovest è simmetrica).

...#...........
.#.#...........
..##...........
...............
...............
##...........##
##...........##

...#...........
....#..........
..###..........
...............
...............
##...........##
##...........##

Se l'aliante vola attraverso il muro, dovrai generare un valore di verità, e altrimenti un valore di falsa. Nell'esempio sopra, l'output corretto è errato, poiché l'aliante si schianterà nella parte sinistra del muro.

Ai fini di questa sfida, si può presumere che se si simula GoL sull'input per passi 2 * (altezza - 3) , l'aliante si trova nella riga inferiore nella posizione prevista e il muro è intatto, quindi l'output è vero .

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio dei byte più basso.

Casi test

Ho raccolto i casi di test in un repository GitHub , poiché sono piuttosto grandi. Ecco i collegamenti ai singoli file:

• Casi di prova veritieri come matrici 2D di bit
• Casi di prova falsi come matrici 2D di bit
• Tutti i casi di test in formato leggibile dall'uomo

Python 2 , 142 136 135 byte

^{-6 byte grazie a ElPedro
-1 byte grazie a TuukkaX}

p=input()
z=p[2].index(1)
m=(p[1][z]-p[1][z+1]<1)*2-1
k=i=0
for b in p[3:]:x=p[2][::m].index(1)+i;k|=1in b[::m][x-2:x+8];i+=1
print 1-k

Provalo online! oppure Verifica tutti i casi di test

Verifica dell'orientamento (est / ovest):

Usando z=p[2].index(1)per ottenere il primo quadrato sulla 3a riga (rappresentato dal quadrato rosso), e quindi m=(p[1][z]-p[1][z+1]<1)*2-1per sottrarre il valore a destra (verde) da quello a sinistra (blu), in questo modo tutti e 4 gli alianti indicano che stanno per a sud-ovest si ottiene 1(riga in alto nell'immagine), mentre quelli che vanno a sud-est risultano in 0o -1.
Quindi converti: 1 -> -1e 0,-1 -> 1da utilizzare sul parametro per invertire gli elenchi quando hai a che fare con quelli occidentali. In questo modo gli alianti che vanno a sud-ovest sono minacciati come quello che va a sud-est.

Movimento aliante

Questo è il movimento che la vela in direzione sud-est fa, ha uno schema a "scala" e il blocco più a sinistra sulla terza linea è costante per ogni schema. Usandolo come punto di partenza, i 3 blocchi circostanti a sinistra e a destra e i 4 blocchi centrali vengono controllati per la presenza di 1s (che sarebbe il muro).

Ottava, 123 122 108 byte

Grazie a @LuisMendo salvato 2 byte

B=A=input("");B(1:3,:)=0;do;until nnz((A=A&(s=conv2(A,(m=-1:1)|m','same'))>1&s<4|~A&s==3)-B)-5;any(A(end,:))

Provalo online!

O

Verifica tutti i casi di test

Grazie a Rod che prepara i casi di test.

B=A=input("");
B(1:3,:)=0;
do
until nnz((A=A&(s=conv2(A,(m=-1:1)|m','same'))>1&s<4|~A&s==3)-B)-5
any(A(end,:))

Risposta precedente:

B=A=input("");
B(1:3,:)=0;
while nnz(A~=B)==5
    s=conv2(A,(m=-1:1)|m','same');
    x=~A;
    A&=~A|~(s<2|s>3);
    A|=x&s==3;
end;
any(A(end,:))

Per prima cosa estrarre il modello di muro come variabile B.
Esegui la simulazione GoL fino a quando il modello di muro e il modello simulato hanno più / meno di 5 celle diverse.
Se l'aliante ha ricevuto l'ultima riga la funzione ritorna vera.

Retina , 101 93 91 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

O$#^`.(?=(.*¶)*(?<=#_.\2.+##.(.*¶)\D+))
$#1
¶(?>_(_)*#+_+¶_+¶(?<1>_+¶)*)(?>(?<-1>.)+)_{11}

Provalo online!

Certamente non ancora ottimale.