Diberikan bilangan bulat positif n, mengeluarkan N"matriks" identitas -dimensi, yang merupakan N^Nlarik dengan 1semua komponen indeks sama dan 0tidak. N^Nberarti N-oleh-N-oleh-N-oleh -...

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

Sebagai contoh, jika aadalah 4berdimensi identitas "matrix", maka satu-satunya entri dengan 1akan a[0][0][0][0], a[1][1][1][1], a[2][2][2][2], dan a[3][3][3][3].

Ini adalah kode-golf . Jawaban terpendek dalam byte menang. Celah standar berlaku.

Oktaf, 29 byte

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

Cobalah online!

Jelly , 8 byte

×=¥þ’¡`Ṡ

Cobalah online!

Ooh, sepertinya saya bisa mengalahkan @Dennis dalam bahasanya sendiri lagi :-)

Ini adalah fungsi 1-argumen (karena format output default Jelly untuk daftar bersarang sedikit ambigu, artinya bisa dikatakan tidak memenuhi spesifikasi sebagai program lengkap).

Penjelasan

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

Untuk memahami ini, ada baiknya untuk melihat langkah-langkah perantara. Untuk input 3, kami mendapatkan langkah perantara berikut:

1. [1,2,3](input, dibuat menjadi rentang yang secara implisit oleh þ)
2. [[1,0,0],[0,2,0],[0,0,3]](buat tabel dengan [1,2,3], bandingkan untuk mendapatkan persamaan [[1,0,0],[0,1,0],[0,0,1]], lalu kalikan dengan salah satu nilai yang kami bandingkan)
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]]] (ide yang sama lagi)
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]]](ganti setiap elemen dengan tandanya menggunakan Ṡ)

Perhatikan fakta bahwa input mulai 1-dimensi berarti kita harus mengulang (input-1) kali untuk menambahkan (input-1) dimensi, menghasilkan daftar dimensi-input.

Fakta menyenangkan: program ini berisi lima quicks berturut-turut ¥þ’¡`,. (Quick adalah pengubah "tautan", atau bawaan, digunakan untuk mengubah perilakunya atau menggabungkannya dengan tautan lain.)

Mathematica, 30 byte

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

APL (Dyalog) , 10 byte

1=≢∘∪¨⍳⍴⍨⎕

Cobalah online!

1= 1 adalah sama dengan

≢ nomor

∘ dari

∪ elemen unik

¨ di masing-masing

⍳ indeks dalam array dengan dimensi

⍴⍨ yang membentuk kembali diri ( N salinan N ) dari

⎕ input ( N ) [?]

Jelly , 9 byte

ðṗE€ṁ+þ’¡

Cobalah online!

Bagaimana itu bekerja

Mencapai tugas secara langsung tampaknya sulit (saya belum menemukan cara), tetapi menyusun array dengan nomor yang sama dan array dengan bentuk yang sama cukup mudah.

ðmembuat diad rantai, dan input integer n berfungsi sebagai argumen kiri dan kanan untuk rantai. Dimungkinkan untuk menggunakan rantai monadik sebagai gantinya, tetapi aturan parsing untuk yang diad menyimpan tiga byte di sini (dua setelah accouting for ð).

The listrik Cartesian atom ṗ, dengan argumen kiri dan kanan sama untuk n , konstruksi array semua vektor dengan panjang n yang terdiri dari unsur [1, ..., n] , diurutkan leksikografi.

Ketika n = 3 , ini menghasilkan

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

The sama setiap Quicklink E€menguji unsur semua vektor dibangun untuk kesetaraan.

Ketika n = 3 , kita dapatkan

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

yang merupakan elemen dari matriks identitas 3 dimensi, dalam susunan datar.

Dilink cepat +þ’¡disebut dengan argumen kiri dan argumen kanan n . Quick ¡memanggil atom decrement ’, yang menghasilkan n-1 , lalu memanggil quicklink tabel tambahkan +þ n-1 kali.

Awalnya, argumen +þkeduanya n . Setelah setiap panggilan, argumen kanan digantikan oleh yang kiri, dan yang kiri digantikan oleh nilai balik dari panggilan.

The meja cepat memanggil add atom +untuk setiap elemen argumen kiri dan setiap elemen argumen kanan, membangun tabel / matriks nilai kembali. Argumen integer awal n dipromosikan ke rentang [1, ... n] .

Ketika n = 3 , setelah promosi tetapi sebelum iterasi pertama, kedua argumen tersebut

[1, 2, 3]

Menambahkan setiap integer dalam array ini ke setiap integer dalam array ini menghasilkan

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

Dalam doa berikutnya, kami menambahkan masing-masing array ini ke integer di [1, 2, 3] . Addition vectorizes (menambahkan integer ke array menambahkannya ke setiap elemen), jadi kita dapatkan

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

Array ini memiliki bentuk yang sama dengan matriks identitas 3 dimensi, tetapi bukan elemen yang benar.

Akhirnya, atom cetakanṁ membuang entri bilangan bulat dari hasil ke kanan dan menggantinya sesuai dengan unsur-unsur dalam hasil di sebelah kiri.

Python , 70 byte

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

Cobalah online!

Solusi rekursif. Memikirkan matriks sebagai daftar matriks satu dimensi lebih kecil, itu beralih ke daftar itu untuk turun pohon. Itu mengingat indeks yang dipilih l, dan ketika nindeks telah diambil, kami menetapkan 1atau 0tergantung pada apakah semuanya sama.

Python 2 , 73 byte

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

Cobalah online!

Peningkatan pada metode benar-benar manusiawi membuat matriks nol dan kemudian menetapkan yang ke diagonal.

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)

Cobalah online!

Beberapa omong kosong dengan eval, menghasilkan daftar bersarang, dan substitusi format string. String yang akan dievaluasi terlihat seperti:

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

Python 2 + NumPy , 80 72 70 byte

Sekarang diikat dengan jawaban Python teratas!

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

Cobalah online

_{Disimpan 8 byte berkat Andras Deak, dan 2 oleh officialaimm}

Python 2 , 99 93 90 byte

Terima kasih kepada Rod untuk beberapa bantuan lebih banyak lagi yang mendapatkannya bekerja dan juga mencukur 6 byte off! -3 byte terima kasih kepada xnor.

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

Cobalah online!

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)

Penjelasan: idigunakan untuk melacak apakah sel berada di diagonal utama atau tidak. Awalnya itu tidak terdefinisi, jadi pada panggilan rekursif pertama kami selalu melewati dimensi pertama, sementara pada panggilan rekursif berikutnya kami hanya meneruskannya jika indeks dimensi saat ini sama dengan semua dimensi sebelumnya, jika tidak kami melewati indeks nyang menunjukkan bahwa semua sel rekursif harus nol.

Brainfuck , 61 byte

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

Tidak disatukan

Angka-angka setelah tanda kurung siku menunjukkan sel kepala berakhir.

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

Cobalah online!

Input adalah nomor biner. Output adalah matriks yang disimpan dalam urutan baris-utama.

R , 64 49 byte

-15 byte berkat Jarko Dubbeldam

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

Membaca dari stdin dan mengembalikan array, mencetak sebagai matriks. seqmenghasilkan urutan merata spasi dari 1ke n^ndengan panjang l=n, yang melakukan trik dengan cukup baik untuk mengindeks ke mana 1s pergi.

Cobalah online!

versi lama:

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

Baca ndari stdin; mengembalikan array, mencetak hasilnya sebagai matriks. Saya berjuang dengan ini untuk sementara waktu sampai saya membaca dokumen untuk [, yang menunjukkan bahwa matriks dapat digunakan untuk mengindeks array, di mana setiap baris matriks mewakili set indeks. Rapi!

Cobalah online!

J , 16 15 byte

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

Cobalah online!

Python 3 + numpy, 81 77 byte

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

Saya tidak sepenuhnya yakin bahwa di atas cocok dengan semua pedoman: ini mengembalikan ndarray dengan properti yang diberikan. Saya tahu fungsi anonim biasanya baik-baik saja, tetapi shell interaktif sebenarnya akan dicetak

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

Jika array bulu membuat di atas tidak valid, saya harus melempar print()untuk sesuatu seperti 7 byte tambahan.

Cobalah online!

Pyth, 14 byte

ucGQtQms!t{d^U

Suite uji

Penjelasan:, ^Uyang secara implisit ^UQQ, di mana Qinput, menghitung semua daftar elemen Q yang mungkin dari rentang 0 ... n-1. ms!t{dmemetakan yang dengan semua elemen sama dengan 1, dan sisanya ke 0. Ini memberikan hasil yang rata

ucGQtQ jalankan yang berikut ini, Q - 1 kali: Potong input ke daftar ukuran Q.

C # (.NET Core) , 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;}

Cobalah online!

Awalnya saya pikir itu tidak bisa dilakukan dengan ekspresi lambda di C # ... ^ __ ^ U

Common Lisp, 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)))

Cobalah online!

Cadel super-panjang biasa. Berkurang 12 byte, terima kasih kepada @ceilingcat!

Penjelasan:

(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

Coba Di Sini!
Meninggalkan output di tumpukan , dapat dilihat di konsol. Jika angka-angka dalam output dibiarkan berupa string, maka angka rtersebut dapat dihapus.
Seperti halnya tes menyenangkan tentang bagaimana SOGL dalam tantangan, itu sama sekali tidak dibuat untuk: 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 %))

Bagus bahwa assoc-in berfungsi juga dengan vektor, tidak hanya dengan hash-maps.