Avertissement: L'histoire racontée dans cette question est entièrement fictive et inventée uniquement dans le but de fournir une intro.

Je suis un mauvais fermier, et pour faire monter le prix du blé dans ma région, j'ai décidé de brûler les champs de tous les fermiers autour de moi. J'aimerais vraiment voir les champs s'enflammer (afin que je puisse utiliser mon rire diabolique et me frotter les mains avec joie), mais je ne veux pas non plus être pris en train de regarder, alors j'ai besoin de vous pour simuler le champ incinéré pour moi.

Ta tâche:

Écrivez un programme ou une fonction qui prend en entrée un champ et renvoie les étapes de sa gravure jusqu'à ce que le champ entier soit en cendres. Une section spécifique du champ qui est en feu est représentée par un entier représentant l'intensité de la flamme. Un incendie commence à "1" et passe à "2" puis à "3", et ainsi de suite. Une fois qu'un incendie atteint «4», il attrape directement (non en diagonale) les zones adjacentes qui sont inflammables en feu. Une fois qu'il atteint "8", il s'éteint à la prochaine itération et se transforme en cendre, représentée par un "A". Lorsqu'une zone n'a pas encore été touchée par le feu, elle est représentée par un "0". Par exemple, si le champ ressemble à ceci:

100
000

Votre programme devrait produire ceci:

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

Si vous le souhaitez, vous pouvez remplacer les symboles ci-dessus par tout ensemble de symboles que vous choisissez, à condition qu'ils soient cohérents et distincts les uns des autres.

Contribution:

La position de départ du champ, sous n'importe quelle forme standard, telle qu'une chaîne délimitée par un retour à la ligne comme ci-dessus.

Sortie:

Le champ à chaque itération lors de sa gravure, soit sous forme de tableau, soit sous forme de chaîne délimitée par un caractère.

Cas de test:

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

Notation:

C'est le code-golf , le score le plus bas en octets gagne!

APL (Dyalog) , 52 octets *

Suppose ⎕IO←0que c'est la valeur par défaut sur de nombreux systèmes. Prend le champ en utilisant 0 pour les emplacements vides, 1 pour le champ non allumé, 2 pour le nouveau feu, 5 pour propager le feu et 10 pour les cendres. L'entrée doit être d'au moins 3 × 3, ce qui n'est pas un problème car des lignes et des colonnes supplémentaires peuvent être complétées par des zéros (espaces au format OP).

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

Essayez-le en ligne!

Mon format rend difficile la vérification de l'exactitude, alors voici une version avec pré et post-traitement supplémentaire pour traduire à partir du format OP.

⍣{… } Répéter jusqu'à:

 ⍺ la prochaine génération

 ≡ est identique à

 ⎕←⍵ la génération actuelle, sortie

{…}⌺3 3  Remplace chaque cellule par le résultat de cette fonction appliquée à son voisinage de Moore:

 ,⍵ défiler (aplatir) l'argument; donne une liste de neuf éléments

 r← affecter à r

 4⊃ choisissez le quatrième élément; le centre, c'est-à-dire la valeur de cellule d'origine

 c← affecter à c

 1= est-ce égal à cela?

 : si oui, alors:

  ⍳2 premier à ɩ ntegers; 0 1

  9⍴ r Eshape à la longueur de neuf; 0 1 0 1 0 1 0 1 0

  r/⍨ utiliser cela pour filtrer r (cela n'obtient que les voisins orthogonaux)

  4∊ est-ce que quatre en sont membres? (c.-à-d. y aura-t-il un cinq dans la prochaine génération?)

  1+ ajoute un; 1 si pas pris feu ou 2 si pris feu

 ⋄ sinon (c'est-à-dire que la valeur actuelle est 0 ou ≥ 2)

  ×c le signum de c

  c+ c plus cela (c.-à-d. augmenter d'une unité en cas d'incendie)

  10⌊ minimum de dix et cela (car les cendres ne brûlent pas)

* Dans Dyalog Classic, utilisez ⎕U233A au lieu de ⌺.

Python 3 , 232 octets

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)

Essayez-le en ligne!

-3 octets grâce à officialaimm en fusionnant l'autre lambda dans f(semble désordonné mais économise les octets et c'est tout ce qui nous
importe ) -8 octets grâce à M. Xoder
-26 octets grâce aux ovs
-6 octets grâce à ppperry

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

Sauvegardé 2 octets grâce à la suggestion de @ Shaggy d'utiliser 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>

Utilise 9au lieu de A. Entrée sous forme de tableau 2D d'entiers. Sortie sous forme de tableau de ces tableaux.

Simuler le monde (en Emoji) , 1407 octets?

N'aimez-vous pas utiliser une explication explorable comme langage de programmation? L'inconvénient est qu'il n'y a généralement pas de programme très bien défini, donc dans ce cas, j'utilise le JSON qu'il exporte. (si vous avez de meilleures idées, faites le moi savoir)

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

Essayez-le ici ou ici:

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

Rétine , 103 96 88 octets

^
¶
;{:`

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

Essayez-le en ligne!Utilise la 9cendre; cela peut être changé à un coût de 4 octets en utilisant T`1-8`2-8A. Edit: sauvé 6 octets grâce à @MartinEnder. Explication:

^
¶

Ajoutez un séparateur pour que les sorties ne se rencontrent pas. (Aide également lors de la correspondance ci-dessous.)

;{:`

N'imprimez pas l'état final (qui est le même que l'état précédent qui a déjà été imprimé). Répétez jusqu'à ce que la passe ne change pas l'état. Imprime l'état actuel avant chaque passage.

T`0d`d

Faites avancer l'intensité de tout le feu.

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

Allumez les champs non éclairés selon le cas. Sous-explication:

(?<=¶(.)*)

Mesurez le numéro de colonne de ce champ éteint.

0

Faites correspondre le champ non éclairé.

(?=4

Recherchez un champ approprié à droite.

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

Recherchez un champ approprié dans la même colonne (en utilisant un groupe d'équilibrage) dans la ligne ci-dessous. Notez que si l'entrée pouvait être garantie rectangulaire, cela pourrait être simplifié |.*¶(?>(?<-1>.)*)4pour une économie de 3 octets.

  |(?<=40

Recherchez un champ approprié à gauche. (Puisque nous regardons du côté droit du champ, nous voyons également le champ non éclairé.)

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

Recherchez un champ approprié dans la même colonne de la ligne ci-dessus. Dans la mesure où il s'agit d'une correspondance et donc d'une correspondance de droite à gauche, la condition du groupe d'équilibrage doit apparaître avant les colonnes qui ont été mises en correspondance par le groupe d'équilibrage.

Perl 5 , 365 octets

@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

Essayez-le en ligne!

Utilise «9» au lieu de «A» pour indiquer un emplacement brûlé.

Expliqué

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

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]

Essayez-le en ligne! Utilisation: hprend un champ comme une liste de lignes et renvoie une liste de champs. Un champ non brûlé est indiqué par @et cendres par 9, les différents feux sont les chiffres 1à 8.

• fgère la propagation du feu de gauche à droite en remplaçant tous les @champs non brûlés qui sont à droite d'un 3champ en feu par0 .
• iincrémente chaque chiffre tant qu'il est inférieur à 9.
• gs'applique fà chaque ligne, puis inverse la ligne, s'applique à fnouveau et inverse. Ensuite, la liste des lignes est transposée et à nouveau sur chaque ligne et son inverse fest appliqué.
• hs'applique gà l'entrée jusqu'à ce qu'elle ne change plus et recueille les résultats.

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

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

Ce programme définit une fonction qui prend deux entrées, un pointeur vers un tableau de chaînes précédé de sa longueur, comme le permet cette entrée / sortie par défaut. Sorties vers STDOUT avec une nouvelle ligne de fin.

Essayez-le en ligne!

Octave, 72 69 octets

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

L'entrée est considérée comme un tableau 2D de nombres et les espaces vides marqués d'un Inf. 'A'a été remplacé par9 . Les résultats intermédiaires (sous forme de tableau de nombres) sont imprimés implicitement.

Essayez-le en ligne!

Explication:

Dans une boucle, la fonction imdilate(dilatation morphologique de l'image) de l'ensemble d'images est utilisée pour simuler la propagation du feu.

Python 2 , 325 octets

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

fprend l'entrée comme un tableau 2D d'entiers et les espaces vides marqués avec ''. 'A'a été remplacé par9 . La fonction génère un générateur de tous les champs dans le temps dans le même format.

Essayez-le en ligne!

Octave , 212 octets

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

Pour exécuter, spécifiez un tableau de caractères tel que:

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

... alors fais:

r(f)

Explication du code à suivre ...

Essayez-le en ligne!

^{Remarque: J'ai essayé d'exécuter ce code avec tio.run , mais je n'obtenais aucune sortie. J'ai dû utiliser un autre service.}

PHP, 226 212 210 209 185 177 177 octets

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;

prend une entrée avec un retour à la ligne à partir d'un fichier nommé m ; 9pour les cendres.

Courez avec -nrou essayez-le en ligne .

première approche: PHP 7.0, 209 octets

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;

prend une entrée avec un retour à la ligne à partir d'un fichier nommé m .

Courir avec -nrou essayez-le en ligne .

Notes de version PHP (pour l'ancienne approche)

• pour PHP plus ancien que 7.0, remplacez tout après $c-4| par$g[$y+$p=[1,0,-1][$a]][$q+=$x]!="0"||$g[$y+$p][$q]=1;
• pour PHP plus ancien que 5.5, remplacez [1,0,-1][$a] par$a%2*~-($a&2)
• pour PHP plus récent que 7.0, remplacez a&$cpar ""<$c, +$cpar 0<$cet $c-4par$c!=4

Octave, 419 312 octets

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

Essayez-le en ligne!

Ceci est ma version, cela fonctionne, alors maintenant j'ai encore besoin de jouer au golf. Je pense que cela peut être beaucoup plus court si je trouve un moyen de trouver les indices des 4 dans une matrice, mais je ne sais pas comment.
PS: A est un 9 dans mon code.

Pochoir ( ∊-mode) , 22 octets

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

Essayez-le en ligne!

Tout comme dans l'entrée de test, utilisez des entiers séparés par des espaces pour 0- 8, ' 'pour les blancs et'A' pour A. N'oubliez pas d'ajouter également des blancs de fin.