Left Rotation of a String
Last Updated :
11 Nov, 2024
Improve
Given a string s and an integer d, the task is to left rotate the string by d positions.
Examples:
Input: s = “GeeksforGeeks”, d = 2
Output: “eksforGeeksGe”
Explanation: After the first rotation, string s becomes “eeksforGeeksG” and after the second rotation, it becomes “eksforGeeksGe”.Input: s = “qwertyu”, d = 2
Output: “ertyuqw”
Explanation: After the first rotation, string s becomes “wertyuq” and after the second rotation, it becomes “ertyuqw”.
Table of Content
[Naive Approach] Left Rotate one by one
The idea is to store the first character in a variable and shift all the remaining characters to the left by one position, then place the first character at the end of string. This process is repeated d times.
// C++ Program to left rotate the string by d
// positions by rotating one element at a time
#include <iostream>
#include <string>
using namespace std;
void rotateString(string &s, int d) {
int n = s.size();
// Repeat the rotation d times
for (int i = 0; i < d; i++) {
// Left rotate the string by one position
int first = s[0];
for (int j = 0; j < n - 1; j++)
s[j] = s[j + 1];
// Place the first character at the end
s[n - 1] = first;
}
}
int main() {
string s = "GeeksforGeeks";
int d = 2;
rotateString(s, d);
cout << s << endl;
return 0;
}
// C Program to left rotate the string by d positions
// by rotating one element at a time
#include <stdio.h>
#include <string.h>
void rotateString(char s[], int d) {
int n = strlen(s);
// Repeat the rotation d times
for (int i = 0; i < d; i++) {
// Left rotate the string by one position
char first = s[0];
for (int j = 0; j < n - 1; j++)
s[j] = s[j + 1];
// Place the first character at the end
s[n - 1] = first;
}
}
int main() {
char s[] = "GeeksforGeeks";
int d = 2;
rotateString(s, d);
printf("%s\n", s);
return 0;
}
// Java Program to left rotate the string by d positions
// by rotating one element at a time
import java.util.Arrays;
class GfG {
static String rotateString(String s, int d) {
// Convert the string to a char array
char[] charArray = s.toCharArray();
int n = charArray.length;
// Perform the rotation d times
for (int i = 0; i < d; i++) {
// Store the first character
char first = charArray[0];
// Shift each character one position to
// the left
for (int j = 0; j < n - 1; j++)
charArray[j] = charArray[j + 1];
// Move the first character to the end
charArray[n - 1] = first;
}
return new String(charArray);
}
public static void main(String[] args) {
String s = "GeeksforGeeks";
int d = 2;
String rotatedString = rotateString(s, d);
System.out.println(rotatedString);
}
}
# python Program to left rotate the string by d
# positions by rotating one element at a time
def rotateString(s, d):
# Convert the string to a list of
# characters
s = list(s)
n = len(s)
# Perform the rotation d times
for _ in range(d):
# Store the first character
first = s[0]
# Shift each character one
# position to the left
for i in range(n - 1):
s[i] = s[i + 1]
# Move the first character to the end
s[n - 1] = first
# Convert the list back to a string
return ''.join(s)
s = "GeeksforGeeks"
d = 2
rotatedString = rotateString(s, d)
print(rotatedString)
// C# Program to left rotate the string by d positions
// by rotating one element at a time
using System;
class GfG {
static string rotateString(string s, int d) {
// Convert the string to a character array
char[] charArray = s.ToCharArray();
int n = charArray.Length;
// Perform the rotation d times
for (int i = 0; i < d; i++) {
// Store the first character
char first = charArray[0];
// Shift each character one position to
// the left
for (int j = 0; j < n - 1; j++)
charArray[j] = charArray[j + 1];
// Move the first character to the end
charArray[n - 1] = first;
}
// Convert the character array to a string
return new string(charArray);
}
static void Main() {
string s = "GeeksforGeeks";
int d = 2;
string rotatedString = rotateString(s, d);
Console.WriteLine(rotatedString);
}
}
// Javascript Program to left rotate the string by d positions
// by rotating one element at a time
function rotateString(s, d) {
// Convert the string to an array
let charArray = s.split('');
let n = charArray.length;
// Perform the rotation d times
for (let i = 0; i < d; i++) {
// Store the first character
let first = charArray[0];
// Shift each character one position to the left
for (let j = 0; j < n - 1; j++)
charArray[j] = charArray[j + 1];
// Move the first character to the end
charArray[n - 1] = first;
}
// Convert the array back to a string
return charArray.join('');
}
let s = "GeeksforGeeks";
let d = 2;
let rotatedString = rotateString(s, d);
console.log(rotatedString);
Output
eksforGeeksGe
Time Complexity: O(n*d), the outer loop runs d times, and inner loop runs n times.
Auxiliary Space: O(1) if the string is mutable, like in C++. For immutable strings like in Java, C#, Python and Javascript an extra character array of size n is used, so the space complexity will be O(n).
[Better Approach] Using Temporary Char Array
The idea is to use a temporary character array of size n (size of original string). If we left rotate the string by d positions, the last n – d elements will be at the front and the first d elements will be at the end.
- Copy the last (n – d) elements of original string into the first n – d positions of temporary array.
- Then, copy the first d elements of the original string to the end of temporary array.
- Finally, convert the temporary char array to the string.
// C++ program to left rotate a string by d
// position using a temporary array
#include <iostream>
#include <string>
using namespace std;
string rotateString(string &s, int d) {
int n = s.length();
// Handle cases where d > n
d = d % n;
char temp[n];
// Copy the last (n - d) characters
// to the start of temp Array
for (int i = 0; i < n - d; i++)
temp[i] = s[d + i];
// Copy the first d characters to the end
// of temp Array
for (int i = 0; i < d; i++)
temp[n - d + i] = s[i];
// Convert temp array to the string
return string(temp, n);
}
int main() {
string s = "GeeksforGeeks";
int d = 2;
string rotatedString = rotateString(s, d);
cout << rotatedString << endl;
return 0;
}
// Java program to left rotate a string by d position
// using a temporary array
import java.io.*;
class GfG {
static String rotateString(String s, int d) {
int n = s.length();
// Handle cases where d > n
d = d % n;
char[] temp = new char[n];
// Copy the last (n - d) characters to the
// start of temp array
for (int i = 0; i < n - d; i++)
temp[i] = s.charAt(d + i);
// Copy the first d characters to the end of
// temp array
for (int i = 0; i < d; i++)
temp[n - d + i] = s.charAt(i);
// Convert the temp array back to the String
return new String(temp);
}
public static void main(String[] args) {
String s = "GeeksforGeeks";
int d = 2;
String rotatedString = rotateString(s, d);
System.out.println(rotatedString);
}
}
# Python program to left rotate a string
# by d position using a temporary array
def rotateString(s, d):
n = len(s)
# Handle cases where d > n
d = d % n
# Create a temporary array of the
# same length as s
temp = [''] * n
# Copy the last (n - d) characters
# to the start of temp array
for i in range(n - d):
temp[i] = s[d + i]
# Copy the first d characters to the
#end of temp array
for i in range(d):
temp[n - d + i] = s[i]
# Convert temp array back to the string
return ''.join(temp)
s = "GeeksforGeeks"
d = 2
rotatedString = rotateString(s, d)
print(rotatedString)
// C# program to left rotate a string by d position
// using temporary array
using System;
class GfG {
static string rotateString(string s, int d) {
int n = s.Length;
// Handle cases where d > n
d = d % n;
char[] temp = new char[n];
// Copy the last (n - d) characters
// to the start of temp array
for (int i = 0; i < n - d; i++)
temp[i] = s[d + i];
// Copy the first d characters to the end
// of temp array
for (int i = 0; i < d; i++)
temp[n - d + i] = s[i];
// Convert temp array back to the string
return new string(temp);
}
static void Main() {
string s = "GeeksforGeeks";
int d = 2;
string rotatedString = rotateString(s, d);
Console.WriteLine(rotatedString);
}
}
// Javascript program to left rotate a string
// by d position using temporary array
function rotateString(s, d) {
let n = s.length;
// Handle cases where d > n
d = d % n;
let temp = new Array(n);
// Copy the last (n - d) characters to
// the start of temp array
for (let i = 0; i < n - d; i++)
temp[i] = s[d + i];
// Copy the first d characters
// to the end of temp array
for (let i = 0; i < d; i++)
temp[n - d + i] = s[i];
// Convert the array back to the string
return temp.join("");
}
let s = "GeeksforGeeks";
let d = 2;
let rotatedString = rotateString(s, d);
console.log(rotatedString);
Output
eksforGeeksGe
Time Complexity: O(n), as we are visiting each element only twice.
Auxiliary Space: O(n), as we are using an additional character array.
[Expected Approach – 1] Using Juggling Algorithm
The idea behind the juggling algorithm is that we can rotate all the elements in cycle. Each cycle is independent and represents a group of elements that will shift among themselves during the rotation. If the starting index of a cycle is i, then next elements of the cycle will be present at indices (i + d) % n, (i + 2d) % n, (i + 3d) % n … and so on till we reach back to index i. The total number of cycles will be GCD of n and d. And, we perform a single left rotation within each cycle.
To know more about the Juggling algorithm, refer this article – Juggling Algorithm for Array Rotation.
// C++ Program to left rotate the string by d positions
// using Juggling Algorithm
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
void rotateString(string &s, int d) {
int n = s.size();
// Handle the case where d > size of array
d %= n;
// Calculate the number of cycles in the rotation
int cycles = __gcd(n, d);
// Perform a left rotation within each cycle
for (int i = 0; i < cycles; i++) {
// Start element of current cycle
char startChar = s[i];
// Start index of current cycle
int currIdx = i, nextIdx;
// Rotate elements till we reach the start of cycle
while (true) {
nextIdx = (currIdx + d) % n;
if (nextIdx == i)
break;
// Update the next index with the current element
s[currIdx] = s[nextIdx];
currIdx = nextIdx;
}
// Copy the start element of current cycle
// at the last index of the cycle
s[currIdx] = startChar;
}
}
int main() {
string s = "GeeksforGeeks";
int d = 2;
rotateString(s, d);
cout << s << endl;
return 0;
}
// C Program to left rotate the string by d positions
// using Juggling Algorithm
#include <stdio.h>
#include <string.h>
void rotateString(char s[], int d) {
int n = strlen(s);
// Handle the case where d > size of array
d %= n;
// Calculate the number of cycles in the
// rotation
int cycles = gcd(n, d);
// Perform a left rotation within each cycle
for (int i = 0; i < cycles; i++) {
// Start element of the current cycle
char startChar = s[i];
// Start index of the current cycle
int currIdx = i, nextIdx;
// Rotate elements until we return to the
// start of the cycle
while (1) {
nextIdx = (currIdx + d) % n;
if (nextIdx == i)
break;
// Update the current index with the
// element at the next index
s[currIdx] = s[nextIdx];
currIdx = nextIdx;
}
// Place the start element of the current
// cycle at the last index
s[currIdx] = startChar;
}
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
char s[] = "GeeksforGeeks";
int d = 2;
rotateString(s, d);
printf("%s\n", s);
return 0;
}
// Java Program to left rotate the string by d positions
// using Juggling Algorithm
import java.io.*;
class GfG {
static String rotateString(String s, int d) {
int n = s.length();
// Handle the case where
// d > size of the string
d %= n;
// Calculate the number of
// cycles (GCD of n and d)
int cycles = gcd(n, d);
// Convert string to character array
char[] arr = s.toCharArray();
// Perform a left rotation within each cycle
for (int i = 0; i < cycles; i++) {
// Start element of current cycle
char temp = arr[i];
int j = i;
while (true) {
int k = (j + d) % n;
if (k == i) {
break;
}
// Move the element to the next index
arr[j] = arr[k];
j = k;
}
// Place the saved element in the
// last position of the cycle
arr[j] = temp;
}
// Convert the rotated character
// array back to a string
return new String(arr);
}
// function to calculate GCD of two numbers
static int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
public static void main(String[] args) {
String s = "GeeksforGeeks";
int d = 2;
String rotatedString = rotateString(s, d);
System.out.println(rotatedString);
}
}
# python Program to left rotate the string by
# d positions using Juggling Algorithm
def gcd(a, b):
while b:
a, b = b, a % b
return a
def rotateString(s, d):
n = len(s)
# Handle the case where d > size of
# the string
d %= n
# Calculate the number of cycles (GCD
# of n and d)
cycles = gcd(n, d)
# Convert string to a list of characters
arr = list(s)
# Perfrom a left rotation wihtin each cycle
for i in range(cycles):
# Start element of current cycle
temp = arr[i]
j = i
while True:
k = (j + d) % n
if k == i:
break
# Move the element to the next
# index
arr[j] = arr[k]
j = k
# Place the saved element in the last
# position of the cycle
arr[j] = temp
# Convert the list of characters back to
# a string and return
return ''.join(arr)
s = "GeeksforGeeks"
d = 2
rotatedString = rotateString(s, d)
print(rotatedString)
// C# Program to left rotate the string by d positions
// using Juggling Algorithm
using System;
class GfG {
static int Gcd(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
static string rotateString(string s, int d) {
int n = s.Length;
// Handle the case where d > size of the string
d %= n;
// Calculate the number of cycles (GCD of n and d)
int cycles = Gcd(n, d);
// Convert string to a character array
char[] arr = s.ToCharArray();
// Perform a left rotation within each cycle
for (int i = 0; i < cycles; i++) {
// Start element of the current cycle
char temp = arr[i];
int j = i;
while (true) {
int k = (j + d) % n;
if (k == i)
break;
// Move the element to the next index
arr[j] = arr[k];
j = k;
}
// Place the saved element in the last position
// of the cycle
arr[j] = temp;
}
// Convert the character array back to a string
return new string(arr);
}
static void Main() {
string s = "GeeksforGeeks";
int d = 2;
string rotatedString = rotateString(s, d);
Console.WriteLine(rotatedString);
}
}
// JavaScript Program to left rotate the string by d
// positions using Juggling Algorithm
function gcd(a, b) {
while (b !== 0) {
let temp = b;
b = a % b;
a = temp;
}
return a;
}
function rotateString(s, d) {
let n = s.length;
// Handle the case where d > size of the string
d %= n;
// Calculate the number of cycles (GCD of n and d)
let cycles = gcd(n, d);
// Convert string to a character array
let arr = s.split('');
// Perform a left rotation within each cycle
for (let i = 0; i < cycles; i++) {
// Start element of the current cycle
let temp = arr[i];
let j = i;
while (true) {
let k = (j + d) % n;
if (k === i) {
break;
}
// Move the element to the next index
arr[j] = arr[k];
j = k;
}
// Place the first element in the last position
// of the cycle
arr[j] = temp;
}
// Convert the character array back to a string
return arr.join('');
}
let s = "GeeksforGeeks";
let d = 2;
let rotatedString = rotateString(s, d);
console.log(rotatedString);
Output
eksforGeeksGe
Time Complexity: O(n)
Auxiliary Space: O(1) if the string is mutable, like in C++. For immutable strings like in Java, C#, Python and Javascript an extra character array of size n is used, so the space complexity will be O(n).
[Expected Approach – 2] Using Reversal Algorithm
The idea is based on the observation that if we left rotate the string by d positions, the last (n – d) elements will be at the front and the first d elements will be at the end.
- Reverse the substring containing the first d elements of the string.
- Reverse the substring containing the last (n – d) elements of the string.
- Finally, reverse all the elements of the string.
// C++ program to left rotate a string by d position
// using Reversal Algorithm
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
void rotateString(string &s, int d) {
int n = s.size();
// Handle the case where d > size of array
d %= n;
// Reverse the first d elements
reverse(s.begin(), s.begin() + d);
// Reverse the remaining n-d elements
reverse(s.begin() + d, s.end());
// Reverse the entire string
reverse(s.begin(), s.end());
}
int main() {
string s = "GeeksforGeeks";
int d = 2;
rotateString(s, d);
cout << s << endl;
return 0;
}
// Java program to left rotate a string by d position
// using Reversal Algorithm
import java.io.*;
class GfG {
static String rotateString(String s, int d) {
int n = s.length();
// Handle the case where d > size of string
d %= n;
// Convert string to a character array
char[] temp = s.toCharArray();
// Reverse the first d elements
reverse(temp, 0, d - 1);
// Reverse the remaining n-d elements
reverse(temp, d, n - 1);
// Reverse the entire array
reverse(temp, 0, n - 1);
// Convert the array back to a string and return
return new String(temp);
}
static void reverse(char[] temp, int start, int end) {
while (start < end) {
char c = temp[start];
temp[start] = temp[end];
temp[end] = c;
start++;
end--;
}
}
public static void main(String[] args) {
String s = "GeeksforGeeks";
int d = 2;
String rotatedString = rotateString(s, d);
System.out.println(rotatedString);
}
}
# Python program to left rotate a string by d positons
# using Reversal Algorithm
def rotateString(s, d):
n = len(s)
# Handle cases where d > n
d %= n
# Convert the string to a list of characters
temp = list(s)
# Reverse the first d elements
reverse(temp, 0, d - 1)
# Reverse the remaining n - d elements
reverse(temp, d, n - 1)
# Reverse the entire array
reverse(temp, 0, n - 1)
# Convert the list back to a string and return
return ''.join(temp)
def reverse(temp, start, end):
while start < end:
temp[start], temp[end] = temp[end], temp[start]
start += 1
end -= 1
s = "GeeksforGeeks"
d = 2
rotatedString = rotateString(s, d)
print(rotatedString)
// C++ program to left rotate a string by d positions
// using Reversal Algorithm
using System;
class GfG {
static string RotateString(string s, int d) {
int n = s.Length;
// Handle cases where d > n
d %= n;
// Convert the string to a character array
char[] temp = s.ToCharArray();
// Reverse the first d elements
Reverse(temp, 0, d - 1);
// Reverse the remaining n - d elements
Reverse(temp, d, n - 1);
// Reverse the entire array
Reverse(temp, 0, n - 1);
// Convert the character array back to a string
return new string(temp);
}
static void Reverse(char[] temp, int start, int end) {
while (start < end) {
char c = temp[start];
temp[start] = temp[end];
temp[end] = c;
start++;
end--;
}
}
static void Main() {
string s = "GeeksforGeeks";
int d = 2;
string rotatedString = RotateString(s, d);
Console.WriteLine(rotatedString);
}
}
// C++ program to left rotate a string by d position
// using Reversal Algorithm
function rotateString(s, d) {
const n = s.length;
// Handle cases where d > n
d %= n;
// Convert the string to a character array
let temp = s.split("");
// Reverse the first d elements
reverse(temp, 0, d - 1);
// Reverse the remaining n - d elements
reverse(temp, d, n - 1);
// Reverse the entire array
reverse(temp, 0, n - 1);
// Convert the array back to a string
return temp.join("");
}
function reverse(temp, start, end) {
while (start < end) {
// Swap elements
[temp[start], temp[end]]
= [temp[end], temp[start]];
start++;
end--;
}
}
let s = "GeeksforGeeks";
let d = 2;
let rotatedString = rotateString(s, d);
console.log(rotatedString);
Output
eksforGeeksGe
Time Complexity: O(n), where n is the size of the given string.
Auxiliary Space: O(1) if the string is mutable, like in C++. For immutable strings like in Java, C#, python and Javascript, an extra character array of size n is used, so the space complexity will be O(n).
