June 2018 Update

Task/Permutations/Rust/permutations-1.rust

@@ -1,34 +1,40 @@
-struct QuickPerm<T> {
+pub fn permutations(size: usize) -> Permutations {
+    Permutations { idxs: (0..size).collect(), swaps: vec![0; size], i: 0 }
+}
+
+pub struct Permutations {
     idxs: Vec<usize>,
-    elems: Vec<T>,
-    idx: usize,
+    swaps: Vec<usize>,
+    i: usize,
 }
 
-impl<T: Clone> QuickPerm<T>  {
-    fn new(elems: Vec<T>) -> Self {
-        QuickPerm { idxs: (0..elems.len()+1).collect(), elems: elems, idx: 1 }
-    }
-}
+impl Iterator for Permutations {
+    type Item = Vec<usize>;
 
-impl<T: Clone> Iterator for QuickPerm<T> {
-    type Item = Vec<T>;
     fn next(&mut self) -> Option<Self::Item> {
-        if self.idx == self.elems.len() { return None; }
-
-        self.idxs[self.idx] -= 1;
-        let other = if self.idx % 2 == 1 { self.idxs[self.idx] } else { 0 };
-        self.elems.swap(self.idx, other);
-        self.idx = 1;
-        while self.idxs[self.idx] == 0 {
-            self.idxs[self.idx] = self.idx;
-            self.idx += 1;
+        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;
         }
-        Some(self.elems.clone())
+        self.i = 1;
+        Some(self.idxs.clone())
     }
 }
 
 fn main() {
-    for perm in QuickPerm::new(vec![1,2,3]) {
-        println!("{:?}", perm);
-    }
+    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

@@ -1,4 +1,5 @@
 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);
@@ -11,15 +12,7 @@ fn permute<T, F: Fn(&[T])>(used: &mut Vec<T>, unused: &mut VecDeque<T>, action:
     }
 }
 
-// Same as the vec! macro, but for VecDeques as well
-macro_rules! vec_deque {
-    ($($item:expr),*) => {{
-        let mut deque = ::std::collections::VecDeque::new();
-        $(deque.push_back($item);)*
-        deque
-    }}
-}
-
 fn main() {
-    permute(&mut Vec::new(), &mut vec_deque![1,2,3], &|perm| println!("{:?}", perm));
+    let mut queue = (1..4).collect::<VecDeque<_>>();
+    permute(&mut Vec::new(), &mut queue, &|perm| println!("{:?}", perm));
 }