double weekly match

Author: caibirdme

src/lib.rs

@@ -394,6 +394,10 @@ mod prob_5355;
 mod prob_5356;
 mod prob_5357;
 mod prob_5359;
+mod prob_5360;
+mod prob_5361;
+mod prob_5362;
+mod prob_5363;
 mod prob_5364;
 mod prob_5366;
 mod prob_5367;

src/prob_5360.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn count_largest_group(n: i32) -> i32 {
+        let mut hash = HashMap::new();
+        let mut m = 0;
+        for i in 1..=n {
+            let mut t = i;
+            let mut c = 0;
+            while t > 0 {
+                c += t%10;
+                t /= 10;
+            }
+            let p = hash.entry(c).or_insert(0);
+            *p += 1;
+            m = m.max(*p);
+        }
+        let mut ans = 0;
+        for &v in hash.values() {
+            if v == m {
+                ans += 1;
+            }
+        }
+        ans
+    }
+}
+
+struct Solution;

src/prob_5361.rs

@@ -0,0 +1,67 @@
+impl Solution {
+    pub fn check_overlap(radius: i32, x_center: i32, y_center: i32, x1: i32, y1: i32, x2: i32, y2: i32) -> bool {
+        if x1<=x_center && y1 <= y_center && x2>=x_center && y2 >= y_center {
+            return true;
+        }
+        if x1 > x_center+radius || x2 < x_center-radius {
+            return false;
+        }
+        if y1 >= y_center {
+            if y1 > y_center + radius {
+                false
+            } else if y1 == y_center + radius {
+                x1 <= x_center && x2 >= x_center
+            } else {
+                let w = radius.pow(2)-(y1-y_center).pow(2);
+                if x2 < x_center && (x2-x_center).pow(2) > w {
+                    return false;
+                }
+                if x1 > x_center && (x1-x_center).pow(2) > w {
+                    return false;
+                }
+                true
+            }
+        } else if y2 <= y_center {
+            if y2 < y_center-radius {
+                false
+            } else if y2 == y_center-radius {
+                x1 <= x_center && x2 >= x_center
+            } else if x1<=x_center-radius && x2>=x_center+radius {
+                true
+            } else {
+                let w = radius.pow(2)-(y2-y_center).pow(2);
+                if x2 < x_center && (x2-x_center).pow(2) > w {
+                    return false;
+                }
+                if x1 > x_center && (x1-x_center).pow(2) > w {
+                    return false;
+                }
+                true
+            }
+        } else {
+            true
+        }
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_check_overlap() {
+        let test_cases = vec![
+            (1415,807,-784,-733,623,-533,1005, false),
+            (1,0,3,7,3,10,6, false),
+            (1,0,0,1,-1,3,1, true),
+            (1,0,0,-1,0,0,1, true),
+            (1,1,1,-3,-3,3,3,true),
+            (1,1,1,1,-3,2,-1, false),
+        ];
+        for (r, xc,yc,x1,y1,x2,y2,ok) in test_cases {
+            assert_eq!(Solution::check_overlap(r,xc,yc,x1,y1,x2,y2), ok, "r:{},xc:{},yc:{},x1:{},y1:{},x2:{},y2:{}", r,xc,yc,x1,y1,x2,y2);
+        }
+    }
+}

src/prob_5362.rs

@@ -0,0 +1,44 @@
+impl Solution {
+    pub fn can_construct(s: String, k: i32) -> bool {
+        let n = s.len();
+        let k = k as usize;
+        if n == 0 || n < k {
+            return false;
+        }
+        if n == k {
+            return true;
+        }
+        let mut count = [0; 26];
+        for &c in s.as_bytes() {
+            count[(c-b'a') as usize] += 1;
+        }
+        let mut odd_num = 0;
+        for i in 0..26 {
+            if count[i] & 1 == 1 {
+                odd_num += 1;
+            }
+        }
+        odd_num <= k
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_can_construct() {
+        let test_cases = vec![
+            ("leetcode", 3, false),
+            ("yzyzyzyzyzyzyzy", 2, true),
+            ("true", 4, true),
+            ("cr", 7, false),
+            ("annabelle", 2, true),
+        ];
+        for (s, k, ok) in test_cases {
+            assert_eq!(Solution::can_construct(s.to_string(), k), ok, "s: {}, k:{}",s,k);
+        }
+    }
+}

src/prob_5363.rs

@@ -0,0 +1,50 @@
+use std::cmp::max;
+
+impl Solution {
+    pub fn max_satisfaction(mut satisfaction: Vec<i32>) -> i32 {
+        let n = satisfaction.len();
+        if n == 0 {
+            return 0;
+        }
+        if n == 1 {
+            if satisfaction[0] < 0 {
+                return 0;
+            }
+            return satisfaction[0];
+        }
+        satisfaction.sort();
+        let mut s = 0;
+        let mut w = 0;
+        let mut ans = 0;
+        for i in (0..n).rev() {
+            let val = satisfaction[i]+w+s;
+            if val < 0 {
+                break;
+            }
+            s += satisfaction[i];
+            w = val;
+            ans = ans.max(val);
+        }
+        ans
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_max_satisfaction() {
+        let test_cases = vec![
+            (vec![-2,5,-1,0,3,-3], 35),
+            (vec![4,3,2], 20),
+            (vec![-1,-8,0,5,-9], 14),
+            (vec![-1,-4,-5], 0),
+        ];
+        for (sat, expect) in test_cases {
+            assert_eq!(Solution::max_satisfaction(sat.clone()), expect, "sat: {:?}", sat);
+        }
+    }
+}