この課題は、2018年5月の「Language of the Month」イベントの一部として、MATL言語の機能の一部に関連しています。

前書き

MATLでは、多くの2入力機能が働く要素単位で放送。これは次のことを意味します。

• 要素単位（またはベクトル化）：関数は、サイズが一致する2つの配列を入力として受け取ります。関数によって定義された操作は、対応するエントリの各ペアに適用されます。たとえば、修正後表記を使用する場合：

  [2 4 6] [10 20 30] +
  

  与え ouputをを

  [12 24 36]
  

  これは多次元配列でも機能します。表記[1 2 3; 4 5 6]は2× 3配列（行列）を表します

  1 2 3
  4 5 6
  

  これは2、最初の次元（垂直）と32番目（水平）に沿ったサイズを持ちます。例えば

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

  与える

  [20 80 180; 120 300 560]
  

• ブロードキャストまたは（シングルトン拡張）：2つの入力配列のサイズは一致しませんが、一致しない各次元では、配列の1つにsizeがあり1ます。この配列は、サイズを一致させるために、他の次元に沿って暗黙的に複製されます。そして、上記のように要素ごとに操作が適用されます。たとえば、サイズが1× 2と3×の2つの入力配列を考えます1。

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

  ブロードキャストのおかげで、これは

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

  そしてそれは与える

  [10 20; 5 10; 2 4]
  

  同様に、サイズが3× 2と3×の場合1（ブロードキャストは2番目の次元にのみ作用するようになりました）、

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

  与える

  [19 18; 27 26; 35 34]
  

  次元の数は異なる場合もあります。たとえば、サイズが3×2と3×1×5の入力は互換性があり、3×2×5の結果が得られます。実際、サイズ3×2は3×2×1と同じです（暗黙的に後続のシングルトン次元が多数あります）。

  一方、最初の次元に沿ったサイズはandであり、それらは等しくなく、いずれも等しくないため、一対の2× 配列2と3× 1配列はエラーになります。231

モジュラー放送の定義

モジュラーブロードキャストは、サイズが一致しないものがない場合でも機能するブロードキャストの一般化です1。たとえば、次の2× 2および3× 1配列を関数の入力として考えます+。

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

規則は次のとおりです。各次元について、その次元に沿って小さい配列は、他の配列のサイズと一致するようにモジュール式（循環）に複製されます。これは、上記と同等になります

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

結果で

[12 14; 26 28; 32 34]

2番目の例として、

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

一般に、サイズがa× bとc×の入力は、サイズが× dの結果をmax(a,b)返しmax(c,d)ます。

チャレンジ

上記で定義したモジュラーブロードキャストを使用して、2次元配列の追加を実装します。

配列は長方形（不規則ではない）で、負でない整数のみを含み、少なくとも1各次元でサイズを持ちます。

追加規則：

• どんな合理的な手段でも入力と出力を取ることができます。それらの形式は通常どおり柔軟です。

• すべてのプログラミング言語で、プログラムまたは機能が許可されます。標準的な抜け穴は禁止されています。

• バイト単位の最短コードが優先されます。

テストケース

以下は;、行セパレータとして使用します（上記の例のように）。各テストケースには、2つの入力が表示され、次に出力が表示されます。

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

ゼリー、10バイト

ṁ€ZL$Z€Ɗ⁺S

マトリックスペア（行の2つの配列）を入力として受け取り、マトリックスを返します。

オンラインでお試しください！

使い方

ṁ€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.

炭、25 23バイト

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

オンラインでお試しください！リンクは、コードの詳細バージョンです。入力を3次元配列として受け取ります。説明：

Ａθ

すべてを入力してください。

    θ                   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バイト

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

オンラインでお試しください！

最後に！今月の言語に触発されたチャレンジが今月の言語で答えられるのにたった1週間しかかかりませんでした！

私の推測では、これは可能な限り短くはありませんが、初期バージョンが40バイトを超えていたので十分満足しています。編集：私は正しかった、ルイスは絞り出すために別のバイトを見つけました！

,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バイト

に変更するsum(m)ことにより、バイトをゴルフm+n

@Jonathan Frechのおかげでもう1バイト

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

入力を2つの2次元配列のリストとして受け取ります。

• Zラムダは、入力として二つの配列を受け取り、インデックスを返すイテレータを返し、インデックスが最大配列の長さに達するまで、両方の配列から値を合併しました。インデックス変数は、私には有用ではありませんし、バイト私がかかりますが、私はそれなしで行う方法がわからない...（関連します）
• メインラムダは、入力配列を受け取りZ、外側および内側の配列を呼び出します。最も内側の値が加算されます。

オンラインでお試しください！

使用itertools.cycleすることは少し不正行為のように感じますが、インポートステートメントの長さによって十分に罰せられたと思います:)

私は確かにこれは、より多くのいくつか、これらの役に立たないの葉、特に反復法golfedできてるiとj変数を。それをゴルフする方法についてのヒントに感謝しますが、おそらく明らかな何かを見逃しています。

JavaScript（ES6）、131バイト

仕事に適したツールではなく、おそらく適切なアプローチでもありません。まあ...¯\ _（ツ）_ /¯

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

オンラインでお試しください！

どうやって？

ヘルパー関数g（）は、最大の入力配列（aまたはb）と同じ大きさの配列を作成し、その上でコールバック関数cを呼び出します。

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

ヘルパー関数h（）は、モジュラーブロードキャストで（x、y）の2D配列aを読み取ります。

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

メインコードは次のようになります。

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

再帰バージョン、134バイト

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)

オンラインでお試しください！

05AB1E、15バイト

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

オンラインでお試しください！

古いバージョン、25バイト

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

オンラインでお試しください！

説明

15バイト：

2FεIζg∍ø]øεø¨} O –完全なプログラム。STDINから3D [A、B]リストとして入力を取得します。
2F – 2回適用：
  ε– [A、B]のそれぞれについて：
   Iζ–入力を転置します（ギャップをスペースで埋めます）。
     g –長さ（行数を取得）。
      ∍–現在のアイテム（AまたはB）を必要な長さに延長します。
       ø–転置。
        ] –すべてのループを閉じます。
         ø–もう一度転置します。
          ε– ^の各行（ループ結果の列）：
           ø–列を転置します。
            ¨} –最後の要素を削除して、map-loopを閉じます。
              O –合計。

25バイト：

é`DŠg∍）Σнg} `DŠнgδ∍€〜）ø€øO–完全なプログラム。STDINから3Dリストとして入力を受け取ります。
é–リストを長さ順に並べ替えます。
 `D –コンテンツを個別にスタックにダンプし、ToSを複製します。
   Š–トリプルスワップを実行します。a、b、c-> c、a、b
    g – ToSの長さを取得します。
     ∍–短いリストを（高さで）適宜拡張します。
      ）Σ} –スタック全体をリストにラップし、以下でソートします。
        нg–最初のアイテムの長さ。
           `DŠ–上記と同じ。
              нg–最初の要素の長さ。
                δ∍€〜–それに応じて短いリストを（幅で）拡張します。 
                    ）ø–スタックをリストにラップし、転置（zip）します。
                      €ø-次に、各リストを圧縮します。
                        O –ベクトル化された合計を適用します。

R、136104103 95 93バイト

ジュゼッペのアドバイスを受けて、なんと33 35バイトを駆け抜けました。演算子を関数名として使用して、100バイト未満を取得できました。より読みやすいコードの履歴を参照してください。

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)

オンラインでお試しください！

K（ngn / k）、23バイト

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

オンラインでお試しください！

05AB1E、18バイト

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

オンラインでお試しください！

説明

é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バイト

KeSmlhdQmm+Fm@@bdkQKeSlM

ここで試してみてください

説明

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バイト

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

オンラインでお試しください。

説明：

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バイト

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

オンラインでお試しください！

これは私が使用する機会を得ることができる唯一の時間である可能性があります |[0]

パイソン2、124の 116バイト

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

オンラインでお試しください！

説明：

2つの2次元リストのリストを入力として受け取ります。

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

パイソン2、101の 97 105バイト

編集：4バイトを保存してくれたDead Possumに感謝（再び！）

編集2：8バイトを失った、いくつかのテストケースが合格していませんでした

Dead Possumの以前のソリューション（彼に感謝！）と私自身の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)`)

オンラインでお試しください！

私のPython 3ソリューションと同じ入力（2次元リストのペア）。

コメント付きコード：

# 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

ジュリア0.6、85の 83バイト

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

オンラインでお試しください！

（ジョー・キングのおかげで交換⧻してください）\

各マトリックスが同じサイズ（行サイズの積x列サイズの積）になるように水平および垂直に各マトリックスを繰り返し、それらを加算して、そこから正しい領域を抽出します。（行ベクトル入力または列ベクトル入力は、reshape2次元配列としてキャストするための呼び出しを必要としますが、質問では「2次元配列の実装加算」と「入力および出力はすべて合理的な手段です。それらの形式は通常どおり柔軟です。」）