Thử thách rất đơn giản. Cho một đầu vào số nguyên n, đầu ra n x nma trận danh tính. Ma trận danh tính là một ma trận có 1s kéo dài từ trên cùng bên trái xuống dưới cùng bên phải. Bạn sẽ viết một chương trình hoặc một hàm sẽ trả về hoặc xuất ra ma trận danh tính mà bạn đã xây dựng. Đầu ra của bạn có thể là một mảng 2D hoặc các số được phân tách bằng dấu cách / tab và dòng mới.

Ví dụ đầu vào và đầu ra

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.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

MATL, 2 byte

Xy

Một bản dịch của câu trả lời Octave của tôi.

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

Phiên bản 4 byte không tích hợp sẵn (nhờ 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 byte

identity(Ans

Sự thật thú vị: Cách ngắn nhất để có được một danh sách {N,N}là dim(identity(N.

Đây là cách ngắn nhất mà không có nội dung, trong 8 byte:

randM(Ans,Ans)^0

randM(tạo một ma trận ngẫu nhiên với các mục nhập bao gồm tất cả các số nguyên nằm trong khoảng từ -9 đến 9 (nghe có vẻ cụ thể vì nó là). Chúng tôi sau đó đưa ma trận này đến sức mạnh thứ 0.

Julia, 9 3 byte

eye

Đây chỉ là một hàm dựng sẵn chấp nhận một số nguyên nvà trả về một nxn Array{Float64,2}(tức là một mảng 2D). Gọi nó như thế eye(n).

Lưu ý rằng các bài nộp của mẫu này được chấp nhận theo chính sách này .

APL, 5 byte

∘.=⍨⍳

Đây là một hàm chức năng đơn âm chấp nhận một số nguyên ở bên phải và trả về ma trận danh tính.

Hãy thử nó ở đây

Octave, 10 4 byte

@eye

Trả về một hàm ẩn danh lấy một số nvà trả về ma trận danh tính.

R, 4 byte

diag

Khi được cung cấp một ma trận, diagtrả về đường chéo của ma trận. Tuy nhiên, khi được cung cấp một số nguyên n, diag(n)trả về ma trận danh tính.

Dùng thử trực tuyến

Python 2, 42 byte

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

Một hàm ẩn danh, tạo đầu ra như [(1, 0, 0), (0, 1, 0), (0, 0, 1)],

Đầu tiên, tạo danh sách ([1]+[0]*n)*n, n=3trông giống như

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

Sử dụng thủ thuật zip / iter zip(*[iter(_)]*n để tạo các nhóm ncho

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

Lưu ý rằng 1một chỉ số đến sau mỗi lần, đưa ra ma trận danh tính. Nhưng, có thêm một hàng hoàn toàn bằng không, được loại bỏ bằng [:n].

Thạch, 4 byte

R=€R

Không sử dụng tích hợp. Hãy thử trực tuyến!

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

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 byte

=@i.

Đây là một hàm lấy một số nguyên và trả về ma trận.

Haskell, 43 37 byte

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

Khá đơn giản, mặc dù tôi nghĩ rằng người ta có thể làm tốt hơn (không có ngôn ngữ đã được tích hợp chức năng này, như nhiều người đã làm).

Chỉnh sửa: giảm một số byte nhờ rjan Johansen

Bình thường, 7 byte

XRm0Q1Q

Dùng thử trực tuyến: Trình diễn

Tạo một ma trận các số không và thay thế các phần tử đường chéo bằng các phần tử.

JavaScript ES6, 68 62 52 byte

Đã lưu 10 byte nhờ một thủ thuật gọn gàng từ @Neil

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

Thử một cách tiếp cận khác với @ Cᴏɴᴏʀ O'Bʀɪᴇɴ's. Có thể có thể được cải thiện.

Võng mạc , 25

Tín dụng cho @randomra và @Martin để chơi gôn thêm.

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

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

Lưu ý điều này có đầu vào là một unary. Nếu điều này không được chấp nhận, thì đầu vào thập phân có thể được cung cấp như sau:

Võng mạc, 34

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

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

Haskell, 54 byte

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

ftrả về ma trận danh tính cho đầu vào n. Xa tối ưu.

Lua, 77 75 65 byte

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

Chà, tôi không chắc lua có phải là ngôn ngữ tốt nhất cho việc này với sự kết hợp hai giai đoạn không ... Nhưng này, có một phát súng vào nó. Tôi sẽ xem nếu có bất kỳ cải tiến sẽ được thực hiện.

BIÊN TẬP:

Tôi đã tìm ra một cái gì đó tình cờ mà tôi thấy khá kỳ lạ, nhưng, nó hoạt động.

Trong Lua, mọi người đều biết bạn có khả năng gán các hàm cho các biến. Đây là một trong những tính năng hữu ích của CodeGolf.

Điều này có nghĩa thay vì:

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

Bạn có thể làm được việc này:

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

Nhưng chờ đã, Lua cho phép một số lượng OOP. Vì vậy, bạn thậm chí có thể làm:

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

Điều đó sẽ làm việc tốt và cắt giảm nhân vật.

Bây giờ đến phần kỳ lạ. Bạn thậm chí không cần phải gán một chuỗi tại bất kỳ điểm nào. Đơn giản chỉ cần làm:

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

Sẽ làm việc.

Vì vậy, bạn có thể thấy sự khác biệt một cách trực quan, hãy xem kết quả đánh gôn của điều này:

Sử dụng chuỗi.sub (88 ký tự)

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

Gán chuỗi.sub cho một biến (65 ký tự)

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

Chỉ định chuỗi.sub bằng cách sử dụng phương pháp OOP (64 ký tự)

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

Chỉ định chuỗi.sub bằng cách sử dụng phương pháp .. không? (60 ký tự)

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

Nếu ai đó biết tại sao điều này hoạt động, tôi sẽ quan tâm.

Trăn 3, 48

Đã lưu 1 byte nhờ sp3000.

Tôi thích những thách thức tôi có thể giải quyết trong một dòng. Khá đơn giản, xây dựng một dòng trong số 1 và 0 bằng với độ dài của int được truyền vào. Kết quả là một mảng 2d. Nếu bạn bọc phần sau: in '\n'.join(), nó sẽ in đẹp.

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

C, 59 hoặc 59 56 hoặc 56

Hai phiên bản có chiều dài giống hệt nhau.

3 byte được lưu do đề xuất từ ​​anatolyg: (n+1)->~n

Lặp lại itừ n*n-1không. In 1 nếu i% (n + 1) bằng 0, ngược lại 0. Sau đó in một dòng mới if i%n= 0 nếu không là khoảng trắng.

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 byte

I(3)

Đầu ra

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

Mata là ngôn ngữ lập trình ma trận có sẵn trong gói thống kê Stata. I (n) tạo ma trận danh tính có kích thước n * n

K6 , 1 byte

=

= chính xác là

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

Bình thường, 8 byte

mmsqdkQQ

Hãy thử nó ở đây .

Python 3.5 với NumPy - 57 49 30 byte

import numpy
numpy.identity

NumPy.identity nhận một số nguyên, n và trả về một ma trận danh tính theo n. Câu trả lời này được cho phép thông qua chính sách này .

Toán học, 35 byte

không sử dụng 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 byte

Uo £Z®¥X|0

Kiểm tra nó trực tuyến! Lưu ý: phiên bản này có thêm một vài byte để in ra đầu ra.

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

Brain-Flak , 206 170 162 byte

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

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

K, 7 byte

t=\:t:!

Lấy sản phẩm chéo bằng của hai vectơ chứa [0, n).

Trong hành động:

  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 byte

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

Tạo một mảng 2D và thay thế các phần tử trong đó hàng và cột bằng nhau 1.

CJam, 7 byte

{,_ff=}

Đây là một khối mã bật ra một số nguyên từ ngăn xếp và trả lại một mảng 2D.

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

Toán học, 14 byte

IdentityMatrix

Trường hợp thử nghiệm

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

Perl, 39 33 byte

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

Cảm ơn TonMedel đã lưu 6 byte

Chạy với -Eperlrun:

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