Open In App

# Next higher palindromic number using the same set of digits

Given a palindromic number num having n number of digits. The problem is to find the smallest palindromic number greater than num using the same set of digits as in num. If no such number can be formed then print “Not Possible”.
The number could be very large and may or may not even fit into long long int.

Examples:

Input : 4697557964
Output :  4756996574

Input : 543212345
Output : Not Possible

Approach:

Follow the below steps to solve the problem:

1. If number of digits n <= 3, then print “Not Possible” and return.
2. Calculate mid = n/2 – 1.
3. Start traversing from the digit at index mid up to the 1st digit and while traversing find the index i of the rightmost digit which is smaller than the digit on its right side.
4. Now search for the smallest digit greater than the digit num[i] in the index range i+1 to mid. Let the index of this digit be smallest.
5. If no such smallest digit found, then print “Not Possible”.
6. Else the swap the digits at index i and smallest and also swap the digits at index n-i-1 and n-smallest-1. This step is done so as to maintain the palindromic property in num.
7. Now reverse the digits in the index range i+1 to mid. Also If n is even then reverse the digits in the index range mid+1 to n-i-2 else if n is odd then reverse the digits in the index range mid+2 to n-i-2. This step is done so as to maintain the palindromic property in num.
8. Print the final modified number num.

Implementation:

## C

 // C implementation to find next higher// palindromic number using the same set// of digits #include #include  // function to reverse the digits in the// range i to j in 'num'void reverse(char num[], int i, int j){    while (i < j) {        char temp = num[i];        num[i] = num[j];        num[j] = temp;        i++;        j--;    }} // function to find next higher palindromic// number using the same set of digitsvoid nextPalin(char num[], int n){    // if length of number is less than '3'    // then no higher palindromic number    // can be formed    if (n <= 3) {        printf("Not Possible");        return;    }     // find the index of last digit    // in the 1st half of 'num'    int mid = n / 2 - 1;    int i, j;     // Start from the (mid-1)th digit and    // find the first digit that is    // smaller than the digit next to it.    for (i = mid - 1; i >= 0; i--)        if (num[i] < num[i + 1])            break;     // If no such digit is found, then all    // digits are in descending order which    // means there cannot be a greater    // palindromic number with same set of    // digits    if (i < 0) {        printf("Not Possible");        return;    }     // Find the smallest digit on right    // side of ith digit which is greater    // than num[i] up to index 'mid'    int smallest = i + 1;    for (j = i + 2; j <= mid; j++)        if (num[j] > num[i] && num[j] <= num[smallest])            smallest = j;     // swap num[i] with num[smallest]    char temp = num[i];    num[i] = num[smallest];    num[smallest] = temp;     // as the number is a palindrome, the same    // swap of digits should be performed in    // the 2nd half of 'num'    temp = num[n - i - 1];    num[n - i - 1] = num[n - smallest - 1];    num[n - smallest - 1] = temp;     // reverse digits in the range (i+1) to mid    reverse(num, i + 1, mid);     // if n is even, then reverse digits in the    // range mid+1 to n-i-2    if (n % 2 == 0)        reverse(num, mid + 1, n - i - 2);     // else if n is odd, then reverse digits    // in the range mid+2 to n-i-2    else        reverse(num, mid + 2, n - i - 2);     // required next higher palindromic number    printf("Next Palindrome: %s", num);} // Driver program to test aboveint main(){    char num[] = "4697557964";    int n = strlen(num);    nextPalin(num, n);    return 0;}

## C++

 // C++ implementation to find next higher// palindromic number using the same set// of digits#include using namespace std; // function to reverse the digits in the// range i to j in 'num'void reverse(char num[], int i, int j){    while (i < j) {        swap(num[i], num[j]);        i++;        j--;    }} // function to find next higher palindromic// number using the same set of digitsvoid nextPalin(char num[], int n){    // if length of number is less than '3'    // then no higher palindromic number    // can be formed    if (n <= 3) {        cout << "Not Possible";        return;    }     // find the index of last digit    // in the 1st half of 'num'    int mid = n / 2 - 1;    int i, j;     // Start from the (mid-1)th digit and    // find the first digit that is    // smaller than the digit next to it.    for (i = mid - 1; i >= 0; i--)        if (num[i] < num[i + 1])            break;     // If no such digit is found, then all    // digits are in descending order which    // means there cannot be a greater    // palindromic number with same set of    // digits    if (i < 0) {        cout << "Not Possible";        return;    }     // Find the smallest digit on right    // side of ith digit which is greater    // than num[i] up to index 'mid'    int smallest = i + 1;    for (j = i + 2; j <= mid; j++)        if (num[j] > num[i] &&            num[j] <= num[smallest])            smallest = j;     // swap num[i] with num[smallest]    swap(num[i], num[smallest]);     // as the number is a palindrome, the same    // swap of digits should be performed in    // the 2nd half of 'num'    swap(num[n - i - 1], num[n - smallest - 1]);     // reverse digits in the range (i+1) to mid    reverse(num, i + 1, mid);     // if n is even, then reverse digits in the    // range mid+1 to n-i-2    if (n % 2 == 0)        reverse(num, mid + 1, n - i - 2);     // else if n is odd, then reverse digits    // in the range mid+2 to n-i-2    else        reverse(num, mid + 2, n - i - 2);     // required next higher palindromic number    cout << "Next Palindrome: "         << num;} // Driver program to test aboveint main(){    char num[] = "4697557964";    int n = strlen(num);    nextPalin(num, n);    return 0;}

## Java

 // Java implementation to find next higher// palindromic number using the same set// of digitsimport java.util.*; class NextHigherPalindrome{    // function to reverse the digits in the    // range i to j in 'num'    public static void reverse(char num[], int i,                                          int j)    {        while (i < j) {            char temp = num[i];            num[i] = num[j];            num[j] = temp;            i++;            j--;        }    }         // function to find next higher palindromic    // number using the same set of digits    public static void nextPalin(char num[], int n)    {        // if length of number is less than '3'        // then no higher palindromic number        // can be formed        if (n <= 3) {            System.out.println("Not Possible");            return;        }        char temp;                 // find the index of last digit        // in the 1st half of 'num'        int mid = n / 2 - 1;        int i, j;             // Start from the (mid-1)th digit and        // find the first digit that is        // smaller than the digit next to it.        for (i = mid - 1; i >= 0; i--)            if (num[i] < num[i + 1])                break;             // If no such digit is found, then all        // digits are in descending order which        // means there cannot be a greater        // palindromic number with same set of        // digits        if (i < 0) {            System.out.println("Not Possible");            return;        }             // Find the smallest digit on right        // side of ith digit which is greater        // than num[i] up to index 'mid'        int smallest = i + 1;        for (j = i + 2; j <= mid; j++)            if (num[j] > num[i] &&                num[j] <= num[smallest])                smallest = j;             // swap num[i] with num[smallest]        temp = num[i];        num[i] = num[smallest];        num[smallest] = temp;                 // as the number is a palindrome,        // the same swap of digits should        // be performed in the 2nd half of        // 'num'        temp = num[n - i - 1];        num[n - i - 1] = num[n - smallest - 1];        num[n - smallest - 1] = temp;                 // reverse digits in the range (i+1)        // to mid        reverse(num, i + 1, mid);             // if n is even, then reverse        // digits in the range mid+1 to        // n-i-2        if (n % 2 == 0)            reverse(num, mid + 1, n - i - 2);             // else if n is odd, then reverse        // digits in the range mid+2 to n-i-2        else            reverse(num, mid + 2, n - i - 2);             // required next higher palindromic        // number        String result=String.valueOf(num);        System.out.println("Next Palindrome: "+                                   result);    }         // Driver Code    public static void main(String args[])    {        String str="4697557964";        char num[]=str.toCharArray();        int n=str.length();        nextPalin(num,n);    }} // This code is contributed by Danish Kaleem

## Python

 # Python implementation to find next higher# palindromic number using the same set# of digits # function to reverse the digits in the# range i to j in 'num'def reverse(num, i, j) :         while (i < j) :        temp = num[i]        num[i] = num[j]        num[j] = temp        i = i + 1        j = j - 1              # function to find next higher palindromic# number using the same set of digitsdef nextPalin(num, n) :         # if length of number is less than '3'    # then no higher palindromic number    # can be formed    if (n <= 3) :        print "Not Possible"        return         # find the index of last digit    # in the 1st half of 'num'    mid = n / 2 - 1         # Start from the (mid-1)th digit and    # find the first digit that is    # smaller than the digit next to it.    i = mid - 1    while i >= 0 :        if (num[i] < num[i + 1]) :            break        i = i - 1         # If no such digit is found, then all    # digits are in descending order which    # means there cannot be a greater    # palindromic number with same set of    # digits    if (i < 0) :        print "Not Possible"        return         # Find the smallest digit on right    # side of ith digit which is greater    # than num[i] up to index 'mid'    smallest = i + 1    j = i + 2    while j <= mid :        if (num[j] > num[i] and num[j] <                        num[smallest]) :            smallest = j        j = j + 1         # swap num[i] with num[smallest]    temp = num[i]    num[i] = num[smallest]    num[smallest] = temp         # as the number is a palindrome,    # the same swap of digits should    # be performed in the 2nd half of    # 'num'    temp = num[n - i - 1]    num[n - i - 1] = num[n - smallest - 1]    num[n - smallest - 1] = temp         # reverse digits in the range (i+1)    # to mid    reverse(num, i + 1, mid)         # if n is even, then reverse    # digits in the range mid+1 to    # n-i-2    if (n % 2 == 0) :        reverse(num, mid + 1, n - i - 2)             # else if n is odd, then reverse    # digits in the range mid+2 to n-i-2    else :        reverse(num, mid + 2, n - i - 2)                      # required next higher palindromic    # number    result = ''.join(num)         print "Next Palindrome: ",result     # Driver Codest = "4697557964"num = list(st)n = len(st)nextPalin(num, n) # This code is contributed by Nikita Tiwari

## C#

 // C# implementation to find// next higher palindromic// number using the same set// of digitsusing System; class GFG{    // function to reverse    // the digits in the    // range i to j in 'num'    public static void reverse(char[] num,                               int i, int j)    {        while (i < j)        {            char temp = num[i];            num[i] = num[j];            num[j] = temp;            i++;            j--;        }    }         // function to find next    // higher palindromic number    // using the same set of digits    public static void nextPalin(char[] num,                                 int n)    {        // if length of number is        // less than '3' then no        // higher palindromic number        // can be formed        if (n <= 3)        {            Console.WriteLine("Not Possible");            return;        }        char temp;                 // find the index of last        // digit in the 1st half        // of 'num'        int mid = n / 2 - 1;        int i, j;             // Start from the (mid-1)th        // digit and find the        // first digit that is        // smaller than the digit        // next to it.        for (i = mid - 1; i >= 0; i--)            if (num[i] < num[i + 1])                break;             // If no such digit is found,        // then all digits are in        // descending order which        // means there cannot be a        // greater palindromic number        // with same set of digits        if (i < 0)        {            Console.WriteLine("Not Possible");            return;        }             // Find the smallest digit on        // right side of ith digit         // which is greater than num[i]        // up to index 'mid'        int smallest = i + 1;        for (j = i + 2; j <= mid; j++)            if (num[j] > num[i] &&                num[j] < num[smallest])                smallest = j;             // swap num[i] with        // num[smallest]        temp = num[i];        num[i] = num[smallest];        num[smallest] = temp;                 // as the number is a palindrome,        // the same swap of digits should        // be performed in the 2nd half of        // 'num'        temp = num[n - i - 1];        num[n - i - 1] = num[n - smallest - 1];        num[n - smallest - 1] = temp;                 // reverse digits in the         // range (i+1) to mid        reverse(num, i + 1, mid);             // if n is even, then        // reverse digits in the        // range mid+1 to n-i-2        if (n % 2 == 0)            reverse(num, mid + 1,                    n - i - 2);             // else if n is odd, then        // reverse digits in the        // range mid+2 to n-i-2        else            reverse(num, mid + 2,                    n - i - 2);             // required next higher        // palindromic number        String result = new String(num);        Console.WriteLine("Next Palindrome: "+                                      result);    }         // Driver Code    public static void Main()    {        String str = "4697557964";        char[] num = str.ToCharArray();        int n = str.Length;        nextPalin(num, n);    }} // This code is contributed by mits

## PHP

 = 0; \$i--)        if (\$num[\$i] < \$num[\$i + 1])            break;     // If no such digit is found,    // then all digits are in    // descending order which means    // there cannot be a greater    // palindromic number with same    // set of digits    if (\$i < 0)    {        echo "Not Possible";        return;    }     // Find the smallest digit on right    // side of ith digit which is greater    // than num[i] up to index 'mid'    \$smallest = \$i + 1;    \$j = 0;    for (\$j = \$i + 2; \$j <= \$mid; \$j++)        if (\$num[\$j] > \$num[\$i] &&            \$num[\$j] < \$num[\$smallest])            \$smallest = \$j;     // swap num[i] with num[smallest]    \$t = \$num[\$i];    \$num[\$i] = \$num[\$smallest];    \$num[\$smallest] = \$t;         // as the number is a palindrome,    // the same swap of digits should    // be performed in the 2nd half of 'num'    \$t = \$num[\$n - \$i - 1];    \$num[\$n - \$i - 1] = \$num[\$n - \$smallest - 1];    \$num[\$n - \$smallest - 1] = \$t;     // reverse digits in the    // range (i+1) to mid    reverse(\$num, \$i + 1, \$mid);     // if n is even, then    // reverse digits in the    // range mid+1 to n-i-2    if (\$n % 2 == 0)        reverse(\$num, \$mid + 1, \$n - \$i - 2);     // else if n is odd, then reverse    // digits in the range mid+2    // to n-i-2    else        reverse(\$num, \$mid + 2, \$n - \$i - 2);     // required next higher    // palindromic number    echo "Next Palindrome: " . \$num;} // Driver Code\$num = "4697557964";\$n = strlen(\$num);nextPalin(\$num, \$n); // This code is contributed by mits?>

## Javascript



Output

Next Palindrome: 4756996574

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

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