Single vector multiple times in 2d array-CodePudding

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

CodePudding user response：

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],
]

CodePudding user response：

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)

CodePudding user response：

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))

CodePudding user response：

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]]

CodePudding user response：

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)))