给定一个正整数n，输出- N维标识“ matrix”，这是其中索引的所有分量均相等的N^N数组1，0否则为相等。N^N表示N个N个N个...

1 -> [1]

2 -> [[1,0],[0,1]]

3 -> [[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,1,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,1]]]

4 -> [[[[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,1,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]]]

例如，如果a是4维同一性“基质”，然后用仅条目1会是a[0][0][0][0]，a[1][1][1][1]，a[2][2][2][2]，和a[3][3][3][3]。

这是代码高尔夫球。以字节为单位的最短答案将获胜。有标准漏洞。

八度，29字节

@(n)accumarray((x=1:n)'+!x,1)

在线尝试！

果冻，8字节

×=¥þ’¡`Ṡ

在线尝试！

哦，看来我又用自己的语言退出@Dennis了:-)

这是一个1参数的函数（因为Jelly的嵌套列表的默认输出格式有点含糊，这意味着它可能无法满足完整程序的规范）。

说明

×=¥þ’¡`Ṡ
     ¡    Repeatedly apply the following operation,
    ’     {input-1} times in total:
   þ        For each element of the current value {perhaps made into a range}
      `     and of {the range from 1 to the} {input}:
 =            Compare corresponding elements, giving 0 for equal or 1 for unequal
× ¥           then multiply by one of the elements
       Ṡ  then replace each element with its sign

为了理解这一点，有助于看一下中间步骤。对于输入3，我们得到以下中间步骤：

1. [1,2,3] （输入，由 þ）
2. [[1,0,0],[0,2,0],[0,0,3]]（用制作表格[1,2,3]，比较是否相等以获得[[1,0,0],[0,1,0],[0,0,1]]，然后乘以我们比较的值之一）
3. [[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,2,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,3]]] （同样的想法）
4. [[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,1,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,1]]]（使用替换每个元素的符号Ṡ）

请注意，输入从一维开始，这一事实意味着我们必须循环（input-1）次才能添加（input-1）维，从而生成一个输入维列表。

有趣的事实：该程序连续包含五个快捷键¥þ’¡`。（快捷方式是“链接”或内置的修饰符，用于修改其行为或将其与另一个链接组合。）

Mathematica，30个字节

Array[Boole@*Equal,#~Table~#]&

APL（Dyalog），10字节

1=≢∘∪¨⍳⍴⍨⎕

在线尝试！

1= [是] 1等于

≢ 数字

∘ 的

∪ 独特元素

¨ 在每个

⍳ 维度为的数组中的索引

⍴⍨ 自重塑（Ñ副本Ñ）的

⎕ 输入（N）[？]

果冻，9字节

ðṗE€ṁ+þ’¡

在线尝试！

怎么运行的

直接完成任务似乎很困难（我还没有找到方法），但是构造相同编号的数组和相同形状的数组非常容易。

ð使链条成为二进角，整数输入n用作链条的左参数和右参数。可以改用单子链，但是二进位链的解析规则在此保存了三个字节（在为ð）。

左，右自变量等于n的笛卡尔幂原子构造长度为n的所有矢量的数组，这些矢量由[1，...，n]的元素按字典顺序排序。ṗ

当n = 3时，得出

[[1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 2, 1], [1, 2, 2], [1, 2, 3], [1, 3, 1], [1, 3, 2], [1, 3, 3], [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 2, 1], [2, 2, 2], [2, 2, 3], [2, 3, 1], [2, 3, 2], [2, 3, 3], [3, 1, 1], [3, 1, 2], [3, 1, 3], [3, 2, 1], [3, 2, 2], [3, 2, 3], [3, 3, 1], [3, 3, 2], [3, 3, 3]]

在等于每个快速链接E€测试对于平等的所有构建的载体的元素。

当n = 3时，我们得到

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

它们是平面阵列中3维恒等矩阵的元素。

+þ’¡使用左参数和右参数n调用二元快速链接。快速¡调用递减的原子’，产生n-1，然后调用添加表 quicklink +þ n-1次。

最初，的参数+þ均为n。每次调用后，将右侧参数替换为左侧参数，并将左侧参数替换为调用的返回值。

该表快速为其左参数的每个元素和其右参数的每个元素调用add原子+，从而构造返回值的表/矩阵。初始整数参数n提升为范围[1，... n]。

当n = 3时，晋升之后但第一次迭代之前，两个参数均为

[1, 2, 3]

将此数组中的每个整数与该数组中的每个整数相加，得出

[[2, 3, 4], [3, 4, 5], [4, 5, 6]]

在下一个调用中，我们将这些数组的每一个添加到[1，2，3]中的整数中。加法向量化（将整数添加到数组会将其添加到每个元素），因此我们得到

[[[3, 4, 5], [4, 5, 6], [5, 6, 7]],
 [[4, 5, 6], [5, 6, 7], [6, 7, 8]],
 [[5, 6, 7], [6, 7, 8], [7, 8, 9]]]

此数组的形状与3维恒等矩阵相同，但没有正确的元素。

最后，模具原子ṁ将结果的整数项丢弃到右侧，并按顺序将结果替换为左侧的元素。

Python，70个字节

f=lambda n,l=[]:[f(n,l+[i])for i in(len(l)<n)*range(n)]or+(l==l[:1]*n)

在线尝试！

递归解决方案。将矩阵视为一维较小的矩阵列表，然后在该列表上进行迭代以遍历树。它会记住在中选择的索引l，并且在选择n索引后，我们根据它们是否相同来分配一个1或0。

Python 2，73个字节

n=input();r=0
exec'r=eval(`[r]*n`);'*n+('n-=1;r'+'[n]'*n+'=1;')*n
print r

在线尝试！

对全人类制作零矩阵然后将对角线分配为零的方法的一种改进。

Python 2，88字节

n=input()
t=tuple(range(n))
print eval('['*n+'+(i0'+'==i%d'*n%t+')'+'for i%d in t]'*n%t)

在线尝试！

带有一些废话eval，生成嵌套列表和字符串格式替换。要评估的字符串如下所示：

[[[+(i0==i0==i1==i2)for i0 in t]for i1 in t]for i2 in t]

Python 2 + NumPy，80 72 70字节

现在与顶级Python答案捆绑在一起！

from numpy import*
n=input()
a=zeros((n,)*n)
a[[range(n)]*n]=1
print a

在线尝试

_{感谢Andras Deak，节省了8个字节，officialaimm节省了2个字节}

Python 2中，99 93 90个字节

感谢Rod提供了更多帮助，使其得以正常运行，并且节省了6个字节！-3个字节感谢xnor。

n=input()
r=eval(`eval('['*n+'0'+']*n'*n)`)
for i in range(n):exec'r'+`[i]`*n+'=1'
print r

在线尝试！

JavaScript（ES6），67个字节

f=(n,d=n-1,i)=>[...Array(n)].map((_,j)=>d?f(n,d-1,j-i?n:j):j-i?0:1)

说明：i用于跟踪单元格是否在主对角线上。最初它是未定义的，因此在第一个递归调用中，我们总是传递第一个维度，而在随后的递归调用中，我们仅在当前维度索引等于所有先前维度的情况下传递它，否则我们传递一个索引n，指示所有递归单元格应为零。

Brainfuck，61字节

>,[->+>+<<]>[-<<+>>]>-[->+.-<<<<[->+>+<<]>[-<+>]>[->>.<<]>]+.

不打高尔夫球

尖括号后面的数字表示头部在上方的单元格。

>,                   read n to 1
[->+>+<<]            move 1 to 2 and 3
>2[-<<+>>]>3         move 2 to 0 
                     (tape: n 0 0 n 0)
-[                   while cell 3 {
    -                  dec 3
    >4+.-<3            print \x1
    <<<0[->+>+<<]      move 0 to 1 and 2
    >1[-<+>]>2         move 1 to 0
                       (tape: 0 0 n rows_left 0)
    [                  while cell 2 {
        -                dec 2
        >>4.<<           print \x0
    ]>3                }
]                    }
+.                   print \x1

在线尝试！

输入为二进制数。输出是按行优先顺序存储的矩阵。

R，64 49字节

-15个字节，感谢Jarko Dubbeldam

x=array(0,rep(n<-scan(),n));x[seq(1,n^n,l=n)]=1;x

从stdin读取并返回一个数组，以矩阵形式打印。seq生成一个长度为，从1到均匀间隔的序列，该技巧可以很好地索引1的位置。n^nl=n

在线尝试！

旧版：

n=scan();x=rep(0,n^n);x=array(x,rep(n,n));x[matrix(1:n,n,n)]=1;x

n从stdin 读取；返回一个数组，将结果打印为矩阵。我花了一段时间苦苦挣扎，直到阅读了的文档[，该文档指出可以使用矩阵对数组进行索引，其中矩阵的每一行都代表一组索引。整齐！

在线尝试！

J，16 15字节

i.@#~=i.*]#.#&1

在线尝试！

Python 3 + numpy，81 77字节

from numpy import*
f=lambda n:all([a==range(n)for a in indices((n,)*n)],0)+0

我不能完全确定上面的内容是否符合所有准则：它会返回具有给定属性的ndarray。我知道匿名函数通常很好，但是实际上会打印一个交互式外壳

>>> f(2)
array([[1, 0],
       [0, 1]])

如果数组绒毛使上述内容无效，则我必须抛出a print()来表示另外7个字节。

在线尝试！

Pyth，14个字节

ucGQtQms!t{d^U

测试套件

说明：^U，这是隐含的^UQQ，在哪里Q输入，计算range的所有可能的Q元素列表0 ... n-1。ms!t{d映射所有元素等于1的元素，其余元素映射为0。这将使输出平坦化

ucGQtQ 执行以下Q-1次：将输入切成大小为Q的列表。

C＃（.NET Core），166字节

n=>{var c=new int[n];int i=0,d;for(;i<n;c[i++]=n);var m=System.Array.CreateInstance(typeof(int),c);for(i=0;i<n;i++){for(d=0;d<n;c[d++]=i);m.SetValue(1,c);};return m;}

在线尝试！

起初我以为用C＃中的lambda表达式无法完成... ^ __ ^ U

Common Lisp，147133字节

(defun i(n)(flet((m(x)(fill(make-list n)x)))(let((a(make-array(m n):initial-element 0)))(dotimes(i n)(incf(apply #'aref a(m i))))a)))

在线尝试！

通常的超长口吻。减少了12个字节，感谢@ceilingcat！

说明：

(defun i (n)
  (flet ((m (x) (fill (make-list n) x)))            ; function to build a list of n values x
    (let ((a (make-array (m n) :initial-element 0))); build the array with all 0
      (dotimes (i n)                                ; for i from 0 to n-1
        (incf (apply #'aref a (m i))))              ; add 1 to a[i]..[i] 
      a)))                                          ; return the array

SOGL V0.12，22 个字节

.^κ.H/ 0* 1.H≤Οčr.H{.n

在这里尝试！
将输出保留在堆栈中，可在控制台中查看。如果输出中的数字允许为字符串，则r可以将其删除。
就像对SOGL如何应对挑战的有趣测试一样，它完全不是针对：p的

input: x
.^                      push  x^x
  κ                     subtract x    (x^x)-x
   .H/                  divide by x   ((x^x) - x)/x
       0*               get that many zeroes
          1             push "1"
           .H           push x-1
             ≤          pull the first item from the stack to the top
              Ο         encase (x-1 times the zeroes, separated, started and ended with 1s)
               č        chop to a char-array
                r       convert each character to a number
                 .H{    repeat x-1 times:
                    .n    in the top array, for each group of x contents, encase that in an array

Clojure，92个字节

#(reduce(fn[v i](assoc-in v(repeat % i)1))(nth(iterate(fn[v](vec(repeat % v)))0)%)(range %))

很高兴assoc-in也可用于向量，不仅适用于哈希映射。