update day7

src/day7.rs

@@ -0,0 +1,207 @@
+use std::collections::HashMap;
+
+use aoc_runner_derive::{aoc, aoc_generator};
+#[aoc_generator(day7)]
+fn parse(input: &str) -> Vec<Vec<String>> {
+    let input: Vec<Vec<String>> = input.split('\n')
+        .map(|line| line.split(' ').map(|x| x.into()).collect::<Vec<String>>())
+        .collect::<Vec<_>>();
+
+    input
+}
+
+#[aoc(day7, part1)]
+fn part1(input: &Vec<Vec<String>>) -> usize {
+    let mut tmp: Vec<Vec<String>> = Vec::new();
+    input.clone_into(&mut tmp);
+    let mut input = tmp;
+
+    for line in 0..input.len() {
+        let hand = &input[line][0];
+        let mut card_freq: HashMap<char, i16> = HashMap::new();
+        for card in hand.chars() {
+            card_freq.entry(card)
+                .and_modify(|count| *count += 1)
+                .or_insert(1);
+        }
+
+        let mut set_count: HashMap<i16, i16> = HashMap::new();
+        for i in 1..=5 {
+            let card_count = card_freq.values().filter(|x| **x == i).count().try_into().unwrap();
+            if card_count != 0 {
+                set_count.insert(i, card_count);
+            }
+        }
+
+        let power = match set_count {
+            x if x.contains_key(&5) => "7",
+            x if x.contains_key(&4) => "6",
+            x if x.contains_key(&3) && x.contains_key(&2) => "5",
+            x if x.contains_key(&3) => "4",
+            x if x.get(&2).unwrap_or(&0) >= &2 => "3",
+            x if x.get(&2).unwrap_or(&0) == &1 => "2",
+            HashMap { .. } => "1"
+        };
+
+        input[line].push(power.into());
+    }
+
+    input.sort_by(|lhs, rhs| {
+        let lhs_power: i32 = lhs[2].parse().unwrap();
+        let rhs_power: i32 = rhs[2].parse().unwrap();
+        if lhs_power != rhs_power {
+            return lhs_power.cmp(&rhs_power);
+        }
+
+        let lhs_hand: Vec<i32> = lhs[0].chars().map(card_value).collect();
+        let rhs_hand: Vec<i32> = rhs[0].chars().map(card_value).collect();
+        for i in 0..5 {
+            if lhs_hand[i] == rhs_hand[i] { continue; }
+            return lhs_hand[i].cmp(&rhs_hand[i]);
+        }
+
+        panic!("Should not be reachable");
+    });
+
+
+    let mut total_winnings = 0;
+    for i in 0..input.len() {
+        let bid: usize = input[i][1].parse().unwrap();
+        total_winnings += (i + 1) * bid;
+    }
+
+    total_winnings
+}
+
+fn card_value(card: char) -> i32 {
+    match card {
+        'A' => 13,
+        'K' => 12,
+        'Q' => 11,
+        'J' => 10,
+        'T' => 9,
+        '9' => 8,
+        '8' => 7,
+        '7' => 6,
+        '6' => 5,
+        '5' => 4,
+        '4' => 3,
+        '3' => 2,
+        '2' => 1,
+        _ => panic!("invalid card")
+    }
+}
+
+#[aoc(day7, part2)]
+fn part2(input: &Vec<Vec<String>>) -> usize {
+    let mut tmp: Vec<Vec<String>> = Vec::new();
+    input.clone_into(&mut tmp);
+    let mut input = tmp;
+
+    for line in 0..input.len() {
+        let hand = &input[line][0];
+        if hand == "JJJJJ" {
+            input[line].push("7".to_string());
+            continue;
+        }
+        let mut card_freq: HashMap<char, i16> = HashMap::new();
+        let joker_count: i16 = hand.chars().filter(|c| c == &'J').count().try_into().unwrap();
+        for card in hand.chars().filter(|c| c != &'J') {
+            card_freq.entry(card)
+                .and_modify(|count| *count += 1)
+                .or_insert(1);
+        }
+
+        // The most helpful place for the jokers will always be with the max card count
+        let max = card_freq.clone().into_iter().max_by(|a, b| a.1.cmp(&b.1)).unwrap();
+        card_freq.entry(max.0)
+            .and_modify(|count| *count += joker_count);
+
+        let mut set_count: HashMap<i16, i16> = HashMap::new();
+        for i in 1..=5 {
+            let card_count = card_freq.values().filter(|x| **x == i).count().try_into().unwrap();
+            if card_count != 0 {
+                set_count.insert(i, card_count);
+            }
+        }
+
+        let power = match set_count {
+            x if x.contains_key(&5) => "7",
+            x if x.contains_key(&4) => "6",
+            x if x.contains_key(&3) && x.contains_key(&2) => "5",
+            x if x.contains_key(&3) => "4",
+            x if x.get(&2).unwrap_or(&0) >= &2 => "3",
+            x if x.get(&2).unwrap_or(&0) == &1 => "2",
+            HashMap { .. } => "1"
+        };
+
+        input[line].push(power.to_string());
+    }
+
+    input.sort_by(|lhs, rhs| {
+        let lhs_power: i32 = lhs[2].parse().unwrap();
+        let rhs_power: i32 = rhs[2].parse().unwrap();
+        if lhs_power != rhs_power {
+            return lhs_power.cmp(&rhs_power);
+        }
+
+        let lhs_hand: Vec<i32> = lhs[0].chars().map(card_value_pt2).collect();
+        let rhs_hand: Vec<i32> = rhs[0].chars().map(card_value_pt2).collect();
+        for i in 0..5 {
+            if lhs_hand[i] == rhs_hand[i] { continue; }
+            return lhs_hand[i].cmp(&rhs_hand[i]);
+        }
+
+        panic!("Should not be reachable");
+    });
+
+
+    let mut total_winnings = 0;
+    for i in 0..input.len() {
+        let bid: usize = input[i][1].parse().unwrap();
+        total_winnings += (i + 1) * bid;
+    }
+
+    total_winnings
+}
+
+fn card_value_pt2(card: char) -> i32 {
+    match card {
+        'A' => 13,
+        'K' => 12,
+        'Q' => 11,
+        'T' => 10,
+        '9' => 9,
+        '8' => 8,
+        '7' => 7,
+        '6' => 6,
+        '5' => 5,
+        '4' => 4,
+        '3' => 3,
+        '2' => 2,
+        'J' => 1,
+        _ => panic!("invalid card")
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const EX: &str = r"32T3K 765
+T55J5 684
+KK677 28
+KTJJT 220
+QQQJA 483";
+
+    #[test]
+    fn part1_example() {
+        assert_eq!(part1(&parse(EX)), 6440);
+    }
+
+    #[test]
+    fn part2_example() {
+        assert_eq!(part2(&parse(EX)), 5905);
+    }
+}

src/lib.rs

@@ -1,3 +1,4 @@
+mod day7;
 mod day6;
 mod day5;
 mod day3;