Single vector multiple times in 2d array

Question

This is my code:

b = [6 * [1, 3, 4, 2],
 4 * [2, 1, 4, 3],
 3 * [3, 4, 2, 1],
 4 * [4, 2, 1, 3],
 4 * [4, 3, 2, 1],
 ]

Which returns an array which has 6X4=24 elements in the first line 4X4=16 in the second etc...

What i want to achieve is adding the exact same line multiple times like:

1, 3, 4, 2
1, 3, 4, 2
1, 3, 4, 2
1, 3, 4, 2
1, 3, 4, 2
1, 3, 4, 2 #6 tines the first line
2, 1, 4, 3
2, 1, 4, 3
2, 1, 4, 3
2, 1, 4, 3 # 4 times the second
..........

but of course by not copying the same line again and again

This is answered in https://stackoverflow.com/questions/4501636/creating-sublists — Necklondon, May 15 '22 at 21:34
Thanks, even though this has 69 answers already i didn't find it before (probably because of my bad english), but i got the answer i wanted here — YourHelper, May 15 '22 at 21:57

score 2 · Answer 1 · answered May 15 '22 at 21:33

Try:

b = [
    *[[1, 3, 4, 2] for _ in range(6)],
    *[[2, 1, 4, 3] for _ in range(4)],
    *[[3, 4, 2, 1] for _ in range(3)],
    *[[4, 2, 1, 3] for _ in range(4)],
    *[[4, 3, 2, 1] for _ in range(4)],
]

print(b)

Prints:

[
    [1, 3, 4, 2],
    [1, 3, 4, 2],
    [1, 3, 4, 2],
    [1, 3, 4, 2],
    [1, 3, 4, 2],
    [1, 3, 4, 2],
    [2, 1, 4, 3],
    [2, 1, 4, 3],
    [2, 1, 4, 3],
    [2, 1, 4, 3],
    [3, 4, 2, 1],
    [3, 4, 2, 1],
    [3, 4, 2, 1],
    [4, 2, 1, 3],
    [4, 2, 1, 3],
    [4, 2, 1, 3],
    [4, 2, 1, 3],
    [4, 3, 2, 1],
    [4, 3, 2, 1],
    [4, 3, 2, 1],
    [4, 3, 2, 1],
]

Thanks a lot for answering, but the other one is faster that's why i gave it the check,but yours is upvoted too ;) — YourHelper, May 15 '22 at 21:50

score 1 · Accepted Answer · answered May 15 '22 at 21:42

1

You can also put it in one line with

b = 6*[[1, 3, 4, 2]] + 4*[[2, 1, 4, 3]] + 3*[[3, 4, 2, 1]] + 4*[[4, 2, 1, 3]] + 4* [[4, 3, 2, 1]])

print(b)

answered May 15 '22 at 21:42

Dynosol

26
2

score 0 · Answer 3 · answered May 15 '22 at 21:52

0

Only two steps if you don't want to change how b was created.

import numpy as np 

B = np.concatenate(b).ravel()
b = np.reshape(B,(21,4))

answered May 15 '22 at 21:52

AboAmmar

5,439
2
13
24

score 0 · Answer 4 · answered May 15 '22 at 21:57

You can use a list comprehension of a list comprehension to repeat y times your x lists (from bb and aa, respectively)

The notation is a bit strange, the "center" one is the outer element, then it expands on the right.

Advantage: numpy not required, and it will work for any size entries, unlike other answers "harcoding" the rows

aa=[[1, 3, 4, 2],
[2, 1, 4, 3],
[3, 4, 2, 1],
[4, 2, 1, 3],
[4, 3, 2, 1]]

bb=[6,4,3,4,4]

xx = [x for x,y in zip(aa,bb) for _ in range(y) ]

returns: [[1, 3, 4, 2], [1, 3, 4, 2], [1, 3, 4, 2], [1, 3, 4, 2], [1, 3, 4, 2], [1, 3, 4, 2], [2, 1, 4, 3], [2, 1, 4, 3], [2, 1, 4, 3], [2, 1, 4, 3], [3, 4, 2, 1], [3, 4, 2, 1], [3, 4, 2, 1], [4, 2, 1, 3], [4, 2, 1, 3], [4, 2, 1, 3], [4, 2, 1, 3], [4, 3, 2, 1], [4, 3, 2, 1], [4, 3, 2, 1], [4, 3, 2, 1]]

cards · Answer 5 · 2022-05-16T00:30:41.653

It can be done systematically by pairing the factors and the sublists and multiplying them together. Then flat the list.

Here a hacky-way

b = [[1, 3, 4, 2],
 [2, 1, 4, 3],
 [3, 4, 2, 1],
 [4, 2, 1, 3],
 [4, 3, 2, 1],
 ]

factors = [6, 4, 3, 4, 4]

print(sum(f*[l] for f, l in zip(factors, b), []))

The flattening part (chaining of lists) is done with sum( , []) but is not performant (and designed for that)... but still useful, in my opinion, to test some small stuffs on the fly. The list chaining have to be done with i.e. itertools.chain. Here an example

import itertools as it
...
list(it.chain.from_iterable(f*[l] for f, l in zip(factors, b)))

# or (for many iterators)
list(it.chain(*(f*[l] for f, l in zip(factors, b))))

# or with repeat
list(it.chain.from_iterable(it.starmap(it.repeat, zip(b, factors))))

# or (another) with repeat
list(it.chain.from_iterable(map(it.repeat, b, factors))

# or ...
list(it.chain.from_iterable(map(list.__mul__, ([i] for i in b) , factors)))

# or with reduce
import functools as fc

list(fc.reduce(lambda i, j: i + j, zip(b, factors)))

Single vector multiple times in 2d array

5 Answers5