Ispirato da questo .

sfondo

Il malvagio agricoltore ha deciso di bruciare il tuo campo di grano per aumentare i prezzi. Per garantire la totale distruzione, ha anche inzuppato il campo di benzina. Ancora più sfortunatamente, ti è capitato di camminare sul campo quando è stato acceso il fuoco, e devi uscire rapidamente per sopravvivere.

Sfida

Dato un campo contenente grano, fuoco e la tua posizione, determina se riesci a uscire dal campo in tempo.

Un campo è costituito da grano (qui rappresentato da .) e fuoco ( F). Qui la tua posizione è contrassegnata con a O. Per esempio:

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

Ogni secondo ti sposti in qualsiasi cella adiacente (ma non in diagonale) e ogni fuoco si diffonde in ogni cella adiacente. Se non riesci a trasferirti in una cella che non sarà in fiamme, muori. Se riesci a uscire dal campo, sopravvivi. Vediamo cosa succede in questo esempio:

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

Regole

• Il tuo input è il campo come griglia. Puoi scegliere qualsiasi formato di input, inclusa una stringa con separatori di riga o un array 2D.
  • Si può non prendere come input le posizioni per incendio e / o da soli.
  • È possibile utilizzare 3 valori distinti come grano, fuoco e posizione, comprese le non stringhe per l'input dell'array.
  • I campi hanno sempre una dimensione di almeno 1 x 1, rettangolari e non contengono caratteri non validi.
  • Qualsiasi campo conterrà esattamente uno dei valori che rappresentano la tua posizione e ogni altra posizione potrebbe essere o meno un incendio.
• Il tuo output è uno dei due valori distinti per "sopravvivi" o "muori", come al solito nel problema decisionale .
• Si applicano le regole standard del code-golf .

Casi test

Sopravvissuto

O

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

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

FFFF
FFFO
FFFF

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

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

Non è sopravvissuto

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

Lumache, 15 byte

\Oo!{.,fee7.,\F

Provalo online!

1significa sopravvivenza mentre 0significa morte.

Poiché è impossibile superare il fuoco, non è mai utile provare a aggirarlo. Il percorso migliore è sempre una linea retta. Quindi ci sono solo quattro possibili scelte della via di fuga. Per determinare se una direzione è sicura, controlliamo che Fnel "cono di fuoco" sia presente una direzione.

Python 2 , 283 218 209 208 byte

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

Provalo online!

Prende l'input come stringa separata da nuove righe e ritorna True/FalseperDead/Alive

Funziona controllando ogni direzione (udlr) per l' Fira guardando verso l'esterno:

Esempio:

Ingresso:

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

Controlli antincendio:

Up:       Down:     Left:     Right:

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

Se tutte le direzioni contengono fuoco muori, altrimenti c'è una via di fuga.

Modifica: torna a prendere una stringa come input, e ora controlla solo su / destra, ma controlla anche l'input indietro (dando giù / sinistra)

Risparmio di molti byte grazie a Mr. Xcoder e Felipe Nardi Batista

JavaScript, 174 byte

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 di input:

• Matrice di matrice di numeri interi
• 2 per F, 1 per ., 0 perO

Produzione:

• Valore vero (1) per sopravvivere
• Valore falso (NaN) per die

Provalo:

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

Considera un automa cellulare. Ci sono 3 stati per una cella O(raggiungibile dalle persone), F(catturato), .(non è successo nulla). La regola per creare la prossima generazione è:

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 volta che una cella al limite ha Ostato, le persone sopravvivono. Se ciò non è avvenuto in quantità sufficiente, allora la gente è morta.

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

Ottava, 71 byte

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

Provalo online!

o

Verifica tutti i casi di test!

Formato di input:

• Matrice 2D di numeri interi
• 1per ., 2per Oe 3perF

Produzione:

• true e false

Spiegazione:

Spiegazione:

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 byte

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

Provalo online! Richiede che lo sfondo sia spazio anziché .s (o potrebbe essere usato qualche altro personaggio sicuro per regexp). Spiegazione:

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

Se è presente un Obordo qualsiasi, elimina tutto il resto (caso di sopravvivenza)

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

Posiziona a #in qualsiasi spazio sopra un esistente O.

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

E a #in qualsiasi spazio al di sotto di un esistente O.

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

Cambia la #s in Os, e anche qualsiasi spazio a sinistra o a destra di un esistente O.

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

Posizionare #s sopra qualsiasi Fs esistente . Questi possono sovrascrivere Osia gli spazi.

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

Posizionare #s al di sotto di qualsiasi Fs esistente , sovrascrivendo anche Os e spazi.

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

Cambia la #s in Fs, e anche qualsiasi Oo spazio a sinistra o a destra di un esistente F. Ripeti finché gli Fs non hanno consumato tutto.

O

Ritorna 1per sopravvivere, 0se no.