Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Étant donné un entier signé de 32 bits x, renvoie le résultat de l'inversion de la partie numérique de x.

Si l'entier inversé dépasse la plage d'un entier signé de 32 bits [−2 ^31, 2 ^31 − 1], 0 est renvoyé.

Supposons que l'environnement ne permet pas le stockage d'entiers 64 bits (signés ou non signés).

Exemple 1:
Entrée : x = 123
Sortie : 321

Exemple 2 :
Entrée : x = -123
Sortie : -321

Exemple 3 :
Entrée : x = 120
Sortie : 21

Exemple 4 :
Entrée : x = 0
Sortie : 0

indice:

-2 ^31 <= x <= 2 ^31 - 1
1

Algorithme 1 (indépendamment du stockage d'entiers 64 bits) : retournement de chaîne

#include <iostream>
#include <string>
#include <algorithm>
#include <climits>

class Solution {
public:
    int reverse(int x) {
        // 将整数转换为字符串
        std::string str = std::to_string(x);
        
        // 处理负号
        if (x < 0) {
            std::reverse(str.begin() + 1, str.end());
        } else {
            std::reverse(str.begin(), str.end());
        }
        
        // 将反转后的字符串转换回整数
        long rev = std::stoll(str);
        
        // 检查是否超出32位有符号整数范围
        if (rev > INT_MAX || rev < INT_MIN) {
            return 0;
        }
        
        return static_cast<int>(rev);
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

Il est relativement simple de ne pas considérer la situation dans laquelle les entiers de 64 bits ne peuvent pas être stockés, je n'entrerai donc pas dans les détails.

Algorithme 2 : Méthode mathématique

Le code complet est le suivant :

class Solution {
public:
    int reverse(int x) {
        int max = 2147483647;
        int min = -2147483648;
        int rev = 0;
        while(x != 0){
            if(rev > max / 10 || rev < min / 10){
                return 0;
            }
            int digit = x % 10;
            x /= 10;
            rev  = rev * 10 + digit;
            
        }
        return rev;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

analyser
La première étape consiste à retourner la forme :

// 弹出 x 的末尾数字 digit
digit = x % 10
x /= 10

// 将数字 digit 推入 rev 末尾
rev = rev * 10 + digit
1
2
3
4
5
6

Puisque x est un entier de 32 bits, afin d'éviter un débordement, il est nécessaire de déterminer si le résultat inversé dépassera la plage d'un entier signé de 32 bits [−2 ^31, 2 ^31−1] avant de calculer rev. pour la dernière fois.

Puisque la question nécessite que l'environnement ne puisse pas stocker d'entiers de 64 bits, elle ne peut pas être directement−2 ^ 31 ≤ rev⋅10+digit ≤2 ^ 31 −1。
Par conséquent, certaines méthodes mathématiques doivent être adoptées pour éviter que des valeurs supérieures aux entiers de 32 bits n'apparaissent pendant le processus de calcul. Ici, les valeurs limites peuvent être décomposées. souviens-toi:

min = −2 ^31 = -2147483648;
max = 2 ^31−1 = 2147483647;
1
2

Pour le décomposer :
min = (min/10) * 10 - 8;
max = (max/10) * 10 + 7;

Quand x>0,
rev * 10 + chiffre <= (max/10) * 10 + 7
=>
(rev - max/10)*10 <= 7 - chiffre ;

Lorsque rév < max/10 :
Autrement dit, cela peut être vrai lorsque le chiffre <= 17. Puisque le chiffre <= 9, l'équation est toujours vraie.

Lorsque rév = max/10 :
chiffre <= 7;
Si x peut encore être démonté à ce moment, cela signifie que le nombre de chiffres dans x est le même que max, et le chiffre est le chiffre le plus élevé de x et parce que x <= 2 ^31 - 1 = 2147483647, le chiffre le plus élevé. de x est 2. C'est-à-dire chiffre <= 2, donc l'équation est toujours valable.

Lorsque rév > max/10 :
Puisque l’analyse à ce moment est la situation où x>0, cette situation n’est pas vraie.

Cela peut donc être simplifié en x <= max/10, donc dans le code, lorsque x>max/10, vous pouvez renvoyer 0 ;

---

Ensuite, la situation où x<0 peut être analysée de la même manière.