Faster approach using sorted ranges for faster equality checking

Author: maneatingape

README.md

@@ -381,7 +381,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 16 | [Aunt Sue](https://adventofcode.com/2015/day/16) | [Source](src/year2015/day16.rs) | 20 |
 | 17 | [No Such Thing as Too Much](https://adventofcode.com/2015/day/17) | [Source](src/year2015/day17.rs) | 45 |
 | 18 | [Like a GIF For Your Yard](https://adventofcode.com/2015/day/18) | [Source](src/year2015/day18.rs) | 154 |
-| 19 | [Medicine for Rudolph](https://adventofcode.com/2015/day/19) | [Source](src/year2015/day19.rs) | 187 |
+| 19 | [Medicine for Rudolph](https://adventofcode.com/2015/day/19) | [Source](src/year2015/day19.rs) | 23 |
 | 20 | [Infinite Elves and Infinite Houses](https://adventofcode.com/2015/day/20) | [Source](src/year2015/day20.rs) | 1667 |
 | 21 | [RPG Simulator 20XX](https://adventofcode.com/2015/day/21) | [Source](src/year2015/day21.rs) | 2 |
 | 22 | [Wizard Simulator 20XX](https://adventofcode.com/2015/day/22) | [Source](src/year2015/day22.rs) | 235 |

src/year2015/day19.rs

@@ -1,6 +1,11 @@
 //! # Medicine for Rudolph
 //!
-//! Part one is a brute force search and replace of every possibility.
+//! Part one is a brute force search and replace of every possibility with two optimizations.
+//! Replacements that add the same number of extra molecules are grouped together, as different
+//! length strings can never match.
+//!
+//! Next replacement ranges are sorted into ascending order. Non-overlapping ranges can never match,
+//! so checking for other equals string only needs to consider ranges that intersect.
 //!
 //! Part two uses the analysis from `askalski` provided on the
 //! [Day 19 solution megathread](https://www.reddit.com/r/adventofcode/comments/3xflz8/day_19_solutions/).
@@ -15,29 +20,57 @@ pub fn parse(input: &str) -> Input<'_> {
 
 pub fn part1(input: &Input<'_>) -> usize {
     let (molecule, replacements) = input;
-    let mut distinct = FastSet::new();
 
-    for (from, to) in replacements {
-        for (start, _) in molecule.match_indices(from) {
-            let size = molecule.len() - from.len() + to.len();
-            let end = start + from.len();
+    let mut groups = FastMap::new();
+    let mut modified = Vec::new();
+    let mut result = 0;
 
-            let mut string = String::with_capacity(size);
-            string.push_str(&molecule[..start]);
-            string.push_str(to);
-            string.push_str(&molecule[end..]);
+    // Group replacements of the same size together.
+    for &(from, to) in replacements {
+        let extra = to.len() - from.len();
+        groups.entry(extra).or_insert(Vec::new()).push((from, to));
+    }
 
-            distinct.insert(string);
+    for (_, group) in groups {
+        // Build list of all possible modified strings.
+        for (from, to) in group {
+            for (start, _) in molecule.match_indices(from) {
+                let end = start + from.len();
+                modified.push((start, end, to));
+            }
         }
+
+        modified.sort_unstable_by_key(|&(start, ..)| start);
+
+        'outer: for (i, &(start, end, to)) in modified.iter().enumerate() {
+            for &(start2, _, to2) in &modified[i + 1..] {
+                // Stop checking early once ranges no longer overlap.
+                if start2 >= start + to.len() {
+                    break;
+                }
+
+                // Compare replaced sections for equality.
+                let first = to.bytes().chain(molecule[end..].bytes());
+                let second = molecule[start..start2].bytes().chain(to2.bytes());
+
+                if first.zip(second).all(|(a, b)| a == b) {
+                    continue 'outer;
+                }
+            }
+
+            result += 1;
+        }
+
+        modified.clear();
     }
 
-    distinct.len()
+    result
 }
 
 pub fn part2(input: &Input<'_>) -> usize {
     let (molecule, _) = input;
 
-    let elements = molecule.chars().filter(char::is_ascii_uppercase).count();
+    let elements = molecule.bytes().filter(u8::is_ascii_uppercase).count();
     let rn = molecule.matches("Rn").count();
     let ar = molecule.matches("Ar").count();
     let y = molecule.matches('Y').count();