Uwaga: Historia opowiedziana w tym pytaniu jest całkowicie fikcyjna i wymyślona wyłącznie w celu wprowadzenia wstępu.

Jestem złym rolnikiem i aby podnieść cenę pszenicy w mojej okolicy, postanowiłem spalić pola wszystkich rolników wokół mnie. Naprawdę chciałbym zobaczyć, jak pola wybuchają w płomieniach (abym mógł użyć mojego złego śmiechu i pocierać moje ręce razem z radością), ale nie chcę też być przyłapany na oglądaniu, więc musisz symulować bycie polem spalone dla mnie.

Twoje zadanie:

Napisz program lub funkcję, która pobiera jako dane wejściowe pole i zwraca etapy jego spalania, aż całe pole zostanie popiołem. Określony odcinek płonącego pola jest reprezentowany przez liczbę całkowitą reprezentującą intensywność płomienia. Ogień zaczyna się od „1” i przechodzi do „2”, a następnie „3” i tak dalej. Gdy ogień osiągnie „4”, łapie wszelkie bezpośrednio (nie po przekątnej) sąsiednie obszary, które są łatwopalne w ogniu. Gdy osiągnie „8”, wypala się podczas następnej iteracji i zamienia się w popiół, reprezentowany przez „A”. Gdy obszar nie został jeszcze dotknięty przez ogień, jest reprezentowany przez „0”. Na przykład, jeśli pole wygląda tak:

100
000

Twój program powinien wypisać to:

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

Jeśli chcesz, możesz zastąpić powyższe symbole dowolnym wybranym przez siebie zestawem symboli, o ile są one spójne i różnią się od siebie.

Wkład:

Pozycja początkowa pola, w dowolnej standardowej formie, na przykład ciąg znaków rozdzielany znakami jak wyżej.

Wydajność:

Pole w każdej iteracji podczas spalania, albo jako tablica, albo jako ciąg ograniczony przez jakiś znak.

Przypadki testowe:

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

Punktacja:

To jest golf golfowy , najniższy wynik w bajtach wygrywa!

APL (Dyalog) , 52 bajty *

Zakłada, że ⎕IO←0jest to domyślne w wielu systemach. Zajmuje pole za pomocą 0 dla pustych miejsc, 1 dla niepalnego pola, 2 dla nowego ognia, 5 dla rozprzestrzeniania ognia i 10 dla popiołu. Dane wejściowe muszą mieć co najmniej 3 × 3, co nie stanowi problemu, ponieważ dodatkowe wiersze i kolumny można uzupełnić zerami (spacje w formacie OP).

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

Wypróbuj online!

Mój format utrudnia sprawdzenie poprawności, więc oto wersja z dodanym przetwarzaniem wstępnym i końcowym do tłumaczenia z formatu OP i na format OP.

⍣{… } Powtarzaj do:

 ⍺ następne pokolenie

 ≡ jest identyczny z

 ⎕←⍵ obecna generacja, wyprowadzona

{… }⌺3 3 Zastąp każdą komórkę wynikiem tej funkcji zastosowanym w jej sąsiedztwie Moore:

 ,⍵ ravel (spłaszcz) argument; daje listę dziewięciu elementów

 r← przypisać do r

 4⊃ wybierz czwarty element; środek, tj. oryginalna wartość komórki

 c← przypisać do c

 1= czy jeden jest równy?

 : jeśli tak, to:

  ⍳2 najpierw do t ntegers; 0 1

  9⍴ R eshape długości dziewięciu; 0 1 0 1 0 1 0 1 0

  r/⍨ użyj tego do filtrowania r (to dostaje tylko ortogonalnych sąsiadów)

  4∊ czy czwórka jest tego członkiem? (tj. czy będzie ich pięć w następnym pokoleniu?)

  1+ Dodaj jeden; 1, jeśli się nie zapali lub 2, jeśli się zapali

 ⋄ else (tj. bieżąca wartość wynosi 0 lub ≥ 2)

  ×c podpis ok

  c+ c plus to (tj. zwiększyć o jeden, jeśli się pali)

  10⌊ co najmniej dziesięć i to (ponieważ popiół się nie pali)

* W Dyalog Classic, używając ⎕U233A zamiast ⌺.

Python 3 , 232 bajty

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)

Wypróbuj online!

-3 bajty dzięki Officialaimm poprzez połączenie drugiej lambdy w f(wygląda bałagan, ale oszczędza bajty i to wszystko, na czym nam zależy)
-8 bajtów dzięki Mr. Xoder
-26 bajtów dzięki ovs
-6 bajtów dzięki ppperry

JavaScript (ES6), 217 210 207 204 193 192 190 bajtów

Zaoszczędzono 2 bajty dzięki sugestii @ Shaggy o użyciu 9as 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>

Używa 9zamiast A. Dane wejściowe jako tablica liczb całkowitych 2D. Dane wyjściowe jako tablica takich tablic.

Symulowanie świata (w emoji) , 1407 bajtów?

Czy nie lubisz używać wyjaśnień jako języka programowania? Wadą tego jest to, że zwykle nie jest bardzo dobrze zdefiniowany program, więc w tym przypadku używam eksportowanego JSON. (jeśli masz jakieś lepsze pomysły, daj mi znać)

{"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}}}

Wypróbuj tutaj lub tutaj:

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

Siatkówka , 103 96 88 bajtów

^
¶
;{:`

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

Wypróbuj online! Zastosowania 9dla popiołu; można to zmienić przy użyciu 4 bajtów T`1-8`2-8A. Edycja: Zapisano 6 bajtów dzięki @MartinEnder. Wyjaśnienie:

^
¶

Dodaj separator, aby wyjścia nie wpadały na siebie. (Pomaga również przy dopasowywaniu poniżej.)

;{:`

Nie drukuj stanu końcowego (który jest taki sam jak poprzedni stan, który został już wydrukowany). Powtarzaj, aż przebieg nie zmieni stanu. Drukuj bieżący stan przed każdym przejściem.

T`0d`d

Zwiększ intensywność całego ognia.

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

Oświetl odpowiednio nieoświetlone pola. Wyjaśnienie:

(?<=¶(.)*)

Zmierz numer kolumny tego nieoświetlonego pola.

0

Dopasuj nieoświetlone pole.

(?=4

Poszukaj odpowiedniego pola po prawej stronie.

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

Poszukaj odpowiedniego pola w tej samej kolumnie (przy użyciu grupy bilansującej) w poniższym wierszu. Zauważ, że jeśli wejście może być zagwarantowane jako prostokątne, można to uprościć w |.*¶(?>(?<-1>.)*)4celu zaoszczędzenia 3 bajtów.

  |(?<=40

Poszukaj odpowiedniego pola po lewej stronie. (Ponieważ patrzymy z prawej strony pola, widzimy również pole nieoświetlone).

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

Poszukaj odpowiedniego pola w tej samej kolumnie w wierszu powyżej. Ponieważ jest to wygląd zewnętrzny, a zatem dopasowanie od prawej do lewej, warunek grupy równoważącej musi pojawić się przed kolumnami, które zostały dopasowane przez grupę równoważącą.

Perl 5 , 365 bajtów

@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

Wypróbuj online!

Używa „9” zamiast „A”, aby wskazać wypaloną lokalizację.

Wyjaśnił

@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 bajty

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]

Wypróbuj online! Użycie: hpobiera pole jako listę linii i zwraca listę pól. Pole jest wskazany przez niespalone @i popiół przez 9, różne pożary są cyfry 1do 8.

• fzarządza rozprzestrzenianiem się ognia od lewej do prawej, zastępując wszystkie niespalone @pola, które są odpowiednie do płonącego 3pola 0.
• i zwiększa każdą cyfrę, o ile jest mniejsza niż 9 .
• gstosuje się fdo każdej linii, a następnie cofa linię, stosuje się fponownie i cofa. Następnie lista linii jest transponowana i ponownie na każdej linii i na jej odwrocief stosowana jest .
• hstosuje gsię do danych wejściowych, dopóki nie zmieni się i nie zbierze wyników.

C (gcc) , 308 305 299 297 295 291 bajtów

#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);}

Ten program definiuje funkcję, która pobiera dwa dane wejściowe, wskaźnik do tablicy ciągów poprzedzonych jej długością, co jest dozwolone przez to domyślne ustawienie We / Wy. Dane wyjściowe do STDOUT z końcowym znakiem nowej linii.

Wypróbuj online!

Oktawa, 72 69 bajtów

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

Dane wejściowe są traktowane jako tablica liczb 2D i puste miejsca oznaczone Inf. 'A'został zastąpiony przez 9. Wyniki pośrednie (jako tablica liczb) niejawnie wydrukowane.

Wypróbuj online!

Wyjaśnienie:

W pętli funkcja imdilate(morfologiczne rozszerzenie obrazu) z pakietu obrazu służy do symulacji rozprzestrzeniania się ognia.

Python 2 , 325 bajtów

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

fprzyjmuje dane wejściowe jako tablicę liczb całkowitych 2D i puste miejsca oznaczone ''. 'A'został zastąpiony przez 9. Funkcja generuje generator wszystkich pól w czasie w tym samym formacie.

Wypróbuj online!

Oktawa , 212 bajtów

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

Aby uruchomić, określ tablicę znaków, taką jak:

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

... następnie wykonaj:

r(f)

Objaśnienie kodu do naśladowania ...

Wypróbuj online!

^{Note: I tried to run this code with tio.run, but I wasn't getting any output. I had to use another service.}

PHP, 226 212 210 209 185 177 bytes

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;

takes input with a trailing newline from a file named m; 9 for ashes.

Run with -nr or try it online.

first approach: PHP 7.0, 209 bytes

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;

takes input with a trailing newline from a file named m.

Run with -nr or try it online.

PHP version notes (for old approach)

• for PHP older than 7.0, replace everything after $c-4| with $g[$y+$p=[1,0,-1][$a]][$q+=$x]!="0"||$g[$y+$p][$q]=1;
• for PHP older than 5.5, replace [1,0,-1][$a] with $a%2*~-($a&2)
• for PHP newer than 7.0, replace a&$c with ""<$c, +$c with 0<$c and $c-4 with $c!=4

Octave, 419 312 bytes

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

Try it online!

This is my version it works, so now I still need to golf it. I think it can be a lot shorter if I find a way to find the indices of the 4 in a matrix, but I don't know how.
PS: A is a 9 in my code.

Stencil (∊-mode), 22 bytes

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

Try it online!

Just like in the test input, use integers separated by spaces for 0-8, ' ' for blank and 'A' for A. Remember to add trailing blanks too.