C'è un virus all'interno di un destinatario di 5x5. Poiché sappiamo come si diffonde la sua contaminazione, la tua missione è quella di produrre l'ultimo stadio della contaminazione.

Il destinatario

Sarà rappresentata come una matrice bidimensionale di 5x5:

Dove 1significa una posizione in cui il virus è già stato contaminato e 0una posizione non contaminata.

Come si diffonde il virus

Una posizione contaminata non può essere pulita.
Una posizione pulita sarà contaminata nella fase successiva solo se almeno due delle sue posizioni adiacenti (celle nord, est, sud e ovest) sono contaminate.
L'ultima fase della contaminazione si verifica quando non è più possibile contaminare più cellule pulite.

Campione

Usando come fase 1 della contaminazione il destinatario sopra descritto, la fase 2 sarà:

La fase 3 della contaminazione sarà:

La fase 4 della contaminazione sarà:

E la fase 5 (in questo esempio, l'ultima) sarà:

Sfida

Dato come input uno stadio della contaminazione, dovresti emettere l'ultimo stadio della contaminazione.

Puoi scrivere un programma completo o una funzione. Puoi prendere l'input come matrice / elenco, come numeri separati o anche come stringa. Scegli il modo migliore che si adatta alla tua lingua.

Vince la risposta più breve in byte!

Un altro caso di test

code-golf binary-matrix

— rimosso
fonte

1

Come può 1 0 1verificarsi nell'output? Lo zero centrale non è adiacente a due 1s?

— Lynn

@Lynn .. ho aggiornato;) ... scusatemi per questo

— rimosso il

1

Potresti aggiungere 1 0 0 1 0 \ 0 0 1 0 1 \ 0 0 0 0 0 \ 1 0 0 0 0 \ 0 0 1 0 0come test case?

— Conor O'Brien,

@ CᴏɴᴏʀO'Bʀɪᴇɴ. Aggiunto grazie

— rimosso il

2

Tutti i casi di test finora hanno solo righe e colonne complete che terminano vuote. Suggerirei 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, che rimane invariato.

— xnor

12

Dal momento che si tratta fondamentalmente di un automa cellulare che ti do ..

Regola Golly Quicklife, 10 byte

01234/234V

Immettere la regola, incollare la griglia in Golly, eseguire il modello. Il modello risultante è l'output.

Spiegazione:

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

O se insisti su una regola RuleLoader completa, 89 byte:

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

Il nome del cognome è X, stessi passaggi di prima.

— CalculatorFeline
fonte

3

È un linguaggio di programmazione ?

— Lynn

1

Golly Quicklife può simulare B3/S23che può fare qualsiasi cosa! ... Ma ha un formato di input rigoroso (come l'intero programma è incluso nell'input (come altrimenti lo faresti?)). MA PERCHÉ ROVERE IL DIVERTIMENTO ??

— CalcolatriceFeline

Bene, dobbiamo solo aspettare una domanda che si riduce al comportamento a lungo termine di un automa cellulare!

— CalcolatriceFeline

1

Ho qualche dubbio sulla validità. Se Golly mostrasse solo il risultato finale, andrebbe bene, ma mostra anche risultati intermedi (a meno che non mi sbagli)

— lirtosiast

1

@CatsAreFluffy Allora hai il mio voto.

— Lirtosiast

5

Python 2, 97 byte

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:]

Provalo online . L'input viene preso come una stringa tra virgolette con ogni riga delimitata da newline. Non 980è ottimale e può essere sostituito con un multiplo inferiore di 35. Poiché non ha alcun impatto sulla durata di questo programma, ho lasciato la determinazione del limite superiore sicuro più basso come esercizio per il lettore.

— xsot
fonte

Richiede virgolette sull'input e \ n righe evase.

— CalcolatriceFeline

@CatsAreFluffy Credo che il link Ideone chiarisca già come viene preso l'input.

— xsot

L'input viene preso come una stringa tra virgolette con ogni riga delimitata da \ n s.

— CalcolatriceFeline

Va bene, lo modificherò per renderlo meno ambiguo.

— xsot,

3

Javascript (ES6), 91 89 87 byte

Come una funzione che accetta l'input come una matrice di numeri o stringhe.

-2 byte da Neil (combinando l'assegnazione di y con la conversione di stringhe)

-2 byte (rimozione della variabile 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>

Espandi frammento

— nderscore
fonte

Salva 2 byte scrivendo (y=...)+''==xinvece di (y=...),y+''==x.

— Neil,

2

MATL , 22 byte

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

Funziona con la versione corrente (15.0.0) della lingua.

Provalo online !

Il formato di input è: matrice 2D con righe separate da punti e virgola. Quindi i quattro casi di test hanno i seguenti input:

[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]

Spiegazione

Ciò esegue ripetutamente una convoluzione 2D dell'array di input con la seguente maschera, che definisce quali vicini contano come contaminanti:

0 1 0
1 0 1
0 1 0

Per ottenere un risultato delle stesse dimensioni dell'array originale, viene prima riempito con una cornice di zeri e quindi viene mantenuta solo la parte "valida" della convoluzione (cioè quella senza effetti di bordo).

Una soglia di 2 viene applicata all'output della convoluzione e il risultato è ORed dal punto di vista degli elementi con l'input originale.

Questo deve essere fatto un numero di volte sufficiente per garantire il raggiungimento dello stato finale. Un semplice criterio che soddisfa questo è: iterare quante volte il numero di voci nell'array di input (cioè 25 volte nei casi di 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
fonte

1

TI-BASIC, 151 byte

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]

Inserisci come [[1,0,0,1,1][1,0,0,0,0]...].

— Conor O'Brien
fonte

1

Penso che sia possibile ottenere questo a circa 100 byte. Primo consiglio: usa un Repeatloop.

— lirtosiast,

1

Lua, 236 byte

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)

Accetta input dalla riga di comando e utilizza la manipolazione di stringhe di Lua per ottenere la risposta.

Ungolfed:

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)

— Trebuchette
fonte

1

APL, 76 72 70 byte

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

Ciò che fa è: espandere la matrice in una 7x7, quindi centrare il nostro argomento (omega). Da questa matrice, genera 4 matrici "figlio", ognuna spostata in una direzione diversa (su / giù / sinistra / destra), sommale (in modo da ottenere il numero di vicini), rilascia il riquadro (per tornare a un Matrice 5x5). O questa nuova matrice con quella "vecchia", per essere sicuri che non abbiamo lasciato cadere nessuna cellula nel processo (cioè al limite). Quindi, utilizzare la ⍣≡combinazione per arrivare a un valore in virgola fissa.

{⍵∨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

esempio (considerando la funzione assegnata a 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
fonte

L'ultima fase della contaminazione

Il destinatario

Come si diffonde il virus

Campione

Sfida

Un altro caso di test

Regola Golly Quicklife, 10 byte

Python 2, 97 byte

Javascript (ES6), 91 89 87 byte

MATL , 22 byte

Spiegazione

TI-BASIC, 151 byte

Lua, 236 byte

APL, 76 72 70 byte