Wyzwanie to jest związane z niektórymi funkcjami języka MATL w ramach wydarzenia Język miesiąca miesiąca 2018 .

Wprowadzenie

W MATL wiele funkcji dwóch wejść działa elementarnie z rozgłaszaniem . Oznacza to, co następuje:

• Pod względem elementów (lub wektoryzacji ): funkcja przyjmuje jako dane wejściowe dwie tablice o pasujących rozmiarach. Operacja zdefiniowana przez funkcję jest stosowana do każdej pary odpowiednich pozycji. Na przykład za pomocą notacji po poprawce:

  [2 4 6] [10 20 30] +
  

  daje wyjście

  [12 24 36]
  

  Działa to również z tablicami wielowymiarowymi. Notacja [1 2 3; 4 5 6]reprezentuje tablicę 2× 3(macierz)

  1 2 3
  4 5 6
  

  który ma rozmiar 2wzdłuż pierwszego wymiaru (w pionie) i 3wzdłuż drugiego (w poziomie). Na przykład

  [2 4 6; 3 5 7] [10 20 30; 40 60 80] *
  

  daje

  [20 80 180; 120 300 560]
  

• Nadawanie lub ( rozszerzenie singleton ): dwie tablice wejściowe nie mają pasujących rozmiarów, ale w każdym niepasującym wymiarze jedna z tablic ma rozmiar 1. Ta tablica jest domyślnie replikowana wzdłuż innych wymiarów, aby dopasować rozmiary; a następnie operacja jest stosowana elementowo, jak wyżej. Rozważmy na przykład dwie tablice wejściowe o rozmiarach 1× 2i 3× 1:

  [10 20] [1; 2; 5] /
  

  Dzięki nadawaniu jest to równoważne z

  [10 20; 10 20; 10 20] [1 1; 2 2; 5 5] /
  

  i tak daje

  [10 20; 5 10; 2 4]
  

  Podobnie w przypadku rozmiarów 3× 2i 3× 1(nadawanie działa teraz tylko w drugim wymiarze),

  [9 8; 7 6; 5 4] [10; 20; 30] +
  

  daje

  [19 18; 27 26; 35 34]
  

  Liczba wymiarów może być nawet inna. Na przykład dane wejściowe o rozmiarach 3 × 2 i 3 × 1 × 5 są kompatybilne i dają wynik 3 × 2 × 5. W rzeczywistości rozmiar 3 × 2 jest taki sam jak 3 × 2 × 1 (istnieje arbitralnie wiele ukrytych wymiarów singletonu).

  Z drugiej strony para tablic 2× 2i 3× 1spowodowałaby błąd, ponieważ rozmiary wzdłuż pierwszego wymiaru wynoszą 2i 3: nie są równe i żaden z nich nie jest 1.

Definicja nadawania modułowego

Nadawanie modułowe to uogólnienie nadawania, które działa, nawet jeśli nie ma niepasujących rozmiarów 1. Rozważmy na przykład następujące tablice 2× 2i 3× 1jako dane wejściowe funkcji +:

[2 4; 6 8] [10; 20; 30] +

Zasada jest następująca: dla każdego wymiaru tablica, która jest mniejsza wzdłuż tego wymiaru, jest replikowana modułowo (cyklicznie) w celu dopasowania do rozmiaru drugiej tablicy. Czyni to powyższy odpowiednik

[2 4; 6 8; 2 4] [10 10; 20 20; 30 30] +

z rezultatem

[12 14; 26 28; 32 34]

Jako drugi przykład

[5 10; 15 20] [0 0 0 0; 1 2 3 4; 0 0 0 0; 5 6 7 8; 0 0 0 0] +

produkuje

[5 10 5 10; 16 22 18 24; 5 10 5 10; 20 26 22 28; 5 10 5 10]

Ogólnie dane wejściowe o rozmiarach a× bi c× ddają wynik o rozmiarze max(a,b)× max(c,d).

Wyzwanie

Zaimplementuj dodatek dla dwuwymiarowych tablic z modułową transmisją, jak zdefiniowano powyżej.

Tablice będą prostokątne (nie poszarpane), będą zawierały nieujemne liczby całkowite i będą miały rozmiar co najmniej1 w każdym wymiarze.

Dodatkowe zasady:

• Dane wejściowe i wyjściowe można przyjmować dowolnymi rozsądnymi środkami . Ich format jest elastyczny jak zwykle.

• Programy lub funkcje są dozwolone w dowolnym języku programowania . Standardowe luki są zabronione .

• Najkrótszy kod w bajtach wygrywa.

Przypadki testowe

Poniższe zastosowania stanowią ;separator wierszy (jak w powyższych przykładach). Każdy przypadek testowy pokazuje dwa wejścia, a następnie dane wyjściowe.

[2 4; 6 8]
[10; 20; 30]
[12 14; 26 28; 32 34]

[5 10; 15 20]
[0 0 0 0; 1 2 3 4; 0 0 0 0; 5 6 7 8; 0 0 0 0]
[5 10 5 10; 16 22 18 24; 5 10 5 10; 20 26 22 28; 5 10 5 10]

[1]
[2]
[3]

[1; 2]
[10]
[11; 12]

[1 2 3 4 5]
[10 20 30]
[11 22 33 14 25]

[9 12 5; 5 4 2]
[4 2; 7 3; 15 6; 4 0; 3 3]
[13 14 9;12 7 9;24 18 20;9 4 6;12 15 8]

[9 12 5; 5 4 2]
[4 2 6 7; 7 3 7 3; 15 6 0 1; 4 0 1 16; 3 3 3 8]
[13 14 11 16; 12 7 9 8; 24 18 5 10; 9 4 3 21; 12 15 8 17]

[6 7 9]
[4 2 5]
[10 9 14]

Galaretka , 10 bajtów

ṁ€ZL$Z€Ɗ⁺S

Pobiera na wejściu parę macierzy (dwie tablice wierszy) i zwraca macierz.

Wypróbuj online!

Jak to działa

ṁ€ZL$Z€Ɗ⁺S  Main link. Argument: [M, N] (matrix pair)

  Z $       Zip M with N (i.e., transpose the matrix of arrays [M, N], ...
   L            then take the length (number of rows) of the result.
ṁ€          Mold M and N like the indices, cyclically repeating their rows as many
            times as needed to reach the length to the right.
     Z€     Zip each; transpose both M and N.
       Ɗ⁺   Combine the three links to the left into a chain and duplicate it.
            The first run enlarges the columns, the second run the rows.
         S  Take the sum of the modified matrices.

Węgiel , 25 23 bajtów

ＡθＩＥ⌈ＥθＬιＥ⌈ＥθＬ§λ⁰ΣＥ觧νιλ

Wypróbuj online! Link jest do pełnej wersji kodu. Pobiera dane wejściowe jako trójwymiarową tablicę. Wyjaśnienie:

Ａθ

Wprowadź wszystko.

    θ                   Input
   Ｅ                    Map over arrays
      ι                 Current array
     Ｌ                  Length
  ⌈                     Maximum
 Ｅ                      Map over implicit range
          θ             Input
         Ｅ              Map over arrays
             λ          Current array
            § ⁰         First element
           Ｌ            Length
        ⌈               Maximum
       Ｅ                Map over implicit range
                 θ      Input
                Ｅ       Map over arrays
                    ν   Current array
                   § ι  Cyclically index using outer loop index
                  §   λ Cyclically index using inner loop index
               Σ        Sum
Ｉ                       Cast to string
                        Implicitly print on separate lines and paragraphs

MATL , 25 24 bajtów

,iZy]vX>XKx,@GK:KP:3$)]+

Wypróbuj online!

Wreszcie! Odpowiedź na język inspirowany językiem miesiąca zajęła język miesiąca!

Domyślam się, że nie jest tak krótki, jak to możliwe, ale cieszę się, ponieważ moja początkowa wersja miała ponad 40 bajtów. edytuj: Miałem rację, Luis znalazł kolejny bajt do wyciśnięcia!

,iZy]	# do twice: read input and find the size of each dimension
vX>	# find the maximum along each dimension
XKx	# save this into clipboard K and delete from stack. Stack is now empty.
,	# do twice:
 @G	# push the input at index i where i=0,1.
	# MATL indexes modularly, so 0 corresponds to the second input
 K:	# push the range 1...K[1]
 KP:	# push the range 1...K[2]
 3$)	# use 3-input ) function, which uses modular indexing
	# to expand the rows and columns to the appropriate broadcasted size
]	# end of loop
+	# sum the now appropriately-sized matrices and implicitly display

Python 3 , 127 126 125 bajtów

zagrał w bajt zmieniając sum(m)nam+n

Jeszcze jeden bajt dzięki @Jonathan Frech

lambda y:[[m+n for n,m,j in Z(l)]for*l,i in Z(y)]
from itertools import*
Z=lambda y:zip(*map(cycle,y),range(max(map(len,y))))

Pobiera dane wejściowe jako listę dwóch dwuwymiarowych tablic.

• ZN trwa dwie macierze na wejściu i zwraca iterację uzyskując indeks i połączone z obu tablic wartości do momentu, gdy wskaźnik osiąga długość w największym zespołem detektorów. Zmienna indeksu nie jest dla mnie przydatna i kosztuje mnie bajtów, ale nie wiem, jak się bez niej obejść ... ( powiązane )
• Główna lambda po prostu pobiera tablice wejściowe i wywołuje tablice Zzewnętrzne i wewnętrzne. Najbardziej wewnętrzne wartości są sumowane.

Wypróbuj online!

Używanie itertools.cycleprzypomina trochę oszustwo, ale myślę, że zostałem wystarczająco ukarany samą długością wyciągu z importu :)

Jestem pewien, że można to jeszcze trochę pograć w golfa, zwłaszcza metoda iteracji, która pozostawia te bezużyteczne ii jzmienne. Byłbym wdzięczny za wszelkie wskazówki dotyczące gry w golfa, prawdopodobnie brakuje mi czegoś oczywistego.

JavaScript (ES6), 131 bajtów

Niewłaściwe narzędzie do pracy i prawdopodobnie również niewłaściwe podejście. No cóż ... ¯ \ _ (ツ) _ / ¯

a=>b=>(g=(a,b,c)=>[...Array((a[b[L='length']]?a:b)[L])].map(c))(a,b,(_,y)=>g(a[0],b[0],(_,x)=>(h=a=>a[y%a[L]][x%a[0][L]])(a)+h(b)))

Wypróbuj online!

W jaki sposób?

Funkcja pomocnicza g () tworzy tablicę, która jest tak duża jak największa tablica wejściowa ( a lub b ) i wywołuje nad nią funkcję zwrotną c :

g = (a, b, c) =>
  [...Array(
    (a[b[L = 'length']] ? a : b)[L]
  )].map(c)

Funkcja pomocniczych h () odczytuje 2D tablicy A w (x, y) o modułowej nadawania:

h = a => a[y % a[L]][x % a[0][L]]

Główny kod brzmi teraz następująco:

a => b =>
  g(a, b, (_, y) =>
    g(a[0], b[0], (_, x) =>
      h(a) + h(b)
    )
  )

Wersja rekurencyjna, 134 bajty

a=>b=>(R=[],g=x=>a[y]||b[y]?a[0][x]+1|b[0][x]+1?g(x+1,(R[y]=R[y]||[])[x]=(h=a=>a[y%a.length][x%a[0].length])(a)+h(b)):g(+!++y):R)(y=0)

Wypróbuj online!

05AB1E , 15 bajtów

2FεIζg∍ø]øεø¨}O

Wypróbuj online!

Stara wersja, 25 bajtów

é`DŠg∍)Σнg}`DŠнgδ∍€˜)ø€øO

Wypróbuj online!

Wyjaśnienie

15 bajtów:

2FεIζg∍ø] øεø¨} O - Pełny program. Pobiera dane wejściowe jako listę 3D [A, B] ze STDIN.
2F - Zastosuj dwukrotnie:
  ε - Dla każdego w [A, B]:
   Iζ - Transponuj dane wejściowe (wypełniając luki spacjami).
     g - Długość (pobierz liczbę wierszy).
      ∍ - Wydłuż bieżący element (A lub B) do wymaganej długości.
       ø - transpozycja.
        ] - Zamknij wszystkie pętle.
         ø - Transponuj ponownie.
          ε - Dla każdego wiersza w ^ (kolumna wyniku pętli):
           ø - Transponuj kolumnę.
            ¨} - Usuń ostatni element i zamknij pętlę mapy.
              O - Suma.

25 bajtów:

é`DŠg∍) }нg} `DŠнgδ∍ € ˜) ø € øO - Pełny program. Pobiera dane wejściowe jako listę 3D z STDIN.
é - Sortuj listę według długości.
 `D - Zrzuć zawartość osobno na stos, zduplikuj ToS.
   Š - Wykonaj potrójną zamianę. a, b, c -> c, a, b.
    g - Uzyskaj długość ToS.
     ∍ - Wydłuż odpowiednio krótszą listę (wysokość).
      ) Σ} - Zawiń cały stos w listę i posortuj według:
        нg - długość pierwszego elementu.
           `DŠ - Taki sam jak powyżej.
              нg - długość pierwszego elementu.
                δ∍ € ˜ - Odpowiednio przedłuż krótszą listę (na szerokość). 
                    ) ø - Zawiń stos w listę i transponuj (skompresuj).
                      € ø - Następnie skompresuj każdą listę.
                        O - Zastosuj wektoryzowane podsumowanie.

R , 136 104 103 95 93 bajtów

Grał w golfa aż 33 35 bajtów zgodnie z radą Giuseppe. Udało się uzyskać mniej niż 100 bajtów za pomocą operatora jako nazwy funkcji. Zobacz historię, aby uzyskać bardziej czytelny kod.

function(x,y,d=pmax(dim(x),dim(y)))y/d[2]/d[1]+x/d[2]/d[1]
"/"=function(x,j)apply(x,1,rep,,j)

Wypróbuj online!

K (ngn / k) , 23 bajty

{+/2{+:'(|/#:'x)#'x}/x}

Wypróbuj online!

05AB1E , 18 bajtów

éR`UvXNèy‚é`©g∍®+ˆ

Wypróbuj online!

Wyjaśnienie

éR                  # sort by length, descending
  `U                # store the shorter list in X
    v               # for each list y, index N in the longer list
     XNè            # get the nth element of the shorter list
        y‚é         # pair with y and sort by length
           `©g∍     # repeat the shorter list to the same length as the longer
               ®+   # elementwise addition of the lists
                 ˆ  # add to global list
                    # implicitly print global list

Pyth, 24 bajty

KeSmlhdQmm+Fm@@bdkQKeSlM

Wypróbuj tutaj

Wyjaśnienie

KeSmlhdQmm+Fm@@bdkQKeSlM
                    eSlMQ  Get the maximum length of (implicit) input...
KeSmlhdQ           K       ... and the maximum row length.
        mm                 For each 2d index ...
          +Fm@@bdkQ        ... get the sum of the appropriate elements.

Java 8, 172 bajty

A->B->{int m=A.length,o=A[0].length,d=B.length,u=B[0].length,l=m>d?m:d,a=o>u?o:u,r[][]=new int[l][a],$;for(;l-->0;)for($=a;$-->0;)r[l][$]=A[l%m][$%o]+B[l%d][$%u];return r;}

Wypróbuj online.

Wyjaśnienie:

A->B->{                   // Method with integer-matrix as both parameters and return-type
  int m=A.length,         //  Rows of `A`                        (we got an     M)
      o=A[0].length,      //  Columns of `A`                     (we got an     O)
      d=B.length,         //  Rows of `B`                        (we got a      D)
      u=B[0].length,      //  Columns of `B`                     (we got a      U)
      l=m>d?m:d,          //  Maximum of both rows               (we got an     L)
      a=o>u?o:u,          //  Maximum of both columns            (we got an     A)
      r[][]=new int[l][a],//  Result-matrix of size `l` by `a`   (and we got an R)
      $;                  //  Temp integer                       (which $pells? ;P)
  for(;l-->0;)            //  Loop over the rows
    for($=a;$-->0;)       //   Inner loop over the columns
      r[l][$]=            //    Set the current cell in the result-matrix to:
        A[l%m][$%o]       //     The value at {`l` modulo-`m`, `$` modulo-`o`} in `A`
        +B[l%d][$%u];     //     Plus the value at {`l` modulo-`d`, `$` modulo-`u`} in `B`
  return r;}              //  Return the result matrix

APL (Dyalog Classic) , 23 21 bajtów

↑{+⌿⍺[⍵|[0]⍳⍴⍺]}2,¨⍴¨

Wypróbuj online!

może to być jedyny raz, kiedy mam okazję skorzystać |[0]

Python 2 , 124 116 bajtów

l=len
A,B=sorted(input(),key=l)
A*=l(B)
for i in eval(`zip(A,B)`):a,b=sorted(i,key=l);a*=l(b);print map(sum,zip(*i))

Wypróbuj online!

Wyjaśnienie:

Pobiera na wejściu listę dwóch list 2-d.

l=len
A,B=sorted(input(),key=l)         # Sort inputed lists by length
A*=l(B)                           # Extend shorter list
for i in eval(`zip(A,B)`):        # Zip and remove copied references
  a,b=sorted(i,key=l)             # Sort lists in each pair (keep references)
  a*=l(b)                         # Extend shorter list
  print map(sum,zip(*i))          # Zip and sum

Python 2 , 101 97 105 bajtów

Edycja: Jeszcze raz dziękuję Dead Possum za uratowanie 4 bajtów

Edycja 2: utracono 8 bajtów, niektóre przypadki testowe nie były przekazywane

Mieszanka pomiędzy wcześniejszego rozwiązania Dead Possum (dzięki niemu!) I mojego własnego rozwiązania Python 3 .

lambda y:[map(sum,P(i))for i in P(y)]
def P(y):y=sorted(y,key=len);y[0]*=len(y[1]);return eval(`zip(*y)`)

Wypróbuj online!

Te same dane wejściowe, co moje rozwiązanie Python 3 (para dwuwymiarowych list).

Skomentowany kod:

# Iterate over the nested lists, resized & joined by P(),
# and sum the inner joined items
lambda y:[map(sum,P(i))for i in P(y)]
def P(y):
 y=sorted(y,key=len)  # Sort the two input lists by length
 y[0]*=len(y[1])      # Multiply the smallest one by the biggest one's length
                      # (The smallest list is now the previously largest one)
 return eval(`zip(*y)`)  # Return paired list elements up to the smallest list's length

Julia 0,6 , 85 83 bajtów

M\N=(((r,c),(s,d))=size.((M,N));repmat(M,s,d)+repmat(N,r,c))[1:max(r,s),1:max(c,d)]

Wypróbuj online!

(Wymień ⧻się \dzięki Jo Kinga )

Działa poprzez powtarzanie każdej macierzy poziomo i pionowo, aby oba miały ten sam rozmiar (iloczyn rozmiarów wierszy x iloczyn rozmiarów kolumn), dodając je i wyodrębniając z nich właściwy region. (Wejścia wektorów wierszy lub wejścia wektorów kolumn wymagają reshapewywołania, aby były rzutowane jako tablice dwuwymiarowe, co, jak zakładam, jest w porządku, ponieważ pytanie określa „Dodanie implementacji dla tablic dwuwymiarowych” i „Dane wejściowe i wyjściowe mogą być odbierane przez dowolne rozsądne środki. Ich format jest jak zwykle elastyczny. ”)