Minimum rotations required to get the same string

Given a string, we need to find the minimum number of rotations required to get the same string.

Examples:

Input : s = "geeks"
Output : 5

Input : s = "aaaa"
Output : 1

The idea is based on below post.
A Program to check if strings are rotations of each other or not

• Step 1 : Initialize result = 0 (Here result is count of rotations) 
• Step 2 : Take a temporary string equals to original string concatenated with itself. 
• Step 3 : Now take the substring of temporary string of size same as original string starting from second character (or index 1). 
• Step 4 : Increase the count. 
• Step 5 : Check whether the substring becomes equal to original string. If yes, then break the loop. Else go to step 2 and repeat it from the next index. 

Implementation:

C++

// C++ program to determine minimum number
// of rotations required to yield same
// string.
#include <iostream>
using namespace std;

// Returns count of rotations to get the
// same string back.
int findRotations(string str)
{
    // tmp is the concatenated string.
    string tmp = str + str;
    int n = str.length();

    for (int i = 1; i <= n; i++) {

        // substring from i index of original
        // string size.
        string substring = tmp.substr(i, str.size());

        // if substring matches with original string
        // then we will come out of the loop.
        if (str == substring)
            return i;
    }
    return n;
}

// Driver code
int main()
{
    string str = "abc";
    cout << findRotations(str) << endl;
    return 0;
}

Java

// Java program to determine minimum number
// of rotations required to yield same
// string.

import java.util.*;

class GFG
{
    // Returns count of rotations to get the
    // same string back.
    static int findRotations(String str)
    {
        // tmp is the concatenated string.
        String tmp = str + str;
        int n = str.length();

        for (int i = 1; i <= n; i++)
        {

            // substring from i index of original
            // string size.

            String substring = tmp.substring(
                      i, i+str.length());

            // if substring matches with original string
            // then we will come out of the loop.
            if (str.equals(substring))
                return i;
        }
        return n;
    }

    // Driver Method
    public static void main(String[] args)
    {
            String str = "aaaa";
        System.out.println(findRotations(str));
    }
}
/* This code is contributed by Mr. Somesh Awasthi */

Python3

# Python 3 program to determine minimum
# number of rotations required to yield
# same string.

# Returns count of rotations to get the
# same string back.
def findRotations(str):

    # tmp is the concatenated string.
    tmp = str + str
    n = len(str)

    for i in range(1, n + 1):

        # substring from i index of
        # original string size.
        substring = tmp[i: i+n]

        # if substring matches with
        # original string then we will
        # come out of the loop.
        if (str == substring):
            return i
    return n

# Driver code
if __name__ == '__main__':

    str = "abc"
    print(findRotations(str))

# This code is contributed
# by 29AjayKumar.

C#

// C# program to determine minimum number
// of rotations required to yield same
// string.
using System;

class GFG {

    // Returns count of rotations to get
    // the same string back.
    static int findRotations(String str)
    {

        // tmp is the concatenated string.
        String tmp = str + str;
        int n = str.Length;

        for (int i = 1; i <= n; i++)
        {

            // substring from i index of
            // original string size.

            String substring =
                 tmp.Substring(i, str.Length);

            // if substring matches with
            // original string then we will
            // come out of the loop.
            if (str == substring)
                return i;
        }

        return n;
    }

    // Driver Method
    public static void Main()
    {
        String str = "abc";

        Console.Write(findRotations(str));
    }
}

// This code is contributed by nitin mittal.

PHP

<?php
// PHP program to determine minimum
// number of rotations required to
// yield same string.

// Returns count of rotations
// to get the same string back.
function findRotations($str)
{
    // tmp is the concatenated string.
    $tmp = ($str + $str);
    $n = strlen($str);

    for ( $i = 1; $i <= $n; $i++)
    {

        // substring from i index
        // of original string size.
        $substring = $tmp.substr($i,
                          strlen($str));

        // if substring matches with
        // original string then we will
        // come out of the loop.
        if ($str == $substring)
            return $i;
    }
    return $n;
}

// Driver code
$str = "abc";
echo findRotations($str), "\n";

// This code is contributed
// by Sachin
?>

Javascript

<script>
// javascript program to determine minimum number
// of rotations required to yield same
// string.

    // Returns count of rotations to get the
    // same string back.
    function findRotations( str) {
        // tmp is the concatenated string.
        var tmp = str + str;
        var n = str.length;

        for (var i = 1; i <= n; i++) {

            // substring from i index of original
            // string size.

            var substring = tmp.substring(i ,str.length);

            // if substring matches with original string
            // then we will come out of the loop.
            if (str===(substring))
                return i;
        }
        return n;
    }

    // Driver Method

        var str = "abc";
        document.write(findRotations(str));

// This code contributed by gauravrajput1
</script>

Output

3

Time Complexity: O(n²)
Auxiliary Space : O(n)

We can solve this problem without using any temporary variable as extra space . We will traverse the original string  and at each position we partition it and concatenate the right substring and left substring and check whether it is equal to original string

Implementation:

C++

// C++ program to determine minimum number
// of rotations required to yield same
// string.
#include <iostream>
using namespace std;

// Returns count of rotations to get the
// same string back.
int findRotations(string str)
{
    int ans = 0; //to store the answer
      int n = str.length(); //length of the string

      //All the length where we can partition
      for(int i=1;i<n-1;i++)
    {
          //right part + left part = rotated string
          // we are checking whether the rotated string is equal to
        //original string
          if(str.substr(i,n-i) + str.substr(0,i)  == str)
        {
             ans = i;
              break;
        }
    }
      if(ans == 0)
      return n;
      return ans;
}

// Driver code
int main()
{
    string str = "abc";
    cout << findRotations(str) << endl;
    return 0;
}

Java

// Java program to determine minimum number
// of rotations required to yield same
// string.

import java.util.*;

class GFG
{
    // Returns count of rotations to get the
    // same string back.
    static int findRotations(String str)
    {
        int ans = 0; //to store the answer
        int n = str.length(); //length of the string

          //All the length where we can partition
        for(int i=1;i<str.length()-1;i++)
        {
              //right part + left part = rotated string
              // we are checking whether the rotated string is equal to
            //original string
            if(str.substring(i, str.length()-i) + str.substring(0, i)  == str)
            {
                 ans = i;
                  break;
            }
        }
          if(ans == 0)
            return n;
          return ans;
    }

    // Driver Method
    public static void main(String[] args)
    {
            String str = "abc";
        System.out.println(findRotations(str));
    }
}
// This code is contributed by Aarti_Rathi

Python3

# Python program to determine minimum number
# of rotations required to yield same
# string.

# Returns count of rotations to get the
# same string back.
def findRotations(Str):

    ans = 0 # to store the answer
    n = len(Str) # length of the String

    # All the length where we can partition
    for i in range(1 , len(Str) - 1):

        # right part + left part = rotated String
        # we are checking whether the rotated String is equal to
        # original String
        if(Str[i: n] + Str[0: i]  == Str):
            ans = i
            break

    if(ans == 0):
        return n
    return ans

# Driver code
Str = "abc"
print(findRotations(Str))

# This code is contributed by shinjanpatra

C#

// C# program to determine minimum number
// of rotations required to yield same
// string.
using System;

class GFG {

    // Returns count of rotations to get
    // the same string back.
    static int findRotations(String str)
    {

        int ans = 0; //to store the answer
        int n = str.Length; //length of the string

          //All the length where we can partition
          for(int i=1;i<str.Length-1;i++)
        {
              //right part + left part = rotated string
              // we are checking whether the rotated string is equal to
            //original string
              if(str.Substring(i,n-i) + str.Substring(0,i)  == str)
            {
                 ans = i;
                  break;
            }
        }
          if(ans == 0)
             return n;
          return ans;
    }

    // Driver Method
    public static void Main()
    {
        String str = "abc";

        Console.Write(findRotations(str));
    }
}

// This code is contributed by Aarti_Rathi

Javascript

<script>

// JavaScript program to determine minimum number
// of rotations required to yield same
// string.

// Returns count of rotations to get the
// same string back.
function findRotations(str)
{
    let ans = 0; // to store the answer
    let n = str.length; // length of the string

      // All the length where we can partition
      for(let i = 1; i < str.length - 1; i++)
    {
          // right part + left part = rotated string
          // we are checking whether the rotated string is equal to
        // original string
          if(str.substr(i, n - i) + str.substr(0, i)  == str)
        {
            ans = i;
            break;
        }
    }
      if(ans == 0)
      return n;
      return ans;
}

// Driver code

let str = "abc";
document.write(findRotations(str),"</br>");

// This code is contributed by shinjanpatra

</script>

Output

3

Time Complexity: O(n²)
Auxiliary Space: O(1)

Alternate Implementation in Python : 

C++

// C++ program to determine minimum
// number of rotations required to yield
// same string.
#include <iostream>
using namespace std;

// Driver program
int main()
{
    string String = "aaaa";
    string check = "";

    for(int r = 1; r < String.length() + 1; r++)
    {

        // checking the input after each rotation
        check = String.substr(0, r) + String.substr(r, String.length()-r);

        // following if statement checks if input is
        // equals to check , if yes it will print r and
        // break out of the loop
        if(check == String){
            cout<<r;
            break;
        }
    }
    return 0;
}

// This code is contributed by shinjanpatra

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main (String[] args) {
       String string = "aaaa";
    String check = "";

    for(int r = 1; r < string.length() + 1; r++)
    {

        // checking the input after each rotation
        check = string.substring(0, r) + string.substring(r, string.length());

        // following if statement checks if input is
        // equals to check , if yes it will print r and
        // break out of the loop
        if(check.equals(string)){
            System.out.println(r);
            break;
        }
    }
    }
}

Python3

# Python 3 program to determine minimum
# number of rotations required to yield
# same string.

# input
string = 'aaaa'
check = ''

for r in range(1, len(string)+1):
  # checking the input after each rotation
  check = string[r:] + string[:r]

  # following if statement checks if input is
  # equals to check , if yes it will print r and
  # break out of the loop
  if check == string:
    print(r)
    break

# This code is contributed
# by nagasowmyanarayanan.

C#

// C# program to determine minimum number
// of rotations required to yield same
// string.
using System;

class GFG {
    // Driver Method
    public static void Main()
    {
        String str = "aaaa";
        String check = "";
        for(int r = 1; r < str.Length + 1; r++)
        {

            // checking the input after each rotation
            check = str.Substring(0, r) + str.Substring(r, str.Length-r);

            // following if statement checks if input is
            // equals to check , if yes it will print r and
            // break out of the loop
            if(check == str){
                Console.Write(r);
                break;
            }
        }
    }
}

// This code is contributed by Aarti_Rathi

Javascript

<script>

// JavaScript program to determine minimum
// number of rotations required to yield
// same string.

// input
let string = 'aaaa'
let check = ''

for(let r=1;r<string.length+1;r++){
    // checking the input after each rotation
    check = string.substring(r) + string.substring(0,r)

    // following if statement checks if input is
    // equals to check , if yes it will print r and
    // break out of the loop
    if(check == string){
        document.write(r)
        break
    }
}

// This code is contributed
// by shinjanpatra

</script>

Output

1

Time Complexity: O(n²), n as length of string
Auxiliary Space: O(n), n as length of string

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.