Faster simpler approach

Author: maneatingape

README.md

@@ -95,7 +95,7 @@ pie
 | 3 | [Rucksack Reorganization](https://adventofcode.com/2022/day/3) | [Source](src/year2022/day03.rs) | 15 |
 | 4 | [Camp Cleanup](https://adventofcode.com/2022/day/4) | [Source](src/year2022/day04.rs) | 7 |
 | 5 | [Supply Stacks](https://adventofcode.com/2022/day/5) | [Source](src/year2022/day05.rs) | 14 |
-| 6 | [Tuning Trouble](https://adventofcode.com/2022/day/6) | [Source](src/year2022/day06.rs) | 6 |
+| 6 | [Tuning Trouble](https://adventofcode.com/2022/day/6) | [Source](src/year2022/day06.rs) | 3 |
 | 7 | [No Space Left On Device](https://adventofcode.com/2022/day/7) | [Source](src/year2022/day07.rs) | 10 |
 | 8 | [Treetop Tree House](https://adventofcode.com/2022/day/8) | [Source](src/year2022/day08.rs) | 55 |
 | 9 | [Rope Bridge](https://adventofcode.com/2022/day/9) | [Source](src/year2022/day09.rs) | 122 |

src/year2022/day06.rs

@@ -5,64 +5,48 @@
 //! as the window then we know that all characters are unique, as sets contain no duplicate elements.
 //!
 //! We'll use a faster approach that minimizes the work needed. Instead of creating a set for each
-//! window, we'll maintain a count of each character. As the window advances we add the next
-//! character to the count and remove the character the drops out of the window.
+//! window, we'll maintain the last position seen of each character. As we advance character by
+//! character we lookup the previous position. If this is within the packet size, then we advance
+//! the start of the packet to exclude that character. Once the packet has reached the desired
+//! size then we return the current index.
 //!
 //! [`windows`]: slice::windows
 //! [`HashSet`]: std::collections::HashSet
 
-/// Convert the input string into a `vec` of `usize`, where "a" maps to 0 and "z" to 25.
-///
-/// Notes:
-/// * We need to [`trim`] to remove the trailing newline character
-/// * Advent of Code input is always ASCII characters, so casting to an `u8` slice is acceptable.
-///
-/// [`trim`]: str::trim
-pub fn parse(input: &str) -> Vec<usize> {
-    input.trim().bytes().map(|b| (b - b'a') as usize).collect()
+/// Return the input directly.
+pub fn parse(input: &str) -> &str {
+    input
 }
 
 /// Find the first unique set of size 4
-pub fn part1(input: &[usize]) -> usize {
+pub fn part1(input: &str) -> usize {
     find(input, 4)
 }
 
 /// Find the first unique set of size 14
-pub fn part2(input: &[usize]) -> usize {
+pub fn part2(input: &str) -> usize {
     find(input, 14)
 }
 
-/// Efficient search algorithm.
-///
-/// The cardinality of the input is only 26 so a fixed size array can store the count of each
-/// character. We are interested in 2 transitions:
-/// * If the count for a character was 0 and is now 1, then this is the only character of this type
-///   in the window and we should increment the `different` counter by 1.
-/// * If the count for the character was 1 and is now 0, then the character is no longer present
-///   in the window, and we should decrement the `different` counter by 1.
-///
-/// All other transitions have no effect on the value of `different`. Once the `different` counter
-/// is the same as the window size then we return the 1-based index as our answer.
-fn find(input: &[usize], marker: usize) -> usize {
-    let mut letters = [0; 26];
-    let mut different = 0;
-
-    for i in 0..input.len() {
-        let new = input[i];
-        letters[new] += 1;
-        if letters[new] == 1 {
-            different += 1;
-        }
-
-        if i >= marker {
-            let old = input[i - marker];
-            letters[old] -= 1;
-            if letters[old] == 0 {
-                different -= 1;
-            }
+/// The cardinality of the input is only 26 so a fixed size array can store the last position
+/// of each character.
+fn find(input: &str, marker: usize) -> usize {
+    let mut start = 0;
+    let mut seen = [0; 26];
+
+    for (i, b) in input.bytes().enumerate() {
+        // Use the character as an index into the array.
+        let index = (b - b'a') as usize;
+        let previous = seen[index];
+        // Positions are 1-based.
+        seen[index] = i + 1;
+
+        // There's a duplicate so advance the start of the window one character past it.
+        if previous > start {
+            start = previous;
         }
-
-        if different == marker {
+        // We've reached the desired packet size with no duplicates so finish.
+        if i + 1 - start == marker {
             return i + 1;
         }
     }

tests/year2022/day06_test.rs

@@ -5,11 +5,11 @@ const EXAMPLE: &str = "mjqjpqmgbljsphdztnvjfqwrcgsmlb";
 #[test]
 fn part1_test() {
     let input = parse(EXAMPLE);
-    assert_eq!(part1(&input), 7);
+    assert_eq!(part1(input), 7);
 }
 
 #[test]
 fn part2_test() {
     let input = parse(EXAMPLE);
-    assert_eq!(part2(&input), 19);
+    assert_eq!(part2(input), 19);
 }