# Construct the Identity Matrix

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 , so the shortest code in bytes wins.

-

# MATL, 2 bytes

``````Xy
``````

A translation of my Octave answer.

Try it online.

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
``````
-
It must have been difficult, to translate this very sophisticated code :D – flawr Jan 28 at 18:40
@flawr You have no idea. This is truly my masterpiece. – quartata Jan 28 at 18:40
– Cᴏɴᴏʀ O'Bʀɪᴇɴ Jan 28 at 18:42
Now I see why you were asking! :-D – Luis Mendo Jan 28 at 18:54
Without builtins: `:t!=` – Luis Mendo Jan 28 at 18:56

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

-
I see what you did there! Nice one! – Ismael Miguel Jan 29 at 21:41

# APL, 5 bytes

``````∘.=⍨⍳
``````

This is a monadic function train that accepts an integer on the right and returns the identity matrix.

Try it here

-

# Octave, 10 4 bytes

``````@eye
``````

Returns an anonymous function that takes a number `n` and returns the identity matrix.

-
`@eye` is sufficient. – flawr Jan 28 at 18:37
@flawr Thanks, I knew there was a way to do it like that but I always forget :P – quartata Jan 28 at 18:39
`eye` produces the identity matrix in a lot/some numerically oriented languages. – flawr Jan 28 at 18:50

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

-
"that sounds oddly specific because it is" TI-BASIC is weird. O_o – Doorknob Jan 29 at 13:48

# Jelly, 4 bytes

``````R=€R
``````

Doesn't use a built-in. Try it online!

### 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.
``````
-
This code is unacceptably long. – flawr Jan 28 at 18:53
@flawr Twice the length of the shortest one. That's indeed an unusual encounter. – Rainer P. Jan 28 at 18:55
@flawr Yes, and no shorter than J. FAIL! – Adám Feb 10 at 15:27

# J, 4 bytes

``````=@i.
``````

This is a function that takes an integer and returns the matrix.

-

``````f n=[[fromEnum (y==x)|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).

-
You can cheat the `fromEnum` as `sum[1|x==y]`. – xnor Jan 29 at 0:31

## 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 `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]`.

-
Damn that zip/iter trick is ingenious – Seeq Feb 9 at 20:58

# JavaScript ES6, 6862 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.

-
This was exactly what I wrote before I scrolled down to find out that you'd beaten me to it. – Neil Jan 28 at 19:57
So, in response to your challenge, I give you the (in hindsight) obvious `x=>[...Array(x)].map((_,y,x)=>x.map((_,z)=>+(y==z)))` for a saving of 10 bytes. – Neil Jan 28 at 19:59
@Neil Thanks a lot! I'll mention that it's your trick in the answer. – ETHproductions Jan 28 at 20:12

# Retina, 25

Credit to @randomra and @Martin for extra golfing.

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

Try it online.

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.

-
...whoa. Retina is becoming powerful as a language for more than regex. – ETHproductions Jan 28 at 21:02
@ETHproductions yes, though this is answer pretty much all regex substitution. The only special thing is the use of `\$*0` to replace a number n with n `0`s. – Digital Trauma Jan 28 at 21:06

``````(#)=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.

-
You can save a handful of bytes using a list comprehension instead of a `map` call. – MathematicalOrchid Jan 29 at 9:23

# Pyth, 7 bytes

``````XRm0Q1Q
``````

Try it online: Demonstration

Creating a matrix of zeros and replacing the diagonal elements with ones.

-

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

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

-
The "z.rep" line is breaking on mine. I'm betting there should be a z='' somewhere? A shorter variant of z=''z.rep would just be ('').rep . You can also use the cmdline ... for reading input, and widdle the bytecount down to 57 as follows: z='0'for i=1,...do print(z:rep(i-1)..1 ..z:rep(...-i))end – thenumbernine Mar 22 at 11:39
I found someone suggesting ("").rep before, but I was unable to get it to work. It'd always error out. Maybe my interpreter is the problem here. I'm struggling to find any documentation on this command line input, do you know where it can be found? – Skyl3r Mar 23 at 12:51

# 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)]
``````
-
`x-i-1 -> x+~i` – Sp3000 Jan 28 at 21:58

# 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

-

## Pyth, 8 bytes

``````mmsqdkQQ
``````

Try it here.

-
I must say, it's highly unusual that the Pyth answer is four times longer than the shortest answer... – ETHproductions Jan 28 at 21:01
Hrm, this was the best I was able to get that looks 100% valid, but I did find `qRRQQ` which seems to work except you get `True` and `False` instead of `1` and `0`, however fixing this afaik requires using three bytes for `sMM` which doesn't help... – FryAmTheEggman Jan 28 at 21:11
@FryAmTheEggman I also found qRRQQ. I've tried a number of other programs, and none of them were shorter. – lirtosiast Jan 28 at 21:12

# 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);}
``````
-
`n+1` is too dull. Use `~n` instead! – anatolyg Jan 29 at 0:23
Thanks! I should have spotted that, because it occured to me when I looked at NBZ's challenge today. – Level River St Jan 29 at 0:31

# Python 3.5 with NumPy - 5749 30 bytes

``````import numpy
numpy.identity
``````

NumPy.identity takes in an integer, n, and returns a n by n identity matrix. This answer is allowable via this policy.

-
Actually I believe`import numpy\nnumpy.identity`is a legitimate answer. – FryAmTheEggman Jan 28 at 21:49
Thanks for the tip @MorganThrapp! And @FryAmTheEggman, you mean that my answer could just be `import numpy\nnumpy.identity()` which is 30 bytes? – linkian209 Jan 29 at 20:09
I got so confused by \nnumpy lol... This would also be valid, @FryAmTheEggman, no? `from numpy import identity`. 26 bytes. – Ogaday Feb 3 at 16:53
Also, see my answer something similar – Ogaday Feb 3 at 17:00
@Ogaday I don't think that is correct, the line you've given does not evaluate to a function. You would need to do `from numpy import identidy\nidentity` (in which case it would be shorter to use `*` instead of the specific builtin) – FryAmTheEggman Feb 3 at 17:53

# Mathematica, 35 Bytes

without using IdentityMatrix

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

# 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)
``````
-

# Japt, 14 12 bytes

``````Uo £Z®,+(X¥Z
``````

Test it online! Note: this version has a few extra bytes to pretty-print the output.

``````Uo £Z®,+(X¥Z      // 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¥Z             //   (X == Z) converted to a number. 1 for equal, 0 for non-equal.
// Implicit output
``````
-

# 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!

-

# Mathematica, 14 bytes

``````IdentityMatrix
``````

Test case

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

Thanks to Ton Hospel for saving 6 bytes

Running with the `-E` perlrun:

``````\$ echo 3 | perl -E'@%=1..<>;\$a=\$_,say map{\$a==\$_|0}@%for@%'
100
010
001
``````
-
Golfing a bit more: `/\$/,say map\$`==\$_|0,@%for@%=1..<>` or even better `//,say map\$'==\$_|0,@%for@%=1..<>` but like that you can't put it in single quotes anymore – Ton Hospel Mar 8 at 15:51
@TonHospel Wow thats cool, thanks. The later would require the use of `print` instead of say, because `-E` is only free on the command line. – andlrc Mar 14 at 22:15

# Jolf, 7 + 1 = 8 bytes

Replace all ☺s with `\x01` and `\xad` with a soft hyphen, or use the online interpreter. (Turn pretty output on for one byte.)

``````!☺!X\xad☺j
!X       eye
j  (the input)
!☺         get the data
implicit printing
``````

Probably more interesting, a solution without a builtin is 11 + 1 = 12 bytes

``````ZXZyjjdP=Sn
Zyjj       create a matrix of width = height = j (input)
ZX    d      matrix map
=Sn  if x-marker is y-marker
P     as a number
``````
-

# JavaScript, 75 74 bytes

``````n=>eval("for(a=[],i=0;i<n;i++){a[i]=[];for(j=0;j<n;)a[i][j]=+(i==j++)};a")
``````

Can be improved, probably.

-

## PowerShell, 52 bytes

``````param(\$a)1..\$a|%{\$d++;(1..\$a|%{+(\$d-eq\$_)})-join' '}
``````

Since the only built-in .NET class for matrices is ... umm ... inadequate, shall we say, we're just going to construct and output a string representation here...

Takes input `\$a` then executes a double-for-loop over range `1..\$a`. Each outer loop we increment helper variable `\$d` (the first loop, since `\$d` isn't initialized, turns `\$d++` into `\$null + 1 = 1` ... in PowerShell logic it makes sense), and each inner loop is simply an integer-cast with `+` of an equality between `\$d` and the current element `\$_`. Each inner loop is `-join`ed together with spaces so it prints nicely, and each outer loop causes a newline, so output code is pretty cheap.

### Example

``````PS C:\Tools\Scripts\golfing> .\construct-identity-matrix.ps1 10
1 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 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;};
``````

Creates a 2D array and replaces elements where row and column are equal with `1`.

-

``````import Data.Matrix
identity
``````

Maybe a little bit boring.

Usage example:

``````Prelude Data.Matrix> identity 4
( 1 0 0 0 )
( 0 1 0 0 )
( 0 0 1 0 )
( 0 0 0 1 )
``````
-