[Question]
  [
The challenge is very simple. Given an integer input `n`, output the `n x n` identity matrix. The identity matrix is one that has `1`s spanning from the top left down to the bottom right. You will write a program or a function that will return or output the identity matrix you constructed. Your output may be a 2D array, or numbers separated by spaces/tabs and newlines.
**Example input and 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.
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins.
  
[Answer]
# MATL, 2 bytes
```
Xy
```
A translation of my Octave answer.
[Try it online.](http://matl.tryitonline.net/#code=WHk&input=Mw&args=)
A 4 byte version with no built-ins (thanks to Luis Mendo):
```
:t!=
:     take input n and a generate row array [1,2,...n]
 t    duplicate
  !   zip
   =  thread compare over the result
```
[Answer]
## TI-BASIC, 2 bytes
```
identity(Ans
```
Fun fact: The shortest way to get a list `{N,N}` is `dim(identity(N`.
Here's the shortest way without the builtin, in 8 bytes:
```
randM(Ans,Ans)^0
```
`randM(` creates a random matrix with entries all integers between -9 and 9 inclusive (that sounds oddly specific because it is). We then take this matrix to the 0th power.
[Answer]
# Julia, ~~9~~ 3 bytes
```
eye
```
This is just a built-in function that accepts an integer `n` and returns an `nxn Array{Float64,2}` (i.e. a 2D array). Call it like `eye(n)`.
Note that submissions of this form are acceptable per [this policy](http://meta.codegolf.stackexchange.com/questions/7205/on-scoring-builtin-functions).
[Answer]
# APL, 5 bytes
```
∘.=⍨⍳
```
This is a monadic function train that accepts an integer on the right and returns the identity matrix.
[Try it here](http://tryapl.org/?a=f%u2190%u2218.%3D%u2368%u2373%20%u22C4%20f%204&run)
[Answer]
## Python 2, 42 bytes
```
lambda n:zip(*[iter(([1]+[0]*n)*n)]*n)[:n]
```
An anonymous function, produces output like `[(1, 0, 0), (0, 1, 0), (0, 0, 1)]`,
First, creates the list `([1]+[0]*n)*n`, which for `n=3` looks like
```
[1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]
```
Using the [zip/iter trick](http://paddy3118.blogspot.com/2012/12/that-grouping-by-zipiter-trick-explained.html) `zip(*[iter(_)]*n` to make groups of `n` gives
```
[(1, 0, 0), (0, 1, 0), (0, 0, 1), (0, 0, 0)]
```
Note that the `1` comes one index later each time, giving the identity matrix. But, there's an extra all-zero row, which is removed with `[:n]`.
[Answer]
# Octave, ~~10~~ 4 bytes
```
@eye
```
Returns an anonymous function that takes a number `n` and returns the identity matrix.
[Answer]
# R, 4 bytes
```
diag
```
When given a matrix, `diag` returns the diagonal of the matrix. However, when given an integer `n`, `diag(n)` returns the identity matrix.
[Try it online](http://www.r-fiddle.org/#/fiddle?id=q3aeHVGZ)
[Answer]
# Jelly, 4 bytes
```
R=€R
```
Doesn't use a built-in. [Try it online!](http://jelly.tryitonline.net/#code=Uj3igqxS&input=&args=NA)
### How it works
```
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.
```
[Answer]
# J, 4 bytes
```
=@i.
```
This is a function that takes an integer and returns the matrix. 
[Answer]
# JavaScript ES6, ~~68~~ ~~62~~ 52 bytes
*Saved 10 bytes thanks to a neat trick from @Neil*
```
x=>[...Array(x)].map((_,y,x)=>x.map((_,z)=>+(y==z)))
```
Trying a different approach than @Cᴏɴᴏʀ O'Bʀɪᴇɴ's. Could possibly be improved.
[Answer]
# Pyth, 7 bytes
```
XRm0Q1Q
```
Try it online: [Demonstration](http://pyth.herokuapp.com/?code=XRm0Q1Q&input=5&debug=0)
Creating a matrix of zeros and replacing the diagonal elements with ones. 
[Answer]
**Haskell, ~~43~~ 37 bytes**
```
f n=[[0^abs(x-y)|y<-[1..n]]|x<-[1..n]]
```
Pretty straightforward, though I think one can do better (without a language that already has this function built in, as many have done).
Edit: dropped some bytes thanks to Ørjan Johansen
[Answer]
# [Retina](https://github.com/mbuettner/retina), 25
Credit to @randomra and @Martin for extra golfing.
```
\B.
 0
+`(.*) 0$
$0¶0 $1
```
[Try it online.](http://retina.tryitonline.net/#code=XEIuCiAwCitgKC4qKSAwJAokMMK2MCAkMQ&input=MTExMQ)
Note this takes input as a unary. If this is not acceptable, then decimal input may be given as follows:
# Retina, 34
```
.+
$0$*1
\B.
 0
+`(.*) 0$
$0¶0 $1
```
[Try it online.](http://retina.tryitonline.net/#code=LisKJDAkKjEKXEIuCiAwCitgKC4qKSAwJAokMMK2MCAkMQ&input=MTA)
[Answer]
# Python 3, 48
Saved 1 byte thanks to sp3000.
I love challenges I can solve in one line. Pretty simple, build a line out of 1 and 0 equal to the length of the int passed in. Outputs as a 2d array. If you wrap the part after the : in `'\n'.join()`, it'll pretty print it.
```
lambda x:[[0]*i+[1]+[0]*(x+~i)for i in range(x)]
```
[Answer]
# Haskell, 54 bytes
```
(#)=replicate
f n=map(\x->x#0++[1]++(n-x-1)#0)[0..n-1]
```
`f` returns the identity matrix for input n. Far from optimal.
[Answer]
# C,  ~~59 or 59~~  56 or 56
Two versions of identical length.
3 bytes saved due to suggestion from anatolyg: `(n+1)` --> `~n`
Iterates `i` from `n*n-1` to zero. Prints a 1 if i%(n+1) is zero, otherwise 0. Then prints a newline if `i%n`=0 otherwise a space.
```
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);}
```
[Answer]
# 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
```
Well, I'm not sure if lua is the best language for this with the two period concatenation... But hey, there's a shot at it. I'll see if there's any improvements to be made.
**EDIT:**
I figured something out on accident which I find rather odd, but, it works.
In Lua, everyone knows you have the ability to assign functions to variables. This is one of the more useful CodeGolf features. 
This means instead of:
```
string.sub("50", 1, 1) -- = 5
string.sub("50", 2, 2) -- = 0
string.sub("40", 1, 1) -- = 4
string.sub("40", 2, 2) -- = 0
```
You can do this:
```
s = string.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0
```
But wait, Lua allows some amount of OOP. So you could potentially even do:
```
z=""
s = z.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0
```
That will work as well and cuts characters.
Now here comes the weird part. You don't even need to assign a string at any point. Simply doing:
```
s = z.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0
```
Will work.
---
So you can visually see the difference, take a look at the golfed results of this:
**Using string.sub (88 characters)**
```
string.sub("50", 1, 1)string.sub("50", 2, 2)string.sub("40", 1, 1)string.sub("40", 2, 2)
```
**Assigning string.sub to a variable (65 characters)**
```
s=string.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)
```
**Assigning string.sub using an OOP approach (64 characters)**
```
z=""s=z.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)
```
**Assigning string.sub using a.. nil approach? (60 characters)**
```
s=z.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)
```
If someone knows why this works, I'd be interested.
[Answer]
# Mata, 4 bytes
```
I(3)
```
**Output**
```
[symmetric]
       1   2   3
    +-------------+
  1 |  1          |
  2 |  0   1      |
  3 |  0   0   1  |
    +-------------+
```
Mata is the matrix programming language available within the Stata statistical package. I(n) creates an identity matrix of size n\*n
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~206~~ ~~170~~ 162 bytes
```
(([{}])){({}<>(())<><(({})<{({}()(<>)<>)}{}>)>)}{}(({}<><(())>)){({}()<({[()]<({}()<({}<>((((()()()()){}){}){})((()()()()){}){})<>>)>}{})>)<>((()()()()()){})<>}<>
```
[Try it online!](https://tio.run/##ZY2xCsMwDER/527I2O0Q5DuMB2colIYMXYW/XZFtSodKAqHT6en4tNe1Pc/2jgCK90o6vMsAUibkQA0JhCwldu/G2TCdGlZbd6DgBaz6DhOVwZVM3Ko/TZbYpHJ8@W3XXpagiEds@w0 "Brain-Flak – Try It Online")
[Answer]
# [K6](https://github.com/JohnEarnest/ok), 1 [byte](http://meta.codegolf.stackexchange.com/a/9429/43319)
```
=
```
`=` is exactly this
[Try it online!](https://tio.run/nexus/k-ok#@29r@v8/AA "K (oK) – TIO Nexus")
[Answer]
# K, 7 bytes
```
t=\:t:!
```
Take the equality cross product of two vectors containing [0,n).
In 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)
```
[Answer]
## Pyth, 8 bytes
```
mmsqdkQQ
```
Try it [here](http://pyth.herokuapp.com/?code=mmsqdkQQ&input=5&debug=0).
[Answer]
# Mathematica, 14 bytes
```
IdentityMatrix
```
**Test case**
```
IdentityMatrix[4]
(* {{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}} *)
```
[Answer]
# Mathematica, 35 Bytes
without using IdentityMatrix
```
Table[Boole[i==j],{i,1,#},{j,1,#}]&
```
[Answer]
## 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>
```
[Answer]
# Japt, ~~14~~ ~~12~~ 10 bytes
```
Uo £Z®¥X|0
```
[Test it online!](http://ethproductions.github.io/japt/?v=master&code=VW8go1qupVh8MH19ILc=&input=NQ==) Note: this version has a few extra bytes to pretty-print the 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
```
[Answer]
# [R](https://www.r-project.org/), 28 bytes
```
function(n,x=1:n)+!x%o%x-x^2
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP08jT6fC1tAqT1NbsUI1X7VCtyLO6H@ahqnmfwA "R – Try It Online")
For pure fun, just another attempt at a non-built-in R solution. Uses the shortcut `%o%` version of the `outer` function.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
```
°¨œÙ
```
[Try it online!](https://tio.run/##yy9OTMpM/f//0IZDK45OPjzz/39TAA "05AB1E – Try It Online")
Unique permutations of (10^input)[0:-1]
[Answer]
# Java, 60 bytes
```
n->{int[][]i=new int[n][n];for(;n-->0;)i[n][n]=1;return i;};
```
Creates a 2D array and replaces elements where row and column are equal with `1`.
[Answer]
# CJam, 7 bytes
```
{,_ff=}
```
This is a code block that pops an integer from the stack and pushes a 2D array in return.
[Try it online!](http://cjam.tryitonline.net/#code=OSwxPiAgICBlIyBbMSAuLi4gOF0KeyxfZmY9fQolOnAgICAgIGUjIE1hcC4gUHJpbnQgZWFjaC4&input=)
]