Poiché domani è il 4 maggio, ecco un piccolo post a tema Star Wars per prepararti mentalmente a tutte le brutte battute che verranno domani.

backstory

Durante una sessione del senato galattico tutti i senatori sono seduti in una n*ngriglia. Un improvviso focolaio di influenza JarJar (che dura per sempre e fa parlare gli infetti come JarJar Binks) fa sì che alcuni senatori vengano infettati.

Ecco un esempio con una 6*6griglia in cui Xsono presenti i senatori infetti, l'elenco corrispondente è [[0,5],[1,4],[2,3],[2,1],[3,3],[3,0],[4,5],[0,5]]:

Successivamente, l'infezione inizia a diffondersi passo dopo passo. Due senatori sono adiacenti se condividono un intero bordo sulla griglia (cioè, in alto, in basso, a destra, a sinistra), il che significa che escludiamo le diagonali.

Possiamo concludere che un senatore può essere adiacente ad altri 2,3 o 4 senatori e rivendicare le seguenti regole per l'infezione:

• Un senatore che è stato infettato rimane infetto per sempre
• Un senatore viene infettato in un passaggio se era adiacente a 2 o più senatore infetto nel passaggio precedente

Ecco un esempio con la griglia precedente che mostra i 2 primi passi dell'infezione:

Dopo i prossimi passi tutto il senato sarà infetto

IL TUO COMPITO

Non è necessario che il tuo codice gestisca input non validi come un elenco maggiore n*no coordinate che non siano distinte.

Il tuo codice prenderà come input un elenco di coppie di numeri interi (o una griglia binaria o qualsiasi altro formato adatto alla tua lingua) e un numero intero n(che può essere superfluo se usi un formato diverso da un elenco), ad esempio:

8 [[1,2],[1,1],[7,4],[2,7],[4,3]]

n essendo il lato della griglia, il che significa che la griglia sarà una griglia * n, e l'elenco delle coppie di numeri interi sono le coordinate delle cellule dei senatori con infezione iniziale.

La parte inferiore sinistra della griglia è [0,0] e la parte superiore destra è [n-1, n-1]. L'angolo in alto a sinistra è [0, n-1].

Il tuo codice deve generare un numero intero:

-1 o un valore falso o un errore se l'intera griglia non sarà mai totalmente infetta o il numero minimo di passaggi necessari per infettare l'intera griglia

Casi test

6 [[0,5],[1,4],[2,3],[2,1],[3,3],[3,0],[4,5],[5,0]] => 7

4 [[1,1][0,3][1,0][3,0][3,3]] => 9

Ricorda che questo è code-golf , quindi vince la risposta più breve in byte!

MATL, 29 28 byte

tn:"tlY6Z+1>Z|t?@.]]Nl=?l_]&

L'input ha la forma di una matrice 2D di 1 e 0

Provalo su MATL Online

Spiegazione

        % Implicitly grab user input as a 2D matrix
t       % Duplicate the inputs
n:      % Count the number of elements in the input (N) and create the array [1...N]
"       % Loop this many times (maximum number of steps we analyze)
  t     % Duplicate the top element
  lY6   % Push the 2D array => [0 1 0; 1 0 1; 0 1 0]
  Z+    % Perform 2D convolution (and maintain the size)
  l>    % Find all values that are >= 2
  Z|    % Perform an element-wise OR with the previous state
  t?    % If all elements are 1's
    @.  % Push the current index and break out of the loop
  ]     % End of if 
]       % End of for loop
Nl=?    % If there is only one element on the stack
  l_    % Push a negative one
]       % End of if statement
&       % Display the top stack element

APL (Dyalog 16.0), 54 caratteri o 60 byte

Prende la matrice racchiusa come argomento, restituisce il numero del passaggio che completa l'infezione, ovvero 1 = è già completamente infetto. 0 = non si diffonde completamente, che è solo 1 + i numeri del PO.

54 caratteri (Unicode):

(≢×0=0∊⊃){(⊢≡f←⊢∨2≤{+/,⍵×3 3⍴0 1}⌺3 3)⊃⍵:⍵⋄(⊂f⊃⍵),⍵}⍣≡

60 byte (classico):

(≢×0=0∊⊃){(⊢≡f←⊢∨2≤{+/,⍵×3 3⍴0 1}⎕U233A 3 3)⊃⍵:⍵⋄(⊂f⊃⍵),⍵}⍣≡

⌺ è equivalente a ⎕U233A

Esecuzione degli esempi:

      g←(≢×0=0∊⊃){(⊢≡f←⊢∨2≤{+/,⍵×3 3⍴0 1}⌺3 3)⊃⍵:⍵ ⋄ (⊂f⊃⍵),⍵}⍣≡
      ⎕IO←0
      b←⊂⊖⍉~@(⎕JSON'[[0,5],[1,4],[2,3],[2,1],[3,3],[3,0],[4,5],[5,0]]')⊢0⍴⍨2⍴6
      g b
8
      b←⊂⊖⍉~@(⎕JSON'[[1,1],[0,3],[1,0],[3,0],[3,3]]')⊢0⍴⍨2⍴4
      g b
10

I passi sono come segue:

┌─────────────┬─────────────┬─────────────┬─────── ──────┬─────────────┬─────────────┬─────────────┬─ ────────────┐
│ XX │ XXX │ XXXX │ XXXXX │ XXXXX │ XXXXX │ XXXXX │ XXXXXX │
│ X │ XXX │ XXXX │ XXXXX │ XXXXX │ XXXXX │ XXXXXX │ XXXXXX │
│ XX │ XXX │ XXXX │ XXXX │ XXXXX │ XXXXXX │ XXXXXX │ XXXXXX │
│ │ X │ XXX │ XXXXX │ XXXXXX │ XXXXXX │ XXXXXX │ XXXXXX │
│ X │ XX │ XXX │ XXXXX │ XXXXXX │ XXXXXX │ XXXXXX │ XXXXXX │
│ XX │ XXXX │ XXXX │ XXXX │ XXXXX │ XXXXXX │ XXXXXX │ XXXXXX │
└─────────────┴─────────────┴─────────────┴─────── ──────┴─────────────┴─────────────┴─────────────┴─ ────────────┘
┌─────────┬─────────┬─────────┬─────────┬───────── ┬─────────┬─────────┬─────────┬─────────┬───────── ┐
│ XX │ XX │ XX │ XX │ XX │ XX │ XXX │ XXXX │ XXXX │ XXXX │
│ │ │ │ │ X │ XX │ XXX │ XXXX │ XXXX │ XXXX │
│ X │ X │ XX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXXX │ XXXX │
│ XX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXXX │
└─────────┴─────────┴─────────┴─────────┴───────── ┴─────────┴─────────┴─────────┴─────────┴───────── ┘

Pyth , 49 byte

J^UE2*lK.uS{+NeMf>hT1r8S@Jsmm+VdkNs_MB_MBU2Q)qJeK

Suite di test .

Utilizza 1-indicizzazione per l'output.

Python, 231 byte

g=input()
q=lambda r,c:g[r][c]if(0<=r<m)*(0<=c<m)else 0
m=len(g);p=t=0;n=range(m)
while not all([r for k in g for r in k]):h=[[g[r][c]or sum([q(r+1,c),q(r-1,c),q(r,c+1),q(r,c-1)])>1 for c in n] for r in n];t+=1;0/(g!=h);g=h
print t

Genera un errore se non è possibile.

Provalo online!

JavaScript (ES6), 132 byte

f=s=>(w=s.search`\n`,t=` `.repeat(w+1),t+=s+t,t=s.replace(/0/g,(_,i)=>1-t[i]-t[i+=w]-t[i+=2]-t[i+w]>>>31),t==s?0/!/0/.test(s):1+f(t))

Dove \nrappresenta il carattere letterale di newline. Prende in ingresso come una stringa di 0s e 1s in una matrice newline delimitato. Restituisce NaNse la griglia non verrà mai completamente infettata.