5 Best Ways to Check if a String Can Be Repeated to Make Another String in Python

💡 Problem Formulation: Suppose you have two strings, str1 and str2. The challenge is to check whether str1 can be repeated some number of times to exactly match str2. For example, if str1 = "ab" and str2 = "ababab", the answer should be True because repeating “ab” three times gives “ababab”, which is equal to str2.

Method 1: Using Division and Multiplication

This method checks if the length of str2 is a multiple of str1‘s length. If it is, it repeats str1 the appropriate number of times and compares it to str2.

Here’s an example:

str1 = "abc"
str2 = "abcabcabc"
def can_string_be_repeated(str1, str2):
    if len(str2) % len(str1) == 0:
        return str1 * (len(str2) // len(str1)) == str2
    return False

print(can_string_be_repeated(str1, str2))

Output: True

This code defines a function can_string_be_repeated that first checks if the length of str2 is divisible by the length of str1. If the check passes, it then multiplies str1 by the division result and compares the new string to str2.

Method 2: Using the str.find() Method

This approach utilizes the built-in str.find() method to look for str1 inside str2. After confirming the size relationship as in Method 1, it seeks to match the beginning of str1 throughout the entire str2. If str1 is found at multiples of its length, then it can be concluded that str2 is a repetition of str1.

Here’s an example:

str1 = "ab"
str2 = "ababab"
def can_string_be_repeated(str1, str2):
    if len(str2) % len(str1) != 0:
        return False
    return all(str2.find(str1, i) == i for i in range(0, len(str2), len(str1)))

print(can_string_be_repeated(str1, str2))

Output: True

This snippet checks for the occurrence of str1 at every index that it should appear if str2 is made of repeated str1 patterns. It uses a generator expression within the all() function to ensure every required index matches.

Method 3: Using Regular Expressions

By leveraging Python’s regular expressions module re, this method crafts a pattern to match str1 repeated consecutively and then tries to match this pattern against str2.

Here’s an example:

import re
str1 = "ab"
str2 = "abab"
pattern = f"({str1})+"
match = re.fullmatch(pattern, str2)

print(bool(match))

Output: True

In the code, a regular expression pattern is created that represents str1 repeated one or more times. The re.fullmatch() function is then used to determine if the entire string str2 conforms to this pattern, yielding a boolean result.

Method 4: Using String Slicing

This method attempts to solve the problem by slicing str2 into chunks the size of str1 and then checking if every slice equals str1.

Here’s an example:

str1 = "xyz"
str2 = "xyzxyzxyzxyz"
def can_string_be_repeated(str1, str2):
    len_str1 = len(str1)
    return all(str2[i:i+len_str1] == str1 for i in range(0, len(str2), len_str1))

print(can_string_be_repeated(str1, str2))

Output: True

The function divides str2 into smaller strings of the same length as str1 and uses a generator expression with the all() function to check if each substring is equal to str1.

Bonus One-Liner Method 5: Using the in Operator

A clever one-liner leverages the fact that if str1 can be repeated to form str2, then str2 should be contained in any string formed by repeating str1 at least twice.

Here’s an example:

str1 = "a"
str2 = "aaaa"
print(str2 in str1 * 2 * (len(str2) // len(str1)))

Output: True

This one-liner multiplies str1 by twice the quotient of the lengths of str2 and str1 and checks if str2 is a substring of the result using the in operator.

Summary/Discussion

• Method 1: Division and Multiplication. Strengths: Simple and fast for short strings. Weaknesses: Performance may degrade with very long strings due to the multiplication operation.
• Method 2: str.find() Method. Strengths: Does not create new strings, saving memory. Weaknesses: Slightly more complex and potentially slower due to repetitive finding operation.
• Method 3: Regular Expressions. Strengths: Very powerful and can be adapted to more complex patterns. Weaknesses: Can be slower and less readable for those not familiar with regex syntax.
• Method 4: String Slicing. Strengths: Memory efficient as it does not create a new string. Weaknesses: Could be slower than other methods for very large strings.
• Method 5: Using the in Operator. Strengths: Extremely concise. Weaknesses: May not be immediately clear to readers how it works, and potential for excessive memory usage in some cases.