# 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(n)

## 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.`

## Javascript

 ``

## PHP

 ``

Output

```Strings are rotations of each other

```

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

Another Approach: Comparing the prefix and suffix

• Check if sizes of two strings are not same, then return false.
• Check if ith character is equal to the first character of str2
• Check prefix of str1 with suffix of str2
• Check suffix of str2 with prefix of str1
• If none of the above cases satisfy then answer must be false so, return false

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``;`   `    ``for` `(``int` `i = 0; i < str1.length(); i++) {` `        ``// check if ith character is equal to the first` `        ``// character of str2` `        ``if` `(str1[i] == str2[0]) {` `            ``// check suffix of str1 with prefix of str2` `            ``if` `(str1.substr(i)` `                ``== str2.substr(0, str1.length() - i)) {` `                ``// check prefix of str1 with suffix of str2` `                ``if` `(str1.substr(0, i)` `                    ``== str2.substr(str1.length() - i))` `                    ``return` `true``;` `            ``}` `        ``}` `    ``}` `    ``// if none of the above cases satisfy then answer must` `    ``// be false so return false` `    ``return` `false``;` `}`   `/* 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;` `}` `// This code is contributed by Abhishek Sharma`

## Java

 `// Java program to check if two given strings are rotations` `// of each other`   `class` `StringRotation {` `    ``/* Function checks if passed strings (s1 and s2)` `       ``are rotations of each other */` `    ``static` `boolean` `areRotations(String s1, String s2)` `    ``{` `        ``/* Check if sizes of two strings are same */` `        ``if` `(s1.length() != s2.length()) {` `            ``return` `false``;` `        ``}` `        ``else` `{` `            ``for` `(``int` `i = ``0``; i < s1.length(); i++) {` `                ``// checking character at ith index with` `                ``// first character of s2` `                ``if` `(s1.charAt(i) == s2.charAt(``0``)) {` `                    ``// checking prefix of s2 with suffix of` `                    ``// s1` `                    ``if` `(s1.substring(i).equals(s2.substring(` `                            ``0``, s1.length() - i))) {` `                        ``// checking prefix of s1 with suffix` `                        ``// of s2` `                        ``if` `(s1.substring(``0``, i).equals(` `                                ``s2.substring(s1.length()` `                                             ``- i)))` `                            ``return` `true``;` `                    ``}` `                ``}` `            ``}` `        ``}` `        ``return` `false``;` `    ``}`   `    ``// 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"``);` `    ``}` `}`

## Python

 `# Python program to check if strings are rotations of` `# each other or not`   `# Function checks if passed strings (s1 and s2)` `# are rotations of each other`     `def` `areRotations(s1, s2):` `    ``# check length of both strings are equal or not` `    ``if` `len``(s1) !``=` `len``(s2):` `        ``return` `False` `    ``else``:` `        ``for` `i ``in` `range``(``len``(s1)):` `            ``if` `s1[i] ``=``=` `s2[``0``]:  ``# compare the ith charcter in s1 with first character of s2` `                ``if` `s1[i:] ``=``=` `s2[:``len``(s1)``-``i]:  ``# compare prefix of s2 with suffix of s1` `                    ``# compare prefix of s1 with suffix of s2` `                    ``if` `s1[:i] ``=``=` `s2[``len``(s1)``-``i:]:` `                        ``return` `True` `    ``return` `False`     `# 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"``)`

## 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` `        ``if` `(str1.Length != str2.Length)` `            ``return` `false``;` `        ``else` `{` `            ``for` `(``int` `i = 0; i < str1.Length; i++) {` `                ``// checking character at ith index with` `                ``// first character of s2` `                ``if` `(str1[i] == str2[0]) {` `                    ``// checking prefix of s2 with suffix of` `                    ``// s1` `                    ``if` `(str1.Substring(i)` `                        ``== str2.Substring(0, str1.Length` `                                                 ``- i)) {` `                        ``// checking prefix of s1 with suffix` `                        ``// of s2` `                        ``if` `(str1.Substring(0, i)` `                            ``== str2.Substring(str1.Length` `                                              ``- i))` `                            ``return` `true``;` `                    ``}` `                ``}` `            ``}` `        ``}` `        ``return` `false``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``String str1 = ``"FGABCDE"``;` `        ``String str2 = ``"ABCDEFG"``;`   `        ``// Function call` `        ``if` `(areRotations(str1, str2))` `            ``Console.Write(``"Strings are"` `                          ``+ ``" rotations of each other"``);` `        ``else` `            ``Console.Write(``"Strings are "` `                          ``+ ``"not rotations of each other"``);` `    ``}` `}`

## Javascript

 ``

Output

```Strings are rotations of each other

```

Time Complexity: O(N*N), where N is the length of the string and another N because we compare two string.
Auxiliary Space: O(N) , Because we are creating substring

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!