Biorąc pod uwagę dodatnią liczbę całkowitą n, wyprowadzaj N„matrycę” tożsamości wymiarowej, która jest N^Ntablicą, w 1której wszystkie składniki indeksów są równe i w 0przeciwnym razie. N^Noznacza 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]]]]

Na przykład, jeśli ajest 4wymiarowa tożsamość „matrix”, to tylko wpisy z 1byłoby a[0][0][0][0], a[1][1][1][1], a[2][2][2][2], i a[3][3][3][3].

To jest golf golfowy . Najkrótsza odpowiedź w bajtach wygrywa. Obowiązują standardowe luki .

Oktawa, 29 bajtów

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

Wypróbuj online!

Galaretka , 8 bajtów

×=¥þ’¡`Ṡ

Wypróbuj online!

Ooh, wygląda na to, że znów mogę przejść do outgolfa @Dennisa w jego własnym języku :-)

Jest to funkcja 1-argumentowa (ponieważ domyślny format wyjściowy Jelly dla list zagnieżdżonych jest nieco niejednoznaczny, co oznacza, że ​​prawdopodobnie nie spełnia specyfikacji jako pełny program).

Wyjaśnienie

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

Aby to zrozumieć, warto spojrzeć na etapy pośrednie. Dla wejścia 3 otrzymujemy następujące pośrednie kroki:

1. [1,2,3](dane wejściowe wprowadzone pośrednio do zakresu þ)
2. [[1,0,0],[0,2,0],[0,0,3]](utwórz tabelę [1,2,3], porównaj, aby uzyskać równość [[1,0,0],[0,1,0],[0,0,1]], a następnie pomnóż ją przez jedną z porównywanych wartości)
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]]] (znowu ten sam pomysł)
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]]](zastąp każdy element jego znakiem za pomocą Ṡ)

Zauważ, że wejście zaczyna się od 1-wymiarowej oznacza, że ​​musimy zapętlić (input-1) razy, aby dodać wymiary (input-1), tworząc listę danych wejściowych.

Ciekawostka: program ten zawiera pięć Quicks z rzędu, ¥þ’¡`. (Szybki to modyfikator „linku” lub wbudowanego, służący do modyfikowania jego zachowania lub łączenia go z innym linkiem.)

Mathematica, 30 bajtów

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

APL (Dyalog) , 10 bajtów

1=≢∘∪¨⍳⍴⍨⎕

Wypróbuj online!

1= [jest] 1 równa

≢ numer

∘ z

∪ unikalne elementy

¨ w każdym z

⍳ indeksy w tablicy o wymiarach

⍴⍨ samokształtu ( N kopii N ) z

⎕ wejście ( N ) [?]

Galaretka , 9 bajtów

ðṗE€ṁ+þ’¡

Wypróbuj online!

Jak to działa

Bezpośrednie wykonanie zadania wydaje się trudne (nie znalazłem sposobu), ale tworzenie tablic o tych samych liczbach i tablic o tym samym kształcie jest dość łatwe.

ðpowoduje, że łańcuch staje się dyadyczny, a wejściowa liczba całkowita n służy zarówno jako lewy, jak i prawy argument łańcucha. Można zamiast tego użyć łańcucha monadycznego, ale reguły analizujące dla tych dynamicznych zapisują tutaj trzy bajty (dwa po sprawdzeniu ð).

Kartezjański moc atom ṗz argumentem w lewo i w prawo równej N , tworzy tablicę wszystkich wektorów o długości n , które składają się z elementów [1, ..., n] , sortowane leksykograficznie.

Gdy n = 3 , daje to

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

Sobie równe Szybki odnośnik E€testuje elementy wszystkich skonstruowanych wektorów do równości.

Gdy n = 3 , otrzymujemy

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

które są elementami trójwymiarowej matrycy tożsamości, w płaskiej matrycy.

Dynamiczne szybkie łącze +þ’¡jest wywoływane z lewym argumentem i prawym argumentem n . Szybkie ¡wywołuje atom dekrementacji ’, który daje n-1 , a następnie wywołuje szybkie łącze dodawania tabeli +þ n-1 razy.

Początkowo +þoba argumenty to n . Po każdym wywołaniu prawy argument jest zastępowany lewym, a lewy zastępowany jest wartością zwracaną wywołania.

Stół szybkie wywołuje dodawania atom +dla poszczególnych elementów jego lewego argumentu, a każdy element jej prawego argumentu budowy stołu / macierz wartości zwracanej. Początkowe argumenty liczb całkowitych n są awansowane do zakresów [1, ... n] .

Gdy n = 3 , po awansie, ale przed pierwszą iteracją, oba argumenty są

[1, 2, 3]

Dodanie każdej liczby całkowitej w tej tablicy do każdej liczby całkowitej w tej tablicy daje wynik

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

W kolejnym wywołaniu dodajemy każdą z tych tablic do liczb całkowitych w [1, 2, 3] . Dodawanie wektoryzuje (dodanie liczby całkowitej do tablicy dodaje ją do każdego elementu), więc otrzymujemy

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

Ta tablica ma taki sam kształt jak trójwymiarowa matryca tożsamości, ale nie ma prawidłowych elementów.

Na koniec atom pleśniṁ odrzuca wpisy liczb całkowitych wyniku po prawej stronie i zastępuje je kolejno elementami w wyniku po lewej stronie.

Python , 70 bajtów

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

Wypróbuj online!

Rozwiązanie rekurencyjne. Myśląc o macierzy jako liście macierzy o jeden wymiar mniejszej, iteruje tę listę, aby zejść z drzewa. Pamięta wybrane indeksy l, a kiedy nzostały wybrane, przypisujemy 1lub w 0zależności od tego, czy wszystkie są takie same.

Python 2 , 73 bajty

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

Wypróbuj online!

Ulepszenie metody tworzenia przez człowieka matrycy zer, a następnie przypisywania ich do przekątnej.

Python 2 , 88 bajtów

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

Wypróbuj online!

Niektóre bzdury eval, generowanie zagnieżdżonej listy i podstawianie w postaci łańcucha. Ciąg do oceny wygląda następująco:

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

Python 2 + NumPy , 80 72 70 bajtów

Teraz związany z najwyższą odpowiedzią na Python!

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

Wypróbuj online

_{Zaoszczędzono 8 bajtów dzięki Andrasowi Deakowi i 2 przez officialaimm}

Python 2 , 99 93 90 bajtów

Dzięki Rod dla niektórych nawet więcej pomocy, że dostał pracę, a także ogolone 6 bajtów off! -3 bajty dzięki xnor.

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

Wypróbuj online!

JavaScript (ES6), 67 bajtów

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

Objaśnienie: isłuży do śledzenia, czy komórka znajduje się na głównej przekątnej, czy nie. Początkowo jest niezdefiniowany, więc przy pierwszym wywołaniu rekurencyjnym zawsze przekazujemy pierwszy wymiar, podczas gdy przy kolejnych wywołaniach rekurencyjnych przekazujemy go tylko wtedy, gdy bieżący indeks wymiaru jest równy wszystkim poprzednim wymiarom, w przeciwnym razie przekazujemy indeks, nktóry wskazuje, że wszystkie komórki rekurencyjne powinny wynosić zero.

Brainfuck , 61 bajtów

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

Bez golfa

Liczby po nawiasach kątowych wskazują komórkę, nad którą znajduje się głowa.

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

Wypróbuj online!

Dane wejściowe to liczba binarna. Dane wyjściowe to macierz przechowywana w kolejności rzędów głównych.

R , 64 49 bajtów

-15 bajtów dzięki Jarko Dubbeldam

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

Odczytuje ze standardowego wejścia i zwraca tablicę, drukując jako matryce. seqgeneruje sekwencję równomiernie rozmieszczoną od 1do n^nz długością l=n, co całkiem nieźle ułatwia indeksowanie, gdzie idą 1.

Wypróbuj online!

stara wersja:

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

Czyta nze standardowego; zwraca tablicę, drukując wyniki jako macierze. Zmagałem się z tym przez chwilę, aż przeczytałem dokumentację [, która wskazuje, że do indeksowania tablicy można użyć macierzy, gdzie każdy wiersz macierzy reprezentuje zestaw indeksów. Schludny!

Wypróbuj online!

J , 16 15 bajtów

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

Wypróbuj online!

Python 3 + numpy, 81 77 bajtów

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

Nie jestem do końca pewien, czy powyższe spełnia wszystkie wytyczne: zwraca tablicę ndarray o podanych właściwościach. Wiem, że anonimowe funkcje są zwykle w porządku, ale interaktywna powłoka faktycznie wydrukuje

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

Jeśli puch tablic powoduje, że powyższe jest nieważne, muszę wrzucić print()około 7 dodatkowych bajtów.

Wypróbuj online!

Pyth, 14 bajtów

ucGQtQms!t{d^U

Zestaw testowy

Objaśnienie ^U:, niejawnie ^UQQ, gdzie Qjest dane wejściowe, oblicza wszystkie możliwe listy elementów Q zakresu 0 ... n-1. ms!t{dodwzorowuje te ze wszystkimi elementami równymi 1, a pozostałe na 0. Daje to spłaszczoną moc wyjściową

ucGQtQ wykonuje następujące czynności, Q - 1 razy: Posiekaj dane wejściowe na listy o rozmiarze Q.

C # (.NET Core) , 166 bajtów

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

Wypróbuj online!

Na początku myślałem, że nie da się tego zrobić za pomocą wyrażenia lambda w C # ... ^ __ ^ U

Common Lisp, 147 133 bajtów

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

Wypróbuj online!

Zwykłe bardzo długie seplenienie. Zmniejszono 12 bajtów dzięki @ceilingcat!

Wyjaśnienie:

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

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

Wypróbuj tutaj!
Pozostawia dane wyjściowe na stosie , widoczne w konsoli. Jeśli liczby na wyjściu mogą być ciągami, wówczas rmożna je usunąć.
Jako zabawny test tego, jak radzi sobie SOGL w wyzwaniach, nie został on całkowicie stworzony dla: str

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 bajty

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

Fajnie, że assoc-in działa również z wektorami, nie tylko z mapami skrótów.