Il y a un virus à l'intérieur d'un destinataire de 5x5. Comme nous savons comment il propage sa contamination, votre mission est de sortir la dernière étape de la contamination.

Le destinataire

Il sera représenté comme un tableau bidimensionnel de 5x5:

Où 1signifie une position où le virus a déjà contaminé et 0une position non contaminée.

Comment le virus se propage

Une position contaminée ne peut pas être propre.
Une position propre ne sera contaminée à l'étape suivante que si au moins deux de ses positions adjacentes (cellules nord, est, sud et ouest) sont contaminées.
La dernière étape de la contamination se produit lorsqu'aucune cellule plus propre ne peut être contaminée.

Échantillon

En utilisant comme étape 1 de la contamination le receveur décrit ci-dessus, l'étape 2 sera:

L'étape 3 de la contamination sera:

L'étape 4 de la contamination sera:

Et l'étape 5 (dans cet exemple, le dernier) sera:

Défi

Étant donné en entrée une étape de la contamination, vous devez sortir la dernière étape de la contamination.

Vous êtes autorisé à écrire un programme complet ou une fonction. Vous pouvez prendre l'entrée sous forme de tableau / liste, sous forme de nombres séparés ou même sous forme de chaîne. Choisit la meilleure façon qui convient à votre langue.

La réponse la plus courte en octets gagne!

Un autre cas de test

code-golf binary-matrix supprimé
la source

1

Comment peut 1 0 1se produire dans la sortie? Le centre zéro n'est-il pas adjacent à deux 1s?

Lynn

@Lynn .. J'ai mis à jour;) ... désolé pour cela

supprimé

1

Pourriez-vous ajouter 1 0 0 1 0 \ 0 0 1 0 1 \ 0 0 0 0 0 \ 1 0 0 0 0 \ 0 0 1 0 0comme cas de test?

Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ. Ajout de remerciements

supprimé

2

Jusqu'à présent, tous les cas de test n'ont que des lignes et des colonnes pleines se terminant vides. Je suggère 0 1 0 0 0 \ 0 0 0 0 1 \ 0 0 1 0 0 \ 1 0 0 0 0 \ 0 0 0 1 0, qui reste inchangé.

xnor

12

Puisqu'il s'agit essentiellement d'un automate cellulaire, je vous donne ..

Règle Golly Quicklife, 10 octets

01234/234V

Saisissez la règle, collez la grille dans Golly, exécutez le modèle. Le modèle résultant est la sortie.

Explication:

01234 Survive on any number of neighbors
     /234 Born on >2 neighbors
         V Only directly adjacent neighbors count

Ou si vous insistez sur une règle RuleLoader complète, 89 octets:

@RULE X
@TABLE
n_states:2
neighborhood:vonNeumann
symmetries:permute
011001
011101
011111

Le nom de règle est X, mêmes étapes que précédemment.

CalculatorFeline
la source

3

Est-ce un langage de programmation ?

Lynn

1

Golly Quicklife peut simuler B3/S23ce qui peut tout faire! ... Mais il a un format d'entrée strict (comme tout le programme est inclus dans l'entrée (comment feriez-vous autrement?)). MAIS POURQUOI RUINER LE PLAISIR ??

CalculatorFeline

Eh bien, il suffit d'attendre une question qui se résume au comportement à long terme d'un automate cellulaire!

CalculatorFeline

1

J'ai quelques doutes sur la validité. Si Golly n'affiche que le résultat final, ce serait bien, mais il affiche également des résultats intermédiaires (sauf erreur)

lirtosiast

1

@CatsAreFluffy Vous avez alors mon vote positif.

lirtosiast

5

Python 2, 97 octets

s=' '*6+input()
exec"s=s[1:]+('1'+s)[sum(s[i]<'1'for i in[-6,-1,1,6])>2or'/'>s];"*980
print s[6:]

Essayez-le en ligne . L'entrée est considérée comme une chaîne entre guillemets, chaque ligne étant délimitée par des retours à la ligne. Le 980n'est pas optimal et peut être remplacé par un multiple inférieur de 35. Puisqu'il n'a aucun impact sur la durée de ce programme, j'ai laissé la détermination de la limite supérieure sûre la plus basse comme exercice pour le lecteur.

xsot
la source

Nécessite des guillemets autour de l'entrée et \ n des sauts de ligne échappés.

CalculatorFeline

@CatsAreFluffy Je crois que le lien Ideone clarifie déjà la façon dont l'entrée est prise.

xsot

L'entrée est considérée comme une chaîne entre guillemets, chaque ligne étant délimitée par \ n s.

CalculatorFeline

D'accord, je vais le modifier pour le rendre moins ambigu.

xsot

3

Javascript (ES6), 91 89 87 octets

En tant que fonction qui accepte l'entrée comme un tableau de nombres ou de chaînes.

-2 octets de Neil (combinant l'affectation de yavec la conversion de chaîne)

-2 octets (suppression de variable j)

f=x=>(y=x.map((z,i)=>~(i%5&&x[i-1])+~(i%5<4&x[i+1])+~x[i-5]+~x[i+5]<-5|z))+[]==x?y:f(y)

<!-- Snippet demo with array <-> string conversion for convenience -->
<textarea id="input" cols="10" rows="5">0 0 0 0 1
0 0 0 0 1
0 0 0 1 1
0 0 1 1 1
0 1 1 1 1</textarea>
<button id="submit">Run</button>
<pre id="output"></pre>
<script>
strToArray=x=>x.match(/\d/g)
arrayToStr=x=>([]+x).replace(/(.),(.),(.),(.),(.),*/g, '$1 $2 $3 $4 $5\n')
submit.onclick=_=>output.innerHTML=arrayToStr(f(strToArray(input.value)))
</script>

Développer l'extrait

nderscore
la source

Économisez 2 octets en écrivant (y=...)+''==xau lieu de (y=...),y+''==x.

Neil

2

MATL , 22 octets

tn:"t5Bt!=~2X53$Y+1>Y|

Cela fonctionne dans la version actuelle (15.0.0) de la langue.

Essayez-le en ligne !

Le format d'entrée est: tableau 2D avec des lignes séparées par des points-virgules. Les quatre cas de test ont donc les entrées suivantes:

[0 0 0 0 1; 0 0 0 0 1; 0 0 0 1 1; 0 0 1 1 1; 0 1 1 1 1]

[1 1 0 0 1; 0 0 0 0 0; 0 1 0 0 1; 0 0 0 0 0; 1 0 0 0 1]

[1 0 0 0 0; 0 1 0 0 0; 0 0 1 0 0; 0 0 0 1 0; 0 0 0 0 1]

[1 0 0 1 0; 0 0 1 0 1; 0 0 0 0 0; 1 0 0 0 0; 0 0 1 0 0]

Explication

Cela effectue à plusieurs reprises une convolution 2D du tableau d'entrée avec le masque suivant, qui définit quels voisins comptent comme contaminant:

0 1 0
1 0 1
0 1 0

Afin d'obtenir un résultat de la même taille que le tableau d'origine, il est d'abord complété avec un cadre de zéros et ensuite seule la partie "valide" de la convolution est conservée (c'est-à-dire sans effets de bord).

Un seuil de 2 est appliqué à la sortie de la convolution, et le résultat est OU par élément avec l'entrée d'origine.

Cela doit être fait un nombre suffisant de fois pour s'assurer que l'état final a été atteint. Un critère simple qui remplit cela est: itérer autant de fois que le nombre d'entrées dans le tableau d'entrée (c'est-à-dire 25 fois dans les cas de test).

t          % get input 2D array implicitly. Duplicate
n:"        % repeat as many times as elements in the input array
  t        %   duplicate array
  5B       %   number 5 in binary: row vector [1 0 1] 
  t!       %   duplicate and transpose into column
  =~       %   compare for inequality with broadcast. Gives desired mask
  2X53$Y+  %   2D convolution. Output has same size as input 
  1>       %   true for elements equal or greater than 2
  Y|       %   element-wise OR with previous copy of the array
           % end loop. Implicitly display

Luis Mendo
la source

1

TI-BASIC, 151 octets

Prompt [A]
[A]→[B]
Lbl 0
[B]→[A]
For(Y,1,5
For(X,1,5
DelVar ADelVar BDelVar CDelVar D
If Y>1:[A](Y-1,X→A
If Y<5:[A](Y+1,X→B
If X>1:[A](Y,X-1→C
If X<5:[A](Y,X+1→D
max(A+B+C+D≥2,[A](Y,X→[B](Y,X
End
End
If [A]≠[B]:Goto 0
[B]

Saisissez comme [[1,0,0,1,1][1,0,0,0,0]...].

Conor O'Brien
la source

1

Je pense que vous pouvez obtenir cela à environ 100 octets. Premier conseil: utilisez une Repeatboucle.

lirtosiast

1

Lua, 236 octets

s=arg[1]u=s.sub while p~=s do p=s s=s:gsub("(%d)()",function(d,p)t=0 t=t+((p-2)%6>0 and u(s,p-2,p-2)or 0)t=t+(p-7>0 and u(s,p-7,p-7)or 0)t=t+(p+5<30 and u(s,p+5,p+5)or 0)t=t+(p%6>0 and u(s,p,p)or 0)return t>1 and 1 or d end)end print(s)

Accepte les entrées sur la ligne de commande et utilise la manipulation de chaînes de Lua pour obtenir la réponse.

Non golfé:

s=arg[1]
u=s.sub
while p~=s do
    p=s
    s=s:gsub("(%d)()", function(d, p)
                 t=0
                 t=t+((p-2)%6>0 and u(s,p-2,p-2)or 0)
                 t=t+(p-7>0 and u(s,p-7,p-7)or 0)
                 t=t+(p+5<30 and u(s,p+5,p+5)or 0)
                 t=t+(p%6>0 and u(s,p,p)or 0)
                 return t>1 and 1 or d
    end)
end
print(s)

Trébuchette
la source

1

APL, 76 72 70 octets

{⍵∨1<¯1 ¯1↓1 1↓↑+/(1 0)(¯1 0)(0 ¯1)(0 1){⍺[1]⊖⍺[2]⌽⍵}¨⊂¯1⊖¯1⌽7 7↑⍵}⍣≡

Ce que cela fait, c'est: étendre la matrice à 7x7, puis centrer notre argument (oméga). À partir de cette matrice, générez 4 matrices "enfants", chacune décalée dans une direction différente (haut / bas / gauche / droite), ajoutez-les ensemble (donc on obtient le nombre de voisins), déposez le cadre (pour revenir à un Matrice 5x5). Ou cette nouvelle matrice avec l '"ancienne", pour nous assurer que nous n'avons pas laissé de cellules dans le processus (c'est-à-dire au bord). Ensuite, utilisez la ⍣≡combinaison pour obtenir une valeur à virgule fixe.

{⍵∨1<¯1 ¯1↓1 1↓↑+/(1 0)(¯1 0)(0 ¯1)(0 1){⍺[1]⊖⍺[2]⌽⍵}¨⊂¯1⊖¯1⌽7 7↑⍵}⍣≡
                                                             7 7↑⍵    ⍝ Expand the matrix
                                                       ¯1⊖¯1⌽         ⍝ Center the original matrix
                  (1 0)(¯1 0)(0 ¯1)(0 1){⍺[1]⊖⍺[2]⌽⍵}¨⊂               ⍝ Construct 4 child matrices, each offset from the original one by the values on the left of {}
                +/                                                    ⍝ Sum each matrix into one giant matrix
               ↑                                                      ⍝ Mix
     ¯1 ¯1↓1 1↓                                                       ⍝ Transform the 7x7 matrix back to a 5x5 matrix
   1<                                                                 ⍝ Check which elements are smaller than 1
 ⍵∨                                                                   ⍝ "Or" this matrix and the generated matrix
{                                                                 }⍣≡ ⍝ Find the fixpoint

exemple (considérant que la fonction a été assignée contaminate):

          stage ⍝ the base matrix
0 0 0 0 1
0 0 0 0 1
0 0 0 1 1
0 0 1 1 1
0 1 1 1 1
      contaminate stage ⍝ apply the function
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1

Ven
la source

La dernière étape de la contamination

Le destinataire

Comment le virus se propage

Échantillon

Défi

Un autre cas de test

Réponses:

Règle Golly Quicklife, 10 octets

Python 2, 97 octets

Javascript (ES6), 91 89 87 octets

MATL , 22 octets

Explication

TI-BASIC, 151 octets

Lua, 236 octets

APL, 76 72 70 octets