Zainspirowany tym .

tło

Zły rolnik postanowił nagrać pole pszenicy w dół, aby podjechać ceny. Aby zapewnić całkowite zniszczenie, namoczył twoje pole w benzynie. Co więcej, zdarzyło ci się chodzić po polu, gdy było oświetlone ogniem, i musisz szybko wyjść, aby przeżyć.

Wyzwanie

Biorąc pod uwagę pole zawierające pszenicę, ogień i swoją lokalizację, określ, czy możesz zdążyć na czas.

Pole składa się z pszenicy (tutaj reprezentowanej przez .) i ognia ( F). Tutaj Twoja lokalizacja jest oznaczona symbolem O. Na przykład:

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

Co sekundę poruszasz się do sąsiedniej komórki (ale nie po przekątnej), a każdy ogień rozprzestrzenia się na każdą sąsiednią komórkę. Jeśli nie możesz przejść do komórki, która nie będzie w ogniu, umrzesz. Jeśli wydostaniesz się z pola, przeżyjesz. Zobaczmy, co dzieje się w tym przykładzie:

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

Zasady

• Twoje dane wejściowe to pole jako siatka. Możesz wybrać dowolny format wejściowy, w tym ciąg znaków z separatorami linii lub tablicą 2D.
  • Być może nie brać jako wejście lokalizacje dla ognia i / lub siebie.
  • Możesz użyć dowolnych 3 różnych wartości jako pszenicy, ognia i swojej pozycji, w tym nie łańcuchów do wprowadzania danych z tablicy.
  • Pola mają zawsze rozmiar co najmniej 1x1, są prostokątne i nie zawierają niepoprawnych znaków.
  • Każde pole będzie zawierało dokładnie jedną wartość reprezentującą twoją lokalizację, a każda inna pozycja może, ale nie musi, być ogniem.
• Twój wynik jest jedną z dwóch odrębnych wartości dla „przeżywasz” lub „giniesz”, jak zwykle w przypadku problemów decyzyjnych .
• Obowiązują standardowe zasady gry w golfa .

Przypadki testowe

Przetrwał

O

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

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

FFFF
FFFO
FFFF

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

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

Nie przeżył

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

Ślimaki, 15 bajtów

\Oo!{.,fee7.,\F

Wypróbuj online!

1oznacza przetrwanie, a 0śmierć.

Ponieważ nie można uciec przed ogniem, nigdy nie warto go ominąć. Najlepsza trasa to zawsze linia prosta. Istnieją więc tylko cztery możliwe opcje drogi ucieczki. Aby ustalić, czy kierunek jest bezpieczny, sprawdzamy, czy Fw „stożku ognia” wskazuje ten kierunek.

Python 2 , 283 218 209 208 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe jako ciąg oddzielony znakiem nowej linii i zwraca wartość True/FalsedlaDead/Alive

Działa poprzez sprawdzanie każdego kierunku (udlr) pod kątem Fgniewu, patrząc na zewnątrz:

Przykład:

Wkład:

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

Kontrole przeciwpożarowe:

Up:       Down:     Left:     Right:

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

Jeśli wszystkie kierunki zawierają ogień, umrzesz, w przeciwnym razie nastąpi ucieczka.

Edycja: Wróć do pobierania ciągu jako danych wejściowych, a teraz sprawdza tylko wejście w górę / w prawo, ale także sprawdza wejście do tyłu (zwalnianie / w lewo)

Zaoszczędził dużo bajtów dzięki Panu Xcoder i Felipe Nardi Batista

JavaScript, 174 bajty

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 wejściowy:

• Array of Array of Integers
• 2 dla F, 1 dla ., 0 dlaO

Wydajność:

• Prawdziwa wartość (1) dla przeżycia
• Wartość Falsy (NaN) dla matrycy

Spróbuj:

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

Rozważ automat komórkowy. Istnieją 3 stany dla komórki O(osiągalne przez ludzi), F(catch fired), .(nic się nie wydarzyło). Reguła tworzenia następnej generacji to:

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

Kiedy komórka na krawędzi ma Ostan, ludzie przeżyją. Jeśli nie wydarzy się to w wystarczającej ilości, ludzie umrą.

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

Oktawa, 71 bajtów

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

Wypróbuj online!

lub

Sprawdź wszystkie przypadki testowe!

Format wejściowy:

• Tablica liczb całkowitych 2D
• 1za ., 2za Oi 3zaF

Wydajność:

• true i false

Wyjaśnienie:

Wyjaśnienie:

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

Siatkówka , 243 bajty

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

Wypróbuj online! Wymaga, aby w tle były spacje zamiast .s (lub można użyć innej bezpiecznej dla wyrażeń regularnych postaci). Wyjaśnienie:

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

Jeśli jest Ojakaś krawędź, usuń wszystko inne (przypadek przetrwania)

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

Umieść a #w dowolnym miejscu nad istniejącym O.

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

I #w dowolnym miejscu poniżej istniejącego O.

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

Zmień #s na Os, a także dowolne miejsce po lewej lub prawej stronie istniejącego O.

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

Umieść #s nad istniejącymi F. Mogą one zastępować zarówno znaki Os, jak i spacje.

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

Umieść #s pod wszelkimi istniejącymi F, nadpisując Orównież spacje.

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

Zmień #s na Fs, a także dowolną Ospację po lewej lub prawej stronie istniejącej F. Powtarzaj, aż Fs pochłoną wszystko.

O

Wróć 1po przetrwanie, 0jeśli nie.