Le défi est très simple. Avec une entrée entière n, sortez la n x nmatrice d'identité. La matrice d'identité est une matrice qui 1s'étend du haut à gauche au bas à droite. Vous allez écrire un programme ou une fonction qui renverra ou sortira la matrice d’identité que vous avez construite. Votre sortie peut être un tableau 2D ou des nombres séparés par des espaces / tabulations et des nouvelles lignes.

Exemple d'entrée et de sortie

1: [[1]]
2: [[1, 0], [0, 1]]
3: [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
4: [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
5: [[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]]

1
===
1

2
===
1 0
0 1

3
===
1 0 0
0 1 0
0 0 1

etc.

C'est le code-golf , donc le code le plus court en octets gagne.

MATL, 2 octets

Xy

Une traduction de ma réponse Octave.

Essayez-le en ligne.

Une version de 4 octets sans construit (grâce à Luis Mendo):

:t!=
:     take input n and a generate row array [1,2,...n]
 t    duplicate
  !   zip
   =  thread compare over the result

TI-BASIC, 2 octets

identity(Ans

Anecdote: Le moyen le plus rapide d’obtenir une liste {N,N}est dim(identity(N.

Voici le chemin le plus court sans l'integrin, en 8 octets:

randM(Ans,Ans)^0

randM(crée une matrice aléatoire avec des entrées comprenant tous les nombres entiers compris entre -9 et 9 inclus (cela peut paraître étrange parce que c'est le cas). Nous prenons ensuite cette matrice à la puissance 0.

Julia, 9 3 octets

eye

Ceci est juste une fonction intégrée qui accepte un entier net renvoie un nxn Array{Float64,2}(c'est-à-dire un tableau 2D). Appelez ça comme eye(n).

Notez que les soumissions de ce formulaire sont acceptables selon cette politique .

APL, 5 octets

∘.=⍨⍳

Il s'agit d'un train de fonctions monadique qui accepte un entier à droite et renvoie la matrice d'identité.

Essayez ici

Octave, 10 4 octets

@eye

Renvoie une fonction anonyme qui prend un nombre net renvoie la matrice d'identité.

R, 4 octets

diag

Quand une matrice est donnée, diagretourne la diagonale de la matrice. Cependant, lorsqu'un entier est attribué n, diag(n)retourne la matrice d'identité.

Essayez-le en ligne

Python 2, 42 octets

lambda n:zip(*[iter(([1]+[0]*n)*n)]*n)[:n]

Une fonction anonyme produit une sortie telle que [(1, 0, 0), (0, 1, 0), (0, 0, 1)],

Tout d'abord, crée la liste ([1]+[0]*n)*n, qui n=3ressemble à

[1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]

Utilisation de l’ astuce zip / iter zip(*[iter(_)]*n pour créer des groupes de ncadeaux

[(1, 0, 0), (0, 1, 0), (0, 0, 1), (0, 0, 0)]

Notez que le 1vient un index plus tard à chaque fois, donnant la matrice d'identité. Mais, il y a une ligne tout à zéro supplémentaire, qui est supprimée avec [:n].

Gelée, 4 octets

R=€R

N'utilise pas d'intégré. Essayez-le en ligne!

Comment ça marche

R=€R    Main link. Input: n

R       Range; yield [1, ..., n].
   R    Range; yield [1, ..., n].
 =€     Compare each.
        This compares each element of the left list with the right list, so it
        yields [1 = [1, ..., n], ..., n = [1, ..., n]], where comparison is
        performed on the integers.

J, 4 octets

=@i.

C'est une fonction qui prend un entier et retourne la matrice.

Haskell, 43 37 octets

f n=[[0^abs(x-y)|y<-[1..n]]|x<-[1..n]]

C'est assez simple, même si je pense que l'on peut faire mieux (sans un langage qui intègre déjà cette fonction, comme beaucoup l'ont fait).

Edit: laissé tomber quelques octets grâce à Ørjan Johansen

Pyth, 7 octets

XRm0Q1Q

Essayez-le en ligne: démonstration

Créer une matrice de zéros et remplacer les éléments diagonaux par des uns.

JavaScript ES6, 68 62 52 octets

10 octets sauvés grâce à une astuce de @Neil

x=>[...Array(x)].map((_,y,x)=>x.map((_,z)=>+(y==z)))

Essayer une approche différente de celle de @ Cᴏɴᴏʀ O'Bʀɪᴇɴ. Pourrait éventuellement être amélioré.

Rétine , 25

Crédit à @randomra et @Martin pour le golf supplémentaire.

\B.
 0
+`(.*) 0$
$0¶0 $1

Essayez-le en ligne.

Notez que cela prend une entrée unaire. Si cela n’est pas acceptable, l’entrée décimale peut être donnée comme suit:

Rétine, 34 ans

.+
$0$*1
\B.
 0
+`(.*) 0$
$0¶0 $1

Essayez-le en ligne.

Haskell, 54 octets

(#)=replicate
f n=map(\x->x#0++[1]++(n-x-1)#0)[0..n-1]

frenvoie la matrice d'identité pour l'entrée n. Loin d'être optimal.

Lua, 77 75 65 octets

x,v=z.rep,io.read()for a=1,v do print(x(0,a-1)..'1'..x(0,v-a))end

Eh bien, je ne suis pas sûr que Lua soit la meilleure langue pour cela avec la concaténation en deux périodes ... Mais bon, on a une chance. Je verrai s'il y a des améliorations à apporter.

MODIFIER:

J'ai trouvé quelque chose par hasard que je trouve assez étrange, mais ça marche.

En Lua, tout le monde sait que vous avez la possibilité d’attribuer des fonctions à des variables. C'est l'une des fonctionnalités les plus utiles de CodeGolf.

Cela signifie au lieu de:

string.sub("50", 1, 1) -- = 5
string.sub("50", 2, 2) -- = 0
string.sub("40", 1, 1) -- = 4
string.sub("40", 2, 2) -- = 0

Tu peux le faire:

s = string.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0

Mais attendez, Lua permet une certaine quantité de POO. Donc, vous pourriez même potentiellement faire:

z=""
s = z.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0

Cela fonctionnera aussi bien et coupe les caractères.

Maintenant, voici la partie étrange. Vous n'avez même pas besoin d'attribuer une chaîne à un moment donné. Faire simplement:

s = z.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0

Marchera.

Pour que vous puissiez voir visuellement la différence, jetez un coup d’œil aux résultats obtenus:

Utilisation de string.sub (88 caractères)

string.sub("50", 1, 1)string.sub("50", 2, 2)string.sub("40", 1, 1)string.sub("40", 2, 2)

Affectation de string.sub à une variable (65 caractères)

s=string.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)

Affectation de string.sub en utilisant une approche POO (64 caractères)

z=""s=z.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)

Assigner string.sub en utilisant une approche .. nil? (60 caractères)

s=z.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)

Si quelqu'un sait pourquoi cela fonctionne, je serais intéressé.

Python 3, 48

Sauvegardé 1 octet grâce à sp3000.

J'adore les défis que je peux résoudre en une ligne. Assez simple, construisez une ligne à partir de 1 et 0 égale à la longueur de l'int transmis. Sortie en tant que tableau 2d. Si vous emballez la partie après le: in '\n'.join(), ça va bien l’imprimer.

lambda x:[[0]*i+[1]+[0]*(x+~i)for i in range(x)]

C, 59 ou 59 56 ou 56

Deux versions de longueur identique.

3 octets sauvés grâce à une suggestion de anatolyg: (n+1)->~n

Itère ide n*n-1zéro. Imprime un 1 si i% (n + 1) est égal à zéro, sinon 0. Imprime une nouvelle ligne si i%n= 0 sinon un espace.

i;f(n){for(i=n*n;i--;)printf(i%n?"%d ":"%d\n",!(i%~n));}

i;f(n){for(i=n*n;i--;)printf("%d%c",!(i%~n),i%n?32:10);}

Mata, 4 octets

I(3)

Sortie

[symmetric]
       1   2   3
    +-------------+
  1 |  1          |
  2 |  0   1      |
  3 |  0   0   1  |
    +-------------+

Mata est le langage de programmation matriciel disponible dans le progiciel statistique Stata. I (n) crée une matrice d'identité de taille n * n

K6 , 1 octet

=

= est-ce exactement cela

Essayez-le en ligne!

Pyth, 8 octets

mmsqdkQQ

Essayez ici .

Python 3.5 avec NumPy - 57 49 30 octets

import numpy
numpy.identity

NumPy.identity prend un entier, n, et retourne une matrice d'identité par n. Cette réponse est autorisée via cette politique .

Mathematica, 35 octets

sans utiliser IdentityMatrix

Table[Boole[i==j],{i,1,#},{j,1,#}]&

Javascript, 40

f=
n=>'0'.repeat(n).replace(/./g,"$`1$'\n")

I.oninput=_=>O.innerHTML=f(+I.value)
I.oninput()

<input id=I value=5>
<pre id=O>

Japt, 14 12 10 octets

Uo £Z®¥X|0

Testez-le en ligne! Remarque: cette version dispose de quelques octets supplémentaires pour imprimer en jolie sortie.

Uo £Z®¥X|0    // Implicit: U = input integer
Uo £          // Create the range [0..U). Map each item X and the full array Z to:
    Z®        //  Take the full array Z, and map each item Z to:
      ¥X|0    //   (X == Z) converted to a number. 1 for equal, 0 for non-equal.
              // Implicit: output result of last expression

Brain-Flak , 206 170 162 octets

(([{}])){({}<>(())<><(({})<{({}()(<>)<>)}{}>)>)}{}(({}<><(())>)){({}()<({[()]<({}()<({}<>((((()()()()){}){}){})((()()()()){}){})<>>)>}{})>)<>((()()()()()){})<>}<>

Essayez-le en ligne!

K, 7 octets

t=\:t:!

Prenons le produit croisé d'égalité de deux vecteurs contenant [0, n).

En action:

  t=\:t:!3
(1 0 0
 0 1 0
 0 0 1)
  t=\:t:!5
(1 0 0 0 0
 0 1 0 0 0
 0 0 1 0 0
 0 0 0 1 0
 0 0 0 0 1)

Java, 60 octets

n->{int[][]i=new int[n][n];for(;n-->0;)i[n][n]=1;return i;};

Crée un tableau 2D et remplace les éléments où rangée et colonne sont égaux 1.

CJam, 7 octets

{,_ff=}

Il s'agit d'un bloc de code qui extrait un entier de la pile et pousse un tableau 2D en retour.

Essayez-le en ligne!

Mathematica, 14 octets

IdentityMatrix

Cas de test

IdentityMatrix[4]
(* {{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}} *)

Perl, 39 33 octets

/$/,say map$`==$_|0,@%for@%=1..<>

Merci à Ton Hospel d' avoir sauvé 6 octets

Courir avec le -Eperlrun:

$ echo 3 | perl -E'@%=1..<>;$a=$_,say map{$a==$_|0}@%for@%'
100
010
001