Geben Sie bei einer positiven Ganzzahl ndie Neindimensionale Identität "Matrix" aus, bei der es sich um das N^NArray handelt, bei 1dem alle Komponenten der Indizes gleich und 0ansonsten gleich sind . N^Nbedeutet 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]]]]

Zum Beispiel, wenn adie 4-dimensional Identität „Matrix“, dann die einzigen Einträge mit 1wären a[0][0][0][0], a[1][1][1][1], a[2][2][2][2], und a[3][3][3][3].

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt. Es gelten Standardlücken .

Oktave, 29 Bytes

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

Probieren Sie es online!

Gelee , 8 Bytes

×=¥þ’¡`Ṡ

Probieren Sie es online!

Oh, sieht so aus, als würde ich @Dennis wieder in seiner eigenen Sprache spielen :-)

Dies ist eine 1-Argument-Funktion (da das Standardausgabeformat von Jelly für verschachtelte Listen etwas mehrdeutig ist und die Spezifikation möglicherweise nicht als vollständiges Programm erfüllt).

Erläuterung

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

Um dies zu verstehen, ist es hilfreich, die Zwischenschritte zu betrachten. Bei einer Eingabe von 3 erhalten wir folgende Zwischenschritte:

1. [1,2,3](Eingabe, die implizit von der in einen Bereich gestellt wird þ)
2. [[1,0,0],[0,2,0],[0,0,3]](Erstelle eine Tabelle mit [1,2,3], vergleiche, um Gleichheit zu erhalten [[1,0,0],[0,1,0],[0,0,1]], und multipliziere dann mit einem der Werte, die wir verglichen haben.)
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]]] (die gleiche Idee nochmal)
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]]](Ersetzen Sie jedes Element durch sein Vorzeichen mit Ṡ)

Die Tatsache, dass die Eingabe eindimensional beginnt, bedeutet, dass wir eine Schleife (Eingabe-1) durchführen müssen, um Dimensionen (Eingabe-1) hinzuzufügen und eine eindimensionale Liste zu erstellen.

Unterhaltsame Tatsache: Dieses Programm enthält fünf Schnelldurchläufe hintereinander ¥þ’¡`. (Ein Quick ist ein Modifikator für einen "Link" oder einen eingebauten Link, der zum Ändern seines Verhaltens oder zum Kombinieren mit einem anderen Link verwendet wird.)

Mathematica, 30 Bytes

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

APL (Dyalog) , 10 Bytes

1=≢∘∪¨⍳⍴⍨⎕

Probieren Sie es online!

1= [ist] 1 gleich

≢ die Nummer

∘ von

∪ einzigartige Elemente

¨ in jedem

⍳ die Indizes in einem Array mit den Dimensionen von

⍴⍨ die Selbstumformung ( N Kopien von N ) von

⎕ die Eingabe ( N ) [?]

Gelee , 9 Bytes

ðṗE€ṁ+þ’¡

Probieren Sie es online!

Wie es funktioniert

Es scheint schwierig zu sein, die Aufgabe direkt zu lösen (ich habe keinen Weg gefunden), aber es ist ziemlich einfach, Arrays mit den gleichen Zahlen und der gleichen Form zu konstruieren.

ðmacht die Kette dyadisch, und die Ganzzahleingabe n dient sowohl als linkes als auch als rechtes Argument für die Kette. Es ist möglich, stattdessen eine monadische Kette zu verwenden, aber die Analyseregeln für dyadische speichern hier drei Bytes (zwei nach der Berechnung vonð ).

Das kartesische Potenzatom ṗmit dem linken und rechten Argument gleich n konstruiert das Array aller Vektoren der Länge n , die aus lexikographisch sortierten Elementen von [1, ..., n] bestehen .

Wenn n = 3 ist , ergibt dies

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

Der Gleichheits- Quicklink E€testet die Elemente aller konstruierten Vektoren auf Gleichheit.

Wenn n = 3 , bekommen wir

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

Dies sind die Elemente der dreidimensionalen Identitätsmatrix in einer flachen Anordnung.

Der dyadische Quicklink +þ’¡wird mit linkem und rechtem Argument n aufgerufen . Der Quick ¡ruft das Dekrement-Atom auf ’, das n-1 ergibt , und ruft dann den Add-Table- Quicklink +þ n-1- mal auf.

Anfangs sind die Argumente von +þbeide n . Nach jedem Aufruf wird das rechte Argument durch das linke und das linke Argument durch den Rückgabewert des Aufrufs ersetzt.

Die Tabelle ruft für jedes Element des linken Arguments und jedes Element des rechten Arguments schnell das Atom add+ auf und erstellt eine Tabelle / Matrix des Rückgabewerts. Die anfänglichen ganzzahligen Argumente n werden in die Bereiche [1, ... n] hochgestuft .

Wenn n = 3 ist , lauten beide Argumente nach der Heraufstufung, jedoch vor der ersten Iteration

[1, 2, 3]

Das Addieren jeder Ganzzahl in diesem Array zu jeder Ganzzahl in diesem Array ergibt

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

Beim nächsten Aufruf fügen wir jedes dieser Arrays den Ganzzahlen in [1, 2, 3] hinzu . Die Addition vektorisiert (das Hinzufügen einer Ganzzahl zu einem Array fügt es jedem Element hinzu), also erhalten wir

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

Dieses Array hat dieselbe Form wie die dreidimensionale Identitätsmatrix, jedoch nicht die richtigen Elemente.

Schließlich werden die Formatom verwirft die ganzzahlige Einträge des Ergebnisses nach rechts und ersetzt sie mit den Elementen in der Folge nach links um.ṁ

Python , 70 Bytes

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

Probieren Sie es online!

Eine rekursive Lösung. Wenn Sie sich die Matrix als eine um eine Dimension kleinere Liste von Matrizen vorstellen, iteriert sie über diese Liste, um den Baum zu durchlaufen. Es merkt sich die ausgewählten Indizes l, und wenn nIndizes ausgewählt wurden, weisen wir ein 1oder 0abhängig davon, ob sie alle gleich sind.

Python 2 , 73 Bytes

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

Probieren Sie es online!

Eine Verbesserung gegenüber der Methode von Totalhuman , eine Nullmatrix zu erstellen und dann der Diagonale Einsen zuzuweisen .

Python 2 , 88 Bytes

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

Probieren Sie es online!

Ein bisschen Unsinn mit eval, dem Generieren einer verschachtelten Liste und dem Ersetzen durch Zeichenfolgen. Die auszuwertende Zeichenfolge sieht folgendermaßen aus:

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

Python 2 + NumPy , 80 72 70 Bytes

Jetzt mit der Top-Python-Antwort verbunden!

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

Probieren Sie es online aus

_{8 Bytes dank Andras Deak und 2 von officialaimm gespeichert}

Python 2 , 99 93 90 Bytes

Dank Rod für einige noch mehr Hilfe , die habe es funktioniert und auch 6 Bytes abrasiert! -3 Bytes dank xnor.

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

Probieren Sie es 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)

Erläuterung: Wird iverwendet, um zu verfolgen, ob sich die Zelle in der Hauptdiagonale befindet oder nicht. Anfänglich ist es undefiniert, sodass wir beim ersten rekursiven Aufruf immer die erste Dimension übergeben, während wir sie bei nachfolgenden rekursiven Aufrufen nur übergeben, wenn der aktuelle Dimensionsindex allen vorherigen Dimensionen entspricht, andernfalls übergeben wir einen Index, der nangibt, dass alle von Die rekursiven Zellen sollten Null sein.

Brainfuck , 61 Bytes

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

Ungolfed

Die Zahlen hinter den spitzen Klammern geben an, über welcher Zelle sich der Kopf befindet.

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

Probieren Sie es online!

Die Eingabe ist eine Binärzahl. Die Ausgabe ist eine Matrix, die in der Reihenfolge der Hauptzeilen gespeichert ist.

R , 64 49 Bytes

-15 Bytes dank Jarko Dubbeldam

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

Liest von stdin und gibt ein Array zurück, das als Matrizen gedruckt wird. seqErzeugt eine Sequenz mit gleichmäßigem Abstand von 1bis n^nund Längel=n , was sehr gut dazu beiträgt, zu indizieren, wohin die Einsen gehen.

Probieren Sie es online!

alte Version:

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

Liest nvon stdin; Gibt ein Array zurück und druckt die Ergebnisse als Matrizen. Ich habe eine Weile damit gekämpft, bis ich die Dokumente gelesen habe [, die darauf hinweisen, dass eine Matrix zum Indizieren eines Arrays verwendet werden kann, wobei jede Zeile der Matrix die Menge der Indizes darstellt. Ordentlich!

Probieren Sie es online!

J , 16-15 Bytes

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

Probieren Sie es online!

Python 3 + Anzahl, 81 77 Bytes

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

Ich bin nicht ganz sicher, ob das oben genannte allen Richtlinien entspricht: Es wird ein ndarray mit den angegebenen Eigenschaften zurückgegeben. Ich weiß, dass anonyme Funktionen normalerweise in Ordnung sind, aber eine interaktive Shell wird tatsächlich gedruckt

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

Wenn der Array-Flaum das oben genannte ungültig macht, muss ich print()für so etwas wie 7 zusätzliche Bytes einwerfen .

Probieren Sie es online!

Pyth, 14 Bytes

ucGQtQms!t{d^U

Testsuite

Erläuterung: Wenn ^Uimplizit angegeben wird ^UQQ, wo Qsich die Eingabe befindet, werden alle möglichen Q-Element-Listen des Bereichs berechnet 0 ... n-1. ms!t{dOrdnet diejenigen zu, bei denen alle Elemente gleich 1 und der Rest gleich 0 sind. Dies ergibt die abgeflachte Ausgabe

ucGQtQ Führt Folgendes aus, Q - 1 mal: Zerhackt die Eingabe in Listen der Größe 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;}

Probieren Sie es online!

Zuerst dachte ich, dass dies mit einem Lambda-Ausdruck in C # nicht möglich ist ... ^ __ ^ U

Common Lisp, 147 133 Bytes

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

Probieren Sie es online!

Das übliche überlange Lispeln. Reduzierte 12 Bytes dank @ceilingcat!

Erläuterung:

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

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

Probieren Sie es hier aus!
Lässt die Ausgabe auf dem Stapel und kann in der Konsole angezeigt werden. Wenn die Zahlen in der Ausgabe Zeichenfolgen sein dürfen, kann die rentfernt werden.
Nur als lustiger Test, wie sich SOGL in Herausforderungen verhält, wurde es nicht für folgende Zwecke entwickelt: 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 Bytes

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

Schön, dass assoc-in auch mit Vektoren funktioniert, nicht nur mit Hash-Maps.