La sfida è molto semplice. Dato un input intero n, genera la n x nmatrice identità. La matrice identità è una matrice che si 1estende dalla parte superiore sinistra a quella inferiore destra. Scriverai un programma o una funzione che restituirà o genererà la matrice di identità che hai costruito. L'output può essere un array 2D o numeri separati da spazi / tabulazioni e nuove righe.

Esempio di input e output

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.

Questo è code-golf , quindi vince il codice più breve in byte.

MATL, 2 byte

Xy

Una traduzione della mia risposta di Ottava.

Provalo online.

Una versione a 4 byte senza built-in (grazie a 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 byte

identity(Ans

Curiosità: il modo più breve per ottenere un elenco {N,N}è dim(identity(N.

Ecco il modo più breve senza il builtin, in 8 byte:

randM(Ans,Ans)^0

randM(crea una matrice casuale con voci con numeri interi compresi tra -9 e 9 inclusi (che suona stranamente specifico perché lo è). Portiamo quindi questa matrice al nono potere.

Julia, 9 3 byte

eye

Questa è solo una funzione integrata che accetta un numero intero ne restituisce un nxn Array{Float64,2}(ovvero un array 2D). Chiamalo come eye(n).

Si noti che gli invii di questo modulo sono accettabili per questa politica .

APL, 5 byte

∘.=⍨⍳

Questo è un treno di funzioni monadico che accetta un numero intero sulla destra e restituisce la matrice identità.

Provalo qui

Ottava, 10 4 byte

@eye

Restituisce una funzione anonima che accetta un numero ne restituisce la matrice identità.

R, 4 byte

diag

Quando viene data una matrice, diagrestituisce la diagonale della matrice. Tuttavia, quando viene assegnato un numero intero n, diag(n)restituisce la matrice identità.

Provalo online

Python 2, 42 byte

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

Una funzione anonima, produce output come [(1, 0, 0), (0, 1, 0), (0, 0, 1)],

Innanzitutto, crea l'elenco ([1]+[0]*n)*n, che n=3sembra

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

Usando il trucco zip / iter zip(*[iter(_)]*n per creare gruppi di nregali

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

Si noti che 1arriva un indice più tardi ogni volta, dando la matrice identità. Ma c'è una riga tutto zero in più, che viene rimossa con [:n].

Gelatina, 4 byte

R=€R

Non utilizza un built-in. Provalo online!

Come funziona

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 byte

=@i.

Questa è una funzione che accetta un numero intero e restituisce la matrice.

Haskell, 43 37 byte

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

Abbastanza semplice, anche se penso che si possa fare di meglio (senza un linguaggio che abbia già questa funzione integrata, come molti hanno fatto).

Modifica: eliminato alcuni byte grazie a Ørjan Johansen

Pyth, 7 byte

XRm0Q1Q

Provalo online: dimostrazione

Creazione di una matrice di zeri e sostituzione di elementi diagonali con altri.

JavaScript ES6, 68 62 52 byte

Salvato 10 byte grazie a un trucco accurato di @Neil

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

Cercando un approccio diverso rispetto a quello di @ Cᴏɴᴏʀ O'Bʀɪᴇɴ. Potrebbe forse essere migliorato.

Retina , 25

Ringraziamo @randomra e @Martin per il golf extra.

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

Provalo online.

Si noti che questo accetta input come unario. Se ciò non è accettabile, è possibile fornire un input decimale come segue:

Retina, 34

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

Provalo online.

Haskell, 54 byte

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

frestituisce la matrice identità per l'input n. Lungi dall'essere ottimale.

Lua, 77 75 65 byte

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

Beh, non sono sicuro che lua sia la lingua migliore per questo con la concatenazione di due periodi ... Ma hey, c'è una possibilità. Vedrò se ci sono miglioramenti da apportare.

MODIFICARE:

Ho scoperto qualcosa per caso che trovo piuttosto strano, ma funziona.

In Lua, tutti sanno che hai la possibilità di assegnare funzioni alle variabili. Questa è una delle funzionalità più utili di CodeGolf.

Ciò significa invece di:

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

Puoi farlo:

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

Ma aspetta, Lua consente una certa quantità di OOP. Quindi potresti potenzialmente fare anche:

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

Funzionerà anche e taglierà i personaggi.

Ora ecco che arriva la parte strana. Non è nemmeno necessario assegnare una stringa in nessun punto. Semplicemente facendo:

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

Funzionerà.

Quindi puoi vedere visivamente la differenza, dai un'occhiata ai risultati golfati di questo:

Utilizzo di string.sub (88 caratteri)

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

Assegnare string.sub a una variabile (65 caratteri)

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

Assegnare string.sub usando un approccio OOP (64 caratteri)

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

Assegnare string.sub usando un approccio .. nil? (60 caratteri)

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

Se qualcuno sa perché questo funziona, sarei interessato.

Python 3, 48

Salvato 1 byte grazie a sp3000.

Adoro le sfide che posso risolvere in una riga. Abbastanza semplice, costruisci una linea tra 1 e 0 uguale alla lunghezza dell'int int trasmessa. Output come un array 2d. Se avvolgi la parte dopo il: in '\n'.join(), la stamperà piuttosto.

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

C, 59 o 59 56 o 56

Due versioni di identica lunghezza.

3 byte salvati a causa di suggerimenti di anatolyg: (n+1)->~n

Passa ida n*n-1zero a zero. Stampa un 1 se i% (n + 1) è zero, altrimenti 0. Quindi stampa una nuova riga se i%n= 0 altrimenti uno spazio.

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 byte

I(3)

Produzione

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

Mata è il linguaggio di programmazione matriciale disponibile nel pacchetto statistico Stata. I (n) crea una matrice identità di dimensione n * n

K6 , 1 byte

=

= è esattamente questo

Provalo online!

Pyth, 8 byte

mmsqdkQQ

Provalo qui .

Python 3.5 con NumPy - 57 49 30 byte

import numpy
numpy.identity

NumPy.identity accetta un numero intero, n, e restituisce una matrice di identità di n. Questa risposta è consentita tramite questa politica .

Mathematica, 35 byte

senza usare 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 byte

Uo £Z®¥X|0

Provalo online! Nota: questa versione ha qualche byte in più per stampare graziosamente l'output.

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 byte

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

Provalo online!

K, 7 byte

t=\:t:!

Prendi il prodotto incrociato di uguaglianza di due vettori contenenti [0, n).

In azione:

  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 byte

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

Crea un array 2D e sostituisce elementi in cui riga e colonna sono uguali 1.

CJam, 7 byte

{,_ff=}

Questo è un blocco di codice che estrae un numero intero dallo stack e invia in cambio un array 2D.

Provalo online!

Mathematica, 14 byte

IdentityMatrix

Caso di prova

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

Perl, 39 33 byte

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

Grazie a Ton Hospel per aver salvato 6 byte

In esecuzione con il -Eperlrun:

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