fundo

Este desafio é uma homenagem aos apsillers , que venceram a categoria Não tão simples quanto parece no Best of PPCG 2016 com o desafio. Minha caixa de música de 4 notas toca essa música? Parabéns!

Na página "Sobre mim", esse usuário possui um simulador muito interessante para o autômato celular Game of Life . (Sério, vá dar uma olhada.) Por outro lado, a palavra aspillera é em espanhol para "iluminado por setas". À luz desses fatos, esse desafio é sobre flechas no jogo da vida.

Jogo de setas da vida

No GoL, representaremos uma flecha por um planador e uma parede por uma sequência de blocos . Um único planador se aproxima da parede de cima e tenta voar através de um espaço na parede (a flecha). Sua tarefa é verificar se o planador passa pelas setas ou bate na parede.

Entrada

Sua entrada é uma grade de bits, que representa uma configuração GoL. Você pode aceitá-lo em qualquer formato razoável (sequência multilinha de dois caracteres ASCII imprimíveis, lista de sequências, matriz 2D de números inteiros, matriz 2D de booleanos etc.). Para maior clareza, usarei seqüências multilinhas dos caracteres .#a seguir.

A entrada é garantida para ter várias propriedades. Primeiro, sua altura é 2N para alguns N ≥ 6 e sua largura é pelo menos 2N + 2 . A entrada será toda .s, exceto que em algum lugar nas três linhas superiores existe um planador, e nas duas linhas do meio há uma parede de blocos. O planador estará indo para sudoeste ou sudeste, e sua posição é tal que, se as paredes forem removidas, ele não passará por uma borda lateral antes de atingir a borda inferior (mas pode atingir um canto da grade). O planador é inicialmente separado das bordas esquerda e direita por pelo menos uma etapa de .s. Pode estar em qualquer fase.

A parede consiste em blocos, que são separados por uma coluna de .s, exceto em um local, onde serão separados por pelo menos duas colunas de .s. Como o planador, os blocos mais à esquerda e mais à direita também são separados das arestas por um passo de .s. Sempre haverá pelo menos um bloco na borda esquerda e um bloco na borda direita.

Aqui está um exemplo de uma grade de entrada válida:

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

Saída

Como afirmado, sua tarefa é determinar se o planador colide com a parede ou atravessa a borda sul. Para os propósitos deste desafio, ocorre uma falha se a configuração não mais consistir em um único planador e na parede de blocos, independentemente do que acontecer posteriormente na simulação. Os diagramas a seguir mostram as menores lacunas pelas quais um planador do sudeste pode atravessar sem bater nas duas fases distintas (a condição para o planador do sudoeste é simétrica).

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

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

Se o planador voa através da parede, você deve gerar um valor verdadeiro e, caso contrário, um valor falso. Para o exemplo acima, a saída correta é falsa, pois o planador colidirá com a parte esquerda da parede.

Para os propósitos deste desafio, você pode assumir que, se simular o GoL na entrada por 2 * (altura - 3) etapas, o planador estará na linha inferior na posição esperada e a parede estará intacta, e a saída será verdadeira .

Regras e pontuação

Você pode escrever um programa completo ou uma função. A menor contagem de bytes vence.

Casos de teste

Eu coletei os casos de teste em um repositório do GitHub , pois eles são muito grandes. Aqui estão os links para os arquivos individuais:

• Casos de teste verdadeiros como matrizes 2D de bits
• Casos de teste de falsidade como matrizes 2D de bits
• Todos os casos de teste em formato legível por humanos

Python 2 , 142 136 135 bytes

^{-6 bytes graças ao ElPedro
-1 byte graças ao 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

Experimente online! ou Verifique todos os casos de teste

Verificando a orientação (leste / oeste):

Usando z=p[2].index(1)para obter o primeiro quadrado na terceira linha (representada pelo quadrado vermelho) e, em seguida, m=(p[1][z]-p[1][z+1]<1)*2-1subtrair o valor à direita (verde) do valor à esquerda (azul), desta forma, todos os quatro planadores afirmam que sudoeste resultam em 1(linha superior da imagem), enquanto os que vão para sudeste resultam em 0ou -1.
Em seguida, converta: 1 -> -1e 0,-1 -> 1para ser usado no parâmetro para reverter as listas ao lidar com as ocidentais. Desta forma, os planadores que vão para o sudoeste são ameaçados da mesma maneira que para o sudeste.

Movimento de planador

Esse é o movimento que o planador que vai para o sudeste faz, tem um padrão de "escada" e o bloco mais à esquerda na 3ª linha é constante para todos os padrões. Utilizando-o como ponto de partida, os 3 blocos circundantes à esquerda e à direita e os 4 blocos do meio são verificados quanto à presença de 1s (que seria a parede).

Oitava, 123 122 108 bytes

Graças a @LuisMendo economizou 2 bytes

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

Experimente online!

Ou

Verifique todos os casos de teste

Graças a Rod, preparando casos de teste.

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

Resposta anterior:

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

Primeiro extraia o padrão da parede como variável B.
Faça a simulação GoL até que o padrão de parede e o padrão simulado tenham mais / menos de 5 células diferentes.
Se o planador recebeu a última linha, a função retornará true.

Retina , 101 93 91 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

Experimente online!

Certamente ainda não é o ideal.