„Matryca” tożsamości N-wymiarowej

30

Biorąc pod uwagę dodatnią liczbę całkowitą n, wyprowadzaj N„matrycę” tożsamości wymiarowej, która jest N^Ntablicą, w 1której wszystkie składniki indeksów są równe i w 0przeciwnym razie. N^Noznacza 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]]]]

Na przykład, jeśli ajest 4wymiarowa tożsamość „matrix”, to tylko wpisy z 1byłoby a[0][0][0][0], a[1][1][1][1], a[2][2][2][2], i a[3][3][3][3].

To jest . Najkrótsza odpowiedź w bajtach wygrywa. Obowiązują standardowe luki .

Leaky Nun
źródło
1
Powiązane , powiązane .
Leaky Nun
11
Oto odpowiedź MATL z wbudowanym narzędziem, które robi to za Ciebie ...
Cairney Coherheringaahing

Odpowiedzi:

9

Galaretka , 8 bajtów

×=¥þ’¡`Ṡ

Wypróbuj online!

Ooh, wygląda na to, że znów mogę przejść do outgolfa @Dennisa w jego własnym języku :-)

Jest to funkcja 1-argumentowa (ponieważ domyślny format wyjściowy Jelly dla list zagnieżdżonych jest nieco niejednoznaczny, co oznacza, że ​​prawdopodobnie nie spełnia specyfikacji jako pełny program).

Wyjaśnienie

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

Aby to zrozumieć, warto spojrzeć na etapy pośrednie. Dla wejścia 3 otrzymujemy następujące pośrednie kroki:

  1. [1,2,3](dane wejściowe wprowadzone pośrednio do zakresu þ)
  2. [[1,0,0],[0,2,0],[0,0,3]](utwórz tabelę [1,2,3], porównaj, aby uzyskać równość [[1,0,0],[0,1,0],[0,0,1]], a następnie pomnóż ją przez jedną z porównywanych wartości)
  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]]] (znowu ten sam pomysł)
  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]]](zastąp każdy element jego znakiem za pomocą )

Zauważ, że wejście zaczyna się od 1-wymiarowej oznacza, że ​​musimy zapętlić (input-1) razy, aby dodać wymiary (input-1), tworząc listę danych wejściowych.

Ciekawostka: program ten zawiera pięć Quicks z rzędu, ¥þ’¡`. (Szybki to modyfikator „linku” lub wbudowanego, służący do modyfikowania jego zachowania lub łączenia go z innym linkiem.)


źródło
+ !, tylko dlatego, że pokonałeś Dennisa w Jelly.
Zacharý
7

Mathematica, 30 bajtów

Array[Boole@*Equal,#~Table~#]&
ngenisis
źródło
1
@FryAmTheEggman parametrem liczby całkowitej, ponieważ drugim argumentem Tablejest najnowszy dodatek. Matematyka nadal potrzebuje tam listy singletonów: tio.run/##y00sychMLv7/P83WsagosTLaKT8/…
Martin Ender
1
@FryAmTheEggman Wygląda na to, że musisz to zmienić, Array[Boole@*Equal,#~Table~{#}]&aby pracować nad matematyką. Starsze wersje Mathematica nie obsługują liczb całkowitych jako drugiego argumentu Table, i przypuszczam, że matematyka jest oparta na tym.
ngenisis
1
@MartinEnder Pinch, szturchaj, jesteś mi winien colę :)
ngenisis
6

APL (Dyalog) , 10 bajtów

1=≢∘∪¨⍳⍴⍨⎕

Wypróbuj online!

1= [jest] 1 równa

 numer

 z

 unikalne elementy

¨ w każdym z

 indeksy w tablicy o wymiarach

⍴⍨ samokształtu ( N kopii N ) z

 wejście ( N ) [?]

Adám
źródło
5

Galaretka , 9 bajtów

ðṗE€ṁ+þ’¡

Wypróbuj online!

Jak to działa

Bezpośrednie wykonanie zadania wydaje się trudne (nie znalazłem sposobu), ale tworzenie tablic o tych samych liczbach i tablic o tym samym kształcie jest dość łatwe.

ðpowoduje, że łańcuch staje się dyadyczny, a wejściowa liczba całkowita n służy zarówno jako lewy, jak i prawy argument łańcucha. Można zamiast tego użyć łańcucha monadycznego, ale reguły analizujące dla tych dynamicznych zapisują tutaj trzy bajty (dwa po sprawdzeniu ð).

Kartezjański moc atom z argumentem w lewo i w prawo równej N , tworzy tablicę wszystkich wektorów o długości n , które składają się z elementów [1, ..., n] , sortowane leksykograficznie.

Gdy n = 3 , daje to

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

Sobie równe Szybki odnośnik E€testuje elementy wszystkich skonstruowanych wektorów do równości.

Gdy n = 3 , otrzymujemy

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

które są elementami trójwymiarowej matrycy tożsamości, w płaskiej matrycy.

Dynamiczne szybkie łącze +þ’¡jest wywoływane z lewym argumentem i prawym argumentem n . Szybkie ¡wywołuje atom dekrementacji , który daje n-1 , a następnie wywołuje szybkie łącze dodawania tabeli n-1 razy.

Początkowo oba argumenty to n . Po każdym wywołaniu prawy argument jest zastępowany lewym, a lewy zastępowany jest wartością zwracaną wywołania.

Stół szybkie wywołuje dodawania atom +dla poszczególnych elementów jego lewego argumentu, a każdy element jej prawego argumentu budowy stołu / macierz wartości zwracanej. Początkowe argumenty liczb całkowitych n są awansowane do zakresów [1, ... n] .

Gdy n = 3 , po awansie, ale przed pierwszą iteracją, oba argumenty są

[1, 2, 3]

Dodanie każdej liczby całkowitej w tej tablicy do każdej liczby całkowitej w tej tablicy daje wynik

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

W kolejnym wywołaniu dodajemy każdą z tych tablic do liczb całkowitych w [1, 2, 3] . Dodawanie wektoryzuje (dodanie liczby całkowitej do tablicy dodaje ją do każdego elementu), więc otrzymujemy

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

Ta tablica ma taki sam kształt jak trójwymiarowa matryca tożsamości, ale nie ma prawidłowych elementów.

Na koniec atom pleśni odrzuca wpisy liczb całkowitych wyniku po prawej stronie i zastępuje je kolejno elementami w wyniku po lewej stronie.

Dennis
źródło
4

Python , 70 bajtów

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

Wypróbuj online!

Rozwiązanie rekurencyjne. Myśląc o macierzy jako liście macierzy o jeden wymiar mniejszej, iteruje tę listę, aby zejść z drzewa. Pamięta wybrane indeksy l, a kiedy nzostały wybrane, przypisujemy 1lub w 0zależności od tego, czy wszystkie są takie same.


Python 2 , 73 bajty

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

Wypróbuj online!

Ulepszenie metody tworzenia przez człowieka matrycy zer, a następnie przypisywania ich do przekątnej.


Python 2 , 88 bajtów

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

Wypróbuj online!

Niektóre bzdury eval, generowanie zagnieżdżonej listy i podstawianie w postaci łańcucha. Ciąg do oceny wygląda następująco:

[[[+(i0==i0==i1==i2)for i0 in t]for i1 in t]for i2 in t]
xnor
źródło
4

Python 2 + NumPy , 80 72 70 bajtów

Teraz związany z najwyższą odpowiedzią na Python!

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

Wypróbuj online

Zaoszczędzono 8 bajtów dzięki Andrasowi Deakowi i 2 przez officialaimm

mbomb007
źródło
2
Skorzystaj z fantazyjnego indeksowania: a[[range(n)]*n]=1zamiast swojego exec.
Andras Deak
(Jest właściwie fill_diagonal(a,1)w tym celu, ale to o jeden bajt dłużej)
Andras Deak
1
+1 za ładną produkcję. I nie widzę zastosowania zmiennej i, która powinna zaoszczędzić 2 bajty.
officialaimm
3

Python 2 , 99 93 90 bajtów

Dzięki Rod dla niektórych nawet więcej pomocy, że dostał pracę, a także ogolone 6 bajtów off! -3 bajty dzięki xnor.

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

Wypróbuj online!

całkowicie ludzki
źródło
1
def/returnNigdy lepiej niż jest input/print(w najlepszym scenariuszu jest równe), można również upuść ()na ('[%d]'%i)ograniczenie do 93 bajtów
Rod
1
'[%d]'%izdarza się, że jest to ciąg powtórzeń [i].
xnor
2

JavaScript (ES6), 67 bajtów

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

Objaśnienie: isłuży do śledzenia, czy komórka znajduje się na głównej przekątnej, czy nie. Początkowo jest niezdefiniowany, więc przy pierwszym wywołaniu rekurencyjnym zawsze przekazujemy pierwszy wymiar, podczas gdy przy kolejnych wywołaniach rekurencyjnych przekazujemy go tylko wtedy, gdy bieżący indeks wymiaru jest równy wszystkim poprzednim wymiarom, w przeciwnym razie przekazujemy indeks, nktóry wskazuje, że wszystkie komórki rekurencyjne powinny wynosić zero.

Neil
źródło
2

Brainfuck , 61 bajtów

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

Bez golfa

Liczby po nawiasach kątowych wskazują komórkę, nad którą znajduje się głowa.

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

Wypróbuj online!

Dane wejściowe to liczba binarna. Dane wyjściowe to macierz przechowywana w kolejności rzędów głównych.

Promień
źródło
W odpowiedziach jest już kilka różnych formatów wyjściowych, więc zakładam, że jedynym wymaganiem jest „jakaś standardowa reprezentacja macierzy”. Jeśli musi być w określonym formacie, odpowiednio zmodyfikuję kod.
Ray
Wydaje mi się, że wiersz-major w tym konkretnym przypadku wyglądałby dokładnie jak kolumna major
Octopus
@Octopus W rzeczywistości program określa, czy powinien on być w kolejności rzędów głównych, czy kolumnowych, w oparciu o język, w którym jest napisany interpreter Brainfuck. Mój jest napisany w C, więc naturalnie wysyła macierz w kolejności rzędów większych. Jeśli jednak użyjesz interpretera napisanego w Fortranie lub MATLAB, wykryje to i automatycznie przełączy się na główną kolumnę. (Jeśli używałeś interpretera napisanego w samym Brainfuck, rozwiązuje on niejednoznaczność na podstawie języka, w którym napisany jest edytor tekstu.) :-)
Ray
2

R , 64 49 bajtów

-15 bajtów dzięki Jarko Dubbeldam

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

Odczytuje ze standardowego wejścia i zwraca tablicę, drukując jako matryce. seqgeneruje sekwencję równomiernie rozmieszczoną od 1do n^nz długością l=n, co całkiem nieźle ułatwia indeksowanie, gdzie idą 1.

Wypróbuj online!

stara wersja:

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

Czyta nze standardowego; zwraca tablicę, drukując wyniki jako macierze. Zmagałem się z tym przez chwilę, aż przeczytałem dokumentację [, która wskazuje, że do indeksowania tablicy można użyć macierzy, gdzie każdy wiersz macierzy reprezentuje zestaw indeksów. Schludny!

Wypróbuj online!

Giuseppe
źródło
array(0, rep(n,n)działa, więc nie musisz tego robić rep. Możesz wtedy również przejść nprzez array(0, rep(n<-scan(),n)).
JAD
Ponadto x[seq(1,n^n,l=n)]=1jest o 1 bajt krótszy.
JAD
@JarkoDubbeldam dziękuję! Niezłe.
Giuseppe
1

Python 3 + numpy, 81 77 bajtów

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

Nie jestem do końca pewien, czy powyższe spełnia wszystkie wytyczne: zwraca tablicę ndarray o podanych właściwościach. Wiem, że anonimowe funkcje są zwykle w porządku, ale interaktywna powłoka faktycznie wydrukuje

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

Jeśli puch tablic powoduje, że powyższe jest nieważne, muszę wrzucić print()około 7 dodatkowych bajtów.

Wypróbuj online!

Andras Deak
źródło
1

Pyth, 14 bajtów

ucGQtQms!t{d^U

Zestaw testowy

Objaśnienie ^U:, niejawnie ^UQQ, gdzie Qjest dane wejściowe, oblicza wszystkie możliwe listy elementów Q zakresu 0 ... n-1. ms!t{dodwzorowuje te ze wszystkimi elementami równymi 1, a pozostałe na 0. Daje to spłaszczoną moc wyjściową

ucGQtQ wykonuje następujące czynności, Q - 1 razy: Posiekaj dane wejściowe na listy o rozmiarze Q.

isaacg
źródło
1

C # (.NET Core) , 166 bajtów

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

Wypróbuj online!

Na początku myślałem, że nie da się tego zrobić za pomocą wyrażenia lambda w C # ... ^ __ ^ U

Charlie
źródło
1

Common Lisp, 147 133 bajtów

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

Wypróbuj online!

Zwykłe bardzo długie seplenienie. Zmniejszono 12 bajtów dzięki @ceilingcat!

Wyjaśnienie:

(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
Renzo
źródło
@ceilingcat, ops, w wersji golfowej był głupi błąd. Poprawione, dziękuję!
Renzo,
0

SOGL V0.12 , 22 bajty

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

Wypróbuj tutaj!
Pozostawia dane wyjściowe na stosie , widoczne w konsoli. Jeśli liczby na wyjściu mogą być ciągami, wówczas rmożna je usunąć.
Jako zabawny test tego, jak radzi sobie SOGL w wyzwaniach, nie został on całkowicie stworzony dla: str

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
dzaima
źródło
0

Clojure, 92 bajty

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

Fajnie, że assoc-in działa również z wektorami, nie tylko z mapami skrótów.

NikoNyrh
źródło