# Longest subsequence of a number having same left and right rotation A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

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: __4 _

Explanation:

_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:_ 6 _

Explanation:

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.

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

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(2N * 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;`

`}`

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

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.

## Search strings with the help of given pattern in an Array of strings

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

## Minimum flips required to convert given string into concatenation of equal

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

## Smallest String consisting of a String S exactly K times as a Substring

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

## Minimum number of flips with rotation to make binary string alternating

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

## Javascript String Search: How to Search String in JavaScript

Javascript String search() is an inbuilt function that executes the search for a match between a regular expression and this String object.