Враховуючи додатне ціле число 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) разів, щоб додати (вхід-1) розміри, створюючи список вхідних розмірів.

Цікавий факт: ця програма містить п'ять Quicks підряду, ¥þ’¡`. (Швидкий - це модифікатор "посилання" або вбудований, який використовується для зміни його поведінки або комбінування з іншою ланкою.)

Математика, 30 байт

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

APL (Dyalog) , 10 байт

1=≢∘∪¨⍳⍴⍨⎕

Спробуйте в Інтернеті!

1= [є] 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]]]

Цей масив має таку ж форму, як і тривимірна матриця ідентичності, але не правильні елементи.

Нарешті, атом формиṁ відкидає цілі записи результату праворуч і замінює їх у порядку з елементами в результаті зліва.

Пітон , 70 байт

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

Спробуйте в Інтернеті!

Рекурсивне рішення. Розглядаючи матрицю як список матриць на один розмір менше, вона повторює цей список, щоб спуститись по дереву. Він запам'ятовує вибрані індекси l, і коли nіндекси були вибрані, ми призначаємо а 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 офіційним символом}

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

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

Безумовно

Цифри після кутових дужок вказують, що клітина закінчена.

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

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

Спробуйте в Інтернеті!

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

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

Читає nвід stdin; повертає масив, друкуючи результати у вигляді матриць. Я деякий час боровся з цим, поки не прочитав документи для [, які вказують на те, що матриця може бути використана для індексації масиву, де кожен рядок матриці представляє набір індексів. Акуратно!

Спробуйте в Інтернеті!

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 додаткових байтів.

Спробуйте в Інтернеті!

Піт, 14 байт

ucGQtQms!t{d^U

Тестовий набір

Пояснення:, ^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

Лист звичайний, 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 %))

Приємно, що Assoc-in працює також з векторами, не тільки з хеш-картами.