How to Map a subset of list elements to a function?

Question

How would you, given a list {1, 2, 3, 4}, apply a function f to 1 and 2, then 2 and 3, etc.?

{f[1,2], f[2,3], f[3,4]}

More generally, how do you define which parts of a list you want to pass/Map/Apply to a function that takes multiple arguments?

Thank you and a big thanks to everyone who contributed alternative solutions as well. — Teo Sartori, Commented Apr 9, 2012 at 20:28

Mr.Wizard · Accepted Answer · 2012-08-11 04:39:09Z

17

You might first partition your list and then use Map as usual :

f[#[[1]], #[[2]]] & /@ Partition[{1,2,3,4}, 2, 1]

(* {f[1, 2], f[2, 3], f[3, 4]} *)

edited Aug 11, 2012 at 4:39

Mr.Wizard

273k34 gold badges595 silver badges1.4k bronze badges

answered Apr 9, 2012 at 14:35

b.gates.you.know.what

20.2k2 gold badges45 silver badges86 bronze badges

$\begingroup$ Excellent, that works. $\endgroup$
– Teo Sartori
Commented Apr 9, 2012 at 14:43
$\begingroup$ why is it f[#[[1]], #[[2]]] and not just f[#1,#2]? $\endgroup$
– Eiyrioü von Kauyf
Commented Apr 10, 2012 at 0:58
6

$\begingroup$ f[#1, #2] & @@@ Partition[{1,2,3}, 2, 1] $\endgroup$
– Per Alexandersson
Commented Apr 10, 2012 at 7:40
3

$\begingroup$ @PerAlexandersson f @@ Partition is enough/ $\endgroup$
– Kuba
Commented Jan 21, 2015 at 10:49
1

$\begingroup$ @Kuba you mean f @@@ Partition[{1,2,3,4}, 2, 1]. $\endgroup$
– Greg Hurst
Commented Dec 20, 2017 at 18:05

| Show 1 more comment

Mr.Wizard · Accepted Answer · 2018-07-29 02:51:48Z

Update: in version 10.2 BlockMap was added as a System context function.

If the arguments are sequential there is a function Developer`PartitionMap that does this directly, potentially saving considerable memory over Partition.

Developer`PartitionMap[f @@ # &, Range@5, 2, 1]

{f[1, 2], f[2, 3], f[3, 4], f[4, 5]}

Syntax is the same as for Partition but with the function to map inserted as the first argument. Notice in my use above that I needed Apply (short form @@) to pass the elements as arguments rather than a single list.

If the arguments are not sequental you can use Part:

list = {a, b, c, d, e}; 

parts = {{1, 2}, {4, 1, 3}, {5, 2}};

f @@ list[[#]] & /@ parts

{f[a, b], f[d, a, c], f[e, b]}

Mr.Wizard · Accepted Answer · 2012-08-11 04:39:43Z

18

You can use

f @@@ Partition[{1,2,3,4}, 2, 1]

which will give

{f[1,2], f[2,3], f[3,4]}

edited Aug 11, 2012 at 4:39

Mr.Wizard

273k34 gold badges595 silver badges1.4k bronze badges

answered Apr 9, 2012 at 14:38

Szabolcs

236k31 gold badges641 silver badges1.3k bronze badges

1

$\begingroup$ And this one is nice and short. $\endgroup$
– Teo Sartori
Commented Apr 9, 2012 at 14:44

Add a comment |

4 revs · Accepted Answer · 2020-06-16 09:23:30Z

Several additional alternatives:

MapThread:

MapThread[g, #] &@{Most@#, Rest@#} &@{r, s, t, u, v, w}

{g[r, s], g[s, t], g[t, u], g[u, v], g[v, w]}

or,

MapThread[g, #] &@Transpose@Partition[#, 2,1] &@{r, s, t, u, v, w}

{g[r, s], g[s, t], g[t, u], g[u, v], g[v, w]}

which allows more flexibility to specify the lists to thread over, like:

MapThread[g, #] &@Transpose@Partition[#, 3, 2, 1] &@{r, s, t, u, v, w}

{g[r, s, t], g[s, t, u], g[t, u, v], g[u, v, w]}

Inner:

With last argument set to List gives the same result as MapThread:

Inner[g, Sequence @@ #, List] &@Transpose@Partition[#, 2, 1] &@{r, s,t, u, v, w}

{g[r, s], g[s, t], g[t, u], g[u, v], g[v, w]}

Thread:

Thread[g[Most@#, Rest@#]] &@{r, s, t, u, v, w};
Thread[g[Sequence @@ #]] &@({Most@#, Rest@#} &@{r, s, t, u, v, w});
Thread[g[Sequence @@ #]] &@(Transpose@Partition[#, 2, 1] &@{r, s, t,u, v, w});

From docs on Thread:

Functions with attribute Listable are threaded automatically over lists.

Hence for Listable functions, e.g., for h in the following example:

SetAtrributes[h, Listable];
h[Sequence @@ #] &@(Transpose@Partition[#, 2, 1] &@{r, s, t, u, v, w})

gives the same result as does

Thread[h[Sequence @@ #]] &@(Transpose@Partition[#, 2, 1] &@{r, s, t, u, v, w}).

Also from docs:

MapThread takes the function and its arguments separately.

Thread evaluates the whole expression before threading.

Hence, using MapThread is "safer" as pointed out in Mr.Wizard's comments.

Timings:

Test data:

 tsts = Table[RandomInteger[1000, 1000000], {10}];

Results table (apologies for not figuring out how to apply Thread in the following):

Grid[{{"method", "timing"}, 
    {HoldForm[Thread[g[Sequence @@ #]] &@(Transpose@Partition[#, 2, 1] &)], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
    Thread[g[Sequence @@ #]] &@ (Transpose@Partition[#, 2, 1] &@ tsts[[i]])][[1]], 
      {i, 1, 10}] // Mean},
    {HoldForm[Thread[g[Most@#, Rest@#]] &], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
    Thread[g[Most@#, Rest@#]] &@tsts[[i]]][[1]], {i, 1, 10}] //  Mean},
    {HoldForm[MapThread[g, Transpose@Partition[#, 2, 1]] &], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
    MapThread[g, Transpose@Partition[#, 2, 1]] &@tsts[[i]]][[1]], {i, 1, 10}] // Mean},
    {HoldForm[MapThread[g, {Most@#, Rest@#}] &], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
    MapThread[g, {Most@#, Rest@#}] &@tsts[[i]]][[1]], {i, 1, 10}] //  Mean},
    {HoldForm[Inner[g, Sequence @@ #, List] &@{Most@#, Rest@#} &], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
    Inner[g,Sequence @@ #,List] &@{Most@#,Rest@#} &@tsts[[i]]][[1]], {i, 1, 10}] // Mean}, 
    {HoldForm[Inner[g, Sequence @@ #, List] &@Transpose@Partition[#, 2, 1] &], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
    Inner[g, Sequence @@ #, List] &@Transpose@Partition[#, 2, 1] &@
    tsts[[i]]][[1]], {i, 1, 10}] // Mean},
    {HoldForm[Developer`PartitionMap[g @@ # &, tsts[[i]], 2, 1]], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
    Developer`PartitionMap[g @@ # &, tsts[[i]], 2, 1]][[1]], {i, 1, 10}] // Mean}, 
    {HoldForm[g @@@ Partition[tsts[[i]], 2, 1]], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
    g @@@ Partition[tsts[[i]], 2, 1]][[1]], {i, 1, 10}] // Mean}, 
    {HoldForm[ g @@@ Most[{tsts[[i]], RotateLeft@tsts[[i]]}\[Transpose]]], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
    g @@@ Most[{tsts[[i]], RotateLeft@tsts[[i]]}\[Transpose]]][[1]], {i, 1, 10}] // Mean}, 
    {HoldForm[Fold[(Sow[g[#1, #2]]; #2) &, First@#, Rest@#] &@tsts[[i]]; // 
     Reap // Last], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
     Fold[(Sow[g[#1, #2]]; #2) &, First@#, Rest@#] &@tsts[[i]]; //
      Reap // Last][[1]], {i, 1, 10}] // Mean},
    {HoldForm[g[#[[1]], #[[2]]] & /@ Partition[tsts[[i]], 2, 1]], 
    Table[AbsoluteTiming[ClearSystemCache[]; 
     g[#[[1]], #[[2]]] & /@ Partition[tsts[[i]], 2, 1]][[1]], {i, 1, 10}] // Mean}}, 
    Frame -> All]

Timing results:

enter image description here

Probably too specific since the OP was asking "generally" but if you expand this answer to address Listable functions and discuss the performance benefits you'll heartily earn my +1. — Mr.Wizard, Commented Apr 9, 2012 at 15:03
@Mr.Wizard I like this one, and it's the type of thing I often use as I didn't know about Developer`Partition until very recently. — rcollyer, Commented Apr 9, 2012 at 15:11
@rcollyer I like this one a lot too (hence: "heartily") but the answer is unfinished. Thread as shown is dangerous because of evaluation order, and the most elegant an efficient possibility (with Listable functions) is neither shown nor explained. — Mr.Wizard, Commented Apr 9, 2012 at 15:13
@Mr.Wizard How is Thread dangerous? I don't see it. I also, don't see the answer as being incomplete. Instead, I see it as not being generalizable, e.g. what if the OP wanted to expand it to sequential, overlapping triples, instead? — rcollyer, Commented Apr 9, 2012 at 15:20
@Mr.Wizard well with Listable functions neither Thread nor MapThread are necessary, e.g. Block[{f}, SetAttributes[f, Listable]; f[Most@#, Rest@#] &@{1, 2, 3}]. Setting f = Print is an interesting counter argument. I'm still parsing it. My Listable example doesn't function as expected with Print, either. — rcollyer, Commented Apr 9, 2012 at 15:46

kglr · Accepted Answer · 2017-12-21 03:35:49Z

Update: A function f can be mapped to partition elements using f as the undocumented 6th argument of Partition.

Partition[{1, 2, 3, 4}, 2, 1, {1, -1}, {}, f]

{f[1, 2], f[2, 3], f[3, 4]}

Partition[{1, 2, 3, 4}, 2, 1, {1, -1}, {}, Plus]

{3, 5, 7}

Partition[Range[10], 5, 2, None, {}, Mean[{##}] &]

{3, 5, 7}

Also works with ragged partitions if f is defined for sequences of varying length:

{Partition[Range[5], 5, 2, {-1, 1}, {}],
 Partition[Range[5], 5, 2, {-1, 1}, {}, foo],
 Partition[Range[5], 5, 2, {-1, 1}, {}, Plus]} // Column // TeXForm

$\begin{array}{l} \{\{1\},\{1,2,3\},\{1,2,3,4,5\},\{3,4,5\},\{5\}\} \\ \{\text{foo}(1),\text{foo}(1,2,3),\text{foo}(1,2,3,4,5),\text{foo}(3,4,5),\text{foo}(5)\} \\ \{1,6,15,12,5\} \\ \end{array}$

Original post:

List @@ Partition[f[1, 2, 3, 4], 2, 1]

{f[1, 2], f[2, 3], f[3, 4]}

Community · Accepted Answer · 2017-04-13 12:55:55Z

7

Mathematica 10 introduced MovingMap and operator forms:

MovingMap[Apply[f], Range @ 9, 2]

{f[1, 2], f[2, 3], f[3, 4], f[4, 5], f[5, 6], f[6, 7], f[7, 8], f[8, 9]}

Useful information: Mathematica periodic moving map

In Mathematica 10.1 the syntax for MovingMap changed; now you must use:

MovingMap[Apply[f], Range @ 9, 1]

{f[1, 2], f[2, 3], f[3, 4], f[4, 5], f[5, 6], f[6, 7], f[7, 8], f[8, 9]}

edited Apr 13, 2017 at 12:55

CommunityBot

1

answered Jan 23, 2015 at 22:39

Mr.Wizard

273k34 gold badges595 silver badges1.4k bronze badges

1

$\begingroup$ There's also ListCorrelate[{1, 1}, Range@9, {1, -1}, {}, Times, f] $\endgroup$
– LLlAMnYP
Commented May 12, 2015 at 9:01
$\begingroup$ @LLlAMnYP My update is not intended to preclude that; please post that as an answer if you would like. $\endgroup$
– Mr.Wizard
Commented May 12, 2015 at 9:03
$\begingroup$ it's on my mind right now, as I'm reflecting on a question of mine about mapping to a subsequence of a list (generalization to multidimensional lists in a different way, than suggested before). I'm surprised, it didn't show up in the answers, as it's around since v.4, but I'm reluctant to post it, when there are now several functions in v.10 that do specifically the required thing. $\endgroup$
– LLlAMnYP
Commented May 12, 2015 at 9:20
$\begingroup$ @LLlAMnYP I see no reason not to post it; not only are backward-compatible methods of use to many people but alternative methods can often be adapted in ways that built-ins cannot. Incidentally ListCorrelate did get a mention in my answer to a more recent and related question. $\endgroup$
– Mr.Wizard
Commented May 12, 2015 at 9:35

Add a comment |

Sjoerd C. de Vries · Accepted Answer · 2012-04-09 17:20:05Z

6

And yet another one:

list = Range[5];

f @@@ Most[{list, RotateLeft@list}\[Transpose]]

(*
==> {f[1, 2], f[2, 3], f[3, 4], f[4, 5]}
*)

answered Apr 9, 2012 at 17:20

Sjoerd C. de Vries

66.1k15 gold badges189 silver badges327 bronze badges

Add a comment |

LLlAMnYP · Accepted Answer · 2015-05-12 09:50:24Z

It's strange, that ListCorrelate has not been mentioned, according to the documentation, it has been around unchanged since v.4.0. It allows a one liner:

ListCorrelate[{1, 1}, Range@9, {1, -1}, {}, Times, f]
(* {f[1, 2], f[2, 3], f[3, 4], f[4, 5], f[5, 6], f[6, 7], f[7, 8], f[8, 9]} *)
ListConvolve[{1, 1}, Range@9, {-1, 1}, {}, Times, f]
(* {f[1, 2], f[2, 3], f[3, 4], f[4, 5], f[5, 6], f[6, 7], f[7, 8], f[8, 9]} *)

ListConvolve, as you can see, acts in a very similar manner. Their drawback is, they necessarily move along the list in steps of one. A result like

(* {f[1, 2, 3], f[3, 4, 5], f[5, 6, 7], f[7, 8, 9]} *)

does not appear to be possible(?)

rm -rf · Accepted Answer · 2012-04-09 17:54:58Z

4

I would probably use Developer`PartitionMap, but here's an approach using Fold, Reap and Sow just to demonstrate the various ways of doing the same thing:

list = {1, 2, 3, 4};
Fold[(Sow[f[#1, #2]]; #2) &, First@#, Rest@#] &@ list; // Reap // Last
(* Out[1]= {{f[1, 2], f[2, 3], f[3, 4]}} *)

answered Apr 9, 2012 at 17:54

rm -rf♦

89.3k21 gold badges297 silver badges479 bronze badges

Add a comment |

Alucard · Accepted Answer · 2017-12-21 00:42:54Z

2

 MapIndexed[f[#1, list[[#2[[1]] + 1]]] &, Most@list]

or

f @@ RotateLeft[list, #][[1 ;; 2]] & /@ Range[0, Length[list] - 2]

answered Dec 21, 2017 at 0:42

Alucard

2,70914 silver badges22 bronze badges

Add a comment |

eldo · Accepted Answer · 2023-12-12 00:09:09Z

2

list = {1, 2, 3, 4};

1.

SequenceCases - introduced in 2015 (10.1)

SequenceCases[list, {a_, b_} :> f[a, b], Overlaps -> True]

{f[1, 2], f[2, 3], f[3, 4]}

2.

BlockMap - introduced in 2015 (10.2)

BlockMap[Apply @ f, list, 2, 1]

{f[1, 2], f[2, 3], f[3, 4]}

answered Dec 12, 2023 at 0:09

eldo

83.1k6 gold badges72 silver badges202 bronze badges

Add a comment |

bmf · Accepted Answer · 2023-12-12 01:08:22Z

As of 2022 we have at our disposal the resource function called ThroughOperator that can do that. This is a development thanks to @Sjoerd Smit.

It was first suggested here. In the comment section under the answer @Sjoerd Smit gives motivation for its development and subsequent use for those interested. It was further used in this thread.

The main use is if we want to apply a number of functions on a list, however, we can use it in this example as well.

Flatten[ResourceFunction["ThroughOperator"][{f}] /@ 
   Partition[{1, 2, 3, 4}, 2, 1]] /. f[{a_, b_}] -> f[a, b]

{f[1, 2], f[2, 3], f[3, 4]}

Try for instance

Flatten[ResourceFunction["ThroughOperator"][{f, g, h, w}] /@ 
  Partition[{1, 2, 3, 4}, 2, 1]]

E. Chan-López · Accepted Answer · 2023-12-12 02:11:27Z

2

Using MapThread and Construct:

h[f_Symbol] := MapThread[Construct, {Array[f &, Length@#], Sequence @@ Transpose@#}] &;

h[f]@Partition[Range[4], 2, 1]

(*{f[1, 2], f[2, 3], f[3, 4]}*)

h[g]@Partition[{r, s, t, u, v, w}, 2, 1]

(*{g[r, s], g[s, t], g[t, u], g[u, v], g[v, w]}*)

answered Dec 12, 2023 at 2:11

E. Chan-López

31.2k3 gold badges29 silver badges50 bronze badges

Add a comment |

eldo · Accepted Answer · 2024-04-29 16:41:02Z

1

list = {1, 2, 3, 4};

Using Query and MapThread

MapThread[f, Query[{Most, Rest}] @ list]

{f[1, 2], f[2, 3], f[3, 4]}

answered Apr 29 at 16:41

eldo

83.1k6 gold badges72 silver badges202 bronze badges

Add a comment |

Stack Exchange Network

How to Map a subset of list elements to a function?

14 Answers 14

Your Answer

Not the answer you're looking for? Browse other questions tagged
list-manipulation
map
partitions
or ask your own question.

Linked

Hot Network Questions

How to Map a subset of list elements to a function?

14 Answers 14

Your Answer

Sign up or log in

Post as a guest

Not the answer you're looking for? Browse other questions tagged list-manipulationmappartitions or ask your own question.

Linked

Related

Hot Network Questions

Not the answer you're looking for? Browse other questions tagged
list-manipulation
map
partitions
or ask your own question.