Dato un numero intero positivo n, Ngenera l'identità -dimensionale "matrice", che è l' N^Narray con 1cui tutti i componenti degli indici sono uguali e in 0altro modo. N^Nsignifica N-per-N-per-N-per -...

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

Ad esempio, se aè l' 4identità dimensionale "matrice", le uniche voci con 1sarebbero a[0][0][0][0], a[1][1][1][1], a[2][2][2][2], e a[3][3][3][3].

Questo è code-golf . Vince la risposta più breve in byte. Si applicano scappatoie standard .

Ottava, 29 byte

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

Provalo online!

Gelatina , 8 byte

×=¥þ’¡`Ṡ

Provalo online!

Ooh, sembra che riesco a superare di nuovo @Dennis nella sua lingua :-)

Questa è una funzione a 1 argomento (perché il formato di output predefinito di Jelly per gli elenchi nidificati è un po 'ambiguo, il che significa che probabilmente non soddisfa le specifiche come un programma completo).

Spiegazione

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

Per capirlo, aiuta a guardare i passaggi intermedi. Per un input di 3, otteniamo i seguenti passaggi intermedi:

1. [1,2,3](input, trasformato in un intervallo implicitamente dal þ)
2. [[1,0,0],[0,2,0],[0,0,3]](crea una tabella con [1,2,3], confronta per ottenere l'uguaglianza [[1,0,0],[0,1,0],[0,0,1]], quindi moltiplica per uno dei valori che abbiamo confrontato)
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]]] (di nuovo la stessa idea)
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]]](sostituisci ogni elemento con il suo segno usando Ṡ)

Notare il fatto che l'ingresso inizia in monodimensionale significa che dobbiamo ripetere il ciclo (input-1) volte per aggiungere dimensioni (input-1), producendo un elenco dimensionale di input.

Una curiosità: questo programma contiene cinque quicks di fila, ¥þ’¡`. (Un rapido è un modificatore di un "collegamento", o incorporato, utilizzato per modificarne il comportamento o combinarlo con un altro collegamento.)

Mathematica, 30 byte

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

APL (Dyalog) , 10 byte

1=≢∘∪¨⍳⍴⍨⎕

Provalo online!

1= [è] 1 uguale a

≢ il numero

∘ di

∪ elementi unici

¨ in ciascuno di

⍳ gli indici in un array con le dimensioni di

⍴⍨ l'auto-rimodellare ( N copie di N ) di

⎕ l'ingresso ( N ) [?]

Gelatina , 9 byte

ðṗE€ṁ+þ’¡

Provalo online!

Come funziona

Raggiungere il compito direttamente sembra essere difficile (non ho trovato un modo), ma contrarre array dello stesso numero e array della stessa forma è abbastanza facile.

ðrende la catena diadica e l'input intero n funge da argomento sia a destra che a sinistra per la catena. È invece possibile utilizzare una catena monadica, ma le regole di analisi per quelle diadiche salvano tre byte qui (due dopo aver attaccato per ð).

L' atomo di potere cartesianoṗ , con argomento destro e sinistro pari a n , costruisce la matrice di tutti i vettori di lunghezza n che consistono in elementi di [1, ..., n] , ordinati lessicograficamente.

Quando n = 3 , questo produce

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

La parità di ciascun collegamento rapido E€verifica l' eguaglianza degli elementi di tutti i vettori costruiti.

Quando n = 3 , otteniamo

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

quali sono gli elementi della matrice di identità tridimensionale, in una matrice piatta.

Il collegamento rapido diadico +þ’¡viene chiamato con argomento sinistro e argomento destro n . Il rapido ¡chiama l'atomo di decremento ’, che produce n-1 , quindi chiama il collegamento rapido della tabella +þ n-1 volte.

Inizialmente, gli argomenti di +þsono entrambi n . Dopo ogni chiamata, l'argomento destro viene sostituito da quello sinistro e quello sinistro viene sostituito dal valore restituito della chiamata.

La tabella chiama l' atomo add+ per ogni elemento del suo argomento sinistro e ogni elemento del suo argomento destro, costruendo una tabella / matrice del valore restituito. Gli argomenti interi iniziali n vengono promossi negli intervalli [1, ... n] .

Quando n = 3 , dopo la promozione ma prima della prima iterazione, entrambi gli argomenti sono

[1, 2, 3]

Aggiungendo ogni numero intero in questo array a ciascun numero intero in questo array si ottiene

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

Nella prossima invocazione, aggiungeremo ciascuno di questi array agli interi in [1, 2, 3] . L'aggiunta vettorializza (l'aggiunta di un numero intero a un array lo aggiunge a ciascun elemento), quindi otteniamo

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

Questa matrice ha la stessa forma della matrice di identità tridimensionale, ma non gli elementi corretti.

Infine, l' atomo di stampoṁ scarta le voci intere del risultato a destra e le sostituisce in ordine con gli elementi nel risultato a sinistra.

Python , 70 byte

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

Provalo online!

Una soluzione ricorsiva. Pensando alla matrice come a un elenco di matrici di una dimensione più piccola, scorre su quell'elenco per scendere l'albero. Ricorda gli indici raccolti le, quando gli nindici sono stati scelti, assegniamo un 1o a 0seconda che siano tutti uguali.

Python 2 , 73 byte

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

Provalo online!

Un miglioramento del metodo totalmente umano di creare una matrice di zero e quindi assegnarne uno alla diagonale.

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)

Provalo online!

Alcune sciocchezze con eval, generazione di un elenco nidificato e sostituzione del formato stringa. La stringa da valutare è simile a:

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

Python 2 + NumPy , 80 72 70 byte

Ora legato con la risposta in alto Python!

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

Provalo online

_{Salvataggio di 8 byte grazie ad Andras Deak e 2 di officialaimm}

Python 2 , 99 93 90 byte

Grazie a Rod per un aiuto ancora maggiore che ha funzionato e ha anche eliminato 6 byte! -3 byte grazie a xnor.

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

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

Spiegazione: iviene utilizzato per tenere traccia del fatto che la cella si trovi sulla diagonale principale o meno. Inizialmente non è definito, quindi nella prima chiamata ricorsiva passiamo sempre la prima dimensione, mentre nelle successive chiamate ricorsive lo passiamo solo se l'indice della dimensione corrente è uguale a tutte le dimensioni precedenti, altrimenti passiamo un indice del nquale indica che tutti le cellule ricorsive dovrebbero essere zero.

Brainfuck , 61 byte

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

Ungolfed

I numeri dopo le parentesi angolari indicano la cella su cui si trova la testa.

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

Provalo online!

L'input è un numero binario. L'output è una matrice memorizzata nell'ordine delle righe principali.

R , 64 49 byte

-15 byte grazie a Jarko Dubbeldam

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

Legge da stdin e restituisce un array, stampando come matrici. seqgenera una sequenza uniformemente distanziata da 1a n^ncon lunghezzal=n , che fa il trucco abbastanza bene per indicizzare dove vanno 1s.

Provalo online!

vecchia versione:

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

Legge nda stdin; restituisce un array, stampando i risultati come matrici. Ho lottato con questo per un po 'fino a quando ho letto i documenti per[ , che indicano che una matrice può essere utilizzata per indicizzare un array, in cui ogni riga della matrice rappresenta l'insieme di indici. ! Neat

Provalo online!

J , 16 15 byte

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

Provalo 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

Non sono del tutto sicuro che quanto sopra si adatta a tutte le linee guida: restituisce un ndarray con le proprietà indicate. So che le funzioni anonime di solito vanno bene, ma una shell interattiva verrà effettivamente stampata

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

Se la fluff dell'array rende non valido quanto sopra, devo inserire a print()qualcosa come 7 byte aggiuntivi.

Provalo online!

Pyth, 14 byte

ucGQtQms!t{d^U

Suite di test

Spiegazione:, ^Uche è implicitamente ^UQQ, dove si Qtrova l'input, calcola tutti i possibili elenchi di elementi Q dell'intervallo 0 ... n-1.ms!t{dmappa quelli con tutti gli elementi uguali a 1 e il resto a 0. Ciò fornisce un output appiattito

ucGQtQ esegue quanto segue, Q - 1 volte: Taglia l'input in elenchi di dimensioni 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;}

Provalo online!

All'inizio ho pensato che non potesse essere fatto con un'espressione lambda in C # ... ^ __ ^ U

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

Provalo online!

Il solito pisolino super lungo. Ridotto di 12 byte grazie a @ceilingcat!

Spiegazione:

(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

Provalo qui!
Lascia l'output nello stack , visualizzabile nella console. Se ai numeri nell'output fosse consentito di essere stringhe, è rpossibile rimuoverli.
Proprio come un test divertente di come SOGL fa nelle sfide per cui non è stato completamente realizzato: 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 %))

Bello che assoc-in funzioni anche con i vettori, non solo con le mappe hash.