More cleanup for D17

2019/17/src/main.rs

@@ -103,31 +103,44 @@ fn function_to_string(function: &[Movement]) -> String {
     function.iter().map(|m| m.to_string()).join(",")
 }
 
-fn split_into_functions<'a>(commands: &'a [Movement]) -> Vec<&'a [Movement]> {
+fn find_reoccuring_segments<'a>(
-    let mut pos = 0;
+    commands: &'a [Movement],
-    let mut segments = Vec::new();
+    previous_segments: &[&'a [Movement]],
-    while pos < commands.len() - 4 {
+    starting_pos: &mut usize,
-        if let Some((n, mov)) = (2..=4)
+    length: usize,
-            .filter_map(|i| {
+) -> Option<(usize, usize, &'a [Movement])> {
-                let reference = commands[pos..].windows(i).next();
+    let reference = commands[*starting_pos..].windows(length).next().unwrap();
-                if segments.contains(&reference.unwrap()) {
+    // If the segment we’re currently looking at (reference) is already in our function list,
-                    Some(((i, 99), reference))
+    // add it with the highest priority. (We’ll deduplicate later)
-                } else {
+    if previous_segments.contains(&reference) {
-                    let dupes = commands[pos..]
+        return Some((length, 99, reference));
-                        .windows(i)
+    }
-                        .filter(|&w| Some(w) == reference)
+    let dupes = commands[*starting_pos..]
+        .windows(length)
+        .filter(|&w| w == reference)
         .count();
-                    if dupes > 0 {
+    if dupes > 1 {
-                        Some(((i, dupes), reference))
+        Some((length, dupes, reference))
     } else {
         None
     }
 }
-            })
+
-            .max_by_key(|((x, y), _)| x * y)
+/**
+ * From each position, try to find the slice of the next 2-4 (inclusive)
+ * elements that reoccur as often as possible in the output.
+ */
+fn split_into_functions<'a>(commands: &'a [Movement]) -> Vec<&'a [Movement]> {
+    let mut pos = 0;
+    let mut segments = Vec::new();
+    while pos < commands.len() - 4 {
+        if let Some((segment_length, _, mov)) = (2..=4)
+            .filter_map(|i| find_reoccuring_segments(commands, &segments, &mut pos, i))
+            // Segments are rated by length and number of occurences
+            .max_by_key(|(x, y, _)| x * y)
         {
-            pos += n.0;
+            pos += segment_length;
-            segments.push(mov.unwrap());
+            segments.push(mov);
         }
     }
     segments