N-dimensionale Identitätsmatrix

30

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 .

code-golf  math  array-manipulation  integer  generation 
— Undichte Nonne
quelle
1
— Undichte Nonne
11
Hier kommt die Antwort von MATL mit einer eingebauten Funktion, die dies für Sie
— erledigt

Antworten:

9

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

+ !, nur weil du Dennis in Jelly besiegt hast.
— Zacharý
7

Mathematica, 30 Bytes

Array[Boole@*Equal,#~Table~#]&
— Genisis
quelle
1
@FryAmTheEggman Ein ganzzahliger Parameter als zweites Argument für Tableist eine neue Ergänzung. Die Mathematik braucht dort noch eine Singleton-Liste: tio.run/##y00sychMLv7/P83WsagosTLaKT8/…
— Martin Ender
1
@FryAmTheEggman Sieht so aus, als müssten Sie es ändern Array[Boole@*Equal,#~Table~{#}]&, um mit Mathematik zu arbeiten. Ältere Versionen von Mathematica unterstützen keine Ganzzahl als zweites Argument Table, und ich denke, Mathics basiert darauf.
— Genisis
1
@ MartinEnder Prise, stupse, du schuldest mir eine Cola :)
— Genisis
6

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

— Adam
quelle
5

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.ṁ

— Dennis
quelle
4

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]
— xnor
quelle
4

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

— mbomb007
quelle
2
Nutzen Sie die ausgefallene Indizierung: a[[range(n)]*n]=1statt Ihrer Exec.
— Andras Deak
(Es gibt eigentlich fill_diagonal(a,1)für diesen Zweck, aber das ist ein Byte länger)
— Andras Deak
1
+1 für die hübsche Ausgabe. Und ich sehe nicht die Verwendung der Variablen i, die 2 Bytes sparen sollte.
— offiziell am
3

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!

— total menschlich
quelle
1
def/returnist besser als nie input/print(es ist gleich im besten Szenario), können Sie auch die Drop - ()in ('[%d]'%i)zur Verringerung der 93 Bytes
— Rod
1
'[%d]'%izufällig die Zeichenfolge von sein [i].
— xnor
2

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.

— Neil
quelle
2

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.

— Strahl
quelle
Die Antworten enthalten bereits einige unterschiedliche Ausgabeformate, daher gehe ich davon aus, dass die einzige Anforderung "eine Standardmatrixdarstellung" ist. Wenn es in einem bestimmten Format sein muss, ändere ich den Code entsprechend.
— Ray
Ich denke, Zeilensprung in diesem speziellen Fall würde genau so aussehen wie Zeilensprung
— Octopus
@Octopus Tatsächlich bestimmt das Programm anhand der Sprache, in der der Brainfuck-Interpreter geschrieben ist, ob es sich um eine Zeilen- oder eine Spaltenreihenfolge handelt. Meins ist in C geschrieben, daher gibt es die Matrix natürlich in Zeilenreihenfolge aus. Wenn Sie jedoch einen in Fortran oder MATLAB geschriebenen Interpreter verwenden, würde dieser dies erkennen und automatisch zur Spaltenhauptreihenfolge wechseln. (Wenn Sie einen in Brainfuck selbst geschriebenen Dolmetscher verwendet haben, wird die Mehrdeutigkeit basierend auf der Sprache, in der Ihr Texteditor geschrieben ist, behoben.) :-)
— Ray
2

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!

— Giuseppe
quelle
array(0, rep(n,n)funktioniert, so müssen Sie nicht tun rep. Sie können dann auch ndurch nehmen array(0, rep(n<-scan(),n)).
— JAD
Ist auch x[seq(1,n^n,l=n)]=11 Byte kürzer.
— JAD
@ JarkoDubbeldam danke! Schön.
— Giuseppe
1

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!

— Andras Deak
quelle
1

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.

— isaacg
quelle
1

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

— Charlie
quelle
1

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
— Renzo
quelle
@ceilingcat, ops, es gab einen blöden Fehler in der Golfversion. Korrigiert, danke!
— Renzo
0

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
— dzaima
quelle
0

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.

— NikoNyrh
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.