Year 2017 Day 4

Author: maneatingape

README.md

@@ -244,6 +244,7 @@ pie
 | 1 | [Inverse Captcha](https://adventofcode.com/2017/day/1) | [Source](src/year2017/day01.rs) | 1 |
 | 2 | [Corruption Checksum](https://adventofcode.com/2017/day/2) | [Source](src/year2017/day02.rs) | 3 |
 | 3 | [Spiral Memory](https://adventofcode.com/2017/day/3) | [Source](src/year2017/day03.rs) | 2 |
+| 4 | [High-Entropy Passphrases](https://adventofcode.com/2017/day/4) | [Source](src/year2017/day04.rs) | 94 |
 
 ## 2016
 

benches/benchmark.rs

@@ -95,6 +95,7 @@ mod year2017 {
     benchmark!(year2017, day01);
     benchmark!(year2017, day02);
     benchmark!(year2017, day03);
+    benchmark!(year2017, day04);
 }
 
 mod year2019 {

input/year2017/day04.txt

@@ -223,6 +223,7 @@ pub mod year2017 {
     pub mod day01;
     pub mod day02;
     pub mod day03;
+    pub mod day04;
 }
 
 /// # Rescue Santa from deep space with a solar system adventure.

src/lib.rs

@@ -141,7 +141,12 @@ fn year2016() -> Vec<Solution> {
 }
 
 fn year2017() -> Vec<Solution> {
-    vec![solution!(year2017, day01), solution!(year2017, day02), solution!(year2017, day03)]
+    vec![
+        solution!(year2017, day01),
+        solution!(year2017, day02),
+        solution!(year2017, day03),
+        solution!(year2017, day04),
+    ]
 }
 
 fn year2019() -> Vec<Solution> {

src/main.rs

@@ -0,0 +1,69 @@
+//! # High-Entropy Passphrases
+//!
+//! ## Part One
+//!
+//! We use a [`FastSet`] to detect duplicates. Sorting the words in each line
+//! then checking for duplicates in adjacent values also works but is slower.
+//!
+//! ## Part Two
+//!
+//! To detect anagrams we first convert each word into a histogram of its letter frequency values.
+//! As the cardinality is at most 26 we can use a fixed size array to represent the set.
+//!
+//! Then a [`FastSet`] is used to detect duplicates. Sorting the letters in each word so that
+//! anagrams become the same also works but is slower.
+use crate::util::hash::*;
+
+type Input<'a> = Vec<&'a str>;
+
+pub fn parse(input: &str) -> Input<'_> {
+    input.lines().collect()
+}
+
+pub fn part1(input: &Input<'_>) -> u32 {
+    let mut result = 0;
+    let mut seen = FastSet::new();
+
+    for line in input {
+        result += 1;
+
+        for token in line.split_ascii_whitespace() {
+            // Insert returns `false` if the value is already in the set.
+            if !seen.insert(token.as_bytes()) {
+                result -= 1;
+                break;
+            }
+        }
+
+        seen.clear();
+    }
+
+    result
+}
+
+pub fn part2(input: &Input<'_>) -> u32 {
+    let mut result = 0;
+    let mut seen = FastSet::new();
+
+    for line in input {
+        result += 1;
+
+        for token in line.split_ascii_whitespace() {
+            // Calculate the frequency of each letter, as anagrams will have the same values.
+            let mut freq = [0_u8; 26];
+
+            for b in token.bytes() {
+                freq[(b - b'a') as usize] += 1;
+            }
+
+            if !seen.insert(freq) {
+                result -= 1;
+                break;
+            }
+        }
+
+        seen.clear();
+    }
+
+    result
+}

src/year2017/day04.rs

@@ -88,6 +88,7 @@ mod year2017 {
     mod day01_test;
     mod day02_test;
     mod day03_test;
+    mod day04_test;
 }
 
 mod year2019 {

tests/test.rs

@@ -0,0 +1,25 @@
+use aoc::year2017::day04::*;
+
+const FIRST_EXAMPLE: &str = "\
+aa bb cc dd ee
+aa bb cc dd aa
+aa bb cc dd aaa";
+
+const SECOND_EXAMPLE: &str = "\
+abcde fghij
+abcde xyz ecdab
+a ab abc abd abf abj
+iiii oiii ooii oooi oooo
+oiii ioii iioi iiio";
+
+#[test]
+fn part1_test() {
+    let input = parse(FIRST_EXAMPLE);
+    assert_eq!(part1(&input), 2);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(SECOND_EXAMPLE);
+    assert_eq!(part2(&input), 3);
+}