How can you manipulate a string to equal the length of another string?

Question

For example, I have the string s1 = "lets go to the mall" and a second string s2 = "hello"

In Python, how can I manipulate the s2 string to equal the length of s1.

s2 would then look like:

s2 = "hellohellohellohell" which would have the same number of characters as s1.

Answer 1

Here's one approach:

s1 = 'lets go to the mall'
s2 = 'hello'
s2 = ''.join(s2[i % len(s2)] for i in range(len(s1)))
print(s2)  # "hellohellohellohell"

Edit: Here's an explanation for those not as familiar with Python or programming =]

• ''.join(...) takes an iterable, which is something you can iterate through, and joins all of those elements together with the empty string in between. So, if what's on the inside is an iterable of letters, it'll join all of those letters together.
• range(len(s1)) produces an iterable of all numbers 0 to len(s1) - 1. The number of numbers in this iterable is equal to the length of s1.
• s2[i] means the letter in the string s2 at index i. So, if s2 = 'hello', then s2[0] = 'h', s2[1] = 'e', etc.
• i % len(s2) means i modulo len(s2), or the remainder when you divide i by the length of s2.
• So, putting that all together, this code first creates an iterable of letters looping through s2 as many times as it needs to in order to get len(s1) many letters, then joins them all together with the empty string in between.

Answer 2

Itertools is the answer. More specifically takewhile and cycle

import itertools

s1 = "lets go to the mall"
s2 = "Hello"

print ("".join(s for _, s in itertools.takewhile(lambda t: t[0] < len(s1), enumerate(itertools.cycle(s2)))))

Or even simpler (using islice):

print ("".join(itertools.islice(itertools.cycle(s2)), len(s1)))

Answer 3

// is integer division which finds the whole multiples. % is the modulo (remainder)

Multiply s2 my the number of times it can go into s1 and then use slicing to add the remaining portion of s2.

s3 = s2 * (len(s1) // len(s2)) + s2[:(len(s1) % len(s2))]

>>> s3
'hellohellohellohell'

Answer 4

(s2 * (len(s1)//len(s2) + 1))[:len(s1)]

Answer 5

Basically multiply s2 by the math.floor of the two lengths divided, then add the remainder of the string:

def extend(s1, s2):
    return s2*int(math.floor(len(s1)/len(s2)))+s2[:len(s1) % len(s2)]

---

>>> extend("lets go to the mall", "hello")
'hellohellohellohell'
>>> 

Answer 6

Off of the top of my head, and you'll have to forgive me, you could use a function like this:

def string_until_whenever(s1, s2):
i = len(s1)
x = 0
newstring = ""
while i != 0:
    newstring = newstring + s2[x]
    x += 1
    i -= 1
    if x == len(s2) - 1:
         x = 0
return newstring

Answer 7

Inefficient, but simple. (The multiplication makes a string much longer than it needs to be.)

n = len(s1)
s3 = (s2*n)[:n]

Answer 8

I think there are many possible solutions. amongst many possible solutions my answer is :

s2 = s2*(len(s1)/len(s2)+1)
s2 = s2[0:len(s1)]

Answer 9

May not be the cleanest solution but you can also do this, using string multiplication and string slicing:

def string_until_whenever(s1, s2):
    temp = ""    
    if len(s2) > len(s1):
        temp = s2
        s2 = s1
        s1 = temp

    new_string = ""
    multiply_by = len(s1)/len(s2)
    modulo = len(s1) % len(s2)    
    new_string = s2 * multiply_by
    new_string = new_string + s2[0:modulo]    

    return new_string


print(string_until_whenever("lets go to the mall", "hello"))
#Outputs: hellohellohellohell