Inspirado por isso .

fundo

O fazendeiro do mal decidiu queimar seu campo de trigo para aumentar os preços. Para garantir a destruição total, ele também encharcou seu campo com gasolina. Ainda mais, infelizmente, você estava andando no campo quando estava aceso e precisava sair rapidamente para sobreviver.

Desafio

Dado um campo que contém trigo, fogo e sua localização, determine se você pode sair do campo a tempo.

Um campo consiste em trigo (aqui representado por .) e fogo ( F). Aqui a sua localização é marcada com um O. Por exemplo:

...F...F
F.......
........
.F......
....O...
...F....
........
.F....F.

A cada segundo você se move para qualquer célula adjacente (mas não na diagonal), e todo fogo se espalha para cada célula adjacente. Se você não pode se mudar para uma célula que não estará pegando fogo, você morre. Se você sair do campo, você sobrevive. Vamos ver o que acontece neste exemplo:

...F...F
F.......
........
.F......
....O...
...F....
........
.F....F.

..FFF.FF
FF.F...F
FF......
FFF.....
.F.F.O..
..FFF...
.F.F..F.
FFF..FFF

FFFFFFFF
FFFFF.FF
FFFF...F
FFFF....
FF.FF.O.
.FFFFFF.
FFFFFFFF
FFFFFFFF

FFFFFFFF
FFFFFFFF
FFFFF.FF
FFFFF.FF
FFFFFFFO
FFFFFFFF
FFFFFFFF
FFFFFFFF

FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFFO <-- you made it out and survived, barely
FFFFFFFF
FFFFFFFF
FFFFFFFF

Regras

• Sua entrada é o campo como uma grade. Você pode escolher qualquer formato de entrada, incluindo uma sequência com separadores de linhas ou uma matriz 2D.
  • Você não pode tomar como entrada os locais para incêndio e / ou você mesmo.
  • Você pode usar quaisquer 3 valores distintos como trigo, fogo e sua posição, incluindo não-strings para entrada da matriz.
  • Os campos têm sempre pelo menos 1 x 1 de tamanho, retangulares e não contêm caracteres inválidos.
  • Qualquer campo conterá exatamente um valor que representa sua localização e todas as outras posições podem ou não ser acionadas.
• Sua saída é um dos dois valores distintos para "você sobrevive" ou "você morre", como de costume no problema de decisão .
• Aplicam-se as regras padrão de código de golfe .

Casos de teste

Sobreviveu

O

....
.O..
....

FFFFF
.....
..O..
.....

FFFF
FFFO
FFFF

.F....
......
......
.F....
..O...
.FF...
.F....
..FF..

...F...F
F.......
........
.F......
....O...
...F....
........
.F....F.

Não sobreviveu

FFF
FOF
FFF

F.F
.O.
F.F

....F
.....
..O..
.....
F....

.F....F.
........
........
F..O....
........
.....F..

...F...F
F......F
........
.F......
....O...
...F....
........
.F....F.

F..F
.O..
FF..

Caracóis, 15 bytes

\Oo!{.,fee7.,\F

Experimente online!

1significa sobrevivência enquanto 0significa morte.

Como é impossível superar o fogo, nunca é útil tentar contorná-lo. A melhor rota é sempre uma linha reta. Portanto, existem apenas quatro opções possíveis de rota de fuga. Para determinar se uma direção é segura, verificamos se há alguma Fno "cone de fogo" apontando nessa direção.

Python 2 , 283 218 209 208 bytes

lambda F:f(F)&f(F[::-1])
def f(F):l=F.split();w=len(l[0])+1;i=F.index('O');x,y=i/w,i%w;r=range(len(l));return all('F'in''.join(n)for n in[[l[i][x+abs(i-y):]for i in r],[l[i][max(0,y+x-i):i+x-y+1]for i in r]])

Experimente online!

Recebe a entrada como uma sequência separada de novas linhas e retorna True/FalseparaDead/Alive

Funciona verificando cada direção (udlr) quanto à Fira, olhando para fora:

Exemplo:

Entrada:

FFFFF
.....
..O..
.....

Verificações de incêndio:

Up:       Down:     Left:     Right:

FFFFF               F             F
 ...                ..           ..
  O         O       ..O         O..
           ...      ..           ..

Se todas as direções contiverem fogo, você morre, caso contrário, haverá uma fuga.

Edit: Voltar a pegar uma string como entrada e agora apenas verifica se há up / right, mas também verifica a entrada de trás para frente (dando para baixo / esquerda)

Economizou muitos bytes graças ao Sr. Xcoder e Felipe Nardi Batista

JavaScript, 174 bytes

a=>+(t=>g=a=>t--?g(a.map((l,y)=>l.map((c,x)=>(h=v=>[(a[y-1]||[])[x],(a[y+1]||[])[x],a[y][x+1],a[y][x-1],c].includes(v),!c&&h()?p=1:[2,0,1].find(h))))):p)((p=a+'!').length)(a)

Formato de entrada:

• Matriz de Matriz de Inteiros
• 2 para F, 1 para ., 0 paraO

Saída:

• Valor de verdade (1) para sobrevivência
• Valor de falsidade (NaN) para o dado

Tente:

f=a=>+(t=>g=a=>t--?g(a.map((l,y)=>l.map((c,x)=>(h=v=>[(a[y-1]||[])[x],(a[y+1]||[])[x],a[y][x+1],a[y][x-1],c].includes(v),!c&&h()?p=1:[2,0,1].find(h))))):p)((p=a+'!').length)(a)
t=s=>f(s.trim().split('\n').map(x=>x.split('').map(n=>({F:2,'.':1,O:0}[n]))))

console.log(t(`
FFFFF
.....
..O..
.....
`))

console.log(t(`
FFFF
FFFO
FFFF
`))

console.log(t(`
.F....
......
......
.F....
..O...
.FF...
.F....
..FF..
`))

console.log(t(`
...F...F
F.......
........
.F......
....O...
...F....
........
.F....F.
`))

console.log(t(`
FFF
FOF
FFF
`))

console.log(t(`
F.F
.O.
F.F
`))

console.log(t(`
....F
.....
..O..
.....
F....
`))

console.log(t(`
.F....F.
........
........
F..O....
........
.....F..
`))

console.log(t(`
...F...F
F......F
........
.F......
....O...
...F....
........
.F....F.
`))

Considere um autômato celular. Existem três estados para uma célula O(acessível por pessoas), F(captura demitida), .(nada aconteceu). A regra para criar a próxima geração é:

for each cell:
  me and my 4 neighborhoods,
    if anyone is `F` then result is `F`,
    otherwise, if anyone is `O` then result is `O`
    otherwise, keep state `.`

Uma vez que uma célula no limite tenha Oestado, as pessoas sobrevivem. Se isso não aconteceu em quantidade suficiente, as pessoas morreram.

// check for all neighbors:
h=v=>[(a[y-1]||[])[x],(a[y+1]||[])[x],a[y][x+1],a[y][x-1],c].includes(v)
// if me == 'O' and i'm edge (neighbors contain _undefined_), then survive
!c&&h()?p=1
// Otherwise apply the given rule
:[2,0,1].find(h)

Oitava, 71 bytes

@(a)(A=blkdiag(0,a,0))<3||any((bwdist(A>2,'ci')>bwdist(A==2,'ci'))(!A))

Experimente online!

ou

Verifique todos os casos de teste!

Formato de entrada:

• Matriz 2D de números inteiros
• 1para ., 2para Oe 3paraF

Saída:

• true e false

Explicação:

Explicação:

A=blkdiag(0,a,0)    % add a boundary of 0s around the array
A<3                 % return truthy when there is no fire
bwdist(A>2,'ci')    % city block distance transform of binary map of fire
bwdist(A==2,'ci')   % city block distance transform of binary map of your location
any(...)(!A)        % check if there is at least one element on the boundary of 
                    % the fire distance map has its distance greater than 
                    % that of distance map of your location

Retina , 243 bytes

^.*O(.|¶)*|(.|¶)*O.*$|(.|¶)*(¶O|O¶)(.|¶)*
O
m`^((.)*) (.*¶(?<-2>.)*(?(2)(?!))O)
$1#$3
m`^((.)*O.*¶(?<-2>.)*(?(2)(?!))) 
$1#
T`p`\O`#| ?O ?
+m`^((.)*)[O ](.*¶(?<-2>.)*(?(2)(?!))F)
$1#$3
+m`^((.)*F.*¶(?<-2>.)*(?(2)(?!)))[O ]
$1#
}T`p`F`#|.?F.?
O

Experimente online! Requer que o plano de fundo seja espaços em vez de .s (ou algum outro caractere seguro para regexp pode ser usado). Explicação:

^.*O(.|¶)*|(.|¶)*O.*$|(.|¶)*(¶O|O¶)(.|¶)*
O

Se houver Oalgum, exclua todo o resto (caso de sobrevivência)

m`^((.)*) (.*¶(?<-2>.)*(?(2)(?!))O)
$1#$3

Coloque um #em qualquer espaço acima de um existente O.

m`^((.)*O.*¶(?<-2>.)*(?(2)(?!))) 
$1#

E um #em qualquer espaço abaixo de um existente O.

T`p`\O`#| ?O ?

Altere #s para Os e também qualquer espaço à esquerda ou à direita de um existente O.

+m`^((.)*)[O ](.*¶(?<-2>.)*(?(2)(?!))F)
$1#$3

Coloque #s acima de qualquer Fs existente . Eles podem substituir Os e espaços.

+m`^((.)*F.*¶(?<-2>.)*(?(2)(?!)))[O ]
$1#

Coloque #s abaixo de qualquer Fs existente , também substituindo Os e espaços.

}T`p`F`#|.?F.?

Altere #s para se Ftambém qualquer Oespaço ou à esquerda ou direita de um existente F. Repita até os Fconsumirem tudo.

O

Volte 1para a sobrevivência, 0se não.