Partition a list into sublists of different lengths

Question

I have the list {a, b, c, d, e, f, g, h, i} and I want to make a sub-list of the form {{{a, b}, c}, {{d, e}, f}, {{g, h}, i}} I've tried using Partition, but I can't see how to use it here.

Hi, welcome to Mathematica.SE, please consider taking the tour so you learn the basic rules of the site. Once you gain enough reputation by making good questions you will be able to vote up and down both questions and answers. Your question has been answered, but its a good idea to wait 24hours for other answers before accepting the best one for you. — rhermans, Aug 25 '15 at 15:12
When you see good questions and answers, please vote them up by clicking the grey triangles, because the credibility of the system is based on the reputation gained by users sharing their knowledge. As you receive help, try to give it too, by answering questions in your area of expertise. — rhermans, Aug 25 '15 at 15:14

LLlAMnYP · Answer 1 · 2015-08-25T20:19:34.333

14

My take:

{Most@#, Last@#} & /@ Partition[{a, b, c, d, e, f, g, h, i}, 3]

@Guesswhoitis:

Transpose[{Drop[#, None, -1], #[[All, -1]]}] & @ Partition[list, 3]

@Pickett

Developer`PartitionMap[{Most[#], Last[#]} &, lst, 3]

edited Aug 25 '15 at 20:19

answered Aug 25 '15 at 15:10

LLlAMnYP

11,486
26
65

1

Equivalent: Transpose[{Drop[#, None, -1], #[[All, -1]]}] & @ Partition[list, 3]. – J. M.'s missing motivation Aug 25 '15 at 15:26
@J. M. True... but for what purpose? (I mean, faster, or something else?) – LLlAMnYP Aug 25 '15 at 15:28
1

It can also be written Developer`PartitionMap[{Most[#], Last[#]} &, lst, 3], which might be faster. – C. E. Aug 25 '15 at 16:00
@Pickett Oooh, regardless, how similar to normal built-in functions, this should be an answer. – LLlAMnYP Aug 25 '15 at 16:22
1

I just presented an approach that is not very different (which is why I left a comment and not an answer). – J. M.'s missing motivation Aug 25 '15 at 16:48

kglr · Answer 2 · 2018-02-03T23:18:30.383

11

Using the (undocumented) six-argument form of Partition to restructure partition elements:

Partition[{a, b, c, d, e, f, g, h, i}, 3, 3, 1, {}, {{#, #2}, #3} &]

{{{a, b}, c}, {{d, e}, f}, {{g, h}, i}}

Also

SequenceCases[{a, b, c, d, e, f, g, h, i}, {a_, b_, c_}:>{{a, b}, c}]

{{{a, b}, c}, {{d, e}, f}, {{g, h}, i}}

edited Feb 03 '18 at 23:18

answered Feb 03 '18 at 16:06

kglr

394,356
18
477
896

kale · Answer 3 · 2015-08-25T20:39:03.467

9

For those with 10.2, a couple new functions for the heck of it...

BlockMap[TakeDrop[#, 2] /. {l_} :> l &, list, 3]

or

BlockMap[TakeDrop[#, 2]~FlattenAt~2 &, list, 3]

or

With[{k := {{#1, #2}, #3} &}, BlockMap[k @@ # &, list, 3]]

edited Aug 25 '15 at 20:39

answered Aug 25 '15 at 20:32

kale

10,922
1
32
69

m_goldberg · Accepted Answer · 2015-08-25T22:23:41.423

9

Good problem for the application of argument destructuring.

data = {a, b, c, d, e, f, g, h, i};

restructure[{a_, b_, c_}] := {{a, b}, c}

restructure /@ Partition[data, 3]

{{{a, b}, c}, {{d, e}, f}, {{g, h}, i}}

edited Aug 25 '15 at 22:23

answered Aug 25 '15 at 22:15

m_goldberg

107,779
16
103
257

@LLlAMnYP. Thanks for pointing out the typo. – m_goldberg Aug 25 '15 at 22:24
No problem, some of these days I'd sooner believe an obvious typo is actually something real subtle and intended. Say, what's self : func[args___] := ... construct called? – LLlAMnYP Aug 25 '15 at 22:25
@LLlAMnYP. I don't know any name for that pattern. – m_goldberg Aug 25 '15 at 22:27
The bot bumped this post today: http://mathematica.stackexchange.com/a/7136/26956 - saw it in the last two lines of code. Your typo reminded me of that. A couple of minutes for chat, maybe? – LLlAMnYP Aug 25 '15 at 22:30
@LLlAMnYP. Sorry, can't chat -- late in my time zone -- need to sign out. – m_goldberg Aug 25 '15 at 23:44
I really like this answer as for a novice- it is easy to understand- many thanks!! – ProfTC Aug 26 '15 at 00:07
@TerenceCosgrove If you feel it's the best one for you, please do accept it. But for interpolation of functions with multidimensional variables the general form is {{{args1},f1},{{args2},f2},...} in that case, a solution that's general enough for any number of elements, not just 3 would suit you better. – LLlAMnYP Aug 26 '15 at 08:03

score 5 · Answer 5 · answered Aug 25 '15 at 23:15

5

Yet another one for variety:

dat = {a, b, c, d, e, f, g, h, i};

{Partition[dat, 2, 3], dat[[3 ;; ;; 3]]}\[Transpose]

{{{a, b}, c}, {{d, e}, f}, {{g, h}, i}}

answered Aug 25 '15 at 23:15

Mr.Wizard

271,378
34
587
1,371

score 4 · Answer 6 · answered Aug 25 '15 at 21:26

4

Something with rules:

Partition[{a, b, c, d, e, f, g, h, i}, 3] /. {x_, y_, z_?AtomQ} -> {{x, y}, z}

answered Aug 25 '15 at 21:26

KennyColnago

15,209
26
62

score 3 · Answer 7 · answered Sep 06 '23 at 18:30

3

list = {a, b, c, d, e, f, g, h, i};

BlockMap[Apply[{{#1, #2}, #3} &], list, 3]

{{{a, b}, c}, {{d, e}, f}, {{g, h}, i}}

answered Sep 06 '23 at 18:30

eldo

67,911
5
60
168

1

(+1) Also BlockMap[{Most@#,Last@#}&, list, 3] – user1066 Sep 06 '23 at 22:43

score 1 · Answer 8 · answered Feb 04 '18 at 04:17

1

list = {a, b, c, d, e, f, g, h, i};
Partition[Riffle[Partition[#, 2, 3], Take[#, {3, -1, 3}]], 2] &@list

{{{a, b}, c}, {{d, e}, f}, {{g, h}, i}}

answered Feb 04 '18 at 04:17

OkkesDulgerci

10,716
1
19
38

score 1 · Answer 9 · answered Sep 07 '23 at 04:53

1

Another way using MapApply and Partition:

{Most@{##}, #3} & @@@ Partition[#, 3] &@list
({{{a, b}, c}, {{d, e}, f}, {{g, h}, i}})

answered Sep 07 '23 at 04:53

E. Chan-López

23,117
3
21
44

score 1 · Answer 10 · answered Sep 07 '23 at 06:06

Using TakeList:

Clear["Global`*"];
f[k_List, parts_List] := Module[{tp = Total@parts},
  FoldPairList[{TakeList[#1, parts], #1[[tp + 1 ;;]]} &
    , k
    , ConstantArray[1, Quotient[Length@k, tp]]] //
   Map[FlattenAt[-1]]
  ]

Usage

alist = {a, b, c, d, e, f, g, h, i};
f[alist, {2, 1}]

{{{a, b}, c}, {{d, e}, f}, {{g, h}, i}}

f[Alphabet[], {5, 3}]

{{{"a", "b", "c", "d", "e"}, "f", "g", "h"}, {{"i", "j", "k", "l", "m"}, "n", "o", "p"}, {{"q", "r", "s", "t", "u"}, "v", "w", "x"}}

f[Alphabet[], {2, 2, 1}]

{{{"a", "b"}, {"c", "d"}, "e"}, {{"f", "g"}, {"h", "i"}, "j"}, {{"k", "l"}, {"m", "n"}, "o"}, {{"p", "q"}, {"r", "s"}, "t"}, {{"u", "v"}, {"w", "x"}, "y"}}

Partition a list into sublists of different lengths

10 Answers10

Linked