描述：
给定一个整数 n ，你需要找到与它最近的回文数（不包括自身）。
“最近的”定义为两个整数差的绝对值最小。
代码：
/**
* @param {string} n
* @return {string}
*/
var nearestPalindromic = function(n) {
n = parseInt(n);
function findPalindromic(num){
let reverseNum = 0,origin = num;
while( num ){
reverseNum = reverseNum * 10 + num % 10;
num = Math.floor(num / 10);
}
if( origin == reverseNum )
return origin.toString();
return false;
}
let leftCount = 0,rightCount = 0;
while(true){
let left = findPalindromic( n + (--leftCount) );
if(left)
return left;
let right = findPalindromic( n + (++rightCount) );
if(right)
return right
}
};思路： 没错，一开始就想到的是枚举，暴力寻找数据----老实人的算法 哈哈哈，然后我现在要换思路了，打算从给出的数据中找规律；
嗯 一会儿看看能不能找出
20180914 10.15
代码：
/**
* @param {string} n
* @return {string}
*/
var nearestPalindromic = function(n) {
// n = parseInt(n);
function findPalindromic(num){
let reverseNum = 0,origin = num;
while( num ){
reverseNum = reverseNum * 10 + num % 10;
num = Math.floor(num / 10);
}
if( origin == reverseNum )
return origin.toString();
return false;
}
if(n.length == 1) return (--n).toString() +'';
if( n.length > (--n).toString().length ){
return n+'';
}
n = (++n).toString();
if( findPalindromic(n) ){
n = +n;
let leftCount = 0,rightCount = 0;
while(true){
let left = findPalindromic( n + (--leftCount) );
if(left)
return left;
let right = findPalindromic( n + (++rightCount) );
if(right)
return right
}
}
let mid = Math.floor(n.length / 2),
left= n.slice(0,mid),
right = n.length % 2 == 0 ? n.slice( mid ) : n.slice(mid + 1),
leftDiff = left - right.split('').reverse().join(''),
rightDiff = right - left.split('').reverse().join('');
if( n.length % 2 == 0 ){
if( Math.abs( +(parseInt( left ) - leftDiff + right) - n ) > Math.abs( +( left + ( parseInt(right) - rightDiff )) - n)){
return ( left + ( parseInt(right) - rightDiff ));
}else{
return ((parseInt( left ) - leftDiff + right) > ( left + ( parseInt(right) - rightDiff )) ) ? ( left + ( parseInt(right) - rightDiff )): (parseInt( left ) - leftDiff + right);
}
}else{
if( Math.abs( +(parseInt( left ) - leftDiff + right) - n ) > Math.abs( +( left + ( parseInt(right) - rightDiff )) - n)){
return ( left + n[mid] + ( parseInt(right) - rightDiff ));
}else{
return ( (parseInt( left ) - leftDiff + n[mid] + right) > ( left + n[mid] + ( parseInt(right) - rightDiff )) )? ( left + n[mid] + ( parseInt(right) - rightDiff )) : (parseInt( left ) - leftDiff + n[mid] + right);
}
}
};思路：
就是说，一个数要想变成回文数， 可以把他分成两半儿，要么让左边的变成右边相反的部分，要么反之，然而测试用例很快就打了我的脸，这样找出来的回文数不是最近的 /再见。。。
然后是找了一圈儿解答，自己摸索着的写法：
/**
* @param {string} n
* @return {string}
*/
var nearestPalindromic = function(n) {
// 返回反序字符串 eg. 123 =》 321
function findMirror(num){
return num.split('').reverse().join('') ;
}
// 用了一些二进制算法，为了骚， l>>1 就是 l / 2 ,然后 l & 1 是为了区分l是奇数还是偶数
let result = new Map(),
l = n.length,
mid = l >> 1,
left = n.slice(0,mid + (l & 1));
if( l == 1)
return (--n).toString();
// palindrome 比原来长度小一位的最大回文数 和 比原来长度大一位的最大回文数
// 这个主要是找出当所给数字在 100 ， 或者 99 这种容易使数字长度发生变化的时候找出对应的数字
let less='',more='';
for( let i = 0; i < l-1; i++)
less += '9';
for( let i = 0; i <= l; i++ ){
if( i==0 || i== (l))
more += '1'
else
more += '0'
}
result.set( 'key1', less );
result.set( 'key2', more );
/**
* 这是核心思想，和我初始时的想法差不多，不过我们为了取绝对值比较小的区间
* 直接使用左半边的替换右半边的就行了，当长度为奇数时，最中间的一位不能复制两次
* 所以用了 l & 1 ，当为奇数时 结果为 slice（ 0， length - 1）;
* 然后就是我没有想到的东西：
* 当我们截取的左半边也会越位，即 末尾为 0 或 9 时 因为当他们 - 1 或 +1
* 时也会使结果发生变化
* 所以我们 要讨论的就是 使 左半边 +1， +0（代表原来的数），-1 三种情况分别产生的回文数
* 然后比较结果 就ok啦
*/
for( let i = -1 ; i <=1; i++){
if( (+left) + i + '' + findMirror( ((+left) + i).toString().slice(0, left.length == 1 ? 1: left.length - (l & 1) )) == n )
continue;
result.set( i, (+left) + i + '' + findMirror( ((+left) + i ).toString().slice(0, left.length == 1 ? 1:left.length - (l & 1)) ) );
}
let minum , abs = Infinity;
console.log(result);
for( let value of result.values()){
if( Math.abs( value - n ) < abs ){
minum = value;
abs = Math.abs( value - n );
}
if( Math.abs( value - n ) == abs ){
minum = +minum > value ? value : minum;
}
console.log(minum)
}
return minum;
};最后值得一提的是，js坑爹的数字运算，Math.pow( 10 ,17) -1 = 100000...000,根本不会产生999...999所以才是用了for拼接字符串的方式来生成less和more，真的坑，然后 Math.min 会产生一个数值，当这个数值使用toString转化成字符串的时候，结果更令人’欣慰‘ ，还有个坑是当两边为字符串时的比较大小 好像是比较他们的字典顺序的。
