Introdução

Vamos observar o seguinte quadrado, consistindo apenas nos dígitos 0 - 9:

1034
4167
8414
3542

A concha externa deste quadrado é:

1034
4  7
8  4
3542

Ele contém zeros, então precisamos descascar a casca externa, deixando:

16
41

A concha externa deste quadrado é:

16
41

Ele não contém zeros e, portanto, é um quadrado não contaminado . Então, basicamente, a definição de um quadrado não contaminado é quando a casca externa do quadrado não contém zeros.

A tarefa

Dado um quadrado de dígitos (contendo apenas números inteiros não negativos) em qualquer formato razoável, produza o maior quadrado não contaminado , descascando constantemente a casca externa, em qualquer formato razoável.

Casos de teste

Caso de teste 1:

Input         Output

1234          1234
2345          2345
3456          3456
4567          4567

Caso de teste 2:

Input         Output

123           123
204           204
346           346

Caso de teste 3:

Input         Output

101           1
010           
101           

Caso de teste 4:

Input         Output

000           (none)
000
000

Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

Geléia , 19 16 bytes

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

Experimente online! ou verifique todos os casos de teste .

Como 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

Economizei 8 bytes graças 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 a função s, que retorna uma matriz 2D de números inteiros quando fornecida uma matriz 2D de números inteiros como entrada.

Como funciona

• função l: dada uma matriz a, retorna uma cópia sem o primeiro e o último índice.

• função p: dada uma matriz 2D a, chama lpara remover a primeira e a última linha e, em cada linha restante, chama lpara remover o punho e a última coluna. Isso realiza o descascamento da cebola.

• function c: dada uma matriz 2D a, retorna uma string que contém apenas os 0s na forma stringified de a.

• function s: dado um array 2D a, chama ca forma descascada do array fornecida por pe no próprio array. Compara essas seqüências lexicograficamente para determinar se a forma descascada tem menos 0s que o original. Caso isso aconteça, o original está contaminado, portanto chame srecursivamente o formulário descascado. Caso contrário, devolva o original.

Retina , 60 57 bytes

A contagem de bytes assume a codificação ISO 8859-1. O avanço de linha à direita é significativo.

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

Experimente online!

Explicação

Devido ao avanço de linha à direita, ele encontra todas as correspondências da regex após a `e as remove da entrada. Devido à liderança, +isso é feito repetidamente até que a saída pare de mudar (o que ocorre porque o regex deixará de corresponder).

Quanto ao próprio regex, ele consiste em duas partes:

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

Esta parte verifica se há algum 0lugar no shell externo. Isso é feito movendo o "cursor" do mecanismo de expressão regular para o início da string com um lookback (usamos [^_]para combinar os dígitos e os feeds de linha):

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

E, a partir dessa posição, usamos um lookahead para encontrar um 0na primeira linha, adjacente a um avanço de linha ou na última linha:

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

A correspondência real consistirá na primeira linha (incluindo seu avanço de linha à direita), na última linha (incluindo seu avanço de linha inicial) ou no primeiro ou no último caractere de uma linha, onde abusamos do limite da palavra \bcomo início / fim da linha âncora:

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

MATL , 26 21 bytes

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

A entrada está no seguinte formato

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

Portanto, os outros quatro casos de teste são

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

O programa falha no último caso de teste, mas produz a saída correta (que não é nada). Obrigado a @Dennis por perceber!

Experimente online! . Ou verifique todos os casos de teste (isso inclui o código de quebra).

Explicação

Isso itera tantas vezes quanto o número de colunas na matriz de entrada, o que é mais que suficiente. A cada iteração, o shell é removido ou mantido dependendo de seus 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

Pitão, 19 bytes

.W}\0.-`H`JutCPG2HJ

Suíte de teste

.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

Recebe entrada na forma de uma seqüência de caracteres com novas linhas separando cada linha (mas nenhuma nova linha inicial ou posterior). Explicação: /^.*0|0\n|\n0|0.*$/é uma regexp que corresponde a quadrados contaminados, enquanto /^.*\n?|.(.*).|\n.*$/corresponde àquelas partes do quadrado que precisam ser excluídas, exceto a (.*)que precisa ser mantida. (Isso é mais curto do que olhar para frente ou para trás para o caractere de nova linha.)

Perl 5, 63 + 3 = 66 bytes

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

Requer a -0bandeira. A entrada não deve conter um caractere de nova linha à direita.

Pyke, 29 bytes

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

Experimente aqui!

Também 29 bytes

QeQhQmhQme]4sBI
/)QtOmtmO=Qr;

Experimente aqui!

Pitão , 31 30 bytes

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

Suíte de teste. (Os últimos erros do testcase)

Melhoria: fez do extrator de loop externo uma função ( L+hbeb).

Versão anterior de 31 bytes:

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

Como funciona:

O código é basicamente: enquanto o produto do escudo externo é zero, retire-o.

Vamos analisar o código principal (Q está implícito aqui):

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

Comece em Q(entrada), whileprimeiro lambda, execute o segundo lambda.

A primeira parte seria o lambda em H:

!*F+1iRTs++hHm+hdedHeH

A segunda parte seria a lambda em Z:

PtmPtdZ

A primeira parte

!*F+1iRTs++hHm+hdedHeH

Vamos analisar isso:

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

Como Pyth usa notação de prefixo , isso seria avaliado:

!*F+1iRT

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

A 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~{}&

Função anônima, recebe entrada como uma matriz. Ignore quaisquer erros que possam resultar durante a execução.