Блог

Вот мой код:

 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 не будет расширяться до такой же длины. Как мне решить эту проблему?

Вы можете использовать cycle и 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]
  

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

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

Решение 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)