Задача очень проста. Учитывая целочисленный ввод n, выведите n x nединичную матрицу. Тождественная матрица - это та, которая имеет 1s, охватывающую от верхнего левого угла до нижнего правого. Вы напишите программу или функцию, которая будет возвращать или выводить построенную вами матрицу идентичности. Выходными данными могут быть двумерный массив или числа, разделенные пробелами / символами табуляции и переводами строки.

Пример ввода и вывода

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.

Это код-гольф , поэтому выигрывает самый короткий код в байтах.

MATL, 2 байта

Xy

Перевод моего октавского ответа.

Попробуйте онлайн.

4-байтовая версия без встроенных модулей (спасибо Луису Мендо):

:t!=
:     take input n and a generate row array [1,2,...n]
 t    duplicate
  !   zip
   =  thread compare over the result

TI-BASIC, 2 байта

identity(Ans

Интересный факт: самый короткий путь , чтобы получить список {N,N}является dim(identity(N.

Вот кратчайший путь без встроенного, в 8 байтов:

randM(Ans,Ans)^0

randM(создает случайную матрицу с записями всех целых чисел от -9 до 9 включительно (это звучит странно, потому что это так). Затем мы возьмем эту матрицу к 0-й степени.

Юлия, 9 3 байта

eye

Это просто встроенная функция, которая принимает целое число nи возвращает nxn Array{Float64,2}(т.е. двумерный массив). Назовите это как eye(n).

Обратите внимание, что представления этой формы являются приемлемыми в соответствии с этой политикой .

APL, 5 байт

∘.=⍨⍳

Это последовательность монадических функций, которая принимает целое число справа и возвращает единичную матрицу.

Попробуй здесь

Октава, 10 4 байта

@eye

Возвращает анонимную функцию, которая принимает число nи возвращает единичную матрицу.

R, 4 байта

diag

Когда задана матрица, diagвозвращает диагональ матрицы. Однако, когда задано целое число n, diag(n)возвращается единичная матрица.

Попробуйте онлайн

Python 2, 42 байта

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

Анонимная функция, производит вывод, как [(1, 0, 0), (0, 1, 0), (0, 0, 1)],

Во-первых, создает список ([1]+[0]*n)*n, который для n=3выглядит

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

Используя почтовый индекс / ИТЭР трюк zip(*[iter(_)]*n сделать группы nдает

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

Обратите внимание, что 1каждый раз приходит по одному индексу, давая матрицу идентичности. Но есть дополнительная строка с нулем, которая удаляется с помощью [:n].

Желе, 4 байта

R=€R

Не использует встроенный. Попробуйте онлайн!

Как это работает

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 байта

=@i.

Это функция, которая принимает целое число и возвращает матрицу.

Haskell, 43 37 байт

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

Довольно просто, хотя я думаю, что можно добиться большего успеха (без языка, в который уже встроена эта функция, как это сделали многие).

Редактировать: отбросил несколько байтов благодаря Орьяну Йохансену

Pyth, 7 байт

XRm0Q1Q

Попробуйте онлайн: демонстрация

Создание матрицы нулей и замена диагональных элементов на единицы.

JavaScript ES6, 68 62 52 байта

Сохранено 10 байтов благодаря аккуратному трюку от @Neil

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

Попытка использовать другой подход, чем у @ Cᴏɴᴏʀ O'Bʀɪᴇɴ. Возможно, будет улучшено.

Сетчатка , 25

Благодарим @randomra и @Martin за дополнительный гольф.

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

Попробуйте онлайн.

Обратите внимание, что это принимает вход как унарный. Если это неприемлемо, то десятичный ввод может быть задан следующим образом:

Сетчатка, 34

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

Попробуйте онлайн.

Haskell, 54 байта

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

fвозвращает единичную матрицу для ввода n. Далеко не оптимально.

Луа, 77 75 65 байт

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

Ну, я не уверен, что для этого лучше всего использовать lua с двухпериодной конкатенацией ... Но, эй, есть шанс. Я посмотрю, есть ли какие-либо улучшения, которые будут сделаны.

РЕДАКТИРОВАТЬ:

Я понял что-то случайно, что я нахожу довольно странным, но это работает.

В Lua все знают, что у вас есть возможность назначать функции переменным. Это одна из наиболее полезных функций CodeGolf.

Это значит вместо:

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

Ты можешь это сделать:

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

Но подождите, Луа позволяет немного ООП. Так что вы могли бы даже сделать:

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

Это будет работать так же хорошо и сокращать персонажей.

Теперь здесь начинается странная часть. Вам даже не нужно назначать строку в любой точке. Просто делаю:

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

Буду работать.

Таким образом, вы можете визуально увидеть разницу, взгляните на результаты этого:

Использование string.sub (88 символов)

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

Присвоение string.sub переменной (65 символов)

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

Назначение string.sub с использованием подхода ООП (64 символа)

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

Назначение string.sub с использованием подхода .. nil? (60 символов)

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

Если кто-то знает, почему это работает, мне было бы интересно.

Python 3, 48

Сохранено 1 байт благодаря sp3000.

Я люблю проблемы, которые я могу решить в одной строке. Довольно просто, построить строку из 1 и 0, равную длине переданного int. Выводит в виде 2d массива. Если вы завернете деталь после: in '\n'.join(), она будет довольно распечатана.

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

С, 59 или 59, 56 или 56

Две версии одинаковой длины.

3 байта сохранены благодаря предложению от Анатолия: (n+1)->~n

Итерирует iот n*n-1нуля. Печатает 1, если i% (n + 1) равно нулю, иначе 0. Затем печатает новую строку, если i%n= 0 в противном случае пробел.

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

Мата, 4 байта

I(3)

Выход

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

Mata - это матричный язык программирования, доступный в статистическом пакете Stata. I (n) создает единичную матрицу размера n * n

К6 , 1 байт

=

= именно это

Попробуйте онлайн!

Pyth, 8 байт

mmsqdkQQ

Попробуй это здесь .

Python 3.5 с NumPy - 57 49 30 байт

import numpy
numpy.identity

NumPy.identity принимает целое число n и возвращает единичную матрицу n. Этот ответ допустим с помощью этой политики .

Mathematica, 35 байт

без использования 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 байт

Uo £Z®¥X|0

Проверьте это онлайн! Примечание: в этой версии есть несколько дополнительных байтов, чтобы красиво распечатать вывод.

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 байта

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

Попробуйте онлайн!

К 7 байт

t=\:t:!

Возьмем произведение на равенство двух векторов, содержащих [0, 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 байт

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

Создает 2D-массив и заменяет элементы, в которых строка и столбец равны 1.

CJam, 7 байтов

{,_ff=}

Это блок кода, который извлекает целое число из стека и возвращает двухмерный массив в ответ.

Попробуйте онлайн!

Mathematica, 14 байтов

IdentityMatrix

Прецедент

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

Perl, 39 33 байта

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

Спасибо Ton Hospel за сохранение 6 байтов

Запуск с -Eperlrun:

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