GeeksforGeeks App
Open App
Browser
Continue

Check if given strings are rotations of each other or not

Given a string s1 and a string s2, write a function to check whether s2 is a rotation of s1.

Examples:

Input: S1 = ABCD, S2 = CDAB
Output: Strings are rotations of each other

Input: S1 = ABCD, S2 = ACBD
Output: Strings are not rotations of each other

Naive Approach: Follow the given steps to solve the problem

• Find all the positions of the first character of the original string in the string to be checked.
• For every position found, consider it to be the starting index of the string to be checked.
• Beginning from the new starting index, compare both strings and check whether they are equal or not.
• (Suppose the original string to is s1, string to be checked to be s2,n is the length of strings and j is the position of the first character of s1 in s2, then for i < (length of original string) , check if s1[i]==s2[(j+1)%n). Return false if any character mismatch is found, else return true.
• Repeat 3rd step for all positions found.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `bool` `checkString(string& s1, string& s2, ``int` `indexFound,``                 ``int` `Size)``{``    ``for` `(``int` `i = 0; i < Size; i++) {``        ``// check whether the character is equal or not``        ``if` `(s1[i] != s2[(indexFound + i) % Size])``            ``return` `false``;``        ``// %Size keeps (indexFound+i) in bounds, since it``        ``// ensures it's value is always less than Size``    ``}` `    ``return` `true``;``}` `int` `main()``{` `    ``string s1 = ``"abcd"``;``    ``string s2 = ``"cdab"``;` `    ``if` `(s1.length() != s2.length()) {``        ``cout << ``"s2 is not a rotation on s1"` `<< endl;``    ``}``    ``else` `{``        ``// store occurrences of the first character of s1``        ``vector<``int``> indexes;` `        ``int` `Size = s1.length();` `        ``char` `firstChar = s1[0];` `        ``for` `(``int` `i = 0; i < Size; i++) {``            ``if` `(s2[i] == firstChar) {``                ``indexes.push_back(i);``            ``}``        ``}` `        ``bool` `isRotation = ``false``;` `        ``// check if the strings are rotation of each other``        ``// for every occurrence of firstChar in s2``        ``for` `(``int` `idx : indexes) {``            ``isRotation = checkString(s1, s2, idx, Size);` `            ``if` `(isRotation)``                ``break``;``        ``}` `        ``if` `(isRotation)``            ``cout << ``"Strings are rotations of each other"``                 ``<< endl;``        ``else``            ``cout``                ``<< ``"Strings are not rotations of each other"``                ``<< endl;``    ``}``    ``return` `0;``}`

Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``// java program to check if two strings are rotation of``    ``// each other or not``    ``static` `boolean` `checkString(String s1, String s2,``                               ``int` `indexFound, ``int` `Size)``    ``{``        ``for` `(``int` `i = ``0``; i < Size; i++) {` `            ``// check whether the character is equal or not``            ``if` `(s1.charAt(i)``                ``!= s2.charAt((indexFound + i) % Size))``                ``return` `false``;` `            ``// %Size keeps (indexFound+i) in bounds,``            ``// since it ensures it's value is always less``            ``// than Size``        ``}` `        ``return` `true``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``String s1 = ``"abcd"``;``        ``String s2 = ``"cdab"``;` `        ``if` `(s1.length() != s2.length()) {``            ``System.out.println(``                ``"s2 is not a rotation on s1"``);``        ``}``        ``else` `{` `            ``ArrayList indexes = ``new` `ArrayList<``                ``Integer>(); ``// store occurrences of the``                            ``// first character of s1` `            ``int` `Size = s1.length();` `            ``char` `firstChar = s1.charAt(``0``);` `            ``for` `(``int` `i = ``0``; i < Size; i++) {``                ``if` `(s2.charAt(i) == firstChar) {``                    ``indexes.add(i);``                ``}``            ``}` `            ``boolean` `isRotation = ``false``;` `            ``// check if the strings are rotation of each``            ``// other for every occurrence of firstChar in s2``            ``for` `(``int` `idx : indexes) {``                ``isRotation = checkString(s1, s2, idx, Size);` `                ``if` `(isRotation)``                    ``break``;``            ``}` `            ``if` `(isRotation)``                ``System.out.println(``                    ``"Strings are rotations of each other"``);``            ``else``                ``System.out.println(``                    ``"Strings are not rotations of each other"``);``        ``}``    ``}``}` `// This code is contributed by shinjanpatra`

Python3

 `# Python3 program for the above approach`  `def` `checkString(s1, s2, indexFound, Size):``    ``for` `i ``in` `range``(Size):` `        ``# check whether the character is equal or not``        ``if``(s1[i] !``=` `s2[(indexFound ``+` `i) ``%` `Size]):``            ``return` `False` `        ``# %Size keeps (indexFound+i) in bounds,``        ``# since it ensures it's value is always less than Size``    ``return` `True`  `# driver code``s1 ``=` `"abcd"``s2 ``=` `"cdab"` `if``(``len``(s1) !``=` `len``(s2)):``    ``print``(``"s2 is not a rotation on s1"``)` `else``:` `    ``indexes ``=` `[]  ``# store occurrences of the first character of s1``    ``Size ``=` `len``(s1)``    ``firstChar ``=` `s1[``0``]``    ``for` `i ``in` `range``(Size):``        ``if``(s2[i] ``=``=` `firstChar):``            ``indexes.append(i)` `    ``isRotation ``=` `False` `    ``# check if the strings are rotation of each other``    ``# for every occurrence of firstChar in s2``    ``for` `idx ``in` `indexes:` `        ``isRotation ``=` `checkString(s1, s2, idx, Size)` `        ``if``(isRotation):``            ``break` `    ``if``(isRotation):``        ``print``(``"Strings are rotations of each other"``)``    ``else``:``        ``print``(``"Strings are not rotations of each other"``)` `# This code is contributed by shinjanpatra`

C#

 `// C# program for the above approach` `using` `System;` `public` `class` `GFG {` `    ``public` `static` `bool` `checkString(``string` `s1, ``string` `s2,``                                   ``int` `indexFound, ``int` `Size)``    ``{``        ``for` `(``int` `i = 0; i < Size; i++) {` `            ``// check whether the character is equal or not``            ``if` `(s1[i] != s2[(indexFound + i) % Size])``                ``return` `false``;` `            ``// %Size keeps (indexFound+i) in bounds, since``            ``// it ensures it's value is always less than``            ``// Size``        ``}` `        ``return` `true``;``    ``}` `    ``static` `public` `void` `Main()``    ``{` `        ``string` `s1 = ``"abcd"``;``        ``string` `s2 = ``"cdab"``;` `        ``if` `(s1.Length != s2.Length) {``            ``Console.WriteLine(``"s2 is not a rotation on s1"``);``        ``}``        ``else` `{` `            ``// store occurrences of the first character of``            ``// s1``            ``int``[] indexes = ``new` `int``[1000];``            ``int` `j = 0;` `            ``int` `Size = s1.Length;` `            ``char` `firstChar = s1[0];` `            ``for` `(``int` `i = 0; i < Size; i++) {``                ``if` `(s2[i] == firstChar) {``                    ``indexes[j] = i;``                    ``j++;``                ``}``            ``}` `            ``bool` `isRotation = ``false``;` `            ``// check if the strings are rotation of each``            ``// other for every occurrence of firstChar in s2``            ``for` `(``int` `idx = 0; idx < indexes.Length; idx++) {``                ``isRotation = checkString(s1, s2, idx, Size);` `                ``if` `(isRotation)``                    ``break``;``            ``}` `            ``if` `(isRotation)``                ``Console.WriteLine(``                    ``"Strings are rotations of each other"``);``            ``else``                ``Console.WriteLine(``                    ``"Strings are not rotations of each other"``);``        ``}``    ``}``}` `// This code is contributed by akashish__`

Javascript

 ``

Output

`Strings are rotations of each other`

Time Complexity: O(n*n) in the worst case, where n is the length of the string.
Auxiliary Space: O(1)

Program to check if strings are rotations of each other or not using queue:

Follow the given steps to solve the problem

• If the size of both strings is not equal, then it can never be possible.
• Push the original string into a queue q1.
• Push the string to be checked inside another queue q2.
• Keep popping q2‘s and pushing it back into it till the number of such operations is less than the size of the string.
• If q2 becomes equal to q1 at any point during these operations, it is possible. Else not.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `bool` `check_rotation(string s, string goal)``{``    ``if` `(s.size() != goal.size())``        ``return` `false``;` `    ``queue<``char``> q1;``    ``for` `(``int` `i = 0; i < s.size(); i++) {``        ``q1.push(s[i]);``    ``}` `    ``queue<``char``> q2;``    ``for` `(``int` `i = 0; i < goal.size(); i++) {``        ``q2.push(goal[i]);``    ``}` `    ``int` `k = goal.size();``    ``while` `(k--) {``        ``char` `ch = q2.front();``        ``q2.pop();``        ``q2.push(ch);``        ``if` `(q2 == q1)``            ``return` `true``;``    ``}``    ``return` `false``;``}` `// Driver code``int` `main()``{``    ``string str1 = ``"AACD"``, str2 = ``"ACDA"``;` `    ``if` `(check_rotation(str1, str2))``        ``printf``(``"Strings are rotations of each other"``);``    ``else``        ``printf``(``"Strings are not rotations of each other"``);``    ``return` `0;``}`

Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG {``    ``static` `boolean` `check_rotation(String s, String goal)``    ``{``        ``if` `(s.length() != goal.length())``            ``return` `false``;` `        ``Queue q1 = ``new` `LinkedList<>();``        ``for` `(``int` `i = ``0``; i < s.length(); i++) {``            ``q1.add(s.charAt(i));``        ``}` `        ``Queue q2 = ``new` `LinkedList<>();``        ``for` `(``int` `i = ``0``; i < goal.length(); i++) {``            ``q2.add(goal.charAt(i));``        ``}` `        ``int` `k = goal.length();``        ``while` `(k > ``0``) {``            ``k--;``            ``char` `ch = q2.peek();``            ``q2.remove();``            ``q2.add(ch);``            ``if` `(q2.equals(q1))``                ``return` `true``;``        ``}` `        ``return` `false``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String str1 = ``"AACD"``;``        ``String str2 = ``"ACDA"``;` `        ``// Function call``        ``if` `(check_rotation(str1, str2))``            ``System.out.println(``                ``"Strings are rotations of each other"``);``        ``else``            ``System.out.printf(``                ``"Strings are not rotations of each other"``);``    ``}``}` `// This code is contributed by gauravrajput1`

Python3

 `# Python3 program for the above approach`  `def` `check_rotation(s, goal):` `    ``if` `(``len``(s) !``=` `len``(goal)):``        ``skip` `    ``q1 ``=` `[]``    ``for` `i ``in` `range``(``len``(s)):``        ``q1.insert(``0``, s[i])` `    ``q2 ``=` `[]``    ``for` `i ``in` `range``(``len``(goal)):``        ``q2.insert(``0``, goal[i])` `    ``k ``=` `len``(goal)``    ``while` `(k > ``0``):``        ``ch ``=` `q2[``0``]``        ``q2.pop(``0``)``        ``q2.append(ch)``        ``if` `(q2 ``=``=` `q1):``            ``return` `True` `        ``k ``-``=` `1` `    ``return` `False`  `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``string1 ``=` `"AACD"``    ``string2 ``=` `"ACDA"` `    ``# Function call``    ``if` `check_rotation(string1, string2):``        ``print``(``"Strings are rotations of each other"``)``    ``else``:``        ``print``(``"Strings are not rotations of each other"``)` `        ``# This code is contributed by ukasp.`

C#

 `// Include namespace system``using` `System;``using` `System.Threading;``using` `System.Collections.Generic;` `public` `class` `GFG``{``  ``public` `static` `bool` `check_rotation(String s, String goal)``  ``{``    ``if` `(s.Length != goal.Length)``    ``{``      ``return` `false``;``    ``}``    ``var` `q1 = ``new` `LinkedList<``char``>();``    ``for` `(``int` `i = 0; i < s.Length; i++)``    ``{``      ``q1.AddLast(s[i]);``    ``}``    ``var` `q2 = ``new` `LinkedList<``char``>();``    ``for` `(``int` `i = 0; i < goal.Length; i++)``    ``{``      ``q2.AddLast(goal[i]);``    ``}``    ``var` `k = goal.Length;``    ``while` `(k > 0)``    ``{``      ``k--;``      ``var` `ch = q2.First.Value;``      ``q2.RemoveFirst();``      ``q2.AddLast(ch);``      ``if` `(!q2.Equals(q1))``      ``{``        ``return` `true``;``      ``}``    ``}``    ``return` `false``;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``var` `str1 = ``"AACD"``;``    ``var` `str2 = ``"ACDA"``;` `    ``// Function call``    ``if` `(GFG.check_rotation(str1, str2))``    ``{``      ``Console.WriteLine(``"Strings are rotations of each other"``);``    ``}``    ``else``    ``{``      ``Console.Write(``"Strings are not rotations of each other"``);``    ``}``  ``}``}` `// This code is contributed by aadityaburujwale.`

Javascript

 ``

Output

`Strings are rotations of each other`

Time Complexity: O(N1 * N2), where N1 and N2 are the lengths of the strings.
Auxiliary Space: O(N)

Efficient Approach: Follow the given steps to solve the problem

• Create a temp string and store concatenation of str1 to str1 in temp, i.e temp = str1.str1
• If str2 is a substring of temp then str1 and str2 are rotations of each other.

Example:

str1 = “ABACD”, str2 = “CDABA”
temp = str1.str1 = “ABACDABACD”
Since str2 is a substring of temp, str1 and str2 are rotations of each other.

Below is the implementation of the above approach:

C++

 `// C++ program to check if two given strings``// are rotations of  each other``#include ``using` `namespace` `std;` `/* Function checks if passed strings (str1``   ``and str2) are rotations of each other */``bool` `areRotations(string str1, string str2)``{``    ``/* Check if sizes of two strings are same */``    ``if` `(str1.length() != str2.length())``        ``return` `false``;` `    ``string temp = str1 + str1;``    ``return` `(temp.find(str2) != string::npos);``}` `/* Driver code */``int` `main()``{``    ``string str1 = ``"AACD"``, str2 = ``"ACDA"``;` `    ``// Function call``    ``if` `(areRotations(str1, str2))``        ``printf``(``"Strings are rotations of each other"``);``    ``else``        ``printf``(``"Strings are not rotations of each other"``);``    ``return` `0;``}`

C

 `// C program to check if two given strings are rotations of``// each other``#include ``#include ``#include ` `/* Function checks if passed strings (str1 and str2)``   ``are rotations of each other */``int` `areRotations(``char``* str1, ``char``* str2)``{``    ``int` `size1 = ``strlen``(str1);``    ``int` `size2 = ``strlen``(str2);``    ``char``* temp;``    ``void``* ptr;` `    ``/* Check if sizes of two strings are same */``    ``if` `(size1 != size2)``        ``return` `0;` `    ``/* Create a temp string with value str1.str1 */``    ``temp = (``char``*)``malloc``(``sizeof``(``char``) * (size1 * 2 + 1));``    ``temp[0] = ``' '``;``    ``strcat``(temp, str1);``    ``strcat``(temp, str1);` `    ``/* Now check if str2 is a substring of temp */``    ``ptr = ``strstr``(temp, str2);` `    ``free``(temp); ``// Free dynamically allocated memory` `    ``/* strstr returns NULL if the second string is NOT a``      ``substring of first string */``    ``if` `(ptr != NULL)``        ``return` `1;``    ``else``        ``return` `0;``}` `/* Driver code */``int` `main()``{``    ``char``* str1 = ``"AACD"``;``    ``char``* str2 = ``"ACDA"``;` `    ``// Function call``    ``if` `(areRotations(str1, str2))``        ``printf``(``"Strings are rotations of each other"``);``    ``else``        ``printf``(``"Strings are not rotations of each other"``);` `    ``getchar``();``    ``return` `0;``}`

Java

 `// Java program to check if two given strings are rotations``// of each other` `class` `StringRotation {``    ``/* Function checks if passed strings (str1 and str2)``       ``are rotations of each other */``    ``static` `boolean` `areRotations(String str1, String str2)``    ``{``        ``// There lengths must be same and str2 must be``        ``// a substring of str1 concatenated with str1.``        ``return` `(str1.length() == str2.length())``            ``&& ((str1 + str1).indexOf(str2) != -``1``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String str1 = ``"AACD"``;``        ``String str2 = ``"ACDA"``;` `        ``// Fuinction call``        ``if` `(areRotations(str1, str2))``            ``System.out.println(``                ``"Strings are rotations of each other"``);``        ``else``            ``System.out.printf(``                ``"Strings are not rotations of each other"``);``    ``}``}``// This code is contributed by  munjal`

Python3

 `# Python program to check if strings are rotations of``# each other or not` `# Function checks if passed strings (str1 and str2)``# are rotations of each other`  `def` `areRotations(string1, string2):``    ``size1 ``=` `len``(string1)``    ``size2 ``=` `len``(string2)``    ``temp ``=` `''` `    ``# Check if sizes of two strings are same``    ``if` `size1 !``=` `size2:``        ``return` `0` `    ``# Create a temp string with value str1.str1``    ``temp ``=` `string1 ``+` `string1` `    ``# Now check if str2 is a substring of temp``    ``# string.count returns the number of occurrences of``    ``# the second string in temp``    ``if` `(temp.count(string2) > ``0``):``        ``return` `1``    ``else``:``        ``return` `0`  `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``string1 ``=` `"AACD"``    ``string2 ``=` `"ACDA"` `    ``# Function call``    ``if` `areRotations(string1, string2):``        ``print``(``"Strings are rotations of each other"``)``    ``else``:``        ``print``(``"Strings are not rotations of each other"``)` `# This code is contributed by Bhavya Jain`

C#

 `// C# program to check if two given strings``// are rotations of each other``using` `System;` `class` `GFG {` `    ``/* Function checks if passed strings``    ``(str1 and str2) are rotations of``    ``each other */``    ``static` `bool` `areRotations(String str1, String str2)``    ``{` `        ``// There lengths must be same and``        ``// str2 must be a substring of``        ``// str1 concatenated with str1.``        ``return` `(str1.Length == str2.Length)``            ``&& ((str1 + str1).IndexOf(str2) != -1);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``String str1 = ``"FGABCDE"``;``        ``String str2 = ``"ABCDEFG"``;` `        ``// Function call``        ``if` `(areRotations(str1, str2))``            ``Console.Write(``"Strings are"``                          ``+ ``" rotation s of each other"``);``        ``else``            ``Console.Write(``"Strings are "``                          ``+ ``"not rotations of each other"``);``    ``}``}` `// This code is contributed by nitin mittal.`

PHP

 ``

Javascript

 ``

Output

`Strings are rotations of each other`

Time Complexity: O(N), where N is the length of the string.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up