Inspirado por esto .

Fondo

El granjero malvado ha decidido quemar su campo de trigo para subir los precios. Para garantizar la destrucción total, también ha empapado su campo en gasolina. Aún más desafortunadamente, estabas caminando en el campo cuando estaba encendido, y debes salir rápidamente para sobrevivir.

Reto

Dado un campo que contiene trigo, fuego y su ubicación, determine si puede salir del campo a tiempo.

Un campo consiste en trigo (aquí representado por .) y fuego ( F). Aquí su ubicación está marcada con un O. Por ejemplo:

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

Cada segundo te mueves a cualquier celda adyacente (pero no en diagonal), y cada fuego se extiende a cada celda adyacente. Si no puedes moverte a una celda que no se incendiará, morirás. Si logras salir del campo, sobrevives. Veamos qué sucede en este ejemplo:

...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

Reglas

• Su entrada es el campo como una cuadrícula. Puede elegir cualquier formato de entrada, incluida una cadena con separadores de línea o una matriz 2D.
  • Es posible que no se tome como entrada los lugares de fuego y / o usted mismo.
  • Puede usar 3 valores distintos como trigo, fuego y su posición, incluidas las no cadenas para la entrada de matriz.
  • Los campos siempre tienen un tamaño de al menos 1x1, son rectangulares y no contienen caracteres no válidos.
  • Cualquier campo contendrá exactamente uno del valor que representa su ubicación, y cualquier otra posición puede o no ser activada.
• Su salida es uno de los dos valores distintos para "sobrevivir" o "morir", como es habitual en el problema de decisión .
• Se aplican reglas estándar de código de golf .

Casos de prueba

Sobrevivió

O

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

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

FFFF
FFFO
FFFF

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

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

No sobrevivio

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..

Caracoles, 15 bytes

\Oo!{.,fee7.,\F

Pruébalo en línea!

1significa supervivencia mientras que 0significa muerte.

Dado que es imposible escapar del fuego, nunca es útil tratar de evitarlo. La mejor ruta es siempre una línea recta. Por lo tanto, solo hay cuatro opciones posibles de ruta de escape. Para determinar si una dirección es segura, verificamos si hay alguno Fen el "cono de fuego" que apunte en esa dirección.

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

Pruébalo en línea!

Toma de entrada como una cadena separada saltos de línea, y vuelve True/FalseparaDead/Alive

Funciona marcando cada dirección (udlr) para ver si hay Fira mirando hacia afuera:

Ejemplo:

Entrada:

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

Comprobaciones de fuego:

Up:       Down:     Left:     Right:

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

Si todas las direcciones contienen fuego, mueres, de lo contrario hay un escape.

Editar: Volver a tomar una cadena como entrada, y ahora solo verifica arriba / derecha, pero también verifica la entrada hacia atrás (hacia abajo / izquierda)

Ahorré muchos bytes gracias al Sr. Xcoder y 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 enteros
• 2 para F , 1 para ., 0 paraO

Salida:

• Valor de verdad (1) para sobrevivir
• Valor de falsa (NaN) para el dado

Intentalo:

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 un autómata celular. Hay 3 estados para una celda O(accesible por personas), F(capturado), .(nada acaba de suceder). La regla para crear la próxima generación es:

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 `.`

Una vez que hay una célula en el borde O, la gente sobrevive. Si esto no sucedió en cantidad suficiente, la gente murió.

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

Octava, 71 bytes

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

Pruébalo en línea!

o

¡Verifique todos los casos de prueba!

Formato de entrada:

• Matriz 2D de enteros
• 1para ., 2para Oy 3paraF

Salida:

• true y false

Explicación:

Explicación:

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

Pruébalo en línea! Requiere que el fondo sea espacios en lugar de .s (o podría usarse algún otro personaje seguro para regexp). Explicación:

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

Si hay un Oen cualquier borde, elimine todo lo demás (caso de supervivencia)

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

Coloque un #en cualquier espacio sobre un existente O.

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

Y a #en cualquier espacio debajo de un existente O.

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

Cambie #s a Os, y también cualquier espacio a la izquierda o derecha de un existente O.

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

Coloque #s sobre cualquier Fs existente . Estos pueden sobrescribir Os, así como espacios.

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

Coloque #s debajo de cualquier Fs existente , también sobrescribiendo Os, así como espacios.

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

Cambie #s a Fs, y también cualquier Oespacio a la izquierda o derecha de un existente F. Repita hasta que los Fs hayan consumido todo.

O

Regrese 1para sobrevivir, 0si no.