How to get such rule with a elegant method

Question

I have two lists:

list={{1,2,3,5},{5,3,9,11,12},{5,9,10,16}};
list2={{7,89},{96,5},{-6,-98}};

This is the expected result.

{{1->{7,89},2->{7,89},3->{7,89},5->{7,89}},
 {5->{96,5},3->{96,5},9->{96,5},11->{96,5},12->{96,5}},
 {5->{-6,-98},9->{-6,-98},10->{-6,-98},16->{-6,-98}}}

This is my current try.

Thread /@ 
 Thread[Rule[list, 
   MapIndexed[ConstantArray[list2[[First[#2]]], Length[#1]] &, list]]]

score 14 · Accepted Answer · answered Dec 25 '16 at 18:54

14

Tuples /@ Thread[list -> List /@ list2]

{
 {1 -> {7, 89}, 2 -> {7, 89}, 3 -> {7, 89}, 5 -> {7, 89}},
 {5 -> {96, 5}, 3 -> {96, 5}, 9 -> {96, 5}, 11 -> {96, 5}, 12 -> {96, 5}},
 {5 -> {-6, -98}, 9 -> {-6, -98}, 10 -> {-6, -98}, 16 -> {-6, -98}}
}

answered Dec 25 '16 at 18:54

Mr.Wizard

271,378
34
587
1,371

Good lesson to me.Thanks. – yode Dec 25 '16 at 18:58
@yode You're welcome :^) – Mr.Wizard Dec 25 '16 at 19:01
I mean,your usage of Tuples and List/@ astonish me. :) – yode Dec 25 '16 at 19:04
@yode I was just having good-natured fun with your typo. I am glad you learned from this example. Quite a few functions work on heads other than List which is quite handy, e.g. (1312) – Mr.Wizard Dec 26 '16 at 03:13
It's not a typo.I just cannot hold the temper of my English sometimes. :) – yode Dec 26 '16 at 03:26
Killer. Would be great to compile a list of such one-liners to show the power of functional approach. – alancalvitti Dec 28 '16 at 16:41

score 10 · Answer 2 · answered Dec 25 '16 at 07:52

10

MapIndexed[# -> list2[[#2[[1]]]] &, list, {2}]

or

ReplacePart[list, {i_, j_} :> list[[i, j]] -> list2[[i]]]

answered Dec 25 '16 at 07:52

WReach

68,832
4
164
269

Wow,thanks.This is very concise method,too. – yode Dec 25 '16 at 08:08

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

9

Thread /@ Thread[list -> Hold /@ list2] // ReleaseHold
Thread /@ Thread[list → Unevaluated /@ list2] /. a_ → b_ -> a -> b
Thread /@ Thread[list -> $ /@ list2] /. $ -> (# &)

As to the reason why I used RightArrow as a medium in the second solution, you may want to read this post.

edited Apr 13 '17 at 12:55

Community

1

answered Dec 25 '16 at 07:27

xzczd

65,995
9
163
468

+1)Impressive...BTY,how do you type that second $\to$? – yode Dec 25 '16 at 07:31
@yode I just transformed \[RightArrow] with M.SE editor :) . – xzczd Dec 25 '16 at 07:41
You can also type ESC SPACE - > ESC. – WReach Dec 25 '16 at 07:54

score 9 · Answer 4 · edited Dec 25 '16 at 16:17

9

Another way to use Thread:

Thread[#, List, 1] & /@ Thread[list -> list2]

{{1 -> {7, 89}, 2 -> {7, 89}, 3 -> {7, 89}, 5 -> {7, 89}}, 
 {5 -> {96, 5}, 3 -> {96, 5}, 9 -> {96, 5}, 11 -> {96, 5}, 12 -> {96, 5}}, 
 {5 -> {-6, -98}, 9 -> {-6, -98}, 10 -> {-6, -98}, 16 -> {-6, -98}}}

edited Dec 25 '16 at 16:17

m_goldberg

107,779
16
103
257

answered Dec 25 '16 at 14:44

kglr

394,356
18
477
896

score 9 · Answer 5 · answered Dec 25 '16 at 16:35

9

MapThread + Outer:

MapThread[Outer[Rule, ##, 1] &, {list, List /@ list2}]

Obfuscatory:

or

o = (\[FivePointedStar] \[Function] \[FivePointedStar] -> #2) /@ # & @@@ ({##}\[Transpose]) &;
o[list, list2]

answered Dec 25 '16 at 16:35

Michael E2

235,386
17
334
747

Upvote for Star. :) – yode Dec 25 '16 at 18:59

score 7 · Answer 6 · answered Dec 25 '16 at 10:16

7

MapThread[Map[Function[x, Rule[x, #2]], #1] &, {list, list2}]

answered Dec 25 '16 at 10:16

ubpdqn

60,617
3
59
148

1

Joke version: MapThread[(#0[[0]] @@ {#0[[1, 2]] -> #2}) /@ # &, {list, list2}] – Jacob Akkerboom Dec 28 '16 at 15:12

score 6 · Answer 7 · answered Dec 25 '16 at 16:15

I'm late to this party, but I don't see any other answer like this:

 helper[{u_, v_}] := Rule[#, v] & /@ u
 helper /@ Transpose[{list, list2}]

{{1 -> {7, 89}, 2 -> {7, 89}, 3 -> {7, 89}, 5 -> {7, 89}}, 
 {5 -> {96, 5}, 3 -> {96, 5}, 9 -> {96, 5}, 11 -> {96, 5}, 12 -> {96, 5}}, 
 {5 -> {-6, -98}, 9 -> {-6, -98}, 10 -> {-6, -98}, 16 -> {-6, -98}}}

This seems to me to be a nice, simple way of solving the problem.

score 1 · Answer 8 · answered Dec 28 '16 at 13:55

1

This works, and it is easy to understand:

Flatten[MapThread[ Function[{l1, l2}, Map[{# -> l2} &, l1]], {list, list2}], 1]

answered Dec 28 '16 at 13:55

CElliott

560
2
7

How to get such rule with a elegant method

8 Answers8