Amazon ： 找出所给数字的下一个回文数

找出所给数字的下一个回文数。所给数字不一定是回文数，要找的是恰好大于这个数字的最小的回文数。

本例子给出了两种方法来实现它。

 思路：  把该数字从中间分成左右长度相等两个数字串，记为左数字串和右数字串。

 

 A: 如果该数字串数字个数>1, 则按下面处理：

 1:如果该数的位数是偶数，把左数字串反过来，形成一个新的右数字串。

    1.1如果该新的右数字串换成数字后，比原来的右数字串大，则原来的左数字串+新的右数字串=所求之数字串。

    1.2 否则，把左数字加1，重新生成为一个新的左数字串，然后把它反转，形成新的右数字串。

        则 新的左数字串 + 新的右数字串 = 所求之数字串。

  

   2 如果该数的位数是奇数，把左数字串反过来，形成一个新的右数字串。

     2.1如果该新的右数字串换成数字后，比原来的右数字串大， 则 原来的左数字串 + 新的右数字串 = 所求之数字串。

     2.2 否则，把中间的那个数字+1。

          2.2.1 如果该中间数字加1后大于9，则把原来的左数字+1，然后形成一个新的左数字串,；如果该中间数字加1后<=9，原来的左数字串不变。

         2.2.2 把上步中的左数字串反转，形成新的右数字串。

         2.2.3 合并上面步骤得到的左数字串+中间数字+右数字串，即为所求之数字串。

 

 B: 如果数字串数字个数=1，则按以下处理：

 如果该数字<9,则，该数字+1后为所求的数字。

 如果该数字=9,则11为所求的数字。

 
程序输出：

entered number=12456 digits=5

V1 result number=12521

V2 result number=12521

entered number=12320 digits=5

V1 result number=12321

V2 result number=12321

entered number=12923 digits=5

V1 result number=13031

V2 result number=13031

entered number=1234 digits=4

V1 result number=1331

V2 result number=1331

entered number=8 digits=1

V1 result number=9

V2 result number=9

entered number=9 digits=1

V1 result number=11

V2 result number=11

entered number=9999 digits=4

V1 result number=9999

V2 result number=100001

entered number=1001001 digits=7

V1 result number=1002001

V2 result number=1002001

RUN SUCCESSFUL (total time: 955ms)

程序代码：

#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <sstream>

using namespace std;

void test(){
std::stringstream ss;
ss<<12345;
int m=0;
ss >> m;
cout<<m<<endl;

string str("");
str=ss.str();
cout<<str<<endl;
string str1("abc");
////在进行多次转换前，必须调用 stringstream::clear()
ss.clear();
ss << str1;
str=ss.str();
cout<<str<<endl;
/*
must use the below 2 statements to clear content stringstream.
*
*/
ss.clear();
ss.str("");
str=ss.str();
cout<<"final="<<str<<endl;
}
/*
思路：把该数字从中间分成左右长度相等两个数字串，记为左数字串和右数字串。

*A: 如果该数字串数字个数>1, 则按下面处理：
1:如果该数的位数是偶数，把左数字串反过来，形成一个新的右数字串。
1.1如果该新的右数字串换成数字后，比原来的右数字串大，则原来的左数字串+新的右数字串=所求之数字串。
1.2 否则，把左数字加1，重新生成为一个新的左数字串，然后把它反转，形成新的右数字串。
则 新的左数字串 + 新的右数字串 = 所求之数字串。

2 如果该数的位数是奇数，把左数字串反过来，形成一个新的右数字串。
2.1如果该新的右数字串换成数字后，比原来的右数字串大， 则 原来的左数字串 + 新的右数字串 = 所求之数字串。
2.2 否则，把中间的那个数字+1。
2.2.1 如果该中间数字加1后大于9，则把原来的左数字+1，然后形成一个新的左数字串,；如果该中间数字加1后<=9，原来的左数字串不变。
2.2.2 把上步中的左数字串反转，形成新的右数字串。
2.2.3 合并上面步骤得到的左数字串+中间数字+右数字串，即为所求之数字串。
*
*B: 如果数字串数字个数=1，则按以下处理：
* 如果该数字<9,则，该数字+1后为所求的数字。
* 如果该数字=9,则11为所求的数字。
*/
int GetFirstBiggerPalindromeV2(int givenumber) {
if(givenumber <=0)
return 0;
std::stringstream ss;
ss<<givenumber;
string numberstring=ss.str();
//digits
int len=numberstring.length();
bool odd=false;

if(len&1==1)
odd=true;

string leftstr(""),rightstr(""),reverseleftstr("");
int leftnum,rightnum,reserveleft;

if(len>1) {
leftstr.append(numberstring,0,len>>1);
if(odd)
rightstr.append(numberstring,(len>>1)+1,len>>1);
else
rightstr.append(numberstring,len>>1,len>>1);

reverseleftstr=leftstr;
reverse(reverseleftstr.begin(),reverseleftstr.end());

//must clear for ss via clear() and str("");
//clear() just clear out flags of stringstream.
ss.clear();
ss.str("");
ss<<leftstr;
ss>>leftnum;

ss.clear();
ss.str("");
ss<<rightstr;
ss>>rightnum;

ss.clear();
ss.str("");
ss<<reverseleftstr;
ss>>reserveleft;
}
int resultnum;
string resultstring;

if(odd){
if(len==1) {
ss.clear();
ss.str("");
ss<<numberstring;
ss>>resultnum;

if(resultnum==9)
resultnum=11;
else
resultnum++;
}
else { //len>1
char pchar=numberstring.at(len>>1);
int middlevalue=pchar-'0';
if(reserveleft <= rightnum){
if(middlevalue<9) {
pchar++;
} else {
pchar='0';
leftnum++;
ss.clear();
ss.str("");
ss<<leftnum;
leftstr=ss.str();

reverseleftstr=leftstr;
reverse(reverseleftstr.begin(),reverseleftstr.end());
}
}
resultstring=leftstr;
resultstring.append(1,pchar);
resultstring += reverseleftstr;
ss.clear();
ss.str("");
ss<<resultstring;
ss>>resultnum;
}
}

if(!odd) {
if(reserveleft <= rightnum) {
//把左数字加1，重新生成为左数字串，然后把它反转，形成新的右数字串。
//把这两个数字串相加，就是所求之数。
leftnum++;
ss.clear();
ss.str("");
ss<<leftnum;
leftstr=ss.str();
reverseleftstr=leftstr;
reverse(reverseleftstr.begin(),reverseleftstr.end());
}
resultstring=leftstr;
resultstring += reverseleftstr;

ss.clear();
ss.str("");
ss<<resultstring;
ss>>resultnum;
}
cout<<"V2 result number="<<resultnum<<endl;
return resultnum;
}

int GetFirstBiggerPalindrome(int givenumber) {

if(givenumber <=0)
return 0;

char strnumber[100]={0};
bool odd=true;
int numberdigit=0,middle=0;

sprintf(strnumber,"%d",givenumber);
numberdigit=strlen(strnumber);
cout<<"entered number="<<strnumber<<" digits="<<numberdigit<<endl;

middle=numberdigit/2;
if((numberdigit&1)==1) {
odd=true;
middle++;
}
else
odd=false;

char leftstr[100]={0};
char rightstr[100]={0};
char leftreversestr[100]={0};

int leftnumber=0,rightnumber=0,leftreverse=0;
char middlenum;
int index=0;
int mid_position;

if(odd)
mid_position=middle-1;
else
mid_position=middle;

for(index=0;index<mid_position;index++){
leftstr[index]= strnumber[index];
leftreversestr[ mid_position-1-index]=leftstr[index];
}
leftstr[index]='\0';
leftreversestr[index]='\0';

leftnumber=atoi(leftstr);
leftreverse=atoi(leftreversestr);

for(index=middle; index< numberdigit; index++){
rightstr[index - middle]= strnumber[index];
}
rightstr[index]='\0';
rightnumber=atoi(rightstr);

char finalstr[100]={0};
char *ptr=0;
int resultNumber=0;

if(odd){
if(numberdigit==1){
middlenum=strnumber[middle-1];
resultNumber=middlenum-'0';
if(resultNumber<9)
resultNumber++;
else
resultNumber=11;
}
//multi digits >=3
else {
middlenum=strnumber[middle-1];
if(leftreverse <= rightnumber) {
if(middlenum < '9' ){
middlenum++;
strcpy(finalstr,leftstr);
finalstr[middle-1]=middlenum;
ptr=finalstr + middle;
strcpy(ptr,leftreversestr);
resultNumber=atoi(finalstr);
}
//==9
else {
middlenum='0';
leftnumber++;
//remake the reverse left
sprintf(leftstr,"%d",leftnumber);
int length=strlen(leftstr);
for(index=0;index<length;index++){
leftreversestr[length-1-index]=leftstr[index];
}
leftreversestr[index]='\0';
strcpy(finalstr,leftstr);
finalstr[middle-1]=middlenum;
ptr=finalstr + middle;
strcpy(ptr,leftreversestr);
resultNumber=atoi(finalstr);
}
}
else { //left>right
strcpy(finalstr,leftstr);
finalstr[middle-1]=middlenum;
ptr=finalstr + middle;
strcpy(ptr,leftreversestr);
resultNumber=atoi(finalstr);
}
}
}

//even
if(!odd) {
if(leftreverse < rightnumber){
leftnumber++;
sprintf(leftstr,"%d",leftnumber);
int length=strlen(leftstr);
for(index=0;index<length;index++){
leftreversestr[length-1-index]=leftstr[index];
}

leftreversestr[index]='\0';
strcpy(finalstr,leftstr);
ptr=finalstr + middle;
strcpy(ptr,leftreversestr);
resultNumber=atoi(finalstr);
}
//leftreverse > right, make directly
else {
strcpy(finalstr,leftstr);
ptr=finalstr + middle;
strcpy(ptr,leftreversestr);
resultNumber=atoi(finalstr);
}
}

cout<<"V1 result number="<<resultNumber<<endl;
return resultNumber;
}
/*
*
*/
int main(int argc, char** argv) {
/*string str="12345";
test();
return 0;
*/
GetFirstBiggerPalindrome(12456);
GetFirstBiggerPalindromeV2(12456);

GetFirstBiggerPalindrome(12320);
GetFirstBiggerPalindromeV2(12320);

GetFirstBiggerPalindrome(12923);
GetFirstBiggerPalindromeV2(12923);

GetFirstBiggerPalindrome(1234);
GetFirstBiggerPalindromeV2(1234);

GetFirstBiggerPalindrome(8);
GetFirstBiggerPalindromeV2(8);

GetFirstBiggerPalindrome(9);
GetFirstBiggerPalindromeV2(9);

GetFirstBiggerPalindrome(9999);
GetFirstBiggerPalindromeV2(9999);

GetFirstBiggerPalindrome(1001001);
GetFirstBiggerPalindromeV2(1001001);

return 0;
}