Einführung

Betrachten wir das folgende Quadrat, das nur aus den Ziffern besteht 0 - 9:

1034
4167
8414
3542

Die äußere Hülle dieses Quadrats ist:

1034
4  7
8  4
3542

Es enthält Nullen, daher müssen wir die äußere Hülle abziehen und Folgendes zurücklassen:

16
41

Die äußere Hülle dieses Quadrats ist:

16
41

Es spielt keine keine Nullen enthalten und ist daher ein nicht-kontaminierten Platz. Die Definition eines nicht kontaminierten Quadrats ist also im Grunde genommen, wenn die äußere Hülle des Quadrats keine Nullen enthält .

Die Aufgabe

Bei einem Quadrat mit Ziffern (das nur nicht negative ganze Zahlen enthält) in einem beliebigen vernünftigen Format geben Sie das größte nicht kontaminierte Quadrat aus, indem Sie die äußere Hülle in einem beliebigen vernünftigen Format ständig abziehen.

Testfälle

Testfall 1:

Input         Output

1234          1234
2345          2345
3456          3456
4567          4567

Testfall 2:

Input         Output

123           123
204           204
346           346

Testfall 3:

Input         Output

101           1
010           
101           

Testfall 4:

Input         Output

000           (none)
000
000

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Jelly , 19 16 Bytes

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

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

8 Bytes gespart dank @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

Definiert eine Funktion s, die ein 2D-Array von Ganzzahlen zurückgibt, wenn ein 2D-Array von Ganzzahlen als Eingabe bereitgestellt wird.

Wie es funktioniert

• Funktion l: ein Array gegebena eine Kopie ohne den ersten und den letzten Index zurück.

• Funktion p: aruft bei einem 2D-Array lauf, die erste und die letzte Zeile zu entfernen, und dann für jede verbleibende Zeilel auf, die erste und die letzte Spalte zu entfernen. Dies führt das Zwiebelschälen durch.

• Funktion c: Gibt bei einem 2D-Array aeine Zeichenfolge zurück, die nur das 0s in der Zeichenfolge von enthälta .

• Funktion s: Bei einem 2D - Array a, Anrufe cauf der geschälten Form des Arrays gegeben durch p, und auf dem Array selbst. Vergleicht diese Zeichenfolgen lexikografisch, um festzustellen, ob die geschälte Form weniger 0s als das Original enthält. Wenn dies der Fall ist, ist das Original kontaminiert. Rufen Sie daher sdas geschälte Formular rekursiv auf. Ansonsten senden Sie das Original zurück.

Retina , 60 57 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus. Der Zeilenvorschub am Ende ist signifikant.

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

Probieren Sie es online!

Erläuterung

Aufgrund des nachfolgenden Zeilenvorschubs werden nach dem alle Übereinstimmungen des regulären Ausdrucks gefunden `und aus der Eingabe entfernt. Aufgrund des Führens +wird dies so oft wiederholt, bis sich die Ausgabe nicht mehr ändert (was darauf zurückzuführen ist, dass der reguläre Ausdruck nicht mehr übereinstimmt).

Die Regex selbst besteht aus zwei Teilen:

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

Dieser Teil prüft, ob 0irgendwo in der Außenhülle eine ist. Dies geschieht, indem der "Cursor" der Regex-Engine mit einem Lookbehind an den Anfang der Zeichenfolge bewegt wird (wir verwenden ihn [^_], um sowohl Ziffern als auch Zeilenvorschübe abzugleichen ):

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

Und dann verwenden wir von dieser Position aus einen Lookahead, um 0entweder in der ersten Zeile neben einem Zeilenvorschub oder in der letzten Zeile einen zu finden:

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

Dann besteht die tatsächliche Übereinstimmung entweder aus der ersten Zeile (einschließlich des nachfolgenden Zeilenvorschubs), der letzten Zeile (einschließlich des führenden Zeilenvorschubs) oder dem ersten oder letzten Zeichen einer Zeile, wobei die Wortgrenze \bals Zeilenanfang / -ende missbraucht wird Anker:

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

MATL , 26 21 Bytes

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

Die Eingabe erfolgt im folgenden Format

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

Die anderen vier Testfälle sind es also

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

Der Programmfehler im letzten Testfall erzeugt aber die korrekte Ausgabe (was nichts ist). Vielen Dank an @Dennis für das Bemerken!

Probieren Sie es online! . Oder überprüfen Sie alle Testfälle (einschließlich Umbruchcode).

Erläuterung

Dies wiederholt sich so oft wie die Anzahl der Spalten in der Eingabematrix, was mehr als ausreichend ist. Bei jeder Iteration wird die Shell in Abhängigkeit von ihren Werten entfernt oder beibehalten.

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

Testsuite

.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

Erfolgt die Eingabe in Form einer Zeichenfolge mit Zeilenumbrüchen, die jede Zeile trennen (jedoch keine führenden oder nachfolgenden Zeilenumbrüche). Erläuterung: /^.*0|0\n|\n0|0.*$/ist ein regulärer Ausdruck, der kontaminierten Feldern entspricht, während er den /^.*\n?|.(.*).|\n.*$/Teilen des Feldes entspricht, die gelöscht werden müssen, mit Ausnahme derjenigen (.*), die beibehalten werden müssen. (Dies ist kürzer als nach vorne oder hinten für das Zeilenumbruchszeichen zu suchen.)

Perl 5, 63 + 3 = 66 Bytes

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

Benötigt die -0Flagge. Die Eingabe sollte kein nachgestelltes Zeilenumbruchzeichen enthalten.

Pyke, 29 Bytes

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

Probieren Sie es hier aus!

Auch 29 Bytes

QeQhQmhQme]4sBI
/)QtOmtmO=Qr;

Probieren Sie es hier aus!

Pyth , 31 30 Bytes

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

Testsuite. (Die letzten Testfallfehler)

Verbesserung: Teil des Outer-Loop-Extraktors wurde zu einer Funktion ( L+hbeb).

Vorherige 31-Byte-Version:

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

Wie es funktioniert:

Der Code lautet im Grunde: Während das Produkt der Außenhülle Null ist, schälen Sie es.

Analysieren wir den Hauptcode (Q ist hier implizit):

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

Start von Q(Eingabe), whileerstes Lambda, zweites Lambda durchführen.

Der erste Teil wäre der Lambda in H:

!*F+1iRTs++hHm+hdedHeH

Der zweite Teil wäre der Lambda in Z:

PtmPtdZ

Der erste Teil

!*F+1iRTs++hHm+hdedHeH

Lassen Sie uns das analysieren:

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

Da Pyth Präfixnotation verwendet , wird dies ausgewertet:

!*F+1iRT

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

Der zweite Teil

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

Anonyme Funktion, nimmt Eingaben als Matrix auf. Ignorieren Sie alle Fehler, die während der Ausführung auftreten können.