Split according to list and apply rule

Question

I have a list which looks some thing like this

{a1, a2, a3, a4, a5, a6, a7, a8, a9, a10}

Now I want to split it according to lengths {1,2,3,4} so that I would have

{{a1},{ a2, a3}, {a4, a5, a6},{ a7, a8, a9, a10}}

and I want to apply the rule with itself. For example: after rule application, the answer should become

{{a1},{a2->a3},{a4->a5->a6},{a7->a8->a9->a10}}.

I have tried to use Split and Partition function but not getting the desired result. Is there any other function that accomplishes this? If not how can I do this?

The first part of your question I answered here: (7511) – Mr.Wizard Dec 03 '15 at 23:16 — Mr.Wizard, Dec 03 '15 at 23:16

score 14 · Answer 1 · 2015-12-28T18:57:55.357

14

Depending on the precedence you want for Rule, you can use either

Fold[Rule, #] & /@ 
 Internal`PartitionRagged[{a1, a2, a3, a4, a5, a6, a7, a8, a9, a10}, {1, 2, 3, 4}]

(* {a1, a2 -> a3, (a4 -> a5) -> a6, ((a7 -> a8) -> a9) -> a10} *)

or

Fold[Rule[#2, #1] &, #] & /@ Reverse /@ 
 Internal`PartitionRagged[{a1, a2, a3, a4, a5, a6, a7, a8, a9, a10}, {1, 2, 3, 4}]

(* {a1, a2 -> a3, a4 -> a5 -> a6, a7 -> a8 -> a9 -> a10} *)

To end up with the requested output, you can evalute List /@ on the resulting expressions.

Update

To avoid mapping twice in the last solution, one could use Fold[Rule[#2, #1] &, Reverse@#] & instead of Fold[Rule[#2, #1] &, #] & /@ Reverse.

Also, instead of using List /@ on the output as suggested above, one could directly enclose the Fold function between braces, e.g.

{Fold[Rule[#2, #1] &, Reverse@#]} & /@ 
  Internal`PartitionRagged[{a1, a2, a3, a4, a5, a6, a7, a8, a9, a10}, {1, 2, 3, 4}]

(* {{a1}, {a2 -> a3}, {a4 -> a5 -> a6}, {a7 -> a8 -> a9 -> a10}} *)

edited Dec 28 '15 at 18:57

answered Dec 03 '15 at 18:00

2

With // Partition[#, 1] & in the end to yield the exact requested output. – anderstood Dec 03 '15 at 18:05
@anderstood. Or {#} &/@ result. – march Dec 03 '15 at 18:29
1

@march List /@ result is probably clearer for a beginner – Dr. belisarius Dec 03 '15 at 18:56
2

@belisariushassettled. And for an established user/expert, too. – march Dec 03 '15 at 18:57

score 8 · Answer 2 · edited Apr 13 '17 at 12:55

The partitioning aspect of your question is already addressed in detail in Partitioning with varying partition size.

The second aspect of your question amounts to performing a right fold. For the case at hand this might be done most easily using pattern matching:

rule[a___, x_, y_] := rule[a, x -> y]
rule[x_] := x

This is essentially a multi-argument Rule with a defined precedence. It does this:

rule[a1, a2, a3, a4]

a1 -> a2 -> a3 -> a4

You can then Apply this function to a list, or list of lists. Using my partitionBy function from the referenced Q&A your operation is then:

in = {a1, a2, a3, a4, a5, a6, a7, a8, a9, a10};

List /@ rule @@@ partitionBy[in, # &]

{{a1}, {a2 -> a3}, {a4 -> a5 -> a6}, {a7 -> a8 -> a9 -> a10}}

Xavier also provided a right fold method, and one that can be much more efficient in certain cases due to the optimizations within Fold. Let's make it an abstraction, and add an Operator Form while we're at:

Default[foldr] = Sequence[];
foldr[f_][p__] := foldr[f, p]
foldr[f_, x_., a : _[__]] := Fold[#2 ~f~ #1 &, x, Reverse @ a]

It does this:

foldr[oo][{a1, a2, a3, a4}]

oo[a1, oo[a2, oo[a3, a4]]]

Your operation is then:

in = {a1, a2, a3, a4, a5, a6, a7, a8, a9, a10};

List /@ foldr[Rule] /@ partitionBy[in, # &]

{{a1}, {a2 -> a3}, {a4 -> a5 -> a6}, {a7 -> a8 -> a9 -> a10}}

Dr. belisarius · Answer 3 · 2015-12-03T19:32:01.050

6

If you don't want to use the handy but undocumented PartitionRagged, you could go by:

l  = {a1, a2, a3, a4, a5, a6, a7, a8, a9, a10}; 
r = Range[1/2 (-1 + Sqrt[1 + 8 Length@l])]
ls = Transpose@{# - PadLeft[Most@r, Length@r], #} &@Accumulate@r;
l[[#1 ;; #2]] & @@@ ls

(*{{a1}, {a2, a3}, {a4, a5, a6}, {a7, a8, a9, a10}}*)

edited Dec 03 '15 at 19:32

answered Dec 03 '15 at 19:02

Dr. belisarius

115,881
13
203
453

"List /@ result is probably clearer for a beginner" – belisarius has settled 16 mins ago :) – Kuba Dec 03 '15 at 19:14
@Kuba What am I missing?:( – Dr. belisarius Dec 03 '15 at 19:19
1

A solution clear for beginner :) – Kuba Dec 03 '15 at 19:20
1

@Kuba Ahhh ... that's Xavier's ! :D – Dr. belisarius Dec 03 '15 at 19:21
2

A documented alternative to PartitionRagged could be: FoldPairList[TakeDrop, {a1, a2, a3, a4, a5, a6, a7, a8, a9, a10}, {1, 2, 3, 4}]. – Dec 03 '15 at 19:44
@Kuba Is this any better?:) l[[#1 ;; #2]] & @@@ Partition[(Flatten@ FoldList[#1 + #2 &, {0, 1}, Range@Ceiling@Sqrt@Length@l])[[2 ;; -2]], 2] – Dr. belisarius Dec 03 '15 at 19:46
@Xavier Oh, on v9 still here – Dr. belisarius Dec 03 '15 at 19:46

score 3 · Answer 4 · answered Feb 07 '16 at 10:31

Just for something different:

pf[lst_, pt_] := Module[{p = Join @@ (Table[#, {#}] & /@ pt)},
  Last@Reap[Inner[Sow, lst, p, List], _, #2 &]]

So,

m = {a1, a2, a3, a4, a5, a6, a7, a8, a9, a10};
pf[m, {1, 2, 3, 4}]

yields:

(*{{a1}, {a2, a3}, {a4, a5, a6}, {a7, a8, a9, a10}}*)

score 2 · Answer 5 · edited Dec 28 '15 at 17:29

2

lst = {a1, a2, a3, a4, a5, a6, a7, a8, a9, a10};
ord = {1, 2, 3, 4}

Prepend[
  Map[Take[lst, #] &,
    Map[{#[[1]] + 1, #[[2]]} &, Partition[Accumulate[ord], 2, 1]]
   ],
  {lst[[1]]}
 ] //. {a___, {b_, c_, p___}, d___} :> {a, {b -> c, p}, d}

{{a1}, {a2 -> a3}, {(a4 -> a5) -> a6}, {((a7 -> a8) -> a9) -> a10}}

edited Dec 28 '15 at 17:29

march

23,399
2
44
100

answered Dec 05 '15 at 07:41

Pankaj Sejwal

2,063
14
23

eldo · Answer 6 · 2023-11-12T22:54:32.343

2

list = {a1, a2, a3, a4, a5, a6, a7, a8, a9, a10};

{ToExpression @ StringRiffle[#, "->"]} & /@ TakeList[list, {1, 2, 3, 4}]

{{a1}, {a2 -> a3}, {a4 -> a5 -> a6}, {a7 -> a8 -> a9 -> a10}}

TakeList since V 11.2 and StringRiffle since V 10.1

edited Nov 12 '23 at 22:54

answered Nov 12 '23 at 17:40

eldo

67,911
5
60
168

score 2 · Answer 7 · answered Nov 13 '23 at 04:11

2

Clear["Global`*"];
list = {a1, a2, a3, a4, a5, a6, a7, a8, a9, a10};
t = TakeList[list, {1, 2, 3, 4}];
TextString[#, ListFormat -> {"{ ", "->", " }"}] & /@ t // ToExpression

{{a1}, {a2 -> a3}, {a4 -> a5 -> a6}, {a7 -> a8 -> a9 -> a10}}

answered Nov 13 '23 at 04:11

Syed

52,495
4
30
85

user1066 · Answer 8 · 2023-11-16T11:51:55.137

Update

(1)

List@*ResourceFunction["FoldRight"][Rule] /@ 
  TakeList[{a1, a2, a3, a4, a5, a6, a7, a8, a9, a10}, {1, 2, 3, 4}]
(* {{a1}, {a2 -> a3}, {a4 -> a5 -> a6}, {a7 -> a8 -> a9 -> a10}} *)

(2)

List@Fold[ReverseApplied[Rule], #1, ##2] & /@ 
  Reverse[TakeList[{a1, a2, a3, a4, a5, a6, a7, a8, a9, a10}, {1, 2, 3, 4}], 2]
(* {{a1}, {a2 -> a3}, {a4 -> a5 -> a6}, {a7 -> a8 -> a9 -> a10}} *)

Right Fold

ResourceFunction["FoldRight"][f]@{a, b, c, d}
(* f[a, f[b, f[c, d]]] *)

Fold[ReverseApplied[f], #1, ##2] &@Reverse[{a, b, c, d}]

(* f[a, f[b, f[c, d]]] *)

Split according to list and apply rule

8 Answers8