introduzione

Osserviamo il seguente quadrato, costituito esclusivamente le cifre 0 - 9:

1034
4167
8414
3542

Il guscio esterno di questo quadrato è:

1034
4  7
8  4
3542

Esso contiene zeri, quindi dobbiamo sbucciare fuori dal guscio esterno, lasciando:

16
41

Il guscio esterno di questo quadrato è:

16
41

Esso non contiene zeri ed è quindi un non contaminata quadrato. Quindi, fondamentalmente, la definizione di un quadrato non contaminata è quando il guscio esterno del quadrato contiene alcun zeri.

L'obiettivo

Dato un quadrato di cifre (contenenti solo numeri interi non negativi) in qualsiasi formato ragionevole, uscita la più grande piazza non contaminata costantemente staccava dal guscio esterno, in qualsiasi formato ragionevole.

Casi test

Caso di prova 1:

Input         Output

1234          1234
2345          2345
3456          3456
4567          4567

Caso di prova 2:

Input         Output

123           123
204           204
346           346

Caso di prova 3:

Input         Output

101           1
010           
101           

Caso di prova 4:

Input         Output

000           (none)
000
000

Questo è il codice-golf , quindi la presentazione con la minor quantità di byte vince!

Gelatina , 19 16 byte

Fœ^F}P
ḊṖZµ⁺⁸ßç?

Provalo online! o verifica tutti i casi di test .

Come funziona

ḊṖZµ⁺⁸ßç?  Main link. Argument: M (2D list)

Ḋ          Dequeue; remove the first row.
 Ṗ         Pop; remove the last row.
  Z        Zip; transpose rows with columns.
   µ       Combine the chain to the left into a link.
    ⁺      Copy the link, executing it twice.
           The copy removes the first and last column and restores the orientation.
       ç?  If the helper link returns a non-zero integer:
     ⁸       Return M unmodified.
      ß      Else, recursively call the main link on the "peeled" M.


Fœ^F}P     Helper link. Arguments: P ("peeled" M), M (unmodified)

F          Flatten P.
   F}      Flatten M.
 œ^        Perform multiset symmetric difference, removing the elements of P from
           the elements of M, respecting multiplicities, leaving precisely the
           elements of the outer shell.
     P     Return the product of the remaining elements.

JavaScript, 105 97 byte

8 byte salvati grazie a @Patrick Roberts!

l=a=>a.slice(1,-1)
p=a=>l(a).map(l)
c=a=>a.join``.replace(/[^0]/g,"")
s=a=>c(p(a))<c(a)?s(p(a)):a

Definisce la funzione s, che restituisce una matrice 2D di numeri interi quando viene fornita una matrice 2D di numeri interi come input.

Come funziona

• funzione l: dato un array a, restituisce una copia senza il suo primo e l'ultimo indice.

• funzione p: dato un array 2D a, chiama lper rimuovere la prima e l'ultima riga, quindi per ogni riga rimanente chiama lper rimuovere il pugno e l'ultima colonna. Esegue la cipolla peeling.

• funzione c: dato un array 2D a, restituisce una stringa che contiene solo la 0s nella forma ristretta di a.

• funzione s: dato un array 2D a, chiama cla forma pelata dell'array dato da pe sull'array stesso. Confronta le stringhe lessicograficamente per determinare se la forma pelata ha meno 0s rispetto all'originale. In tal caso, l'originale è contaminato, quindi chiamare in modo sricorsivo sul modulo pelato. In caso contrario, restituisce l'originale.

Retina , 60 57 byte

conteggio di byte assume codifica ISO 8859-1. L'avanzamento posteriore è significativo.

+`(?<=(?=.*0|[^_]+(¶0|0¶|0.*$))^[^_]*)(^.+¶|¶.+$|.?\b.?)

Provalo online!

Spiegazione

A causa dell'alimentazione di riga finale, trova tutte le corrispondenze della regex dopo il `e le rimuove dall'input. A causa del comando, +questo viene fatto ripetutamente fino a quando l'output non smette di cambiare (questo perché regex smetterà di corrispondere).

Per quanto riguarda la regex stessa, è composta da due parti:

(?<=(?=.*0|[^_]+(¶0|0¶|0.*$))^[^_]*)

Questa parte controlla se c'è un 0punto qualsiasi nel guscio esterno. Lo fa spostando il "cursore" del motore regex all'inizio della stringa con un lookbehind (usiamo [^_]per abbinare sia le cifre che gli avanzamenti di riga):

(?<=...^[^_]*)

E poi da quella posizione usiamo un lookahead per trovare 0uno nella prima riga, adiacente a un avanzamento riga o nell'ultima riga:

(?=.*0|[^_]+(¶0|0¶|0.*$))

Quindi la corrispondenza effettiva consisterà nella prima riga (incluso il suo avanzamento riga finale), nell'ultima riga (incluso il suo avanzamento riga iniziale) o nel primo o nell'ultimo carattere di una riga, in cui abusiamo del confine di parola \bcome inizio / fine della riga ancora:

(^.+¶|¶.+$|.?\b.?)

MATL , 26 21 byte

t"t5LY)y5LZ)h?}6Lt3$)

L'ingresso è nel seguente formato

[1 0 3 4; 4 1 6 7; 8 4 1 4; 3 5 4 2]

Così gli altri quattro casi di test sono

[1 2 3 4; 2 3 4 5; 3 4 5 6; 4 5 6 7]
[1 0 1; 0 1 0; 1 0 1]
[1 2 3; 2 0 4; 3 4 6]
[0 0 0; 0 0 0; 0 0 0]

Il programma si guasta nell'ultimo caso di test, ma produce l'output corretto (che è nulla). Grazie a @Dennis per accorgersene!

Provalo online! . Oppure verifica tutti i casi di test (questo include il codice di wrapping).

Spiegazione

Questo scorre più volte del numero di colonne nella matrice di input, che è più che sufficiente. Ad ogni iterazione, la shell viene rimossa o mantenuta in base ai suoi valori.

t            % Take a matrix as input. Duplicate
"            % For each column (i.e. repeat that many times)
  t5LY)      %   Duplicate top of the stack. Extract first and last rows
  y5LZ)      %   Duplicate the element below the top. Extract first and last columns
  h          %   Concatenate the two arrays into a row vector
  ?          %   If all its entries are non-zero: do nothing
  }          %   Else
    6Lt3$)   %     Get the central part
             % End if, end for. Implicitly display

Pyth, 19 byte

.W}\0.-`H`JutCPG2HJ

Suite di test

.W}\0.-`H`JutCPG2HJ
.W                     While the first function returns true, apply the second
                       function, starting with the input.
           u    2H     Apply the following twice to the input:
              PG       Remove the last row
             C         Transpose
            t          Remove the first row
                       This removes the outermost shell.
          J            Save it to J
         `             Stringify the matrix
       `H              Stringify the input
     .-                Multiset difference
  }\0                  Check if there is a '0' in the resulting string.
                  J    If that succeeds, update the current value to J.
                       When it fails, return the current value.

JavaScript (ES6), 74 byte

f=s=>/^.*0|0\n|\n0|0.*$/.test(s)?f(s.replace(/^.*\n?|.(.*).|\n.*$/g,"$1")):s

Accetta input sotto forma di una stringa con newline che separano ogni riga (ma nessuna nuova riga iniziale o finale). Spiegazione: /^.*0|0\n|\n0|0.*$/è un regexp che le partite piazze contaminati, mentre /^.*\n?|.(.*).|\n.*$/le partite che le parti della piazza, che devono essere cancellati, fatta eccezione per il (.*)quale deve essere mantenuto. (Questo è più breve di guardare avanti o indietro per il personaggio newline.)

Perl 5, 63 + 3 = 66 byte

$_=<>;s/\A.*\n?|^.|.$|\n.*\Z//mg while/\A.*0|0$|^0|0.*\Z/;print

Richiede la -0bandiera. L'input non deve contenere un carattere di nuova riga finale.

Pyke, 29 byte

"D3lt%sBR,"2*ER3*I
/)tOmtmOr;

Provalo qui!

Anche 29 byte

QeQhQmhQme]4sBI
/)QtOmtmO=Qr;

Provalo qui!

Pyth , 31 30 byte

L+hbeb.W!*F+1iRTs+yHyMHPtmPtdZ

Suite di test. (Gli ultimi errori di testcase)

Miglioramento: fatto parte del anello esterno estrattore una funzione ( L+hbeb).

Versione precedente a 31 byte:

.W!*F+1iRTs++hHm+hdedHeHPtmPtdZ

Come funziona:

Il codice è fondamentalmente: mentre il prodotto del materiale esterno è zero, buccia esso.

Analizziamo il codice principale (Q è implicito qui):

.W<lambda:H><lambda:Z>Q

Inizia da Q (input), whileprima lambda, eseguire secondo lambda.

La prima parte sarebbe la lambda inH :

!*F+1iRTs++hHm+hdedHeH

La seconda parte sarebbe la lambda inZ :

PtmPtdZ

La prima parte

!*F+1iRTs++hHm+hdedHeH

Analizziamo questo:

s++hHm+hdedHeH

s++             Concatenate:
   hH              1. the first row
     m+hdedH       2. the first and last item of each row
            eH     3. the last row

Poiché Pyth utilizza la notazione con prefisso , questo sarebbe quindi ottenere valutati:

!*F+1iRT

     iRT  Convert each to integer
 *F+1     Product
!         Negate. If any element of the outer shell is zero, this would return 1.

La seconda parte

PtmPtdZ
  mPtdZ   the inner of each row
Pt        the inner rows

Mathematica, 78 byte

NestWhile[#[[a=2;;-2,a]]&,#,Count[{#[[b={1,-1}]],#[[;;,b]]},0,3]>0&]~Check~{}&

Funzione anonima, accetta input come matrice. Ignora eventuali errori che possono verificarsi durante l'esecuzione.