Tuyên bố miễn trừ trách nhiệm: Câu chuyện được kể trong câu hỏi này hoàn toàn hư cấu và được phát minh chỉ nhằm mục đích cung cấp phần giới thiệu.

Tôi là một nông dân độc ác và để tăng giá lúa mì trong khu vực của mình, tôi đã quyết định đốt cháy những cánh đồng của tất cả những người nông dân xung quanh tôi. Tôi thực sự muốn thấy những cánh đồng bốc cháy (vì vậy tôi có thể sử dụng tiếng cười xấu xa của mình và xoa tay với nhau), nhưng tôi cũng không muốn bị bắt gặp, vì vậy tôi cần bạn mô phỏng cánh đồng thiêu hủy cho tôi.

Nhiệm vụ của bạn:

Viết chương trình hoặc hàm lấy đầu vào của một trường và trả về các giai đoạn của nó đang cháy cho đến khi toàn bộ trường bị tro. Một phần cụ thể của trường đang cháy được biểu thị bằng một số nguyên biểu thị cường độ của ngọn lửa. Một đám cháy bắt đầu từ "1" và chuyển sang "2" và sau đó là "3", v.v. Khi đám cháy đạt đến "4", nó sẽ bắt được bất kỳ khu vực lân cận nào (không theo đường chéo) dễ cháy trên lửa. Khi nó đạt đến "8", nó sẽ cháy ở lần lặp tiếp theo và biến thành tro, được biểu thị bằng chữ "A". Khi một khu vực chưa được chạm vào lửa, nó được biểu thị bằng "0". Ví dụ: nếu trường trông như thế này:

100
000

Chương trình của bạn sẽ xuất ra điều này:

100
000

200
000

300
000

410
100

520
200

630
300

741
410

852
520

A63
630

A74
741

A85
852

AA6
A63

AA7
A74

AA8
A85

AAA
AA6

AAA
AA7

AAA
AA8

AAA
AAA

Nếu bạn muốn, bạn có thể thay thế các biểu tượng trên bằng bất kỳ biểu tượng nào bạn chọn, miễn là chúng nhất quán và khác biệt với nhau.

Đầu vào:

Vị trí bắt đầu của trường, dưới bất kỳ hình thức tiêu chuẩn nào, chẳng hạn như một chuỗi được phân định mới như trên.

Đầu ra:

Trường trong mỗi lần lặp khi nó ghi, dưới dạng một mảng hoặc dưới dạng một chuỗi được giới hạn bởi một số ký tự.

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

0301
000A
555
 |
 v
0301
000A
555

1412
010A
666

2523
020A
777

3634
030A
888

4745
141A
AAA

5856
252A
AAA

6A67
363A
AAA

7A78
474A
AAA

8A8A
585A
AAA

AAAA
6A6A
AAA

AAAA
7A7A
AAA

AAAA
8A8A
AAA

AAAA
AAAA
AAA

Ghi điểm:

Đây là môn đánh gôn , điểm số thấp nhất tính bằng byte!

APL (Dyalog) , 52 byte *

Giả sử ⎕IO←0đó là mặc định trên nhiều hệ thống. Lấy trường bằng 0 cho các ô trống, 1 cho trường không cháy, 2 cho lửa mới, 5 cho lửa lan rộng và 10 cho tro. Đầu vào phải có ít nhất 3 × 3, đây không phải là vấn đề vì các hàng và cột bổ sung có thể được đệm bằng số không (khoảng trắng ở định dạng của OP).

{}{1=c←4⊃r←,⍵:1+4∊r/⍨9⍴⍳2⋄10⌊c+×c}⌺3 3⍣{⍺≡⎕←⍵}

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

Định dạng của tôi khiến bạn khó kiểm tra tính chính xác, vì vậy đây là phiên bản có thêm tiền xử lý và hậu xử lý để dịch từ và sang định dạng của OP.

⍣{... } lặp lại cho đến khi:

 ⍺ thế hệ tiếp theo

 ≡ giống hệt với

 ⎕←⍵ thế hệ hiện tại, xuất ra

{... }⌺3 3 thay thế mỗi tế bào với kết quả của chức năng này áp dụng cho khu phố Moore của nó:

 ,⍵ ravel (flatten) các đối số; đưa ra danh sách chín yếu tố

 r← gán cho r

 4⊃ chọn phần tử thứ tư; trung tâm, tức là giá trị ô ban đầu

 c← gán cho c

 1= là một bằng với điều đó?

 : nếu vậy, thì:

  ⍳2 đầu tiên cho ɩ ntegers; 0 1

  9⍴ r eshape đến chiều dài chín; 0 1 0 1 0 1 0 1 0

  r/⍨ sử dụng để lọc r (điều này chỉ là hàng xóm trực giao)

  4∊ là bốn thành viên của điều đó? (tức là sẽ có năm trong thế hệ tiếp theo?)

  1+ cộng một; 1 nếu không bắt lửa hoặc 2 nếu bắt lửa

 ⋄ khác (tức là giá trị hiện tại là 0 hoặc ≥ 2)

  ×c dấu hiệu của c

  c+ c cộng với đó (tức là tăng thêm một nếu cháy)

  10⌊ tối thiểu là mười và điều đó (vì tro không cháy)

* Trong Dyalog Classic, sử dụng ⎕U233A thay vì ⌺.

Python 3 , 232 byte

def f(j):
 k=[[int(min(9,j[x][y]+(j[x][y]>0)or 3in(lambda k,x,y:[k[i][j]for i,j in[[x-1,y],[x+1,y],[x,y-1],[x,y+1]]if(-1<i<len(k))and(-1<j<len(k[i]))])(j,x,y)))for y in range(len(j[x]))]for x in range(len(j))]
 if k!=j:print(k);f(k)

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

-3 byte nhờ chính thức bằng cách hợp nhất lambda khác vào f(trông có vẻ lộn xộn nhưng tiết kiệm byte và đó là tất cả những gì chúng tôi quan tâm)
-8 byte nhờ ông Xoder
-26 byte nhờ vào ovs
-6 byte nhờ ppperry

JavaScript (ES6), 217 210 207 204 193 192 190 byte

Đã lưu 2 byte nhờ đề xuất sử dụng 9as của Shaggy A.

f=F=>[F,...(t=[],y=0,g=x=>(r=F[y])?(x||(t[y]=[]),r[x]+1)?(t[y][x]=r[x]<8?r[x]+(r[x]>0|[r[x-1],r[x+1],F[y-1]&&F[y-1][x],F[y+1]&&F[y+1][x]].includes(3)):9,g(x+1)):g(0,y++):t)(0)+""!=F?f(t):[]]

// test code
test=s=>{
  var test = document.querySelector("#in").value.split`\n`.map(e => Array.from(e).map(e => parseInt(e)));
  var out = f(test);
  document.querySelector("#out").innerHTML = out.map(e => e.map(e => e.join``).join`\n`).join`\n\n`;
};window.addEventListener("load",test);

<textarea id="in" oninput="test()">0301&#10;0009&#10;555</textarea><pre id="out"></pre>

Sử dụng 9thay vì A. Nhập dưới dạng mảng 2D của số nguyên. Đầu ra như một mảng của các mảng như vậy.

Mô phỏng thế giới (trong biểu tượng cảm xúc) , 1407 byte?

Bạn không thích sử dụng một lời giải thích thú vị như một ngôn ngữ lập trình? Nhược điểm của điều này thường không phải là một chương trình được xác định rõ ràng, vì vậy trong trường hợp này, tôi đang sử dụng JSON mà nó xuất ra. (nếu bạn có ý tưởng nào hay hơn, hãy cho tôi biết)

{"meta":{"description":"","draw":1,"fps":1,"play":true},"states":[{"id":0,"icon":"0","name":"","actions":[{"sign":">=","num":1,"stateID":"4","actions":[{"stateID":"1","type":"go_to_state"}],"type":"if_neighbor"}],"description":""},{"id":1,"icon":"1","name":"","description":"","actions":[{"stateID":"2","type":"go_to_state"}]},{"id":2,"icon":"2","name":"","description":"","actions":[{"stateID":"3","type":"go_to_state"}]},{"id":3,"icon":"3","name":"","description":"","actions":[{"stateID":"4","type":"go_to_state"}]},{"id":4,"icon":"4","name":"","description":"","actions":[{"stateID":"5","type":"go_to_state"}]},{"id":5,"icon":"5","name":"","description":"","actions":[{"stateID":"6","type":"go_to_state"}]},{"id":6,"icon":"6","name":"","description":"","actions":[{"stateID":"7","type":"go_to_state"}]},{"id":7,"icon":"7","name":"","description":"","actions":[{"stateID":"8","type":"go_to_state"}]},{"id":8,"icon":"8","name":"","description":"","actions":[{"stateID":"9","type":"go_to_state"}]},{"id":9,"icon":"A","name":"","description":"","actions":[]}],"world":{"update":"simultaneous","neighborhood":"neumann","proportions":[{"stateID":0,"parts":100},{"stateID":1,"parts":0},{"stateID":2,"parts":0},{"stateID":3,"parts":0},{"stateID":4,"parts":0},{"stateID":5,"parts":0},{"stateID":6,"parts":0},{"stateID":7,"parts":0},{"stateID":8,"parts":0},{"stateID":9,"parts":0}],"size":{"width":9,"height":9}}}

Hãy thử nó ở đây hoặc ở đây:

<iframe width="100%" height="450" src="http://ncase.me/simulating/model/?remote=-Kr2X939XcFwKAunEaMK" frameborder="0"></iframe>

Võng mạc , 103 96 88 byte

^
¶
;{:`

T`0d`d
(?<=¶(.)*)0(?=4|.*¶(?<-1>.)*(?(1)_)4|(?<=40|¶(?(1)_)(?<-1>.)*4.*¶.*))
1

Hãy thử trực tuyến! Sử dụng 9cho tro; điều này có thể được thay đổi với chi phí 4 byte bằng cách sử dụng T`1-8`2-8A. Chỉnh sửa: Đã lưu 6 byte nhờ @MartinEnder. Giải trình:

^
¶

Thêm một dấu phân cách để các đầu ra không chạy vào nhau. (Cũng giúp khi kết hợp bên dưới.)

;{:`

Không in trạng thái cuối cùng (giống như trạng thái trước đó đã được in). Lặp lại cho đến khi vượt qua không thay đổi trạng thái. In trạng thái hiện tại trước mỗi lần vượt qua.

T`0d`d

Nâng cao cường độ của tất cả các ngọn lửa.

(?<=¶(.)*)0(?=4|.*¶(?<-1>.)*(?(1)_)4|(?<=40|¶(?(1)_)(?<-1>.)*4.*¶.*))
1

Ánh sáng không ánh sáng trường thích hợp. Giải thích phụ:

(?<=¶(.)*)

Đo số cột của trường không thích hợp này.

0

Phù hợp với trường không thích hợp.

(?=4

Tìm kiếm một lĩnh vực phù hợp ở bên phải.

  |.*¶(?<-1>.)*(?(1)_)4

Tìm kiếm một trường phù hợp trong cùng một cột (sử dụng nhóm cân bằng) trong dòng bên dưới. Lưu ý rằng nếu đầu vào có thể được đảm bảo hình chữ nhật thì điều này có thể được đơn giản hóa để |.*¶(?>(?<-1>.)*)4tiết kiệm 3 byte.

  |(?<=40

Tìm kiếm một lĩnh vực phù hợp ở bên trái. (Vì chúng tôi đang nhìn từ phía bên phải của trường, chúng tôi cũng thấy trường không sáng.)

      |¶(?(1)_)(?<-1>.)*4.*¶.*))

Tìm kiếm một trường phù hợp trong cùng một cột trong dòng trên. Vì đây là giao diện và do đó khớp từ phải sang trái, điều kiện nhóm cân bằng phải xuất hiện trước các cột được khớp bởi nhóm cân bằng.

Perl 5 , 365 byte

@a=map{[/./g]}<>;do{say@$_ for@a;say;my@n=();for$r(0..$#a){$l=$#{$a[$r]};for(0..$l){$t=$a[$r][$_];$n[$r][$_]=($q=$n[$r][$_])>$t?$q:$t==9?9:$t?++$t:0;if($t==4){$n[$r-1][$_]||=1if$r&&$_<$#{$a[$r-1]};$n[$r+1][$_]||=1if$r<$#a&&$_<$#{$a[$r+1]};$n[$r][$_-1]||=1if$_;$n[$r][$_+1]||=1if$_<$l}}}$d=0;for$r(0..$#a){$d||=$a[$r][$_]!=$n[$r++][$_]for 0..$#{$a[$r]}}@a=@n}while$d

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

Sử dụng '9' thay vì 'A' để chỉ vị trí bị cháy.

Giải thích

@a=map{[/./g]}<>;   # split input into a 2-D array

do{
say@$_ for@a;say;   # output the current state
my@n=();            # holds the next iteration as it's created
for$r(0..$#a){      # loop through rows
  $l=$#{$a[$r]};    # holder for the length of this row
  for(0..$l){
    $t=$a[$r][$_];  # temporary holder for current value
    $n[$r][$_]=($q=$n[$r][$_])>$t?$q:$t==9?9:$t?++$t:0; #update next iteration
    if($t==4){      # ignite the surrounding area if appropriate
      $n[$r-1][$_]||=1if$r&&$_<$#{$a[$r-1]};
      $n[$r+1][$_]||=1if$r<$#a&&$_<$#{$a[$r+1]};
      $n[$r][$_-1]||=1if$_;
      $n[$r][$_+1]||=1if$_<$l
    }
  }
}
$d=0;              # determine if this generation is different than the previous
for$r(0..$#a){$d||=$a[$r][$_]!=$n[$r++][$_]for 0..$#{$a[$r]}}
@a=@n              # replace master with new generation
}while$d

Haskell , 162 byte

import Data.List
i x|x<'9'=succ x|1<2=x
f('3':'@':r)="30"++f r
f(x:r)=x:f r
f e=e
a%b=a.b.a.b
g=map(i<$>).(transpose%map(reverse%f))
h x|y<-g x,y/=x=x:h y|1<3=[x]

Hãy thử trực tuyến! Cách sử dụng: hlấy một trường làm danh sách các dòng và trả về danh sách các trường. Một trường không cháy được chỉ định bởi @và tro bởi 9, các đám cháy khác nhau là các chữ số 1để 8.

• fquản lý việc truyền lửa từ trái sang phải bằng cách thay thế tất cả các @trường không cháy bên phải sang 3trường đang cháy 0.
• ităng mỗi chữ số miễn là nó nhỏ hơn 9.
• gáp dụng fcho từng dòng, sau đó đảo ngược dòng, áp dụng fmột lần nữa và đảo ngược trở lại. Sau đó, danh sách các dòng được hoán vị và một lần nữa trên mỗi dòng và đảo ngược của nó fđược áp dụng.
• háp dụng gcho đầu vào cho đến khi nó không còn thay đổi và thu thập kết quả.

C (gcc) , 308 305 299 297 295 291 byte

#define F B[i][v]
m(A,B,k,y,m,U,i,v)char**B;{do{for(i=k=y=0;i<A;puts(""),++i)for(v=0;v<(m=strlen(B[i]));F=(U=F)>48&&F<56?F+1:F>55?65:(i+1<A&&B[i+1][v]==51||v+1<m&&B[i][v+1]==51||v-1>-1&&B[i][v-1]==52||i-1>-1&&B[i-1][v]==52)&&U<49?49:F,putchar(U),k+=U<49||U>64,++y,++v);puts("");}while(k-y);}

Chương trình này định nghĩa một chức năng mà phải mất hai đầu vào, một con trỏ đến một mảng của chuỗi trước bởi chiều dài của nó, như được cho phép bởi này I / O mặc định. Đầu ra cho STDOUT với một dòng mới.

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

Octave, 72 69 byte

a=input(''),do++a(a&a<9);a+=imdilate(a==4,~(z=-1:1)|~z')&~a,until a>8

Đầu vào được lấy dưới dạng một mảng số 2D và các điểm trống được đánh dấu bằng Inf. 'A'đã được thay thế bằng 9. Kết quả trung gian (dưới dạng mảng số) được in ngầm.

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

Giải trình:

Trong một vòng lặp, chức năng imdilate(giãn hình ảnh hình thái) từ gói hình ảnh được sử dụng để mô phỏng việc truyền lửa.

Python 2 , 325 byte

def f(x):
 while{i for m in x for i in m}>{9,''}:
    yield x;i=0
    for l in x:
     j=0
     for c in l:
        if 0<c<9:x[i][j]+=1
        j+=1
     i+=1
    i=0
    for l in x:
     j=0
     for c in l:
        if c==0 and{1}&{x[k[1]][k[2]]==4for k in[y for y in[[i,i-1,j],[i<len(x)-1,i+1,j],[j,i,j-1],[j<len(l)-1,i,j+1]]if y[0]]}:x[i][j]+=1
        j+=1
     i+=1
 yield x

f lấy đầu vào là một mảng số nguyên 2D và các điểm trống được đánh dấu bằng '' . 'A'đã được thay thế bằng9 . Hàm này tạo ra một trình tạo của tất cả các trường theo thời gian trong cùng một định dạng.

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

Octave , 212 byte

function r(f)b=48;f-=b;c=-16;l=f~=-c;d=17;p=@(x)disp(char(x+b));g=@()disp(' ');p(f);g();while~all(any(f(:)==[0 d c],2))m=f>0&l;f(m)+=1;k=conv2(f==4,[0 1 0;1 0 1;0 1 0],'same')&~m&l;f(k)+=1;f(f>8&l)=d;p(f);g();end

Để chạy, chỉ định một mảng ký tự, chẳng hạn như:

f = ['0301','000A','555 '];

... sau đó làm:

r(f)

Giải thích về mã để làm theo ...

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

^{Lưu ý: Tôi đã cố chạy mã này với tio.run , nhưng tôi không nhận được bất kỳ đầu ra nào. Tôi đã phải sử dụng một dịch vụ khác.}

PHP, 226 212 210 209 185 177 byte

for($f=file(m);$f!=$g;print"
")for($g=$f,$y=0;$r=$f[$y++];)for($x=-1;~$c=$r[++$x];$f[$y-1][$x]=$c=="0"?strstr($g[$y-2][$x].$r[$x-1].$f[$y][$x].$r[$x+1],51)/3:min(++$c,9))echo$c;

nhận đầu vào với một dòng mới từ một tệp có tên m;9cho tro tàn.

Chạy với -nrhoặc thử trực tuyến .

Cách tiếp cận đầu tiên: PHP 7.0, 209 byte

for($f=$g=file(m);trim(join($f),"A
");print"
".join($f=$g))for($y=-1;(a&$c=$r[++$x])||$r=$f[$y-=$x=-1];)for(+$c&&$g[$y][$x]=++$c<9?$c:A,$a=4;$a--;$q=$p)$c-4|($w=&$g[$y+$p=[1,0,-1][$a]])[$q+=$x]!="0"||$w[$q]=1;

nhận đầu vào với một dòng mới từ một tệp có tên m .

Chạy với -nrhoặc thử trực tuyến .

Ghi chú phiên bản PHP (cho cách tiếp cận cũ)

• đối với PHP cũ hơn 7.0, hãy thay thế mọi thứ sau $c-4|bằng$g[$y+$p=[1,0,-1][$a]][$q+=$x]!="0"||$g[$y+$p][$q]=1;
• đối với PHP cũ hơn 5,5, thay thế [1,0,-1][$a]bằng$a%2*~-($a&2)
• cho PHP mới hơn 7.0, thay thế a&$cbằng ""<$c, +$cbằng 0<$cvà $c-4bằng$c!=4

Octave, 419 312 byte

M=input('') %take a matrix M as input
[a, b]=size(M); %size M for later
while mean(mean(M))!=9 %while the whole matrix M isn't ashes
M=M+round(M.^0.001); %if there is a nonzero int add 1 to it
for i=1:a %loop over all values of M
for j=1:b
if(M(i,j)==4) %if a value of 4 is found, ignite the zeros around it
if(M(max(i-1,1),j)==0) M(i-1,j)++;end
if(M(min(i+1,a),j)==0) M(i+1,j)++;end
if(M(i,max(j-1,1))==0) M(i,j-1)++;end      
if(M(i,min(j+1,b))==0) M(i,j+1)++;end
elseif(M(i,j)==10) M(i,j)--;
end
end
end
M %display the matrix
end

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

Đây là phiên bản của tôi, nó hoạt động, vì vậy bây giờ tôi vẫn cần phải chơi nó. Tôi nghĩ nó có thể ngắn hơn rất nhiều nếu tôi tìm cách tìm các chỉ số của 4 trong một ma trận, nhưng tôi không biết làm thế nào.
PS: A là số 9 trong mã của tôi.

Stt ( ∊-mode) , 22 byte

S≡8:'A'⋄0::S⋄(3∊N)⌈S+s

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

Giống như trong đầu vào kiểm tra, sử dụng các số nguyên cách nhau bởi khoảng trắng cho 0- 8, ' 'để trống và'A' cho A. Nhớ thêm khoảng trống theo dõi quá.