Inspiré par cela .

Contexte

Le mal agriculteur a décidé de brûler votre champ de blé afin de faire monter les prix. Pour assurer une destruction totale, il a également trempé votre champ dans l’essence. Encore plus malheureusement, vous vous trouviez sur le terrain quand il était allumé et vous devez sortir rapidement pour survivre.

Défi

Dans un champ contenant du blé, le feu et votre position, déterminez si vous pouvez le quitter à temps.

Un champ est constitué de blé (ici représenté par .) et de feu ( F). Ici votre emplacement est marqué avec un O. Par exemple:

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

Chaque seconde, vous vous déplacez dans une cellule adjacente (mais pas en diagonale) et chaque feu se propage à chaque cellule adjacente. Si vous ne pouvez pas vous déplacer dans une cellule qui ne sera pas en feu, vous mourrez. Si vous réussissez, vous survivez. Voyons ce qui se passe dans cet exemple:

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

Règles

• Votre entrée est le champ sous forme de grille. Vous pouvez choisir n’importe quel format d’entrée, y compris une chaîne avec séparateurs de lignes ou un tableau 2D.
  • Vous ne pouvez pas prendre comme entrée les emplacements pour le feu et / ou vous-même.
  • Vous pouvez utiliser 3 valeurs distinctes, telles que blé, feu et votre position, y compris les non-chaînes pour l'entrée en tableau.
  • Les champs ont toujours une taille minimale de 1x1, sont rectangulaires et ne contiennent aucun caractère non valide.
  • Chaque champ contiendra exactement l’une des valeurs représentant votre emplacement, et toute autre position peut ou non être déclenchée.
• Votre sortie est l’une des deux valeurs distinctes pour "vous survivez" ou "vous mourez", comme d’habitude en cas de problème de décision .
• Les règles standard de code-golf s'appliquent.

Cas de test

Survécu

O

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

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

FFFF
FFFO
FFFF

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

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

N'a pas survécu

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

Escargots, 15 octets

\Oo!{.,fee7.,\F

Essayez-le en ligne!

1signifie survie alors que 0signifie mort.

Puisqu'il est impossible de dépasser le feu, il n'est jamais utile d'essayer de le contourner. Le meilleur itinéraire est toujours une ligne droite. Il n'y a donc que quatre choix possibles de voie d'évacuation. Pour déterminer si une direction est sûre, nous vérifions si Fle "cône de feu" est orienté dans cette direction.

Python 2 , 283 218 209 208 octets

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

Essayez-le en ligne!

Prend l'entrée en tant que chaîne de nouvelle ligne séparée et retourne True/FalsepourDead/Alive

Fonctionne en vérifiant chaque direction (udlr) de la Fcolère en regardant vers l'extérieur:

Exemple:

Contribution:

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

Contrôles incendie:

Up:       Down:     Left:     Right:

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

Si toutes les directions contiennent du feu tu meurs, sinon il y a une fuite.

Éditer: Retour à la prise d'une chaîne en tant qu'entrée et vérifie maintenant uniquement la position haut / droite, mais vérifie également la saisie en arrière (donner vers le bas / gauche)

Économisé beaucoup d'octets grâce à M. Xcoder et Felipe Nardi Batista

JavaScript, 174 octets

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)

Format d'entrée:

• Tableau de tableau d'entiers
• 2 pour F, 1 pour ., 0 pourO

Sortie:

• Valeur de la vérité (1) pour survivre
• Valeur de fausseté (NaN) pour die

Essayez-le:

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

Considérons un automate cellulaire. Il y a 3 états pour une cellule O(accessible par des personnes), F(capture déclenchée), .(rien ne s'est passé). La règle pour créer la prochaine génération est la suivante:

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

Une fois qu'il y a une cellule sur le bord a l' Oétat, les gens survivent. Si cela ne se produisait pas en quantité suffisante, les gens mourraient.

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

Octave, 71 octets

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

Essayez-le en ligne!

ou

Vérifiez tous les cas de test!

Format d'entrée:

• Tableau 2D d'entiers
• 1pour ., 2pour Oet 3pourF

Sortie:

• true et false

Explication:

Explication:

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

Rétine , 243 octets

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

Essayez-le en ligne! Requiert que l’arrière-plan soit constitué d’espaces plutôt que de .s (ou tout autre caractère sûr pour les expressions rationnelles pourrait être utilisé). Explication:

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

S'il y a un Obord, effacez tout le reste (cas de survie)

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

Placez un #dans n'importe quel espace au-dessus d'un existant O.

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

Et #dans n'importe quel espace en dessous d'un existant O.

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

Changez le #s en Os, ainsi que tout espace à gauche ou à droite d'un existant O.

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

Placez #s au-dessus de tout Fart existant . Ceux-ci peuvent écraser Os ainsi que des espaces.

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

Placez #les sous tous les Fs existants , écrasez- Oles aussi bien que les espaces.

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

Changez le #s en Fs, ainsi que n'importe quel Oou l'espace à gauche ou à droite d'un existant F. Répétez jusqu'à ce que les Fs ont tout consommé.

O

Revenir 1pour la survie, 0sinon.