Introducción

Observemos el siguiente cuadrado, que consta solo de los dígitos 0 - 9:

1034
4167
8414
3542

La capa exterior de este cuadrado es:

1034
4  7
8  4
3542

Contiene ceros, por lo que debemos despegar la capa exterior, dejando:

16
41

La capa exterior de este cuadrado es:

16
41

No , no contiene ningún cero y por lo tanto es un no contaminado cuadrado. Básicamente, la definición de un cuadrado no contaminado es cuando la capa externa del cuadrado no contiene ceros.

La tarea

Dado un cuadrado de dígitos (que contiene solo números enteros no negativos) en cualquier formato razonable, genera el cuadrado no contaminado más grande despegando constantemente la cáscara externa, en cualquier formato razonable.

Casos de prueba

Caso de prueba 1:

Input         Output

1234          1234
2345          2345
3456          3456
4567          4567

Caso de prueba 2:

Input         Output

123           123
204           204
346           346

Caso de prueba 3:

Input         Output

101           1
010           
101           

Caso de prueba 4:

Input         Output

000           (none)
000
000

Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.

Jalea , 19 16 bytes

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

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

ḊṖ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 bytes

¡Ahorré 8 bytes gracias 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

Define la función s , que devuelve una matriz 2D de enteros cuando se proporciona una matriz 2D de enteros como entrada.

Cómo funciona

• función l: dada una matriza , devuelve una copia sin su primer y último índice.

• función p: dada una matriz 2D a, llamadas lpara eliminar la primera y última fila, luego para cada fila restante llamadasl para eliminar el puño y la última columna. Esto realiza el pelado de cebolla.

• función c: dada una matriz 2D a, devuelve una cadena que solo contiene la 0s en forma de cadena dea .

• función s: dada una matriz 2D a, invoca cla forma pelada de la matriz dada por py en la matriz misma. Compara estas cadenas lexicográficamente para determinar si la forma pelada tiene menos 0s que la original. Si lo hace, entonces el original está contaminado, así que recurra srecursivamente en la forma pelada. De lo contrario, devuelva el original.

Retina , 60 57 bytes

El recuento de bytes asume la codificación ISO 8859-1. El avance de línea final es significativo.

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

Pruébalo en línea!

Explicación

Debido al avance de línea final, esto encuentra todas las coincidencias de la expresión regular después de la `y las elimina de la entrada. Debido al inicio, +esto se hace repetidamente hasta que la salida deja de cambiar (lo que se debe a que la expresión regular dejará de coincidir).

En cuanto a la expresión regular en sí, consta de dos partes:

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

Esta parte verifica si hay un 0lugar en la capa externa. Lo hace moviendo el "cursor" del motor de expresiones regulares al comienzo de la cadena con una mirada hacia atrás (usamos [^_]para unir los dígitos y los avances de línea):

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

Y luego, desde esa posición, usamos una búsqueda anticipada para encontrar 0uno en la primera línea, adyacente a un salto de línea, o en la última línea:

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

Luego, la coincidencia real consistirá en la primera línea (incluido su avance de línea final), la última línea (incluido su avance de línea principal) o el primer o último carácter de una línea, donde abusamos del límite de la palabra \bcomo principio / fin de línea ancla:

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

MATL , 26 21 bytes

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

La entrada está en el siguiente formato

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

Entonces los otros cuatro casos de prueba son

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

El programa falla en el último caso de prueba, pero produce la salida correcta (que no es nada). ¡Gracias a @Dennis por notarlo!

Pruébalo en línea! . O verifique todos los casos de prueba (esto incluye el código de ajuste).

Explicación

Esto itera tantas veces como el número de columnas en la matriz de entrada, que es más que suficiente. En cada iteración, el shell se elimina o se mantiene según sus valores.

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 bytes

.W}\0.-`H`JutCPG2HJ

Banco de pruebas

.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 bytes

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

Toma la entrada en forma de una cadena con líneas nuevas que separan cada fila (pero no líneas nuevas iniciales o finales). Explicación: /^.*0|0\n|\n0|0.*$/es una expresión regular que coincide con los cuadrados contaminados, mientras /^.*\n?|.(.*).|\n.*$/que coincide con las partes del cuadrado que deben eliminarse, excepto las (.*)que deben mantenerse. (Esto es más corto que mirar hacia adelante o hacia atrás para el personaje de nueva línea).

Perl 5, 63 + 3 = 66 bytes

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

Requiere la -0bandera. La entrada no debe contener un carácter de nueva línea final.

Pyke, 29 bytes

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

Pruébalo aquí!

También 29 bytes

QeQhQmhQme]4sBI
/)QtOmtmO=Qr;

Pruébalo aquí!

Pyth , 31 30 bytes

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

Banco de pruebas.(Los últimos errores del caso de prueba)

Mejora: hizo parte del extractor de bucle externo una función (L+hbeb ).

Versión anterior de 31 bytes:

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

Cómo funciona:

El código es básicamente: mientras que el producto de la capa externa es cero, pélelo.

Analicemos el código principal (Q está implícito aquí):

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

Comience desde Q(entrada), whileprimer lambda, realice el segundo lambda.

La primera parte sería la lambda en H:

!*F+1iRTs++hHm+hdedHeH

La segunda parte sería la lambda en Z:

PtmPtdZ

La primera parte

!*F+1iRTs++hHm+hdedHeH

Analicemos esto:

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

Dado que Pyth usa la notación de prefijo , esto se evaluaría:

!*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 segunda parte

PtmPtdZ
  mPtdZ   the inner of each row
Pt        the inner rows

Mathematica, 78 bytes

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

Función anónima, toma la entrada como una matriz. Ignore cualquier error que pueda resultar durante la ejecución.