"Matriks" identitas dimensi-N


30

Diberikan bilangan bulat positif n, mengeluarkan N"matriks" identitas -dimensi, yang merupakan N^Nlarik dengan 1semua komponen indeks sama dan 0tidak. N^Nberarti N-oleh-N-oleh-N-oleh -...

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

Sebagai contoh, jika aadalah 4berdimensi identitas "matrix", maka satu-satunya entri dengan 1akan a[0][0][0][0], a[1][1][1][1], a[2][2][2][2], dan a[3][3][3][3].

Ini adalah . Jawaban terpendek dalam byte menang. Celah standar berlaku.



11
Inilah jawaban MATL dengan builtin melakukannya untuk Anda ...
caird coinheringaahing

Jawaban:



9

Jelly , 8 byte

×=¥þ’¡`Ṡ

Cobalah online!

Ooh, sepertinya saya bisa mengalahkan @Dennis dalam bahasanya sendiri lagi :-)

Ini adalah fungsi 1-argumen (karena format output default Jelly untuk daftar bersarang sedikit ambigu, artinya bisa dikatakan tidak memenuhi spesifikasi sebagai program lengkap).

Penjelasan

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

Untuk memahami ini, ada baiknya untuk melihat langkah-langkah perantara. Untuk input 3, kami mendapatkan langkah perantara berikut:

  1. [1,2,3](input, dibuat menjadi rentang yang secara implisit oleh þ)
  2. [[1,0,0],[0,2,0],[0,0,3]](buat tabel dengan [1,2,3], bandingkan untuk mendapatkan persamaan [[1,0,0],[0,1,0],[0,0,1]], lalu kalikan dengan salah satu nilai yang kami bandingkan)
  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]]] (ide yang sama lagi)
  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]]](ganti setiap elemen dengan tandanya menggunakan )

Perhatikan fakta bahwa input mulai 1-dimensi berarti kita harus mengulang (input-1) kali untuk menambahkan (input-1) dimensi, menghasilkan daftar dimensi-input.

Fakta menyenangkan: program ini berisi lima quicks berturut-turut ¥þ’¡`,. (Quick adalah pengubah "tautan", atau bawaan, digunakan untuk mengubah perilakunya atau menggabungkannya dengan tautan lain.)


+ !, hanya karena Anda mengalahkan Dennis di Jelly.
Zacharý

7

Mathematica, 30 byte

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

1
@FryAmTheEggman parameter integer sebagai argumen kedua Tableadalah tambahan baru-baru ini. Matematika masih membutuhkan daftar tunggal di sana: tio.run/##y00sychMLv7/P83WsagosTLaKT8/…
Martin Ender

1
@FryAmTheEggman Sepertinya Anda perlu mengubahnya agar Array[Boole@*Equal,#~Table~{#}]&dapat bekerja di Matematika. Versi lama Mathematica tidak mendukung integer sebagai argumen kedua Table, dan saya kira Matematika didasarkan pada hal itu.
ngenisis

1
@MartinEnder Pinch, colek, Anda berhutang Coke :)
ngenisis

6

APL (Dyalog) , 10 byte

1=≢∘∪¨⍳⍴⍨⎕

Cobalah online!

1= 1 adalah sama dengan

 nomor

 dari

 elemen unik

¨ di masing-masing

 indeks dalam array dengan dimensi

⍴⍨ yang membentuk kembali diri ( N salinan N ) dari

 input ( N ) [?]


5

Jelly , 9 byte

ðṗE€ṁ+þ’¡

Cobalah online!

Bagaimana itu bekerja

Mencapai tugas secara langsung tampaknya sulit (saya belum menemukan cara), tetapi menyusun array dengan nomor yang sama dan array dengan bentuk yang sama cukup mudah.

ðmembuat diad rantai, dan input integer n berfungsi sebagai argumen kiri dan kanan untuk rantai. Dimungkinkan untuk menggunakan rantai monadik sebagai gantinya, tetapi aturan parsing untuk yang diad menyimpan tiga byte di sini (dua setelah accouting for ð).

The listrik Cartesian atom , dengan argumen kiri dan kanan sama untuk n , konstruksi array semua vektor dengan panjang n yang terdiri dari unsur [1, ..., n] , diurutkan leksikografi.

Ketika n = 3 , ini menghasilkan

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

The sama setiap Quicklink E€menguji unsur semua vektor dibangun untuk kesetaraan.

Ketika n = 3 , kita dapatkan

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

yang merupakan elemen dari matriks identitas 3 dimensi, dalam susunan datar.

Dilink cepat +þ’¡disebut dengan argumen kiri dan argumen kanan n . Quick ¡memanggil atom decrement , yang menghasilkan n-1 , lalu memanggil quicklink tabel tambahkan n-1 kali.

Awalnya, argumen keduanya n . Setelah setiap panggilan, argumen kanan digantikan oleh yang kiri, dan yang kiri digantikan oleh nilai balik dari panggilan.

The meja cepat memanggil add atom +untuk setiap elemen argumen kiri dan setiap elemen argumen kanan, membangun tabel / matriks nilai kembali. Argumen integer awal n dipromosikan ke rentang [1, ... n] .

Ketika n = 3 , setelah promosi tetapi sebelum iterasi pertama, kedua argumen tersebut

[1, 2, 3]

Menambahkan setiap integer dalam array ini ke setiap integer dalam array ini menghasilkan

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

Dalam doa berikutnya, kami menambahkan masing-masing array ini ke integer di [1, 2, 3] . Addition vectorizes (menambahkan integer ke array menambahkannya ke setiap elemen), jadi kita dapatkan

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

Array ini memiliki bentuk yang sama dengan matriks identitas 3 dimensi, tetapi bukan elemen yang benar.

Akhirnya, atom cetakan membuang entri bilangan bulat dari hasil ke kanan dan menggantinya sesuai dengan unsur-unsur dalam hasil di sebelah kiri.


4

Python , 70 byte

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

Cobalah online!

Solusi rekursif. Memikirkan matriks sebagai daftar matriks satu dimensi lebih kecil, itu beralih ke daftar itu untuk turun pohon. Itu mengingat indeks yang dipilih l, dan ketika nindeks telah diambil, kami menetapkan 1atau 0tergantung pada apakah semuanya sama.


Python 2 , 73 byte

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

Cobalah online!

Peningkatan pada metode benar-benar manusiawi membuat matriks nol dan kemudian menetapkan yang ke diagonal.


Python 2 , 88 byte

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

Cobalah online!

Beberapa omong kosong dengan eval, menghasilkan daftar bersarang, dan substitusi format string. String yang akan dievaluasi terlihat seperti:

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

4

Python 2 + NumPy , 80 72 70 byte

Sekarang diikat dengan jawaban Python teratas!

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

Cobalah online

Disimpan 8 byte berkat Andras Deak, dan 2 oleh officialaimm


2
Manfaatkan pengindeksan mewah: a[[range(n)]*n]=1alih-alih eksekutif Anda.
Andras Deak

(Sebenarnya ada fill_diagonal(a,1)untuk tujuan ini, tapi itu satu byte lebih lama)
Andras Deak

1
+1 untuk hasil yang cantik. Dan, saya tidak melihat penggunaan variabel i, yang seharusnya menghemat 2 byte.
officialaimm

3

Python 2 , 99 93 90 byte

Terima kasih kepada Rod untuk beberapa bantuan lebih banyak lagi yang mendapatkannya bekerja dan juga mencukur 6 byte off! -3 byte terima kasih kepada xnor.

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

Cobalah online!


1
def/returntidak pernah lebih baik daripada input/print(dalam skenario terbaik sama dengan), Anda juga dapat menurunkan ()dalam ('[%d]'%i)pengurangan hingga 93 byte
Rod

1
'[%d]'%ikebetulan adalah string rep dari [i].
xnor

2

JavaScript (ES6), 67 byte

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

Penjelasan: idigunakan untuk melacak apakah sel berada di diagonal utama atau tidak. Awalnya itu tidak terdefinisi, jadi pada panggilan rekursif pertama kami selalu melewati dimensi pertama, sementara pada panggilan rekursif berikutnya kami hanya meneruskannya jika indeks dimensi saat ini sama dengan semua dimensi sebelumnya, jika tidak kami melewati indeks nyang menunjukkan bahwa semua sel rekursif harus nol.


2

Brainfuck , 61 byte

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

Tidak disatukan

Angka-angka setelah tanda kurung siku menunjukkan sel kepala berakhir.

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

Cobalah online!

Input adalah nomor biner. Output adalah matriks yang disimpan dalam urutan baris-utama.


Ada beberapa format output yang berbeda dalam jawaban, jadi saya berasumsi bahwa satu-satunya persyaratan adalah "beberapa representasi matriks standar". Jika perlu dalam format tertentu, saya akan memodifikasi kodenya.
Ray

Saya kira baris-utama dalam kasus khusus ini akan terlihat persis seperti kolom-utama
Octopus

@Octopus Sebenarnya, program menentukan apakah harus dalam urutan baris-utama atau kolom-besar berdasarkan bahasa yang ditulis oleh penerjemah Brainfuck. Tambang ditulis dalam C, sehingga secara alami menampilkan matriks dalam urutan baris-utama. Namun, jika Anda menggunakan juru bahasa yang ditulis dalam Fortran atau MATLAB, itu akan mendeteksi itu dan secara otomatis beralih ke kolom urutan utama. (Jika Anda menggunakan juru bahasa yang ditulis dalam Brainfuck sendiri, itu akan menyelesaikan ambiguitas berdasarkan bahasa yang ditulis oleh editor teks Anda.) :-)
Ray

2

R , 64 49 byte

-15 byte berkat Jarko Dubbeldam

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

Membaca dari stdin dan mengembalikan array, mencetak sebagai matriks. seqmenghasilkan urutan merata spasi dari 1ke n^ndengan panjang l=n, yang melakukan trik dengan cukup baik untuk mengindeks ke mana 1s pergi.

Cobalah online!

versi lama:

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

Baca ndari stdin; mengembalikan array, mencetak hasilnya sebagai matriks. Saya berjuang dengan ini untuk sementara waktu sampai saya membaca dokumen untuk [, yang menunjukkan bahwa matriks dapat digunakan untuk mengindeks array, di mana setiap baris matriks mewakili set indeks. Rapi!

Cobalah online!


array(0, rep(n,n)bekerja, jadi Anda tidak perlu melakukannya rep. Anda kemudian dapat juga mengambil nmelalui array(0, rep(n<-scan(),n)).
JAD

Juga, x[seq(1,n^n,l=n)]=11 byte lebih pendek.
JAD

@JarkoDubbeldam terima kasih! Bagus
Giuseppe


1

Python 3 + numpy, 81 77 byte

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

Saya tidak sepenuhnya yakin bahwa di atas cocok dengan semua pedoman: ini mengembalikan ndarray dengan properti yang diberikan. Saya tahu fungsi anonim biasanya baik-baik saja, tetapi shell interaktif sebenarnya akan dicetak

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

Jika array bulu membuat di atas tidak valid, saya harus melempar print()untuk sesuatu seperti 7 byte tambahan.

Cobalah online!


1

Pyth, 14 byte

ucGQtQms!t{d^U

Suite uji

Penjelasan:, ^Uyang secara implisit ^UQQ, di mana Qinput, menghitung semua daftar elemen Q yang mungkin dari rentang 0 ... n-1. ms!t{dmemetakan yang dengan semua elemen sama dengan 1, dan sisanya ke 0. Ini memberikan hasil yang rata

ucGQtQ jalankan yang berikut ini, Q - 1 kali: Potong input ke daftar ukuran Q.


1

C # (.NET Core) , 166 byte

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

Cobalah online!

Awalnya saya pikir itu tidak bisa dilakukan dengan ekspresi lambda di C # ... ^ __ ^ U


1

Common Lisp, 147 133 byte

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

Cobalah online!

Cadel super-panjang biasa. Berkurang 12 byte, terima kasih kepada @ceilingcat!

Penjelasan:

(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

@ceilingcat, ops, ada kesalahan bodoh dalam versi golf. Diperbaiki, terima kasih!
Renzo

0

SOGL V0.12 , 22 byte

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

Coba Di Sini!
Meninggalkan output di tumpukan , dapat dilihat di konsol. Jika angka-angka dalam output dibiarkan berupa string, maka angka rtersebut dapat dihapus.
Seperti halnya tes menyenangkan tentang bagaimana SOGL dalam tantangan, itu sama sekali tidak dibuat untuk: 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

0

Clojure, 92 byte

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

Bagus bahwa assoc-in berfungsi juga dengan vektor, tidak hanya dengan hash-maps.

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.