Étant donné un entier positif n, Nsortez la "matrice" d'identité -dimensionnelle, qui est le N^Ntableau 1où toutes les composantes des indices sont égales et 0autrement. N^Nsignifie N par N par N par N ...

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

Par exemple, si aest l' 4identité de dimension « matrice », alors les seules entrées avec 1seraient a[0][0][0][0], a[1][1][1][1], a[2][2][2][2]et a[3][3][3][3].

C'est du code-golf . La réponse la plus courte en octets gagne. Des échappatoires standard s'appliquent.

Octave, 29 octets

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

Essayez-le en ligne!

Gelée , 8 octets

×=¥þ’¡`Ṡ

Essayez-le en ligne!

Ooh, on dirait que je rejoue @Dennis dans sa propre langue :-)

Il s'agit d'une fonction à 1 argument (car le format de sortie par défaut de Jelly pour les listes imbriquées est un peu ambigu, ce qui signifie qu'il ne répond sans doute pas aux spécifications en tant que programme complet).

Explication

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

Pour comprendre cela, il est utile de regarder les étapes intermédiaires. Pour une entrée de 3, nous obtenons les étapes intermédiaires suivantes:

1. [1,2,3](entrée, transformée implicitement par le þ)
2. [[1,0,0],[0,2,0],[0,0,3]](faire un tableau avec [1,2,3], comparer pour obtenir l'égalité [[1,0,0],[0,1,0],[0,0,1]], puis multiplier par l'une des valeurs que nous avons comparées)
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]]] (encore la même idée)
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]]](remplacez chaque élément par son signe en utilisant Ṡ)

Notez que l'entrée commence unidimensionnelle signifie que nous devons boucler (entrée-1) fois pour ajouter (entrée-1) des dimensions, produisant une liste d'entrée-dimensionnelle.

Fun fait: ce programme contient cinq Quicks dans une rangée, ¥þ’¡`. (Un rapide est un modificateur d'un "lien", ou intégré, utilisé pour modifier son comportement ou le combiner avec un autre lien.)

Mathematica, 30 octets

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

APL (Dyalog) , 10 octets

1=≢∘∪¨⍳⍴⍨⎕

Essayez-le en ligne!

1= [est] 1 égal à

≢ le nombre

∘ de

∪ éléments uniques

¨ Dans chacun de

⍳ les indices dans un tableau avec les dimensions de

⍴⍨ l'auto-remodelage ( N exemplaires de N ) de

⎕ l'entrée ( N ) [?]

Gelée , 9 octets

ðṗE€ṁ+þ’¡

Essayez-le en ligne!

Comment ça marche

La réalisation directe de la tâche semble difficile (je n'ai pas trouvé de moyen), mais la construction de tableaux de mêmes nombres et de tableaux de même forme est assez facile.

ðrend la chaîne dyadique, et l'entrée entière n sert à la fois d'argument gauche et droit pour la chaîne. Il est possible d'utiliser une chaîne monadique à la place, mais les règles d'analyse pour les chaînes dyadiques économisent ici trois octets (deux après avoir accoutumé pour ð).

L' atome de puissance cartésienṗ , avec un argument gauche et droit égal à n , construit le tableau de tous les vecteurs de longueur n qui sont constitués d'éléments de [1, ..., n] , triés lexicographiquement.

Lorsque n = 3 , cela donne

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

L' égale chaque lien rapideE€ teste l' des éléments de tous les vecteurs construits.

Lorsque n = 3 , nous obtenons

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

qui sont les éléments de la matrice d'identité tridimensionnelle, dans un réseau plat.

Le lien rapide dyadique +þ’¡est appelé avec l'argument gauche et l'argument droit n . Le rapide ¡appelle l'atome de décrémentation ’, ce qui donne n-1 , puis appelle n-1 le lien rapide de la table d' ajout .+þ

Initialement, les arguments de +þsont tous les deux n . Après chaque appel, l'argument de droite est remplacé par celui de gauche et celui de gauche est remplacé par la valeur de retour de l'appel.

Le tableau appelle rapidement l' atome d' ajout+ pour chaque élément de son argument de gauche et chaque élément de son argument de droite, construisant une table / matrice de la valeur de retour. Les arguments entiers initiaux n sont promus dans les plages [1, ... n] .

Lorsque n = 3 , après la promotion mais avant la première itération, les deux arguments sont

[1, 2, 3]

L'ajout de chaque entier de ce tableau à chaque entier de ce tableau donne

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

Dans l'invocation suivante, nous ajoutons chacun de ces tableaux aux entiers de [1, 2, 3] . L'addition vectorise (l'ajout d'un entier à un tableau l'ajoute à chaque élément), donc on obtient

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

Ce tableau a la même forme que la matrice d'identité tridimensionnelle, mais pas les éléments corrects.

Enfin, l' atome de mouleṁ supprime les entrées entières du résultat à droite et les remplace dans l'ordre par les éléments du résultat à gauche.

Python , 70 octets

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

Essayez-le en ligne!

Une solution récursive. En considérant la matrice comme une liste de matrices une dimension plus petite, elle parcourt cette liste pour descendre dans l'arbre. Il se souvient des indices sélectionnés l, et lorsque les nindices ont été sélectionnés, nous attribuons un 1ou 0selon qu'ils sont tous identiques.

Python 2 , 73 octets

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

Essayez-le en ligne!

Une amélioration par rapport à la méthode totalement humaine consistant à créer une matrice de zéros puis à les affecter à la diagonale.

Python 2 , 88 octets

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

Essayez-le en ligne!

Quelques absurdités avec eval, génération d'une liste imbriquée et substitution de format de chaîne. La chaîne à évaluer ressemble à:

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

Python 2 + NumPy , 80 72 70 octets

Maintenant à égalité avec la meilleure réponse Python!

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

Essayez-le en ligne

_{Enregistré 8 octets grâce à Andras Deak, et 2 par officialaimm}

Python 2 , 99 93 90 octets

Merci à Rod pour certains aide encore plus qui a obtenu ce travail et aussi rasé 6 octets off! -3 octets grâce à xnor.

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

Essayez-le en ligne!

JavaScript (ES6), 67 octets

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

Explication: ipermet de savoir si la cellule est sur la diagonale principale ou non. Initialement, il n'est pas défini, donc lors du premier appel récursif, nous passons toujours la première dimension, tandis que lors des appels récursifs suivants, nous ne la transmettons que si l'indice de dimension actuel est égal à toutes les dimensions précédentes, sinon nous passons un index nqui indique que tout les cellules récursives doivent être nulles.

Brainfuck , 61 octets

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

Non golfé

Les chiffres après les crochets indiquent la cellule sur laquelle se trouve la tête.

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

Essayez-le en ligne!

L'entrée est un nombre binaire. La sortie est une matrice stockée dans l'ordre des lignes principales.

R , 64 49 octets

-15 octets grâce à Jarko Dubbeldam

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

Lit à partir de stdin et renvoie un tableau, imprimant sous forme de matrices. seqgénère une séquence régulièrement espacée de 1à n^navec la longueurl=n , ce qui fait très bien l'affaire pour indexer où vont les 1.

Essayez-le en ligne!

ancienne version:

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

Lit à npartir de stdin; renvoie un tableau, imprimant les résultats sous forme de matrices. J'ai lutté avec cela pendant un certain temps jusqu'à ce que je lise les documents pour [, qui indiquent qu'une matrice peut être utilisée pour indexer un tableau, où chaque ligne de la matrice représente l'ensemble des indices. Soigné!

Essayez-le en ligne!

J , 16 15 octets

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

Essayez-le en ligne!

Python 3 + numpy, 81 77 octets

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

Je ne suis pas entièrement sûr que ce qui précède convient à toutes les directives: il renvoie un ndarray avec les propriétés données. Je sais que les fonctions anonymes sont généralement bien, mais un shell interactif s'imprimera

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

Si le fluff du tableau rend ce qui précède invalide, je dois ajouter un print()pour quelque chose comme 7 octets supplémentaires.

Essayez-le en ligne!

Pyth, 14 octets

ucGQtQms!t{d^U

Suite de tests

Explication:, ^Uqui est implicitement ^UQQ, où se Qtrouve l'entrée, calcule toutes les listes d'éléments Q possibles de la plage 0 ... n-1.ms!t{dmappe ceux dont tous les éléments sont égaux à 1 et les autres à 0. Cela donne la sortie aplatie

ucGQtQ exécute les opérations suivantes, Q - 1 fois: Coupez l'entrée dans des listes de taille Q.

C # (.NET Core) , 166 octets

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

Essayez-le en ligne!

Au début, je pensais que cela ne pouvait pas être fait avec une expression lambda en C # ... ^ __ ^ U

Lisp commun, 147133 octets

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

Essayez-le en ligne!

Le lisp super-long habituel. Réduction de 12 octets grâce à @ceilingcat!

Explication:

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

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

Essayez-le ici!
Laisse la sortie sur la pile , visible dans la console. Si les nombres dans la sortie étaient autorisés à être des chaînes, alors le rpourrait être supprimé.
Tout comme un test amusant de la façon dont SOGL fait dans les défis, il n'a pas été fait pour: 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 octets

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

Bien que l' assoc-in fonctionne également avec des vecteurs, pas seulement avec des cartes de hachage.