前書き

2つの空でない整数配列、たとえばA = [0 3 2 2 8 4]およびB = [7 8 7 2]を考えます。それらに対してアライメントの追加を実行するには、次のようにします。

1. 合計長さlcm（length（A）、length（B））になるように各配列を十分に繰り返します。ここで、lcmは最小公倍数を表します。

   A -> [0 3 2 2  8 4][0 3  2 2 8 4]
   B -> [7 8 7 2][7 8  7 2][7 8 7 2]
   

2. 繰り返された配列で要素ごとの加算を実行し、いずれかがカットされているすべての位置で結果をカットします。

   A -> [0  3 2 2   8  4][0 3  2  2  8 4]
   B -> [7  8 7 2][ 7  8  7 2][7  8  7 2]
     -> [7 11 9 4][15 12][7 5][9 10 15 6]
   

3. この配列の配列が結果です。

タスク

入力は整数の2つの空ではない配列であり、出力は上記で定義されたように、配列の加算の結果となります。入力および出力は、任意の合理的な形式にすることができます。加算を実行するときに整数オーバーフローを心配する必要はありません。

ルールとスコアリング

完全なプログラムまたは関数を作成できます。最も低いバイトカウントが優先されます。

テストケース

[1] [4] -> [[5]]
[1,2,-3,-4] [15] -> [[16],[17],[12],[11]]
[0,-4] [2,1,0,-3] -> [[2,-3],[0,-7]]
[0,3,2,2,8,4] [7,8,7,2] -> [[7,11,9,4],[15,12],[7,5],[9,10,15,6]]
[18,17,16] [-1,-2,-3,-4] -> [[17,15,13],[14],[16,14],[15,13],[15],[16,14,12]]
[18,17,16,15] [-1,-2,-3,-4] -> [[17,15,13,11]]
[1,1,1,1,1] [6,5,6,5,6,5,6,2,1] -> [[7,6,7,6,7],[6,7,3,2],[7],[6,7,6,7,6],[7,3,2],[7,6],[7,6,7,6,7],[3,2],[7,6,7],[6,7,6,7,3],[2],[7,6,7,6],[7,6,7,3,2]]
[1,1,1,1,1,1] [6,5,6,5,6,5,6,2,1] -> [[7,6,7,6,7,6],[7,3,2],[7,6,7],[6,7,6,7,3,2]]
[1,1,1,1,1,1,1] [6,5,6,5,6,5,6,2,1] -> [[7,6,7,6,7,6,7],[3,2],[7,6,7,6,7],[6,7,3,2],[7,6,7],[6,7,6,7,3,2],[7],[6,7,6,7,6,7,3],[2],[7,6,7,6,7,6],[7,3,2],[7,6,7,6],[7,6,7,3,2],[7,6],[7,6,7,6,7,3,2]]

JavaScript（ES6）、101 99バイト

入力を2つの配列として受け取ります。文字列を返します。

f=(a,b,j=0,s='')=>a.map((v,i)=>(s+=i*j?' ':s&&'][',s+=b[j]+v,j=++j%b.length))|j?f(a,b,j,s):`[${s}]`

使い方

2番目の配列への別のポインターを更新しながらa、ポインターで最初の配列を反復処理しiます。合計は出力文字列に追加されます。またはのたびにセパレータが挿入されます。反復の開始時と終了時に正確に戻るまで、このプロセスを繰り返します。jba[i] + b[j]si == 0j == 0jb

注：場合|、オペレータが適用される、a.map(...)のいずれかに強制されるNaN（場合aまたは現在の値以上の元素を含有する）j（場合はa正確に1つの要素を含んでいます）。したがって、a.map(...)|j == jすべての場合において、ここで使用しても安全です。

テストケース

f=(a,b,j=0,s='')=>a.map((v,i)=>(s+=i*j?' ':s&&'][',s+=b[j]+v,j=++j%b.length))|j?f(a,b,j,s):`[${s}]`

console.log(f([1], [4]));
console.log(f([1,2,-3,-4], [15]));
console.log(f([0,-4], [2,1,0,-3]));
console.log(f([0,3,2,2,8,4], [7,8,7,2]));
console.log(f([18,17,16], [-1,-2,-3,-4]));
console.log(f([18,17,16,15], [-1,-2,-3,-4]));
console.log(f([1,1,1,1,1], [6,5,6,5,6,5,6,2,1]));
console.log(f([1,1,1,1,1,1], [6,5,6,5,6,5,6,2,1]));
console.log(f([1,1,1,1,1,1,1], [6,5,6,5,6,5,6,2,1]));

Haskell、84 79バイト

a#b=a%b where(c:d)%(e:f)|(x:y)<-d%f=(c+e:x):y;[]%[]=[[]];c%[]=[]:c%b;_%d=[]:a%d

私の最初のバージョンはより読みやすいレイアウトで同じでした：

a#b=a%b where
 (c:d)%(e:f)|(x:y)<-d%f=(c+e:x):y
 []%[]=[[]]
 c%[]=[]:c%b
 _%d=[]:a%d

ローカル定義を使用して、およびに(%)余分な引数を与える必要を回避aしbます。驚くべきことに、これは、@ nimiとほぼ同時に提供されたソリューションとほぼ同じであり、ローカル定義に1行のみを使用するという考えを持ちました。

使用法：

*Main> [0,3,2,2,8,4] # [7,8,7,2]
[[7,11,9,4],[15,12],[7,5],[9,10,15,6]]

PHP、126120バイト

function($a,$b){do{$c[$j][]=$a[$i%$x=count($a)]+$b[$i%$y=count($b)];++$i%$x&&$i%$y?:$j++;}while($i%$x|$i%$y);return$c;};

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

結果の配列の配列を返す無名関数。

基本的に、両方の配列の内容をループ処理し、配列の長さでイテレータを改造して、「コピー」をシミュレートします。配列から各値を取得し、それらを合計しての配列に追加します$c。入力配列の1つ（チャレンジの観点から分割）の最後に到達すると、の新しい配列への割り当てを開始し$cます。

理由do while私たちの条件はに基づいているため、ループがある$i時に開始します、0。最初に条件がチェックされるループを使用すると、ループは実行されません

両方の配列の最後に同時に到達すると、合計が終了します。これは、LCMを意味します。

Haskell、87 84バイト

a#b=a%b where[]%[]=[[]];(e:f)%(g:h)=f%h!(e+g);e%[]=[]:e%b;_%g=[]:a%g
(m:n)!l=(l:m):n

使用例：[0,3,2,2,8,4] # [7,8,7,2]- > [[7,11,9,4],[15,12],[7,5],[9,10,15,6]]。

単純な再帰。基本ケース：両方のリストは空です。そのうちの1つだけが空の場合は、フルバージョンで再起動し、出力で新しいクラスターを開始します。何も空でない場合、合計をfrom要素に追加します。

@Christian Sieversの回答もご覧ください。これはほとんど同じで、数秒前に投稿されました。

オクターブ、113バイト

@(a,b)mat2cell(sum([repmat(a,1,(L=lcm(A=numel(a),B=numel(b)))/A);repmat(b,1,L/B)]),1,diff(unique([0:A:L,0:B:L])))

この関数を直接呼び出すと、括弧内に配置して（@（a、b）...）（[1 2 3 4]、[6 4 5]）として呼び出します。

CJam、30バイト

{Sf*Laf+_s,f*:.+La/0=S2*a-Sa/}

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

入力をリストのペアとして受け取ります。

説明

アイデアは、整列された配列の終了位置、および配列のどこにブレークを挿入する必要があるかを示すマーカーを（短い文字列の形式で）入力配列に挿入することです。これにより、LCMを計算する必要がなくなります。

Sf*    e# Riffle each list with spaces. These are just place holders, so that having
       e# an array-end marker between two elements doesn't misalign subsequent elements.
Laf+   e# Append an empty string to each list. This is the array-end marker.
_s,    e# Convert the pair of lists to a string and get its length. This is always
       e# greater than the number of elements in either input.
f*     e# Repeat either array that many times. This is definitely more than necessary
       e# to reach the LCM (since multiplying by the length of the other list always
       e# gives a common multiple).
:.+    e# Pairwise addition of the list elements. There are four cases:
       e# - Both elements are numbers, add them. This is the actual addition
       e#   we need for the problem.
       e# - Both elements are spaces. This is just a regular position between
       e#   list elements.
       e# - One is a space, one is empty: the result is a single space, and
       e#   this marks a position where one of the arrays ended, which means
       e#   we need to split here.
       e# - Both elements are empty. This happens at the LCM of both list lengths
       e#   and indicates where we need to stop the output.
La/0=  e# Split the input around empty strings and discard everything except
       e# the first chunk.
S2*a-  e# Remove the double-space strings, we no longer need them.
Sa/    e# Split the list around single spaces.

ゼリー、21 20 18バイト

ṁ€L€æl/$S
J€ỊÇœṗÇḊ

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

使い方

ṁ€L€æl/$S  Helper link. Argument [X, Y] (arrays of integers).

       $   Combine the two links to the left into a monadic chain.
  L€       Length each; yield the lengths of X and Y.
    æl/    Reduce by least common multiple.
ṁ€         Mold each; cyclically repeat the elements of X and Y to extend them
           to length lcm(length(X), length(Y)).
        S  Compute the sum of the extended X and Y arrays.

J€ỊÇœṗÇḊ   Main link. Argument [A, B] (arrays of integers).

J€         Indices each; replace A and B by the arrays of there 1-based indices.
  Ị        Insignificant; map 1 to itself, all other indices to 0.
   Ç       Apply the helper link to the result.
           This yield a Boolean array with a 1 (or 2) at all indices where a new
           repetition of A or B (or both) begins.
      Ç    Apply the helper link to [A, B].
    œṗ     Partition; break the result to the right at truthy elements (1 or 2) in
           the result to the right.
       Ḋ   Dequeue; remove the first element of the partition (empty array).

Pythonの3.5 - （146 137 134 130 + 12）= 142のバイト

import math
def s(a,b):
 l,k,*r=map(len,[a,b])
 for i in range(l*k//math.gcd(l,k)):
  r+=a[i%l]+b[i%k],
  if i%k==k-1or i%l==l-1:print(r);r=[]

forループ全体を1行に入れる方法がわかりません。

編集：

• 9バイトを節約してくれたzgarbに感謝します！
• 3バイトを節約してくれたvaultahに感謝します！
• mathmandanが 5バイト節約してくれてありがとう！

Python 2、119バイト

a=input()
i,v,l=0,list(a),len
while 1:q=l(v[0])>l(v[1]);print map(sum,zip(*v)[i:]);i=l(v[q]);v[q]+=a[q];1/(i-l(v[q^1]))

入力をコンマで区切られた2つのタプルとしてstdinから取得し、結果のリストをstdoutに出力します。許可されZeroDivisionErrorているように見えるため、例外を発生させて終了します。

たとえば、入力がの(0, 3, 2, 2, 8, 4), (7, 8, 7, 2)場合、プログラムは印刷します

[7, 11, 9, 4]
[15, 12]
[7, 5]
[9, 10, 15, 6]

stdoutへの例外トレースバック。

J、34 32バイト

[:(<;.1~*)/[:+/*.&#$&>,:&(;2>#\)

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

説明

[:(<;.1~*)/[:+/*.&#$&>,:&(;2>#\)  Input: array A (LHS), array B (RHS)
                             #\   Length of each prefix of A and B
                           2>     Less than 2
                          ;       Link each with A and B
                      ,:&         Pair them
                  #               Length of A and B
               *.&                LCM of the lengths
                    &>            For each box
                   $              Reshape it to the LCM of the lengths
           [:+/                   Reduce by addition
[:        /                       Reduce by
        *                           Sign of RHS
   <;.1~                            Box each partition of LHS

Haskell、166バイト

これはおそらく最もエレガントなアプローチではありません。基本的に、関数?は必要な長さのリストを%合計で1つ作成し、この合計を再び切り詰めます。!これら2つをマージする最後の関数です。

l=length
a?b=take(lcm(l a)$l b)$zipWith(+)(cycle a)$cycle b
l%(i:ind)|l==[]=[]|1>0=take i l:(drop i l)%(map(+(-i))ind)
a!b=(a?b)%[k|k<-[1..],k`mod`l a<1||k`mod`l b<1]

[PHP]、183 152 135バイト

function O($A,$B){while($f<2){$O[$k][]=$A[+$i]+$B[+$j];$f=0;isset($A[++$i])?:$i=!++$k|!++$f;isset($B[++$j])?:$j=!++$k|!++$f;}return$O;}

素敵なバージョン：

function O($A,$B)
{
    while($f<2) {
        $O[$k][]=$A[+$i]+$B[+$j];
        $f=0;
        isset($A[++$i])?:$i=!++$k|!++$f;
        isset($B[++$j])?:$j=!++$k|!++$f;
    }

    return$O;
}

出力：

array (size=4)
  0 => 
    array (size=4)
      0 => int 7
      1 => int 11
      2 => int 9
      3 => int 4
  1 => 
    array (size=2)
      0 => int 15
      1 => int 12
  2 => 
    array (size=2)
      0 => int 7
      1 => int 5
  3 => 
    array (size=4)
      0 => int 9
      1 => int 10
      2 => int 15
      3 => int 6

PowerShell、147 145バイト

param($a,$b)$o=@{};do{$o[+$j]+=,($a[+$i%($x=$a.count)]+$b[$i++%($y=$b.count)]);if(!($i%$x-and$i%$y)){$j++}}until(($x,$y|?{!($i%$_)}).count-eq2)$o

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

（ゴルフの提案を歓迎します。おそらく、これから絞り出せる10〜15バイトがあると思います。）

入力を@(...)コマンドライン引数として（構文を使用して）2つの明示的な配列として受け取ります。PowerShellの多次元配列は奇妙になり、これはより一貫性があるため、結果の配列のハッシュテーブルを返します。いくつかの初期変数を設定してから、再度do/ untilループに入ります。条件は、配列のlcmがcountsになるまで$iです。

各ループの反復では、対応する値$aと$b値を一緒,(...)に追加$oし、適切なspotのハッシュテーブルに追加する前に配列として扱い$jます。配列のカプセル化は、算術的な加算を防ぐために必要+=です。これにより、代わりに配列の連結がオーバーロードされます。次に、$xand $y（カウント）を条件にして、配列の端にいるかどうかを判断します$j。そうであれば、をインクリメントします。

最後$oに、パイプラインに残り、出力は暗黙的です。
（注：PowerShellがデフォルトWrite-Outputでハッシュテーブルを列挙する方法により、これは「後方」に出力される傾向があります。たとえば、結果の0番目の配列は出力の「下部」にあります。ハッシュ自体は問題ありません。たとえば、このコードをリターン変数にカプセル化する場合はうまく使用されます...印刷すると奇妙に見えます）

$ xと$ yを別々ではなく配列のインデックスに移動して2バイトを節約しました（2つのセミコロンを保存しました）。

Python 2、113バイト

a,b=input()
i=m=n=0;r=[]
while(not i)+m+n:r+=[[]]*(not m*n);r[-1]+=[a[m]+b[n]];i+=1;m=i%len(a);n=i%len(b)
print r

Python 3.5、210 176 173 169 158バイト

def f(a,b):
 x=[];e=f=0              
 while 1:
  if e==len(a):         
   print(x);x=[];e=0;
   if f==len(b):break
  if f==len(b):print(x);x=[];f=0
 x+=a[e]+b[f],;e+=1;f+=1

2つのリストを入力として受け取り、すべてのリストを印刷します。

それは私の最初の答えであり、私はまだゴルフをする方法を知りません。私が使用した基本的な考え方は、各リストに2つのカウンターを追加し、分割された値と、追加された値が追加される現在のリストを示すことです。分割が発生するとすぐに、現在のリストを印刷して、新しい空のリストを作成します。

• 34バイトを節約：Dennisと TimmyDに感謝
• 3バイト節約：len（a）とlen（b）にcとdを使用していましたが、それらは役に立たなかったことが判明しました
• 4バイトを保存：orlpのおかげで、不要な括弧を削除
• 11バイトを節約：一部のブロックを再配置し、それらを縮小しました

ラケット373バイト

(let*((lg length)(fl flatten)(ml make-list)(t rest)(r reverse)(m modulo)(o cons)(ln(lg l))(jn(lg j))(c(lcm ln jn))(l2(fl(ml(/ c ln)l)))
(j2(fl(ml(/ c jn)j)))(ll(for/list((a l2)(b j2))(+ a b))))(let p((ll ll)(ol '())(tl '())(n 0))(cond[(empty? ll)(t(r(o(r tl)ol)))]
[(or(= 0(m n ln))(= 0(m n jn)))(p(t ll)(o(r tl)ol)(take ll 1)(+ 1 n))][(p(t ll)ol(o(first ll)tl)(+ 1 n))])))

ゴルフをしていない：

(define(f l j)
  (let* ((ln (length l))
         (jn (length j))
         (c (lcm ln jn))
         (l2 (flatten (make-list (/ c ln) l)))
         (j2 (flatten (make-list (/ c jn) j)))
         (ll (for/list ((a l2)(b j2))
               (+ a b))))

    ; TO CUT LIST INTO PARTS: 
    (let loop ((ll ll)
               (ol '())
               (templ '())
               (n 0))
      (cond
        [(empty? ll) 
         (rest (reverse (cons (reverse templ) ol)))]
        [(or (= 0 (modulo n ln))
             (= 0 (modulo n jn)))
         (loop (rest ll)
               (cons (reverse templ) ol)
               (list (first ll))
               (add1 n))]
        [(loop (rest ll)
               ol
               (cons (first ll) templ)
               (add1 n))]))))

テスト：

(f '[1]  '[4])
(f '[1 2 -3 -4] '[15])
(f '[0 3 2 2 8 4]  '[7 8 7 2])

出力：

'((5))
'((16) (17) (12) (11))
'((7 11 9 4) (15 12) (7 5) (9 10 15 6))

Clojureは、280の 206バイト

(fn[a b](let[A(count a)B(count b)Q quot](map #(map last %)(partition-by first(take-while #((% 0)2)(map-indexed(fn[i s][[(Q i A)(Q i B)(or(= i 0)(>(mod i A)0)(>(mod i B)0))]s])(map +(cycle a)(cycle b))))))))

まあこれはもっと理にかなっています。要素ごとの合計を生成し、位置メタデータを追加し、まだ繰り返していない間を取り、合計値を各パーティションに入れます。

(def f (fn[a b]
         (let[A(count a)B(count b)Q quot]
           (->> (map +(cycle a)(cycle b))
                (map-indexed (fn [i s][[(Q i A)(Q i B)(or(= i 0)(>(mod i A)0)(>(mod i B)0))]s]))
                (take-while #((% 0)2))
                (partition-by first)
                (map #(map last %))))))

オリジナル： これを改善したいと思っていますが、これは私が今持っている最もソートされたものです。

(fn[a b](let [C cycle o count c(take-while #(or(=(% 0)0)(>(% 1)0)(>(% 2)0))(map-indexed(fn[i[A B]][i(mod i(o a))(mod i(o b))(+ A B)])(map(fn[& v]v)(C a)(C b))))](map #(map last %)(partition-by first(map(fn[p c][p(last c)])(reductions + (map #(if(or(=(% 1)0)(=(% 2)0))1 0)c))c)))))

非ゴルフで詳細：

(def f (fn[a b]
         (let [c(->> (map (fn[& v]v) (cycle a) (cycle b))
                     (map-indexed (fn[i[A B]][i (mod i(count a)) (mod i(count b)) (+ A B)]))
                     (take-while #(or(=(% 0)0)(>(% 1)0)(>(% 2)0))))]
           (->> (map (fn[p c][p(last c)]) (reductions +(map #(if(or(=(% 1)0)(=(% 2)0))1 0)c)) c)
                (partition-by first)
                (map #(map last %))))))

コレクションの無限のサイクルを「マージ」することによって開始aし、b両方の配列が再びインデックス0から開始するまで、コレクション内の各要素のインデックスにメタデータを追加するには、かかります。

このコレクションcは、パーティションデータ（1と0の累積合計）とマージされ、パーティション分割され、最後の要素（アイテムの合計）が選択されます。

大幅な改善には、まったく異なるアプローチが必要だと思います。

PHP、150 121 119バイト

function($a,$b){while($i<2|$x|$y)$r[$k+=!($x=$i%count($a))|!$y=$i++%count($b)][]=$a[$x]+$b[$y];array_pop($r);return$r;}

無名関数は入力を配列として受け取ります。

壊す

while($i<2|$x|$y)   // loop while either $a or $b has NO cut
    $r[
                // if either $a or $b has a cut, increment $k; post-increment $i
        $k+=!($x=$i%count($a))|!$y=$i++%count($b)
                // append current $a + current $b to $r[$k]
    ][]=$a[$x]+$b[$y];
array_pop($r);  // $r has one element too much; remove it
return$r;

C ++ 14、206バイト

名前ジェネリックラムダ、必要な入力容器としてP、Q出力容器Rのようになりvector<vector<int>>。

[](auto P,auto Q,auto&R){R.clear();auto a=P.begin(),b=Q.begin(),x=P.end(),y=Q.end();auto A=a,B=b;do{R.emplace_back();while(a!=x&&b!=y)R.back().push_back(*a+++*b++);a=a==x?A:a;b=b==y?B:b;}while(a!=A||b!=B);}

ゴルフをしないと使用法：

#include<vector>
#include<iostream>

using namespace std;

auto f=
[](auto P,auto Q,auto&R){
 R.clear();               //just clear the output to be sure
 //a and b are the iterators, x and y is the end
 auto a=P.begin(),b=Q.begin(),x=P.end(),y=Q.end();
 //just some abbreviations for .begin()
 auto A=a,B=b;
 do{
  R.emplace_back();      //add new vector
  while(a!=x&&b!=y)      //while not at the end of one vector
   R.back().push_back(*a+++*b++);  //add the pointed elements and advance
  a=a==x?A:a;            //reset if at the end   
  b=b==y?B:b;
 }while(a!=A||b!=B);     //if both were resetted, then finish
}
;


int main(){
 vector<int> A = {0, 3, 2, 2, 8, 4};
 vector<int> B = {7, 8, 7, 2};
 vector<vector<int>> R;
 f(A,B,R);
 for (auto c:R){
  for (int x:c)
   cout << x << ", ";
  cout << endl;
 }
 cout << endl;
}

Mathematica 112バイト

これはおそらく改善される可能性があります。アイデアは、各入力配列の長さを変更するカウンターiの賃貸人を追跡するために使用される2番目の要素を持つ2D配列を作成することです。

Split[Table[{#[[1,(m=Mod[i,d=Length/@#,1])[[1]]]]+#[[2,m[[2]]]],Min@m},{i,LCM@@d}],#2[[2]]>#1[[2]]&][[;;,;;,1]]&

使用法

%@{{0,3,2,2,8,4},{7,8,7,2}}

JavaScript（ES6）、131バイト

(a,b,g=(r,[n,...d]=a,[m,...e]=b,s=[])=>1/n?1/m?g(r,d,e,[...s,n+m]):g([...r,s],[n,...d]):1/m?g([...r,s],a,[m,...e]):[...r,s])=>g([])

わずかに未使用：

(a,b,r=[],[n,...d]=a,[m,...e]=b,s=[])
=>1/n?1/m?f(a,b,r,d,e,[...s,n+m])
         :f(a,b,[...r,s],[n,...d],b,[])
     :1/m?f(a,b,[...r,s],a,[m,...e],[])
         :[...r,s]

• アレイの両方の場合dとe数字を含む、第一の数の和がに追加されs、残りの要素が再帰的に処理されます
• 配列の1つに数値が含まれている場合、合計の配列がs結果に追加されr、他の配列は初期配列にリセットされます
• 両方の配列が空の場合、最後の合計が追加された結果が返されます。

悲しいことに、このソリューションには@Arnauldのような冷酷な効率はありませんが、少なくとも私はそれが美しいソリューションだと思います。