Add: solution to LeetCode #9

Author: zhongdongy

TODO.md

@@ -1,13 +1,13 @@
 //! # Solutions to LeetCode problems
-//! 
-//! Note, the problems are quite similar to LeetCode China edition, but for 
+//!
+//! Note, the problems are quite similar to LeetCode China edition, but for
 //! certain problems, the requirements or orders are distinct.
-//! 
+//!
 
 ////////////////////////////////////////////////////////////////////////////////
 
 /// # Problems #000 - #099
-/// 
+///
 /// Solutions to problems #000 to #099 on LeetCode
 pub mod p000_0xx {
     /// Problem #5 *Longest Parlindrome Substring*
@@ -18,4 +18,6 @@ pub mod p000_0xx {
     pub mod p000_007;
     /// Problem #8 *String to Integer (atoi)*
     pub mod p000_008;
-}
+    /// Problem #9 *Palindrome Number*
+    pub mod p000_009;
+}

src/problems.rs

@@ -0,0 +1,126 @@
+//! # Description
+//!
+//! Given an integer `x`, return `true` if `x` is a
+//! palindrome, and `false` otherwise.
+//!
+//! Example 1:
+//!
+//! ```plain
+//! Input: x = 121
+//! Output: true
+//! Explanation: 121 reads as 121 from left to right and from right to left.
+//! ```
+//!
+//! Example 2:
+//!
+//! ```plain
+//! Input: x = -121
+//! Output: false
+//! Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.
+//! ```
+//!
+//! Example 3:
+//!
+//! ```plain
+//! Input: x = 10
+//! Output: false
+//! Explanation: Reads 01 from right to left. Therefore it is not a palindrome.
+//! ```
+//!  
+//! Constraints:
+//!
+//! $-2^{31} \leqslant x \leqslant 2^{31} - 1$
+//!  
+//! Follow up: Could you solve it without converting the integer to a string?
+//!
+//! Source: <https://leetcode.com/problems/palindrome-number/>
+
+////////////////////////////////////////////////////////////////////////////////
+
+/// Check if a given input is a palindrome number
+///
+/// # Arguments
+/// * `x` - input number
+///
+/// # Examples
+/// ```
+/// use leetcode_rust::problems::p000_0xx::p000_009::is_palindrome;
+///
+/// assert!(is_palindrome(12321) == true);
+/// assert!(is_palindrome(-12321) == false);
+/// ```
+pub fn is_palindrome(number: i32) -> bool {
+    // alg_1(number)
+    alg_2(number)
+}
+
+/// Algorithm 1: check digits using double-sided queue.
+///
+/// # Arguments
+/// * `number` - input number to check
+#[allow(dead_code)]
+fn alg_1(mut number: i32) -> bool {
+    if number < 0 {
+        return false;
+    }
+    let mut temp: Vec<i32> = vec![];
+
+    while number >= 10 {
+        temp.push(number % 10);
+        if number >= 10 {
+            number = number / 10;
+        }
+    }
+    temp.push(number);
+
+    if temp.len() == 2 {
+        return temp[0] == temp[1];
+    }
+
+    let mut idx_start = 0;
+    let mut idx_end = temp.len() - 1;
+
+    loop {
+        if idx_end == idx_start {
+            return true;
+        }
+
+        if idx_end - idx_start == 1 {
+            return temp[idx_end] == temp[idx_start];
+        }
+
+        if temp[idx_end] != temp[idx_start] {
+            return false;
+        }
+        idx_end -= 1;
+        idx_start += 1;
+    }
+}
+
+/// Algorithm 2: check digits fast subtraction.
+///
+/// # Arguments
+/// * `number` - input number to check
+#[allow(dead_code)]
+fn alg_2(mut number: i32) -> bool {
+    if number < 0 {
+        return false;
+    }
+
+    // One digit shorter than actual length.
+    let mut digits = (number as f32).log10().floor() as usize;
+    if digits == 0 {
+        return true;
+    }
+
+    loop {
+        number = (number - (number % 10) * 10i32.pow(digits as u32)) / 10;
+        if number < 0 || digits <= 1 {
+            break;
+        }
+
+        digits -= 2;
+    }
+
+    number == 0
+}

src/problems/p000_0xx/p000_009.rs

@@ -0,0 +1,25 @@
+use leetcode_rust::{
+    common::{Case, CaseGroup},
+    new_case,
+};
+
+pub fn use_cases() -> Vec<Case<i32, bool, i32>> {
+    let mut case_group: CaseGroup<i32, bool, i32> = CaseGroup::new();
+
+    // #1
+    new_case!(case_group.create, 123, false);
+    new_case!(case_group.create, 10, false);
+    new_case!(case_group.create, 1230, false);
+    new_case!(case_group.create, 123032, false);
+    new_case!(case_group.create, 123321, true);
+    // #6
+    new_case!(case_group.create, -123321, false);
+    new_case!(case_group.create, 1000030001, false);
+    new_case!(case_group.create, 1, true);
+    new_case!(case_group.create, 0, true);
+    new_case!(case_group.create, 121, true);
+    // #11
+    new_case!(case_group.create, 213, false);
+
+    case_group.all()
+}

tests/cases/c000_0xx/c000_009.rs

@@ -3,4 +3,5 @@ pub mod c000_0xx {
     pub mod c000_006;
     pub mod c000_007;
     pub mod c000_008;
+    pub mod c000_009;
 }

tests/cases/mod.rs

@@ -2,10 +2,12 @@ use crate::cases::c000_0xx::c000_005;
 use crate::cases::c000_0xx::c000_006;
 use crate::cases::c000_0xx::c000_007;
 use crate::cases::c000_0xx::c000_008;
+use crate::cases::c000_0xx::c000_009;
 use leetcode_rust::problems::p000_0xx::p000_005;
 use leetcode_rust::problems::p000_0xx::p000_006;
 use leetcode_rust::problems::p000_0xx::p000_007;
 use leetcode_rust::problems::p000_0xx::p000_008;
+use leetcode_rust::problems::p000_0xx::p000_009;
 
 /// Test Problem 000_005: Longest Palindrome Substring
 #[test]
@@ -42,3 +44,11 @@ fn p000_008_convert_string_to_integer() {
         case.is_valid(p000_008::my_atoi((&case.input).to_string()));
     }
 }
+
+/// Test Problem 000_009: Palindrome Number
+#[test]
+fn p000_009_is_palindrome_number() {
+    for case in c000_009::use_cases() {
+        case.is_valid(p000_009::is_palindrome(case.input));
+    }
+}