Adding list of list to a list

Question

Hello I need some help on how to add a list to a list of list. The program would have to do as below:

{{0,0}, {0}, {0,0,0}}+{1,2,3,4,5,6}

will give

{{1,2}, {3}, {4,5,6}}.

Could this be done? Any help is greatly appreciated. Thanks in advance.

Welcome to Mathematica.SE! I suggest that: 1) You take the introductory Tour now! 2) When you see good questions and answers, vote them up by clicking the gray triangles, because the credibility of the system is based on the reputation gained by users sharing their knowledge. Also, please remember to accept the answer, if any, that solves your problem, by clicking the checkmark sign! 3) As you receive help, try to give it too, by answering questions in your area of expertise. — bbgodfrey, Dec 31 '14 at 01:34
Do you wish to "add" the first list to the second or to partition the second list to have the structure of the first? It appears you mean the latter. Also, please explain your comment as it relates to the question. Thanks. — bbgodfrey, Dec 31 '14 at 01:37
I see that this question has accumulated three Close votes in favor of (23395). While that question sounds similar I don't believe Simon's method can be applied to this problem. If it can please show me, otherwise I shall contravene closure. — Mr.Wizard, Jan 01 '15 at 06:10

score 11 · Accepted Answer · edited Apr 13 '17 at 12:56

11

Without testing whether there are as many elements in the first list as there are in the second, the solution is as simple as

listAdd[structured_, flat_] := Module[{i = 1},
  Function[elm, elm + flat[[i++]], {Listable}][structured]
]

listAdd[{{a, b}, {c}, {d, e, f}}, {1, 2, 3, 4, 5, 6}]
(* {{1 + a, 2 + b}, {3 + c}, {4 + d, 5 + e, 6 + f}} *)

To understand why this works, please study carefully my answer of this question.

edited Apr 13 '17 at 12:56

Community

1

answered Dec 31 '14 at 02:05

halirutan

112,764
7
263
474

2

This is elegant and flexible but it comes at the cost of performance: more than two orders of magnitude slower than add in the "Like/Long" test I just posted. – Mr.Wizard Dec 31 '14 at 23:45

score 6 · Answer 2 · answered Dec 31 '14 at 23:44

Performance comparison

Here is a performance comparison of all methods given in the order of their posting.

Bill's code is not self-contained so I shall use:

bill[a_, b_] := 
 Module[{h, list = b}, 
  Map[(h = Take[list, Length[#]]; list = Drop[list, Length[#]]; # + h) &, a]
 ]

The other functions for ease of execution:

add[a_List, b_List] := a + dynP[b, Length /@ a]

listAdd[structured_, flat_] := 
 Module[{i = 1}, Function[elm, elm + flat[[i++]], {Listable}][structured]]

raggedMap = Internal`PartitionRagged[#1[Flatten[#2], #3], Length /@ #2] &;

listAdd1[structured_, flat_] := Module[{cnt = 1, f}, f = Function[x, x + flat[[cnt++]]];
  Map[f, structured, {-1}]]

deFlatten[flat_, reference_] := 
 Module[{cnt = 1}, Replace[reference, elem_ :> flat[[cnt++]], {-1}]]

listAdd2[structured_, flat_] := deFlatten[Flatten[structured] + flat, structured]

Yi Wang's listAdd3 threw errors so I did not include it in this test.

Generating code for two lists of the like type (Integer) with short sublists:

Needs["GeneralUtilities`"]

a = RandomInteger[9, #] & /@ RandomInteger[{1, 9}, 5000];
b = RandomInteger[9, Length@Flatten@a];

bill[a, b]             // AccurateTiming
add[a, b]              // AccurateTiming
listAdd[a, b]          // AccurateTiming
raggedMap[Plus, a, b]  // AccurateTiming
listAdd1[a, b]         // AccurateTiming
listAdd2[a, b]         // AccurateTiming

Like-types and long sublists:

a = RandomInteger[9, #] & /@ RandomInteger[{1, 500}, 500];
b = RandomInteger[9, Length@Flatten@a];

Unlike types and short sublists:

a = RandomInteger[9, #] & /@ RandomInteger[{1, 9}, 5000];
b = RandomChoice[{"a", "b", "c"}, Length@Flatten@a];

Unlike types and long sublists:

a = RandomInteger[9, #] & /@ RandomInteger[{1, 500}, 500];
b = RandomChoice[{"a", "b", "c"}, Length@Flatten@a];

A table of results:

enter image description here

score 4 · Answer 3 · edited Apr 13 '17 at 12:55

4

This question is similar to 7511, which was solved with

dynP[l_, p_] := MapThread[l[[# ;; #2]] &, {{0}~Join~Most@# + 1, #} &@Accumulate@p]

In your case, dynP[{1, 2, 3, 4, 5, 6},{2, 1, 3}], where the second list is the lengths of the desired partitions, gives the answer. If, on the other hand, you wish to work from your template list, use

dynP[[{1, 2, 3, 4, 5, 6}, Length /@ {{0, 0}, {0}, {0, 0, 0}}]

As a function:

add[a_List, b_List] := a + dynP[b, Length /@ a]

Now:

add[{{2, 3}, {5}, {7, 11, 13}}, {1, 2, 3, 4, 5, 6}]

{{3, 5}, {8}, {11, 16, 19}}

edited Apr 13 '17 at 12:55

Community

1

answered Dec 31 '14 at 01:58

bbgodfrey

61,439
17
89
156

Exactly how I would do it. +1 (And thanks for linking the source.) I added an example; I hope you don't mind. – Mr.Wizard Dec 31 '14 at 10:03
Not at all, @MrWizard. Thank you. – bbgodfrey Dec 31 '14 at 14:07

kglr · Answer 4 · 2021-01-02T12:37:14.730

Two ways to use Internal`CopyListStructure:

addLsts1 = # + Internal`CopyListStructure[#, #2] &;
addLsts1[{{a, b}, {c}, {d, e, f}}, Range@6]

 {{1 + a, 2 + b}, {3 + c}, {4 + d, 5 + e, 6 + f}}

addLsts1 is as fast as Mr.Wizard's add.

A slower alternative:

addLsts2 = Internal`CopyListStructure[#, Flatten[#] + #2] &;
addLsts2[{{a, b}, {c}, {d, e, f}}, Range@6]

{{1 + a, 2 + b}, {3 + c}, {4 + d, 5 + e, 6 + f}}

score 3 · Answer 5 · answered Dec 31 '14 at 01:44

3

IF listoflist is only nested one level deep then

listoflist = {{0, 0}, {0}, {0, 0, 0}};
list = {1, 2, 3, 4, 5, 6};
Map[(h = Take[list, Length[#]]; list = Drop[list, Length[#]]; # + h) &, listoflist]

(* {{1, 2}, {3}, {4, 5, 6}} *)

answered Dec 31 '14 at 01:44

Bill

12,001
12
13

score 2 · Answer 6 · answered Apr 04 '23 at 07:52

Using TakeList:

alist = {{a, b}, {c}, {d, e, f}};
blist = {1, 2, 3, 4, 5, 6};
alist + TakeList[blist, Length /@ alist]

{{1 + a, 2 + b}, {3 + c}, {4 + d, 5 + e, 6 + f}}

Also:

alist TakeList[blist, Length /@ alist]

{{a, 2 b}, {3 c}, {4 d, 5 e, 6 f}}

kglr · Answer 7 · 2015-01-01T09:45:33.757

raggedMap = Internal`PartitionRagged[#1[Flatten[#2], #3], Length /@ #2] &;
raggedAdd = raggedMap[Plus, #, #2] &;

Usage examples:

raggedAdd {{0, 0}, {0}, {0, 0, 0}}, {1, 2, 3, 4, 5, 6}]

or

raggedMap[Plus, {{0, 0}, {0}, {0, 0, 0}}, {1, 2, 3, 4, 5, 6}]

both give

(* {{1, 2}, {3}, {4, 5, 6}} *)

lst1 = {{a, b}, {c}, {d, e, f}}; 
lst2 = {1, 2, 3, 4, 5, 6};
raggedAdd[lst1, lst2]
(* {{1+a, 2+b}, {3+c}, {4+d, 5+e, 6+f}} *)

raggedMap[Times, lst1, lst2]
(* {{a, 2 b}, {3 c}, {4 d, 5 e, 6 f}} *)

Yi Wang · Answer 8 · 2014-12-31T11:19:34.280

One solution: map at the last level

listAdd1[structured_,  flat_] := Module[{cnt = 1, f},
  f =  Function[x, x + flat[[cnt++]]];
  Map[f, structured, {-1}]]

Another solution: First define a function deFlatten[flat, reference], to undo Flatten, according to a given reference list:

deFlatten[flat_, reference_] := Module[{cnt = 1},
  Replace[reference, elem_ :> flat[[cnt++]], {-1}]]

For example,

deFlatten[{a, b, c}, {1, {2, 3}}]

{a, {b, c}}

Then it is trivial to implement listAdd:

listAdd2[structured_, flat_] := 
 deFlatten[Flatten[structured] + flat, structured ]

A third solution, by keeping the position of the list in MapIndexed, and restore the position using ReplacePart

listAdd3[structured_, flat_] := Module[{f}, ReplacePart[structured, 
  Flatten @ MapIndexed[f, structured, {-1}] + flat /. n_ + f[m_, pos_] :> (pos :> m + n)]]

Adding list of list to a list

8 Answers8

Performance comparison

Linked