# Will I make it out in time?

## Snails, 15 bytes

```
\Oo!{.,fee7.,\F
```

Try it online!

`1`

means survival while `0`

means death.

Since it is impossible to outrun the fire, it is never useful to try to go around it. The best route is always a straight line. So there are only four possible choices of escape route. To determine if a direction is safe, we check for any `F`

in the "fire cone" pointing in that direction.

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

Try it online!

Takes input as a newlines separated string, and returns `True/False`

for `Dead/Alive`

Works by checking each direction(udlr) for `F`

ire in by looking outward:

Example:

Input:

```
FFFFF
.....
..O..
.....
```

Fire checks:

```
Up: Down: Left: Right:
FFFFF F F
... .. ..
O O ..O O..
... .. ..
```

If all directions contain fire you die, otherwise there is an escape.

Edit: Back to taking a string as input, and now only checks for up/right, but also checks the input backwards (giving down/left)

Saved a lot of bytes thanks to Mr. Xcoder and 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)
```

Input format:

- Array of Array of Integers
- 2 for
`F`

, 1 for`.`

, 0 for`O`

Output:

- Truthy value (1) for survive
- Falsy value (NaN) for die

Try It:

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

Consider a cellular automaton. There are 3 states for a cell `O`

(reachable by people), `F`

(catch fired), `.`

(nothing just happened). The rule for create next generation is:

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

Once there is an cell on edge has `O`

state, the people survive. If this not happened in enough amount generation, then the people died.

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