O desafio é muito simples. Dada uma entrada inteira n, produza a n x nmatriz de identidade. A matriz de identidade é aquela que se 1estende da parte superior esquerda até a parte inferior direita. Você escreverá um programa ou uma função que retornará ou produzirá a matriz de identidade que você construiu. Sua saída pode ser uma matriz 2D ou números separados por espaços / tabulações e novas linhas.

Exemplo de entrada e saída

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.

Isso é código-golfe , então o código mais curto em bytes vence.

MATL, 2 bytes

Xy

Uma tradução da minha resposta de oitava.

Experimente online.

Uma versão de 4 bytes sem built-ins (graças 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

Curiosidade: A maneira mais curta de obter uma lista {N,N}é dim(identity(N.

Aqui está o caminho mais curto sem o builtin, em 8 bytes:

randM(Ans,Ans)^0

randM(cria uma matriz aleatória com entradas com todos os números inteiros entre -9 e 9, inclusive (isso soa estranhamente específico porque é). Em seguida, levamos essa matriz à 0ª potência.

Julia, 9 3 bytes

eye

Esta é apenas uma função interna que aceita um número inteiro ne retorna um nxn Array{Float64,2}(ou seja, uma matriz 2D). Chame assim eye(n).

Observe que os envios deste formulário são aceitáveis ​​por esta política .

APL, 5 bytes

∘.=⍨⍳

Este é um trem de função monádico que aceita um número inteiro à direita e retorna a matriz de identidade.

Experimente aqui

Oitava, 10 4 bytes

@eye

Retorna uma função anônima que pega um número ne retorna a matriz de identidade.

R, 4 bytes

diag

Quando recebe uma matriz, diagretorna a diagonal da matriz. No entanto, quando determinado um número inteiro n, diag(n)retorna a matriz de identidade.

Experimente online

Python 2, 42 bytes

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

Uma função anônima produz saída como [(1, 0, 0), (0, 1, 0), (0, 0, 1)],

Primeiro, cria a lista ([1]+[0]*n)*n, que n=3parece

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

Usando o zip / iter enganar zip(*[iter(_)]*n para fazer grupos de ndá

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

Observe que o 1índice vem um depois a cada vez, fornecendo a matriz de identidade. Mas, há uma linha extra zero, que é removida com [:n].

Gelatina, 4 bytes

R=€R

Não usa um built-in. Experimente online!

Como 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 é uma função que pega um número inteiro e retorna a matriz.

Haskell, 43 37 bytes

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

Bem direto, embora eu ache que alguém possa fazer melhor (sem uma linguagem que já tenha essa função incorporada, como muitos fizeram).

Edit: caiu alguns bytes graças a Ørjan Johansen

Pitão, 7 bytes

XRm0Q1Q

Experimente online: Demonstração

Criando uma matriz de zeros e substituindo os elementos diagonais por outros.

JavaScript ES6, 68 62 52 bytes

Economizou 10 bytes graças a um truque da @Neil

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

Tentando uma abordagem diferente da @ Cᴏɴᴏʀ O'Bʀɪᴇɴ. Possivelmente poderia ser melhorado.

Retina , 25

Crédito para @randomra e @Martin por golfe extra.

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

Experimente online.

Observe que isso leva a entrada como unária. Se isso não for aceitável, a entrada decimal pode ser fornecida da seguinte maneira:

Retina, 34

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

Experimente online.

Haskell, 54 bytes

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

fretorna a matriz de identidade para a entrada n. Longe de ser o ideal.

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

Bem, não tenho certeza se lua é a melhor linguagem para isso com a concatenação de dois períodos ... Mas ei, há uma chance disso. Vou ver se há alguma melhoria a ser feita.

EDITAR:

Eu descobri algo sobre acidente que eu acho bastante estranho, mas funciona.

Em Lua, todo mundo sabe que você tem a capacidade de atribuir funções a variáveis. Este é um dos recursos mais úteis do CodeGolf.

Isso significa, em vez 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

Você consegue fazer isso:

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

Mas espere, Lua permite uma certa quantidade de POO. Então você pode potencialmente fazer:

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

Isso também funcionará e reduzirá os caracteres.

Agora aqui vem a parte estranha. Você nem precisa atribuir uma string a qualquer momento. Simplesmente fazendo:

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

Vai funcionar.

Para que você possa ver visualmente a diferença, dê uma olhada nos resultados deste jogo:

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)

Atribuindo string.sub a uma variável (65 caracteres)

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

Atribuindo string.sub usando uma abordagem OOP (64 caracteres)

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

Atribuindo string.sub usando uma abordagem .. nil? (60 caracteres)

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

Se alguém souber por que isso funciona, eu estaria interessado.

Python 3, 48

Economizou 1 byte graças ao sp3000.

Adoro desafios que posso resolver em uma linha. Muito simples, construa uma linha de 1 e 0 igual ao comprimento do int passado. Saída como uma matriz 2D. Se você envolver a peça após o: in '\n'.join(), ela será impressa.

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

C, 59 ou 59 56 ou 56

Duas versões de comprimento idêntico.

3 bytes salvos devido a sugestão de anatolyg: (n+1)->~n

Repete ide n*n-1para zero. Imprime 1 se i% (n + 1) for zero, caso contrário, 0. Em seguida, imprime uma nova linha se i%n= 0, caso contrário, um espaço.

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)

Resultado

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

Mata é a linguagem de programação matricial disponível no pacote estatístico Stata. I (n) cria uma matriz de identidade de tamanho n * n

K6 , 1 byte

=

= é exatamente isso

Experimente online!

Pitão, 8 bytes

mmsqdkQQ

Experimente aqui .

Python 3.5 com NumPy - 57 49 30 bytes

import numpy
numpy.identity

NumPy.identity recebe um número inteiro n e retorna uma matriz de identidade n. Esta resposta é permitida através desta política .

Mathematica, 35 bytes

sem usar o 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>

Japonês, 14 12 10 bytes

Uo £Z®¥X|0

Teste online! Nota: esta versão possui alguns bytes extras para imprimir a saída.

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

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

Experimente online!

K, 7 bytes

t=\:t:!

Tome o produto cruzado de igualdade de dois vetores contendo [0, n).

Em ação:

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

Cria uma matriz 2D e substitui elementos em que linha e coluna são iguais 1.

CJam, 7 bytes

{,_ff=}

Este é um bloco de código que exibe um número inteiro da pilha e empurra uma matriz 2D em troca.

Experimente online!

Mathematica, 14 bytes

IdentityMatrix

Caso de teste

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

Agradecimentos a Ton Hospel por salvar 6 bytes

Executando com o -Eperlrun:

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