# Lexicographically smallest rotated sequence | Set 2

Write code to find lexicographic minimum in a circular array, e.g. for the array BCABDADAB, the lexicographic minimum is ABBCABDAD

Input Constraint: 1 < n < 1000

Examples:

```Input:  GEEKSQUIZ
Output: EEKSQUIZG

Input:  GFG
Output: FGG

Input :  CAPABCQ
Output : ABCQCAP
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We have discussed a O(n2Logn) solution in Lexicographically minimum string rotation | Set 1. Here we need to find the starting index of minimum rotation and then print the rotation.

```1) Initially assume 0 to be current min
starting index.
2) Loop through i = 1 to n-1.
a) For each i compare sequence starting
at i with current min starting index
b) If sequence starting at i is lexicographically
smaller, update current min starting
index.
```

Here is pseudo-code for algorithm

```function findIndexForSmallestSequence(S, n):
result = 0
for i = 1:n-1
if (sequence beginning at i <
sequence beginning at result)
result = i
end if
end for
return result
```

Here is implementation of above algorithm.

## C/C++

 `// C++ program to find lexicographically ` `// smallest sequence with rotations. ` `#include ` `using` `namespace` `std; ` ` `  `// Function to compare lexicographically ` `// two sequence with different starting ` `// indexes. It returns true if sequence ` `// beginning with y is lexicographically ` `// greater. ` `bool` `compareSeq(``char` `S[], ``int` `x, ``int` `y, ``int` `n) ` `{ ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``if` `(S[x] < S[y]) ` `            ``return` `false``; ` `        ``else` `if` `(S[x] > S[y]) ` `            ``return` `true``; ` `        ``x = (x + 1) % n; ` `        ``y = (y + 1) % n; ` `    ``} ` `    ``return` `true``; ` `} ` ` `  `// Function to find starting index ` `// of lexicographically smallest sequence ` `int` `smallestSequence(``char` `S[], ``int` `n) ` `{ ` `    ``int` `index = 0; ` `    ``for` `(``int` `i = 1; i < n; i++) ` ` `  `        ``// if new sequence is smaller ` `        ``if` `(compareSeq(S, index, i, n)) ` ` `  `            ``// change index of current min ` `            ``index = i; ` ` `  `    ``return` `index; ` `} ` ` `  `// Function to print lexicographically ` `// smallest sequence ` `void` `printSmallestSequence(``char` `S[], ``int` `n) ` `{ ` `    ``int` `starting_index = smallestSequence(S, n); ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``cout << S[(starting_index + i) % n]; ` `} ` ` `  `// driver code ` `int` `main() ` `{ ` `    ``char` `S[] = ``"DCACBCAA"``; ` `    ``int` `n = 8; ` `    ``printSmallestSequence(S, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find lexicographically ` `// smallest sequence with rotations. ` `import` `java.util.*; ` `import` `java.lang.*; ` `import` `java.io.*; ` ` `  `/* Name of the class */` `class` `LexoSmallest { ` `    ``// Function to compare lexicographically ` `    ``// two sequence with different starting ` `    ``// indexes. It returns true if sequence ` `    ``// beginning with y is lexicographically ` `    ``// greater. ` `    ``static` `boolean` `compareSeq(``char``[] S, ``int` `x, ``int` `y, ``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `            ``if` `(S[x] < S[y]) ` `                ``return` `false``; ` `            ``else` `if` `(S[x] > S[y]) ` `                ``return` `true``; ` `            ``x = (x + ``1``) % n; ` `            ``y = (y + ``1``) % n; ` `        ``} ` `        ``return` `true``; ` `    ``} ` ` `  `    ``// Function to find starting index ` `    ``// of lexicographically smallest sequence ` `    ``static` `int` `smallestSequence(``char``[] S, ``int` `n) ` `    ``{ ` `        ``int` `index = ``0``; ` `        ``for` `(``int` `i = ``1``; i < n; i++) ` ` `  `            ``// if new sequence is smaller ` `            ``if` `(compareSeq(S, index, i, n)) ` ` `  `                ``// change index of current min ` `                ``index = i; ` ` `  `        ``return` `index; ` `    ``} ` ` `  `    ``// Function to print lexicographically ` `    ``// smallest sequence ` `    ``static` `void` `printSmallestSequence(String str, ``int` `n) ` `    ``{ ` `        ``char``[] S = str.toCharArray(); ` `        ``int` `starting_index = smallestSequence(S, n); ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``System.out.print(S[(starting_index + i) % n]); ` `    ``} ` ` `  `    ``// driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``String S = ``"DCACBCAA"``; ` `        ``int` `n = ``8``; ` `        ``printSmallestSequence(S, n); ` `    ``} ` `} ` `// This code is contributed by Mr Somesh Awasthi `

## Python 3

 `# Python 3 program to find lexicographically ` `# smallest sequence with rotations. ` ` `  `# Function to compare lexicographically ` `# two sequence with different starting ` `# indexes. It returns true if sequence ` `# beginning with y is lexicographically ` `# greater. ` `import` `copy ` ` `  ` `  `def` `printSmallestSequence(s): ` `    ``m ``=` `copy.copy(s) ` `    ``for` `i ``in` `range``(``len``(s) ``-` `1``): ` ` `  `        ``if` `m > s[i:] ``+` `s[:i]: ` `            ``m ``=` `s[i:] ``+` `s[:i] ` ` `  `    ``return` `m ` ` `  `#Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``st ``=` `'DCACBCAA'` `    ``print``(printSmallestSequence(st)) ` ` `  ` `  `# This code is contributed by Koushik Reddy B `

## C#

 `// C# program to find lexicographically ` `// smallest sequence with rotations. ` `using` `System; ` ` `  `class` `LexoSmallest { ` `     `  `    ``// Function to compare lexicographically ` `    ``// two sequence with different starting ` `    ``// indexes. It returns true if sequence ` `    ``// beginning with y is lexicographically ` `    ``// greater. ` `    ``static` `bool` `compareSeq(``string` `S, ``int` `x, ``int` `y, ``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``if` `(S[x] < S[y]) ` `                ``return` `false``; ` `            ``else` `if` `(S[x] > S[y]) ` `                ``return` `true``; ` `            ``x = (x + 1) % n; ` `            ``y = (y + 1) % n; ` `        ``} ` `        ``return` `true``; ` `    ``} ` ` `  `    ``// Function to find starting index ` `    ``// of lexicographically smallest sequence ` `    ``static` `int` `smallestSequence(``string` `S, ``int` `n) ` `    ``{ ` `        ``int` `index = 0; ` `        ``for` `(``int` `i = 1; i < n; i++) ` ` `  `            ``// if new sequence is smaller ` `            ``if` `(compareSeq(S, index, i, n)) ` ` `  `                ``// change index of current min ` `                ``index = i; ` ` `  `        ``return` `index; ` `    ``} ` ` `  `    ``// Function to print lexicographically ` `    ``// smallest sequence ` `    ``static` `void` `printSmallestSequence(``string` `str, ``int` `n) ` `    ``{ ` `        ``// char[] S=str.toCharArray(); ` `        ``int` `starting_index = smallestSequence(str, n); ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``Console.Write(str[(starting_index + i) % n]); ` `    ``} ` ` `  `    ``// driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``string` `S = ``"DCACBCAA"``; ` `        ``int` `n = 8; ` `        ``printSmallestSequence(S, n); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` ``\$S``[``\$y``]) ` `            ``return` `true; ` `        ``\$x` `= (``\$x` `+ 1) % ``\$n``; ` `        ``\$y` `= (``\$y` `+ 1) % ``\$n``; ` `    ``} ` `    ``return` `true; ` `} ` ` `  `// Function to find starting index ` `// of lexicographically smallest ` `// sequence ` `function` `smallestSequence(``\$S``, ``\$n``) ` `{ ` `    ``\$index` `= 0; ` `    ``for` `( ``\$i` `= 1; ``\$i` `< ``\$n``; ``\$i``++) ` ` `  `        ``// if new sequence is smaller ` `        ``if` `(compareSeq(``\$S``, ``\$index``, ``\$i``, ``\$n``)) ` ` `  `            ``// change index of current min ` `            ``\$index` `= ``\$i``; ` ` `  `    ``return` `\$index``; ` `} ` ` `  `// Function to print lexicographically ` `// smallest sequence ` `function` `printSmallestSequence(``\$S``, ``\$n``) ` `{ ` `    ``\$starting_index` `= smallestSequence(``\$S``, ``\$n``); ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``echo` `\$S``[(``\$starting_index` `+ ``\$i``) % ``\$n``]; ` `} ` ` `  `    ``// Driver Code ` `    ``\$S``= ``"DCACBCAA"``; ` `    ``\$n` `= 8; ` `    ``printSmallestSequence(``\$S``, ``\$n``); ` ` `  `// This code is contributed by Ajit. ` `?> `

Output:

```AADCACBC
```

Time Complexity : O(n^2)
Auxiliary Space : O(1)

This article is contributed by Pratik Chhajer. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.