Haftungsausschluss: Die Geschichte, die in dieser Frage erzählt wird, ist vollständig fiktiv und wurde ausschließlich zum Zweck der Bereitstellung eines Intro erfunden.

Ich bin ein böser Bauer, und um die Weizenpreise in meiner Gegend zu vertreiben, habe ich beschlossen, die Felder aller Bauern um mich herum zu verbrennen. Ich würde wirklich gerne sehen, wie die Felder in Flammen aufgehen (damit ich mein böses Lachen gebrauchen und meine Hände vor Freude reiben kann), aber ich möchte auch nicht beim Zuschauen erwischt werden, also musst du das Feldwesen simulieren für mich verbrannt.

Deine Aufgabe:

Schreiben Sie ein Programm oder eine Funktion, die als Eingabe ein Feld verwendet und die Phasen des Brennens zurückgibt, bis das gesamte Feld Asche ist. Ein bestimmter Abschnitt des brennenden Feldes wird durch eine ganze Zahl dargestellt, die die Intensität der Flamme darstellt. Ein Feuer beginnt bei "1" und geht weiter zu "2" und dann zu "3" und so weiter. Sobald ein Feuer "4" erreicht, erfasst es alle direkt (nicht diagonal) angrenzenden Bereiche, die im Feuer brennbar sind. Sobald es "8" erreicht, brennt es bei der nächsten Iteration aus und verwandelt sich in Asche, dargestellt durch ein "A". Wenn ein Bereich noch nicht vom Feuer berührt wurde, wird er durch eine "0" dargestellt. Wenn das Feld beispielsweise so aussieht:

100
000

Ihr Programm sollte dies ausgeben:

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

Wenn Sie möchten, können Sie die obigen Symbole durch einen beliebigen Satz von Symbolen ersetzen, sofern diese konsistent und voneinander verschieden sind.

Eingang:

Die Startposition des Felds in einer beliebigen Standardform, z. B. einer Zeichenfolge mit Trennlinie wie oben.

Ausgabe:

Das Feld in jeder Iteration, während es brennt, entweder als Array oder als Zeichenfolge, die von einem Zeichen begrenzt wird.

Testfälle:

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

Wertung:

Dies ist Code-Golf , die niedrigste Punktzahl in Bytes gewinnt!

APL (Dyalog) , 52 Byte *

Nimmt an, ⎕IO←0was auf vielen Systemen Standard ist. Nimmt das Feld mit 0 für leere Felder, 1 für nicht brennendes Feld, 2 für neues Feuer, 5 für ausgebreitetes Feuer und 10 für Asche. Die Eingabe muss mindestens 3 × 3 sein, was kein Problem darstellt, da zusätzliche Zeilen und Spalten mit Nullen (Leerzeichen im OP-Format) aufgefüllt werden können.

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

Probieren Sie es online!

Mein Format macht es schwierig, die Korrektheit zu überprüfen. Hier ist eine Version mit zusätzlicher Vor- und Nachbearbeitung, die vom und zum OP-Format übersetzt werden kann.

⍣{… } Wiederholen bis:

 ⍺ die nächste Generation

 ≡ ist identisch mit

 ⎕←⍵ die aktuelle Generation, ausgegeben

{… }⌺3 3 Ersetzen Sie jede Zelle durch das Ergebnis dieser Funktion, das auf die Umgebung von Moore angewendet wird:

 ,⍵ ravel (platt) das Argument; Gibt eine Liste mit neun Elementen

 r←r  zuweisen

 4⊃ Wähle das vierte Element aus. das Zentrum, dh der ursprüngliche Zellwert

 c← zuweisen c

 1= ist man dem gleich?

 : wenn ja, dann:

  ⍳2 zuerst zu ɩ ntegers; 0 1

  9⍴ r eshape auf Länge neun; 0 1 0 1 0 1 0 1 0

  r/⍨ benutze das um r zu filtern (dies erhält nur die orthogonalen Nachbarn)

  4∊ Ist vier ein Mitglied davon? (Wird es in der nächsten Generation eine Fünf geben?)

  1+ füge eins hinzu; 1, wenn nicht Feuer gefangen oder 2, wenn Feuer gefangen

 ⋄ sonst (dh der aktuelle Wert ist 0 oder ≥ 2)

  ×c das Zeichen von c

  c+ c plus das (dh im Brandfall um eins erhöhen)

  10⌊ mindestens zehn und das (da Asche nicht anbrennt)

* Verwenden Sie in Dyalog Classic ⎕U233A anstelle von ⌺.

Python 3 , 232 Bytes

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)

Probieren Sie es online!

-3 Bytes dank officialaimm durch Zusammenführen des anderen Lambda in f(sieht chaotisch aus, spart aber Bytes und das ist alles, was uns interessiert)
-8 Bytes dank Mr. Xoder
-26 Bytes dank ovs
-6 Bytes dank ppperry

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

2 Bytes gespart dank @ Shaggys Vorschlag, 9as zu verwenden 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>

Verwendet 9anstelle von A. Eingabe als 2D-Array von Ganzzahlen. Ausgabe als Array solcher Arrays.

Simulation der Welt (in Emoji) , 1407 Bytes?

Lieben Sie es nicht, eine erklärbare Sprache als Programmiersprache zu verwenden? Der Nachteil dabei ist, dass es normalerweise kein genau definiertes Programm gibt. In diesem Fall verwende ich den JSON, den es exportiert. (Wenn Sie bessere Ideen haben, lassen Sie es mich wissen)

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

Probieren Sie es hier oder hier:

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

Retina , 103 96 88 Bytes

^
¶
;{:`

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

Probieren Sie es online! Verwendet 9für Asche; Dies kann zu einem Preis von 4 Bytes mit geändert werden T`1-8`2-8A. Bearbeiten: 6 Bytes dank @MartinEnder gespeichert. Erläuterung:

^
¶

Fügen Sie ein Trennzeichen hinzu, damit die Ausgänge nicht ineinander laufen. (Hilft auch beim Matching weiter unten.)

;{:`

Drucken Sie nicht den endgültigen Status (der dem vorherigen Status entspricht, der bereits gedruckt wurde). Wiederholen, bis der Pass den Status nicht mehr ändert. Druckt den aktuellen Status vor jedem Durchgang.

T`0d`d

Erhöhen Sie die Intensität des gesamten Feuers.

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

Helle unbeleuchtete Felder nach Bedarf. Untererklärung:

(?<=¶(.)*)

Messen Sie die Spaltennummer dieses unbeleuchteten Feldes.

0

Passen Sie das unbeleuchtete Feld an.

(?=4

Suchen Sie rechts nach einem geeigneten Feld.

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

Suchen Sie in der Zeile darunter nach einem geeigneten Feld in derselben Spalte (mit einem Bilanzkreis). Beachten Sie, dass, wenn die Eingabe garantiert rechteckig sein könnte, dies |.*¶(?>(?<-1>.)*)4für eine Einsparung von 3 Bytes vereinfacht werden könnte .

  |(?<=40

Suchen Sie links nach einem geeigneten Feld. (Da wir von der rechten Seite des Feldes schauen, sehen wir auch das unbeleuchtete Feld.)

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

Suchen Sie in derselben Spalte in der Zeile oben nach einem geeigneten Feld. Da dies ein Lookbehind und damit eine Übereinstimmung von rechts nach links ist, muss die Bilanzkreisbedingung vor den Spalten stehen, die von dem Bilanzkreis abgeglichen wurden.

Perl 5 , 365 Bytes

@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

Probieren Sie es online!

Verwendet '9' anstelle von 'A', um einen ausgebrannten Ort anzuzeigen.

Erklärt

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

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]

Probieren Sie es online! Verwendung: hNimmt ein Feld als Liste von Zeilen und gibt eine Liste von Feldern zurück. Ein nicht verbranntes Feld wird durch @und Asche durch angezeigt 9, die verschiedenen Brände sind die Ziffern 1bis 8.

• fverwaltet die Ausbreitung des Feuers von links nach rechts, indem alle nicht @verbrannten Felder, die rechts von einem brennenden 3Feld sind, durch ersetzt werden 0.
• ierhöht jede Ziffer, solange sie kleiner als ist 9.
• ggilt ffür jede Zeile, kehrt dann die Zeile um, gilt ferneut und kehrt zurück. Dann wird die Liste der Zeilen transponiert und erneut auf jede Zeile und ihre Umkehrung fangewendet.
• hgilt gfür die Eingabe, bis sie sich nicht mehr ändert und die Ergebnisse sammelt.

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

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

Dieses Programm definiert eine Funktion, die zwei Eingaben akzeptiert, einen Zeiger auf ein Array von Zeichenfolgen, denen die Länge vorausgeht, wie in dieser E / A-Standardeinstellung zulässig . Ausgabe an STDOUT mit nachfolgendem Zeilenumbruch.

Probieren Sie es online!

Octave, 72 69 Bytes

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

Die Eingabe wird als 2D-Zahlenfeld interpretiert und leere Stellen mit gekennzeichnet Inf . 'A'wurde ersetzt durch 9. Zwischenergebnisse (als Array von Zahlen) werden implizit gedruckt.

Probieren Sie es online!

Erläuterung:

In einer Schleife wird die Funktion imdilate(morphologische Bilderweiterung) aus dem Bildpaket verwendet, um die Brandausbreitung zu simulieren.

Python 2 , 325 Bytes

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

fNimmt die Eingabe als 2D-Array von Ganzzahlen und leere Stellen, die mit gekennzeichnet sind ''. 'A'wurde ersetzt durch 9. Die Funktion gibt einen Generator aller Felder über die Zeit im gleichen Format aus.

Probieren Sie es online!

Oktave , 212 Bytes

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

Geben Sie zum Ausführen ein Zeichenarray an, z.

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

... dann mach:

r(f)

Erklärung des folgenden Codes ...

Probieren Sie es online!

^{Hinweis: Ich habe versucht, diesen Code mit tio.run auszuführen , aber keine Ausgabe erhalten. Ich musste einen anderen Dienst nutzen.}

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;

Nimmt Eingaben mit einem nachgestellten Zeilenumbruch aus einer Datei mit dem Namen an m. 9für asche.

Laufen Sie mit -nroder versuchen Sie es online .

erster Ansatz: 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;

Nimmt Eingaben mit einem nachgestellten Zeilenumbruch aus einer Datei mit dem Namen m.

Laufen Sie mit -nroder versuchen Sie es online .

PHP-Versionshinweise (für alten Ansatz)

• Ersetzen Sie für PHP älter als 7.0 alles danach $c-4|durch$g[$y+$p=[1,0,-1][$a]][$q+=$x]!="0"||$g[$y+$p][$q]=1;
• Für PHP älter als 5.5 ersetzen Sie [1,0,-1][$a]durch$a%2*~-($a&2)
• Für PHP neuer als 7.0 ersetzen Sie a&$cmit ""<$c, +$cmit 0<$cund $c-4mit$c!=4

Oktave, 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

Probieren Sie es online!

Dies ist meine Version, die es funktioniert, also muss ich jetzt noch Golf spielen. Ich denke, es kann viel kürzer sein, wenn ich einen Weg finde, die Indizes der 4 in einer Matrix zu finden, aber ich weiß nicht wie.
PS: A ist eine 9 in meinem Code.

Schablone ( ∊-Modus) , 22 Byte

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

Probieren Sie es online!

Verwenden Sie wie in der Testeingabe ganze Zahlen, die durch Leerzeichen für 0- 8, ' 'für Leerzeichen und 'A'für getrennt sind A. Denken Sie daran, auch nachgestellte Leerzeichen einzufügen.