Lấy cảm hứng từ điều này .

Lý lịch

Người nông dân độc ác đã quyết định đốt cháy cánh đồng lúa mì của bạn để đẩy giá lên cao. Để đảm bảo sự hủy diệt hoàn toàn, anh ta cũng đã ngâm cánh đồng của bạn vào xăng. Đáng tiếc hơn nữa, bạn tình cờ đi trên cánh đồng khi nó được thắp lên, và bạn phải nhanh chóng thoát ra để sống sót.

Thử thách

Đưa ra một lĩnh vực có chứa lúa mì, lửa và vị trí của bạn, xác định xem bạn có thể đưa nó ra khỏi trường kịp thời hay không.

Một lĩnh vực bao gồm lúa mì (ở đây đại diện bởi .) và lửa ( F). Ở đây vị trí của bạn được đánh dấu bằng một O. Ví dụ:

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

Mỗi giây bạn di chuyển đến bất kỳ ô liền kề nào (nhưng không theo đường chéo) và mọi đám cháy lan sang mọi ô liền kề. Nếu bạn không thể di chuyển đến một tế bào sẽ không bốc cháy, bạn sẽ chết. Nếu bạn làm cho nó ra khỏi lĩnh vực, bạn tồn tại. Hãy xem điều gì xảy ra trong ví dụ này:

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

Quy tắc

• Đầu vào của bạn là trường dưới dạng lưới. Bạn có thể chọn bất kỳ định dạng đầu vào, bao gồm một chuỗi có dấu phân cách dòng hoặc mảng 2D.
  • Bạn không được chọn làm đầu vào cho các vị trí để chữa cháy và / hoặc chính mình.
  • Bạn có thể sử dụng bất kỳ 3 giá trị riêng biệt nào như lúa mì, lửa và vị trí của bạn, bao gồm cả các chuỗi không cho đầu vào mảng.
  • Các trường luôn có kích thước tối thiểu 1x1, hình chữ nhật và không chứa các ký tự không hợp lệ.
  • Bất kỳ trường nào cũng sẽ chứa chính xác một trong các giá trị đại diện cho vị trí của bạn và mọi vị trí khác có thể hoặc không thể cháy.
• Đầu ra của bạn là một trong hai giá trị riêng biệt cho "bạn sống sót" hoặc "bạn chết", như thường lệ trong vấn đề quyết định .
• Luật golf tiêu chuẩn được áp dụng.

Các trường hợp thử nghiệm

Sống sót

O

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

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

FFFF
FFFO
FFFF

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

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

Không tồn tại

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

Ốc, 15 byte

\Oo!{.,fee7.,\F

Hãy thử trực tuyến!

1có nghĩa là sống sót trong khi 0có nghĩa là chết.

Vì không thể vượt qua ngọn lửa, nên không bao giờ có ích khi cố gắng đi xung quanh nó. Con đường tốt nhất luôn luôn là một đường thẳng. Vì vậy, chỉ có bốn lựa chọn có thể của lối thoát. Để xác định xem một hướng có an toàn không, chúng tôi kiểm tra xem có bất kỳ F"hình nón lửa" nào chỉ theo hướng đó không.

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

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng một chuỗi mới được phân tách và trả về True/FalsechoDead/Alive

Hoạt động bằng cách kiểm tra từng hướng (udlr) cho Fire bằng cách nhìn ra ngoài:

Thí dụ:

Đầu vào:

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

Kiểm tra hỏa hoạn:

Up:       Down:     Left:     Right:

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

Nếu tất cả các hướng chứa lửa bạn chết, nếu không thì có một lối thoát.

Chỉnh sửa: Quay lại lấy một chuỗi làm đầu vào và bây giờ chỉ kiểm tra lên / phải, nhưng cũng kiểm tra đầu vào ngược (đưa xuống / trái)

Đã tiết kiệm rất nhiều byte nhờ có ông Xcoder và 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)

Định dạng đầu vào:

• Mảng mảng số nguyên
• 2 cho F, 1 cho ., 0 choO

Đầu ra:

• Giá trị thật (1) để tồn tại
• Giá trị giả (NaN) cho chết

Thử nó:

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

Hãy xem xét một máy tự động di động. Có 3 trạng thái cho một tế bào O(có thể tiếp cận được bởi mọi người), F(bị đuổi việc), .(không có gì vừa xảy ra). Quy tắc tạo thế hệ tiếp theo là:

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

Một khi có một tế bào ở rìa có Otrạng thái, người dân sống sót. Nếu điều này không xảy ra với số lượng đủ thế hệ, thì người dân đã chết.

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

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

Hãy thử trực tuyến!

hoặc là

Xác nhận tất cả các trường hợp thử nghiệm!

Định dạng đầu vào:

• Mảng 2D của số nguyên
• 1cho ., 2cho Ovà 3choF

Đầu ra:

• true và false

Giải trình:

Giải trình:

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

Võng mạc , 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

Hãy thử trực tuyến! Yêu cầu nền phải là khoảng trắng thay vì .s (hoặc một số ký tự an toàn regrec khác có thể được sử dụng). Giải trình:

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

Nếu có một Ocạnh nào, hãy xóa mọi thứ khác (trường hợp sống sót)

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

Đặt một #trong bất kỳ không gian trên một hiện có O.

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

Và #trong bất kỳ không gian dưới một hiện có O.

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

Thay đổi #s thành Os, và bất kỳ khoảng trắng nào ở bên trái hoặc bên phải của một cái hiện có O.

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

Đặt #s trên bất kỳ Fs hiện có . Chúng có thể ghi đè lên Os cũng như khoảng trắng.

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

Đặt #s bên dưới bất kỳ Fs hiện có , cũng ghi đè Os cũng như khoảng trắng.

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

Thay đổi #s thành Fs, và bất kỳ Ohoặc khoảng trắng ở bên trái hoặc bên phải của một cái hiện có F. Lặp lại cho đến khi Fs đã tiêu thụ mọi thứ.

O

Trả lại 1cho sự sống còn, 0nếu không.