介绍

让我们观察以下仅由数字组成的正方形0 - 9：

1034
4167
8414
3542

这个正方形的外壳是：

1034
4  7
8  4
3542

它包含零，因此我们需要剥去外壳，留下：

16
41

这个正方形的外壳是：

16
41

它不包含任何零，因此是一种无污染的正方形。因此，基本上，无污染正方形的定义是正方形的外壳不包含零时。

任务

给定任意合理格式的数字平方（仅包含非负整数），请通过不断剥离任意合理格式的外壳来输出最大的无污染平方。

测试用例

测试用例1：

Input         Output

1234          1234
2345          2345
3456          3456
4567          4567

测试案例2：

Input         Output

123           123
204           204
346           346

测试案例3：

Input         Output

101           1
010           
101           

测试案例4：

Input         Output

000           (none)
000
000

这是代码高尔夫球，因此以最少的字节提交为准！

果冻，19 16 字节

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

在线尝试！或验证所有测试用例。

怎么运行的

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

感谢@Patrick Roberts，节省了8个字节！

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

定义function s，当提供2D整数数组作为输入时，该函数返回2D整数数组。

怎么运行的

• 函数l：给定一个数组a，返回不带第一个和最后一个索引的副本。

• 函数p：给定2D数组a，调用l将删除第一行和最后一列，然后对其余每个行调用l以删除第一行和最后一列。这样进行洋葱去皮。

• 函数c：给定一个2D数组a，返回一个字符串，该字符串仅包含0字符串化形式的s a。

• 函数s：给定2D数组a，调用c由给定的数组的剥离形式p以及数组本身。从字典上比较这些字符串，以确定所剥皮的形式的0s 是否小于原始形式的。如果是这样，则说明原件已被污染，因此s以去皮的形式递归调用。否则返回原件。

视网膜，60 57字节

字节数假定为ISO 8859-1编码。尾随换行很重要。

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

在线尝试！

说明

由于尾随换行符，这将找到regex之后的所有正则表达式匹配项，`并将其从输入中删除。由于前导，+这是重复进行的，直到输出停止更改（这是因为正则表达式将停止匹配）。

至于正则表达式本身，它由两部分组成：

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

这部分检查是否有 0外壳中任何地方。它通过将正则表达式引擎的“光标”移动到字符串的开头（带有后缀）来实现（我们[^_]用来匹配数字和换行符）：

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

然后从该位置开始，先行查找 0在换行旁边的第一行或最后一行中：

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

然后，实际匹配将由第一行（包括其尾随的换行符），最后一行（包括其首行换行符）或一行的首个或最后一个字符组成，其中我们将单词边界\b用作行的开头/结尾锚：

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

MATL，26 21字节

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

输入采用以下格式

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

所以其他四个测试用例是

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

程序在最后一个测试用例中出错，但是产生了正确的输出（什么也没有）。感谢@Dennis的注意！

在线尝试！。或验证所有测试用例（包括包装代码）。

说明

这迭代了输入矩阵中列数的次数，这足够了。在每次迭代时，将根据其值移除或保留外壳。

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个字节

.W}\0.-`H`JutCPG2HJ

测试套件

.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个字节

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

以字符串形式输入，每行之间用换行符分隔（但不包含前导或尾随的换行符）。说明：/^.*0|0\n|\n0|0.*$/是一个正则表达式，它与受污染的正方形相匹配，而/^.*\n?|.(.*).|\n.*$/与需要删除的正方形部分相匹配（除了(.*)需要保留的部分）。（这比换行符向前或向后看要短。）

Perl 5，63 + 3 = 66字节

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

需要-0标志。输入应该不包含尾部的换行符。

Pyke，29个字节

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

在这里尝试！

也是29个字节

QeQhQmhQme]4sBI
/)QtOmtmO=Qr;

在这里尝试！

Pyth，31 30字节

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

测试套件。（最后一个测试用例错误）

改进：将外循环提取器的一部分设为一个函数（L+hbeb）。

先前的31字节版本：

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

怎么运行的：

代码基本上是：当外壳的乘积为零时，将其剥离。

让我们分析主要代码（Q在这里是隐式的）：

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

从Q（输入）开始，while第一个lambda，执行第二个lambda。

第一部分将是拉姆达在H：

!*F+1iRTs++hHm+hdedHeH

第二部分将是拉姆达在Z：

PtmPtdZ

第一部分

!*F+1iRTs++hHm+hdedHeH

让我们分析一下：

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

由于Pyth使用前缀表示法，因此可以对其进行评估：

!*F+1iRT

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

第二部分

PtmPtdZ
  mPtdZ   the inner of each row
Pt        the inner rows

Mathematica，78个字节

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

匿名函数，将输入作为矩阵。忽略执行期间可能导致的任何错误。