Pozitif bir tam sayı Verilen nçıkış, Nbir boyutlu özdeşlik "matris", N^Nile dizi 1indeksleri tüm bileşenler eşit olduğu 0, aksi. N^NN-by-N-by-N-by -... anlamına gelir.

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

Örneğin, eğer abir 4boyutlu kimlik "matris", daha sonra tek girişleri 1olacağını a[0][0][0][0], a[1][1][1][1], a[2][2][2][2], ve a[3][3][3][3].

Bu kod golfü . Bayt cinsinden en kısa cevap kazanır. Standart boşluklar uygulanır.

Octave, 29 bayt

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

Çevrimiçi deneyin!

Jöle , 8 bayt

×=¥þ’¡`Ṡ

Çevrimiçi deneyin!

Ooh, sanırım @Dennis'i kendi dilinde kendi dilinde yenebiliyorum :-)

Bu bir 1 argüman işlevidir (çünkü Jelly'in yuvalanmış listeler için varsayılan çıktı biçimi biraz belirsizdir, yani tam bir program olarak belirtimi tam olarak yerine getiremediği anlamına gelir).

açıklama

×=¥þ’¡`Ṡ
     ¡    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

Bunu anlamak için ara adımlara bakmak yardımcı olur. 3 giriş için aşağıdaki ara adımları uygularız:

1. [1,2,3](girdi, dolaylı olarak bir aralık içine yerleştirilmiş þ)
2. [[1,0,0],[0,2,0],[0,0,3]](ile bir tablo hazırlayın [1,2,3], eşitliği bulmak için karşılaştırın [[1,0,0],[0,1,0],[0,0,1]], sonra karşılaştırdığımız değerlerden biriyle çarpın)
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]]] (yine aynı fikir)
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]]](kullanarak her bir öğeyi işaretiyle değiştirin Ṡ)

Girişin 1 boyutlu olarak başladığı gerçeğine dikkat edin, giriş boyutlu bir liste oluşturarak (giriş-1) boyutlar eklemek için (giriş-1) kez döngü yapmamız gerektiği anlamına gelir.

Eğlenceli gerçek: Bu program arka arkaya beş hızlı içerir ¥þ’¡`. (Çabuk, davranışını değiştirmek veya başka bir bağlantıyla birleştirmek için kullanılan bir "bağlantı" ya da yerleşik bir değiştiricidir.)

Mathematica, 30 bayt

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

APL (Dyalog) , 10 bayt

1=≢∘∪¨⍳⍴⍨⎕

Çevrimiçi deneyin!

1= [1] 1’e eşittir

≢ numara

∘ arasında

∪ benzersiz elemanlar

¨ her biri içinde

⍳ bir dizideki indeksleri,

⍴⍨ kendini yeniden şekillendirme ( N kopyaları N ) ait

⎕ giriş ( N ) [?]

Jöle , 9 bayt

ðṗE€ṁ+þ’¡

Çevrimiçi deneyin!

Nasıl çalışır

Görevi doğrudan elde etmek zor gibi görünüyor (bir yol bulamadım), ancak aynı sayıdaki dizileri ve aynı şekildeki dizileri oluşturmak oldukça kolaydır.

ðZincir diyadik ve tam sayı giriş yapan n- zinciri için iki sağ ve sol bağımsız değişken olarak hizmet vermektedir. Bunun yerine bir monadik zincir kullanmak mümkündür, ancak dyadik olanlar için ayrıştırma kuralları burada üç bayt kurtarır (hesap oluşturduktan sonra iki tane ð).

Kartezyen güç atomu ṗ, sol ve sağ bağımsız değişkeni eşit olan, n , uzunluğunun tüm vektörlerin dizisi oluşturur , n elemanlarının oluşması [1, ..., n] , sözlük sırasında kriteri.

Zaman , n = 3 , bu verimler

[[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]]

Her eşit uicklink E€eşitlik tüm kurulmuş vektörler elemanlarını test eder.

Ne zaman n = 3 , aldığımız

[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]

3 boyutlu kimlik matrisinin elemanları olan düz bir dizide.

Dyadic quicklink +þ’¡sol argüman ve sağ argüman ile denir n . Çabuk , n-1'i veren ¡azalma atomunu çağırır, daha sonra n-1 kere toplama tablasını çağırır .’+þ

Başlangıçta, +þher ikisinin de argümanları n'dir . Her çağrıdan sonra, sağ argüman soldaki ile değiştirilir, soldaki çağrı ise aramanın dönüş değeri ile değiştirilir.

Tablo hızlı aramaları eklenti atomu +dönüş değeri bir tablo / matris oluşturmak sol argüman her elemanlarının ve sağ argüman her bir elemanı için. İlk tamsayı argümanları n , aralıklara yükseltilir [1, ... n] .

Ne zaman n = 3 , promosyon sonra ancak ilk yineleme önce, her iki bağımsız değişkendir

[1, 2, 3]

Bu dizideki her tamsayı bu dizideki her bir tam sayıya eklemek

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

Bir sonraki çağrımda, bu dizilerin her birini [1, 2, 3] içindeki tam sayılara ekleriz . Ekleme vektörleşir (bir diziye bir tamsayı ekleyerek onu her bir öğeye ekler)

[[[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]]]

Bu dizi, 3 boyutlu kimlik matrisi ile aynı şekle sahiptir, ancak doğru öğeler değil.

Son olarak, kalıp atomu ṁ, sonucun tamsayı girişlerini sağa atar ve sonuçtaki öğeler sola doğru sırayla bunları yerine koyar.

Python , 70 bayt

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

Çevrimiçi deneyin!

Özyinelemeli bir çözüm. Matrisi bir boyut küçültülmüş bir matris listesi olarak düşününce, ağaçta dolaşmak için o listeyi tekrar eder. Alınan endeksleri hatırlar ve endeksler lalındığında , hepsinin aynı olup olmadığına bağlı olarak na 1veya atarız 0.

Python 2,73 bayt

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

Çevrimiçi deneyin!

Tamamen insanın sıfır matris yapma ve sonra köşegenleri atama yönteminde bir gelişme .

Python 2,8 bayt

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

Çevrimiçi deneyin!

evalİç içe geçmiş bir liste oluşturarak ve dize biçiminde ikame ile bazı saçmalıklar . Değerlendirilecek dize şöyle görünür:

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

Python 2 + NumPy , 80 72 70 bayt

Şimdi en iyi Python cevabına bağlı!

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

Çevrimiçi deneyin

_{Andras Deak sayesinde 8 bayt, officialaimm tarafından 2 kurtarıldı}

Python 2 , 99 93 90 bayt

İçin Rod sayesinde bazı çalışmıyor ve ayrıca traş 6 bayt indi bile fazla yardım! Xnor sayesinde -3 bayt.

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

Çevrimiçi deneyin!

JavaScript (ES6), 67 bayt

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

Açıklama: ihücrenin ana diyagonal üzerinde olup olmadığını takip etmek için kullanılır. Başlangıçta tanımsızdır, bu nedenle ilk özyinelemeli çağrıda her zaman birinci boyutu geçiririz; sonraki özyinelemeli çağrılar için yalnızca geçerli boyut dizini önceki tüm boyutlara eşitse, aksi takdirde ntümünün belirttiğini belirten bir dizini geçiririz özyinelemeli hücreler sıfır olmalıdır.

Brainfuck , 61 bayt

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

Ungolfed

Köşeli parantezden sonraki sayılar kafanın bittiği hücreyi gösterir.

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

Çevrimiçi deneyin!

Giriş bir ikili sayıdır. Çıktı, satır ana düzeninde depolanan bir matristir.

R , 64 49 bayt

Jarko Dubbeldam sayesinde -15 bayt

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

Stdin'den okur ve bir dizi döndürür, matris olarak yazdırır. seqeşit aralıklı bir dizi oluşturur1 için n^nuzunluğu l=n1s nereye indeksine oldukça güzel işe yaramaktadır.

Çevrimiçi deneyin!

eski versiyon:

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

Stdin'den okur n; sonuçları matris olarak basarak bir dizi döndürür. Dokümanları okuyana kadar bir süre bunun için mücadele ettim.[ , matrisin her satırının indeks kümesini temsil ettiği bir diziyi dizine almak için kullanılabileceğini gösteren . Temiz!

Çevrimiçi deneyin!

J , 16 15 bayt

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

Çevrimiçi deneyin!

Python 3 + numpy, 81 77 bayt

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

Ben değilim tamamen o verilen özelliklere sahip bir ndarray döndürür: Emin Yukarıdaki uyan tüm kurallar söyledi. Anonim işlevlerin genellikle iyi olduğunu biliyorum, ancak etkileşimli bir kabuk gerçekten yazdırılacak

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

Dizi kabartması yukarıdakileri geçersiz kılarsa, print()7 ek bayt gibi bir şey için atmam gerekir.

Çevrimiçi deneyin!

Pyth, 14 bayt

ucGQtQms!t{d^U

Test odası

Açıklama: ^Udolaylı olarak ^UQQ, Qgiriş nerede , aralığın tüm olası Q öğesi listelerini hesaplar 0 ... n-1. ms!t{dtüm elemanları 1'e eşit olanları ve kalanını 0'a eşler. Bu, düzleştirilmiş çıktılar verir.

ucGQtQ aşağıdakileri yapar, Q - 1 kez: Girdiyi Q boyutunda listeler halinde kesin.

C # (.NET Core) , 166 bayt

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

Çevrimiçi deneyin!

İlk başta C # ... ^ __ ^ U içindeki bir lambda ifadesiyle yapılamadığını düşündüm.

Ortak Lisp, 147 133 bayt

(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)))

Çevrimiçi deneyin!

Her zamanki gibi süper uzun lisp. Azaltılmış 12 bayt @ceilingcat!

Açıklama:

(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 bayt

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

Burada dene!
Çıktıyı konsolda görülebilen istif üzerinde bırakır . Çıktıdaki sayıların dizge olmasına izin verilirse, o rzaman kaldırılabilir.
SOGL’in zorluklarla nasıl başa çıktığını gösteren eğlenceli bir sınav gibi:

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 bayt

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

Assoc-in'in sadece karma haritalarla değil vektörlerle de çalışması güzel .