Add problem 3211: Generate Binary Strings Without Adjacent Zeros

Author: EFanZh

src/lib.rs

@@ -2138,6 +2138,7 @@ pub mod problem_3201_find_the_maximum_length_of_valid_subsequence_i;
 pub mod problem_3206_alternating_groups_i;
 pub mod problem_3208_alternating_groups_ii;
 pub mod problem_3210_find_the_encrypted_string;
+pub mod problem_3211_generate_binary_strings_without_adjacent_zeros;
 pub mod problem_3350_adjacent_increasing_subarrays_detection_ii;
 
 #[cfg(test)]

src/problem_3211_generate_binary_strings_without_adjacent_zeros/dfs.rs

@@ -0,0 +1,74 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+struct Context {
+    buffer: String,
+    result: Vec<String>,
+    length: usize,
+}
+
+impl Context {
+    fn emit(&mut self) {
+        self.result.push(self.buffer.clone());
+    }
+
+    fn push<const C: char>(&mut self, f: impl FnOnce(&mut Self)) {
+        self.buffer.push(C);
+        self.length -= 1;
+
+        f(self);
+
+        self.length += 1;
+        self.buffer.pop();
+    }
+}
+
+impl Solution {
+    fn dfs_0(context: &mut Context) {
+        if context.length == 0 {
+            context.emit();
+        } else {
+            context.push::<'1'>(Self::dfs_1);
+        }
+    }
+
+    fn dfs_1(context: &mut Context) {
+        if context.length == 0 {
+            context.emit();
+        } else {
+            context.push::<'0'>(Self::dfs_0);
+            context.push::<'1'>(Self::dfs_1);
+        }
+    }
+
+    pub fn valid_strings(n: i32) -> Vec<String> {
+        let n = n.cast_unsigned() as usize;
+
+        let mut context = Context {
+            buffer: String::with_capacity(n),
+            result: Vec::new(),
+            length: n,
+        };
+
+        Self::dfs_1(&mut context);
+
+        context.result
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn valid_strings(n: i32) -> Vec<String> {
+        Self::valid_strings(n)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_3211_generate_binary_strings_without_adjacent_zeros/mod.rs

@@ -0,0 +1,19 @@
+pub mod dfs;
+
+pub trait Solution {
+    fn valid_strings(n: i32) -> Vec<String>;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+    use crate::test_utilities;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [(3, &["010", "011", "101", "110", "111"] as &[_]), (1, &["0", "1"])];
+
+        for (n, expected) in test_cases {
+            assert_eq!(test_utilities::unstable_sorted(S::valid_strings(n)), expected);
+        }
+    }
+}