Riffle but not quite

Question

Given the two lists below, is there an in-built command or otherwise neat way of accomplishing the desired output.

list = {{1, 2}, {5, 2}, {9, 3}, {6, 5}};
x = {x1, x2, x3, x4, x5, x6, x7};
desiredOutput = {{1, 2, x1}, {5, 2, x2}, {9, 3, x3}, {6, 5, x4}};

My attempt seems ugly:

{list[[#]][[1]], list[[#]][[2]], x[[#]]} & /@ (list // Length // Range)

Also related: (189), (13748), (14494) – Mr.Wizard Jun 21 '16 at 11:09 — Mr.Wizard, Jun 21 '16 at 11:09

Mr.Wizard · Answer 1 · 2016-06-21T14:43:19.407

16

There are so many ways to handle a problem like this and which one is preferred with depend on style, performance, the type and shape of your data, ease of recollection, etc., but here are several more:

Join[list, x ~Take~ Length[list] ~Partition~ 1, 2]

Riffle[Flatten @ list, x, {3, -1, 3}] ~Partition~ 3

PadRight[list, {Automatic, 3}, List /@ x]

And one inspired by J.M.'s use of Flatten

{list, x} ~Flatten~ {2} // Cases[{{x__}, y_} :> {x, y}]

edited Jun 21 '16 at 14:43

answered Jun 21 '16 at 11:11

Mr.Wizard

271,378
34
587
1,371

1

Yes, that is making nice use of Riffle right there. Good when one can read the documentation. :) – gwr Jun 21 '16 at 11:25
@gwr Thank you! – Mr.Wizard Jun 21 '16 at 11:30

e.doroskevic · Accepted Answer · 2016-06-21T11:14:59.273

15

Example

Code

list = {{1, 2}, {5, 2}, {9, 3}, {6, 5}};
x = {x1, x2, x3, x4, x5, x6, x7};

MapThread[Append, {list, x[[;; Length  @ list]]}]

Output

{{1, 2, x1}, {5, 2, x2}, {9, 3, x3}, {6, 5, x4}}

Reference

Append
MapThread

edited Jun 21 '16 at 11:14

answered Jun 21 '16 at 11:03

e.doroskevic

5,959
1
13
32

Why does MapThread[Append, {list, x[[;; Length @ list]]}] work but not MapThread[Append, {list, x[[;; list // Length]]}] work? Even though list // Length and Length@list give the same result? – Tom Jun 21 '16 at 11:10
1

@Tom consider ;; list // Length and ;; (list // Length). – Kuba Jun 21 '16 at 11:13
Oh ok, I suppose it's my lack of understanding of the order in which Mathematica computes things which tripped me up. – Tom Jun 21 '16 at 11:15

score 12 · Answer 3 · answered Jun 21 '16 at 11:24

12

Shortest so far:

i = 1; list /. {a_, b_} :> {a, b, x[[i++]]}

answered Jun 21 '16 at 11:24

xzczd

65,995
9
163
468

5

+1, but after you add a Module to correctly localize i it will be longer than PadRight. :^) – Mr.Wizard Jun 21 '16 at 11:29

Marius Ladegård Meyer · Answer 4 · 2016-06-21T15:43:39.407

Transpose[Join[Transpose[list], {Take[x, Length[list]]}]]

should be quite fast for long lists. On my work desktop,

rand = RandomInteger[{1, 10}, {10^5, 2}];
xar = Array[x, 10^6];
AT = AbsoluteTiming;

AT[l1 = Transpose[Join[Transpose[rand], {Take[xar, Length[rand]]}]];]
(* {0.032721, Null} *)

AT[l2 = MapThread[Append, {rand, xar[[;; Length@rand]]}];]
(* {0.112556, Null} *)

AT[l3 = Table[{rand[[k, 1]], rand[[k, 2]], xar[[k]]}, {k, 1, 
     Length[rand]}];]
(* {1.975830, Null} *)

l1 == l2 == l3
(* True *)

EDIT: Some more timings just for fun, in no particular order :)

AT[l4 = (i = 1; rand /. {a_, b_} :> {a, b, xar[[i++]]});]
(* {0.161642, Null} *)

AT[l5 = ArrayFlatten[{{rand, {#} & /@ xar[[1 ;; Length[rand]]]}}];]
(* {0.186327, Null} *)

AT[l6 = Append @@@ 
    DeleteCases[Flatten[{rand, xar}, {{2}, {1}}], {_}];]
(* {1.054091, Null} *)

AT[l7 = MapIndexed[Join[#1, xar[[#2]]] &, rand];]
(* {0.277814, Null} *)

AT[l8 = Join[rand, xar~Take~Length[rand]~Partition~1, 2];]
(* {0.083558, Null} *)

AT[l9 = Riffle[Flatten@rand, xar, {3, -1, 3}]~Partition~3;]
(* {0.028951, Null} *)

AT[l10 = PadRight[rand, {Automatic, 3}, List /@ xar];]
(* {0.315211, Null} *)

score 8 · Answer 5 · answered Jun 21 '16 at 10:57

8

How about this using Table?

Table[{list[[k, 1]], list[[k, 2]], x[[k]]}, {k, 1, Length[list]}]

answered Jun 21 '16 at 10:57

Lotus

2,671
11
10

score 7 · Answer 6 · answered Jun 21 '16 at 12:41

7

Using MapIndexed...

MapIndexed[Join[#1, x[[#2]]] &, list]

answered Jun 21 '16 at 12:41

Ymareth

4,741
20
28

score 6 · Answer 7 · answered Jun 21 '16 at 12:29

6

Yet another possibility, using Flatten[] as a "generalized Transpose[]":

Append @@@ DeleteCases[Flatten[{list, x}, {{2}, {1}}], {_}]
   {{1, 2, x1}, {5, 2, x2}, {9, 3, x3}, {6, 5, x4}}

answered Jun 21 '16 at 12:29

J. M.'s missing motivation

124,525
11
401
574

1

Shorter: Append @@@ Cases[Flatten[{list, x}, {2}], {_, _}] (and +1) – Mr.Wizard Jun 21 '16 at 14:38
1

Yes, that's more compact, @Mr. Wizard. Nevertheless, I still feel the need to remind myself of what Flatten[] is doing by specifying all levels explicitly in the second argument. But that's just my crutch... – J. M.'s missing motivation Jun 21 '16 at 14:43
A perfectly valid crutch, IMHO. – Mr.Wizard Jun 21 '16 at 14:44

score 3 · Answer 8 · answered Jun 21 '16 at 12:21

3

list = {{1, 2}, {5, 2}, {9, 3}, {6, 5}}; 
x = {x1, x2, x3, x4, x5, x6, x7};
ArrayFlatten[{{list, {#} & /@ x[[1 ;; 4]]}}]

{{1, 2, x1}, {5, 2, x2}, {9, 3, x3}, {6, 5, x4}}

answered Jun 21 '16 at 12:21

score 3 · Answer 9 · answered Jun 21 '16 at 15:50

3

I haven't seen this yet, but it may be degenerate with someone else's answer.

Append @@@ Partition[Riffle[list, x], 2]

answered Jun 21 '16 at 15:50

N.J.Evans

5,093
19
25

score 3 · Answer 10 · edited May 23 '17 at 12:35

3

ArrayFlatten[{{list, Transpose[{x[[;; Length@list]]}]}}]

See here for some interesting comparisons by Timo

edited May 23 '17 at 12:35

Community

1

answered Jul 20 '16 at 20:23

user41753

31
1

score 3 · Answer 11 · answered Jul 20 '16 at 20:51

3

I think the preferred way to append columns X to matrix A is probably:

Join[X, A, 2]

Adding a single column is slightly less tidy

Join[list, Transpose[{x}], 2]

answered Jul 20 '16 at 20:51

mikado

16,741
2
20
54

score 3 · Answer 12 · answered Jan 03 '24 at 23:46

a = {{1, 2}, {5, 2}, {9, 3}, {6, 5}};
b = {x1, x2, x3, x4, x5, x6, x7};

Some more possibilities:

ReplacePart

ReplacePart[i_ :> Append[a[[i]], b[[i]]]] @ a

{{1, 2, x1}, {5, 2, x2}, {9, 3, x3}, {6, 5, x4}}

Table with Splice (new in 12.1)

Table[{Splice @ a[[i]], b[[i]]}, {i, Length @ a}]

{{1, 2, x1}, {5, 2, x2}, {9, 3, x3}, {6, 5, x4}}

Transpose with TrimRight

Needs["GeneralUtilities`"]
Flatten /@ Transpose @ TrimRight[{a, b}]

{{1, 2, x1}, {5, 2, x2}, {9, 3, x3}, {6, 5, x4}}

E. Chan-López · Answer 13 · 2024-01-04T04:37:38.637

3

Using Transpose and ReplaceAll as follows:

Transpose@{a, b[[;; Length@a]]} /. x_ /; VectorQ[x] :> Splice@x
({{1, 2, x1}, {5, 2, x2}, {9, 3, x3}, {6, 5, x4}})

Or using Cases:

Cases[Transpose@{#, b[[;; Length@#]]}, {x : {__}, y_} :> {Splice@x, y}] &@a
({{1, 2, x1}, {5, 2, x2}, {9, 3, x3}, {6, 5, x4}})

edited Jan 04 '24 at 04:37

answered Jan 04 '24 at 02:28

E. Chan-López

23,117
3
21
44

score 3 · Answer 14 · answered Jan 04 '24 at 06:01

Clear["Global`*"]
list = {{1, 2}, {5, 2}, {9, 3}, {6, 5}};
x = {x1, x2, x3, x4, x5, x6, x7};

To accomodate varying lengths of each of the above vectors:

minlen = Min[Length /@ {list, x}];
listm = list[[1 ;; minlen]];
xm = x[[1 ;; minlen]];

Here are some variations without repeating the Part construct:

SequenceReplace[
 Riffle[listm, xm], {a_List, b_ } :> {Sequence @@ a, b}]
MapThread[Riffle[#1, #2, 1 + Length@#1] &, {listm, xm}]
Join[listm, Transpose[{xm}], 2]
MapThread[Join[#1, {#2}] &, {listm, xm}]
MapThread[Append[#1, #2] &, {listm, xm}]
MapThread[Catenate[{#1, #2}] &, {listm, Transpose[{xm}]}]

Result:

{{1, 2, x1}, {5, 2, x2}, {9, 3, x3}, {6, 5, x4}}

user1066 · Answer 15 · 2024-01-05T14:05:43.207

3

BlockMap[Flatten,Riffle[list, x[[;;Length@list]]],2]

(* {{1,2,x1},{5,2,x2},{9,3,x3},{6,5,x4}} *)

In addition, a variation on the neat answer given by xzczd

MapThread[Replace,{list,{a_, b_} :> {a, b, x[[#]]}&/@Range@Length@list}]
({{1,2,x1},{5,2,x2},{9,3,x3},{6,5,x4}} )

edited Jan 05 '24 at 14:05

answered Jan 04 '24 at 19:06

user1066

17,923
3
31
49

1

(+1) I like to see BlockMap in action. – E. Chan-López Jan 04 '24 at 19:59

Riffle but not quite

15 Answers15

Linked