下一个更高的回文数使用相同的数字集-yiteyi-C++库

给定一个回文数号码有 N 位数。问题是找到最小的回文数大于号码使用与中相同的数字集号码 .如果无法形成此类编号，则打印“不可能”。这个数字可能非常大，甚至可能不适合长整型。

null

例如：

Input : 4697557964Output :  4756996574Input : 543212345Output : Not Possible

建议：请在“上解决” 实践 “首先，在讨论解决方案之前。

方法： 以下是步骤：

如果数字n<=3，则打印“不可能”并返回。
计算中间 =n/2–1。
从索引处的数字开始遍历中间直到第1位，并在遍历时找到索引我最右边的数字，比右边的数字小。
现在搜索大于数字的最小数字 num[i] 在索引范围内 i+1 到中间 .让这个数字的索引为 最小的 .
如果没有找到这样的最小数字，则打印“不可能”。
否则，交换索引中的数字我和 最小的 还可以在索引处交换数字 n-i-1 和 n-1 .执行此步骤是为了在号码 .
现在反转索引范围中的数字 i+1 到中间 .如果 N 甚至可以反转索引范围中的数字 中期+1 到 n-i-2 否则如果 N 如果是奇数，则反转索引范围内的数字 中期+2 到 n-i-2 .执行此步骤是为了在号码 .
打印最终修改的数字号码 .

C++

                         // C++ implementation to find next higher                       
                         // palindromic number using the same set                       
                         // of digits                       
                         #include <bits/stdc++.h>                       
                         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 digits                       
                         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) {                       
                                                 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 above                       
                         int                                     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 digits                       
                         import                                     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 digits                       
                         def                                     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 Code                       
                         st                                     =                                     "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 digits                       
                         using                                     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

                         <?php                       
                         // PHP 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'                       
                         function                                     reverse(&                                     $num                                     ,                                     $i                                     ,                                     $j                                     )                       
                         {                       
                                                 while                                     (                                     $i                                     <                                     $j                                     )                       
                                                 {                       
                                                 $t                                     =                                     $num                                     [                                     $i                                     ];                       
                                                 $num                                     [                                     $i                                     ] =                                     $num                                     [                                     $j                                     ];                       
                                                 $num                                     [                                     $j                                     ] =                                     $t                                     ;                       
                                                 $i                                     ++;                       
                                                 $j                                     --;                       
                                                 }                       
                         }                       
           
                         // function to find next higher                       
                         // palindromic number using the                       
                         // same set of digits                       
                         function                                     nextPalin(                                     $num                                     ,                                     $n                                     )                       
                         {                       
                                                 // if length of number is less                       
                                                 // than '3' then no higher                       
                                                 // palindromic number can be formed                       
                                                 if                                     (                                     $n                                     <= 3)                       
                                                 {                       
                                                 echo                                     "Not Possible"                                     ;                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 // find the index of last digit                       
                                                 // in the 1st half of 'num'                       
                                                 $mid                                     = (                                     $n                                     / 2) - 1;                       
                                                 $i                                     =                                     $mid                                     - 1;                       
                                                 $j                                     ;                       
           
                                                 // Start from the (mid-1)th digit                       
                                                 // and find the first digit                       
                                                 // that is smaller than the digit                       
                                                 // next to it.                       
                                                 for                                     (;                                     $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)                       
                                                 {                       
                                                 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

                         <script>                       
           
                         // Javascript implementation to find next higher                       
                         // palindromic number using the same set                       
                         // of digitsclass NextHigherPalindrome                       
           
                         // Function to reverse the digits in the                       
                         // range i to j in 'num'                       
                         function                                     reverse(num , i, j)                       
                         {                       
                                                 while                                     (i < j)                       
                                                 {                       
                                                 var                                     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                       
                         function                                     nextPalin(num, n)                       
                         {                       
                                   
                                                 // If length of number is less than '3'                       
                                                 // then no higher palindromic number                       
                                                 // can be formed                       
                                                 if                                     (n <= 3)                       
                                                 {                       
                                                 document.write(                                     "Not Possible"                                     );                       
                                                 return                                     ;                       
                                                 }                       
                                                 var                                     temp;                       
                                   
                                                 // Find the index of last digit                       
                                                 // in the 1st half of 'num'                       
                                                 var                                     mid = n / 2 - 1;                       
                                                 var                                     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)                       
                                                 {                       
                                                 document.write(                                     "Not Possible"                                     );                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 // Find the smallest digit on right                       
                                                 // side of ith digit which is greater                       
                                                 // than num[i] up to index 'mid'                       
                                                 var                                     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                       
                                                 var                                     result = num.join(                                     ''                                     );                       
                                                 document.write(                                     "Next Palindrome: "                                     +                       
                                                 result);                       
                         }                       
           
                         // Driver Code                       
                         var                                     str =                                     "4697557964"                                     ;                       
                         var                                     num = str.split(                                     ''                                     );                       
                         var                                     n = str.length;                       
           
                         nextPalin(num,n);                       
           
                         // This code is contributed by 29AjayKumar                       
           
                         </script>                       

输出：

Next Palindrome: 4756996574

时间复杂性： O（n）

本文由 阿尤什·焦哈里 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章