Учитывая положительное целое число n, выведите N-мерную единицу "матрица", которая является N^Nмассивом, 1где все компоненты индексов равны, и в 0противном случае. N^Nозначает N-by-N-by-N-by -...

1 -> [1]

2 -> [[1,0],[0,1]]

3 -> [[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,1,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,1]]]

4 -> [[[[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,1,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]]]

Например, если aесть 4-мерном идентичность «матрица», то только записи с 1бы a[0][0][0][0], a[1][1][1][1], a[2][2][2][2]и a[3][3][3][3].

Это код-гольф . Кратчайший ответ в байтах побеждает. Применяются стандартные лазейки .

Октава, 29 байт

@(n)accumarray((x=1:n)'+!x,1)

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

Желе , 8 байт

×=¥þ’¡`Ṡ

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

Ох, похоже, я снова обгоняю @Dennis на его родном языке :-)

Это функция с 1 аргументом (потому что формат вывода Jelly по умолчанию для вложенных списков немного двусмыслен, что означает, что он, возможно, не соответствует спецификации как полноценная программа).

объяснение

×=¥þ’¡`Ṡ
     ¡    Repeatedly apply the following operation,
    ’     {input-1} times in total:
   þ        For each element of the current value {perhaps made into a range}
      `     and of {the range from 1 to the} {input}:
 =            Compare corresponding elements, giving 0 for equal or 1 for unequal
× ¥           then multiply by one of the elements
       Ṡ  then replace each element with its sign

Чтобы понять это, полезно взглянуть на промежуточные этапы. Для ввода 3 мы получаем следующие промежуточные шаги:

1. [1,2,3](входные данные, неявно сделанные в диапазоне þ)
2. [[1,0,0],[0,2,0],[0,0,3]](составьте таблицу [1,2,3], сравните для получения равенства [[1,0,0],[0,1,0],[0,0,1]], затем умножьте на одно из сравниваемых значений)
3. [[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,2,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,3]]] (снова та же идея)
4. [[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,1,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,1]]](замените каждый элемент его знаком, используя Ṡ)

Обратите внимание на тот факт, что ввод начинается 1-мерным, что означает, что мы должны выполнить цикл (input-1) раз, чтобы добавить (input-1) измерения, создавая список входных измерений.

Интересный факт: эта программа содержит пять квиков подряд ¥þ’¡`. (Быстрый - это модификатор «ссылки», или встроенная функция, используемая для изменения его поведения или объединения с другой ссылкой.)

Mathematica, 30 байт

Array[Boole@*Equal,#~Table~#]&

APL (Dyalog) , 10 байт

1=≢∘∪¨⍳⍴⍨⎕

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

1= [is] 1 равно

≢ номер

∘ из

∪ уникальные элементы

¨ в каждом из

⍳ индексы в массиве с размерами

⍴⍨ самоизображение ( N копий N )

⎕ вход ( N ) [?]

Желе , 9 байт

ðṗE€ṁ+þ’¡

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

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

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

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

Декартова мощность атом ṗ, с левым и правый аргументом , равный п , строит массив из всех векторов длины п , которые состоят из элементов [1, ..., п] , сортируются в лексикографическом.

Когда n = 3 , это дает

[[1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 2, 1], [1, 2, 2], [1, 2, 3], [1, 3, 1], [1, 3, 2], [1, 3, 3], [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 2, 1], [2, 2, 2], [2, 2, 3], [2, 3, 1], [2, 3, 2], [2, 3, 3], [3, 1, 1], [3, 1, 2], [3, 1, 3], [3, 2, 1], [3, 2, 2], [3, 2, 3], [3, 3, 1], [3, 3, 2], [3, 3, 3]]

Равны друг QuickLink E€проверяет элементы всех построенных векторов для равенства.

Когда n = 3 , мы получаем

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

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

Диадическая быстрая ссылка +þ’¡вызывается с левым аргументом и правым аргументом n . Быстрый ¡вызывает атом уменьшения ’, который дает n-1 , затем вызывает быструю ссылку на таблицу добавления +þ n-1 раз.

Первоначально аргументы +þоба n . После каждого вызова правый аргумент заменяется левым, а левый - возвращаемым значением вызова.

Таблица быстро называет добавить атом +для каждого элемента его левый аргумент и каждый элемент его правого аргумента, построения таблицы / матрицы возвращаемого значения. Начальные целочисленные аргументы n переводятся в диапазоны [1, ... n] .

Когда n = 3 , после продвижения, но до первой итерации оба аргумента

[1, 2, 3]

Добавление каждого целого числа в этом массиве к каждому целому числу в этом массиве дает

[[2, 3, 4], [3, 4, 5], [4, 5, 6]]

В следующем вызове мы добавим каждый из этих массивов к целым числам в [1, 2, 3] . Добавление векторизуется (добавление целого числа в массив добавляет его к каждому элементу), поэтому мы получаем

[[[3, 4, 5], [4, 5, 6], [5, 6, 7]],
 [[4, 5, 6], [5, 6, 7], [6, 7, 8]],
 [[5, 6, 7], [6, 7, 8], [7, 8, 9]]]

Этот массив имеет ту же форму, что и трехмерная единичная матрица, но не правильные элементы.

Наконец, атом формыṁ отбрасывает целочисленные записи результата справа и заменяет их по порядку на элементы в результате слева.

Python , 70 байт

f=lambda n,l=[]:[f(n,l+[i])for i in(len(l)<n)*range(n)]or+(l==l[:1]*n)

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

Рекурсивное решение. Думая о матрице как о списке матриц на одно измерение меньше, он перебирает этот список, чтобы пройти вниз по дереву. Он запоминает выбранные индексы l, и когда nиндексы выбраны, мы присваиваем a 1или в 0зависимости от того, все ли они одинаковы.

Python 2 , 73 байта

n=input();r=0
exec'r=eval(`[r]*n`);'*n+('n-=1;r'+'[n]'*n+'=1;')*n
print r

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

Усовершенствование метода полностью человеческого построения матрицы нулей и последующего присвоения их диагонали.

Python 2 , 88 байт

n=input()
t=tuple(range(n))
print eval('['*n+'+(i0'+'==i%d'*n%t+')'+'for i%d in t]'*n%t)

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

Некоторая ерунда с evalсозданием вложенного списка и подстановкой строкового формата. Строка для оценки выглядит так:

[[[+(i0==i0==i1==i2)for i0 in t]for i1 in t]for i2 in t]

Python 2 + NumPy , 80 72 70 байт

Теперь связан с верхним Python ответом!

from numpy import*
n=input()
a=zeros((n,)*n)
a[[range(n)]*n]=1
print a

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

_{Сэкономлено 8 байт благодаря Андрасу Дику и 2 - официальнымaimm.}

Python 2 , 99 93 90 байт

Благодаря Rod для некоторого даже больше помощи , которые получили его работы , а также брили 6 байт прочь! -3 байта благодаря xnor.

n=input()
r=eval(`eval('['*n+'0'+']*n'*n)`)
for i in range(n):exec'r'+`[i]`*n+'=1'
print r

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

JavaScript (ES6), 67 байт

f=(n,d=n-1,i)=>[...Array(n)].map((_,j)=>d?f(n,d-1,j-i?n:j):j-i?0:1)

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

Brainfuck , 61 байт

>,[->+>+<<]>[-<<+>>]>-[->+.-<<<<[->+>+<<]>[-<+>]>[->>.<<]>]+.

Ungolfed

Числа после угловых скобок указывают на ячейку, над которой находится голова.

>,                   read n to 1
[->+>+<<]            move 1 to 2 and 3
>2[-<<+>>]>3         move 2 to 0 
                     (tape: n 0 0 n 0)
-[                   while cell 3 {
    -                  dec 3
    >4+.-<3            print \x1
    <<<0[->+>+<<]      move 0 to 1 and 2
    >1[-<+>]>2         move 1 to 0
                       (tape: 0 0 n rows_left 0)
    [                  while cell 2 {
        -                dec 2
        >>4.<<           print \x0
    ]>3                }
]                    }
+.                   print \x1

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

Ввод представляет собой двоичное число. Выход - это матрица, хранящаяся в главном порядке строк.

R , 64 49 байт

-15 байт благодаря Ярко Дуббелдаму

x=array(0,rep(n<-scan(),n));x[seq(1,n^n,l=n)]=1;x

Читает из стандартного ввода и возвращает массив, печатая в виде матриц. seqгенерирует последовательность, равномерно распределенную 1по n^nдлине и длине l=n, что очень удобно для индексации, куда идут 1.

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

старая версия:

n=scan();x=rep(0,n^n);x=array(x,rep(n,n));x[matrix(1:n,n,n)]=1;x

Читает nсо стандартного ввода; возвращает массив, печатая результаты в виде матриц. Я боролся с этим некоторое время, пока не прочитал документы для [, которые указывают, что матрица может использоваться для индексации массива, где каждая строка матрицы представляет набор индексов. Ухоженная!

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

J , 16 15 байт

i.@#~=i.*]#.#&1

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

Python 3 + NumPy, 81 77 байт

from numpy import*
f=lambda n:all([a==range(n)for a in indices((n,)*n)],0)+0

Я не совсем уверен, что вышесказанное соответствует всем рекомендациям: он возвращает ndarray с заданными свойствами. Я знаю, что анонимные функции обычно хороши, но интерактивная оболочка на самом деле напечатает

>>> f(2)
array([[1, 0],
       [0, 1]])

Если пух массива делает вышеупомянутое недействительным, я должен добавить print()что-то вроде 7 дополнительных байтов.

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

Pyth, 14 байт

ucGQtQms!t{d^U

Тестирование

Explanation:, то ^Uесть неявно ^UQQ, где Qнаходится вход, вычисляет все возможные списки элементов Q диапазона 0 ... n-1. ms!t{dотображает те, у которых все элементы равны 1, а остальные равны 0. Это дает сглаженный вывод

ucGQtQ выполняет следующее, Q - 1 раз: Разбить ввод на списки размером Q.

C # (.NET Core) , 166 байт

n=>{var c=new int[n];int i=0,d;for(;i<n;c[i++]=n);var m=System.Array.CreateInstance(typeof(int),c);for(i=0;i<n;i++){for(d=0;d<n;c[d++]=i);m.SetValue(1,c);};return m;}

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

Сначала я подумал, что это нельзя сделать с помощью лямбда-выражения в C # ... ^ __ ^ U

Common Lisp, 147 133 байта

(defun i(n)(flet((m(x)(fill(make-list n)x)))(let((a(make-array(m n):initial-element 0)))(dotimes(i n)(incf(apply #'aref a(m i))))a)))

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

Обычный супер-длинный лисп. Уменьшено на 12 байт благодаря @ceilingcat!

Объяснение:

(defun i (n)
  (flet ((m (x) (fill (make-list n) x)))            ; function to build a list of n values x
    (let ((a (make-array (m n) :initial-element 0))); build the array with all 0
      (dotimes (i n)                                ; for i from 0 to n-1
        (incf (apply #'aref a (m i))))              ; add 1 to a[i]..[i] 
      a)))                                          ; return the array

SOGL V0.12 , 22 байта

.^κ.H/ 0* 1.H≤Οčr.H{.n

Попробуй здесь!
Оставляет вывод в стеке для просмотра в консоли. Если бы числа в выводе были разрешены как строки, то их rможно удалить.
Так же, как забавный тест того, как SOGL справляется с испытаниями, он был совершенно не предназначен для: p

input: x
.^                      push  x^x
  κ                     subtract x    (x^x)-x
   .H/                  divide by x   ((x^x) - x)/x
       0*               get that many zeroes
          1             push "1"
           .H           push x-1
             ≤          pull the first item from the stack to the top
              Ο         encase (x-1 times the zeroes, separated, started and ended with 1s)
               č        chop to a char-array
                r       convert each character to a number
                 .H{    repeat x-1 times:
                    .n    in the top array, for each group of x contents, encase that in an array

Clojure, 92 байта

#(reduce(fn[v i](assoc-in v(repeat % i)1))(nth(iterate(fn[v](vec(repeat % v)))0)%)(range %))

Приятно, что ассоциация работает также с векторами, а не только с хэш-картами.