Davon inspiriert .

Hintergrund

Der böse Bauer hat beschlossen, Ihr Weizenfeld niederzubrennen, um die Preise anzuheben. Um eine vollständige Zerstörung zu gewährleisten, hat er Ihr Feld auch mit Benzin angefeuchtet. Noch bedauerlicher ist, dass du zufällig auf dem Feld gelaufen bist, als es angezündet wurde, und du musst schnell raus, um zu überleben.

Herausforderung

Bestimmen Sie bei einem Feld mit Weizen, Feuer und Ihrem Standort, ob Sie das Feld rechtzeitig verlassen können.

Ein Feld besteht aus Weizen (hier dargestellt durch .) und Feuer ( F). Hier ist Ihr Standort mit einem gekennzeichnet O. Beispielsweise:

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

Jede Sekunde bewegt man sich zu einer benachbarten Zelle (aber nicht diagonal) und jedes Feuer breitet sich auf jede benachbarte Zelle aus. Wenn Sie sich nicht in eine Zelle begeben können, die nicht in Flammen steht, sterben Sie. Wenn Sie es außerhalb des Feldes schaffen, überleben Sie. Mal sehen, was in diesem Beispiel passiert:

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

Regeln

• Ihre Eingabe ist das Feld als Gitter. Sie können ein beliebiges Eingabeformat auswählen, einschließlich einer Zeichenfolge mit Zeilentrennzeichen oder eines 2D-Arrays.
  • Sie dürfen die Feuerstellen und / oder sich selbst nicht als Eingabe nehmen.
  • Sie können 3 verschiedene Werte als Weizen, Feuer und Ihre Position verwenden, einschließlich Nicht-Zeichenfolgen für die Array-Eingabe.
  • Felder sind immer mindestens 1x1 groß, rechteckig und enthalten keine ungültigen Zeichen.
  • Jedes Feld enthält genau einen Wert, der Ihren Standort darstellt, und jede andere Position kann ausgelöst werden oder nicht.
• Ihre Ausgabe ist einer von zwei unterschiedlichen Werten für "Sie überleben" oder "Sie sterben", wie bei Entscheidungsproblemen üblich .
• Es gelten die Standardregeln für Code-Golf .

Testfälle

Überlebt

O

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

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

FFFF
FFFO
FFFF

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

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

Nicht überlebt

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

Schnecken, 15 Bytes

\Oo!{.,fee7.,\F

Probieren Sie es online!

1bedeutet Überleben, während 0Tod bedeutet.

Da es unmöglich ist, dem Feuer zu entkommen, ist es niemals nützlich, zu versuchen, es zu umgehen. Die beste Route ist immer eine gerade Linie. Es gibt also nur vier mögliche Fluchtwege. Um festzustellen, ob eine Richtung sicher ist, prüfen wir, ob Fder "Feuerkegel" in diese Richtung zeigt.

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

Probieren Sie es online!

Nimmt Eingaben als durch Zeilenumbrüche getrennte Zeichenfolge und gibt True/Falsefür zurückDead/Alive

Überprüfen Sie jede Richtung (udlr) auf FZorn, indem Sie nach außen schauen:

Beispiel:

Eingang:

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

Feuerkontrollen:

Up:       Down:     Left:     Right:

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

Wenn alle Richtungen Feuer enthalten, stirbt man, sonst gibt es eine Flucht.

Bearbeiten: Zurück zum Aufnehmen eines Strings als Eingabe, und jetzt wird nur nach oben / rechts gesucht, aber die Eingabe wird auch rückwärts geprüft (nach unten / links).

Dank Mr. Xcoder und Felipe Nardi Batista konnten viele Bytes gespart werden

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)

Eingabeformat:

• Array von Array von Ganzzahlen
• 2 für F, 1 für ., 0 fürO

Ausgabe:

• Wahrheitswert (1) für das Überleben
• Falscher Wert (NaN) für die

Versuch es:

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

Betrachten Sie einen zellularen Automaten. Es gibt 3 Zustände für eine Zelle O(für Menschen erreichbar), F(gefeuert), .(nichts ist gerade passiert). Die Regel für die Erstellung der nächsten Generation lautet:

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

Sobald eine Zelle am Rand einen OZustand hat, überleben die Menschen. Wenn dies nicht in ausreichender Menge geschah, starben die Menschen.

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

Oktave, 71 Bytes

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

Probieren Sie es online!

oder

Überprüfen Sie alle Testfälle!

Eingabeformat:

• 2D-Array von Ganzzahlen
• 1für ., 2für Ound 3fürF

Ausgabe:

• true und false

Erläuterung:

Erläuterung:

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

Probieren Sie es online! Erfordert, dass der Hintergrund Leerzeichen anstelle von .s enthält (oder ein anderes regexp-sicheres Zeichen verwendet werden kann). Erläuterung:

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

Wenn es eine OKante gibt, löschen Sie alles andere (Überlebensfall)

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

Platzieren Sie a #an einer beliebigen Stelle über einem vorhandenen O.

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

Und ein #in jedem Raum unterhalb eines Bestehenden O.

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

Ändern Sie das #s in Os und auch einen beliebigen Bereich links oder rechts von einem vorhandenen O.

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

Platzieren Sie #s über allen vorhandenen Fs. Diese können sowohl Os als auch Leerzeichen überschreiben .

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

Platzieren Sie #s unter vorhandenen Fs, überschreiben Sie auch Os und Leerzeichen.

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

Ändern Sie das #s in Fs und auch ein beliebiges Ooder Leerzeichen links oder rechts von einem vorhandenen F. Wiederholen, bis die Fs alles verbraucht haben.

O

Wenn nicht, kehre zurück, 1um zu überleben 0.