Styjun

Here is my code:

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 and L3 are two separate lists, and I want them to be the same length. I want list L3 to extend to the size of L4 if it is smaller, and vice versa.

Example One Input:

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

Example One Output:

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

*Here, list L3 extends to the length of list L4.

Example Two Input:

0;NAT;DNADNANNFNDFGDFGFGF

Example Two Output:

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

After testing my code multiple times, it appears that L3, the first line of outputted code, will iterate twice before coming to a stop, so if L4 is incredibly long, L3 will not extend to the same length. How do I resolve this?

You can use cycle and islice from the itertools library.

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

produces

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

If you want a more primitive solution without calling function. You might like to compute how many times you have to repeat the list and also compute the remaining part explicitly.

If I do not change your code too much you could try something like:

Solution 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='')

But if we want to simplify, we could have something like that:

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

If we push the refactoring a little bit too far:

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