Как расширить один список до длины другого?

Question

Вот мой код:

difference = len(L4)-len(L3)
if difference == 0:
    pass
elif difference > 0:
    x = L3[0:difference]
    L3.extend(x)
elif difference < 0:
    x = L4[0:difference]
    L4.extend(x)

L4 и L3 - это два отдельных списка, и я хочу, чтобы они были одинаковой длины. Я хочу, чтобы список L3 расширился до размера L4, если он меньше, и наоборот.

Пример первого ввода:

0;NATE;NATHAN      #NATE is L3, NATHAN IS L4

Пример первого вывода:

[78, 65, 84, 69, 78, 65]     #L3
[78, 65, 84, 72, 65, 78]     #L4

* Здесь список L3 распространяется на длину списка L4.

Пример второго ввода:

0;NAT;DNADNANNFNDFGDFGFGF

Пример второго вывода:

[78, 65, 84, 78, 65, 84]
[68, 78, 65, 68, 78, 65, 78, 78, 70, 78, 68, 70, 71, 68, 70, 71, 70, 71, 70]

После многократного тестирования моего кода выясняется, что L3, первая строка выведенного кода, будет повторяться дважды, прежде чем остановится, поэтому, если L4 невероятно длинен, L3 не будет расширяться до той же длины. Как мне решить эту проблему?

Answer 1

Если я не слишком изменю ваш код, вы можете попробовать что-то вроде:

Решение 1

L3 = list('NAT')
L4 = list('DNADNANNFNDFGDFGFGF')

difference = len(L4)-len(L3)
if difference == 0:
    pass
elif difference > 0:
    num_times, remainder = divmod(len(L4), len(L3))
    x = L3 * num_times + L3[:remainder]
    L3 = x
elif difference < 0:
    num_times, remainder = divmod(len(L3), len(L4))
    x = L4 * num_times + L4[:remainder]
    L4 = x

L3 = list(map(ord, L3))
L4 = list(map(ord, L4))

print(L3, '\n', L4, sep='')

Но если мы хотим упростить, мы могли быесть что-то вроде этого:

Решение 2

L3 = list('NAT')
L4 = list('DNADNANNFNDFGDFGFGF')

size_of_bigger = max(len(L3), len(L4))

num_times, remainder = divmod(size_of_bigger, len(L3))
L3 = L3 * num_times + L3[:remainder]

num_times, remainder = divmod(size_of_bigger, len(L4))
L4 = L4 * num_times + L4[:remainder]

output = "\n".join(str(list(map(ord, x))) for x in [L3, L4])
print(output)

Если мы проведем рефакторинг слишком далеко:

Решение 3

L3 = list('NAT')
L4 = list('DNADNANNFNDFGDFGFGF')

input_lists = [L3, L4]

size_of_bigger = max(map(len, input_lists))

def output_lists(input_lists):
    for current_list in input_lists:
        num_times, remainder = divmod(size_of_bigger, len(current_list))
        yield current_list * num_times + current_list[:remainder]

output = "\n".join(str(list(map(ord, x))) for x in output_lists(input_lists))
print(output)

Answer 2

Вы можете использовать цикл и islice из библиотеки itertools.

from itertools import cycle, islice

def process(shorter, aim):
  #shorter is a lit of int
  #aim is the targeted len
  return list(islice(cycle(shorter), aim))

L3 = [ord(i) for i in 'NATE' ]
L4 = [ord(i) for i in 'NATHAN']
difference = len(L4)-len(L3)
if difference == 0:
  pass
elif difference > 0:
  print(process(L3, len(L4)), L4)
elif difference < 0:
  print(L3, process(L4, len(L3)))

производит

[78, 65, 84, 69, 78, 65] [78, 65, 84, 72, 65, 78]

Если вы хотите более примитивное решение без вызова функции.Вы можете рассчитать, сколько раз вам придется повторить список, а также явно вычислить оставшуюся часть.