El desafío es muy simple. Dada una entrada entera n, salida de la n x nmatriz de identidad. La matriz de identidad es una que se 1extiende desde la parte superior izquierda hasta la parte inferior derecha. Escribirás un programa o una función que devolverá o generará la matriz de identidad que construiste. Su salida puede ser una matriz 2D o números separados por espacios / pestañas y líneas nuevas.

Ejemplo de entrada y salida

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.

Este es el código de golf , por lo que gana el código más corto en bytes.

MATL, 2 bytes

Xy

Una traducción de mi respuesta Octave.

Pruébalo en línea.

Una versión de 4 bytes sin elementos integrados (gracias 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 bytes

identity(Ans

Dato curioso: la forma más corta de obtener una lista {N,N}es dim(identity(N.

Aquí está el camino más corto sin el incorporado, en 8 bytes:

randM(Ans,Ans)^0

randM(crea una matriz aleatoria con entradas de todos los enteros entre -9 y 9 inclusive (eso suena extrañamente específico porque lo es). Luego llevamos esta matriz a la potencia 0.

Julia, 9 3 bytes

eye

Esta es solo una función incorporada que acepta un número entero ny devuelve un nxn Array{Float64,2}(es decir, una matriz 2D). Llámalo como eye(n).

Tenga en cuenta que los envíos de este formulario son aceptables según esta política .

APL, 5 bytes

∘.=⍨⍳

Este es un tren de funciones monádicas que acepta un número entero a la derecha y devuelve la matriz de identidad.

Pruébalo aquí

Octava, 10 4 bytes

@eye

Devuelve una función anónima que toma un número ny devuelve la matriz de identidad.

R, 4 bytes

diag

Cuando se le da una matriz, diagdevuelve la diagonal de la matriz. Sin embargo, cuando se le da un número entero n, diag(n)devuelve la matriz de identidad.

Pruébalo en línea

Python 2, 42 bytes

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

Una función anónima, produce resultados como [(1, 0, 0), (0, 1, 0), (0, 0, 1)],

Primero, crea la lista ([1]+[0]*n)*n, que para n=3parece

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

Usando el truco zip / iter zip(*[iter(_)]*n para hacer grupos de ndonaciones

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

Tenga en cuenta que 1cada vez viene un índice, que da la matriz de identidad. Pero, hay una fila extra de cero, que se elimina con [:n].

Jalea, 4 bytes

R=€R

No utiliza un incorporado. Pruébalo en línea!

Cómo funciona

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 bytes

=@i.

Esta es una función que toma un número entero y devuelve la matriz.

Haskell, 43 37 bytes

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

Bastante sencillo, aunque creo que uno puede hacerlo mejor (sin un lenguaje que ya tenga esta función incorporada, como muchos lo han hecho).

Editar: cayó algunos bytes gracias a Ørjan Johansen

Pyth, 7 bytes

XRm0Q1Q

Pruébalo en línea: demostración

Creando una matriz de ceros y reemplazando los elementos diagonales con unos.

JavaScript ES6, 68 62 52 bytes

Ahorró 10 bytes gracias a un buen truco de @Neil

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

Intentando un enfoque diferente al de @ Cᴏɴᴏʀ O'Bʀɪᴇɴ. Posiblemente podría mejorarse.

Retina , 25

Crédito a @randomra y @Martin por golf extra.

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

Pruébalo en línea.

Tenga en cuenta que esto toma la entrada como unario. Si esto no es aceptable, entonces la entrada decimal se puede dar de la siguiente manera:

Retina, 34

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

Pruébalo en línea.

Haskell, 54 bytes

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

fdevuelve la matriz de identidad para la entrada n. Lejos de ser óptimo.

Lua, 77 75 65 bytes

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

Bueno, no estoy seguro de si lua es el mejor lenguaje para esto con la concatenación de dos períodos ... Pero bueno, hay una oportunidad. Veré si hay alguna mejora que hacer.

EDITAR:

Descubrí algo por accidente que encuentro bastante extraño, pero funciona.

En Lua, todos saben que tienes la capacidad de asignar funciones a variables. Esta es una de las características más útiles de CodeGolf.

Esto significa en lugar 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

Puedes hacerlo:

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

Pero espera, Lua permite cierta cantidad de POO. Por lo tanto, incluso podría hacer:

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

Eso también funcionará y cortará personajes.

Ahora aquí viene la parte extraña. Ni siquiera necesita asignar una cadena en ningún punto. Simplemente haciendo:

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

Trabajará.

Para que pueda ver la diferencia visualmente, eche un vistazo a los resultados de golf de esto:

Usando string.sub (88 caracteres)

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

Asignación de string.sub a una variable (65 caracteres)

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

Asignación de string.sub usando un enfoque OOP (64 caracteres)

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

Asignación de string.sub usando un enfoque nulo? (60 caracteres)

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

Si alguien sabe por qué esto funciona, estaría interesado.

Pitón 3, 48

Guardado 1 byte gracias a sp3000.

Me encantan los desafíos que puedo resolver en una sola línea. Bastante simple, construya una línea de 1 y 0 igual a la longitud del int pasado. Salidas como una matriz 2d. Si envuelve la parte después de: in '\n'.join(), la imprimirá bastante.

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

C, 59 o 59 56 o 56

Dos versiones de idéntica longitud.

3 bytes guardados debido a una sugerencia de anatolyg: (n+1)->~n

Itera ide n*n-1a cero. Imprime un 1 si i% (n + 1) es cero, de lo contrario 0. Luego imprime una nueva línea si i%n= 0 de lo contrario un espacio.

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 bytes

I(3)

Salida

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

Mata es el lenguaje de programación matricial disponible dentro del paquete estadístico Stata. I (n) crea una matriz de identidad de tamaño n * n

K6 , 1 byte

=

= es exactamente esto

Pruébalo en línea!

Pyth, 8 bytes

mmsqdkQQ

Probarlo aquí .

Python 3.5 con NumPy - 57 49 30 bytes

import numpy
numpy.identity

NumPy.identity toma un número entero, n, y devuelve una matriz de identidad por n. Esta respuesta está permitida a través de esta política .

Mathematica, 35 Bytes

sin usar 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 bytes

Uo £Z®¥X|0

¡Pruébalo en línea! Nota: esta versión tiene algunos bytes adicionales para imprimir la salida.

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 bytes

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

Pruébalo en línea!

K, 7 bytes

t=\:t:!

Tome el producto cruzado de igualdad de dos vectores que contienen [0, n).

En acción:

  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 bytes

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

Crea una matriz 2D y reemplaza elementos donde la fila y la columna son iguales 1.

CJam, 7 bytes

{,_ff=}

Este es un bloque de código que saca un número entero de la pila y empuja una matriz 2D a cambio.

Pruébalo en línea!

Mathematica, 14 bytes

IdentityMatrix

Caso de prueba

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

Perl, 39 33 bytes

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

Gracias a Ton Hospel por guardar 6 bytes.

Corriendo con el -Eperlrun:

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