Duplicating and arranging a list [duplicate]

Question

I have a list,

{a,b,c,d,...,z}

And I want to duplicate that list n times such that,

{a,a,a,b,b,b,c,c,c,....z,z,z}.

I have found the Table function can create duplicates by appending to the end of the list. Is this the way to go and then reordering? If so, how?

Any help would be appreciated.

Answer 1

You can use Map (or its shorthand /@) together with Sequence over the list:

list = {a, b, c}
Sequence[#, #, #] & /@ list
(* {a, a, a, b, b, b, c, c, c} *)

For larger amounts of repetition, that gets annoying. In that case, you can use ConstantArray and the remove the List head:

list = {a, b, c}
n = 5
Sequence @@ ConstantArray[#, n] & /@ list
(* {a, a, a, a, a, b, b, b, b, b, c, c, c, c, c} *)

As J. M. mentions you can also use Flatten (or even Join) instead of Sequence:

Flatten[ConstantArray[#, n] & /@ list]
Join @@ (ConstantArray[#, n] &) /@ list

Answer 2

f1 = Flatten@Transpose@ConstantArray@## &;
f2 = With[{ls = #}, Flatten[Transpose@Array[ls &, #2]]] &;
f3 = Flatten@Transpose[Table[#, {#2}]] &;
f4 = Flatten[ArrayPad[List /@ #, {{0, 0}, {0, #2 - 1}}, "Fixed"]] &;

lst = {a, b, c, d};

f1[lst, 3]

{a, a, a, b, b, b, c, c, c, d, d, d}

 Equal @@ (#[lst, 3] & /@ {f1, f2, f3, f4})

True

Timings:

list = RandomReal[{0, 1}, 1000000];
n = 3;
{t1, r1} = f1[list, n] // AbsoluteTiming;
{t2, r2} = f2[list, n] // AbsoluteTiming;
{t3, r3} = f3[list, n] // AbsoluteTiming;
{t4, r4} = f4[list, n] // AbsoluteTiming;
{t5, r5} = Flatten[ConstantArray[#, n] & /@ list] // AbsoluteTiming;
{t6, r6} = Sequence @@ ConstantArray[#, n] & /@ list // AbsoluteTiming;
{t7, r7} = Flatten@Replace[list, a_ :> Table[a, {n}], 1] // AbsoluteTiming;
{t8, r8} = Flatten[NestList[# &, #, 2] & /@ list] // AbsoluteTiming;

{t1, t2, t3, t4, t5, t6, t7, t8}

{0.044306, 0.034579, 0.021672, 0.111301, 0.558783, 2.088776, 1.020894, 0.369900}

Equal @@ {r1, r2, r3, r4, r5, r6, r7, r8}

True

Answer 3

This one is just for fun,

list = ToExpression /@ Alphabet[]
Most@Fold[Riffle[#1, list, #2] &, list~Join~{dummy}, Range[2, 5]]

(* {a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, 
u, v, w, x, y, z} *)

(* {a, a, a, a, a, b, b, b, b, b, c, c, c, c, c, d, d, d, d, d, 
e, e, e, e, e, f, f, f, f, f, g, g, g, g, g, h, h, h, h, h, i, i, i, 
i, i, j, j, j, j, j, k, k, k, k, k, l, l, l, l, l, m, m, m, m, m, n, 
n, n, n, n, o, o, o, o, o, p, p, p, p, p, q, q, q, q, q, r, r, r, r, 
r, s, s, s, s, s, t, t, t, t, t, u, u, u, u, u, v, v, v, v, v, w, w, 
w, w, w, x, x, x, x, x, y, y, y, y, y, z, z, z, z, z} *)

You need the dummy variable or else Riffle won't put any extra zs on the end.

Answer 4

A replacement version:

lst = {a, b, c, d};
Replace[lst, a_ :> Sequence[a, a, a], 1]
(* {a, a, a, b, b, b, c, c, c, d, d, d} *)

or

Replace[lst, a_ :> Sequence @@ Table[a, {5}], 1]
(* {a, a, a, a, a, b, b, b, b, b, c, c, c, c, c, d, d, d, d, d} *)

or, slightly faster,

Flatten@Replace[lst, a_ :> Table[a, {5}], 1]