fix: file structure

Author: yafeng-Soong

src/solution/lc228.rs

@@ -1,26 +1,25 @@
-mod lc228 {
-    pub struct Solution;
-    impl Solution {
-        pub fn summary_ranges(nums: Vec<i32>) -> Vec<String> {
-            let mut res = Vec::new();
-            let mut left = 0;
-            let mut right = 0;
-            let n = nums.len();
-            while left < n {
-                while right < n && nums[right] - nums[left] == (right - left) as i32 {
-                    right += 1;
-                }
+use crate::solution::Solution;
 
-                res.push(if right - left == 1 {
-                    nums[left].to_string()
-                } else {
-                    format!("{}->{}", nums[left], nums[right - 1])
-                });
-                left = right;
+impl Solution {
+    pub fn summary_ranges(nums: Vec<i32>) -> Vec<String> {
+        let mut res = Vec::new();
+        let mut left = 0;
+        let mut right = 0;
+        let n = nums.len();
+        while left < n {
+            while right < n && nums[right] - nums[left] == (right - left) as i32 {
+                right += 1;
             }
 
-            res
+            res.push(if right - left == 1 {
+                nums[left].to_string()
+            } else {
+                format!("{}->{}", nums[left], nums[right - 1])
+            });
+            left = right;
         }
+
+        res
     }
 }
 
@@ -46,6 +45,6 @@ fn test() {
         },
     ];
     for test in tests {
-        assert_eq!(lc228::Solution::summary_ranges(test.nums), test.expect);
+        assert_eq!(Solution::summary_ranges(test.nums), test.expect);
     }
 }

src/solution/lc56.rs

@@ -1,34 +1,32 @@
-mod lc56 {
-    use std::cmp::max;
+use crate::solution::Solution;
+use std::cmp::max;
 
-    pub struct Solution;
-    impl Solution {
-        pub fn merge(mut intervals: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
-            let mut res = Vec::new();
-            intervals.sort_by(|a, b| {
-                if a[0] == b[0] {
-                    b[1].cmp(&a[1])
-                } else {
-                    a[0].cmp(&b[0])
-                }
-            });
-
-            let mut left = 0;
-            let mut right = 0;
-            let n = intervals.len();
-            while left < n {
-                let mut upper = intervals[left][1];
-                while right < n && intervals[right][0] <= upper {
-                    upper = max(upper, intervals[right][1]);
-                    right += 1;
-                }
+impl Solution {
+    pub fn merge(mut intervals: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+        let mut res = Vec::new();
+        intervals.sort_by(|a, b| {
+            if a[0] == b[0] {
+                b[1].cmp(&a[1])
+            } else {
+                a[0].cmp(&b[0])
+            }
+        });
 
-                res.push(vec![intervals[left][0], upper]);
-                left = right;
+        let mut left = 0;
+        let mut right = 0;
+        let n = intervals.len();
+        while left < n {
+            let mut upper = intervals[left][1];
+            while right < n && intervals[right][0] <= upper {
+                upper = max(upper, intervals[right][1]);
+                right += 1;
             }
 
-            res
+            res.push(vec![intervals[left][0], upper]);
+            left = right;
         }
+
+        res
     }
 }
 
@@ -69,6 +67,6 @@ fn test() {
     ];
 
     for test in tests {
-        assert_eq!(lc56::Solution::merge(test.intervals), test.expect);
+        assert_eq!(Solution::merge(test.intervals), test.expect);
     }
 }

src/solution/lc70.rs

@@ -1,27 +1,26 @@
-mod lc70 {
-    pub struct Solution;
-    impl Solution {
-        pub fn climb_stairs(n: i32) -> i32 {
-            if n < 4 {
-                return n;
-            }
+use crate::solution::Solution;
 
-            let mut sum = vec![0; n as usize + 1];
-            sum[1] = 1;
-            sum[2] = 2;
-            for i in 3..n + 1 {
-                let idx = i as usize;
-                sum[idx] = sum[idx - 1] + sum[idx - 2];
-            }
+impl Solution {
+    pub fn climb_stairs(n: i32) -> i32 {
+        if n < 4 {
+            return n;
+        }
 
-            println!("{:?}", sum);
-            sum[n as usize]
+        let mut sum = vec![0; n as usize + 1];
+        sum[1] = 1;
+        sum[2] = 2;
+        for i in 3..n + 1 {
+            let idx = i as usize;
+            sum[idx] = sum[idx - 1] + sum[idx - 2];
         }
+
+        println!("{:?}", sum);
+        sum[n as usize]
     }
 }
 
 #[test]
 fn test() {
-    assert_eq!(lc70::Solution::climb_stairs(2), 2);
-    assert_eq!(lc70::Solution::climb_stairs(4), 5);
+    assert_eq!(Solution::climb_stairs(2), 2);
+    assert_eq!(Solution::climb_stairs(4), 5);
 }

src/solution/lc74.rs

@@ -1,30 +1,30 @@
-mod lc74 {
-    pub struct Solution;
-    impl Solution {
-        pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
-            let m = matrix.len() as i32;
-            let n = matrix[0].len() as i32;
-            let mut x = 0_i32;
-            let mut y = n as i32 - 1;
-            while x < m && y >= 0 {
-                if matrix[x as usize][y as usize] == target {
-                    return true;
-                }
+#![allow(dead_code)]
 
-                if matrix[x as usize][y as usize] < target {
-                    x += 1;
-                } else {
-                    y -= 1;
-                }
+pub struct Solution {}
+impl Solution {
+    pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
+        let m = matrix.len() as i32;
+        let n = matrix[0].len() as i32;
+        let mut x = 0_i32;
+        let mut y = n as i32 - 1;
+        while x < m && y >= 0 {
+            if matrix[x as usize][y as usize] == target {
+                return true;
             }
 
-            false
+            if matrix[x as usize][y as usize] < target {
+                x += 1;
+            } else {
+                y -= 1;
+            }
         }
+
+        false
     }
 }
 
 #[test]
 fn test() {
     let matrix = vec![vec![1, 3, 5, 7], vec![10, 11, 16, 20], vec![23, 30, 34, 60]];
-    assert_eq!(lc74::Solution::search_matrix(matrix, 3), true);
+    assert_eq!(Solution::search_matrix(matrix, 3), true);
 }