Cho một số nguyên dương n, xuất ra N"ma trận" nhận dạng hai chiều, là N^Nmảng có 1tất cả các thành phần của các chỉ số bằng nhau và 0ngược lại. N^Ncó nghĩa là N-by-N-by-N-by -...

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

Ví dụ, nếu alà 4bản sắc chiều "ma trận", sau đó các mục chỉ với 1sẽ a[0][0][0][0], a[1][1][1][1], a[2][2][2][2], và a[3][3][3][3].

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng. Tiêu chuẩn áp dụng.

Octave, 29 byte

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

Hãy thử trực tuyến!

Thạch , 8 byte

×=¥þ’¡`Ṡ

Hãy thử trực tuyến!

Ôi, hình như tôi lại vượt qua @Dennis bằng ngôn ngữ của mình một lần nữa :-)

Đây là hàm 1 đối số (vì định dạng đầu ra mặc định của Jelly cho các danh sách lồng nhau là một chút mơ hồ, có nghĩa là nó được cho là không hoàn thành thông số kỹ thuật như một chương trình đầy đủ).

Giải trình

×=¥þ’¡`Ṡ
     ¡    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

Để hiểu điều này, nó giúp xem xét các bước trung gian. Đối với đầu vào là 3, chúng tôi nhận được các bước trung gian sau:

1. [1,2,3](đầu vào, được tạo thành một phạm vi ngầm định bởi þ)
2. [[1,0,0],[0,2,0],[0,0,3]](tạo một bảng với [1,2,3], so sánh cho đẳng thức để có được [[1,0,0],[0,1,0],[0,0,1]], sau đó nhân với một trong các giá trị chúng ta so sánh)
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]]] (cùng một ý tưởng nữa)
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]]](thay thế từng yếu tố bằng dấu hiệu của nó bằng cách sử dụng Ṡ)

Lưu ý thực tế rằng đầu vào bắt đầu 1 chiều có nghĩa là chúng ta phải lặp (đầu vào-1) lần để thêm kích thước (đầu vào-1), tạo danh sách chiều đầu vào.

Thực tế thú vị: chương trình này chứa năm nhanh chóng liên tiếp , ¥þ’¡`. (Nhanh chóng là một sửa đổi cho một "liên kết", hoặc dựng sẵn, được sử dụng để sửa đổi hành vi của nó hoặc kết hợp nó với một liên kết khác.)

Toán học, 30 byte

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

APL (Dyalog) , 10 byte

1=≢∘∪¨⍳⍴⍨⎕

Hãy thử trực tuyến!

1= [là] 1 bằng

≢ con số

∘ của

∪ yếu tố độc đáo

¨ trong mỗi cái của

⍳ các chỉ số trong một mảng với kích thước của

⍴⍨ tự định hình lại ( N bản sao của N ) của

⎕ đầu vào ( N ) [?]

Thạch , 9 byte

ðṗE€ṁ+þ’¡

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Hoàn thành nhiệm vụ trực tiếp có vẻ khó khăn (tôi chưa tìm ra cách nào), nhưng việc thu hẹp các mảng có cùng số và mảng có cùng hình dạng là khá dễ dàng.

ðlàm cho chuỗi dyadic và đầu vào số nguyên n đóng vai trò là đối số trái và phải cho chuỗi. Thay vào đó, có thể sử dụng một chuỗi đơn âm, nhưng các quy tắc phân tích cú pháp cho các chuỗi dyadic lưu ba byte ở đây (hai sau khi tích lũy choð ).

Nguyên tử năng lượng của Cartesianṗ , với đối số trái và phải bằng n , xây dựng mảng của tất cả các vectơ có độ dài n bao gồm các phần tử của [1, ..., n] , được sắp xếp theo từ vựng.

Khi n = 3 , điều này mang lại

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

Bằng nhau mỗi quicklink E€kiểm tra các phần tử của tất cả các vectơ được xây dựng cho sự bằng nhau.

Khi n = 3 , chúng ta nhận được

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

đó là các yếu tố của ma trận danh tính 3 chiều, trong một mảng phẳng.

Quicklink dyadic +þ’¡được gọi với đối số trái và đối số phải n . Nhanh chóng ¡gọi nguyên tử giảm dần ’, tạo ra n-1 , sau đó gọi bảng addlink +þ n-1 lần.

Ban đầu, các đối số của +þcả n . Sau mỗi cuộc gọi, đối số bên phải được thay thế bằng cuộc gọi bên trái và đối số bên trái được thay thế bằng giá trị trả về của cuộc gọi.

Các bảng nhanh chóng gọi add nguyên tử +cho mỗi yếu tố của lập luận trái của nó và mỗi yếu tố của lý luận quyền của mình, xây dựng một bảng / ma trận của các giá trị trả về. Các đối số nguyên ban đầu n được thăng cấp lên các phạm vi [1, ... n] .

Khi n = 3 , sau khi thăng cấp nhưng trước lần lặp đầu tiên, cả hai đối số đều

[1, 2, 3]

Thêm từng số nguyên trong mảng này vào mỗi số nguyên trong mảng này sẽ mang lại

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

Trong lần gọi tiếp theo, chúng tôi thêm từng mảng này vào các số nguyên trong [1, 2, 3] . Bổ sung vector hóa (thêm một số nguyên vào một mảng thêm nó vào từng phần tử), vì vậy chúng tôi nhận được

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

Mảng này có hình dạng giống như ma trận nhận dạng 3 chiều, nhưng không phải là các phần tử chính xác.

Cuối cùng, nguyên tử khuônṁ loại bỏ các mục nguyên của kết quả sang phải và thay thế chúng theo thứ tự với các phần tử trong kết quả ở bên trái.

Python , 70 byte

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

Hãy thử trực tuyến!

Một giải pháp đệ quy. Nghĩ về ma trận như một danh sách các ma trận nhỏ hơn một chiều, nó lặp đi lặp lại qua danh sách đó để đi xuống cây. Nó nhớ các chỉ số được chọn lvà khi ncác chỉ số đã được chọn, chúng ta gán một 1hoặc 0tùy thuộc vào việc chúng có giống nhau không.

Python 2 , 73 byte

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

Hãy thử trực tuyến!

Một cải tiến về phương pháp hoàn toàn tạo ra một ma trận số 0 và sau đó gán chúng cho đường chéo.

Python 2 , 88 byte

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

Hãy thử trực tuyến!

Một số điều vô nghĩa với eval, tạo ra một danh sách lồng nhau và thay thế định dạng chuỗi. Chuỗi được đánh giá trông giống như:

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

Python 2 + NumPy , 80 72 70 byte

Bây giờ được gắn với câu trả lời Python hàng đầu!

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

Dùng thử trực tuyến

_{Đã lưu 8 byte nhờ Andras Deak và 2 bằng chính thức}

Python 2 , 99 93 90 byte

Cảm ơn Rod vì một số trợ giúp thậm chí còn giúp nó hoạt động tốt hơn và cũng đã loại bỏ 6 byte! -3 byte nhờ xnor.

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

Hãy thử trực tuyến!

JavaScript (ES6), 67 byte

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

Giải thích: iđược sử dụng để theo dõi xem tế bào có nằm trên đường chéo chính hay không. Ban đầu, nó không được xác định, vì vậy trong cuộc gọi đệ quy đầu tiên, chúng tôi luôn vượt qua thứ nguyên đầu tiên, trong khi với các cuộc gọi đệ quy tiếp theo, chúng tôi chỉ chuyển qua nếu chỉ số thứ nguyên hiện tại bằng với tất cả các thứ nguyên trước đó, nếu không, chúng tôi sẽ vượt qua một chỉ số ncho biết tất cả các tế bào đệ quy nên bằng không.

Brainfuck , 61 byte

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

Ung dung

Các số sau dấu ngoặc nhọn cho biết ô đã kết thúc.

>,                   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

Hãy thử trực tuyến!

Đầu vào là một số nhị phân. Đầu ra là một ma trận được lưu trữ theo thứ tự chính hàng.

R , 64 49 byte

-15 byte nhờ Jarko Dubbeldam

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

Đọc từ stdin và trả về một mảng, in dưới dạng ma trận. seqtạo ra một chuỗi cách đều nhau từ 1đến n^nvới chiều dàil=n , thủ thuật này khá độc đáo để lập chỉ mục cho số 1 đi.

Hãy thử trực tuyến!

phiên bản cũ:

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

Đọc n từ stdin; trả về một mảng, in kết quả dưới dạng ma trận. Tôi vật lộn với điều này một lúc cho đến khi tôi đọc tài liệu cho[ biết ma trận có thể được sử dụng để lập chỉ mục cho một mảng, trong đó mỗi hàng của ma trận đại diện cho tập hợp các chỉ mục. Khéo léo!

Hãy thử trực tuyến!

J , 16 15 byte

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

Hãy thử trực tuyến!

Python 3 + numpy, 81 77 byte

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

tôi không hoàn toàn chắc chắn rằng những điều trên phù hợp với tất cả các nguyên tắc: nó trả về một ndarray với các thuộc tính đã cho. Tôi biết các hàm ẩn danh thường ổn, nhưng một vỏ tương tác sẽ thực sự in

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

Nếu chuỗi lông tơ làm cho các giá trị trên không hợp lệ, tôi phải ném vào một print()cái gì đó như 7 byte bổ sung.

Hãy thử trực tuyến!

Bình thường, 14 byte

ucGQtQms!t{d^U

Bộ kiểm tra

Giải thích : ^U, được ngầm định ^UQQ, Qđầu vào ở đâu, tính toán tất cả các danh sách thành phần Q có thể có của phạm vi 0 ... n-1.ms!t{dánh xạ các phần tử có tất cả các phần tử bằng 1 và phần còn lại bằng 0. Điều này mang lại đầu ra phẳng

ucGQtQ thực hiện như sau, Q - 1 lần: Cắt đầu vào thành các danh sách có kích thước Q.

C # (Lõi .NET) , 166 byte

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;}

Hãy thử trực tuyến!

Lúc đầu, tôi nghĩ rằng nó không thể được thực hiện với biểu thức lambda trong C # ... ^ __ ^ U

Lisp thông thường, 147 133 byte

(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)))

Hãy thử trực tuyến!

Các lisp siêu dài thông thường. Giảm 12 byte nhờ @ceilingcat!

Giải trình:

(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 byte

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

Hãy thử nó ở đây!
Để đầu ra trên ngăn xếp , có thể xem trong bảng điều khiển. Nếu các số trong đầu ra được phép là các chuỗi, thì số đó rcó thể bị xóa.
Giống như một thử nghiệm thú vị về cách SOGL thực hiện trong các thử thách, nó hoàn toàn không được thực hiện cho: 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 byte

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

Thật tuyệt khi PGS cũng hoạt động với các vectơ, không chỉ với bản đồ băm.