Add: CN 000_007

Author: zhongdongy

src/problems/p000_0xx/p000_007.rs

@@ -3,8 +3,38 @@
 /// Exchange front and end digits (not bits) one by one, return zero if
 /// overflow
 ///
+/// ### Description
+///
+/// Given a signed 32-bit integer x, return x with its digits reversed.
+/// If reversing x causes the value to go outside the signed 32-bit integer
+/// range [-231, 231 - 1], then return 0.
+///
+/// Assume the environment does not allow you to store 64-bit integers (signed or /// unsigned).
+///
+///  
+///
+/// Example 1:
+///
+/// Input: x = 123
+/// Output: 321
+/// Example 2:
+///
+/// Input: x = -123
+/// Output: -321
+/// Example 3:
+///
+/// Input: x = 120
+/// Output: 21
+///  
+///
+/// Constraints:
+///
+/// -231 <= x <= 231 - 1
+///
+/// Source: https://leetcode.com/problems/reverse-integer/description/
+///
 /// ### Argument
-/// * `x` - 32-bit integer to alter
+/// * `x` - 32-bit signed integer to alter
 ///
 /// ```
 /// use leetcode_rust::problems::p000_0xx::p000_007::reverse_integer;
@@ -20,20 +50,20 @@ pub fn reverse_integer(x: i32) -> i32 {
 /// Reverse an integer (32-bit long) and check for overflow.
 ///
 /// ### Argument
-/// * `x` - 32-bit integer to alter
+/// * `x` - 32-bit signed integer to alter
 fn reverse_s1(x: i32) -> i32 {
     let mut temp_stack: Vec<u8> = vec![];
     // Convert integer to digits.
     for ch in x.to_string().as_bytes() {
-        if *ch as char != '-' {
+        if *ch != 45 {
             temp_stack.push(*ch);
         }
     }
     loop {
         // Remove trailing zeros if present
         match temp_stack.last() {
             Some(last_ch) => {
-                if *last_ch as char == '0' && temp_stack.len() > 1 {
+                if *last_ch == 48 && temp_stack.len() > 1 {
                     temp_stack.pop();
                 } else {
                     break;
@@ -44,17 +74,18 @@ fn reverse_s1(x: i32) -> i32 {
     }
     temp_stack.reverse();
 
-    let mut overflow_at: i32 = 2147483647;
+    // 2147483647 for positive numbers
+    let mut overflow_at_u8: [u8; 10] = [50, 49, 52, 55, 52, 56, 51, 54, 52, 55];
     let mut target: Vec<u8> = vec![];
     // Detect sign of input number and update overflow threshold if needed.
     if x < 0 {
         target.push('-' as u8);
-        overflow_at = 2147483647;
+
+        // 2147483648 for negative numbers (without sign)
+        overflow_at_u8 = [50, 49, 52, 55, 52, 56, 51, 54, 52, 56];
     }
 
     // Check overflow regardless of the sign
-    let overflow_at_str = overflow_at.to_string();
-    let overflow_at_u8 = overflow_at_str.as_bytes();
     if temp_stack.len() >= overflow_at_u8.len() {
         for idx in 0..overflow_at_u8.len() {
             if temp_stack[idx] < overflow_at_u8[idx] {

src/problems_cn.rs

@@ -1,4 +1,5 @@
 pub mod p000_0xx {
     pub mod p000_005;
     pub mod p000_006;
+    pub mod p000_007;
 }

src/problems_cn/p000_0xx/p000_007.rs

@@ -0,0 +1,106 @@
+/// 32 位整型反转的同时检查溢出
+///
+/// ### 题目说明
+/// 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
+///
+/// 如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。
+///
+/// 假设环境不允许存储 64 位整数（有符号或无符号）。
+///
+///
+/// 示例 1：
+///
+/// 输入：x = 123
+/// 输出：321
+/// 示例 2：
+///
+/// 输入：x = -123
+/// 输出：-321
+/// 示例 3：
+///
+/// 输入：x = 120
+/// 输出：21
+/// 示例 4：
+///
+/// 输入：x = 0
+/// 输出：0
+///
+///
+/// 提示：
+///
+/// -231 <= x <= 231 - 1
+///
+/// 来源：力扣（LeetCode）
+/// 链接：https://leetcode.cn/problems/reverse-integer
+/// 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+///
+/// ### Argument
+/// * `x` - 32 位有符号整数
+///
+/// ```
+/// use leetcode_rust::problems_cn::p000_0xx::p000_007::reverse_integer;
+/// assert_eq!(reverse_integer(-2147483647), 0);
+/// assert_eq!(reverse_integer(123), 321);
+/// assert_eq!(reverse_integer(120), 21);
+/// assert_eq!(reverse_integer(-123), -321);
+/// ```
+pub fn reverse_integer(x: i32) -> i32 {
+    reverse_s1(x)
+}
+
+/// 32 位整型反转的同时检查溢出
+///
+/// ### Argument
+/// * `x` - 32 位有符号整数
+fn reverse_s1(x: i32) -> i32 {
+    let mut temp_stack: Vec<u8> = vec![];
+    // 将无符号数转换为数字数组
+    for ch in x.to_string().as_bytes() {
+        if *ch != 45 {
+            temp_stack.push(*ch);
+        }
+    }
+    loop {
+        // 去除结尾的数字 0
+        match temp_stack.last() {
+            Some(last_ch) => {
+                if *last_ch == 48 && temp_stack.len() > 1 {
+                    temp_stack.pop();
+                } else {
+                    break;
+                }
+            }
+            None => break,
+        }
+    }
+    temp_stack.reverse();
+
+    // 正数的溢出阈值为 2147483647（包含符号）
+    let mut overflow_at_u8: [u8; 10] = [50, 49, 52, 55, 52, 56, 51, 54, 52, 55];
+    let mut target: Vec<u8> = vec![];
+    // 检测输入值的符号并据此更新判断溢出的阈值
+    if x < 0 {
+        target.push('-' as u8);
+
+        // 负数的溢出阈值为 2147483648（不包含符号）
+        overflow_at_u8 = [50, 49, 52, 55, 52, 56, 51, 54, 52, 56];
+    }
+
+    // 在无符号的状态下检查溢出
+    if temp_stack.len() >= overflow_at_u8.len() {
+        for idx in 0..overflow_at_u8.len() {
+            if temp_stack[idx] < overflow_at_u8[idx] {
+                // 如果某一位数值比溢出值要小，则没有必要检查后续的各位数值
+                break;
+            }
+            if temp_stack[idx] > overflow_at_u8[idx] {
+                // 上一个数值（如果存在）位置的目标值和阈值相同，
+                // 如果当前位的目标值大于阈值则表示溢出
+                return 0;
+            }
+        }
+    }
+    // 结合符号和数字
+    target = [target, temp_stack].concat();
+    String::from_utf8(target).unwrap().parse::<i32>().unwrap()
+}

tests/cases_cn/c000_0xx/c000_007.rs

@@ -0,0 +1,16 @@
+use leetcode_rust::common::Case;
+
+pub fn use_cases() -> Vec<Case<i32, i32>> {
+    let mut cases: Vec<Case<i32, i32>> = vec![];
+    cases.push(Case::new(-2147483648, vec![0]));
+    cases.push(Case::new(2147483647, vec![0]));
+    cases.push(Case::new(0, vec![0]));
+    cases.push(Case::new(123, vec![321]));
+    cases.push(Case::new(-123, vec![-321]));
+    cases.push(Case::new(120, vec![21]));
+    cases.push(Case::new(900800, vec![8009]));
+    cases.push(Case::new(2147457412, vec![0]));
+    cases.push(Case::new(-2147483412, vec![-2143847412]));
+
+    cases
+}

tests/cases_cn/mod.rs

@@ -1,4 +1,5 @@
 pub mod c000_0xx {
     pub mod c000_005;
     pub mod c000_006;
+    pub mod c000_007;
 }

tests/problems_cn/p000_0xx.rs

@@ -1,17 +1,19 @@
 use super::super::cases_cn::c000_0xx::c000_005;
 use super::super::cases_cn::c000_0xx::c000_006;
+use super::super::cases_cn::c000_0xx::c000_007;
 use leetcode_rust::problems_cn::p000_0xx::p000_005;
 use leetcode_rust::problems_cn::p000_0xx::p000_006;
+use leetcode_rust::problems_cn::p000_0xx::p000_007;
 
-/// Test Problem 000_005: 最长回文子串
+/// 题目 000_005: 最长回文子串
 #[test]
 fn p000_005_longest_palindrome() {
     for case in c000_005::use_cases() {
         case.is_valid(p000_005::longest_palindrome((&case.input).to_string()));
     }
 }
 
-/// Test Problem 000_006: Z 字形变换
+/// 题目 000_006: Z 字形变换
 #[test]
 fn p000_006_zigzag_conversion() {
     for case in c000_006::use_cases() {
@@ -22,3 +24,12 @@ fn p000_006_zigzag_conversion() {
         ));
     }
 }
+
+/// 题目 000_007: 整数反转
+#[test]
+fn p000_007_reverse_integer() {
+    for case in c000_007::use_cases() {
+        case.is_valid(p000_007::reverse_integer(case.input));
+    }
+}
+