From 3b14a8fe1c84459f22f27543bc01b82a6f20d29f Mon Sep 17 00:00:00 2001 From: nottu Date: Mon, 4 Dec 2023 11:33:46 -0800 Subject: [PATCH 1/5] Update day4.rs --- src/bin/day4.rs | 28 ++++++++++------------------ 1 file changed, 10 insertions(+), 18 deletions(-) diff --git a/src/bin/day4.rs b/src/bin/day4.rs index 5e05c9f..a04e593 100644 --- a/src/bin/day4.rs +++ b/src/bin/day4.rs @@ -34,28 +34,20 @@ fn parse_card(card: &str) -> usize { } fn get_card_matches(cards: &str) -> usize { - let cards = cards.split(':').nth(1).unwrap(); - let cards = cards.split('|').collect::>(); + let cards = cards.split(':').nth(1) + .expect("card should be formatted like 'Card : ', no ':' character found"); + .split('|').collect::>(); - // we assume card numbers can repeat themselves... - let mut right_side: HashMap<&str, usize> = HashMap::new(); - for num in cards[1].trim().split(' ') { - let num = num.trim(); - *right_side.entry(num).or_default() += 1; - } + let right_side: HashSet<&str> = cards.get(1) + .expect("card should have two sides separated by '|', no right side found") + .trim() + .split(' ').map(|num| num.trim()).collect; - cards[0] + cards.get(0) + .expect("card should have two sides separated by '|', no left side found") .trim() .split(' ') - .filter(|number| { - let curr_count = right_side.entry(number.trim()).or_default(); - if number.is_empty() || *curr_count == 0 { - false - } else { - *curr_count -= 1; - true - } - }) + .filter(|number| right_side.contins(number.trim())) .count() } From 2c60dff87f269585203af64ae50095353359ae6e Mon Sep 17 00:00:00 2001 From: nottu Date: Mon, 4 Dec 2023 20:07:35 -0800 Subject: [PATCH 2/5] day4: cards can't have duplicate numbers --- src/bin/day4.rs | 43 +++++++++++++++++++++++++++---------------- 1 file changed, 27 insertions(+), 16 deletions(-) diff --git a/src/bin/day4.rs b/src/bin/day4.rs index a04e593..4804042 100644 --- a/src/bin/day4.rs +++ b/src/bin/day4.rs @@ -1,4 +1,4 @@ -use std::collections::HashMap; +use std::collections::HashSet; fn main() { let input = include_str!("day4/input.txt"); @@ -34,21 +34,28 @@ fn parse_card(card: &str) -> usize { } fn get_card_matches(cards: &str) -> usize { - let cards = cards.split(':').nth(1) - .expect("card should be formatted like 'Card : ', no ':' character found"); - .split('|').collect::>(); + let cards = cards + .split(':') + .nth(1) + .expect("card should be formatted like 'Card : ', no ':' character found") + .split('|') + .collect::>(); - let right_side: HashSet<&str> = cards.get(1) - .expect("card should have two sides separated by '|', no right side found") + let right_side: HashSet<_> = cards[1] .trim() - .split(' ').map(|num| num.trim()).collect; + .split(' ') + .map(|num| num.trim()) + .filter(|num| !num.is_empty()) + .collect(); - cards.get(0) - .expect("card should have two sides separated by '|', no left side found") + let left_side: HashSet<_> = cards[0] .trim() .split(' ') - .filter(|number| right_side.contins(number.trim())) - .count() + .map(|num| num.trim()) + .filter(|num| !num.is_empty()) + .collect(); + + left_side.intersection(&right_side).count() } #[test] @@ -59,11 +66,15 @@ fn day4_test_part2() { fn part2(input: &str) -> String { let parse_cards: Vec<_> = input.lines().map(get_card_matches).collect(); - let mut parsed_cards_counts = vec![1; parse_cards.len()]; + let mut card_counter = vec![0; parse_cards.len() + 1]; + card_counter[0] = 1; + let mut count = 0; + let mut total_card_count = 0; for (idx, score) in parse_cards.into_iter().enumerate() { - for count_idx in 1..=score { - parsed_cards_counts[idx + count_idx] += parsed_cards_counts[idx]; - } + count += card_counter[idx]; + total_card_count += count; + card_counter[idx + 1] += count; + card_counter[idx + score + 1] -= count; } - parsed_cards_counts.iter().sum::().to_string() + total_card_count.to_string() } From e7cc3c86c6bb7a811137413226d9fe2ceccc80c3 Mon Sep 17 00:00:00 2001 From: nottu Date: Thu, 7 Dec 2023 17:57:47 -0800 Subject: [PATCH 3/5] day 5, 6 and 7 --- src/bin/day5.rs | 193 +++++++ src/bin/day5/input.txt | 187 +++++++ src/bin/day5/test_input.txt | 33 ++ src/bin/day6.rs | 121 +++++ src/bin/day6/input.txt | 2 + src/bin/day6/test_input.txt | 2 + src/bin/day7.rs | 183 +++++++ src/bin/day7/input.txt | 1000 +++++++++++++++++++++++++++++++++++ src/bin/day7/test_input.txt | 5 + 9 files changed, 1726 insertions(+) create mode 100644 src/bin/day5.rs create mode 100644 src/bin/day5/input.txt create mode 100644 src/bin/day5/test_input.txt create mode 100644 src/bin/day6.rs create mode 100644 src/bin/day6/input.txt create mode 100644 src/bin/day6/test_input.txt create mode 100644 src/bin/day7.rs create mode 100644 src/bin/day7/input.txt create mode 100644 src/bin/day7/test_input.txt diff --git a/src/bin/day5.rs b/src/bin/day5.rs new file mode 100644 index 0000000..af65962 --- /dev/null +++ b/src/bin/day5.rs @@ -0,0 +1,193 @@ +fn main() { + let input = include_str!("day5/input.txt"); + dbg!(part1(input)); + + let input = include_str!("day5/input.txt"); + dbg!(part2(input)); +} + +#[test] +fn day5_test_part1() { + let input = include_str!("day5/test_input.txt"); + assert_eq!(part1(input), "35") +} + +fn part1(input: &str) -> String { + let mut input_lines = input.lines(); + + let seeds: Vec = input_lines + .next() + .expect("at least one line") + .split(':') + .nth(1) + .unwrap() + .trim() + .split(' ') + .filter(|s| !s.is_empty()) + .map(|num| num.parse().unwrap()) + .collect(); + let maps = { + input_lines.next(); + let lines: Vec<&str> = input_lines.collect(); + let mut idx = 1; + let seed_soil_map = read_map(&lines[idx..]); + idx += 2 + seed_soil_map.len(); + let soil_fert_map = read_map(&lines[idx..]); + idx += 2 + soil_fert_map.len(); + let fert_water_map = read_map(&lines[idx..]); + idx += 2 + fert_water_map.len(); + let water_light_map = read_map(&lines[idx..]); + idx += 2 + water_light_map.len(); + let light_temp_map = read_map(&lines[idx..]); + idx += 2 + light_temp_map.len(); + let temp_humidity_map = read_map(&lines[idx..]); + idx += 2 + temp_humidity_map.len(); + let humidity_location_map = read_map(&lines[idx..]); + + [ + seed_soil_map, + soil_fert_map, + fert_water_map, + water_light_map, + light_temp_map, + temp_humidity_map, + humidity_location_map, + ] + }; + + seeds + .into_iter() + .map(|seed| { + // println!("_______________"); + maps.iter().fold(seed, |item, map_rels| { + // dbg!(map_rels, item); + let pp = map_rels.partition_point(|m| m.from <= item); + if pp == 0 { + item + } else { + let pp = pp - 1; + // dbg!(map_rels, pp); + let diff = item - map_rels[pp].from; + + // dbg!(item, mapped); + if diff + 1 > map_rels[pp].range { + item + } else { + diff + map_rels[pp].to + } + } + }) + }) + .min() + .unwrap() + .to_string() +} + +#[derive(Debug)] +struct MapRel { + to: u32, + from: u32, + range: u32, +} + +fn read_map(lines: &[&str]) -> Vec { + let mut compressed_map = vec![]; + for line in lines { + if line.is_empty() { + break; + } + let nums: Vec<_> = line.split(' ').map(|num| num.parse().unwrap()).collect(); + compressed_map.push(MapRel { + to: nums[0], + from: nums[1], + range: nums[2], + }); + } + compressed_map.sort_by_key(|m| m.from); + compressed_map +} + +#[test] +fn day5_test_part2() { + let input = include_str!("day5/test_input.txt"); + assert_eq!(part2(input), "46") +} + +fn part2(input: &str) -> String { + let mut input_lines = input.lines(); + + let seeds: Vec = input_lines + .next() + .expect("at least one line") + .split(':') + .nth(1) + .unwrap() + .trim() + .split(' ') + .filter(|s| !s.is_empty()) + .map(|num| num.parse().unwrap()) + .collect(); + let maps = { + input_lines.next(); + let lines: Vec<&str> = input_lines.collect(); + let mut idx = 1; + let seed_soil_map = read_map(&lines[idx..]); + idx += 2 + seed_soil_map.len(); + let soil_fert_map = read_map(&lines[idx..]); + idx += 2 + soil_fert_map.len(); + let fert_water_map = read_map(&lines[idx..]); + idx += 2 + fert_water_map.len(); + let water_light_map = read_map(&lines[idx..]); + idx += 2 + water_light_map.len(); + let light_temp_map = read_map(&lines[idx..]); + idx += 2 + light_temp_map.len(); + let temp_humidity_map = read_map(&lines[idx..]); + idx += 2 + temp_humidity_map.len(); + let humidity_location_map = read_map(&lines[idx..]); + + [ + seed_soil_map, + soil_fert_map, + fert_water_map, + water_light_map, + light_temp_map, + temp_humidity_map, + humidity_location_map, + ] + }; + + let mut curr_min = u32::MAX; + for idx in 0..seeds.len() / 2 { + let idx = 2 * idx; + let seed = seeds[idx]; + let range = seeds[idx + 1]; + curr_min = curr_min.min( + (0..range) + .map(|i| seed + i) + .map(|seed| { + // println!("_______________"); + maps.iter().fold(seed, |item, map_rels| { + // dbg!(map_rels, item); + let pp = map_rels.partition_point(|m| m.from <= item); + if pp == 0 { + item + } else { + let pp = pp - 1; + // dbg!(map_rels, pp); + let diff = item - map_rels[pp].from; + + // dbg!(item, mapped); + if diff + 1 > map_rels[pp].range { + item + } else { + diff + map_rels[pp].to + } + } + }) + }) + .min() + .unwrap(), + ); + } + curr_min.to_string() +} diff --git a/src/bin/day5/input.txt b/src/bin/day5/input.txt new file mode 100644 index 0000000..89be225 --- /dev/null +++ b/src/bin/day5/input.txt @@ -0,0 +1,187 @@ +seeds: 3121711159 166491471 3942191905 154855415 3423756552 210503354 2714499581 312077252 1371898531 165242002 752983293 93023991 3321707304 21275084 949929163 233055973 3626585 170407229 395618482 226312891 + +seed-to-soil map: +522866878 679694818 556344137 +1206934522 1236038955 57448427 +2572695651 3529213882 270580892 +1082547209 29063229 124387313 +2080101996 2392534586 180161065 +1079211015 153450542 3336194 +2466695431 2286534366 106000220 +1887791814 2094224184 192310182 +2843276543 2572695651 956518231 +2341707296 1887791814 124988135 +1264382949 156786736 473875833 +67220304 1331644457 455646574 +3903217571 3799794774 267521683 +2260263061 2012779949 81444235 +1738258782 630662569 49032249 +29063229 1293487382 38157075 +3799794774 4067316457 103422797 + +soil-to-fertilizer map: +69994133 1665188283 300635345 +0 1965823628 36826481 +2222587532 2553838094 476943506 +2929387922 3030781600 856348250 +4182440411 2441311209 112526885 +36826481 2002650109 33167652 +2044606970 4116986734 177980562 +1815516279 549395220 220301482 +1186435707 0 549395220 +916609638 1315676862 269826069 +3785736172 2044606970 396704239 +2699531038 3887129850 229856884 +1735830927 1585502931 79685352 +370629478 769696702 545980160 + +fertilizer-to-water map: +2485494684 3430237839 78539769 +2045426403 2253341567 99573285 +290571869 0 280695139 +3540352207 2045426403 63912525 +2879366909 3356847577 67075608 +868611408 858081124 224160766 +2304858397 2525185867 55003581 +189640733 280695139 100931136 +2144999688 3983682880 159858709 +3374818325 3858616265 14108175 +3604264732 2580189448 427645906 +1730244179 535856806 2894582 +4242091162 3634410314 52876134 +4031910638 3872724440 110958440 +1092772174 1116784935 90115688 +1182887862 381626275 154230531 +4149183732 3263940147 92907430 +4142869078 3423923185 6314654 +571267008 728392121 129689003 +3315918322 2352914852 58900003 +2359861978 3508777608 125632706 +2735364270 2109338928 144002639 +2946442517 2411814855 113371012 +1733138761 1082241890 34543045 +700956011 1600026409 167655397 +3059813529 3041876971 222063176 +2564034453 3687286448 171329817 +3281876705 3007835354 34041617 +0 538751388 189640733 +3388926500 4143541589 151425707 +1337118393 1206900623 393125786 + +water-to-light map: +66525849 932008802 34502691 +1231709999 161981088 108836128 +4050378444 3046032039 195065028 +1188304980 324179540 43405019 +0 95455239 66525849 +1134942656 270817216 53362324 +4015087939 2401779423 35290505 +3174436586 2144628864 257150559 +3688283374 3968162731 326804565 +101028540 367584559 564424243 +665452783 23428765 72026474 +2144628864 2437069928 302742058 +1340546127 0 23428765 +737479257 1714174561 397463399 +3431587145 2789335810 256696229 +4245443472 2739811986 49523824 +1363974892 966511493 747663068 +2447370922 3241097067 727065664 + +light-to-temperature map: +3188351957 4202865263 58820659 +583430260 717912118 192120954 +1044551258 2246397764 71032709 +3109547837 4261685922 33281374 +1678878772 1586709546 87694921 +1115583967 3604496785 152969541 +3142829211 2200875018 45522746 +2103724421 1412959073 173750473 +3094755823 2836912864 14792014 +4233716778 2851704878 61250518 +1809783323 3254776949 293941098 +570222212 2097755032 13208048 +34744215 693464 72237295 +1773265141 2502078476 36518182 +775551214 4072807084 98261716 +2718819720 511651563 117721319 +873812930 4171068800 31796463 +905609393 3933865219 138941865 +373474927 3892288779 41576440 +3040218555 3117948789 54537268 +2397118702 2538596658 1887839 +0 72930759 34744215 +2277474894 1316613368 93303271 +370955311 1409916639 2519616 +1359408316 3757466326 134822453 +2370778165 306806837 1167210 +220512052 1412436255 522818 +3335711852 1674404467 423350565 +335173455 2743397480 35781856 +3900016435 982913025 333700343 +2399006541 2540484497 202912983 +3816795945 2110963080 83220490 +415051367 910033072 72879953 +2663040982 3548718047 55778738 +3759062417 2779179336 57733528 +3247172616 629372882 88539236 +1494230769 2317430473 184648003 +1766573693 2194183570 6691448 +2601919524 245685379 61121458 +2371945375 220512052 25173327 +221034870 3003810204 114138585 +2836541039 307974047 203677516 +487931320 3172486057 82290892 +106981510 0 693464 +1268553508 2912955396 90854808 + +temperature-to-humidity map: +1844491325 2716144828 118858329 +1004942401 2971501799 229549152 +696973964 238546929 19842755 +716816719 119302258 119244671 +444146335 2339344684 80152617 +3752420807 853580623 112964826 +3736479208 2933101125 15941599 +1822411864 805752927 11014046 +3183816206 2835003157 98097968 +3538508914 2576089466 88076349 +1833425910 816766973 11065415 +3865385633 2664165815 51979013 +1706894195 1592117663 89769434 +2892814110 3354360228 291002096 +2450334080 3645362324 65003481 +3934652728 3721018678 66888233 +3285923313 2419497301 85776839 +3917364646 2257358228 17288082 +3371700152 2090549466 166808762 +524298952 633077915 172675012 +1600852292 966545449 106041903 +2283983708 620036820 13041095 +2176983704 2274646310 64698374 +2515337561 1072587352 32448957 +846714263 1105036309 42935019 +3719859664 603417276 16619544 +2547786518 258389684 345027592 +0 1147971328 444146335 +1963349654 3787906911 213634050 +836061390 3710365805 10652873 +889649282 0 115293119 +2241682078 1681887097 42301630 +3281914174 115293119 4009139 +2297024803 3201050951 153309277 +1796663629 827832388 25748235 +3626585263 2505274140 70815326 +1234491553 1724188727 366360739 +3697400589 2949042724 22459075 + +humidity-to-location map: +3693038281 1946208152 169064741 +3025397429 1673895501 272312651 +2522027478 1111558812 503369951 +3862103022 3729735566 432864274 +1111558812 2115272893 1374715990 +3356676818 3489988883 239746683 +3297710080 1614928763 58966738 +2486274802 4162599840 35752676 +3596423501 4198352516 96614780 diff --git a/src/bin/day5/test_input.txt b/src/bin/day5/test_input.txt new file mode 100644 index 0000000..f756727 --- /dev/null +++ b/src/bin/day5/test_input.txt @@ -0,0 +1,33 @@ +seeds: 79 14 55 13 + +seed-to-soil map: +50 98 2 +52 50 48 + +soil-to-fertilizer map: +0 15 37 +37 52 2 +39 0 15 + +fertilizer-to-water map: +49 53 8 +0 11 42 +42 0 7 +57 7 4 + +water-to-light map: +88 18 7 +18 25 70 + +light-to-temperature map: +45 77 23 +81 45 19 +68 64 13 + +temperature-to-humidity map: +0 69 1 +1 0 69 + +humidity-to-location map: +60 56 37 +56 93 4 diff --git a/src/bin/day6.rs b/src/bin/day6.rs new file mode 100644 index 0000000..0fbcb45 --- /dev/null +++ b/src/bin/day6.rs @@ -0,0 +1,121 @@ +fn main() { + let input = include_str!("day6/input.txt"); + dbg!(part1(input)); + + let input = include_str!("day6/input.txt"); + dbg!(part2(input)); +} + +#[test] +fn day6_test_part1() { + let input = include_str!("day6/test_input.txt"); + assert_eq!(part1(input), "288") +} + +struct RaceData { + time: i64, + distance: i64, +} + +fn parse_input(input: &str) -> Vec { + let input: Vec<&str> = input.lines().collect(); + let times = input[0] + .split(':') + .nth(1) + .unwrap() + .trim() + .split(' ') + .map(|times| times.trim()) + .filter(|s| !s.is_empty()) + .map(|s| s.parse().unwrap()); + let distance = input[1] + .split(':') + .nth(1) + .unwrap() + .trim() + .split(' ') + .map(|times| times.trim()) + .filter(|s| !s.is_empty()) + .map(|s| s.parse().unwrap()); + times + .zip(distance) + .map(|(time, distance)| RaceData { time, distance }) + .collect() +} + +fn part1(input: &str) -> String { + parse_input(input) + .into_iter() + .map(|race_data| win_ways(race_data.time, race_data.distance)) + .fold(0, |acc, x| { + dbg!(x); + if acc == 0 { + x + } else if x == 0 { + acc + } else { + acc * x + } + }) + .to_string() +} + +#[test] +fn day6_test_win_ways() { + let win_ways = win_ways(7, 9); + assert_eq!(win_ways, 4); +} + +fn win_ways(time: i64, distance: i64) -> i64 { + // (time - x) * x - distance = -x^2 + x*time - ditance + // same as solving := x^2 - x * time + distance + // a = 1 + // b = -time + // c = distance + let time = time as f64; + // add a small epsilon to ensure we get a larger distance + let distance = distance as f64 + 0.000000000001; + let sq_pt = ((time * time) - (4.0 * distance)).sqrt(); + let left_part = ((time - sq_pt) / 2.0).ceil() as i64; + let right_part = ((time + sq_pt) / 2.0).floor() as i64; + dbg!(left_part, right_part); + (left_part..=right_part).count() as i64 +} + +#[test] +fn day6_test_part2() { + let input = include_str!("day6/test_input.txt"); + assert_eq!(part2(input), "71503") +} + +fn part2(input: &str) -> String { + let race_data = parse_input2(input); + win_ways(race_data.time, race_data.distance).to_string() +} + +fn parse_input2(input: &str) -> RaceData { + let input: Vec<&str> = input.lines().collect(); + let time = input[0] + .split(':') + .nth(1) + .unwrap() + .trim() + .split(' ') + .map(|times| times.trim()) + .filter(|s| !s.is_empty()) + .collect::(); + let distance = input[1] + .split(':') + .nth(1) + .unwrap() + .trim() + .split(' ') + .map(|times| times.trim()) + .filter(|s| !s.is_empty()) + .collect::(); + dbg!(&time, &distance); + RaceData { + time: time.parse::().unwrap(), + distance: distance.parse::().unwrap(), + } +} diff --git a/src/bin/day6/input.txt b/src/bin/day6/input.txt new file mode 100644 index 0000000..973ba45 --- /dev/null +++ b/src/bin/day6/input.txt @@ -0,0 +1,2 @@ +Time: 47 70 75 66 +Distance: 282 1079 1147 1062 diff --git a/src/bin/day6/test_input.txt b/src/bin/day6/test_input.txt new file mode 100644 index 0000000..28f5ae9 --- /dev/null +++ b/src/bin/day6/test_input.txt @@ -0,0 +1,2 @@ +Time: 7 15 30 +Distance: 9 40 200 diff --git a/src/bin/day7.rs b/src/bin/day7.rs new file mode 100644 index 0000000..20a5565 --- /dev/null +++ b/src/bin/day7.rs @@ -0,0 +1,183 @@ +fn main() { + let input = include_str!("day7/input.txt"); + dbg!(part1(input)); + + let input = include_str!("day7/input.txt"); + dbg!(part2(input)); +} + +type Hand = [u8; 5]; + +#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)] +enum HandType { + Single, + Pair, + Three, + Four, + Five, +} + +impl HandType { + fn new(count: usize) -> Self { + match count { + 1 => Self::Single, + 2 => Self::Pair, + 3 => Self::Three, + 4 => Self::Four, + 5 => Self::Five, + n => { + dbg!(n); + panic!("you're not supposed to be here!") + } + } + } + fn next(self) -> Self { + match self { + HandType::Single => HandType::Pair, + HandType::Pair => HandType::Three, + HandType::Three => HandType::Four, + HandType::Four => HandType::Five, + HandType::Five => unreachable!(), + } + } +} + +impl From for usize { + fn from(value: HandType) -> Self { + match value { + HandType::Single => 1, + HandType::Pair => 2, + HandType::Three => 3, + HandType::Four => 4, + HandType::Five => 5, + } + } +} + +fn get_hand_types(hand: &Hand, use_jokers: bool) -> Vec { + println!("__________________"); + let mut counts = [0; 15]; + for card in hand { + counts[*card as usize] += 1; + } + let mut hands: Vec<_> = counts + .into_iter() + .enumerate() + .filter(|&(_idx, c)| c > 0) + .map(|(idx, c)| (idx, HandType::new(c))) + .collect(); + hands.sort_by_key(|(_idx, h)| h.to_owned()); + hands.reverse(); + + let Some(jokers) = hands.iter().find(|(idx, _)| *idx == 0) else { + return hands.into_iter().map(|(_idx, h)| h).collect(); + }; + if !use_jokers || hands.len() == 1 { + return hands.into_iter().map(|(_idx, h)| h).collect(); + } + + let mut final_hands: Vec<_> = hands + .iter() + .filter(|(idx, _h)| *idx != 0) + .map(|(_idx, h)| h.to_owned()) + .collect(); + let num_jokers: usize = jokers.1.into(); + dbg!(&hands, (jokers, num_jokers)); + for _ in 0..num_jokers { + final_hands[0] = final_hands[0].next(); + } + dbg!(final_hands) + // final_hands +} + +#[test] +fn day7_test_part1() { + let input = include_str!("day7/test_input.txt"); + assert_eq!(part1(input), "6440") +} + +fn part1(input: &str) -> String { + let hands = parse_input(input); + rank_hands(&hands, false) + .into_iter() + .sum::() + .to_string() +} + +fn rank_hands(hands: &[(Hand, u128)], use_jokers: bool) -> Vec { + let mut hands: Vec<_> = hands + .iter() + .map(|(hand, bid)| (hand, get_hand_types(hand, use_jokers), bid)) + .collect(); + hands.sort_by(|h1, h2| { + let (cards1, h1, _) = h1; + let mut h1 = h1.iter(); + let (cards2, h2, _) = h2; + let mut h2 = h2.iter(); + // println!("Comparing:\n\t{i} | Here h1: {h1:?}\t{j} | h2: {h2:?}"); + while let (Some(hand_type1), Some(hand_type2)) = (h1.next(), h2.next()) { + if hand_type1 == hand_type2 { + continue; + } + return hand_type1.cmp(hand_type2); + } + for (c1, c2) in cards1.iter().zip(cards2.iter()) { + if c1 == c2 { + continue; + } + return c1.cmp(c2); + } + println!("here h1: {h1:?}\th2: {h2:?}"); + std::cmp::Ordering::Equal + }); + hands + .iter() + .enumerate() + .map(|hand| dbg!(hand)) + .map(|(idx, hand_bid)| (idx as u128 + 1) * hand_bid.2) + .collect() +} + +fn parse_input(input: &str) -> Vec<(Hand, u128)> { + input + .lines() + .map(|line| { + let mut items = line.split(' '); + let hand = parse_hand(items.next().unwrap()); + let bid = items.next().unwrap().parse::().unwrap(); + (hand, bid) + }) + .collect() +} +fn parse_hand(input: &str) -> Hand { + let mut hand = Hand::default(); + input + .chars() + .map(|c| match c { + 'T' => 10, + 'J' => 0, + 'Q' => 12, + 'K' => 13, + 'A' => 14, + n => n as u8 - b'0', + }) + .enumerate() + .for_each(|(idx, n)| { + hand[idx] = n; + }); + hand +} + +#[test] +fn day7_test_part2() { + let input = include_str!("day7/test_input.txt"); + assert_eq!(part2(input), "5905") +} + +fn part2(input: &str) -> String { + let hands = parse_input(input); + rank_hands(&hands, true) + .into_iter() + .sum::() + .to_string() +} diff --git a/src/bin/day7/input.txt b/src/bin/day7/input.txt new file mode 100644 index 0000000..7d03f8f --- /dev/null +++ b/src/bin/day7/input.txt @@ -0,0 +1,1000 @@ +32555 626 +4558J 55 +62K22 775 +T7JJT 530 +K4333 992 +4T884 682 +42222 694 +22333 122 +367Q4 661 +552A5 435 +2K2K2 131 +22Q2Q 141 +9J2TT 623 +T8JTJ 677 +A4999 432 +QQJ8Q 338 +K49QT 244 +TK8Q2 584 +3T386 597 +6J69J 930 +4J935 495 +QKT3A 420 +JJJ8J 365 +222J2 375 +JKKKJ 733 +8KK8K 314 +QJ533 119 +666JJ 725 +AA9J7 543 +3QQQ3 80 +QJ777 891 +4J2JT 487 +688KQ 819 +9J999 809 +43524 706 +KK9JK 901 +99Q9T 657 +823T4 71 +73222 226 +45K24 143 +Q3986 453 +TTA94 884 +A455A 57 +A7777 697 +8267J 606 +999TT 612 +QJQQQ 620 +K5QJ7 235 +9Q5TK 67 +8Q8Q8 690 +75567 688 +3Q3Q7 662 +KA959 2 +J8888 51 +JKT6A 187 +KK73K 419 +79999 255 +2222K 643 +J5T79 107 +25K43 105 +5KKK4 166 +T8J53 848 +AA5A5 561 +8885Q 483 +A67A7 260 +JT433 329 +45J66 106 +3A2Q4 669 +99T9A 525 +87Q58 11 +J85TT 615 +Q99TA 617 +TTTJT 514 +8Q888 616 +6Q2A6 998 +9Q83A 441 +Q88A9 820 +8JK7A 20 +J2A2K 189 +398KT 121 +TQ7KA 283 +TT3T8 120 +2JJ23 962 +A3TAA 723 +QK999 264 +3Q323 402 +T353A 724 +54QQQ 407 +Q447K 959 +7TTTT 622 +J4344 683 +8TA65 468 +72T6J 965 +38777 410 +J63A9 110 +5K9KJ 60 +3TJK7 769 +A3TTT 520 +576J5 744 +62622 770 +T9965 560 +J3888 342 +66566 207 +33J6J 658 +85727 45 +75747 670 +46832 90 +TK9KT 578 +T7K5Q 362 +KK46J 254 +QJA7T 532 +28JKK 162 +754TK 14 +55757 169 +4Q8A6 534 +26J22 326 +5Q9QQ 216 +222Q7 294 +34333 102 +8258A 703 +555KK 720 +38882 98 +23322 360 +74786 824 +KKK8K 197 +J7778 450 +49499 21 +JK98Q 215 +4A358 649 +9AAAT 18 +8J882 989 +63T8T 188 +7T77T 430 +5725A 427 +57697 341 +57257 991 +44799 262 +AA8AA 818 +53553 3 +7979Q 702 +8K482 728 +29K63 828 +J32J9 947 +T5ATQ 220 +J2772 504 +KTK2T 994 +JJQ3T 630 +33338 480 +KQTT4 666 +32A33 866 +AAAAQ 705 +QQ42Q 524 +72473 312 +85T45 869 +9689J 349 +K53A5 286 +2993T 749 +992T9 541 +KTTK8 738 +96963 97 +AA5AA 178 +55T55 668 +38K62 734 +7Q44Q 776 +3T6JT 333 +JA5T8 421 +99459 94 +446QQ 841 +KKK7A 850 +98696 871 +KKT74 236 +6J528 438 +T3TTT 840 +424JJ 35 +K8J8K 7 +KJJ37 711 +Q35J8 567 +2A233 750 +A2Q4A 861 +3T779 851 +A9AKA 648 +92JK3 261 +A4J78 746 +479TQ 650 +55558 229 +43444 135 +QQAQ4 767 +Q2QQT 793 +J2232 977 +6TTJ6 485 +KTKA9 62 +77A57 1 +9757Q 129 +343TT 502 +K4JK9 914 +53395 529 +9TT9K 117 +K2A8T 747 +A3328 214 +767K7 296 +J6A66 853 +5Q6K4 842 +J2QA4 356 +64J28 681 +528T4 352 +8AAAT 972 +2KA97 636 +QQQQA 33 +2A84A 390 +QK7KK 42 +75832 440 +8TJ8T 788 +22725 31 +94T33 754 +49T29 588 +Q6Q55 73 +5T455 716 +T33J3 580 +5555J 388 +J5J22 306 +K3T9A 191 +55259 109 +J8T88 290 +85998 234 +J979J 583 +Q6739 637 +TK689 325 +85K5K 433 +5T45T 552 +J3636 155 +23623 673 +8T43K 685 +3Q3Q3 539 +Q7KAQ 642 +92JK9 172 +6666A 644 +2JQTQ 345 +88J86 241 +5JJAA 971 +8368J 790 +A8Q45 704 +TQ985 659 +2626J 517 +QQ3QQ 206 +A726A 507 +Q5A49 344 +44686 153 +795T8 816 +9T7Q6 13 +49448 209 +7J773 346 +TTK55 357 +64T94 736 +3A3AA 805 +53TJ3 228 +Q2999 452 +T22TT 412 +57777 921 +77737 66 +34437 559 +J5852 137 +Q8T8T 586 +6KJK6 880 +99994 331 +KKTTK 618 +628T7 935 +53792 386 +T776T 920 +88JJ8 147 +6Q96T 864 +222JJ 984 +89889 562 +AJKA9 221 +87A54 6 +QQ4Q4 765 +2QQQ2 904 +QQ3Q6 980 +KK4KK 339 +AA3AQ 899 +QQ4K6 878 +J4884 516 +4J232 379 +8786J 967 +8QTQT 478 +T7339 985 +2J442 482 +87444 508 +34443 151 +K8TQ7 233 +J6866 587 +3Q333 425 +QA88A 784 +KK4A7 679 +AAAKA 766 +7575K 595 +TTTTQ 868 +2AA22 125 +558T5 150 +TAJ8T 321 +665QQ 79 +8QTJ7 472 +A4555 22 +45345 491 +773A7 575 +J6T32 687 +9AAAA 813 +QKJTA 569 +K2TT3 897 +TTJT6 239 +56656 269 +55525 951 +339J3 745 +A7K62 845 +A6AAA 134 +8Q833 932 +A8A5A 185 +J233K 373 +TTK22 966 +4K884 303 +Q53QA 566 +J62J8 761 +9697Q 846 +79963 825 +6A53J 132 +KKK85 737 +TT7J7 167 +QKAAQ 10 +JQQAQ 464 +49624 950 +JK999 126 +7Q77Q 398 +T2JT5 934 +77J8J 127 +893TJ 610 +45994 772 +26656 808 +5333J 86 +K4J44 900 +58545 519 +5QQQ5 451 +TJJ22 50 +5JK68 763 +9KK74 505 +KQKJK 270 +67T66 52 +22226 56 +Q6Q45 603 +AA887 699 +A3249 237 +99455 912 +74974 814 +QQ4QQ 9 +J2535 351 +K7J75 640 +4577A 100 +5Q92T 212 +A6AAJ 639 +QA9AA 676 +7JK5J 996 +6QKK6 198 +792T6 242 +7AJ47 479 +JA787 854 +KKJKK 399 +94667 173 +A3AAA 624 +38A57 581 +KKKK5 47 +7QJ29 136 +K3333 232 +Q6T2K 671 +33A35 634 +AAK8K 544 +65792 481 +AKQT5 830 +A797T 292 +J3QQ4 324 +QKT65 510 +333J3 833 +52A2A 742 +KKKAK 952 +J5A64 651 +99925 183 +8A888 961 +A4Q5K 113 +2AJT9 515 +24424 811 +988J8 740 +T545Q 28 +AQ9K6 942 +93993 812 +KKT43 265 +JA494 322 +44TT5 332 +36TQJ 625 +45QTA 177 +9K9KK 406 +K6K5J 156 +46464 607 +763J3 509 +J9A4A 84 +33373 849 +6QJQQ 192 +55553 913 +22J72 789 +AKK5Q 512 +T3T33 865 +55QQ5 250 +TJK6T 533 +QTQK2 986 +87234 460 +7A772 499 +64666 165 +97777 528 +99Q9Q 874 +32A26 29 +3T33Q 258 +K4947 1000 +J73T8 318 +J9622 247 +TTTT8 909 +62662 768 +KAAAK 393 +K9555 573 +367A5 225 +33J34 847 +75898 954 +7KTJ5 91 +KTKQQ 473 +22T2T 783 +9J5A4 759 +57888 320 +647QQ 922 +2J798 963 +64K42 836 +49KK9 563 +842K4 12 +39793 551 +A4968 970 +22J2T 604 +33389 955 +75975 713 +K4KAT 905 +87TJ8 867 +97645 894 +6JQ9T 291 +4KK3K 308 +KTTJT 83 +98595 288 +3J5J3 918 +88K88 741 +5T7K9 678 +3AAJ3 656 +3QJ3J 523 +J754T 317 +5796K 732 +J3767 608 +723QJ 700 +K572T 335 +TTTQ5 859 +42J2A 781 +38666 358 +TATAT 334 +T7AAA 572 +AA793 227 +A7J88 708 +QJQQJ 448 +4K4AJ 540 +J5A5A 469 +243TT 27 +88T88 149 +T222K 739 +T463A 44 +6TTTT 911 +43QQQ 590 +94AAQ 834 +7Q7JJ 196 +83447 5 +99K8K 310 +6A42J 353 +29939 267 +78882 77 +QTT7T 557 +T3QTT 140 +3A3A3 794 +7A7AA 367 +899J9 542 +76822 810 +53345 602 +J6K7J 41 +TJ53A 442 +99977 821 +4J77T 138 +285TQ 488 +888KK 889 +5K255 513 +3T329 879 +J6Q3Q 101 +TQ457 37 +64898 337 +6A26A 78 +4J444 470 +TT555 461 +9K999 40 +TTAA2 758 +67J63 240 +8TTT7 64 +K6K74 748 +K2K2J 936 +82828 274 +A2TK7 890 +JJJ22 600 +4AJ3K 815 +299JJ 613 +Q7AJ9 359 +J4484 465 +ATTTT 152 +6385T 463 +65TK6 416 +654JT 200 +T4TTJ 553 +994J4 527 +TTJ4K 925 +7Q444 838 +3474J 547 +AAAAT 535 +339Q3 276 +37737 148 +7935A 837 +27A27 36 +77778 302 +KKK3K 459 +63388 284 +AAQQQ 680 +96A52 364 +JJJJJ 735 +7K523 752 +92K9K 799 +Q4346 391 +A6T2Q 298 +ATK99 281 +92T37 128 +39A93 593 +7TJTT 785 +89888 497 +8793J 518 +KK444 293 +TTQ65 176 +KKA3K 266 +TJ8A3 158 +787QK 195 +37332 903 +QQ89Q 719 +22232 614 +88284 190 +Q332Q 764 +K2252 795 +6QAA6 621 +69939 397 +JK42K 489 +J7KKK 978 +T5KTT 717 +555Q5 48 +88877 361 +62A9K 252 +79236 30 +6664Q 38 +43388 394 +95863 238 +QQAJA 522 +27KQ4 886 +8QKQA 411 +99A9A 946 +22236 164 +2Q6TQ 205 +228A2 46 +492J4 976 +TQJ53 49 +J6JA6 664 +K8A8A 492 +8T47K 454 +4AAKA 997 +8K596 248 +497QJ 787 +J4JA8 832 +T5687 888 +6T656 938 +3QK69 803 +73QT8 872 +A56K9 287 +8AA99 910 +JJ559 213 +JJQ34 347 +46462 852 +Q3Q8T 827 +Q838T 271 +KKAK6 133 +95953 413 +7T75J 663 +J69J2 437 +K9955 230 +K82KK 710 +KQTQ4 490 +994TJ 455 +58AJ2 186 +AA7A4 179 +QKK4K 124 +7658A 251 +5JQ52 987 +95Q6T 170 +KJ8J8 960 +78867 598 +KJ469 801 +9TTTT 15 +83A3Q 773 +9J496 555 +ATAAT 381 +525J2 201 +95777 674 +J97TK 59 +44454 712 +K333J 104 +3555J 953 +AJ32J 383 +4TK26 449 +384J6 692 +K7KKK 718 +AT3T9 157 +82J22 974 +2TTTT 23 +5Q7Q5 82 +68666 876 +4ATA4 596 +T9J99 343 +88A8K 937 +TT7T7 782 +Q4244 184 +385K7 693 +JJK53 993 +4K99A 61 +47467 654 +J6677 467 +5J443 313 +246AQ 69 +5A29J 594 +86586 401 +J2TJT 180 +44988 130 +5JJ52 571 +646J8 300 +4Q22Q 531 +4TQJQ 902 +68885 256 +5AA65 210 +9999Q 92 +KKKTK 395 +JT4A6 988 +5544K 295 +9T65J 444 +33743 305 +884T8 387 +93233 494 +96999 431 +K9J8J 990 +T7T54 249 +57555 503 +QK6K3 181 +8ATT8 751 +99J22 426 +AQ9QQ 548 +KAAKK 638 +A242K 791 +66755 870 +T4543 219 +Q4Q32 445 +8K492 585 +3J947 823 +Q42QA 24 +99399 369 +K55J8 755 +7J6J6 54 +AAK5A 817 +Q7QQQ 511 +67QQ3 896 +38TJ4 146 +62493 223 +TAAQT 929 +ATAT7 400 +43348 16 +QK495 589 +94T9Q 112 +5J55J 895 +45595 873 +J9JAJ 860 +A55QA 19 +T483T 641 +57T32 434 +264KA 475 +T3T55 304 +66J4J 779 +K6AQA 804 +TQQ5T 968 +77AAJ 259 +25258 627 +4AT6K 85 +79795 780 +J3364 632 +23KAT 418 +4QQTQ 4 +8KJ42 665 +Q4739 564 +75J2K 123 +29Q85 982 +2J5A2 116 +7Q777 979 +29J99 217 +7628A 72 +A84AK 297 +J4745 727 +K8TJ9 204 +QT246 199 +QQQJ7 486 +K2KKK 549 +QTTJ5 493 +JTJTT 257 +77K7K 160 +QQ44A 202 +Q7Q78 975 +27772 63 +72776 316 +2KK52 118 +37797 926 +7AQ25 949 +77J6Q 709 +KT539 753 +8QJQJ 368 +998J5 380 +7333J 372 +J8469 81 +7777J 299 +82773 698 +8Q8J5 655 +27TA5 74 +J2T2T 577 +T4444 506 +56A34 70 +52T52 378 +JT327 778 +622K6 280 +935Q6 919 +AA4A4 944 +22ATT 68 +5JQKQ 43 +98T68 862 +727JJ 65 +9KQ4K 958 +AJAA9 115 +J333Q 392 +J39J3 374 +TK33K 885 +49T38 500 +QA884 103 +9J9J4 633 +8AA86 163 +99995 645 +3K499 389 +33T33 999 +A4AAA 792 +3TQA8 945 +77776 915 +3A92Q 8 +J9K8K 53 +62666 653 +A3766 498 +9434J 301 +5ATAT 829 +56K28 882 +222Q2 285 +25K63 382 +AAQQA 646 +JK9JA 689 +K7K33 34 +78KKK 340 +J2QQ2 203 +84888 422 +84J46 757 +68878 599 +98989 777 +42K23 208 +67667 863 +33988 582 +52T8T 957 +T44Q4 981 +54632 429 +69332 628 +5JAA2 611 +4A4A4 652 +K3535 111 +5J4J5 786 +87JJ4 171 +K5KA5 969 +876K4 144 +KQKTT 396 +93839 743 +36K8K 175 +6J256 907 +AA9K6 417 +A4A47 892 +8T99T 537 +88788 328 +Q5QQQ 797 +ATJAQ 95 +999JJ 424 +Q3J64 931 +T4T4T 526 +TTJ38 336 +5K72A 730 +K77QK 218 +K44K2 917 +64AAA 58 +66ATT 591 +AQA8K 576 +TT75K 423 +68J7T 721 +T8K8K 96 +777JJ 771 +QJ5Q5 635 +4966K 275 +JT836 898 +4TTTA 99 +QTTQQ 282 +55656 943 +22454 458 +99868 883 +J55AT 501 +K8992 279 +2244T 558 +66667 174 +49943 246 +328T8 385 +995JA 311 +AQ5J9 629 +A8AA8 906 +J5K65 796 +62QKK 835 +3A35A 93 +66T66 222 +3J633 414 +6JKK2 731 +8AAJK 538 +5J335 354 +29932 550 +K5QQ5 278 +83383 928 +A4T9Q 684 +AAJAA 88 +6T22A 142 +22228 428 +6234Q 268 +639K5 476 +T622T 887 +68662 471 +K36A9 715 +52245 858 +J444J 462 +A2J9K 701 +4J74K 194 +6KKK9 330 +JJK38 277 +ATAKT 17 +7896Q 404 +8K7K7 243 +43324 802 +4485Q 844 +4K9Q4 760 +342J3 983 +J888A 881 +A8KQJ 660 +QQ4Q7 756 +AAAA2 807 +AT368 75 +6TKTT 521 +8KJ29 253 +94JT5 822 +53335 108 +4AQJQ 139 +K4K34 916 +K44JK 370 +A3333 327 +K938A 415 +88AA3 466 +3QKJ9 87 +7TJQT 855 +67763 26 +325Q8 371 +K2KK2 826 +22QQ8 263 +4Q33Q 798 +6358K 231 +A6AA6 806 +22J78 315 +J2845 211 +K36AQ 408 +84Q48 319 +89878 956 +K69J2 403 +564KA 436 +49292 154 +7629A 939 +J4999 631 +3T7T7 574 +6T3T6 893 +555JK 579 +J7538 592 +A5A58 875 +J7898 456 +5JT5T 457 +45JK3 159 +6T3T9 536 +87778 774 +433J4 877 +8T599 570 +QJ632 89 +4J222 477 +TTK8T 839 +96996 601 +3KJ3K 446 +943T7 545 +KK3JQ 973 +A37T2 25 +J6666 355 +Q4775 908 +66KK2 726 +93956 933 +5JJ35 667 +44994 474 +T8J69 161 +TJ5Q2 289 +4Q44Q 447 +Q7A69 647 +5T5TT 273 +J5KKQ 484 +24422 409 +TQK76 377 +KKK66 800 +QKKQA 384 +KKKA4 565 +J779J 691 +76566 307 +2J2Q6 941 +8A568 309 +94AA5 856 +J247J 696 +99QQJ 995 +43339 964 +5AJ6K 729 +J67KQ 376 +4454Q 672 +KT6A7 843 +QT7Q8 443 +TQQ4T 363 +54548 323 +3K8QK 940 +34777 76 +327T8 405 +92929 927 +27793 546 +9T27Q 924 +QKJ8K 32 +52225 923 +3T242 366 +86A46 568 +J9796 39 +77A7A 145 +KKKT6 722 +TQQQQ 182 +JQJJQ 948 +54622 556 +92889 224 +44666 193 +TAATJ 686 +22292 619 +K2853 714 +A9A9A 857 +38783 348 +35874 439 +29TJQ 605 +A5992 695 +4TTT9 168 +77474 272 +3ATTJ 245 +37TA6 496 +A5A55 707 +564A8 554 +48J5Q 831 +28K28 350 +84484 762 +3A337 114 +A33J3 675 +5T694 609 diff --git a/src/bin/day7/test_input.txt b/src/bin/day7/test_input.txt new file mode 100644 index 0000000..e3500c3 --- /dev/null +++ b/src/bin/day7/test_input.txt @@ -0,0 +1,5 @@ +32T3K 765 +T55J5 684 +KK677 28 +KTJJT 220 +QQQJA 483 From 474bce13c4d645c533e381ea4b042225dabe2842 Mon Sep 17 00:00:00 2001 From: nottu Date: Thu, 7 Dec 2023 22:10:11 -0800 Subject: [PATCH 4/5] day 8 --- src/bin/day8.rs | 139 ++++++ src/bin/day8/input.txt | 796 +++++++++++++++++++++++++++++++++++ src/bin/day8/test_input.txt | 9 + src/bin/day8/test_input2.txt | 5 + src/bin/day8/test_input3.txt | 10 + 5 files changed, 959 insertions(+) create mode 100644 src/bin/day8.rs create mode 100644 src/bin/day8/input.txt create mode 100644 src/bin/day8/test_input.txt create mode 100644 src/bin/day8/test_input2.txt create mode 100644 src/bin/day8/test_input3.txt diff --git a/src/bin/day8.rs b/src/bin/day8.rs new file mode 100644 index 0000000..12eef05 --- /dev/null +++ b/src/bin/day8.rs @@ -0,0 +1,139 @@ +use std::collections::HashMap; + +fn main() { + let input = include_str!("day8/input.txt"); + dbg!(part1(input)); + + let input = include_str!("day8/input.txt"); + dbg!(part2(input)); +} + +#[test] +fn day8_test_part1() { + let input = include_str!("day8/test_input.txt"); + assert_eq!(part1(input), "2"); + + let input = include_str!("day8/test_input2.txt"); + assert_eq!(part1(input), "6"); +} + +fn part1(input: &str) -> String { + let (directions, map) = parse_input(input); + let num_directions = directions.len(); + let mut curr_node = "AAA".to_string(); + let goal_node = "ZZZ".to_string(); + + let mut step_count = 0; + while curr_node != goal_node { + let next_dirs = &map[&curr_node]; + curr_node = match directions[step_count % num_directions] { + Direction::Left => &next_dirs.left, + Direction::Right => &next_dirs.right, + } + .to_string(); + step_count += 1; + } + + step_count.to_string() +} + +#[derive(Debug)] +struct Node { + left: String, + right: String, +} + +#[derive(Debug, PartialEq, Eq)] +enum Direction { + Left, + Right, +} + +impl From for Direction { + fn from(value: char) -> Self { + match value { + 'R' => Self::Right, + 'L' => Self::Left, + _ => panic!("???"), + } + } +} + +fn parse_input(input: &str) -> (Vec, HashMap) { + let mut input_lines = input.lines(); + let directions: Vec = input_lines + .next() + .unwrap() + .chars() + .map(Direction::from) + .collect(); + // one empty line + input_lines.next(); + // parse nodes + let node_data = input_lines.map(|l| { + let mut node = l.split('=').map(|i| i.trim()); + let node_name = node.next().unwrap(); + let next_nodes = node.next().unwrap().replace(['(', ')'], ""); + let next_nodes: Vec<_> = next_nodes.split(',').map(|n| n.trim()).collect(); + ( + node_name.to_owned(), + next_nodes[0].to_owned(), + next_nodes[1].to_owned(), + ) + }); + let mut node_map = HashMap::new(); + for data in node_data { + node_map.insert( + data.0.to_owned(), + Node { + left: data.1, + right: data.2, + }, + ); + } + (directions, node_map) +} + +#[test] +fn day8_test_part2() { + let input = include_str!("day8/test_input3.txt"); + assert_eq!(part2(input), "6") +} + +fn part2(input: &str) -> String { + let (directions, map) = parse_input(input); + let curr_nodes: Vec = map + .keys() + .filter(|k| k.ends_with('A')) + .map(|n| n.to_owned()) + .collect(); + + dbg!(&curr_nodes); + + curr_nodes + .into_iter() + .map(|n| get_steps(n, &map, &directions)) + .fold(1, num::integer::lcm) + .to_string() +} + +fn get_steps( + mut curr_node: String, + map: &HashMap, + directions: &Vec, +) -> usize { + let mut step_count = 0; + let num_directions = directions.len(); + + while !curr_node.ends_with('Z') { + let next_dirs = &map[&curr_node]; + curr_node = match directions[step_count % num_directions] { + Direction::Left => &next_dirs.left, + Direction::Right => &next_dirs.right, + } + .to_string(); + step_count += 1; + } + + step_count +} diff --git a/src/bin/day8/input.txt b/src/bin/day8/input.txt new file mode 100644 index 0000000..2937e6c --- /dev/null +++ b/src/bin/day8/input.txt @@ -0,0 +1,796 @@ +LLRLRRLLRLRRLLRLRRLRRRLRLRLRRRLLRLRRRLRLRRRLRLRLLLRRLRLRLLRLRRLRRRLRRRLLRRLRLRRRLRRLRRRLRLLRRLRRRLRRRLRRLRLRRLLLRLRLLRRRLRRLLRLRLRRLLRLRRLLRLRRLRRLLRRRLRLRLRRRLLRRRLRRLRRRLRRRLRLRRRLRRLLLRRRLRLLLRRRLRLLRLLRRRLLRRLRRRLRRRLRLLRLRLRRRLLRRLRRRLRRLRLLRRRLRRLRRRLRRRLRRRLRLRRRLRRRLRLRRRR + +XGS = (FDM, XCS) +PJD = (XJN, PCV) +FLJ = (VRH, NBF) +RXS = (DNN, DHH) +DQD = (NTV, CRQ) +HGJ = (QJF, JTK) +JDL = (QHC, TKN) +VMX = (DVX, KDB) +SPX = (FMD, MQS) +DSQ = (BNF, PDJ) +XJQ = (QST, MFT) +BGX = (MSH, JQQ) +CMT = (FSP, SCN) +BVV = (LPL, LPL) +MBR = (BHB, RMB) +VVP = (QTP, TJC) +BFC = (SMR, SMR) +DTN = (CMN, NVG) +BVN = (BKM, KPN) +BCR = (MHM, MPT) +NDK = (NHG, RVN) +FRR = (NKL, KKN) +XDP = (GBQ, VGF) +KCS = (CXN, GGR) +HLG = (FMQ, NXV) +MTP = (KFV, QCH) +VFH = (GPQ, RFK) +HSG = (JKV, KNK) +THL = (CPG, BBF) +FJP = (CVM, BVF) +TGR = (LNL, JGD) +JJD = (QLT, QMC) +DQK = (NDK, NFS) +KFN = (PJK, XSJ) +QLN = (NKV, MGT) +GJR = (HBJ, HLG) +JXD = (NFK, KMD) +CGM = (QHF, PJR) +FPM = (DHB, VBS) +NMK = (MVX, MFM) +SJQ = (VBD, GKP) +XVX = (KCS, TNV) +FNC = (BCR, LQB) +KLA = (XKM, DNG) +CHD = (TPM, BHH) +RMV = (PBC, QPM) +BXH = (QDC, LKX) +VQK = (HRJ, LBX) +VNR = (SDB, JQL) +TQS = (JPX, NLL) +RPK = (KTX, XKP) +AAA = (XMG, HJX) +NQS = (TGB, RDK) +JKK = (SFX, VDH) +DKM = (RXJ, DXF) +VGF = (MXT, LKT) +KQN = (KTG, NCT) +MXV = (HFT, QJM) +CKP = (FMC, JPT) +HGP = (JMV, DXV) +VRC = (NVR, NHK) +DPR = (VBV, FLJ) +VBL = (PXB, BVN) +GSG = (KSL, VSX) +FNK = (VPD, NKN) +LVB = (SQB, SQB) +PRF = (HNP, TDG) +TGV = (NVR, NHK) +DXV = (QNK, PKL) +KMP = (KVB, VMR) +BTR = (LKF, PJD) +QHC = (DFT, DTJ) +RXM = (LRG, NPH) +KTX = (RFR, QRT) +JHR = (BRV, QRB) +JDH = (BFX, DTN) +JLQ = (TTV, GKH) +CMQ = (HQL, PJP) +DJF = (JTK, QJF) +KVB = (MXL, PTK) +DMD = (HXP, ZZZ) +XJV = (CRV, JLM) +JXR = (JMQ, LQM) +DFT = (DRN, JQM) +JSC = (XFX, XFX) +CKB = (VVK, XBK) +RFJ = (CKP, QMH) +HRP = (LQT, CJV) +HXJ = (CKB, FCT) +DMX = (CRV, JLM) +XBK = (LVB, FXN) +JVP = (SKF, LCK) +JLV = (VPT, DMK) +SXK = (TNR, MTF) +DTJ = (JQM, DRN) +KLN = (FDX, NPN) +SKG = (BTR, HXG) +RFR = (XCT, FHN) +FKB = (JJL, CGM) +HNP = (DKR, JLQ) +HKC = (FDM, XCS) +QQN = (MTP, DCG) +QRX = (RPJ, PQM) +SMD = (BBD, DSQ) +SFJ = (JMR, JMR) +CJZ = (QMH, CKP) +PGB = (SDJ, LQF) +CMS = (XSG, TFG) +JMV = (PKL, QNK) +GHH = (RHT, RXS) +NLN = (XJX, MVC) +RCG = (DCG, MTP) +XHF = (SSF, CBS) +PNC = (GPB, MJJ) +RXC = (XHF, LDN) +XVM = (NKR, KQG) +MTF = (FKN, FKV) +FGM = (JPJ, DFG) +MTG = (RRX, FFL) +HCC = (RFS, PBH) +TJL = (RPJ, PQM) +RDK = (RLT, MMJ) +CSD = (MDQ, HSG) +KVP = (VRC, TGV) +QJM = (LSF, DQK) +TTV = (RCC, LXJ) +TJC = (RDG, LFV) +BFS = (FFL, RRX) +BRV = (NRJ, HCN) +HXP = (XMG, HJX) +NJK = (MJT, GBX) +DGV = (NDH, DPB) +RGD = (KBH, XDP) +CRV = (QBD, QLJ) +RPS = (LPH, PRR) +PLF = (BHH, TPM) +SJF = (LFB, NMD) +HLQ = (XJX, MVC) +SJR = (XKM, DNG) +TQP = (BTG, QJG) +MTJ = (JPJ, DFG) +SQB = (RFJ, RFJ) +KPN = (VTC, LDH) +BDZ = (CQP, HRP) +QFC = (XJQ, PMR) +XMV = (HTS, RXT) +MQS = (FXV, VCL) +TLQ = (XMV, TSC) +TCQ = (CXH, RCV) +KNK = (CBD, VQK) +GHD = (DBJ, VPK) +TKP = (TXK, MPJ) +CCC = (NKL, KKN) +QFN = (TJD, JDJ) +DVJ = (GQM, QKJ) +TNC = (PVV, PMJ) +HJX = (DQD, JDR) +NFF = (JMR, GTZ) +JSB = (SLS, HSC) +NVR = (CTV, PNS) +FNV = (XLK, FNC) +JVR = (TGB, RDK) +TXM = (SNN, DMZ) +CNF = (KLN, BDB) +QRG = (PDS, MHP) +QVV = (JJD, RLL) +XML = (VMR, KVB) +TLB = (NTD, VKD) +SDJ = (CNQ, FNV) +TKN = (DTJ, DFT) +HFK = (LPF, XPH) +LJP = (SFJ, SFJ) +SMX = (RQV, DDH) +JBL = (XML, KMP) +NDA = (PBF, FHP) +LRP = (XKP, KTX) +JCK = (BGC, CNF) +XCF = (SPJ, CVR) +VNV = (CMQ, JPQ) +BPJ = (XVP, DXQ) +MVC = (QFC, DLV) +QRK = (SDJ, LQF) +BFX = (CMN, NVG) +JMQ = (MFC, RXD) +JPQ = (PJP, HQL) +FCN = (NPH, LRG) +RXQ = (FMG, GJF) +DVX = (GSS, CFM) +CSH = (VQF, PTV) +STM = (CFH, BMQ) +NVF = (CSH, VHC) +CKG = (VSX, KSL) +BLG = (QHJ, DLB) +RCB = (VVX, XCF) +MGX = (HGT, HGP) +NVG = (KMC, VSM) +JLM = (QBD, QLJ) +NKR = (HCD, RQC) +QKJ = (VXK, TRR) +XSJ = (TCQ, PCL) +HQP = (HSJ, DGV) +NPQ = (RBR, FNB) +DDH = (PTQ, KQN) +KTG = (DHL, KSX) +MHP = (FCX, VCB) +LBA = (CKP, QMH) +GBX = (DLC, JRX) +TKX = (RNJ, PPC) +FHK = (KCV, NBK) +CJV = (RCG, QQN) +PPC = (JDH, SBM) +KKN = (KVP, HBC) +HBT = (XDM, PGN) +CNC = (FVV, TCX) +MXL = (BMP, BPJ) +XVP = (TRL, HVN) +XLX = (JSK, KNX) +FCT = (VVK, XBK) +CFH = (VRX, XMK) +TNV = (CXN, GGR) +JHK = (VQR, LDL) +JPJ = (JBL, NBC) +TNR = (FKV, FKN) +RXJ = (SKG, BFK) +QDV = (RHT, RXS) +QQQ = (XHH, JVP) +HGS = (MFV, DKC) +NBK = (LNV, QLN) +LDL = (CRJ, PRF) +JRL = (KJS, PVK) +FXR = (HCS, CMT) +NVX = (GJR, GTQ) +CFM = (SMT, SXK) +TFG = (SPN, TLF) +PPF = (KJN, NXJ) +VPV = (HQP, KRB) +MGT = (TJL, QRX) +LGB = (KBH, XDP) +BNS = (CTP, CBL) +KSX = (BFS, MTG) +GDD = (NBP, STP) +CJQ = (VHM, JNQ) +GQC = (NTD, VKD) +FMC = (SKX, LRF) +PTQ = (KTG, NCT) +KNG = (BRV, QRB) +KQG = (RQC, HCD) +NSG = (HXJ, LBP) +QPM = (KPK, XVX) +CXH = (LGS, LQR) +LCF = (GBS, MHB) +VBD = (MBR, NBJ) +SDB = (SVM, JJM) +DCR = (FVK, KGG) +BDJ = (XRG, CQL) +JMR = (VRM, NFN) +XFR = (LQM, JMQ) +MBP = (CBL, CTP) +GVD = (CLB, FMF) +MFH = (PPC, RNJ) +PTK = (BMP, BPJ) +LGJ = (PXP, HJK) +GKP = (MBR, NBJ) +HXG = (LKF, PJD) +NBC = (XML, KMP) +SJG = (LPF, XPH) +BKM = (VTC, LDH) +DKC = (NQS, JVR) +JSJ = (TQP, RLR) +PMR = (QST, MFT) +BRM = (PRR, LPH) +KRL = (BGX, XNX) +TCX = (GQC, TLB) +QLJ = (FPS, JFN) +HCD = (FXR, PJJ) +TBN = (DSJ, VPV) +FFL = (NBB, FKB) +GRN = (HCC, NJF) +LQB = (MHM, MPT) +SFX = (LGB, RGD) +HJB = (VNR, KFT) +HRJ = (GLC, CHR) +MJT = (DLC, JRX) +FHN = (HHG, RMV) +VTJ = (BFC, JTL) +CQP = (CJV, LQT) +VCB = (NGR, JRL) +VNN = (JKK, SCK) +XNT = (RXQ, LJS) +SCN = (TNC, LGP) +FMF = (TKP, NNT) +VSM = (HNF, RLF) +CNQ = (FNC, XLK) +MPT = (TLQ, SBG) +DSJ = (KRB, HQP) +CXV = (QRK, PGB) +LBX = (GLC, CHR) +VBV = (NBF, VRH) +TJQ = (LCH, HTJ) +CPG = (QVC, CJQ) +KJN = (PLB, DGH) +NCM = (VTJ, SXJ) +FXV = (NCM, SDH) +XRG = (DPR, MXD) +LCM = (PMN, VCS) +SHN = (SMK, PHG) +MXD = (FLJ, VBV) +FDJ = (LKV, BKX) +JDR = (NTV, CRQ) +XDR = (LPV, XTH) +RNJ = (JDH, SBM) +FHP = (MGQ, HJB) +PVH = (GPQ, GPQ) +MGM = (RBS, HPR) +VFQ = (RBR, FNB) +XRV = (LCH, HTJ) +DGP = (FDJ, GTJ) +HJV = (DHB, VBS) +KPK = (TNV, KCS) +CMX = (DBJ, VPK) +BHH = (VRN, SMX) +PJL = (NLS, SCL) +SPJ = (RXM, FCN) +NTV = (TSJ, BSR) +FXN = (SQB, GLR) +DTK = (VVP, TCD) +DBJ = (MFH, TKX) +DCJ = (BTP, GVD) +NMD = (DJB, MGC) +PBC = (XVX, KPK) +FRS = (KMD, NFK) +LNL = (SQC, DTK) +NGH = (XKL, HPT) +RFS = (CHD, PLF) +DMK = (JJT, FHK) +SNS = (SHN, BMD) +RLR = (BTG, QJG) +FDM = (GRN, CBK) +PLB = (CCT, JTT) +VTC = (CMS, XSC) +XKM = (QGF, TBN) +MVJ = (SLB, TXM) +PKL = (CSQ, SJQ) +SLB = (SNN, SNN) +JKV = (VQK, CBD) +BBD = (BNF, PDJ) +GSS = (SXK, SMT) +LRG = (SPB, TGR) +FDN = (JXD, FRS) +XKX = (HXC, PGT) +PDJ = (FRR, CCC) +HXM = (VNN, VJG) +QMC = (CXV, TLH) +GLG = (GGV, VBL) +RXT = (LCF, GBT) +TGL = (NXJ, KJN) +JPT = (SKX, LRF) +NLL = (SPX, DDQ) +BHB = (RGP, FQL) +XKN = (HBT, XXG) +RLT = (JLB, BDJ) +SHF = (HGP, HGT) +HKV = (DLB, QHJ) +SVM = (XDR, BLN) +PMN = (QTL, QRG) +CXN = (JLV, FMT) +GQV = (PJK, XSJ) +HMM = (MGX, SHF) +VSC = (PDH, XVM) +LCK = (NSG, JPR) +JQL = (JJM, SVM) +FRQ = (SVG, DCR) +TDG = (JLQ, DKR) +SMT = (TNR, MTF) +GBT = (GBS, MHB) +QMH = (JPT, FMC) +DXJ = (CMQ, JPQ) +JJM = (XDR, BLN) +DDQ = (FMD, MQS) +NDH = (VVQ, DCM) +LSF = (NFS, NDK) +VGM = (STS, XNT) +PJR = (GXF, JDL) +XFC = (XVM, PDH) +LBP = (CKB, FCT) +KFT = (SDB, JQL) +TTT = (QLS, GCV) +LPH = (SJF, BPT) +JGS = (XKL, HPT) +VDH = (LGB, RGD) +VHC = (VQF, PTV) +NKN = (GDD, XDC) +RND = (VGM, PSD) +QVC = (VHM, JNQ) +JJL = (QHF, PJR) +QRB = (NRJ, HCN) +MJJ = (FQT, RXC) +NNA = (HRP, CQP) +PBF = (MGQ, HJB) +VRT = (DSS, FDN) +DCM = (CLV, JCK) +QLS = (SJR, SJR) +RMT = (XHH, JVP) +DMR = (MLF, MVJ) +QJG = (NLN, HLQ) +DLV = (XJQ, PMR) +LKF = (XJN, PCV) +VQR = (PRF, CRJ) +SXJ = (BFC, JTL) +MDQ = (KNK, JKV) +QVD = (BVF, CVM) +TGG = (LPL, BDZ) +HDJ = (HGB, HSH) +HTT = (LHQ, HGS) +SKX = (HXM, JMF) +FCX = (NGR, JRL) +HSJ = (NDH, DPB) +BFK = (HXG, BTR) +XSG = (SPN, TLF) +NCD = (MFM, MVX) +PHG = (BKS, SMD) +XMK = (QVD, FJP) +FXL = (PGT, HXC) +KBH = (VGF, GBQ) +CBG = (QDC, LKX) +LDN = (SSF, CBS) +SVG = (FVK, KGG) +BVF = (GHH, QDV) +SPB = (LNL, JGD) +LQR = (QXX, LCM) +KHV = (JSK, KNX) +LFV = (XFJ, XKN) +QHG = (JJD, RLL) +HGB = (LRP, RPK) +NRJ = (DXJ, VNV) +LKT = (PNC, LJX) +MSH = (CDN, DMS) +MLF = (SLB, SLB) +MMJ = (JLB, BDJ) +VRM = (HSR, HTT) +MHM = (TLQ, SBG) +LRF = (HXM, JMF) +VHM = (PVH, VFH) +FQL = (XRV, TJQ) +MPJ = (LFS, CFJ) +LMF = (CNC, KCC) +JTK = (XJR, DGP) +HFT = (DQK, LSF) +RQV = (PTQ, KQN) +LDT = (BMQ, CFH) +RGP = (TJQ, XRV) +SDH = (VTJ, SXJ) +LKV = (JVB, TFD) +KDD = (XFX, XGV) +CVM = (GHH, QDV) +PLS = (DVX, KDB) +VCL = (NCM, SDH) +SCK = (SFX, VDH) +LJX = (MJJ, GPB) +JTT = (LMF, SVS) +PHV = (KRL, SVD) +PDS = (VCB, FCX) +VPD = (XDC, GDD) +VRJ = (HXP, HXP) +LPV = (HKC, XGS) +BDB = (FDX, NPN) +DXF = (BFK, SKG) +FMG = (JGS, NGH) +NXV = (LJP, SBT) +PQM = (QVV, QHG) +SNN = (PBF, FHP) +LGP = (PMJ, PVV) +FKV = (CBG, BXH) +VJG = (JKK, SCK) +JPR = (HXJ, LBP) +TPM = (SMX, VRN) +KXT = (VQR, LDL) +NPN = (FRQ, SRD) +TRL = (DCJ, BLS) +CBK = (NJF, HCC) +KMD = (GQV, KFN) +GQM = (TRR, VXK) +QST = (RMT, QQQ) +XDM = (KXT, JHK) +TLH = (QRK, PGB) +VRH = (BNS, MBP) +VVK = (LVB, LVB) +HVN = (BLS, DCJ) +TLJ = (HSG, MDQ) +QLQ = (STM, LDT) +LKX = (DBT, XTS) +VXK = (DKM, KKV) +XKL = (NPQ, VFQ) +LDP = (BPH, RCB) +VRN = (RQV, DDH) +LJS = (FMG, GJF) +FMT = (DMK, VPT) +BPT = (LFB, NMD) +RLL = (QMC, QLT) +JNQ = (PVH, VFH) +HJK = (JSC, KDD) +QHF = (JDL, GXF) +DGH = (JTT, CCT) +PVV = (RND, XCQ) +XFX = (VRJ, VRJ) +NRN = (GQM, QKJ) +VPK = (TKX, MFH) +GLC = (PPF, TGL) +JJT = (KCV, NBK) +FVK = (XQS, PJL) +VRD = (RCB, BPH) +GPQ = (BVV, BVV) +XCT = (HHG, RMV) +VMR = (PTK, MXL) +NTD = (XJV, DMX) +CBS = (GHD, CMX) +SNZ = (DNG, XKM) +QTP = (LFV, RDG) +DMZ = (FHP, PBF) +LQT = (RCG, QQN) +FPS = (RBX, DMR) +LGS = (LCM, QXX) +ZZZ = (HJX, XMG) +RCV = (LQR, LGS) +PBH = (CHD, PLF) +JPX = (DDQ, SPX) +DNN = (MXV, DVB) +QRT = (XCT, FHN) +HHG = (PBC, QPM) +SBM = (BFX, DTN) +JVB = (VSC, XFC) +QNK = (CSQ, SJQ) +BPM = (KNG, JHR) +HBC = (TGV, VRC) +MGQ = (VNR, KFT) +BTP = (CLB, FMF) +SVD = (BGX, XNX) +RHT = (DHH, DNN) +KJS = (FRN, JSB) +BLS = (GVD, BTP) +TJD = (JXR, XFR) +RMS = (HJV, FPM) +MFV = (JVR, NQS) +DXQ = (HVN, TRL) +HSC = (BRM, RPS) +CCP = (GGV, VBL) +GTB = (QKQ, PHV) +RBX = (MLF, MLF) +MDN = (GBX, MJT) +HXC = (KPF, DJL) +HSR = (HGS, LHQ) +BMD = (PHG, SMK) +GTZ = (NFN, VRM) +LDH = (CMS, XSC) +NXJ = (PLB, DGH) +FGR = (GJR, GTQ) +KKV = (RXJ, DXF) +XCQ = (PSD, VGM) +JQQ = (DMS, CDN) +XCS = (GRN, CBK) +JQM = (FNK, DKQ) +DNG = (QGF, TBN) +GBQ = (MXT, LKT) +QLT = (TLH, CXV) +HTL = (NLL, JPX) +DLB = (VRF, THL) +GTQ = (HBJ, HLG) +NBB = (CGM, JJL) +GPB = (FQT, RXC) +QBD = (FPS, JFN) +NHG = (NRN, DVJ) +TRR = (KKV, DKM) +DJB = (XKX, FXL) +CBD = (HRJ, LBX) +CFJ = (BPM, RPN) +TXK = (CFJ, LFS) +TCD = (QTP, TJC) +XTS = (GLG, CCP) +PGN = (KXT, JHK) +BMP = (XVP, DXQ) +CQL = (MXD, DPR) +HGT = (DXV, JMV) +JDJ = (XFR, JXR) +KRB = (HSJ, DGV) +BSR = (VRT, GTK) +RMB = (RGP, FQL) +BKS = (BBD, DSQ) +LQM = (RXD, MFC) +RQC = (FXR, PJJ) +TSC = (RXT, HTS) +XPH = (HGJ, DJF) +NPH = (TGR, SPB) +SCL = (HDJ, PQL) +XHH = (LCK, SKF) +CBL = (MTJ, FGM) +VQF = (QLQ, XLH) +LPL = (HRP, CQP) +VKD = (DMX, XJV) +XJX = (DLV, QFC) +KCC = (TCX, FVV) +GJK = (RMS, RFL) +JTL = (SMR, TTT) +XMG = (JDR, DQD) +PQL = (HSH, HGB) +LCH = (GJK, DMM) +PMJ = (RND, XCQ) +FRN = (SLS, HSC) +CHR = (PPF, TGL) +DFG = (NBC, JBL) +PJJ = (HCS, CMT) +CRJ = (HNP, TDG) +RLF = (JSJ, GMJ) +GKH = (LXJ, RCC) +RNT = (TJD, JDJ) +CLV = (CNF, BGC) +DRN = (FNK, DKQ) +RDG = (XKN, XFJ) +BNF = (CCC, FRR) +HQH = (HPR, RBS) +QJF = (DGP, XJR) +NJF = (PBH, RFS) +FKN = (CBG, BXH) +FSP = (LGP, TNC) +RXD = (SJG, HFK) +PCL = (RCV, CXH) +CLB = (NNT, TKP) +XNX = (JQQ, MSH) +VVQ = (JCK, CLV) +DHH = (DVB, MXV) +MXT = (LJX, PNC) +MFC = (SJG, HFK) +QKQ = (SVD, KRL) +CVR = (FCN, RXM) +RFK = (BVV, TGG) +NBP = (HQH, MGM) +QXX = (VCS, PMN) +PVK = (FRN, JSB) +HCN = (DXJ, VNV) +XLK = (LQB, BCR) +HPR = (HMM, CNT) +VDF = (PHV, QKQ) +KNX = (LGJ, CMC) +PXB = (KPN, BKM) +HNF = (GMJ, JSJ) +DKR = (GKH, TTV) +NGR = (KJS, PVK) +QDC = (XTS, DBT) +LPF = (DJF, HGJ) +LXJ = (FGR, NVX) +NBJ = (RMB, BHB) +QGF = (DSJ, VPV) +KSL = (QFN, RNT) +DHL = (BFS, MTG) +STP = (MGM, HQH) +FMQ = (LJP, LJP) +TGB = (RLT, MMJ) +TLF = (NCD, NMK) +NLS = (PQL, HDJ) +HRG = (SHN, BMD) +DMM = (RMS, RFL) +VPT = (JJT, FHK) +SKF = (JPR, NSG) +NFN = (HTT, HSR) +KGG = (PJL, XQS) +DHB = (CSD, TLJ) +QVA = (VRM, NFN) +SSF = (GHD, CMX) +LFB = (DJB, MGC) +GMJ = (TQP, RLR) +HTS = (GBT, LCF) +FQT = (LDN, XHF) +TFD = (VSC, XFC) +CMC = (PXP, HJK) +VBS = (CSD, TLJ) +DLC = (KHV, XLX) +NKV = (TJL, QRX) +KFV = (GSG, CKG) +GGV = (BVN, PXB) +DKQ = (NKN, VPD) +SLS = (RPS, BRM) +PJP = (VDF, GTB) +BTG = (NLN, HLQ) +VCS = (QTL, QRG) +CSQ = (GKP, VBD) +CCT = (LMF, SVS) +NNT = (TXK, MPJ) +XTH = (XGS, HKC) +SMK = (BKS, SMD) +HCS = (SCN, FSP) +HPT = (NPQ, VFQ) +KPF = (NVF, CDF) +PDH = (KQG, NKR) +PCV = (NJK, MDN) +XXG = (PGN, XDM) +MGC = (FXL, XKX) +QTL = (PDS, MHP) +JLB = (CQL, XRG) +RVN = (DVJ, NRN) +CTP = (FGM, MTJ) +RCC = (FGR, NVX) +CDF = (VHC, CSH) +NKL = (HBC, KVP) +PTV = (XLH, QLQ) +BBF = (QVC, CJQ) +TSJ = (VRT, GTK) +GCV = (SJR, SNZ) +NBF = (MBP, BNS) +PSD = (XNT, STS) +XLH = (LDT, STM) +NFK = (GQV, KFN) +VVX = (CVR, SPJ) +PNS = (VMX, PLS) +RBR = (HRG, SNS) +SBT = (SFJ, NFF) +DBT = (CCP, GLG) +RPN = (KNG, JHR) +XFJ = (HBT, XXG) +JSK = (LGJ, CMC) +CNT = (SHF, MGX) +HBJ = (FMQ, NXV) +VRX = (FJP, QVD) +RBS = (CNT, HMM) +STS = (RXQ, LJS) +DVB = (QJM, HFT) +JRX = (XLX, KHV) +RPJ = (QHG, QVV) +KDB = (GSS, CFM) +LHQ = (MFV, DKC) +RRX = (FKB, NBB) +HTJ = (GJK, DMM) +CDN = (VRD, LDP) +NFS = (RVN, NHG) +XJR = (GTJ, FDJ) +NCT = (DHL, KSX) +NHK = (CTV, PNS) +BGC = (KLN, BDB) +XJN = (MDN, NJK) +MFT = (RMT, QQQ) +RFL = (HJV, FPM) +XQS = (NLS, SCL) +BPH = (XCF, VVX) +SBG = (TSC, XMV) +LNV = (MGT, NKV) +QCH = (CKG, GSG) +JMF = (VNN, VJG) +LQF = (FNV, CNQ) +MVX = (HKV, BLG) +SQC = (VVP, TCD) +PGT = (DJL, KPF) +MFM = (BLG, HKV) +FMD = (VCL, FXV) +VRF = (BBF, CPG) +GTJ = (LKV, BKX) +XGV = (VRJ, DMD) +CTV = (PLS, VMX) +GLR = (RFJ, CJZ) +PXP = (JSC, KDD) +SRD = (SVG, DCR) +GGR = (FMT, JLV) +HSH = (RPK, LRP) +GXF = (QHC, TKN) +GBS = (TQS, HTL) +MHB = (HTL, TQS) +GTK = (DSS, FDN) +DJL = (CDF, NVF) +DPB = (VVQ, DCM) +DCG = (KFV, QCH) +FDX = (SRD, FRQ) +XKP = (QRT, RFR) +FVV = (GQC, TLB) +DMS = (VRD, LDP) +SVS = (KCC, CNC) +PRR = (SJF, BPT) +LFS = (RPN, BPM) +BLN = (XTH, LPV) +SPN = (NMK, NCD) +CMN = (KMC, VSM) +QHJ = (THL, VRF) +JGD = (DTK, SQC) +KCV = (QLN, LNV) +CRQ = (TSJ, BSR) +JFN = (RBX, DMR) +GJF = (NGH, JGS) +VSX = (RNT, QFN) +HQL = (VDF, GTB) +KMC = (HNF, RLF) +XSC = (TFG, XSG) +XDC = (STP, NBP) +PJK = (TCQ, PCL) +DSS = (JXD, FRS) +SMR = (QLS, QLS) +BMQ = (VRX, XMK) +FNB = (SNS, HRG) +BKX = (TFD, JVB) diff --git a/src/bin/day8/test_input.txt b/src/bin/day8/test_input.txt new file mode 100644 index 0000000..9029a1b --- /dev/null +++ b/src/bin/day8/test_input.txt @@ -0,0 +1,9 @@ +RL + +AAA = (BBB, CCC) +BBB = (DDD, EEE) +CCC = (ZZZ, GGG) +DDD = (DDD, DDD) +EEE = (EEE, EEE) +GGG = (GGG, GGG) +ZZZ = (ZZZ, ZZZ) diff --git a/src/bin/day8/test_input2.txt b/src/bin/day8/test_input2.txt new file mode 100644 index 0000000..7d1b58d --- /dev/null +++ b/src/bin/day8/test_input2.txt @@ -0,0 +1,5 @@ +LLR + +AAA = (BBB, BBB) +BBB = (AAA, ZZZ) +ZZZ = (ZZZ, ZZZ) diff --git a/src/bin/day8/test_input3.txt b/src/bin/day8/test_input3.txt new file mode 100644 index 0000000..5b3fa58 --- /dev/null +++ b/src/bin/day8/test_input3.txt @@ -0,0 +1,10 @@ +LR + +11A = (11B, XXX) +11B = (XXX, 11Z) +11Z = (11B, XXX) +22A = (22B, XXX) +22B = (22C, 22C) +22C = (22Z, 22Z) +22Z = (22B, 22B) +XXX = (XXX, XXX) From 2b00aff3911813e1c24df4fa4df343d1f8850bd8 Mon Sep 17 00:00:00 2001 From: nottu Date: Thu, 7 Dec 2023 22:14:58 -0800 Subject: [PATCH 5/5] small cleanup --- src/bin/day8.rs | 27 ++++++--------------------- 1 file changed, 6 insertions(+), 21 deletions(-) diff --git a/src/bin/day8.rs b/src/bin/day8.rs index 12eef05..e7bc8ca 100644 --- a/src/bin/day8.rs +++ b/src/bin/day8.rs @@ -19,22 +19,8 @@ fn day8_test_part1() { fn part1(input: &str) -> String { let (directions, map) = parse_input(input); - let num_directions = directions.len(); - let mut curr_node = "AAA".to_string(); - let goal_node = "ZZZ".to_string(); - - let mut step_count = 0; - while curr_node != goal_node { - let next_dirs = &map[&curr_node]; - curr_node = match directions[step_count % num_directions] { - Direction::Left => &next_dirs.left, - Direction::Right => &next_dirs.right, - } - .to_string(); - step_count += 1; - } - - step_count.to_string() + let curr_node = "AAA".to_string(); + get_steps(curr_node, &map, &directions, |s: &str| s == "ZZZ").to_string() } #[derive(Debug)] @@ -108,11 +94,10 @@ fn part2(input: &str) -> String { .map(|n| n.to_owned()) .collect(); - dbg!(&curr_nodes); - + let check_is_end = |s: &str| s.ends_with('Z'); curr_nodes .into_iter() - .map(|n| get_steps(n, &map, &directions)) + .map(|n| get_steps(n, &map, &directions, check_is_end)) .fold(1, num::integer::lcm) .to_string() } @@ -121,11 +106,12 @@ fn get_steps( mut curr_node: String, map: &HashMap, directions: &Vec, + check_is_end: fn(&str) -> bool, ) -> usize { let mut step_count = 0; let num_directions = directions.len(); - while !curr_node.ends_with('Z') { + while !check_is_end(&curr_node) { let next_dirs = &map[&curr_node]; curr_node = match directions[step_count % num_directions] { Direction::Left => &next_dirs.left, @@ -134,6 +120,5 @@ fn get_steps( .to_string(); step_count += 1; } - step_count }