Java Program for Check whether all the rotations of a given number is greater than or equal to the given number or not

Given an integer x, the task is to find if every k-cycle shift on the element produces a number greater than or equal to the same element. 
A k-cyclic shift of an integer x is a function that removes the last k digits of x and inserts them in its beginning. 
For example, the k-cyclic shifts of 123 are 312 for k=1 and 231 for k=2. Print Yes if the given condition is satisfied else print No.
Examples:

Input: x = 123 
Output : Yes 
The k-cyclic shifts of 123 are 312 for k=1 and 231 for k=2. 
Both 312 and 231 are greater than 123.
Input: 2214 
Output: No 
The k-cyclic shift of 2214 when k=2 is 1422 which is smaller than 2214 

Approach: Simply find all the possible k cyclic shifts of the number and check if all are greater than the given number or not.
Below is the implementation of the above approach: 

Java

// Java implementation of the approach
class GFG
{

    static void CheckKCycles(int n, String s)
    {
        boolean ff = true;
        int x = 0;
        for (int i = 1; i < n; i++)
        {

            // Splitting the number at index i
            // and adding to the front
            x = (s.substring(i) + s.substring(0, i)).length();

            // Checking if the value is greater than
            // or equal to the given value
            if (x >= s.length())
            {
                continue;
            }
            ff = false;
            break;
        }
        if (ff)
        {
            System.out.println("Yes");
        }
        else
        {
            System.out.println("No");
        }

    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 3;
        String s = "123";
        CheckKCycles(n, s);
    }
}

/* This code contributed by PrinciRaj1992 */

Output:

Yes

Time Complexity: O(N²), where N represents the length of the given string.

The time complexity of the program is O(N²) because first it runs a loop for traversing the string and inside that substring function is used.

Auxiliary Space: O(1), no extra space is required, so it is a constant.

Approach 2:

• Here’s another approach to solve the same problem:
• Iterate through all possible k values from 1 to n/2.
• For each k value, check if the string can be split into k cycles of length n/k. To do this, compare the substring of the original string from 0 to n/k with the substring of the original string from i*(n/k) to (i+1)*(n/k), for all i from 1 to k-1.
• If the string can be split into k cycles of length n/k, then it satisfies the given condition. Return “Yes”.
• If the string cannot be split into any cycles, then return “No”.
• Here’s the Java implementation of this approach:

Java

public class Main {
    public static String hasKCycles(int n, String s) {
        for (int k = 1; k <= n/2; k++) {
            if (n % k != 0) {
                continue;
            }

            int len = n/k;
            boolean flag = true;

            for (int i = 1; i < k; i++) {
                if (!s.substring((i-1)*len, i*len).equals(s.substring(i*len, (i+1)*len))) {
                    flag = false;
                    break;
                }
            }

            if (flag) {
                return "Yes";
            }
        }

        return "No";
    }

    public static void main(String[] args) {
        int n = 3;
        String s = "123";
        System.out.println(hasKCycles(n, s));
    }
}

Output:

Yes

Time Complexity: O(N^2), where N represents the length of the given string.

Auxiliary Space: O(1), no extra space is required, so it is a constant.

Please refer complete article on Check whether all the rotations of a given number is greater than or equal to the given number or not for more details!