挑战非常简单。给定整数输入n，输出n x n单位矩阵。单位矩阵是1从左上角到右下角的s 矩阵。您将编写一个程序或函数来返回或输出您构造的身份矩阵。您的输出可能是2D数组，或者是由空格/制表符和换行符分隔的数字。

输入和输出示例

1: [[1]]
2: [[1, 0], [0, 1]]
3: [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
4: [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
5: [[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]]

1
===
1

2
===
1 0
0 1

3
===
1 0 0
0 1 0
0 0 1

etc.

这是code-golf，因此以字节为单位的最短代码获胜。

MATL，2个字节

Xy

我的八度答案的翻译。

在线尝试。

没有内置功能的4字节版本（感谢Luis Mendo）：

:t!=
:     take input n and a generate row array [1,2,...n]
 t    duplicate
  !   zip
   =  thread compare over the result

TI-BASIC，2个字节

identity(Ans

有趣的事实：获取列表的最短方法{N,N}是dim(identity(N。

这是没有内置的最短方法，为8个字节：

randM(Ans,Ans)^0

randM(创建一个随机矩阵，其条目的所有整数在-9和9之间（包括-9和9）（这听起来有些奇怪，因为确实如此）。然后，我们将此矩阵取0的幂。

朱莉娅9 3个字节

eye

这只是一个接受整数n并返回nxn Array{Float64,2}（即2D数组）的内置函数。这样称呼eye(n)。

请注意，根据本政策，可以接受这种形式的提交。

APL，5个字节

∘.=⍨⍳

这是一个单子函数列，它在右边接受一个整数并返回单位矩阵。

在这里尝试

八度，10 4字节

@eye

返回一个带数字n并返回单位矩阵的匿名函数。

R，4个字节

diag

给定矩阵时，diag返回矩阵的对角线。但是，给定一个整数时n，diag(n)返回单位矩阵。

在线尝试

Python 2，42字节

lambda n:zip(*[iter(([1]+[0]*n)*n)]*n)[:n]

匿名函数，产生类似的输出[(1, 0, 0), (0, 1, 0), (0, 0, 1)]，

首先，创建list ([1]+[0]*n)*n，其n=3外观类似于

[1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]

使用zip / iter技巧 zip(*[iter(_)]*n制作成组的n捐赠

[(1, 0, 0), (0, 1, 0), (0, 0, 1), (0, 0, 0)]

请注意，1每次出现索引后一次，都会给出单位矩阵。但是，还有一个额外的全零行，已用删除[:n]。

果冻，4个字节

R=€R

不使用内置的。在线尝试！

这个怎么运作

R=€R    Main link. Input: n

R       Range; yield [1, ..., n].
   R    Range; yield [1, ..., n].
 =€     Compare each.
        This compares each element of the left list with the right list, so it
        yields [1 = [1, ..., n], ..., n = [1, ..., n]], where comparison is
        performed on the integers.

J，4个字节

=@i.

这是一个接受整数并返回矩阵的函数。

Haskell，43 37字节

f n=[[0^abs(x-y)|y<-[1..n]]|x<-[1..n]]

非常简单，尽管我认为可以做得更好（没有一种语言已经内置了此功能，就像许多人所做的那样）。

编辑：感谢ØrjanJohansen删除了一些字节

Pyth，7个字节

XRm0Q1Q

在线尝试：演示

创建零矩阵，并用1替换对角线元素。

的JavaScript ES6，68个 62 52字节

@Neil的巧妙技巧节省了10个字节

x=>[...Array(x)].map((_,y,x)=>x.map((_,z)=>+(y==z)))

尝试使用不同于@CᴏɴᴏʀO'Bʀɪᴇɴ的方法。可能会得到改善。

视网膜 25

感谢@randomra和@Martin进行额外的高尔夫运动。

\B.
 0
+`(.*) 0$
$0¶0 $1

在线尝试。

请注意，这会将输入作为一元。如果这是不可接受的，则可以给出如下十进制输入：

视网膜，34

.+
$0$*1
\B.
 0
+`(.*) 0$
$0¶0 $1

在线尝试。

Haskell，54个字节

(#)=replicate
f n=map(\x->x#0++[1]++(n-x-1)#0)[0..n-1]

f返回输入n的单位矩阵。远非最佳。

Lua 77 75 65字节

x,v=z.rep,io.read()for a=1,v do print(x(0,a-1)..'1'..x(0,v-a))end

好吧，我不确定在两个时期的连接中lua是否是最好的语言……但是，嘿，有一个镜头。我将看看是否有任何需要改进的地方。

编辑：

我偶然发现了一些奇怪的东西，但是它确实有效。

在Lua中，每个人都知道您可以将函数分配给变量。这是更有用的CodeGolf功能之一。

这意味着代替：

string.sub("50", 1, 1) -- = 5
string.sub("50", 2, 2) -- = 0
string.sub("40", 1, 1) -- = 4
string.sub("40", 2, 2) -- = 0

你可以这样做：

s = string.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0

但是，等等，Lua允许一些OOP。因此，您甚至可以执行以下操作：

z=""
s = z.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0

这样也可以工作并削减字符。

现在来了奇怪的部分。您甚至都不需要在任何时候分配一个字符串。简单地做：

s = z.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0

将工作。

因此，您可以直观地看到区别，看一下高尔夫球的效果：

使用string.sub（88个字符）

string.sub("50", 1, 1)string.sub("50", 2, 2)string.sub("40", 1, 1)string.sub("40", 2, 2)

将string.sub分配给变量（65个字符）

s=string.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)

使用OOP方法分配string.sub（64个字符）

z=""s=z.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)

使用a..nil方法分配string.sub？（60个字符）

s=z.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)

如果有人知道为什么这样做，我会很感兴趣。

Python 3、48

由于sp3000，节省了1个字节。

我喜欢可以一站式解决的挑战。非常简单，用1和0构成的线等于传入的int的长度。输出为2d数组。如果将零件包裹在：中'\n'.join()，它将很漂亮地打印出来。

lambda x:[[0]*i+[1]+[0]*(x+~i)for i in range(x)]

C，59或59 56或56

长度相同的两个版本。

由于anatolyg的建议，节省了3个字节：(n+1)->~n

迭代i从n*n-1零。如果i％（n + 1）为零，则打印1；否则为0。如果i%n= 0 ，则打印换行，否则为空格。

i;f(n){for(i=n*n;i--;)printf(i%n?"%d ":"%d\n",!(i%~n));}

i;f(n){for(i=n*n;i--;)printf("%d%c",!(i%~n),i%n?32:10);}

Mata，4个字节

I(3)

输出量

[symmetric]
       1   2   3
    +-------------+
  1 |  1          |
  2 |  0   1      |
  3 |  0   0   1  |
    +-------------+

Mata是Stata统计软件包中提供的矩阵编程语言。I（n）创建大小为n * n的单位矩阵

K6，1个字节

=

= 就是这个

在线尝试！

Pyth，8个字节

mmsqdkQQ

在这里尝试。

蟒3.5 NumPy的- 57个 49 30字节

import numpy
numpy.identity

NumPy.identity接受整数n，并返回一个乘以n的恒等矩阵。通过此政策可以允许此答案。

Mathematica，35字节

不使用IdentityMatrix

Table[Boole[i==j],{i,1,#},{j,1,#}]&

Javascript，40岁

f=
n=>'0'.repeat(n).replace(/./g,"$`1$'\n")

I.oninput=_=>O.innerHTML=f(+I.value)
I.oninput()

<input id=I value=5>
<pre id=O>

Japt，14 12 10字节

Uo £Z®¥X|0

在线测试！注意：此版本还有一些额外的字节可以漂亮地打印输出。

Uo £Z®¥X|0    // Implicit: U = input integer
Uo £          // Create the range [0..U). Map each item X and the full array Z to:
    Z®        //  Take the full array Z, and map each item Z to:
      ¥X|0    //   (X == Z) converted to a number. 1 for equal, 0 for non-equal.
              // Implicit: output result of last expression

脑高射炮，206个 170 162字节

(([{}])){({}<>(())<><(({})<{({}()(<>)<>)}{}>)>)}{}(({}<><(())>)){({}()<({[()]<({}()<({}<>((((()()()()){}){}){})((()()()()){}){})<>>)>}{})>)<>((()()()()()){})<>}<>

在线尝试！

K，7个字节

t=\:t:!

取两个包含[0，n）的向量的等式叉积。

实际上：

  t=\:t:!3
(1 0 0
 0 1 0
 0 0 1)
  t=\:t:!5
(1 0 0 0 0
 0 1 0 0 0
 0 0 1 0 0
 0 0 0 1 0
 0 0 0 0 1)

Java，60个字节

n->{int[][]i=new int[n][n];for(;n-->0;)i[n][n]=1;return i;};

创建2D数组并将行和列等于的元素替换1。

CJam，7个字节

{,_ff=}

这是一个代码块，该代码块从堆栈中弹出一个整数并返回2D数组。

在线尝试！

Mathematica，14个字节

IdentityMatrix

测试用例

IdentityMatrix[4]
(* {{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}} *)

Perl，39 33个字节

/$/,say map$`==$_|0,@%for@%=1..<>

感谢Ton Hospel节省了6个字节

使用-Eperlrun 运行：

$ echo 3 | perl -E'@%=1..<>;$a=$_,say map{$a==$_|0}@%for@%'
100
010
001