Using MapAt to map at a particular depth (levelspec)

Question

I have the following sample list (my actual list is, of course, much longer):

A={{{"15", "CG"}, {"391", "CG"}, {"412", "CC3"}}, {{"3", "CG"}, 
    {"16", "CG"}, {"392", "CG"}}};

I would like to map an arbitrary function f onto the string representation of numbers, like this:

{{{f["15"], "CG"}, {f["391"], "CG"}, {f["412"], "CC3"}}, {{f["3"], "CG"}, 
  {f["16"], "CG"}, {f["392"], "CG"}}}

Is there a straightforward, succinct way of doing this using Map, MapAt, or something else? Unlike Map, it seems that MapAt does not have an option with levelspec.

score 23 · Accepted Answer · answered May 18 '12 at 19:35

23

A combination of Map and MapAt perhaps?

Map[MapAt[f, #, 1] &, A, {2}]

(* ===>  {{{f["15"], "CG"}, {f["391"], "CG"}, {f["412"], "CC3"}}, 
         {{f["3"], "CG"}, {f["16"], "CG"}, {f["392"], "CG"}}} 
*)

answered May 18 '12 at 19:35

Sjoerd C. de Vries

65,815
14
188
323

kglr · Answer 2 · 2012-05-18T19:45:51.327

20

To map f to number strings appearing at any position or depth:

Map[If[StringMatchQ[#, NumberString], f[#], #] &, A, {-1}]
(* => {{{f["15"], "CG"}, {f["391"], "CG"}, {f["412"], "CC3"}}, {{f["3"], "CG"}, {f["16"], "CG"}, {f["392"], "CG"}}} *)

another example:

b = {{{"15", "CG"}, {{"391", "CG"}, "230"}, {"412", "CC3"}}, {{"3", 
 "CG"}, {"392", {"CG", {"CG", "345"}}}}};
Map[If[StringMatchQ[#, NumberString], f[#], #] &, b, {-1}]
(* => {{{f["15"], "CG"}, {{f["391"], "CG"}, f["230"]}, {f["412"], "CC3"}}, {{f["3"], "CG"}, {f["392"], {"CG", {"CG", f["345"]}}}}} *)

edited May 18 '12 at 19:45

answered May 18 '12 at 19:36

kglr

394,356
18
477
896

1

This one deserves more credit, +1 – Rojo May 18 '12 at 20:31

score 15 · Answer 3 · answered May 19 '12 at 09:48

15

More options:

Apply[{f[#1], ##2} &, A, {2}]

{f[#1], ##2} & @@@ # & /@ A

ReplacePart[A, {i_, j_, 1} :> f @ A[[i, j, 1]] ]

ReplacePart[A, p:{_, _, 1} :> f @ Extract[A, p] ]

answered May 19 '12 at 09:48

Mr.Wizard

271,378
34
587
1,371

@David I'm not sure how to read that; is the code hard to read? (I think ReplacePart is quite readable myself.) – Mr.Wizard May 19 '12 at 13:21
The second example would be difficult to read for the newly initiated in mma. My +1 more accurately reflects my amazement at your skill in crafting so many different solutions. – DavidC May 19 '12 at 13:43

Rojo · Answer 4 · 2012-05-18T21:53:46.387

14

A[[All, All, 1]] = Map[f, A[[All, All, 1]], {2}]

I think the neatest given the question is probably a mix between David Carraher and kguler's

A /. x_String /; StringMatchQ[x, NumberString] :> f[x]

or a little bit more efficiently, searching only the lowest levels

Replace[A, x_String /; StringMatchQ[x, NumberString] :> f[x], {-1}]

edited May 18 '12 at 21:53

answered May 18 '12 at 20:03

Rojo

42,601
7
96
188

This solution intrigues me, but I don't think it all got posted – Jagra May 18 '12 at 20:16
It makes the changes in place. Why does it intrigue you @Jagra? – Rojo May 18 '12 at 20:19
A construct (A[[All,All,1]] =), that I just never thought of using before. Except I can't get it work properly ;-( – Jagra May 18 '12 at 20:23
1

@Jagra, since the changes are made in place, you can use it only once. If you run it twice, you get f[f["23"]], etc – Rojo May 18 '12 at 20:25
1

Also, don't look at the output of that line. Look at the value of A after running the line – Rojo May 18 '12 at 20:26
Ah! Another mystery revealed. Thanks. Very cool. – Jagra May 18 '12 at 20:27

score 13 · Answer 5 · edited May 21 '12 at 09:43

13

Try a very simple idea:

A = {{{"15", "CG"}, {"391", "CG"}, {"412", "CC3"}}, {{"3", 
     "CG"}, {"16", "CG"}, {"392", "CG"}}};

g[{x_, y_}] := {f[x], y};

Map[g, A, {2}]

{{{f["15"], "CG"}, {f["391"], "CG"}, {f["412"], "CC3"}}, {{f["3"], 
   "CG"}, {f["16"], "CG"}, {f["392"], "CG"}}}

edited May 21 '12 at 09:43

Mr.Wizard

271,378
34
587
1,371

answered May 21 '12 at 08:04

Alexei Boulbitch

39,397
2
47
96

score 11 · Answer 6 · answered May 19 '12 at 00:18

I like to use @@ (or @@@ on lists) since #1 is easier to read than #[[1]] in the middle (muddle) of more brackets:

Map[{f[#1], #2} & @@ # &, A, {2}]

{{{f["15"], "CG"}, {f["391"], "CG"}, {f["412"], "CC3"}}, {{f["3"], 
   "CG"}, {f["16"], "CG"}, {f["392"], "CG"}}}

DavidC · Answer 7 · 2012-05-19T13:12:43.750

10

Perhaps

 g = # /. {a_String, b_String} :>  {f[a], b} &;
 g@A

yielding

{{{f["15"], "CG"}, {f["391"], "CG"}, {f["412"], "CC3"}}, {{f["3"], 
"CG"}, {f["16"], "CG"}, {f["392"], "CG"}}}

edited May 19 '12 at 13:12

answered May 18 '12 at 19:40

DavidC

16,724
1
42
94

score 10 · Answer 8 · answered May 18 '12 at 20:40

10

Another possibility, which I don't think has been given (but is similar to other answers):

Map[{f@First@#, Last@#} &, A, {2}]

answered May 18 '12 at 20:40

user1066

17,923
3
31
49

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

9

As @Kuba shows here, now in version 9 you can do:

MapAt[f,A,{All,All,1}]

edited Apr 13 '17 at 12:55

Community

1

answered Aug 27 '13 at 03:47

Murta

26,275
6
76
166

4

It might be nice to mention that Kuba brought this to your attention. – Mr.Wizard Aug 27 '13 at 04:25
I agree. Done :) – Murta Aug 27 '13 at 11:24
even MapAt[f,A,{;;,;;,1}] – garej Jan 29 '16 at 09:22

Jagra · Answer 10 · 2012-05-18T20:29:30.243

9

Map on map does the job nicely:

{f[#[[1]]], #[[2]]} & /@ # & /@ A

{{{f[15],CG},{f[391],CG},{f[412],CC3}},{{f[3],CG},{f[16],CG},{f[392],CG}}}

edited May 18 '12 at 20:29

answered May 18 '12 at 19:46

Jagra

14,343
1
39
81

score 7 · Answer 11 · answered May 18 '12 at 21:17

7

A /. a_?(StringMatchQ[#, DigitCharacter ..] &) :> f[a] // Quiet

answered May 18 '12 at 21:17

unstable

1,497
15
14

score 1 · Answer 12 · answered Oct 17 '23 at 22:47

 list = {
   {{"15", "CG"}, {"391", "CG"}, {"412", "CC3"}},
   {{"3", "CG"}, {"16", "CG"}, {"392", "CG"}}};

1.

Since V 13.1 there is ReplaceAt:

ReplaceAt[list, a_ :> f[a], {All, All, 1}]

{{{f["15"], "CG"}, {f["391"], "CG"}, {f["412"], "CC3"}}, {{f["3"], "CG"}, {f["16"], "CG"}, {f["392"], "CG"}}}

2.

We can use it to apply f only if the first list member is a number string:

list = {
   {{"xx", "CG"}, {"391", "CG"}, {"yy", "CC3"}},
   {{"3", "CG"}, {"16", "CG"}, {"392", "CG"}}};
ReplaceAt[list, 
 a_?(StringMatchQ[#, NumberString] &) :> Log @ N @ ToExpression[a], {All, All, 1}]

{{{"xx", "CG"}, {5.96871, "CG"}, {"yy", "CC3"}}, {{1.09861, "CG"}, {2.77259, "CG"}, {5.97126, "CG"}}}

3.

I also like Query:

Query[All, All, {1 -> f}] @ list

{{{f["15"], "CG"}, {f["391"], "CG"}, {f["412"], "CC3"}}, {{f["3"], "CG"}, {f["16"], "CG"}, {f["392"], "CG"}}}

Using MapAt to map at a particular depth (levelspec)

12 Answers12

Linked

Related