Binning sequential sets of elements together in a list

Question

Given a list of the form:

list={{1,2,3,4,5},{6,7,8,9,10},{11,12},{13,14,15,16},{17,18,19,20,21,22,23},{24},{25,26},{27},{4}}

How can I bin each sequential set of n elements of the list together? For example, if n = 3, we would transform the above list into:

{{1,2,3,4,5,6,7,8,9,10,11,12},{13,14,15,16,17,18,19,20,21,22,23,24},{25,26,27,4}}

of length 3.

@b.gatessucks So apply Partition with the desired value of N, and then flatten each of the new elements? — HStoley, Sep 13 '13 at 11:24
e.g. like so: Join @@@ Partition[list, 3], but depends a lot on what you plan to do — Pinguin Dirk, Sep 13 '13 at 11:25
@b.gatessucks Is there an easy command to apply Flatten[ ,1] to each element in the list? — HStoley, Sep 13 '13 at 11:25
Using Flatten, it'd be like: Flatten /@ Partition[list, 3]. But again, not knowing where you are headed, it's hard to provide a "real" answer — Pinguin Dirk, Sep 13 '13 at 11:27
@PinguinDirk Your suggestion Join @@@ Partition[list, 3] was the answer to my question as far as I'm concerned, unless you're aware of a faster way to proceed. — HStoley, Sep 13 '13 at 11:30

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

Let

list={{1,2,3,4,5},{6,7,8,9,10},{11,12},{13,14,15,16},
       {17,18,19,20,21,22,23},{24},{25,26},{27},{4}}

Thanks to @b.gatessucks, you could either:

 Join @@@ Partition[list, 3]

or

 Flatten /@ Partition[list, 3]

both return:

{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, {13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}, {25, 26, 27, 4}}

Note that depending on the initial structure of list, maybe "unexpected" results might occur, e.g. try the following (dropping the last element, i.e. {4}):

Flatten /@ Partition[Most@list, 3]

{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, {13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}}

Why? Most@listnow only has 8 elements, thus it is hard to partition in groups of three. By standard, Partition only returns the "full" (i.e. consisting of 3 elements) lists.

To react, you could e.g. use:

Flatten /@ Partition[Most@list, 3, 3, 1, {}]

{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, {13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}, {25, 26, 27}}

See the documentation of Partition for more information.

Also, check out the dynP function by Mr.Wizard!

score 4 · Answer 2 · answered Sep 13 '13 at 11:51

4

Try!

Partition[Flatten@#1, #2, #2, 1, {}] & @@ {list, 12}

answered Sep 13 '13 at 11:51

PlatoManiac

14,723
2
42
74

kglr · Answer 3 · 2018-01-06T12:51:24.307

2

Partition[list, 3, 3, 1, {}, Join]

{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
{13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24},
{25, 26, 27, 4}}

Also

BlockMap[Flatten, list,3]

{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
{13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24},
{25, 26, 27, 4}}

edited Jan 06 '18 at 12:51

answered Jan 06 '18 at 12:16

kglr

394,356
18
477
896

Thanks for bringing BlockMap to my attention. (+1) – Edmund Jan 06 '18 at 13:43
@Edmund, thank you for the upvote. – kglr Jan 06 '18 at 17:03

score 0 · Answer 4 · answered Apr 14 '23 at 09:30

The OP includes a 9-element list:

list = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12}, {13, 14, 15, 
   16}, {17, 18, 19, 20, 21, 22, 23}, {24}, {25, 26}, {27}, {4}}

For dividing the number 9 it into bins, consider:

QuotientRemainder[
    Length@list, #] /. {a_, b_} :> {Sequence @@ ConstantArray[#, a], 
     If[b != 0, b, Nothing]} & /@ Range[5]
{{1, 1, 1, 1, 1, 1, 1, 1, 1}, {2, 2, 2, 2, 1}, {3, 3, 3}, {4, 4, 
  1}, {5, 4}}

Define a function to Catenate n lists together using TakeList:

nCatenate[list_List, n_Integer] :=
 Catenate /@ 
  TakeList[list, 
   QuotientRemainder[Length@list, 
     n] /. {a_, b_} :> {Sequence @@ ConstantArray[n, a], 
      If[b != 0, b, Nothing]}]
nCatenate[list, 3]

{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, {13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}, {25, 26, 27, 4}}

nCatenate[list, 2]

{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {11, 12, 13, 14, 15, 16}, {17, 18,
19, 20, 21, 22, 23, 24}, {25, 26, 27}, {4}}

One can decide if the last (left over) items are to be kept.

Addendum

Another way of realizing sublist counts as shown above can be:

ips = IntegerPartitions[9]
Last /@ (MaximalBy[ips, Count[#]] & /@ Range[5])

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

Binning sequential sets of elements together in a list

4 Answers4