Introducción

Considere dos matrices enteras no vacías, digamos A = [0 3 2 2 8 4] y B = [7 8 7 2] . Para realizar la adición de alineación en ellos, hacemos lo siguiente:

1. Repita cada matriz suficientes veces para tener una longitud total mcm (longitud (A), longitud (B)) . Aquí mcm representa el mínimo común múltiplo.

   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. Realice la suma por elementos en las matrices repetidas y corte el resultado en cada posición donde haya un corte en cualquiera de ellas.

   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. Esta matriz de matrices es su resultado.

La tarea

Sus entradas son dos matrices no enteras de enteros, y su salida será el resultado de su adición de alineación, como se definió anteriormente. Las entradas y salidas pueden estar en cualquier formato razonable. No tiene que preocuparse por el desbordamiento de enteros al realizar la adición.

Reglas y puntaje

Puede escribir un programa completo o una función. El conteo de bytes más bajo gana.

Casos de prueba

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

Toma la entrada como 2 matrices. Devuelve una cadena.

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

Cómo funciona

Repetimos la primera matriz acon un puntero imientras actualizamos otro puntero jen la segunda matriz b. Las sumas a[i] + b[j]se agregan a la cadena de salida s. Se inserta un separador cada vez i == 0o j == 0. Repetimos este proceso hasta jque regrese exactamente al principio o bal final de una iteración.

Nota: Cuando |se aplica el operador, a.map(...)se coacciona a NaN(si acontiene más de un elemento) o al valor actual de j(si acontiene exactamente un elemento). Por lo tanto, a.map(...)|j == jen todos los casos y es seguro de usar aquí.

Casos de prueba

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 bytes

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

Mi primera versión fue la misma en un diseño más legible:

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

Usar una definición local para evitar tener que dar (%)argumentos adicionales para ay b. Sorprendentemente, esta es casi la misma solución dada casi al mismo tiempo que @ nimi, de quien tomé la idea de usar solo una línea para la definición local.

Uso:

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

PHP, 126 120 bytes

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

Pruébalo aquí!

Función anónima que devuelve la matriz resultante de matrices.

Esencialmente, recorremos los contenidos de nuestros dos conjuntos, modificando nuestro iterador por la longitud del conjunto para simular 'copiarlos'. Tomando cada uno de los valores de las matrices, los sumamos y los agregamos a una matriz en$c . Si llegamos al final de una de nuestras matrices de entrada (una división, en términos del desafío), comenzamos a asignar una nueva matriz en $c.

El motivo de la do while bucle es porque nuestra condición se basa en $i, que comienza en 0. Si usamos un bucle donde se verifica la condición al principio, el bucle no se ejecutará

Solo finalizamos la suma una vez que llegamos al final de ambas matrices al mismo tiempo, lo que implicaría el LCM.

Haskell, 87 84 bytes

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

Ejemplo de uso: [0,3,2,2,8,4] # [7,8,7,2] -> [[7,11,9,4],[15,12],[7,5],[9,10,15,6]].

Recurrencia simple Caso base: ambas listas están vacías. Si solo uno de ellos está vacío, reinicie con una versión completa e inicie un nuevo clúster en la salida. Si ninguno está vacío, anteponga la suma al elemento from.

También eche un vistazo a la respuesta de @Christian Sievers , que es casi idéntica y se publicó unos segundos antes.

Octava, 113 bytes

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

esta función se puede llamar directamente para llamarla, colocarla entre paréntesis y llamar como (@ (a, b) ...) ([1 2 3 4], [6 4 5])

CJam , 30 bytes

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

Pruébalo en línea!

Toma datos como un par de listas.

Explicación

La idea es insertar algunos marcadores en las matrices de entrada (en forma de cadenas cortas) que indican dónde termina la matriz alineada y dónde necesitamos insertar los saltos en las matrices. De esta forma podemos evitar tener que calcular el 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.

Gelatina , 21 20 18 bytes

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

Pruébalo en línea!

Cómo funciona

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

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

No puedo entender cómo poner todo el bucle for en una línea.

Ediciones:

• Gracias zgarb por guardar 9 bytes!
• Gracias vaultah por guardar 3 bytes!
• Gracias mathmandan ahorrando 5 bytes!

Python 2, 119 bytes

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

Toma la entrada de stdin como dos tuplas separadas por comas, emite las listas resultantes a stdout. Termina planteando la ZeroDivisionErrorexcepción, ya que parece estar permitido .

Por ejemplo, si la entrada es (0, 3, 2, 2, 8, 4), (7, 8, 7, 2), el programa imprimirá

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

a stdout y la excepción rastrea a stderr.

J , 34 32 bytes

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

Pruébalo en línea!

Explicación

[:(<;.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 bytes

Probablemente este no sea el enfoque más elegante: Básicamente, la función ?crea una lista de la longitud necesaria con los suums, y %está recortando esta suma nuevamente. !es la función final que combina esos dos.

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 bytes

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

Buena versión:

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

Salida:

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

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

Pruébalo en línea!

(Se aceptan sugerencias de golf. Siento que probablemente hay otros 10 a 15 bytes que se pueden extraer de esto. )

Toma datos como dos matrices explícitas (con la @(...)sintaxis) como argumentos de línea de comandos. Devuelve una tabla hash de las matrices resultantes, porque las matrices multidimensionales en PowerShell pueden volverse extrañas, y esto es más consistente. Establece algunas variables iniciales, luego ingresa a do/ untilloop nuevamente, siendo el condicional hasta $ique el mcm de la matriz cuente .

Cada iteración del ciclo, agregamos los valores correspondientes $ay $bjuntos, lo tratamos como una matriz ,(...)antes de agregarlo a la tabla hash $oen el lugar apropiado $j. La encapsulación de la matriz es necesaria para evitar la adición aritmética; en su lugar, esto obliga +=a sobrecargar la concatenación de la matriz. Luego, un condicional en $xy $y(los recuentos) para determinar si estamos en un borde de matriz; si es así, incrementamos $j.

Finalmente, dejamos $oen la tubería y la salida es implícita.
(Nota: debido a cómo PowerShell enumera las tablas hash con el valor predeterminadoWrite-Output , esto tiende a salir "hacia atrás"; como en, la matriz resultante "0" está en la "parte inferior" de la salida. El hash en sí está bien, y sería se usa muy bien si, por ejemplo, encapsula este código en una variable de retorno ... simplemente se ve extraño cuando se imprime).

Ahorró 2 bytes moviendo $ x y $ y en la indexación de la matriz en lugar de separarlos (guardó dos puntos y comas).

Python 2, 113 bytes

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 Bytes

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

Toma dos listas como entrada e imprime todas las listas.

Es mi primera respuesta y todavía no sé jugar al golf. La idea básica que he usado es tener dos contadores para cada lista que indican una división y una lista actual donde se agregan los valores agregados; Tan pronto como se encuentra una división, imprimimos la lista actual y hacemos una nueva vacía.

• Guardado 34 bytes : Gracias a Dennis y TimmyD
• Guardado 3 bytes : estaba usando c y d para len (a) y len (b), pero resulta que no fueron útiles
• Guardado 4 bytes : gracias a orlp , eliminó la parálisis no deseada
• Guardado 11 bytes : reorganizó algunos bloques y los truncó

Raqueta 373 bytes

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

Sin golf:

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

Pruebas:

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

Salida:

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

Clojure, 280 206 bytes

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

Bueno, esto tiene mucho más sentido. Generando la suma de elementos sabios, agregando metadatos posicionales, tomando mientras aún no hemos repetido y colocando el valor de la suma para cada partición.

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

Original: espero mejorar esto, pero este es el más amable que tengo por ahora.

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

Sin golfos y detallado:

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

Comienza por "fusionar" un ciclo infinito de colecciones a y b, agrega metadatos en el índice de cada elemento dentro de la colección, toma hasta que ambas secuencias comiencen desde el índice 0 nuevamente.

Esta coleccion c se fusiona con datos de partición (una suma acumulativa de unos y ceros), se divide y se selecciona el último elemento (que es la suma de elementos).

Creo que para mejoras significativas se requiere un enfoque totalmente diferente.

PHP, 150 121 119 bytes

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

La función anónima toma datos como matrices.

Descompostura

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 bytes

Como lambda sin nombre genérico, que requieren recipientes de entrada P, Qy el recipiente de salida Ra ser como 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);}

Sin golf y uso:

#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 Bytes

Esto probablemente podría mejorarse. La idea es crear una matriz 2D con el segundo elemento utilizado para rastrear el arrendador del contador y modificar la longitud de cada matriz de entrada.

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

Uso

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

JavaScript (ES6), 131 bytes

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

Ligeramente incólume:

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

• Si ambas matrices dy econtienen números, la suma del primer número se agrega as y los elementos restantes se procesan de forma recursiva
• Si una de las matrices contiene números, la matriz de sumas sse agrega al resultado ry la otra matriz se restablece a su matriz inicial
• Si ambas matrices están vacías, simplemente devuelva el resultado con las últimas sumas agregadas.

Lamentablemente, esta solución no tiene la eficacia despiadada de @ Arnauld, pero al menos creo que es una solución hermosa.