Contexte

Ce défi est en l'honneur des apsillers , qui ont remporté la catégorie Pas aussi simple qu'il n'y paraît dans Best of PPCG 2016 avec leur défi Ma boîte à musique à 4 notes peut-elle jouer cette chanson? Toutes nos félicitations!

Sur sa page "À propos de moi", cet utilisateur a un simulateur vraiment soigné pour l' automate cellulaire Game of Life . (Sérieusement, allez le vérifier.) D'un autre côté, le mot aspillera est espagnol pour "flèches éclairées". À la lumière de ces faits, ce défi concerne les flèches dans Game of Life.

Flèches de jeu de la vie

Dans GoL, nous représenterons une flèche par un planeur et un mur par une séquence de blocs . Un seul planeur s'approche du mur par le haut et essaie de voler à travers un espace dans le mur (la flèche éclairée). Votre tâche consiste à vérifier si le planeur passe à travers la flèche ou s’écrase dans le mur.

Contribution

Votre entrée est une grille de bits, qui représente une configuration GoL. Vous pouvez le prendre dans n'importe quel format raisonnable (chaîne multiligne de deux caractères ASCII imprimables différents, liste de chaînes, tableau 2D d'entiers, tableau 2D de booléens, etc.). Pour plus de clarté, j'utiliserai les chaînes de caractères multilignes des caractères .#suivants.

L'entrée est garantie d'avoir plusieurs propriétés. Tout d'abord, sa hauteur est de 2N pour certains N ≥ 6 , et sa largeur est d'au moins 2N + 2 . L'entrée sera tout .s, sauf que quelque part sur les trois premières rangées est un planeur, et sur les deux rangées du milieu il y a un mur de blocs. Le planeur se dirigera vers le sud-ouest ou le sud-est, et sa position est telle que si les murs sont supprimés, il ne passera pas par un bord latéral avant d'atteindre le bord inférieur (mais il peut atteindre un coin de la grille). Le planeur est initialement séparé des bords gauche et droit par au moins un pas de .s. Cela peut être dans n'importe quelle phase.

Le mur est constitué de blocs, qui sont séparés par une colonne de .s, sauf en un seul endroit, où ils seront séparés par au moins deux colonnes de .s. Comme le planeur, les blocs les plus à gauche et à droite sont également séparés des bords par un pas de .s. Il y aura toujours au moins un bloc sur le bord gauche et un bloc sur le bord droit.

Voici un exemple de grille d'entrée valide:

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

Sortie

Comme indiqué, votre tâche consiste à déterminer si le planeur s'écrase dans le mur ou se rend jusqu'au bord sud. Aux fins de ce défi, un crash se produit si la configuration n'est plus constituée d'un seul planeur et du mur de blocs, indépendamment de ce qui se passe plus tard dans la simulation. Les diagrammes suivants montrent les plus petites lacunes qu'un planeur sud-est peut traverser sans s'écraser dans les deux phases distinctes (la condition pour les planeurs sud-ouest est symétrique).

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

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

Si le planeur vole à travers le mur, vous devez afficher une valeur vraie, et sinon une valeur fausse. Pour l'exemple ci-dessus, la sortie correcte est fausse, car le planeur va s'écraser dans la partie gauche du mur.

Aux fins de ce défi, vous pouvez supposer que si vous simulez GoL sur l'entrée pour 2 * (hauteur - 3) étapes, le planeur est sur la rangée du bas dans la position attendue et le mur est intact, alors la sortie est véridique .

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. Le nombre d'octets le plus bas gagne.

Cas de test

J'ai rassemblé les cas de test dans un référentiel GitHub , car ils sont assez volumineux. Voici les liens vers les fichiers individuels:

• Cas de test authentiques sous forme de tableaux 2D de bits
• Cas de test de fausseté sous forme de tableaux 2D de bits
• Tous les cas de test dans un format lisible par l'homme

Python 2 , 142 136 135 135 octets

^{-6 octets grâce à ElPedro
-1 octet grâce à 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

Essayez-le en ligne! ou vérifier tous les cas de test

Vérification de l'orientation (est / ouest):

Utilisez z=p[2].index(1)pour obtenir le premier carré de la 3ème ligne (représenté par le carré rouge), puis m=(p[1][z]-p[1][z+1]<1)*2-1pour soustraire la valeur de droite (verte) de celle de gauche (bleue), de cette façon, les 4 états des planeurs qui vont au sud-ouest résulte en 1(rangée du haut de l'image), tandis que ceux qui vont au sud-est donnent 0ou -1.
Puis convertissez: 1 -> -1et0,-1 -> 1 à utiliser sur le paramètre pour inverser les listes lorsque vous traitez avec des listes occidentales. De cette façon, les planeurs allant vers le sud-ouest sont menacés de la même manière que celui qui va vers le sud-est.

Mouvement de planeur

C'est le mouvement que fait le planeur allant vers le sud-est, il a un motif en "échelle", et le bloc le plus à gauche sur la 3ème ligne est constant pour chaque motif. En l'utilisant comme point de départ, les 3 blocs environnants à gauche et à droite, et les 4 blocs du milieu sont vérifiés pour la présence de 1s (ce serait le mur).

Octave, 123 122 108 octets

Merci à @LuisMendo économisé 2 octets

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,:))

Essayez-le en ligne!

Ou

Vérifier tous les cas de test

Merci à Rod de préparer des cas de 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,:))

Réponse précédente:

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,:))

Extraire d'abord le modèle de mur comme variable B.
Effectuez une simulation GoL jusqu'à ce que le motif de mur et le motif simulé aient plus / moins de 5 cellules différentes.
Si le planeur a reçu la dernière ligne, la fonction renvoie true.

Rétine , 101 93 91 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

Certainement pas encore optimal.