introduction

Observons le carré suivant, composé uniquement des chiffres 0 - 9:

1034
4167
8414
3542

L'enveloppe extérieure de ce carré est:

1034
4  7
8  4
3542

Il contient des zéros, donc nous devons décoller de l'enveloppe extérieure, laissant:

16
41

L'enveloppe extérieure de ce carré est:

16
41

Il ne ne contient pas de zéros et est donc un non contaminé carré. Donc, fondamentalement, la définition d'un carré non contaminé est lorsque la coque extérieure du carré ne contient pas de zéros.

La tâche

Étant donné un carré de chiffres (contenant uniquement des entiers non négatifs) dans n'importe quel format raisonnable, sortez le plus grand carré non contaminé en décollant constamment la coque extérieure, dans n'importe quel format raisonnable.

Cas de test

Cas de test 1:

Input         Output

1234          1234
2345          2345
3456          3456
4567          4567

Cas de test 2:

Input         Output

123           123
204           204
346           346

Cas de test 3:

Input         Output

101           1
010           
101           

Cas de test 4:

Input         Output

000           (none)
000
000

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Gelée , 19 16 octets

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

Essayez-le en ligne!ou vérifiez tous les cas de test .

Comment ça fonctionne

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

8 octets enregistrés grâce à @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

Définit la fonction s , qui renvoie un tableau 2D d'entiers lorsque fourni un tableau 2D d'entiers en entrée.

Comment ça fonctionne

• fonction l: étant donné un tableaua , retourne une copie sans ses premier et dernier index.

• fonction p: étant donné un tableau 2D a, appelle lpour supprimer la première et la dernière ligne, puis pour chaque ligne restante, appellel pour supprimer le premier et la dernière colonne. Cela effectue le pelage de l'oignon.

• fonction c: étant donné un tableau 2D a, retourne une chaîne qui ne contient que le 0s sous la forme chaîne dea .

• fonction s: étant donné un tableau 2D a, fait appel cà la forme pelée du tableau donnée par p, et au tableau lui-même. Compare ces chaînes lexicographiquement pour déterminer si la forme pelée a moins de 0s que l'original. Si c'est le cas, l'original est contaminé, appelez donc srécursivement sur la forme pelée. Sinon, renvoyez l'original.

Rétine , 60 57 octets

Le nombre d'octets suppose un codage ISO 8859-1. Le saut de ligne arrière est important.

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

Essayez-le en ligne!

Explication

En raison du saut de ligne de fin, cela trouve toutes les correspondances de l'expression régulière après le `et les supprime de l'entrée. En raison de la direction+ cela se fait à plusieurs reprises jusqu'à ce que la sortie cesse de changer (ce qui sera dû au fait que l'expression régulière cessera de correspondre).

Quant à l'expression régulière elle-même, elle se compose de deux parties:

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

Cette partie vérifie s'il y a un 0endroit dans la coque extérieure. Il le fait en déplaçant le "curseur" du moteur d'expression régulière au début de la chaîne avec un lookbehind (nous utilisons [^_]pour faire correspondre les chiffres et les sauts de ligne):

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

Et puis à partir de cette position, nous utilisons un lookahead pour trouver un 0dans la première ligne, à côté d'un saut de ligne, ou dans la dernière ligne:

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

Ensuite, la correspondance réelle consistera soit en la première ligne (y compris son saut de ligne de fin), la dernière ligne (y compris son saut de ligne de tête) ou le premier ou le dernier caractère d'une ligne, où nous abusons de la limite de mot \bcomme début / fin de ligne ancre:

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

MATL , 26 21 octets

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

L'entrée est au format suivant

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

Ainsi, les quatre autres cas de test sont

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

Le programme fait une erreur dans le dernier cas de test, mais produit la sortie correcte (qui n'est rien). Merci à @Dennis de l'avoir remarqué!

Essayez-le en ligne! . Ou vérifiez tous les cas de test (cela inclut le code d'habillage).

Explication

Cela répète autant de fois que le nombre de colonnes dans la matrice d'entrée, ce qui est plus que suffisant. A chaque itération, le shell est supprimé ou conservé en fonction de ses valeurs.

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 octets

.W}\0.-`H`JutCPG2HJ

Suite de tests

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

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

Prend l'entrée sous la forme d'une chaîne avec des retours à la ligne séparant chaque ligne (mais pas de retour à la ligne de début ou de fin). Explication: /^.*0|0\n|\n0|0.*$/est une expression rationnelle qui correspond aux carrés contaminés, tandis qu'elle /^.*\n?|.(.*).|\n.*$/correspond aux parties du carré qui doivent être supprimées, à l'exception de celles (.*)qui doivent être conservées. (C'est plus court que de regarder en avant ou en arrière pour le caractère de nouvelle ligne.)

Perl 5, 63 + 3 = 66 octets

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

Nécessite le -0drapeau. L'entrée ne doit pas contenir de caractère de fin de ligne.

Pyke, 29 octets

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

Essayez-le ici!

Aussi 29 octets

QeQhQmhQme]4sBI
/)QtOmtmO=Qr;

Essayez-le ici!

Pyth , 31 30 octets

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

Suite de tests.(Les dernières erreurs de testcase)

Amélioration: fait de l'extracteur de boucle externe une fonction ( L+hbeb).

Version précédente de 31 octets:

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

Comment ça fonctionne:

Le code est fondamentalement: alors que le produit de la coque extérieure est nul, décollez-le.

Analysons le code principal (Q est implicite ici):

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

Commencez par Q(entrée), whilepremier lambda, effectuez le deuxième lambda.

La première partie serait le lambda dans H:

!*F+1iRTs++hHm+hdedHeH

La deuxième partie serait le lambda dans Z:

PtmPtdZ

La première partie

!*F+1iRTs++hHm+hdedHeH

Analysons ceci:

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

Puisque Pyth utilise la notation de préfixe , cela serait alors évalué:

!*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 seconde partie

PtmPtdZ
  mPtdZ   the inner of each row
Pt        the inner rows

Mathematica, 78 octets

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

Fonction anonyme, prend l'entrée comme une matrice. Ignorez toutes les erreurs pouvant survenir lors de l'exécution.