nightly match 24

Author: caibirdme

src/lib.rs

@@ -407,6 +407,8 @@ mod prob_5364;
 mod prob_5366;
 mod prob_5367;
 mod prob_5370;
+mod prob_5374;
+mod prob_5375;
 mod prob_5377;
 mod prob_5379;
 mod prob_5380;

src/prob_5374.rs

@@ -0,0 +1,49 @@
+impl Solution {
+    pub fn get_happy_string(n: i32, k: i32) -> String {
+        let mut arr = vec![];
+        let mut uk = k as usize;
+        let mut ans = None;
+        Self::dfs(0, n as usize, &mut uk, &mut arr, &mut ans);
+        ans.unwrap_or("".to_string())
+    }
+    fn dfs(i: usize, n: usize, k: &mut usize, arr: &mut Vec<u8>, ans: &mut Option<String>) {
+        if ans.is_some() {
+            return;
+        }
+        if i == n {
+            *k -= 1;
+            if *k == 0 {
+                *ans = Some(unsafe {std::str::from_utf8_unchecked(&arr).to_string()});
+            }
+            return;
+        }
+        for c in b'a'..=b'c' {
+            if i > 0 && arr[i-1] == c {
+                continue;
+            }
+            arr.push(c);
+            Self::dfs(i+1, n, k, arr, ans);
+            arr.pop();
+        }
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_get_happy_string() {
+        let test_cases = vec![
+            (1, 4, ""),
+            (3, 9, "cab"),
+            (2, 7, ""),
+            (10, 100, "abacbabacb"),
+        ];
+        for (n,k,expect) in test_cases {
+            assert_eq!(Solution::get_happy_string(n, k), expect, "n:{}, k:{}",n,k);
+        }
+    }
+}

src/prob_5375.rs

@@ -0,0 +1,71 @@
+macro_rules! val {
+    ($e: expr) => {
+        ($e-b'0') as i64
+    };
+}
+
+impl Solution {
+    pub fn number_of_arrays(s: String, k: i32) -> i32 {
+        const MOD: i64 = 1000000007;
+        let n = s.len();
+        let bs = s.as_bytes();
+        let mut f = vec![0i64; n];
+        let k = k as i64;
+        if val!(bs[0]) > k {
+            return 0;
+        }
+        f[0] = 1;
+        for i in 1..n {
+            let mut t = val!(bs[i]);
+            let mut q = 1;
+            if t > k {
+                return 0;
+            }
+            if f[i-1] > 0 && t != 0{
+                f[i] += f[i-1];
+            }
+            for j in (0..i).rev() {
+                q *= 10;
+                if q > k {
+                    break;
+                }
+                let w = val!(bs[j]);
+                if w == 0 {
+                    continue;
+                }
+                t += w*q;
+                if t > k {
+                    break;
+                }
+                if j > 0 {
+                    f[i] += f[j-1];
+                } else if j == 0 {
+                    f[i] += 1;
+                }
+            }
+            f[i] %= MOD;
+        }
+        f[n-1] as i32
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_number_of_arrays() {
+        let test_cases = vec![
+            ("1000", 10000, 1),
+            ("1000", 10, 0),
+            ("1317", 2000, 8),
+            ("2020", 30, 1),
+            ("1234567890", 90, 34),
+        ];
+        for (s, k, expect) in test_cases {
+            assert_eq!(Solution::number_of_arrays(s.to_string(), k), expect, "s: {}, k: {}",s,k);
+        }
+    }
+}