# Partition a list into sublists of different lengths

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. Commented Aug 25, 2015 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. Commented Aug 25, 2015 at 15:14

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

• @LLlAMnYP. Thanks for pointing out the typo. Commented Aug 25, 2015 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? Commented Aug 25, 2015 at 22:25
• @LLlAMnYP. I don't know any name for that pattern. Commented Aug 25, 2015 at 22:27
• The bot bumped this post today: 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? Commented Aug 25, 2015 at 22:30
• @LLlAMnYP. Sorry, can't chat -- late in my time zone -- need to sign out. Commented Aug 25, 2015 at 23:44

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

DeveloperPartitionMap[{Most[#], Last[#]} &, lst, 3]

• Equivalent: Transpose[{Drop[#, None, -1], #[[All, -1]]}] & @ Partition[list, 3]. Commented Aug 25, 2015 at 15:26
• @J. M. True... but for what purpose? (I mean, faster, or something else?) Commented Aug 25, 2015 at 15:28
• It can also be written DeveloperPartitionMap[{Most[#], Last[#]} &, lst, 3], which might be faster. Commented Aug 25, 2015 at 16:00
• @Pickett Oooh, regardless, how similar to normal built-in functions, this should be an answer. Commented Aug 25, 2015 at 16:22
• I just presented an approach that is not very different (which is why I left a comment and not an answer). Commented Aug 25, 2015 at 16:48

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

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


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


Something with rules:

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

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

• (+1) Also BlockMap[{Most@#,Last@#}&, list, 3] Commented Sep 6, 2023 at 22:43
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}}

Another way using MapApply and Partition:

{Most@{##}, #3} & @@@ Partition[#, 3] &@list

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


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