How to repeat one list to match the length of another?

I have two lists:

A = ['a', 'b', 'c', 'd', 'e']
B = ['c', 'a', 't']

How could I repeat the items of B to match the length of A?

C = ['c', 'a', 't', 'c', 'a']

Alternatively, would it also be possible to combine A and B to yield:

C = ['ac', 'ba', 'ct', 'dc', 'ea']

The logic is unclear, but assuming that you want to repeat the items of B as many times as needed to match the length of A, use itertools.cycle and itertools.islice:

from itertools import cycle, islice

A = ['a', 'b', 'c', 'd', 'e']
B = ['c', 'a', 't']

C = list(islice(cycle(B), len(A)))

Output: ['c', 'a', 't', 'c', 'a']

For fun, another (less efficient) approach but without imports, repeating, then slicing A:

C = (B*-(-len(A)//len(B)))[:len(A)]

# -(-len(A)//len(B)) is a trick to get the ceiled value of len(A)/len(B)

combining A and B

from itertools import cycle

C = [''.join(x) for x in zip(A, cycle(B))]

# or
C = [f'{a}{b}' for a, b in zip(A, cycle(B))]

Output: ['ac', 'ba', 'ct', 'dc', 'ea']

To repeat a list n times, use ls * n.

Example:

ls = ['d', 'o', 'g']
ls * 3

Output is:

['d', 'o', 'g', 'd', 'o', 'g', 'd', 'o', 'g']

To add partial repetitions, use slicing to get the last partial repetition and add to full repetitions, you can get the required full repetitions and remainder by using divmod:

ls = ['s', 'i', 'n', 'g', 'u', 'l', 'a', 'r', 'i', 't', 'y']
n = 24
f, r = divmod(n, len(ls))
ls * f + ls[:r]

Output:

['s', 'i', 'n', 'g', 'u', 'l', 'a', 'r', 'i', 't', 'y', 's', 'i', 'n', 'g', 'u', 'l', 'a', 'r', 'i', 't', 'y', 's', 'i']

You can wrap it in a function so that you can easily reuse it:

def repeat(ls, n):
    f, r = divmod(n, len(ls))
    return ls * f + ls[:r]

Example usage:

In [595]: repeat('Python', 16)
Out[595]: 'PythonPythonPyth'

You can also use a list comprehension to do that, just use modular arithmetic to scale down the index when it is greater than or equal to the length of the list:

def repeat_listcomp(ls, n):
    l = len(ls)
    return [ls[i%l] for i in range(n)]

The first preserves the data type of the argument, the second doesn't.

I should add the accepted answer is much more efficient than my list comprehension solution but much slower than my original solution (I mistook the ns to µs), and my code helps you understand it better:

In [598]: %timeit repeat_listcomp('abcdefghijklmnopqrstuvwxyz', 2048)
150 µs ± 1.85 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [599]: %timeit repeat('abcdefghijklmnopqrstuvwxyz', 2048)
754 ns ± 21.1 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

In [600]: from itertools import cycle, islice

In [601]: %timeit list(islice(cycle('abcdefghijklmnopqrstuvwxyz'), 2048))
32.9 µs ± 821 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

I have understand that you want a script which put cat word the len of A list:

It is written in Python.

A = ['a' , 'b' , 'c' , 'd' , 'e']

B = ['c' , 'a' , 't']

C = []
C_combine_A_B = []

b_len = len(B)
a_len = len(A)

i = 0
while i < a_len:
    C.append(B[i%b_len])
    C_combine_A_B.append(A[i]+B[i%b_len])
    i+=1

print(C)
print(C_combine_A_B)

If you do not understand something tell me and I will explain you.

EDIT: combined list impl added

C = B + [x for x in B if x in A]

As there's no clear explanation of logic, the most straightforward approach to get desired C list is to concatenate B list with elements of A list that B list contains.

You could use divmod to compute how many times to repeat B and what extra range to add at the end:

A = ['a', 'b', 'c', 'd', 'e']
B = ['c', 'a', 't']

r,x = divmod(len(A),len(B))  # repeats, extra
C   = B*r + B[:x]

print(C)
['c', 'a', 't', 'c', 'a']

Another approach could be to use extend:

C = B[:len(A)]
C.extend( C[i] for i in range(len(A)-len(B)) )

print(C)
['c', 'a', 't', 'c', 'a']

For your alternate approach, a list comprehension with modulo indexing could do it:

C = [a+B[i%len(B)] for i,a in enumerate(A)]

print(C)
['ac', 'ba', 'ct', 'dc', 'ea']

or a gnarly map/zip:

*C, = map("".join,zip(A,B*(1+len(A)//len(B))))

print(C)
['ac', 'ba', 'ct', 'dc', 'ea']

# or using itertools:

from itertools import cycle
*C, = map("".join,zip(A,cycle(B)))