超过时限在线法官

Question

这就是问题所在:

输入输入的第一行将包含测试用例的数量T(1≤T≤50)。下面的每条T行都包含一个长度不超过80位的正整数N。输出每个测试用例的输出将是包含大于或等于输入数字的最小回文的单行。样本输入

2
42
321

样本输出

44
323

当我向在线裁判提交代码时，我一直超过时间限制（3秒限制）

  class Main {

static String ReadLn (int maxLg) 
    {
        byte lin[] = new byte [maxLg];
        int lg = 0, car = -1;
        String line = "";

        try
        {
            while (lg < maxLg)
            {
                car = System.in.read();
                if ((car < 0) || (car == '\n')) break;
                lin [lg++] += car;
            }
        }
        catch (IOException e)
        {
            return (null);
        }

        if ((car < 0) && (lg == 0)) return (null);  // eof
        return (new String (lin, 0, lg));
    }


    static boolean isPalandriome(String s){
        String newString = "";
        for(int i =s.length()-1;i >= 0; i--){
            newString += s.charAt(i);
        }
        if(newString.equals(s))
            return true;
        else
            return false;
    }
    public static void main(String[] args) {

            BigInteger entredNumber;
            String input;
            input = Main.ReadLn(10);
            int tests = Integer.parseInt(input);
            List<BigInteger> numbers = new ArrayList<BigInteger>();
            for (int i =0;i<tests;i++)
        {
            input = Main.ReadLn(100);
            entredNumber = new BigInteger(input);
                numbers.add(entredNumber);

        }


            for(int i=0;i<tests;i++){
                BigInteger number = numbers.get(i);

                while(!isPalandriome(String.valueOf(number))){
                    number  = number.add(BigInteger.ONE);
                }
                System.out.println(number);

            }

    }
}

我在我的代码中找不到花太多时间的东西。

Answer 1

最后编码希望你发现这有用用了0.10秒

import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        CustomReader cr = new CustomReader(1000000);
        int T = cr.nextInt(), fIndex, bIndex, fStartIndex, bStartIndex;
        StringBuilder output = new StringBuilder();
        byte[] input;
        boolean isAppend1 = false;
        for (int i = 0; i < T; i++) {
            input = cr.nextInput();
            fStartIndex = bStartIndex = cr.getCurrInputLength() / 2;
            isAppend1 = false;
            if (cr.getCurrInputLength() % 2 == 0) {
                bStartIndex--;
            }
            fIndex = fStartIndex;
            bIndex = bStartIndex;
            while (input[bIndex] == input[fIndex]) {
                if (bIndex - 1 < 0) {
                    break;
                } else {
                    bIndex--;
                    fIndex++;
                }
            }
            if (input[bIndex] > input[fIndex]) {
                while (bIndex >= 0) {
                    input[fIndex++] = input[bIndex--];
                }
            } else {
                if (input[bStartIndex] < 57) {
                    input[bStartIndex] = (byte) (input[bStartIndex] + 1);
                } else {
                    bIndex = bStartIndex;
                    while (bIndex >= 0 && input[bIndex] == 57) {
                        input[bIndex] = 48;
                        bIndex--;
                    }
                    if (bIndex >= 0) {
                        input[bIndex] = (byte) (input[bIndex] + 1);
                    } else {
                        input[0] = 49;
                        if (fStartIndex != bStartIndex) {
                            input[fStartIndex] = 48;
                            bStartIndex = fStartIndex;
                        } else {
                            input[fStartIndex + 1] = 48;
                            bStartIndex = fStartIndex = fStartIndex + 1;
                        }
                        isAppend1 = true;
                    }
                }
                while (bStartIndex > -1) {
                    input[fStartIndex++] = input[bStartIndex--];
                }
            }
            for (int j = 0; j < cr.getCurrInputLength(); j++) {
                output.append((char) input[j]);
            }
            if (isAppend1) {
                output.append("1");
            }
            output.append("\n");
        }
        System.out.print(output.toString());
        // genInput();
    }

    private static class CustomReader {
        private byte[] buffer;
        private byte[] currInput = new byte[1000000];
        private int currInputLength;
        private int currIndex;
        private int validBytesInBuffer;

        CustomReader(int buffSize) {
            buffer = new byte[buffSize];
        }

        public int nextInt() throws IOException {
            int value;
            byte b;
            while (true) {
                b = getNextByte();
                if (b > 47 && b < 58) {
                    break;
                }
            }
            value = b - 48;
            while (true) {
                b = getNextByte();
                if (b > 47 && b < 58) {
                    value = (value * 10) + (b - 48);
                } else {
                    break;
                }
            }
            return value;
        }

        public byte[] nextInput() throws IOException {
            byte b;
            this.currInputLength = 0;
            while (true) {
                b = getNextByte();
                if (b > 47 && b < 58) {
                    break;
                }
            }
            currInput[currInputLength++] = b;
            while (true) {
                b = getNextByte();
                if (b > 47 && b < 58) {
                    currInput[currInputLength++] = b;
                } else {
                    break;
                }
            }
            return this.currInput;
        }

        public int getCurrInputLength() {
            return this.currInputLength;
        }

        private byte getNextByte() throws IOException {
            if (currIndex == buffer.length || currIndex == validBytesInBuffer) {
                validBytesInBuffer = System.in.read(buffer);
                currIndex = 0;
            }
            return buffer[currIndex++];
        }
    }

    public static void genInput() {
        for (int i = 0; i < 100; i++) {
            System.out.println((int) (Math.random() * 1000000000));
        }
    }
}