Método de processamento do palíndromo

Solução 1: solução comum

Uma solução é melhor compreendido por primeiro inteiro em uma cadeia, em seguida, a matriz de cadeia é dividida, uma necessidade metade do comprimento ciclo só pode ser determinada nos elementos correspondentes da matriz é igual ao

código de
Java

///简单粗暴，看看就行
class Solution {
    public boolean isPalindrome(int x) {
        String reversedStr = (new StringBuilder(x + "")).reverse().toString();
        return (x + "").equals(reversedStr);
    }
}

Solução 2: solução matemática avançada

Através do arredondamento e da operação restante para obter o número correspondente no número inteiro para comparação.

Por exemplo: o número 1221.

Ao calcular 1221/1000, o primeiro obtido
calculando 10% em 1221, um último bit pode ser obtido
em comparação
e, em seguida, a comparação continua a tirar 22

código de implementação
Java

class Solution {
    public boolean isPalindrome(int x) {
        //边界判断
        if (x < 0) return false;
        int div = 1;
        //
        while (x / div >= 10) div *= 10;
        while (x > 0) {
            int left = x / div;
            int right = x % 10;
            if (left != right) return false;
            x = (x % div) / 10;
            div /= 100;
        }
        return true;
    }
}

Solução três: solução avançada - solução engenhosa

Olhando intuitivamente para o número de palíndromos, é como dobrar os números ao meio para ver se eles correspondem um a um.

Portanto, a operação desta solução é tirar a segunda metade do número e invertê-lo.

Um ponto a ser observado aqui é que, como o número de palíndromos pode ser ímpar ou par, portanto, quando seu comprimento é par, ele deve ser igual quando dobrado ao meio; quando seu comprimento é ímpar, depois de dobrado ao meio, Um comprimento requer a remoção de um dígito (divida por 10 e arredondado).

As práticas específicas são as seguintes:

Cada vez que a operação restante (% 10) é executada, o número mais baixo é retirado: y = x% 10
O número mais baixo é adicionado ao final do número retirado: revertNum = revertNum * 10 + y Para
cada dígito mais baixo obtido, x deve ser selecionado entre Divida por 10 para
determinar se x é menor que revertNum. Quando é menor, significa que o número foi dividido pela metade ou mais da metade.
Finalmente, determine a paridade: se for par, revertNum e x são iguais; se for ímpar, o número do meio Apenas no bit mais baixo de revertNum, divida-o por 10 e deve ser igual a x.

Implementação de código

class Solution {
    public boolean isPalindrome(int x) {
        //思考：这里大家可以思考一下，为什么末尾为 0 就可以直接返回 false
        if (x < 0 || (x % 10 == 0 && x != 0)) return false;
        int revertedNumber = 0;
        while (x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }
        return x == revertedNumber || x == revertedNumber / 10;
    }
}