找出最接近的对称数字

找出几个候选答案然后比较差值（最多为4个）

长度为1，#长度为1，直接减一返回
开头为1，9~~9为一个候选答案 例：100001，答案为99999
开头为9，10~~01为一个候选答案 例：99999，答案为100001
如果本身对称，则把最中间的一个（或两个）位数减（如果0则加）一
例：123321，答案为122221
例：120021，答案为121121
如果不对称：
-把前半部分逆序替换掉后半部分 例：1223，答案为1221

while True:
    try:
        string = input()
        length = len(string)

        if length == 1:                         # 长度为1，直接减一
            print(str(int(string) - 1))
        else:
            candidate = []                      # 候选字答案
            if string[0] == '1':                # 开头为1，9**9可能为候选字
                candidate.append('9' * (length - 1))
            elif string[0] == '9':              # 开头为9，10**01可能为候选字
                candidate.append('1' + '0' * (length - 1) + '1')
            if string == string[::-1]:          # 如果本身对称，则把最中间的一个（或两个）位数减（如果0则加）一
                temp = list(string)
                if temp[length // 2] == '0':
                    temp[length // 2] = temp[(length - 1) // 2] = '1'
                else:
                    char = str(int(temp[length // 2]) - 1)
                    temp[length // 2] = temp[(length - 1) // 2] = char
                candidate.append(''.join(temp))
            else:                               # 不对称，把前半部分逆序替换掉后半部分
                temp = list(string[:(length // 2)] + string[:((length + 1) // 2)][::-1])
                candidate.append(''.join(temp))
                if temp[length // 2] == '0':    # 最中间为0，只能加一
                    temp[length // 2] = temp[(length - 1) // 2] = '1'
                    candidate.append(''.join(temp))
                elif temp[length // 2] == '9':  # 最中间为9，只能减一
                    temp[length // 2] = temp[(length - 1) // 2] = '8'
                    candidate.append(''.join(temp))
                else:                           # 加一和减一都加入候选答案
                    char = int(temp[length // 2])
                    temp[length // 2] = temp[(length - 1) // 2] = str(char + 1)
                    candidate.append(''.join(temp))
                    temp[length // 2] = temp[(length - 1) // 2] = str(char - 1)
                    candidate.append(''.join(temp))
            candidate = sorted(list(map(int, candidate)))
            string = int(string)
            diff = string                       # 保存差值
            for num in candidate:               # 在候选答案里选择差值最小的最小数（前面已排序）
                if abs(string - num) < diff:
                    result = num
                    diff = abs(string - num)
            print(result)


    except Exception:
        break

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String s = bufferedReader.readLine();
        String leftStr = s.substring(0, (s.length() + 1) / 2);
        long left = Long.parseLong(leftStr);
        long smaller = getLeftSmallerSymmetry(s.length(), left, leftStr.length());
        long bigger = getLeftBiggerSymmetry(s.length(), left, leftStr.length());
        long sValue = Long.parseLong(s);
        long sToSmaller=sValue - smaller;
        long sToBigger=bigger - sValue;
        long closestValue;
        long minDistance;
        if (sToSmaller <= sToBigger) {
            closestValue = smaller;
            minDistance=sToSmaller;
        } else {
            closestValue = bigger;
            minDistance=sToBigger;
        }
        if (!isSymmetry(s)) {
            long equal = getLeftEqualSymmetry(s.length(), left, leftStr.length());
            long sToEqual = Math.abs(equal - sValue);
            if (sToEqual < minDistance) {
                closestValue = equal;
            } else if (sToEqual == minDistance) {
                if (equal < sValue) {
                    closestValue = equal;
                }
            }
        }
        System.out.println(closestValue);
    }

    //判断s是否对称
    static boolean isSymmetry(String s) {
        int mid = s.length() / 2;
        for (int i = 0, j = s.length() - 1; i < mid; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }

    //将左半部分反转到右半部分
    static void reverseLeftToRight(char[] cs) {
        int mid = cs.length / 2;
        for (int i = 0, j = cs.length - 1; i < mid; i++, j--) {
            cs[j] = cs[i];
        }
    }

    //获取左半部分减去1的对称值
    static long getLeftSmallerSymmetry(int originLen, long leftValue, int leftLen) {
        long leftSmaller = leftValue - 1;
        String leftSmallerStr = String.format("%0" + leftLen + "d", leftSmaller);
        char[] temp;
        temp = Arrays.copyOf(leftSmallerStr.toCharArray(), originLen);
        reverseLeftToRight(temp);
        if (temp[0] == '0' && temp.length > 1) {
            temp = String.valueOf(temp, 1, temp.length - 1).toCharArray();
            temp[temp.length - 1] = '9';
        }
        return Long.parseLong(String.valueOf(temp));
    }

    //获取左半部分相等的对称值
    static long getLeftEqualSymmetry(int originLen, long leftValue, int leftLen) {
        String leftEqualStr = String.valueOf(leftValue);
        char[] temp = Arrays.copyOf(leftEqualStr.toCharArray(), originLen);
        reverseLeftToRight(temp);
        return Long.parseLong(String.valueOf(temp));
    }

    //获取左半部分加上1的对称值
    static long getLeftBiggerSymmetry(int originLen, long leftValue, int leftLen) {
        long leftBigger = leftValue + 1;
        String leftBiggerStr = String.valueOf(leftBigger);
        char[] temp;
        if (leftBiggerStr.length() > leftLen) {
            temp = Arrays.copyOf(leftBiggerStr.toCharArray(), originLen + 1);
        } else {
            temp = Arrays.copyOf(leftBiggerStr.toCharArray(), originLen);
        }
        reverseLeftToRight(temp);
        return Long.parseLong(String.valueOf(temp));
    }
}

import java.util.Scanner;
/*
* 本体要找的是和输入值最近的对称数
* 一般思路 输入值的字符串 截一半 再对称 例如输入 1234 截前一半 12 再对称 1221  那么答案是1221
* 思路基本是对的 但是有特殊情况 例如 1291，答案为1331，而非1221
    例：1800，答案为1771，而非1881
  总的来说对于输入值 abcdef (这里一个字母代表一个数) 最靠近的数字 abccba , ab(c+1)(c+1)ba ,ab(c-1)(c-1)ba 三种情况都有可能
  * 那么就三种全算 ,分别再看一下三者与abcdef差值 ,差值取绝对值最小的那个就是最近
*
* */
public class mianshi {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String mystring=scanner.nextLine();

        long[] dealwithequal = dealwithequal(mystring);
        long[] dealwithsmaller = dealwithsmaller(mystring);
        long[] dealwithbigger = dealwithbigger(mystring);

        //下面主要是比较三者绝对值之差 从而选出要用的值
        //1.两次 使用三元运算符找出绝对值最小的那个
        long tempvalue = dealwithequal[1] > dealwithsmaller[1] ? dealwithequal[1] : dealwithsmaller[1];
        tempvalue = tempvalue > dealwithbigger[1] ? tempvalue : dealwithbigger[1];
        //2.找到最小绝对值之后 回头是依次判断是哪个数组来的,找到了就把题目要的数据传给result
        long result = 0L;
        if (tempvalue == dealwithequal[1]) {
            result = dealwithequal[0];
        }
        if (tempvalue == dealwithsmaller[1]) {
            result = dealwithsmaller[0];
        }
        if (tempvalue == dealwithbigger[1]) {
            result = dealwithbigger[0];
        }
        System.out.println("最接近的值是" + result);

    }


    public static long[] dealwithequal(String mystring) {
        /*总体思路 1.字符串以前一半为蓝本 倒序复制 覆盖后半段 三个方法的差别主要就在字符串前一半的最后一位究竟是+1 -1 还是不变
                  2.新生成的字符串变格式为long 计算与原字符串数字的绝对值
                  3.将long格式的数据和绝对值一起放进一个数组返回,给主程序比较
        * */
        //1.1 字符串拆成 字符串数组
        String[] split = mystring.split("");
        //1.2 字符串以前一半为蓝本 倒序复制 覆盖后半段 字符串前一半的最后一位不变 即 abccba型
        //需要注意 可能有些人会以字符串长度的分奇偶两种情况 这个想法可以 ,但 (数组长度 + 1) / 2 直接就可以解决
        for (int i = 0; i < (split.length + 1) / 2; i++) {
            split[(split.length - 1 - i)] = split[i];
        }
        //1.3 新数组生成了 想转为字符串 我这里用stringBuffer
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < split.length; i++) {
            stringBuffer.append(split[i]);
        }
        String s = stringBuffer.toString();
        //1.4 新字符串转long型 之后计算与输入数据的差值的绝对值
        long i1 = Long.parseLong(s);
        //1.5 注意输入的是字符串 这里用Long.parseLong转换一下才能计算差值的绝对值  之后就放进一个新数组返回
        long[] arr = {i1, Math.abs(i1 - Long.parseLong(mystring))};
        return arr;
    }

    public static long[] dealwithsmaller(String mystring) {
        String[] split = mystring.split("");
        //本情形就是字符串前一半的最后一位减1 即ab(c-1)(c-1)ba 型
        //由于是数组中储存的是字符串  所以需要转为Integer 才能计算 算完了转回字符串类型 覆盖原值
        Integer integer = Integer.valueOf(split[(split.length + 1) / 2 - 1]);
        integer = integer - 1;
        split[(split.length + 1) / 2 - 1] = integer.toString();
        //下面都和第一种情况一样
        for (int i = 0; i < (split.length + 1) / 2; i++) {
            split[(split.length - 1 - i)] = split[i];
        }
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < split.length; i++) {
            stringBuffer.append(split[i]);
        }
        String s = stringBuffer.toString();

        long i1 = Long.parseLong(s);

        long[] arr = {i1, Math.abs(i1 - Long.parseLong(mystring))};
        return arr;
    }

    public static long[] dealwithbigger(String mystring) {
        String[] split = mystring.split("");
        //本情形就是字符串前一半的最后一位加1 即 ab(c+1)(c+1)ba 型
        Integer integer = Integer.valueOf(split[(split.length + 1) / 2 - 1]);
        integer = integer + 1;
        split[(split.length + 1) / 2 - 1] = integer.toString();
        //下面同上
        for (int i = 0; i < (split.length + 1) / 2; i++) {
            split[(split.length - 1 - i)] = split[i];
        }
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < split.length; i++) {
            stringBuffer.append(split[i]);
        }
        String s = stringBuffer.toString();

        long i1 = Long.parseLong(s);

        long[] arr = {i1, Math.abs(i1 - Long.parseLong(mystring))};
        return arr;
    }

}

#include<iostream>
#include<string>
using namespace std;
int main()
{
    bool flag=1;//输入数是否对称
    bool fn=1;//输入数是否每位都为9
    bool fj=0;//判断输入是否形如100...01
    string str;
    string s="";
    cin>>str;
    int i,a,b,len=str.length();
    for(i=0;i<=(len-1)/2;i++){
        if(flag&&str[i]!=str[len-i-1])
            flag=0;
        if(fn&&str[i]!='9')
            fn=0;
        s+=str[i];
    }
    if(!flag){
        cout<<s;
        for(i-=2;i>=0;cout<<str[i--]);//不对称，直接前半部分反序输出
    }else{
        a=stoi(s);//s长度最长为9，在int范围内
        for(i=10;i<=a;i==a ? fj=1:fj=0,i*=10);
        if(fj)
            cout<<stoi(str)-2<<endl;
        else{
            if(len&1){
                b=a%100;
                b==99 ? a++:(b%10==0&&b!=0 ? a++:a--);
                cout<<a;
                a/=10;
            }else{
                b=a%10;
                b==9 ? a++:a--;
                cout<<a;
            }
            if(fn)    a/=10;
            while(a){
                cout<<a%10;
                a/=10;
            }
        }
    }
}

full pass 
public static String findLoopNearByX(String sample){
        try{
            long value = Long.parseLong(sample);
            char[] bits = sample.toCharArray();
            int len = bits.length;
            if(len>1){
                long subTenTime = tenTime(len/2);
                long header = value/subTenTime * subTenTime; //10000--100
                long subHeader = header - subTenTime;
                long addHeader = header + subTenTime;
                long[] headers = new long[3];
                headers[0] = getBackHeader(len,subHeader);
                headers[1] = getBackHeader(len,header);
                headers[2] = getBackHeader(len,addHeader);
                return getResult(value,headers);
            }else{
                return Long.toString(value-1);
            }

        }catch(NumberFormatException e){
            return "Error";
        }
    }
    private static long getBackHeader(int sampleLen,long header){
        char[] bitsX = Long.toString(header).toCharArray();
        int bitLen = bitsX.length;
        if(bitLen>1){
            for(int i=0;i<bitLen;i++){
                bitsX[bitLen-1-i] = bitsX[i];
            }
        }
        if(sampleLen%2==0 && (sampleLen-bitLen==1)){
            bitsX[(bitLen/2)] = '9';
        }
        return Long.parseLong(new String(bitsX));
    }

    private static long tenTime(int time){
        long x = 1;
        for(int i=0;i<time;i++){
            x *= 10;
        }
        return x;
    }

    private static String getResult(long num,long[] choice){
        long diff = Math.abs(choice[0]-num);
        int index = 0;
        for(int i=0;i<choice.length;i++){
            //System.out.println(choice[i]);
            long gap = Math.abs(choice[i]-num);
            //System.out.println(gap);
            if(gap<diff){
                index = i;
                diff = gap;
                //System.out.println(index);
            }
        }
        if(choice[index]==num){
            index = 0;
        }
        return Long.toString(choice[index]);
    }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Collections;
public class Main {
    /**
     * 思路
     * 分为数字对称与非对称
     * 
     * 对称要注意取的值要与自己的差值最小
     * 
     * 非对称的数字直接去取对半反转拼接
     *
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        long l = Long.parseLong(s);
        StringBuffer sb1 = new StringBuffer();
        StringBuffer sb2 = new StringBuffer();
        StringBuffer rel = new StringBuffer();
        // 取数字中位数
        int halfLength = s.length() / 2;
        // 前半段放入到sb1中2
        for (int i = 0; i < halfLength; i++) {
            sb1.append(s.charAt(i));
        }
        sb2.append(sb1);
        // 如果是奇数个数字
        if (s.length() % 2 == 1) {
            sb2.append(s.charAt(halfLength));
            rel.append(sb2);
            rel.append(sb1.reverse());
        } else {
            // 偶数个数字，分情况讨论，分别求出上限、下限、中限    1921
            long smallerLeft = (Long.parseLong(sb2.toString()) - 1);  //18
            long biggerLeft = Long.parseLong(sb2.toString()) + 1;  //20
            long midLeft = Long.parseLong(sb2.toString());  //19
            // 1881
            StringBuffer smaller = new StringBuffer();
            smaller.append(smallerLeft);
            StringBuffer s1 = new StringBuffer(smaller);
            smaller.append(s1.reverse());
            long l1 = l - Long.parseLong(smaller.toString());
            //20021
            StringBuffer bigger = new StringBuffer();
            bigger.append(biggerLeft);
            StringBuffer s2 = new StringBuffer(bigger);
            bigger.append(s2.reverse());
            long l2 = Long.parseLong(bigger.toString()) - l;
            //1991
            StringBuffer mid = new StringBuffer();
            mid.append(midLeft);
            StringBuffer s3 = new StringBuffer(mid);
            mid.append(s3.reverse());
            long ll2 = l - Long.parseLong(mid.toString());
            long ll1 = Long.parseLong(mid.toString()) - l;
            long l3 = ll1 >= 0 ? ll1 : ll2;
            // 比较差距最小值
            Long[] arr = {l1, l2, l3};
            Long min = Collections.min(Arrays.asList(arr));
            if (l1 == min) {
                rel.append(smaller);
            } else if (l2 == min) {
                rel.append(bigger);
            } else {
                rel.append(mid);
            }
        }
        System.out.println(rel.toString());
    }
}

兴业银行笔试时碰到这题，现在写出来了

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        char[] chars = str.toCharArray();
        int len = str.length();
        for (int i = 0; i < len / 2; i++) {
            chars[len - 1 - i] = chars[i];
        }
        System.out.println(String.valueOf(chars));
    }
}

#include <bits/stdc++.h>

using namespace std;

int main()
{     string s;     while(cin>>s){         int n = s.length();         for(int i=0,j=n-1;i<j;i++,j--){             s[j] = s[i];         }         cout<<s<<endl;     }     return 0;
}

n = input()
l1,l2 = [],[]
for i in n:
    l1.append(i)
for i in range(len(n)-1,-1,-1):
    l2.append(n[i])
if l1==l2:
    print(n)
else:
    o = ''
    for i in range(0,len(n)//2):
        o = o+n[i]
    if len(n)%2==1:
        o = o + n[len(n)//2]
    for i in range(len(n)//2-1,-1,-1):
        o = o+n[i]
    print(o)

import java.util.*;

// 长度-1：99999
// 长度+1：100001
// 前半  对称： 1800  → (18)81 、18000 → (180)81
// 前半-1对称： 18000 → (180+1)00 → (181)81
// 前半+1对称： 1800  → (18-1)00  → (17)71
// 5种取最小 🔥
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.next();
        int n = s.length();
        // 9999
        StringBuilder sb1 = new StringBuilder();
        for (int i = 0; i < n - 1; i++) {
            sb1.append(9);
        }

        // 10001
        StringBuilder sb2 = new StringBuilder();
        sb2.append(1);
        for (int i = 0; i < n - 1; i++) {
            sb2.append(0);
        }
        sb2.append(1);

        // 前半 ±0/1 对称
        String preStr = s.substring(0, (n + 1) / 2);
        int preNum = Integer.parseInt(preStr);

        StringBuilder sb3 = new StringBuilder(); // 0
        sb3.append(preStr).append(rev(preStr).substring(n & 1)); // n&1：奇偶长度分

        String pre = String.valueOf(preNum - 1); // -1
        StringBuilder sb4 = new StringBuilder();
        sb4.append(pre).append(rev(pre).substring(n & 1));

        pre = String.valueOf(preNum + 1); // +1
        StringBuilder sb5 = new StringBuilder();
        sb5.append(pre).append(rev(pre).substring(n & 1));
        
        // 处理结果：取和原数绝对差最小的
        Long a = Long.parseLong(sb1.toString());
        Long b = Long.parseLong(sb2.toString());
        Long c = Long.parseLong(sb3.toString());
        Long d = Long.parseLong(sb4.toString());
        Long e = Long.parseLong(sb5.toString());
        Long[] res = new Long[] {a, b, c, d, e};
        long origin = Long.parseLong(s);
        Arrays.sort(res, (x, y)-> {
            Long dist1 = Math.abs(x - origin);
            Long dist2 = Math.abs(y - origin);
            if (dist1 != dist2) return  dist1.compareTo(dist2);
            return x.compareTo(y);
        });
        System.out.println(res[0]);
    }

    static String rev(String s) { // 反转字符串
        return new StringBuilder(s).reverse().toString();
    }
}

#include <bits/stdc++.h>
using namespace std;

int main() {
    string s;
    cin >> s;
    for (int i = 0; i < s.length() / 2; i++) {
        int b = s.length() - 1 - i;
        s[b] = s[i];
    }
    cout << s;
}
// 64 位输出请用 printf("%lld")

参考题解java版本写出的 c++版本

#include<bits/stdc++.h>
using namespace std;
typedef long long  LL;

// 判断是否是 1000 这种模式的 字符串
bool isValid(string s)
{
    bool flag = true;
    if (s[0] != '1') flag = false;

    if (s[0] == '1')
    {
        for (unsigned int i = 1; i < s.size(); i++)
        {
            if (s[i] != '0')
            {
                flag = false;
                break;
            }
        }
    }
    return flag;
}

int main()
{
    // 33802918 6 96668661
    // 33802918 6 81920833
    // 只需要把前半段的复制到后半段
    string s;
    cin >> s;
    if (s.size() <= 1) 
    {
        cout << s;
        return 0;
    }

    // 是1000 类型的
    if (isValid(s))
    {
        string r = "";
        while (r.size() < s.size()-1)
            r += "9";
        cout << r;
        return 0;
    }

    // 不是1000类型的
    string str = s; 
    reverse(s.begin(), s.end());
    int n = s.size();
    // cout << n << endl;

    string substr = s.substr(n/2+1);
    // cout << substr << endl;
    str.replace(n/2+1, n, substr);

    cout << str << endl;
    return 0;
}

	找出几个候选答案然后比较差值（最多为4个） 



	长度为1，#长度为1，直接减一返回 开头为1，9~~9为一个候选答案        例：100001，答案为99999 开头为9，10~~01为一个候选答案       例：99999，答案为100001 如果本身对称，则把最中间的一个（或两个）位数减（如果0则加）一  例：123321，答案为122221  例：120021，答案为121121 如果不对称：  -把前半部分逆序替换掉后半部分       例：1223，答案为1221 



	 -把最中间的一个（或两个）位数加一   例：1291，答案为1331，而非1221 



	 -把最中间的一个（或两个）位数减一   例：1800，答案为1771，而非1881 



	 



	



	额外的，在这里测试用例比较少，有些情况并未测试出来。如果本身不对称直接把前半部分逆序替换掉后半部分也是能通过的。但不严谨。希望添加测试用例。 



	 例：9， 答案为8（没有单个数的测试用例） 



	 例：1291，答案为1331，而非1221  



	 例：1800，答案为1771，而非1881

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String mystring=scanner.nextLine();

        if(mystring.length()==1){
            System.out.println(Integer.parseInt(mystring)-1);
            return;
        }

        long[] dealwithequal = dealwithequal(mystring);
        long[] dealwithsmaller = dealwithsmaller(mystring);
        long[] dealwithbigger = dealwithbigger(mystring);

        //下面主要是比较三者绝对值之差 从而选出要用的值
        //1.两次 使用三元运算符找出绝对值最小的那个
        long tempvalue = dealwithequal[1] < dealwithsmaller[1] ? dealwithequal[1] : dealwithsmaller[1];
        tempvalue = tempvalue < dealwithbigger[1] ? tempvalue : dealwithbigger[1];
        //2.找到最小绝对值之后 回头是依次判断是哪个数组来的,找到了就把题目要的数据传给result
        long result = 0L;
        if (tempvalue == dealwithequal[1]) {
            result = dealwithequal[0];
        }
        if (tempvalue == dealwithsmaller[1]) {
            result = dealwithsmaller[0];
        }
        if (tempvalue == dealwithbigger[1]) {
            result = dealwithbigger[0];
        }

        if(mystring.startsWith("1")){
            //1开头，需比较N-1个9
            StringBuffer sb=new StringBuffer();
            for(int i=0;i<mystring.length()-1;i++){
                sb.append('9');
            }
            long restemp1=Math.abs(Integer.parseInt(mystring)-Integer.parseInt(sb.toString()));
            result=(tempvalue>=restemp1)?Integer.parseInt(sb.toString()):result;
        }else if(mystring.startsWith("9")){
            //9开头，需比较N+1个10...01
            StringBuffer sb2=new StringBuffer();

            sb2.append('1');
            for(int i=0;i<mystring.length()-1;i++){
                sb2.append('0');
            }
            sb2.append('1');
            long restemp2=Math.abs(Integer.parseInt(mystring)-Integer.parseInt(sb2.toString()));
            result=(tempvalue>=restemp2)?Integer.parseInt(sb2.toString()):result;
        }

        System.out.println(result);

    }


    public static long[] dealwithequal(String mystring) {
        /*总体思路 1.字符串以前一半为蓝本 倒序复制 覆盖后半段 三个方法的差别主要就在字符串前一半的最后一位究竟是+1 -1 还是不变
                  2.新生成的字符串变格式为long 计算与原字符串数字的绝对值
                  3.将long格式的数据和绝对值一起放进一个数组返回,给主程序比较
        * */
        //1.1 字符串拆成 字符串数组
        String[] split = mystring.split("");
        //1.2 字符串以前一半为蓝本 倒序复制 覆盖后半段 字符串前一半的最后一位不变 即 abccba型
        //需要注意 可能有些人会以字符串长度的分奇偶两种情况 这个想法可以 ,但 (数组长度 + 1) / 2 直接就可以解决
        for (int i = 0; i < (split.length + 1) / 2; i++) {
            split[(split.length - 1 - i)] = split[i];
        }
        //1.3 新数组生成了 想转为字符串 我这里用stringBuffer
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < split.length; i++) {
            stringBuffer.append(split[i]);
        }
        String s = stringBuffer.toString();
        //输入字符本身不能为回文串
        if(s.equals(mystring)){
            return new long[]{0, Integer.MAX_VALUE};
        }
        //1.4 新字符串转long型 之后计算与输入数据的差值的绝对值
        long i1 = Long.parseLong(s);
        //1.5 注意输入的是字符串 这里用Long.parseLong转换一下才能计算差值的绝对值  之后就放进一个新数组返回
        long[] arr = {i1, Math.abs(i1 - Long.parseLong(mystring))};
        return arr;
    }

    public static long[] dealwithsmaller(String mystring) {
        String[] split = mystring.split("");
        //本情形就是字符串前一半的最后一位减1 即ab(c-1)(c-1)ba 型
        //由于是数组中储存的是字符串  所以需要转为Integer 才能计算 算完了转回字符串类型 覆盖原值
        Integer integer = Integer.valueOf(split[(split.length + 1) / 2 - 1]);
        //中间值不能为0
        if(integer==0){
            return new long[]{0, Integer.MAX_VALUE};
        }
        integer = integer - 1;
        split[(split.length + 1) / 2 - 1] = integer.toString();
        //下面都和第一种情况一样
        for (int i = 0; i < (split.length + 1) / 2; i++) {
            split[(split.length - 1 - i)] = split[i];
        }
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < split.length; i++) {
            stringBuffer.append(split[i]);
        }
        String s = stringBuffer.toString();

        long i1 = Long.parseLong(s);

        long[] arr = {i1, Math.abs(i1 - Long.parseLong(mystring))};
        return arr;
    }

    public static long[] dealwithbigger(String mystring) {
        String[] split = mystring.split("");
        //本情形就是字符串前一半的最后一位加1 即 ab(c+1)(c+1)ba 型
        Integer integer = Integer.valueOf(split[(split.length + 1) / 2 - 1]);
        //中间值不能为9
        if(integer==9){
            return new long[]{0, Integer.MAX_VALUE};
        }
        integer = integer + 1;
        split[(split.length + 1) / 2 - 1] = integer.toString();
        //下面同上
        for (int i = 0; i < (split.length + 1) / 2; i++) {
            split[(split.length - 1 - i)] = split[i];
        }
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < split.length; i++) {
            stringBuffer.append(split[i]);
        }
        String s = stringBuffer.toString();

        long i1 = Long.parseLong(s);

        long[] arr = {i1, Math.abs(i1 - Long.parseLong(mystring))};
        return arr;
    }

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String num = sc.next();
        int chang = num.length();
        char[] ch =num.toCharArray();
        if(chang==1) System.out.println(Integer.parseInt(num)-1);
        else if(!sw(num)){
            int left = 0;
            int right = num.length()-1;
            while(left<=right){
                ch[right] = ch[left];
                left++;
                right--;
            }
            System.out.println(String.valueOf(ch));
        }
        else{
            int i=-1;
            int j=1;
            int nu = Integer.parseInt(num);
            while(true){
                int nu1 = nu+i;
                int nu2 = nu+j;
                if(sw(String.valueOf(nu1))) {
                    nu=nu1;
                    break;
                }
                if(sw(String.valueOf(nu2))) {
                    nu=nu2;
                    break;
                }
                i--;
                j++;
            }
            System.out.println(String.valueOf(nu));
        }
    }
    static boolean sw(String str){
        int left = 0;
        int right = str.length()-1;
        while(left<=right){
            if(str.charAt(left)!=str.charAt(right)){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

从中间分为左右半子串，对称数即以左子串镜像
if 偶数串：
    生成3个目标数：
    1、左子串直接镜像
    2、左子串加1后镜像，如果加1进位变奇数串，则左串尾数作中间数镜像（中间数去重）
    3、左子串减1后镜像，如果减1退位变奇数串 ，则左串镜像且左串尾数补作中间数
else 奇数串：
    生成3个目标数：
    1、左子串（含中间数）直接镜像，中间数去重  2、左子串加1后镜像（中间数去重），如果加1进位变偶数串，则去掉左串尾数后再镜像
    3、左子串减1后镜像（中间数去重），如果减1退位变奇数串 ，则左串镜像且左串尾数补作中间数
移除自身，按目标差(与原数差的绝对值, 目标数大小）由小到大排序，取第一个即答案


 def solve(s):
    ret = ''
    if s == '0':
        return '1'
    if len(s) == 1:
        return str(int(s)-1)
    if len(s) % 2 == 0:
        left_part = s[:len(s)//2]
        right_part = left_part[::-1]
        left_part_up = str(int(left_part)+1)
        right_part_up = left_part_up[::-1] if len(left_part_up) == len(
            left_part) else left_part_up[::-1][1:]  # 加1后进位，中间数重复只保留一份
        left_part_down = str(int(left_part)-1)
        right_part_down = left_part_down[::-1] if len(left_part_down) == len(
            left_part) else left_part_down[-1] + left_part_down[::-1]  # 减1后退位，少算个中间数，以左边个位为中间数
    else:
        left_part = s[:len(s)//2 + 1]
        right_part = left_part[::-1][1:]
        left_part_up = str(int(left_part)+1)
        if len(left_part_up) == len(left_part):
            right_part_up = left_part_up[::-1][1:]
        else:
            # 加1后进位，奇变偶，中间数重复2次，左去尾，右去头
            left_part_up = left_part_up[:len(left_part_up)-1]
            right_part_up = left_part_up[::-1]
        left_part_down = str(int(left_part)-1)
        right_part_down = left_part_down[::-1][1:] if len(left_part_down) == len(
            left_part) else left_part_down[::-1]  # 减1后退位，奇变偶，不需要中间数，左右对称即可
    nearst = [left_part + right_part, left_part_up +
              right_part_up, left_part_down + right_part_down]
    nearst.sort()
    nearst.sort(key=lambda x: (abs(int(x)-int(s)), x))
    if s in nearst:
        nearst.remove(s)
    ret = nearst[0]
    return ret
if __name__ == "__main__":
    s = input()
    result = solve(s)
    print(result)