镂空阵列

35

任务

这个挑战非常简单。您的输入是一个矩形的二维整数数组，大小至少为1×1。可以采用任何合理的格式。您的输出应为输入数组，但所有不在第一行或最后一行或列上的条目均设置为0。它必须与输入格式相同。

例如，如果输入数组是

67  4 -8  5 13
 9 13 42  4 -7
 1  1  3 -9 29
16 99  8 77  0

那么正确的输出是

67  4 -8  5 13
 9  0  0  0 -7
 1  0  0  0 29
16 99  8 77  0

规则和计分

您可以编写完整的程序或函数，并且允许函数在适当位置修改输入而不是返回输入。最低字节数获胜，并且不允许出现标准漏洞。

测试用例

它们被格式化为嵌套列表，以使复制粘贴更加容易。

[[3]] -> [[3]]
[[7,2,8]] -> [[7,2,8]]
[[3],[5],[12],[-6]] -> [[3],[5],[12],[-6]]
[[99,98,97],[88,87,86]] -> [[99,98,97],[88,87,86]]
[[6,7],[8,9],[10,11]] -> [[6,7],[8,9],[10,11]]
[[-1,-2,-3],[1,2,3],[5,5,5]] -> [[-1,-2,-3],[1,0,3],[5,5,5]]
[[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]] -> [[67,4,-8,5,13],[9,0,0,0,-7],[1,0,0,0,29],[16,99,8,77,0]]
[[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0]] -> [[0,1,0,1,0],[1,0,0,0,1],[0,0,0,0,0],[1,0,0,0,1],[0,1,0,1,0]]

排行榜

这是一个堆栈片段，用于按语言生成常规排行榜和获胜者概述。为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

## Language Name, N bytes

如果要包含多个数字（例如，由于您提高了分数或要单独列出解释器标记），请确保实际分数是标题中的最后一个数字：

## Perl, <s>50</s> 43 + 2 (-p flag) = 45 bytes

您还可以将语言名称设置为链接，然后该链接将显示在页首横幅代码段中：

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

显示代码段

code-golf  array-manipulation 
— 兹加布
source

Answers:

13

MATL，9个字节

0HJ_ht4$(

输入格式为

[67  4 -8  5 13;  9 13 42  4 -7;  1  1  3 -9 29; 16 99  8 77  0]

编辑（2016年6月12日）：为了适应语言的更改，下面的链接已_替换为q。

在线尝试！

0           % Push a 0: value that will be assigned into the array
HJ_h        % Vector [2, -1j]: this corresponds to index 2:end-1 for rows
t           % Duplicate: same index for columns
4$(         % Assignment indexing with 4 inputs: array, new value, row and col indices
            % Since the first input (array) to this function is currently missing, it's
            % implicitly taken at this point from stdin
            % Implicitly display stack contents, which is the modified array
— 路易斯·门多
source
2
真好！我知道MATL会不断发展。：D
— 烧杯
12

Java 7，作为全名功能：85

void f(int[][]a){for(int i=0,j;++i<a.length-1;)for(j=1;j<a[i].length-1;)a[i][j++]=0;}

您可以在Java 8中对此进行lambda删除，以删除一些字节，但是我实际上并不这样做。

— 地位
source
您可以使用来节省空间Arrays.fill(a[i],1,a[i].length-1,0);吗？它只有36个字节而不是37个字节。=）
— corsiKa
@corsiKa很好，但是我必须导入或完全限定它：/
— Geobits，2016年
出于好奇，为什么两个循环都不同？为什么不for(int i=0,j;++i<a.length-1;)for(j=0;++j<a[i].length-1;)a[i][j]=0;呢？它不保存任何字节，但是在两个循环相同的情况下更加一致。：）
— 凯文·克鲁伊森
12

果冻，18 17 15 9字节

0W&ṖZ
ÇÇ^

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

背景

这种方法基于@ Sp3000的Jelly答案，特别是基于他的想法，即利用不同长度的列表之间的矢量化运算。

我们从输入的第一行中的0与每个整数的按位与开始。由于自动矢量化，可以通过取[0]的按位与与输入（不包含最后一行）来实现。0与第一行配对，导致一行零。由于剩余的行在[0]中没有对应的行，因此它们保持不变。

现在我们转置结果，再次应用上述变换（有效地删除最后一列并将第一列清零），然后再次转置。

对于输入

 67   4  -8   5  13
  9  13  42   4  -7
  1   1   3  -9  29
 16  99   8  77   0

这导致

  0   0   0   0
  0  13  42   4
  0   1   3  -9

现在，我们对该结果与原始矩阵进行按位异或。将整数与自身进行异或运算将得出0。将整数与0进行XOR（或根本不对其进行XOR）会产生相同的整数。这将矩阵挖空。

怎么运行的

0W&ṖZ    Helper link. Argument: M (matrix)

0W       Yield [0].
   Ṗ     Yield M, without its last row.
  &      Take the bitwise AND of both.
    Z    Zip the result.

ÇÇ^      Main link. Input: A (matrix)

Ç        Call the helper link on A.
 Ç       Call the helper link on the result.
  ^      Take the bitwise XOR of the result and A.
— 丹尼斯
source
8

Mathematica，27个字节

(a=#;a[[2;;-2,2;;-2]]=0;a)&
— Alephalpha
source
2
令人印象深刻。现在，您能解释一下吗？看起来您正在将内部单元格重新分配为零，并且-2s表示倒数第二列或第二行。
— DavidC
多么简单！
— njpipeorgan
7

R，33 48字节

我知道，R不是打高尔夫球的。但是它是为位置索引而设计的。

a <- matrix(c(67,4,-8,5,13,9,13,42,4,-7,1,1,3,-9,29,16,99,8,77,0), ncol=5, byrow=TRUE)
a
#      [,1] [,2] [,3] [,4] [,5]
# [1,]   67    4   -8    5   13
# [2,]    9   13   42    4   -7
# [3,]    1    1    3   -9   29
# [4,]   16   99    8   77    0

将不在边缘行或边缘列上任何位置的值替换为0：

x <- function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]<-0;a}

x(a)
#      [,1] [,2] [,3] [,4] [,5]
# [1,]   67    4   -8    5   13
# [2,]    9    0    0    0   -7
# [3,]    1    0    0    0   29
# [4,]   16   99    8   77    0

还检查2列测试：

b <- matrix(c(99,98,97,88,87,86), ncol=2, byrow=TRUE)
b
#     [,1] [,2]
#[1,]   99   98
#[2,]   97   88
#[3,]   87   86

x(b)
#     [,1] [,2]
#[1,]   99   98
#[2,]   97   88
#[3,]   87   86

后代：先前的尝试

# a[2:(nrow(a)-1),2:(ncol(a)-1)]<-0 # previous attempt

测试所有示例：

tests <- read.table(text="[[3]] -> [[3]]
                          [[7,2,8]] -> [[7,2,8]]
                          [[3],[5],[12],[-6]] -> [[3],[5],[12],[-6]]
                          [[99,98,97],[88,87,86]] -> [[99,98,97],[88,87,86]]
                          [[6,7],[8,9],[10,11]] -> [[6,7],[8,9],[10,11]]
                          [[-1,-2,-3],[1,2,3],[5,5,5]] -> [[-1,-2,-3],[1,0,3],[5,5,5]]
                          [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]] -> [[67,4,-8,5,13],[9,0,0,0,-7],[1,0,0,0,29],[16,99,8,77,0]]
                          [[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0]] -> [[0,1,0,1,0],[1,0,0,0,1],[0,0,0,0,0],[1,0,0,0,1],[0,1,0,1,0]]")
tests$cols <- c(1,3,1,3,2,3,5,5)
tests$V1 <- gsub("\\[|\\]","",tests$V1)
tests$V1 <- paste0("c(",tests$V1,")")
tests$V3 <- gsub("\\[|\\]","",tests$V3)
tests$V3 <- paste0("c(",tests$V3,")")

testfn <- function(testno) {
  intest <- matrix(eval(parse(text=tests$V1[testno])), ncol=tests$cols[testno], byrow=TRUE)
  intest <- x(intest)
  outtest <- matrix(eval(parse(text=tests$V3[testno])), ncol=tests$cols[testno], byrow=TRUE)
  return(identical(intest, outtest))
}

sapply(seq_len(nrow(tests)), testfn)
# [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE
— 乔纳森·卡洛尔
source
1或2行或列矩阵会发生什么？
— mnel
好点，第一次尝试未通过2列测试，并删除了中间行。我会更新。
— 乔纳森·卡罗尔
1
欢迎来到编程难题和代码高尔夫球！我们要求所有提交的内容均为完整程序或功能。在这种情况下，您的计分代码只是一个片段，因为它假定变量a存在。为了符合我们的规则，您可以使其成为一个采用矩阵的函数，例如function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]=0;a}47个字节。
— Alex A.
6

Mathematica 81 76字节

(d=Dimensions@m;q=MemberQ;m Boole@Array[{1,d[[1]]}~q~#||{1,d[[2]]}~q~#2&,d])&

怎么运行的

假设输入数组存储在中m。的尺寸为m{4,5}`

(m={{67,4,-8,5,13}, {9,13,42,4,-7}, {1,1,3,-9,29}, {16,99,8,77,0}})//MatrixForm

米

a如果该单元格||位于最后一行的第一行或（）或第一列或最后一列，则数组中的每个单元格为True ；否则为False。

(d=Dimensions@m;a=Array[MemberQ[{1,d[[1]]},#]||MemberQ[{1,d[[2]]},#2]&,d])&[m]//MatrixForm

真正

将函数Boole应用于数组会将True转换为1，将False转换为0。

b = Boole[a]

笨蛋

乘矩阵m通过b。这会将m中的每个单元乘以b中的相应单元。

m b

空心矩阵

— 戴维
source
您可以将其||用作OR来保存几个字节，我还可以看到其他几个字节也可以保存！
— 西蒙斯（Simmons）
西蒙斯，谢谢您的建议。
— DavidC 2016年
＃-Unitize @ ArrayFilter [Det，Array [Norm @ * List，Dimensions @＃]，1]＃＆
— njpipeorgan
@njpipeorgan，我建议您提交。（并希望解释一下它是如何工作的！）
— DavidC
@DavidC我已经发布了我的答案
— njpipeorgan
6

GNU Sed，31岁

  • 感谢@manatwork节省了4个字节。

在此提交 （讨论）之前的版本4.2.2或更早版本。

分数包括+1作为-r选项。

输入行以换行符分隔。每行上的元素都是单行分隔的。

1n
$n
:
s/ -?\w+ / : /
t
y/:/0/

说明

1n                   # 1st line: print unchanged, then load next line
$n                   # last line: print unchanged, then load next line (i.e. EOF and stop)
:                    # unnamed label
s/ -?\w+ / : /       # substitute a number in spaces with a `:` in spaces
t                    # If the above matched, jump back to the label and try again
y/:/0/;              # transliterate `:` to `0`

在线尝试。

— 数字创伤
source
1
哦，我明白了，这是一种无需花钱就可以解决的“奇特”方式，谢谢！
— andlrc
1
括号过多：1n;$n;:;s/ -?\w+ / : /;t;y/:/0/。
— manatwork '16
1
您能否在引号中包含有关使您的答案有效的提交信息，该站点确实很慢，并且需要1分钟才能完全加载
— Ferrybig
@manatwork谢谢-保存了4个字节！
— Digital Trauma
@Ferrybig 在此主题的开发人员讨论中添加了另一个链接。
— Digital Trauma
5

八度，34字节

function h(M) M(2:end-1,2:end-1)=0

请注意，输入需要用分号分隔数组行：

h([[3];[5];[12];[-6]])

说明：

倍频程（和MATLAB）数组索引基于1。指定范围Array(1:end)将为您提供数组（在此示例中为一维）的所有元素。Array(2:end-1)将为您提供除第一个和最后一个元素以外的所有元素。

M(2:end-1,2:end-1)=0

设置0所有不在第一行或最后一行或列中的元素：

>> A = [[-1,-2,-3];[1,2,3];[5,5,5]]
A =

  -1  -2  -3
   1   2   3
   5   5   5

>> h(A)
M =

  -1  -2  -3
   1   0   3
   5   5   5

如果维度之一小于或等于2，该范围end-1是少超过2个，因此该范围的端部(2:end-1)小于所述开头。在这种情况下，八度会忽略范围并且不执行任何操作。这类似于for循环：

for (int i=2; i < 2; i++) {...}

停止条件在第一次迭代中为真，因此我们退出了循环。

>> A = [[6,7];[8,9];[10,11]]
A =

    6    7
    8    9
   10   11

>> h(A)
M =

    6    7
    8    9
   10   11
— 烧杯
source
5

果冻，12 字节

ZṖṖ1;¥€
¬ÇÇ×

我认为这行得通，但仍将我的头缠在果冻上。在线尝试！

（感谢@Dennis提供了-2个字节）

通过将输入数组乘以1s和0s的数组来工作，每种方法都小一维。例如，因为[[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]]我们将元素元素乘以

1 1 1 1
1 0 0 0
1 0 0 0

完整说明

[Helper link - argument is a matrix]
Z           Zip
 ṖṖ         Pop last two elements, or [:-2]
   1;¥€     Append a 1 in front of every row

[Main link]
¬           Not, turning 0s to 1s and everything else to 0s. Even though some zeroes
            turn into 1s, it's fine because we multiply element-wise at the end,
            and 0*1 = 0
 ÇÇ         Perform helper link twice
   ×        Multiply element-wise
— Sp3000
source
5

ES6，52个 48 46字节

f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)

编辑：由于@ user81655，节省了4个字节。多亏了@ETHproductions，进一步节省了2个字节。

— 尼尔
source
聪明！这是一种非常相似的方法，没有g它，它可以节省一些字节：f=a=>a.map((b,i)=>i&&a[i+1]!=a.x?b.map?f(b):0:b)
— user81655 '16
不错的工作！我数了48个字节（也许您忘了f=），但您可以将其减少到46：f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)
— ETHproductions 2016年
1
@ETHproductions是的，我确实忘记了数f=。另外，我对+.5作品有些惊讶，但我看到它在另一个调用中添加了字符串。
— 尼尔，
4

Mathematica，55个字节

#-Unitize@ArrayFilter[Det,Power~Array~Dimensions@#,1]#&

测试用例

%[RandomInteger[9,{5,5}]]
(*
  {{8,8,3,6,5},
   {7,0,0,0,4},
   {2,0,0,0,7},
   {3,0,0,0,5},
   {8,6,1,0,8}}
*)

说明

此答案的主要思想与DavidC的答案相同（首先构造一个掩码矩阵，然后将其乘以原始矩阵），但是掩码矩阵的构造不同。

ArrayFilter[f,list,r]映射f到list范围内的每个元素r。

ArrayFilter[f,{1,2,3,4,5},1]
(* { f[{1,1,2}], f[{1,2,3}], f[{2,3,4}], f[{3,4,5}], f[{4,5,5}] } *)

注意边界元素在邻居不足的地方重复。当list2维数为2时，此功能可以很好地配合使用Det并提供所需的结果，因为在四个边界上重复的列或行会消除行列式。

ArrayFilter[Det,Power~Array~{4,4},1]
(*
  {{0, 0,  0,    0},
   {0, 12, 72,   0},
   {0, 48, 1152, 0},
   {0, 0,  0,    0}}
*)

其中Power~Array~{4,4}保证内部位置的决定因素不为零。和

1-Unitize@%
(*
  {{1,1,1,1},
   {1,0,0,1},
   {1,0,0,1},
   {1,1,1,1}}
*)

给出掩码矩阵。

— 新泽西州
source
4

Python，50个字节

def f(a):
 for l in a[1:-1]:l[1:-1]=[0]*(len(l)-2)

接受列表列表，并对其进行修改。Python的slice语法对于此任务并不方便。

我了解到，将列表乘以负数会得到一个空列表，这使上面的代码可以在较小的输入上工作。

— Mathmandan
source
4

朱莉娅，50 35字节

A->A[2:size(A,1)-1,2:size(A,2)-1]=0

这是一个匿名函数，它接受数组并在适当的位置对其进行修改。要调用它，请将其分配给变量。

这里的方法非常简单：对于n × m输入数组A，我们通过构造范围为所有i = 2，...，n -1和j = 2，...，m -1 分配A ij = 0 指数。范围可能为空，例如如果n或m = 1，则不进行替换。

在线尝试

感谢Dennis，节省了15个字节！

— 亚历克斯·A
source
4

C，62字节

y;f(a,b,c)int **a;{for(b--;b-->1;)for(y=1;y<c-1;)a[b][y++]=0;}

希望可以将数组的长度/宽度作为参数。我稍微玩了一下memset / bzero，但是乘以倍数会sizeof(int)大大增加代码的大小。

编辑：55字节，如果我们可以进一步弯曲规则并将数组存储为字符，因为每个输入只有一位数字。

x;
#define f(a,b,c) for(x=1;x<b-1;)bzero(a[x++]+1,c-2);

编辑：感谢华盛顿圭迪斯的提示！

— 乔希
source
您是不是真的想乘以sizeof(int)？您可以4改用...
— anatolyg 2016年
sizeof(int) != 4在我的机器上：P
— 乔什（Josh）2016年
我敢打赌，它仍然是个位数，您可以使用。
— anatolyg
我的意思是到那时，我只能确定它是一个字符数组而不是整数，因为问题仅使用一位数字。只取决于我们想改变规则多远。
— 乔什
谢谢！现在，我也可以使用超然-->运算符；）
— Josh
3

Perl 6，28个字节

{.[1..*-2]»[1..*-2] »=»0}

这样就地修改了输入

用法

my @test-cases = (
  [[3],] => [[3],],
  [[7,2,8],] => [[7,2,8],],
  [[3],[5],[12],[-6]] => [[3],[5],[12],[-6]],
  [[99,98,97],[88,87,86]] => [[99,98,97],[88,87,86]],
  [[6,7],[8,9],[10,11]] => [[6,7],[8,9],[10,11]],
  [[ -1,-2,-3],[1,2,3],[5,5,5]] => [[ -1,-2,-3],[1,0,3],[5,5,5]],
  [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]] => [[67,4,-8,5,13],[9,0,0,0,-7],[1,0,0,0,29],[16,99,8,77,0]],
  [[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0]] => [[0,1,0,1,0],[1,0,0,0,1],[0,0,0,0,0],[1,0,0,0,1],[0,1,0,1,0]],
);

use Test;
plan +@test-cases;

for @test-cases {
  my $k = .key;
  {.[1..*-2]»[1..*-2] »=»0}( $k ); # <==
  ok $k eqv .value
}
1..8
ok 1 - 
ok 2 - 
ok 3 - 
ok 4 - 
ok 5 - 
ok 6 - 
ok 7 - 
ok 8 -
— 布拉德·吉尔伯特b2gills
source
{.[1..*-2]»[1..*-2]X=0}保存2个字节
— raiph
@raiph它似乎不适用于后两种情况
— Brad Gilbert b2gills
3

JavaScript的ES6，69个 66 57字节

Y=>Y.map((X,y)=>X.map((N,x)=>x*y&&X[x+1]+.5&&Y[y+1]?0:N))

怎么运行的

此解决方案映射输入中的每个y-index y和x-index x，并根据这两个索引决定是否将其丢弃。我们需要保留四种情况：

  • x 是0
  • y 是0
  • x 等于内部数组的长度减去1
  • y 等于外部数组的长度减去1

我们可以通过稍加乘法来处理前两个：x*y返回0iff或者xor y为0，否则返回一个正整数。现在是第三个：我们可以检查是否为X.length>x+1，但这需要很多字节。另一种方法是检查前面的项目是否虚假，即undefined，这是您尝试访问不存在的项目时得到的结果。但是，如果下一项是，这也会匹配0，因此我们添加0.5以确保不会发生这种情况：

1 + 0.5 = 1.5 (truthy)
0 + 0.5 = 0.5 (truthy)
-1 + 0.5 = -0.5 (truthy)
undefined + 0.5 = NaN (falsy)

最后，第四点：由于外部数组内部只有数组，而且任何数组都是真实的，所以我们可以检查一下Y[y+1]。现在使用?0:N，我们将其转换0为以上所有结果为真；N除此以外。就是这样！

— ETH生产
source
3

视网膜，31 24 22

(?<=¶.+ )\S+(?= .*¶)
0

由于randomra，节省了2个字节

在线尝试！

可能有更好的方法，因为这只是一个非常基本的多行替换。本质上，我们发现每个数字都以换行符开头，一定数量的字符和一个空格，然后立即跟一个空格，然后又是一个换行符。这些数字都将全部替换为0。

这将不会保留列填充，但我认为这不是问题。

— 弗莱姆·埃格曼
source
3

Java 8，作为lambda函数：82 83 95字符/字节

Lambda签名：（int[][] -> (void)即Consumer<int[][]>）

(a)->{int[]v={1,1};while(++v[0]<a.length){while(++v[1]<a[0].length)a[v[0]-1][v[1]-1]=0;v[1]=1}}

编辑犯了一个错误，我认为a [x，y]是第x行和yth col。显然，它应该是[[x] [y]！

编辑我忘了测试代码，并且每次循环内都需要将列设置为零，即+12字节。：/

— 超中微子
source
3

哈斯克尔， 59 58个字节

k _[x]=[x]
k f(x:y)=x:(f<$>init y)++[last y]
f=k(k(\_->0))

展开式

onInner :: (a -> a) -> [a] -> [a]
onInner _ [x]    = [x]
onInner f (x:xs) = x : map f (init xs) ++ [last xs]

hollowOut :: [[Int]] -> [[Int]]
hollowOut = 
   onInner       -- leave first and last line alone 
     (onInner    -- leave first and last entry per line 
       (const 0) -- replace entries by 0
     )
— 泽塔
source
你应该能转++[last y]成:(last y)或:last y
— HEGX64
@ HEGX64：不，类型错误。x : map f (…)已经是type [a]，并且last y具有type a，而(:) :: a -> [a] -> [a]。在Haskell中，在列表末尾添加元素很烂，因为这些列表是单链接的前向列表。
— Zeta
哎呀 我知道我应该在发布之前
— 亲自
1
你可以把k成中缀运算符，假设#和翻转的参数保存一个字节：[x]#_=...，(x:y)#f=...，f=(#(# \_->0))并且你可以将你的主要功能，即名称f=为另外两个字节。
— nimi
2

Pyth，18个字节

Qjbm:dSttld0P.Qe.Q

说明

                   - autoassign Q=eval(input())
                   - autoassign .Q = map(eval, rest_of_input)
Q                  - imp_print(Q)
   m        P.Q    -  [V for d in .Q[:-1]]
      Sttld        -     range(1, len(d)-2+1)
    :d     0       -    assign_indexes(d, ^, 0)
 jb                - "\n".join(^)
               e.Q - imp_print(.Q[-1])

输入数组用换行符分隔

在这里尝试

— 蓝色
source
2

Groovy，70个字节

这不是很有创意，但是很短！

g={a->for(i=1;i<a.size()-1;i++)for(j=1;j<a[i].size()-1;)a[i][j++]=0;a}

说明

一个arg关闭

g={a->

遍历内部数组，跳过第一个和最后一个元素

for(i=1;i<a.size()-1;i++)

遍历内部数组中的中间项

for(j=1;j<a[i].size()-1;)

将元素设置为0并返回a

a[i][j++]=0;a}

测验

assert g([[3]]) == [[3]]
assert g([[7, 2, 8]]) == [[7, 2, 8]]
assert g([[3], [5], [12], [-6]]) == [[3], [5], [12], [-6]]
assert g([[99, 98, 97], [88, 87, 86]]) == [[99, 98, 97], [88, 87, 86]]
assert g([[6, 7], [8, 9], [10, 11]]) == [[6, 7], [8, 9], [10, 11]]
assert g([[-1, -2, -3], [1, 2, 3], [5, 5, 5]]) == [[-1, -2, -3], [1, 0, 3], [5, 5, 5]]
assert g([[67, 4, -8, 5, 13], [9, 13, 42, 4, -7], [1, 1, 3, -9, 29], [16, 99, 8, 77, 0]]) == [[67, 4, -8, 5, 13], [9, 0, 0, 0, -7], [1, 0, 0, 0, 29], [16, 99, 8, 77, 0]]
assert g([[0, 1, 0, 1, 0], [1, 0, 1, 0, 1], [0, 1, 0, 1, 0], [1, 0, 1, 0, 1], [0, 1, 0, 1, 0]]) == [[0, 1, 0, 1, 0], [1, 0, 0, 0, 1], [0, 0, 0, 0, 0], [1, 0, 0, 0, 1], [0, 1, 0, 1, 0]]
— 阿特金
source
2

R，71 64 57字节

function(m){if(all((y<-dim(m)-1)>1))m[2:y[1],2:y[2]]=0;m}

编辑 -7通过与<2行或<2列矩阵明确地明确地处理字节 EDIT2通过分配矩阵的尺寸-7字节，而检查的大小

— nel
source
1

C ++， 80 79个字节

期望数组int**具有给定的大小n和k：

void p(int**c,int n,int k){for(int j,i=1;1+i<n;++i)for(j=1;j+1<k;)c[i][j++]=0;}

适用于具有size()和value_type & operator[](int)（98字节）的任何类型的替代方法：

template<class C>void p(C&c){for(int j,i=1;1+i<c.size();++i)for(j=1;j+1<c[i].size();)c[i][j++]=0;}

扩展版

template <class Container>
void hollowOut(Container & ctn){
    const auto size = ctn.size();

    for(typename Container::size_type i = 1; i + 1 < size; ++i) {
        const auto inner_size = ctn[i].size();

        for(decltype(inner_size) j = 1; j + 1 < inner_size; ++j) {
            ctn[i][j] = 0;
        }
    }
}
— 泽塔
source
似乎将矩阵尺寸添加到输入中是一个标准漏洞
— 2016年
1

PHP，82 81 80 71字节

function(&$z){for(;$z[++$i+1];)for(;0 .$z[0][++$$i+1];)$z[$i][$$i]=0;};

像这样运行：

php -r '$f = function(&$z){for(;$z[++$i+1];)for(;0 .$z[0][++$$i+1];)$z[$i][$$i]=0;};   $z=[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]; $f($z); print_r($z);'
  • 通过假设行大小恒定来节省一个字节（thx到manatwork）
  • 通过将其设为匿名函数来保存字节
  • 通过使用下一个数组项的真实性来节省7个字节，从而避免调用count，这对于codegolf来说太长了
— ros
source
在处理矩阵时，所有子数组的长度应相同。因此，在内部for始终迭代最多count($z[0])-1保留1个字符是安全的。
— manatwork '16
1

APL，17字节 15字节

{⍵×(⌽∨⊖)1∊¨⍳⍴⍵}

怎么运行的

  • ⍳⍴⍵ 生成一个二维数组，其中所有单元格都包含参数的所有单元格的坐标。
  • 1∊¨在每个这样的单元格中搜索是否存在1，如果存在则返回1，否则返回0。这将建立一个矩阵，其中第一行和第一列为1，其余所有为0。
  • (⌽∨⊖) 与逻辑“或”矩阵的两个版本组合，一个沿第一个轴反转，一个沿最后一个轴反转。
  • ⍵× 是标准乘法。
— 斯蒂芬诺
source
您可以用（⊖∨⌽）代替（⊣∨⊖∘⌽），少两个字节
— Moris Zucca
辉煌！我来做吧！
— lstefano
0

Perl，34 + 2 = 36字节

next if$.==1||eof;s/ .+?(?= )/ 0/g

需要-p标志：

$ perl -pE'next if$.==1||eof;s/ .+?(?= )/ 0/g' <<< $'1 2 3\n4 5 6\n7 8 9'
1 2 3
4 0 6
7 8 9

怎么运行的：

# '-p' Read each line into `$_` and auto prints
next if$.==1||eof; # `$.` is set to to the current line in file (1, 2, ..., n)
                   # and `eof` is true if its the last line
s/ .+?(?= )/ 0/g
— 安德尔
source
0

Lua，69个字节

function f(a)for i=2,#a-1 do
for o=2,#a[i]-1 do
a[i][o]=0
end
end end

如果我只有大括号而不是dos and end ...

— 胡扯
source
0

SmileBASIC，69 51字节

DEF H A,W,H
FOR I=1TO H-2FILL A,0,W*I+1,W-2NEXT
END

填充数组中的2D区域通常需要在循环中使用FILL。但是在图形页面上处理2D数据要容易得多，因此首先将数组复制到那里。

原来我以为我很聪明使用图形命令...但是事实证明，多次调用FILL实际上更短。

无论如何，函数输入是数组和宽度/高度（这在Smilebasic中是标准的，因为无法检查数组的尺寸。）

— 12Me21
source
0

APL（Dyalog Classic），12字节

⊢-(⍉0⍪1↓⌽)⍣4

在线尝试！

⍉⌽⍵ 通常是旋转（水平反转并转置）

在这里，我们将其与0⍪1↓⍵将第一行替换为零（放下一行，然后在顶部连接0）组合成单列：⍉0⍪1↓⌽

⍣4 重复4次

⊢- 从原始矩阵中减去

— ngn
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.