给定回文数之前的先前最大回文数

Question

The Question is: You are given a number 'N' in the form of a string 'S', which is a palindrome. You need to find the greatest number strictly less than 'N' which is also a palindrome.

I tried to solve this question but is giving wrong answer for some test cases. can anyone help me to correct my code. Below is my code:

string nextSmallerPalindrome(string &s)
{
    int n = s.length();
    string ans = "";
    
    if(n == 1)
    {
        s[0]--;
        return s;
    }
    
    if(s == "11")
    {
        return "9";
    }
    
   // For Handling odd cases
    if(n % 2 != 0)
    {
        int idx = n / 2;
        int diff = 0;
        
        if(s[idx] == '0')
        {
            s[idx] = '9';
            diff = 1;
        }
        else
        {
            s[idx]--;
        }
        
        idx--;
        
        while(idx >= 0 && diff == 1)
        {
            if(s[idx] == '0')
            {
                s[idx] = '9';
                idx--;
            }
            else
            {
                s[idx]--;
                diff = 0;
                break;
            }
        }
        
        int i = 0;
        while(i < n && s[i] == '0')
        {
            i++;
        }
        
        for(; i < n; i++)
        {
            ans = ans + s[i];
        }
        
        int new_n = ans.length();
        
        int j = 0;
        int k = new_n - 1;
        
        while(j < k)
        {
            if(ans[j] == ans[k])
            {
                j++;
                k--;
            }
            else
            {
                ans[k] = ans[j];
                j++;
                k--;
            }
        }
        
        return ans;
    }
    else                             // For handling even cases
    {
        int idx = n / 2 - 1;
        int diff = 0;
        
        if(s[idx] == '0')
        {
            s[idx] = '9';
            diff = 1;
        }
        else
        {
            s[idx]--;
        }
        
        idx--;
        
        while(idx >= 0 && diff == 1)
        {
            if(s[idx] == '0')
            {
                s[idx] = '9';
                idx--;
            }
            else
            {
                s[idx]--;
                diff = 0;
                break;
            }
        }
        
        int i = 0;
        while(i < n && s[i] == '0')   // For ignoring Zeros from front of the string
        {
            i++;
        }
        
        for(; i < n; i++)     //storing all the string s in new string ans after ignoring front 0
        {
            ans = ans + s[i];
        }
        
        int new_n = ans.length();
        
        int j = 0;
        int k = new_n - 1;
        
        while(j < k)                // checking and changing the last half into first half
        {
            if(ans[j] == ans[k])
            {
                j++;
                k--;
            }
            else
            {
                ans[k] = ans[j];
                j++;
                k--;
            }
        }
        
        return ans;
    }
}

Input Format: The first line of the input contains an integer T denoting the number of test cases.

The first and the only line of each test case contains a string 'S', denoting the number whose next smaller palindrome is to be found.

Test Case:

19
7
77
101
1001
1221
144441
3444444443
57855875
10000001
11
1
111
101
1001
11011
1110111
1190911
20002
10011001

Answer 1

Excuse me, but I will not fix the code. I will rather describe how I would solve it. If you like the idea, then you will have a very easy time doing it.

A palindrome has n digits. n may be pair or odd. The first n / 2 digits (rounded upwards) is a number. Get that number (cut down the digits in the second half) and subtract 1.

Look at the result and the number of its digits. If subtracting 1 decreases the number of digits of your half-number, then handle that accordingly. Should be easy if you have the right idea.

Answer 2

Seems like using the same expression for idx in even cases as odd cases works better.

(It still doesn't handle the case for 7 , though.)

Change this:

else                             // For handling even cases
{
    int idx = n / 2 - 1;

to this:

else                             // For handling even cases
{
    int idx = n / 2;

Results: