5 Best Ways to Check if Strings Are Rotations of Each Other in Python

💡 Problem Formulation: In Python, the task of determining if two strings are rotations of each other involves comparing the characters in the strings after possibly cyclically shifting them. For example, if we take “hello” and rotate it, creating “llohe”, the program should recognize these two strings as rotations of one another.

Method 1: Concatenation Check

The Concatenation Check method involves doubling the first string and then checking if the second string is a substring of this newly formed string. This method uses the inbuilt in operator to check for the substring. It’s efficient because it only needs to perform one string concatenation and one substring search.

Here’s an example:

def are_rotations(str1, str2):
    return len(str1) == len(str2) and str2 in str1 * 2

print(are_rotations('abcd', 'dabc')) # Expected Output: True
print(are_rotations('abcd', 'cdab')) # Expected Output: True

The above code checks whether the second string is a substring of the first string concatenated with itself. If it is, the strings are rotations of each other.

Method 2: Using Slicing

The Slicing method iterates through the first string, slicing and rotating it to compare with the second string. This is done using the slicing syntax in Python. It’s a brute force method that works well for short strings but could be less efficient for longer ones due to multiple string creations.

Here’s an example:

def are_rotations(str1, str2):
    if len(str1) != len(str2):
        return False
    length = len(str1)
    for i in range(length):
        if str1[i:] + str1[:i] == str2:
            return True
    return False

print(are_rotations('hello', 'llohe')) # Expected Output: True

This snippet continuously slices the first string and checks if the result matches the second string. When a match is found, it returns True, indicating the strings are rotations of each other.

Method 3: Iterative Comparison

The Iterative Comparison method involves comparing characters from both strings one-by-one, considering the rotation factor. This can be done by iterating over the indices and using modulo operation. This method is straightforward and does not rely on creating multiple string instances.

Here’s an example:

def are_rotations(str1, str2):
    if len(str1) != len(str2):
        return False
    for i in range(len(str1)):
        if all(str1[(i + j) % len(str1)] == str2[j] for j in range(len(str2))):
            return True
    return False

print(are_rotations('rotation', 'tationro')) # Expected Output: True

This code compares the two strings by rotating the indices in each iteration and checking if all rotated positions match. The strings are rotations if any such complete match is found.

Method 4: Using Python’s find() Method

With Python’s find() method, the Concatenation Check from Method 1 can be enhanced by explicitly searching for the index where the second string appears in the concatenated first string. Though similar to Method 1, it gives more control over the process and can be potentially useful if the position is of interest.

Here’s an example:

def are_rotations(str1, str2):
    if len(str1) != len(str2):
        return False
    return (str1 + str1).find(str2) != -1

print(are_rotations('abcdef', 'defabc')) # Expected Output: True

This code snippet determines if the second string occurs within the concatenated first string using the find() method, confirming if they are rotations of each other.

Bonus One-Liner Method 5: Lambda Expression

The use of a lambda expression can condense the Concatenation Check into a single line of code. It provides an elegant and concise solution and flaunts Python’s capabilities for writing compact code.

Here’s an example:

are_rotations = lambda str1, str2: len(str1) == len(str2) and str2 in str1 * 2

print(are_rotations('reverse', 'severer')) # Expected Output: True

This one-liner lambda function performs the same operation as Method 1 but in a condensed, functional programming style, checking whether the strings are rotations.

Summary/Discussion

• Method 1: Concatenation Check. Simple and efficient for all string sizes. Requires minimal code and is Pythonic. Weakness: depends on the efficiency of substring search in Python.
• Method 2: Using Slicing. Brute force approach that is easy to understand. Good for learning purposes. Weakness: potentially slower for longer strings due to multiple string creations.
• Method 3: Iterative Comparison. Directly compares characters with rotation accounted for. Memory efficient since it avoids string creation. Weakness: More code and might be slower due to the all() function call overhead.
• Method 4: Using Python’s find() Method. More control over substring search, and it’s clear when none is found due to the returning of -1. Strengths include readability and explicitness. Weakness: Not substantially different from Method 1 performance-wise.
• Bonus One-Liner Method 5: Lambda Expression. Extremely concise; showcases Python’s expressive power. Good for quick, one-off checks. Weakness: lambda expressions can be less readable for complex operations.