Data commit

Task/Permutations/Rust/permutations-1.rust

@@ -0,0 +1,40 @@
+pub fn permutations(size: usize) -> Permutations {
+    Permutations { idxs: (0..size).collect(), swaps: vec![0; size], i: 0 }
+}
+
+pub struct Permutations {
+    idxs: Vec<usize>,
+    swaps: Vec<usize>,
+    i: usize,
+}
+
+impl Iterator for Permutations {
+    type Item = Vec<usize>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.i > 0 {
+            loop {
+                if self.i >= self.swaps.len() { return None; }
+                if self.swaps[self.i] < self.i { break; }
+                self.swaps[self.i] = 0;
+                self.i += 1;
+            }
+            self.idxs.swap(self.i, (self.i & 1) * self.swaps[self.i]);
+            self.swaps[self.i] += 1;
+        }
+        self.i = 1;
+        Some(self.idxs.clone())
+    }
+}
+
+fn main() {
+    let perms = permutations(3).collect::<Vec<_>>();
+    assert_eq!(perms, vec![
+        vec![0, 1, 2],
+        vec![1, 0, 2],
+        vec![2, 0, 1],
+        vec![0, 2, 1],
+        vec![1, 2, 0],
+        vec![2, 1, 0],
+    ]);
+}

Task/Permutations/Rust/permutations-2.rust

@@ -0,0 +1,18 @@
+use std::collections::VecDeque;
+
+fn permute<T, F: Fn(&[T])>(used: &mut Vec<T>, unused: &mut VecDeque<T>, action: &F) {
+    if unused.is_empty() {
+        action(used);
+    } else {
+        for _ in 0..unused.len() {
+            used.push(unused.pop_front().unwrap());
+            permute(used, unused, action);
+            unused.push_back(used.pop().unwrap());
+        }
+    }
+}
+
+fn main() {
+    let mut queue = (1..4).collect::<VecDeque<_>>();
+    permute(&mut Vec::new(), &mut queue, &|perm| println!("{:?}", perm));
+}