add vec_vec macro

Author: pymongo

src/backtracking/all_paths_from_source_to_target.rs

@@ -49,13 +49,12 @@ fn dfs(
 
 #[test]
 fn test_all_paths_source_target() {
-    use crate::parse_2d_array;
     // 入参graph的数据格式是邻接表，graph[0]表示节点0的连向节点1和节点2
-    const TEST_CASES: [(&str, &str); 1] = [("[[1,2],[3],[3],[]]", "[[0,1,3],[0,2,3]]")];
-    for &(input, output) in TEST_CASES.iter() {
-        assert_eq!(
-            all_paths_source_target(parse_2d_array(input)),
-            parse_2d_array(output)
-        );
+    let test_cases = vec![(
+        vec_vec![[1, 2], [3], [3], []],
+        vec_vec![[0, 1, 3], [0, 2, 3]],
+    )];
+    for (input, output) in test_cases.into_iter() {
+        assert_eq!(all_paths_source_target(input), output);
     }
 }

src/easy/grid_or_matrix/island_perimeter.rs

@@ -29,14 +29,17 @@ fn island_perimeter(grid: Vec<Vec<i32>>) -> i32 {
 
 #[test]
 fn test_island_perimeter() {
-    const TEST_CASES: [(&str, i32); 1] = [(
-        "[[0, 1, 0, 0],
-          [1, 1, 1, 0],
-          [0, 1, 0, 0],
-          [1, 1, 0, 0]]",
+    /*
+    "[[0, 1, 0, 0],
+      [1, 1, 1, 0],
+      [0, 1, 0, 0],
+      [1, 1, 0, 0]]",
+    */
+    let test_cases = vec![(
+        vec_vec![[0, 1, 0, 0], [1, 1, 1, 0], [0, 1, 0, 0], [1, 1, 0, 0]],
         16,
     )];
-    for &(grid, perimeter) in TEST_CASES.iter() {
-        assert_eq!(island_perimeter(crate::parse_2d_array(grid)), perimeter);
+    for (grid, perimeter) in test_cases.into_iter() {
+        assert_eq!(island_perimeter(grid), perimeter);
     }
 }

src/easy/grid_or_matrix/rotate_matrix.rs

@@ -38,18 +38,12 @@ fn rotate(m: &mut Vec<Vec<i32>>) {
 
 #[test]
 fn test_rotate() {
-    use crate::parse_2d_array;
-    const TEST_CASES: [(&str, &str); 1] = [(
-        "[[1,2,3],
-           [4,5,6],
-           [7,8,9]]",
-        "[[7,4,1],
-           [8,5,2],
-           [9,6,3]]",
+    let test_cases = vec![(
+        vec_vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+        vec_vec![[7, 4, 1], [8, 5, 2], [9, 6, 3]],
     )];
-    for &(input, output) in TEST_CASES.iter() {
-        let mut matrix = parse_2d_array(input);
-        rotate(&mut matrix);
-        assert_eq!(matrix, parse_2d_array(output));
+    for (mut input, output) in test_cases.into_iter() {
+        rotate(&mut input);
+        assert_eq!(input, output);
     }
 }

src/easy/grid_or_matrix/spiral_matrix.rs

@@ -53,22 +53,18 @@ fn spiral_matrix_1(a: Vec<Vec<i32>>) -> Vec<i32> {
 
 #[test]
 fn test_spiral_matrix_1() {
-    const TEST_CASES: [(&str, &[i32]); 2] = [
+    let test_cases = vec![
         (
-            "[[1,2,3],
-           [4,5,6],
-           [7,8,9]]",
-            &[1, 2, 3, 6, 9, 8, 7, 4, 5],
+            vec_vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+            vec![1, 2, 3, 6, 9, 8, 7, 4, 5],
         ),
         (
-            "[[1,2,3,4],
-           [5,6,7,8],
-           [9,10,11,12]]",
-            &[1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7],
+            vec_vec![[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
+            vec![1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7],
         ),
     ];
-    for &(input, output) in TEST_CASES.iter() {
-        assert_eq!(spiral_matrix_1(crate::parse_2d_array(input)), output);
+    for (input, output) in test_cases.into_iter() {
+        assert_eq!(spiral_matrix_1(input), output);
     }
 }
 
@@ -116,15 +112,13 @@ fn spiral_matrix_2(n: i32) -> Vec<Vec<i32>> {
 fn test_spiral_matrix_2() {
     assert_eq!(
         spiral_matrix_2(5),
-        crate::parse_2d_array(
-            "[
-        [1, 2, 3, 4, 5],
-        [16, 17, 18, 19, 6],
-        [15, 24, 25, 20, 7],
-        [14, 23, 22, 21, 8],
-        [13, 12, 11, 10, 9]
-    ]"
-        )
+        vec_vec![
+            [1, 2, 3, 4, 5],
+            [16, 17, 18, 19, 6],
+            [15, 24, 25, 20, 7],
+            [14, 23, 22, 21, 8],
+            [13, 12, 11, 10, 9]
+        ]
     );
 }
 

src/easy/matrix_diagonal_traverse.rs

@@ -139,26 +139,15 @@ fn find_diagonal_order(mat: Vec<Vec<i32>>) -> Vec<i32> {
 #[test]
 #[should_panic]
 fn test_find_diagonal_order() {
-    const TEST_CASES: [(&str, &[i32]); 3] = [
+    let test_cases = vec![
+        (vec_vec![[2, 5], [8, 4], [0, -1]], vec![2, 5, 8, 0, 4, -1]),
         (
-            "[[2,5],
-           [8,4],
-           [0,-1]]",
-            &[2, 5, 8, 0, 4, -1],
-        ),
-        (
-            "[[1,2,3],
-           [4,5,6],
-           [7,8,9]]",
-            &[1, 2, 4, 7, 5, 3, 6, 8, 9],
-        ),
-        (
-            "[[2,3],
-           [2,3],",
-            &[2, 3],
+            vec_vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+            vec![1, 2, 4, 7, 5, 3, 6, 8, 9],
         ),
+        (vec_vec![[2, 3], [2, 3]], vec![2, 3]),
     ];
-    for &(input, output) in TEST_CASES.iter() {
-        assert_eq!(find_diagonal_order(crate::parse_2d_array(input)), output);
+    for (input, output) in test_cases.into_iter() {
+        assert_eq!(find_diagonal_order(input), output);
     }
 }

src/easy/very_easy.rs

@@ -439,16 +439,12 @@ fn reconstruct_queue(mut a: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
 
 #[test]
 fn test_reconstruct_queue() {
-    use crate::parse_2d_array;
-    const TEST_CASES: [(&str, &str); 1] = [(
-        "[[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]",
-        "[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]",
+    let test_cases = vec![(
+        vec_vec![[7, 0], [4, 4], [7, 1], [5, 0], [6, 1], [5, 2]],
+        vec_vec![[5, 0], [7, 0], [5, 2], [6, 1], [4, 4], [7, 1]],
     )];
-    for (input, output) in TEST_CASES.iter() {
-        assert_eq!(
-            reconstruct_queue(parse_2d_array(input)),
-            parse_2d_array(output)
-        );
+    for (input, output) in test_cases.into_iter() {
+        assert_eq!(reconstruct_queue(input), output);
     }
 }
 
@@ -1160,13 +1156,13 @@ fn corp_flight_bookings(records: Vec<Vec<i32>>, n: i32) -> Vec<i32> {
 
 #[test]
 fn test_corp_flight_bookings() {
-    const TEST_CASES: [(&str, i32, &[i32]); 1] =
-        [("[[1,2,10],[2,3,20],[2,5,25]]", 5, &[10, 55, 45, 25, 25])];
-    for &(records, n, output) in TEST_CASES.iter() {
-        assert_eq!(
-            corp_flight_bookings(crate::parse_2d_array(records), n),
-            output
-        );
+    let test_cases = vec![(
+        vec_vec![[1, 2, 10], [2, 3, 20], [2, 5, 25]],
+        5,
+        vec![10, 55, 45, 25, 25],
+    )];
+    for (records, n, output) in test_cases.into_iter() {
+        assert_eq!(corp_flight_bookings(records, n), output);
     }
 }
 
@@ -1260,9 +1256,8 @@ fn maximum_units(mut box_types: Vec<Vec<i32>>, mut truck_size: i32) -> i32 {
 
 #[test]
 fn test_maximum_units() {
-    const TEST_CASES: [(&str, i32, i32); 1] = [("[[1,3],[2,2],[3,1]]", 4, 8)];
-    for &(box_types, truck_size, max_value) in TEST_CASES.iter() {
-        let box_types = crate::parse_2d_array(box_types);
+    let test_cases = vec![(vec_vec![[1, 3], [2, 2], [3, 1]], 4, 8)];
+    for (box_types, truck_size, max_value) in test_cases.into_iter() {
         assert_eq!(maximum_units(box_types, truck_size), max_value);
     }
 }
@@ -1307,11 +1302,12 @@ fn count_students(students: Vec<i32>, sandwiches: Vec<i32>) -> i32 {
 
 #[test]
 fn test_count_students() {
-    const TEST_CASES: [(&[i32], &[i32], i32); 1] = [
-        (&[1, 1, 1, 0, 0, 1], &[1, 0, 0, 0, 1, 1], 3)
-    ];
+    const TEST_CASES: [(&[i32], &[i32], i32); 1] = [(&[1, 1, 1, 0, 0, 1], &[1, 0, 0, 0, 1, 1], 3)];
     std::mem::size_of_val(&9i32);
     for &(students, sandwiches, n_students_not_eat) in &TEST_CASES {
-        assert_eq!(count_students(students.to_vec(), sandwiches.to_vec()), n_students_not_eat);
+        assert_eq!(
+            count_students(students.to_vec(), sandwiches.to_vec()),
+            n_students_not_eat
+        );
     }
 }

src/lib.rs

@@ -1,7 +1,11 @@
 #![feature(is_sorted, asm)]
-#![allow(dead_code)]
+#![allow(dead_code, unused_macros)]
 // #![deny(warnings)]
 #![doc(html_playground_url = "https://play.rust-lang.org/")]
+// 如果mod backtracking写在mod macros上面，则mod backtracking无法使用macros内的所有宏
+// Macros can only be used after they have been defined(macro_use)
+#[macro_use]
+mod macros;
 mod backtracking;
 mod bfs;
 mod binary_search;
@@ -16,29 +20,3 @@ mod random;
 mod special_data_structure;
 mod string;
 mod union_find;
-
-pub fn parse_2d_array(s: &str) -> Vec<Vec<i32>> {
-    let len = s.len();
-    let s = &s[1..len - 1];
-    let mut ret = vec![];
-    for nums_str in s.split("],") {
-        let nums_str = nums_str.trim().replace('[', "").replace(']', "");
-        let mut nums = vec![];
-        for num in nums_str.split(',') {
-            if num.is_empty() {
-                continue;
-            }
-            nums.push(num.trim().parse::<i32>().unwrap());
-        }
-        ret.push(nums);
-    }
-    ret
-}
-
-#[test]
-fn test_parse_2d_array() {
-    assert_eq!(
-        parse_2d_array("[[17,2],[-31],[3],[]]"),
-        vec![vec![17, 2], vec![-31], vec![3], vec![]]
-    );
-}

src/macros.rs

@@ -0,0 +1,14 @@
+/// https://docs.rs/rustgym-util/0.2.4/src/rustgym_util/data.rs.html#2-6
+macro_rules! vec_vec {
+    [$($token_tree:tt),* $(,)?] => {
+        vec![$(vec!$token_tree),*]
+    };
+}
+
+#[test]
+fn test_vec_vec_i32() {
+    let expected = vec![vec![17, 2], vec![-31], vec![3], vec![]];
+    assert_eq!(vec_vec![[17, 2], [-31], [3], []], expected);
+    assert_eq!(vec_vec!([17, 2], [-31], [3], [],), expected);
+    assert_eq!(vec_vec! {[17,2],[-31],[3],[],}, expected);
+}

src/union_find/min_cost_to_connect_all_points.rs

@@ -70,16 +70,13 @@ fn min_cost_connect_points(points: Vec<Vec<i32>>) -> i32 {
 
 #[test]
 fn test_min_cost_connect_points() {
-    const TEST_CASES: [(&str, i32); 4] = [
-        ("[[0,0],[2,2],[3,10],[5,2],[7,0]]", 20),
-        ("[[3,12],[-2,5],[-4,1]]", 18),
-        ("[[0,0],[1,1],[1,0],[-1,1]]", 4),
-        ("[[2,-3],[-17,-8],[13,8],[-17,-15]]", 53),
+    let test_cases = vec![
+        (vec_vec![[0, 0], [2, 2], [3, 10], [5, 2], [7, 0]], 20),
+        (vec_vec![[3, 12], [-2, 5], [-4, 1]], 18),
+        (vec_vec![[0, 0], [1, 1], [1, 0], [-1, 1]], 4),
+        (vec_vec![[2, -3], [-17, -8], [13, 8], [-17, -15]], 53),
     ];
-    for &(points, min_cost) in TEST_CASES.iter() {
-        assert_eq!(
-            min_cost_connect_points(crate::parse_2d_array(points)),
-            min_cost
-        );
+    for (points, min_cost) in test_cases.into_iter() {
+        assert_eq!(min_cost_connect_points(points), min_cost);
     }
 }