solve aylei#7

Author: aylei

src/lib.rs

@@ -4,3 +4,4 @@ mod n0003_longest_substring;
 mod n0004_median_of_two_sorted_arrays;
 mod n0005_longest_palindromic_substring;
 mod n0006_zigzag_conversion;
+mod n0007_reverse_integer;

src/main.rs

@@ -73,4 +73,7 @@ fn build_desc(content: &str) -> String {
         .replace(""", "\"")
         .replace("\n\n", "\n")
         .replace("\n", "\n * ")
+        .replace("−", "-")
+        .replace("</sup>", "")
+        .replace("<sup>", "^")
 }

src/n0007_reverse_integer.rs

@@ -0,0 +1,70 @@
+/**
+ * [7] Reverse Integer
+ *
+ * Given a 32-bit signed integer, reverse digits of an integer.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: 123
+ * Output: 321
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: -123
+ * Output: -321
+ * 
+ * 
+ * Example 3:
+ * 
+ * 
+ * Input: 120
+ * Output: 21
+ * 
+ * 
+ * Note:<br />
+ * Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [-2^31,  2^31 - 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+impl Solution {
+    pub fn reverse(x: i32) -> i32 {
+        let mut input: i64 = x as i64;
+        let mut result: i64 = 0;
+        let mut digit: i64 = 0;
+        let base: i64 = 2;
+        let upper_bound: i64 = base.pow(31) - 1;
+        let lower_bound: i64 = - base.pow(31);
+        while input != 0 {
+            digit = input % 10;
+            result = result * 10 + digit;
+            input = input / 10;
+        }
+        if result > upper_bound || result < lower_bound {
+            return 0;
+        }
+        result as i32
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_7() {
+        assert_eq!(Solution::reverse(123), 321);
+        assert_eq!(Solution::reverse(-123), -321);
+        assert_eq!(Solution::reverse(0), 0);
+        assert_eq!(Solution::reverse(-123000), -321);
+        let base: i64 = 2;
+        assert_eq!(Solution::reverse((base.pow(31) - 1) as i32), 0);
+        assert_eq!(Solution::reverse((-base.pow(31)) as i32), 0);
+    }
+}