Technology sharing

Likou 7. ENARRATIO duorum algorithmorum pro integris vicissitudine

2024-07-12

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

Dato obolo signato integro x 32-, redde eventum invertendo partem numerorum ipsius x.

Si integer eversus excedit extensionem integer 32-biti signati [−2^31, 2^31, 1], 0 redditur.

Pone ambitum non permittit repositionem 64-blorum integrorum (signati vel non signati).

Exemplum 1:
Input: x = 123
Output: 321

Exemplum II:
Input: x = -123
Output: -321

Exemplum III:
Input: x = 120
Output: 21

Exemplum 4:
Input: x = 0
Output: 0

innuere;

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

Algorithmus I (pro repono LXIV frenum integri): Missa flipping

#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

Relative simplex est condiciones non considerare quod 64-bit integros condi non possunt, ideo singula non ingrediar.

Algorithmus II: Methodus Mathematica

Codicem integrum sic habet:

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

parse
Primus gradus est ut flip figura:

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

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

Cum x sit integer 32-bit, ad evitandam redundantiam, determinare necesse est, an effectus conversorum integer excedat latitudinem 32-biti signati [−2^31, 2^31−1] ante calculandum rev. pro tempore novissimo.

Cum quaestio postulat ut ambitus integros 64-bit reponere non possit, directe esse non potest−2 ^ 31 ≤ rev⋅10+digit ≤2 ^ 31 −1
Nonnulli ergo methodi mathematicae adhibendae sunt, ne valores 32-bit integros excedant, ne in processu calculi appareant. Hic terminus valores dissolui possunt. memini;

min =2 ^31 = -2147483648;
max = 2 ^311 = 2147483647;
  • 1
  • 2

Frangere ;
min = (min/10) * 10 - 8;
max = (max/10) * 10 + 7;

Cum x&gt; 0,
rev * 10 + digit &lt;= (max/10) * 10 + 7
=>
(rev - max/10)* 10 &lt;= 7 - digit;

Cum rev &lt; max/10:
Hoc est, verum esse potest cum digit &lt;= 17. Cum digit &lt;= 9, aequatio semper tenet.

Cum rev = max/10;
digit &lt;= 7;
Si autem x hoc tempore disiungi potest, significat numerum digitorum in x idem esse ac max, et hoc tempore digitum summum digitum ipsius x, et quod x &lt;= 2 ^31 - 1 = 2147483647. summa digiti ipsius x est 2. Id est, digit&lt;=2, ergo aequatio semper tenet.

Cum rev &gt; max/10:
Cum analysis hoc tempore condicio sit x&gt;0, haec condicio non tenet.

Ita simplicior esse potest ad x &lt;= max/10, sic in codice, cum x&gt;max/10, redire 0;


Deinde, res cum x&lt;0 eodem modo resolvi potest.