Given a numeric string **S**, the task is to find the maximum length of a subsequence having its left rotation equal to its right rotation.

**Examples:**

Input:S = “100210601”Output:4Explanation:

The subsequence “0000” satisfies the necessary condition.

The subsequence “1010” generates the string “0101” on left rotation and string “0101” on right rotation. Since both the rotations are same. Therefore, “1010” satisfies the condition as well.

Therefore, the maximum length of such subsequence is 4.Input:S = “252525”Output:6Explanation:

The subsequence “252525” generates the string “525252” on left rotation and string “525252” on right rotation. Since both the rotations are same. Therefore, the “252525” satisfies the required condition.

**Naive Approach:** The simplest approach to solve the problem is to generate all possible subsequences of the given string, and for each subsequence, check if its left rotation is equal to its right rotation. **Time Complexity:** O(2^{N} * N) **Auxiliary Space:** O(N)

**Efficient Approach: **To optimize the above approach, the main observation is that the subsequence should either consist of a **single character** or should be of even length consisting of **two characters alternatively**.

Illustration:

str = “2424”

Left rotation of the string = “4242”

Right rotation of the string = “4242”

As we can see, since the number is of even length having two characters appearing alternately, therefore, the left and right rotation of the given number is equal.

str = “24242”

Left rotation of the string = “42422”

Right rotation of the string = “22424”

As we can see, since the number is of odd length having two characters appearing alternately, therefore, the left and right rotation of the given number is not equal.

Follow the steps below to solve the problem:

- Generate all possible two-digit numbers.
- For each two-digit number generated, check for the alternating occurrence of both the digits in the string. Keep incrementing count to store length of alternating subequence for the particular combination.
- After entire traversal of the string, check if both the digits are equal or not. If found to be true, update
**count**to the required answer. If both the digits are equal, then update**count**or**count – 1**to the answer if count is even or odd respectively. - Repeat the above steps for all the possible combinations and print the maximum
**count**obtained.

Below is the implementation of the above approach:

## C++

`// C++ Program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the longest subsequence` `// having equal left and right rotation` `int` `findAltSubSeq(string s)` `{` ` ` `// Length of the string` ` ` `int` `n = s.size(), ans = INT_MIN;` ` ` `// Iterate for all possible combinations` ` ` `// of a two-digit numbers` ` ` `for` `(` `int` `i = 0; i < 10; i++) {` ` ` `for` `(` `int` `j = 0; j < 10; j++) {` ` ` `int` `cur = 0, f = 0;` ` ` `// Check for alternate occurrence` ` ` `// of current combination` ` ` `for` `(` `int` `k = 0; k < n; k++) {` ` ` `if` `(f == 0 and s[k] - ` `'0'` `== i) {` ` ` `f = 1;` ` ` `// Increment the current value` ` ` `cur++;` ` ` `}` ` ` `else` `if` `(f == 1 and s[k] - ` `'0'` `== j) {` ` ` `f = 0;` ` ` `// Increment the current value` ` ` `cur++;` ` ` `}` ` ` `}` ` ` `// If alternating sequence is` ` ` `// obtained of odd length` ` ` `if` `(i != j and cur % 2 == 1)` ` ` `// Reduce to even length` ` ` `cur--;` ` ` `// Update answer to store` ` ` `// the maximum` ` ` `ans = max(cur, ans);` ` ` `}` ` ` `}` ` ` `// Return the answer` ` ` `return` `ans;` `}` `// Driver Code` `int` `main()` `{` ` ` `string s = ` `"100210601"` `;` ` ` `cout << findAltSubSeq(s);` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## Java

`// Java Program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to find the longest subsequence` `// having equal left and right rotation` `static` `int` `findAltSubSeq(String s)` `{` ` ` `// Length of the String` ` ` `int` `n = s.length(), ans = Integer.MIN_VALUE;` ` ` `// Iterate for all possible combinations` ` ` `// of a two-digit numbers` ` ` `for` `(` `int` `i = ` `0` `; i < ` `10` `; i++)` ` ` `{` ` ` `for` `(` `int` `j = ` `0` `; j < ` `10` `; j++)` ` ` `{` ` ` `int` `cur = ` `0` `, f = ` `0` `;` ` ` `// Check for alternate occurrence` ` ` `// of current combination` ` ` `for` `(` `int` `k = ` `0` `; k < n; k++) ` ` ` `{` ` ` `if` `(f == ` `0` `&& s.charAt(k) - ` `'0'` `== i) ` ` ` `{` ` ` `f = ` `1` `;` ` ` `// Increment the current value` ` ` `cur++;` ` ` `}` ` ` `else` `if` `(f == ` `1` `&& ` ` ` `s.charAt(k) - ` `'0'` `== j) ` ` ` `{` ` ` `f = ` `0` `;` ` ` `// Increment the current value` ` ` `cur++;` ` ` `}` ` ` `}` ` ` `// If alternating sequence is` ` ` `// obtained of odd length` ` ` `if` `(i != j && cur % ` `2` `== ` `1` `)` ` ` `// Reduce to even length` ` ` `cur--;` ` ` `// Update answer to store` ` ` `// the maximum` ` ` `ans = Math.max(cur, ans);` ` ` `}` ` ` `}` ` ` `// Return the answer` ` ` `return` `ans;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `String s = ` `"100210601"` `;` ` ` `System.out.print(findAltSubSeq(s));` `}` `}` `// This code is contributed by PrinciRaj1992` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to implement ` `# the above approach ` `import` `sys` `# Function to find the longest subsequence ` `# having equal left and right rotation ` `def` `findAltSubSeq(s):` ` ` ` ` `# Length of the string` ` ` `n ` `=` `len` `(s)` ` ` `ans ` `=` `-` `sys.maxsize ` `-` `1` ` ` ` ` `# Iterate for all possible combinations ` ` ` `# of a two-digit numbers ` ` ` `for` `i ` `in` `range` `(` `10` `):` ` ` `for` `j ` `in` `range` `(` `10` `):` ` ` `cur, f ` `=` `0` `, ` `0` ` ` ` ` `# Check for alternate occurrence ` ` ` `# of current combination ` ` ` `for` `k ` `in` `range` `(n):` ` ` `if` `(f ` `=` `=` `0` `and` `ord` `(s[k]) ` `-` ` ` `ord` `(` `'0'` `) ` `=` `=` `i):` ` ` `f ` `=` `1` ` ` ` ` `# Increment the current value` ` ` `cur ` `+` `=` `1` ` ` ` ` `elif` `(f ` `=` `=` `1` `and` `ord` `(s[k]) ` `-` ` ` `ord` `(` `'0'` `) ` `=` `=` `j):` ` ` `f ` `=` `0` ` ` ` ` `# Increment the current value` ` ` `cur ` `+` `=` `1` ` ` ` ` `# If alternating sequence is ` ` ` `# obtained of odd length ` ` ` `if` `i !` `=` `j ` `and` `cur ` `%` `2` `=` `=` `1` `:` ` ` ` ` `# Reduce to even length ` ` ` `cur ` `-` `=` `1` ` ` ` ` `# Update answer to store ` ` ` `# the maximum ` ` ` `ans ` `=` `max` `(cur, ans)` ` ` ` ` `# Return the answer ` ` ` `return` `ans` `# Driver code` `s ` `=` `"100210601"` `print` `(findAltSubSeq(s))` `# This code is contributed by Stuti Pathak` |

*chevron_right*

*filter_none*

## C#

`// C# Program to implement` `// the above approach` `using` `System;` `class` `GFG{` `// Function to find the longest subsequence` `// having equal left and right rotation` `static` `int` `findAltSubSeq(String s)` `{` ` ` `// Length of the String` ` ` `int` `n = s.Length, ans = ` `int` `.MinValue;` ` ` `// Iterate for all possible combinations` ` ` `// of a two-digit numbers` ` ` `for` `(` `int` `i = 0; i < 10; i++)` ` ` `{` ` ` `for` `(` `int` `j = 0; j < 10; j++)` ` ` `{` ` ` `int` `cur = 0, f = 0;` ` ` `// Check for alternate occurrence` ` ` `// of current combination` ` ` `for` `(` `int` `k = 0; k < n; k++) ` ` ` `{` ` ` `if` `(f == 0 && s[k] - ` `'0'` `== i) ` ` ` `{` ` ` `f = 1;` ` ` `// Increment the current value` ` ` `cur++;` ` ` `}` ` ` `else` `if` `(f == 1 && ` ` ` `s[k] - ` `'0'` `== j) ` ` ` `{` ` ` `f = 0;` ` ` `// Increment the current value` ` ` `cur++;` ` ` `}` ` ` `}` ` ` `// If alternating sequence is` ` ` `// obtained of odd length` ` ` `if` `(i != j && cur % 2 == 1)` ` ` `// Reduce to even length` ` ` `cur--;` ` ` `// Update answer to store` ` ` `// the maximum` ` ` `ans = Math.Max(cur, ans);` ` ` `}` ` ` `}` ` ` `// Return the answer` ` ` `return` `ans;` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `String s = ` `"100210601"` `;` ` ` `Console.Write(findAltSubSeq(s));` `}` `}` `// This code is contributed by PrinciRaj1992` |

*chevron_right*

*filter_none*

**Output:**

4

**Time Complexity:** O(N) **Auxiliary Space:** O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Left Rotation and Right Rotation of a String
- Minimize characters to be changed to make the left and right rotation of a string same
- Longest Increasing Subsequence using Longest Common Subsequence Algorithm
- Find the length of the longest subsequence with first K alphabets having same frequency
- Print left rotation of array in O(n) time and O(1) space
- Left rotation of an array using vectors in C++
- Length of longest subsequence having sum of digits of each element as a Composite Number
- Reversal algorithm for right rotation of an array
- Number of possible permutations when absolute difference between number of elements to the right and left are given
- Subsequence pair from given Array having all unique and all same elements respectively
- Longest subsequence such that every element in the subsequence is formed by multiplying previous element with a prime
- Longest subsequence having equal numbers of 0 and 1
- Length of longest Palindromic Subsequence of even length with no two adjacent characters same
- Maximize count of corresponding same elements in given Arrays by Rotation
- Longest subsequence having greater corner values
- Find the longest subsequence of an array having LCM at most K
- Longest subsequence having difference atmost K
- Longest Increasing Subsequence having sum value atmost K
- Length of longest subsequence in an Array having all elements as Nude Numbers
- Length of longest subsequence having absolute difference of all pairs divisible by K

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.