Add 3 problems

Author: yafeng-Soong

src/solution/lc1338.rs

@@ -0,0 +1,50 @@
+use crate::solution::Solution;
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn min_set_size(arr: Vec<i32>) -> i32 {
+        let mut count_map = HashMap::new();
+        for &val in &arr {
+            *count_map.entry(val).or_insert(0) += 1;
+        }
+
+        let mut nums: Vec<i32> = count_map.values().cloned().collect();
+        nums.sort_by(|a, b| b.cmp(a));
+        let half = (arr.len() / 2) as i32;
+        let mut res = 0;
+        let mut sum = 0;
+        for val in nums {
+            res += 1;
+            sum += val;
+            if sum >= half {
+                break;
+            }
+        }
+
+        res
+    }
+}
+
+#[test]
+fn test_reduce() {
+    struct Test {
+        arr: Vec<i32>,
+        expected: i32,
+    }
+
+    let tests = vec![
+        Test {
+            arr: vec![3, 3, 3, 3, 5, 5, 5, 2, 2, 7],
+            expected: 2,
+        },
+        Test {
+            arr: vec![7, 7, 7, 7, 7],
+            expected: 1,
+        },
+    ];
+
+    for t in tests {
+        let res = Solution::min_set_size(t.arr);
+        assert_eq!(t.expected, res);
+    }
+}

src/solution/lc1387.rs

@@ -0,0 +1,60 @@
+use crate::solution::Solution;
+
+impl Solution {
+    pub fn get_kth(lo: i32, hi: i32, k: i32) -> i32 {
+        let mut nums: Vec<i32> = (lo..=hi).collect();
+        nums.sort_by(|&a, &b| {
+            let res = Self::compute_weight(a).cmp(&Self::compute_weight(b));
+            match res {
+                std::cmp::Ordering::Equal => a.cmp(&b),
+                _ => res,
+            }
+        });
+
+        nums[k as usize - 1]
+    }
+
+    fn compute_weight(mut num: i32) -> i32 {
+        let mut res = 0;
+        loop {
+            match num {
+                1 => break,
+                n if n % 2 == 0 => num /= 2,
+                _ => num = 3 * num + 1,
+            }
+            res += 1;
+        }
+
+        res
+    }
+}
+
+#[test]
+fn test() {
+    struct Test {
+        lo: i32,
+        hi: i32,
+        k: i32,
+        expected: i32,
+    }
+
+    let tests = vec![
+        Test {
+            lo: 12,
+            hi: 15,
+            k: 2,
+            expected: 13,
+        },
+        Test {
+            lo: 7,
+            hi: 11,
+            k: 4,
+            expected: 7,
+        },
+    ];
+
+    for t in tests {
+        let res = Solution::get_kth(t.lo, t.hi, t.k);
+        assert_eq!(t.expected, res);
+    }
+}

src/solution/lc1812.rs

@@ -0,0 +1,34 @@
+use crate::solution::Solution;
+
+impl Solution {
+    pub fn square_is_white(coordinates: String) -> bool {
+        let x = coordinates.chars().nth(0).unwrap() as i32;
+        let y = coordinates.chars().nth(1).unwrap() as i32;
+
+        x % 2 != y % 2
+    }
+}
+
+#[test]
+fn test_lc1812() {
+    struct Test {
+        input: String,
+        expected: bool,
+    }
+
+    let tests = vec![
+        Test {
+            input: String::from("a1"),
+            expected: false,
+        },
+        Test {
+            input: String::from("h3"),
+            expected: true,
+        },
+    ];
+
+    for test in tests {
+        let mut res = Solution::square_is_white(test.input);
+        assert_eq!(test.expected, res);
+    }
+}

src/solution/mod.rs

@@ -4,12 +4,15 @@ mod lc101;
 mod lc104;
 mod lc105;
 mod lc122;
+mod lc1338;
 mod lc134;
+mod lc1387;
 mod lc14;
 mod lc151;
 mod lc155;
 mod lc169;
 mod lc1717;
+mod lc1812;
 mod lc2;
 mod lc21;
 mod lc215;