In string manipulation tasks, we may need to rotate the characters of a string to the left or right by a specified number of positions. A left rotation moves the first k characters to the end, while a right rotation moves the last k characters to the beginning.
Example: let's take a string s = "geeks" and we need to perform a left and right shift of k=2 places:
s = "geeks"
left shift = "eksge"
right shift = "ksgee"
This article explores different ways to perform such shifts in Python using different methods, let's explore them with examples:
Using String Slicing
This method combines slicing with string multiplication to handle shifts efficiently in a single step. It works by dividing the string at the specified index and rearranging the parts.
Example:
s = "geeksforgeeks"
k = 3
l = s[k:] + s[:k]
r = s[-k:] + s[:-k]
print("Left Shift:", l)
print("Right Shift:", r)
Output
Left Shift: ksforgeeksgee Right Shift: eksgeeksforge
Explanation:
- s[k:] gets all characters from index k to the end and s[:k] gets the first k characters.
- s[k:] + s[:k] moves the first k characters to the end (Left Shift).
- s[-k:] + s[:-k] moves the last k characters to the front (Right Shift).
Using % Operator and Slicing
Modulo operator (%) ensures the shift value remains within the bounds of the string length. This avoids unnecessary operations when the shift value exceeds the string length.
Example:
s = "geeksforgeeks"
k = 17
n = len(s)
k %= n
l = s[k:] + s[:k]
r = s[-k:] + s[:-k]
print("Left Shift:", l)
print("Right Shift:", r)
Output
Left Shift: sforgeeksgeek Right Shift: eeksgeeksforg
Explanation:
- k %= n reduces unnecessary full rotations. Shifting a 13-character string by 17 is the same as shifting by 4 (since 17 % 13 = 4).
- Slicing is then used to perform the shifts.
Using collections.deque
Deque (double-ended queue) from the collections module is designed for efficient rotations and manipulations. This method uses the built-in rotate function of deque for shifting characters.
Example:
from collections import deque
s = "geeksforgeeks"
k = 3
d = deque(s)
d.rotate(-k)
l = ''.join(d)
d.rotate(2 * k)
r = ''.join(d)
print("Left Shift:", l)
print("Right Shift:", r)
Output
Left Shift: ksforgeeksgee Right Shift: eksgeeksforge
Explanation:
- Positive values for rotate perform right shifts, while negative values perform left shifts.
- rotate(-k) rotates left.
- rotate(2 * k) returns to original, then rotates right by k.
- The result is obtained by converting the rotated deque back into a string.
Using List Comprehension with join()
This approach uses list comprehension to calculate the shifted indices and reconstructs the string using the join() function. It provides a flexible way to perform shifts..
Example:
s = "geeksforgeeks"
k = 3
n = len(s)
k %= n
l = ''.join([s[(i + k) % n] for i in range(n)])
r = ''.join([s[(i - k) % n] for i in range(n)])
print("Left Shift:", l)
print("Right Shift:", r)
Output
Left Shift: ksforgeeksgee Right Shift: eksgeeksforge
Explanation:
- (i + k) % n computes the new index after shifting left.
- (i - k) % n computes the new index after shifting right.
- join() converts the list back to a string.
Using Itertools and islice
Cycle creates an infinitely repeating iterable from the original string. This allows us to extract the desired shifted sequence using slicing.
Example:
from itertools import cycle, islice
s = "geeksforgeeks"
k = 3
n = len(s)
k %= n
l = ''.join(islice(cycle(s), k, k + n))
r = ''.join(islice(cycle(s), n - k, 2 * n - k))
print("Left Shift:", l)
print("Right Shift:", r)
Output
Left Shift: ksforgeeksgee Right Shift: eksgeeksforge
Explanation:
- cycle(s) creates an infinite repeating iterator.
- islice(..., k, k + n) extracts a slice after skipping k characters (left shift).
- islice(..., n - k, 2 * n - k) extracts slice for right shift.
Also read: String slicing, collections.deque, list comprehension, itertools.cycle, islice.
