rustgym 0.2.0

rustgym solutions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

struct Solution;
use std::cmp::Ordering::*;

impl Solution {
    fn four_sum(mut nums: Vec<i32>, target: i32) -> Vec<Vec<i32>> {
        let n = nums.len();
        let mut res = vec![];
        nums.sort_unstable();
        let mut i = 0;
        while i + 3 < n {
            if i > 0 && nums[i - 1] == nums[i] {
                i += 1;
                continue;
            }
            if nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target {
                break;
            }
            if nums[n - 3] + nums[n - 2] + nums[n - 1] + nums[i] < target {
                i += 1;
                continue;
            }
            let mut j = i + 1;
            while j + 2 < n {
                if j > i + 1 && nums[j - 1] == nums[j] {
                    j += 1;
                    continue;
                }
                if nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target {
                    break;
                }
                if nums[n - 2] + nums[n - 1] + nums[i] + nums[j] < target {
                    j += 1;
                    continue;
                }
                let sum2 = nums[i] + nums[j];
                let mut l = j + 1;
                let mut r = n - 1;
                while l < r {
                    let sum4 = sum2 + nums[l] + nums[r];
                    match sum4.cmp(&target) {
                        Less => {
                            l += 1;
                        }
                        Greater => {
                            r -= 1;
                        }
                        Equal => {
                            res.push(vec![nums[i], nums[j], nums[l], nums[r]]);
                            l += 1;
                            r -= 1;
                            while l < r && nums[l - 1] == nums[l] {
                                l += 1;
                            }
                            while l < r && nums[r] == nums[r + 1] {
                                r -= 1;
                            }
                        }
                    }
                }
                j += 1
            }
            i += 1
        }
        res
    }
}

#[test]
fn test() {
    let nums = vec![1, 0, -1, 0, -2, 2];
    let target = 0;
    let mut ans: Vec<Vec<i32>> = vec_vec_i32![[-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2]];
    let mut res = Solution::four_sum(nums, target);
    res.sort_unstable();
    ans.sort_unstable();
    assert_eq!(ans, res);
}