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

struct Solution;

impl Solution {
    fn nth_ugly_number(n: i32, a: i32, b: i32, c: i32) -> i32 {
        let mut left = 0;
        let mut right = 2_000_000_000;
        while left < right {
            let mid = left + (right - left) / 2;
            if Self::count(mid, a as u64, b as u64, c as u64) < n as u64 {
                left = mid + 1;
            } else {
                right = mid
            }
        }
        left as i32
    }

    fn count(num: u64, a: u64, b: u64, c: u64) -> u64 {
        num / a + num / b + num / c
            - num / Self::lcm(a, b)
            - num / Self::lcm(b, c)
            - num / Self::lcm(a, c)
            + num / Self::lcm(a, Self::lcm(b, c))
    }

    fn lcm(a: u64, b: u64) -> u64 {
        a * b / Self::gcd(a, b)
    }

    fn gcd(a: u64, b: u64) -> u64 {
        if a == 0 {
            b
        } else {
            Self::gcd(b % a, a)
        }
    }
}

#[test]
fn test() {
    let n = 3;
    let a = 2;
    let b = 3;
    let c = 5;
    let res = 4;
    assert_eq!(Solution::nth_ugly_number(n, a, b, c), res);
    let n = 4;
    let a = 2;
    let b = 3;
    let c = 4;
    let res = 6;
    assert_eq!(Solution::nth_ugly_number(n, a, b, c), res);
    let n = 5;
    let a = 2;
    let b = 11;
    let c = 13;
    let res = 10;
    assert_eq!(Solution::nth_ugly_number(n, a, b, c), res);
    let n = 1000000000;
    let a = 2;
    let b = 217983653;
    let c = 336916467;
    let res = 1999999984;
    assert_eq!(Solution::nth_ugly_number(n, a, b, c), res);
}