Day 2 aoc in progress

advent_of_code/2020/1/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

advent_of_code/2020/1/input.txt

@@ -0,0 +1,200 @@
+1645
+1995
+1658
+1062
+1472
+1710
+1424
+1823
+1518
+1656
+1811
+1511
+1320
+1521
+1395
+1996
+1724
+1666
+1637
+1504
+1766
+534
+1738
+1791
+1372
+1225
+1690
+1949
+1495
+1436
+1166
+1686
+1861
+1889
+1887
+997
+1202
+1478
+833
+1497
+1459
+1717
+1272
+1047
+1751
+1549
+1204
+1230
+1260
+1611
+1506
+1648
+1354
+1415
+1615
+1327
+1622
+1592
+1807
+1601
+1026
+1757
+1376
+1707
+1514
+1905
+1660
+1578
+1963
+1292
+390
+1898
+1019
+1580
+1499
+1830
+1801
+1881
+1764
+1442
+1838
+1088
+1087
+1040
+1349
+1644
+1908
+1697
+1115
+1178
+1224
+1810
+1445
+1594
+1894
+1287
+1676
+1435
+1294
+1796
+1350
+1685
+1118
+1488
+1726
+1696
+1190
+1538
+1780
+1806
+1207
+1346
+1705
+983
+1249
+1455
+2002
+1466
+1723
+1227
+1390
+1281
+1715
+1603
+1862
+1744
+1774
+1385
+1312
+1654
+1872
+1142
+1273
+1508
+1639
+1827
+1461
+1795
+1533
+1304
+1417
+1984
+28
+1693
+1951
+1391
+1931
+1179
+1278
+1400
+1361
+1369
+1343
+1416
+1426
+314
+1510
+1933
+1239
+1218
+1918
+1797
+1255
+1399
+1229
+723
+1992
+1595
+1191
+1916
+1525
+1605
+1524
+1869
+1652
+1874
+1756
+1246
+1310
+1219
+1482
+1429
+1244
+1554
+1575
+1123
+1194
+1408
+1917
+1613
+1773
+1809
+1987
+1733
+1844
+1423
+1718
+1714
+1923
+1503

advent_of_code/2020/1/src/main.rs

@@ -0,0 +1,68 @@
+fn solve_1(input: &str) -> u32 {
+    let numbers: Vec<u32> = input
+        .lines()
+        .map(|number| number.parse::<u32>().unwrap())
+        .collect();
+
+    for n in numbers.iter() {
+        for m in numbers.iter() {
+            if n + m == 2020 {
+                return n * m;
+            }
+        }
+    }
+
+    return 0;
+}
+
+fn solve_2(input: &str) -> u32 {
+    let numbers: Vec<u32> = input
+        .lines()
+        .map(|number| number.parse::<u32>().unwrap())
+        .collect();
+
+    for n in numbers.iter() {
+        for m in numbers.iter() {
+            if n + m > 2020 {
+                continue;
+            }
+            for v in numbers.iter() {
+                if n + m + v == 2020 {
+                    return n * m * v;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The magic number is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The bigger magic number is {}", result_2);
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 514579);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 241861950);
+    }
+}

advent_of_code/2020/1/test.txt

@@ -0,0 +1,6 @@
+1721
+979
+366
+299
+675
+1456

advent_of_code/2020/2/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2020/2/src/main.rs

@@ -0,0 +1,67 @@
+use nom::{
+    bytes::complete::tag,
+    character::complete::{alpha1, anychar, multispace1, u32},
+    multi::separated_list1,
+    sequence::{preceded, tuple},
+    IResult,
+};
+
+fn parse_input(input: &str) -> IResult<&str, Vec<(u32, u32, char, &str)>> {
+    let (input, result) = separated_list1(
+        multispace1,
+        tuple((
+            u32,
+            preceded(tag("-"), u32),
+            preceded(tag(" "), anychar),
+            preceded(tag(": "), alpha1),
+        )),
+    )(input)?;
+
+    Ok((input, result))
+}
+
+fn solve_1(input: &str) -> usize {
+    let (_, input) = parse_input(input).unwrap();
+
+    input
+        .into_iter()
+        .filter(|(min, max, c, s)| {
+            let mut cs = 0;
+            for ch in s.chars() {
+                if ch == *c {
+                    cs += 1;
+                }
+            }
+
+            return cs >= *min && cs <= *max;
+        })
+        .count()
+}
+
+fn solve_2(input: &str) {}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The number of valid passwords is {}", result_1);
+
+    let result_2 = solve_2(input);
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 2);
+    }
+
+    #[test]
+    fn test_2() {}
+}

advent_of_code/2020/2/test.txt

@@ -0,0 +1,3 @@
+1-3 a: abcde
+1-3 b: cdefg
+2-9 c: ccccccccc

advent_of_code/2023/5/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2023/5/input.txt

@@ -0,0 +1,254 @@
+seeds: 1132132257 323430997 2043754183 4501055 2539071613 1059028389 1695770806 60470169 2220296232 251415938 1673679740 6063698 962820135 133182317 262615889 327780505 3602765034 194858721 2147281339 37466509
+
+seed-to-soil map:
+1280158874 0 45923291
+0 1431836695 234754481
+2476778759 365219074 73714061
+3997869725 4152785341 16553125
+3014496893 3731980396 420804945
+3435301838 2667516045 60128827
+2784964719 2727644872 187996890
+792043155 613341484 49447658
+1444573280 2476024240 74468580
+2728723659 3675739336 56241060
+2704677524 4236229588 24046135
+2360313001 1780050354 116465758
+1326082165 226504189 118491115
+3495430665 3630596320 3607732
+1519041860 662789142 56785021
+3973462947 3383860003 24406778
+1575826881 45923291 119425025
+1695251906 766775600 665061095
+2667516045 3323175190 6512477
+4240794960 3329687667 54172336
+720792676 344995304 20223770
+489053726 438933135 143852141
+741016446 746305099 20470501
+3499038397 4169338466 66891122
+761486947 582785276 30556208
+3565929519 3249598798 73576392
+659636803 165348316 61155873
+234754481 2221724995 254299245
+2674028522 4260275723 30649002
+841490813 1896516112 325208883
+632905867 719574163 26730936
+1166699696 1666591176 113459178
+2972961609 3634204052 41535284
+4195000071 3408266781 45794889
+4190957500 4290924725 4042571
+3639505911 2915641762 333957036
+4014422850 3454061670 176534650
+
+soil-to-fertilizer map:
+528009375 3804807330 65591757
+3608285775 3569685636 235121694
+432120564 3045118038 95888811
+3843407469 1792428879 363149111
+4206556580 2155577990 88410716
+3441777 3141006849 428678787
+1019419908 3870399087 424568209
+593601132 2619299262 425818776
+1443988117 3441777 1788987102
+3232975219 2243988706 375310556
+
+fertilizer-to-water map:
+3768646817 2541098841 42522952
+657445332 493998363 293094466
+3153469588 3947073749 287697992
+2513829777 3047249136 215146452
+968568929 29638292 96921246
+1600806946 1111339724 96961929
+3880726440 2687212715 52238929
+416544049 1090614661 20725063
+1749924539 4274983783 15782292
+1306572576 1208301653 21184719
+2134505230 4234771741 40212042
+1697768875 0 29638292
+3811169769 2617656044 69556671
+487527141 787092829 169918191
+3932965369 2583621793 34034251
+178562138 1471396125 237981911
+2728976229 3010972799 36276337
+2174717272 3262395588 176952386
+3035746039 1749924539 117723549
+2794475974 2764473831 241270065
+437269112 443740334 50258029
+2790274753 4290766075 4201221
+3441167580 3767315650 179758099
+3966999620 3439347974 327967676
+2351669658 2236446487 162160119
+1585319642 1229486372 15487304
+1327757295 186177987 257562347
+2765252566 2739451644 25022187
+950539798 1709378036 18029131
+1765706831 1867648088 368798399
+1199093816 1363917365 107478760
+3763417914 3005743896 5228903
+1065490175 957011020 133603641
+3620925679 2398606606 142492235
+59618449 1244973676 118943689
+0 126559538 59618449
+
+water-to-light map:
+2368177077 1928300684 68416280
+3459327457 4032125413 181740227
+2874128303 2996109939 93290692
+40167335 1203835270 50270286
+2984608918 3988581415 43543998
+1295445723 891961544 129160430
+232873619 72411133 344405432
+4002859459 4225073350 66563582
+3451555101 2874128303 4441992
+3957368975 2950619455 45490484
+4192270745 3148930063 6297777
+1638782153 2125726715 498901151
+3028152916 2912054150 38565305
+577279051 1504061698 367203335
+3418071246 2878570295 33483855
+3897839543 3089400631 59529432
+2967418995 3166056654 3449280
+3641067684 3835626234 152955181
+4147219041 3436688572 45051704
+2436593357 1021121974 182713296
+3066718221 3484273209 351353025
+2647866375 1254105556 189577037
+4198568522 3340289798 96398774
+2619306653 39188438 21015758
+2982075985 3481740276 2532933
+4069423041 3155227840 10828814
+2186332185 1443682593 52835141
+90437621 678875874 142435998
+980629741 2624627866 212815546
+2239167326 1996716964 129009751
+1424606153 571958210 106917664
+0 1871265033 40167335
+2980967789 4223965154 1108196
+1619041805 450217426 19740348
+1193445287 469957774 102000436
+944482386 426277008 23940418
+4080251855 3169505934 66967186
+1548392133 821311872 70649672
+1531523817 1911432368 16868316
+2970868275 4213865640 10099514
+3455997093 4291636932 3330364
+2137683304 416816565 9460443
+3794022865 3236473120 103816678
+2147143747 0 39188438
+2640322411 1496517734 7543964
+968422804 60204196 12206937
+
+light-to-temperature map:
+224631556 2579077346 68012835
+93390978 2647090181 93292258
+836334842 260175809 93895333
+3305235739 4175688657 119278639
+2495493200 354071142 67947352
+2563440552 648390650 214063090
+4184988573 4065709934 109978723
+930230175 2740382439 151863620
+2777503642 1813071562 114742417
+3424514378 3772814840 292895094
+1492090043 422018494 226372156
+3717409472 3176683751 126763710
+3273297 2243837725 90117681
+1216313119 2511603925 67473421
+4104753748 3096448926 80234825
+2392410003 1112358810 103083197
+759707869 2434976952 76626973
+2031212648 2333955406 101021546
+2132234194 0 260175809
+1718462199 1931087276 312750449
+186683236 1682505485 37948320
+1174711552 1070757243 41601567
+292644391 1215442007 467063478
+3844173182 3512234274 260580566
+1283786540 862453740 208303503
+3096448926 3303447461 208786813
+1082093795 1720453805 92617757
+0 1927813979 3273297
+
+temperature-to-humidity map:
+1908382071 0 48093237
+1668173777 369927146 108464980
+2454615458 3265918092 19222900
+2948843885 2383489773 582426713
+1291899323 304752282 65174864
+4051886972 3793288156 243080324
+2849120094 3285140992 99723791
+2415628816 3186987107 38986642
+724194709 716571124 379381363
+1103576072 2070505932 18664072
+3531270598 1602200086 102620550
+4020906946 3755760878 30980026
+1122240144 2285968817 97520956
+2779959793 1533039785 69160301
+1357074187 2089170004 196798813
+1823337263 624772153 85044808
+561911923 1433912547 99127238
+2538151277 1095952487 222368482
+1776638757 709816961 6754163
+2248869517 1776958859 59989455
+2760519759 48093237 3497277
+3770981692 4278303020 16664276
+3755760878 4263082206 15220814
+2497298857 263899862 40852420
+2473838358 1900103862 23460499
+234010997 51590514 212309348
+661039161 1836948314 63155548
+0 1923564361 87630970
+1219761100 1704820636 72138223
+87630970 478392126 146380027
+1956475308 3462247498 171643650
+3787645968 3786740904 6547252
+2764017036 2054563175 15942757
+2171486802 3384864783 77382715
+446320345 1318320969 115591578
+1783392920 3225973749 39944343
+2308858972 2965916486 106769844
+1553873000 3072686330 114300777
+3794193220 4036368480 226713726
+2128118958 2011195331 43367844
+
+humidity-to-location map:
+2944942064 3820503519 61983659
+3834803738 3234323053 106874653
+2156211251 3962463577 28956273
+483302901 3882487178 79976399
+2282996952 2161034243 46548053
+2629999410 1876993734 225283872
+3370099006 3129013552 105309501
+1029930529 620272722 135507476
+3572091970 2932598747 109287331
+3739626327 942443797 51739908
+3311342369 2102277606 58756637
+3941678391 399929037 136325691
+1245368468 58880743 172279414
+790057642 1189404679 239872887
+1498307968 3341197706 67668316
+273081010 616914814 3357908
+2501095485 2803694822 128903925
+3475408507 4198283833 96683463
+1860675375 3456652816 219039792
+245544342 2207582296 27536668
+3006925723 1666468371 210525363
+3791366235 3733939634 11933242
+1165438005 1502653815 79930463
+1691906495 231160157 168768880
+1590576804 994183705 101329691
+2079715167 2235118964 76496084
+276438918 3991419850 206863983
+563279300 2507766048 226778342
+2855283282 3408866022 47786794
+1565976284 2311615048 24600520
+3217451086 1095513396 93891283
+3803299477 1429277566 31504261
+4161888175 2757743175 45951647
+2903070076 1460781827 41871988
+3681379301 3675692608 58247026
+4207839822 3041886078 87127474
+2185167524 2734544390 23198785
+2329545005 2336215568 171550480
+4078004082 1582584278 83884093
+1417647882 536254728 80660086
+58880743 755780198 186663599
+2208366309 3745872876 74630643

advent_of_code/2023/5/src/main.rs

@@ -0,0 +1,338 @@
+use nom::{
+    bytes::complete::tag,
+    character::complete::{i64, multispace0, multispace1},
+    multi::separated_list1,
+    sequence::{delimited, tuple},
+    IResult, Parser,
+};
+
+/// This function assumes your input vector is sorted.
+/// It might break if this is not the case.
+/// We don't check if this is actually true, because that would take O(n) time,
+/// while we aim for this function to only take up O(log n) time.
+fn binary_search<'a, Item: Ord + Eq>(
+    value_to_find: &Item,
+    vector_to_find_it_in: &'a Vec<Item>,
+) -> Option<&'a Item> {
+    if vector_to_find_it_in.is_empty() {
+        None
+    } else {
+        let mut index = vector_to_find_it_in.len() / 2;
+        let mut lower = 0;
+        let mut upper = vector_to_find_it_in.len() - 1;
+        while upper != lower {
+            if vector_to_find_it_in[index] <= *value_to_find {
+                upper = index;
+            } else {
+                lower = index;
+            }
+            index = (upper - lower) / 2;
+        }
+        if vector_to_find_it_in[index] == *value_to_find {
+            Some(&vector_to_find_it_in[index])
+        } else {
+            None
+        }
+    }
+}
+
+fn give_map_parser<'a: 'b, 'b: 'a>(
+    map_name: &'a str,
+) -> impl FnMut(&'a str) -> IResult<&'b str, Vec<(i64, i64, i64)>> {
+    delimited(
+        tag(map_name),
+        separated_list1(
+            multispace1,
+            tuple((i64, multispace1, i64, multispace1, i64)).map(|(a, _, b, _, c)| (a, b, c)),
+        ),
+        multispace0,
+    )
+}
+
+fn parse_input(
+    input: &str,
+) -> IResult<
+    &str,
+    (
+        Vec<i64>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+    ),
+> {
+    let (input, result) = tuple((
+        delimited(tag("seeds: "), separated_list1(tag(" "), i64), multispace1),
+        give_map_parser("seed-to-soil map:\n"),
+        give_map_parser("soil-to-fertilizer map:\n"),
+        give_map_parser("fertilizer-to-water map:\n"),
+        give_map_parser("water-to-light map:\n"),
+        give_map_parser("light-to-temperature map:\n"),
+        give_map_parser("temperature-to-humidity map:\n"),
+        give_map_parser("humidity-to-location map:\n"),
+    ))(input)?;
+
+    Ok((input, result))
+}
+
+fn destination_to_source_mapping(source: i64, mappings: &Vec<(i64, i64, i64)>) -> i64 {
+    mappings
+        .iter()
+        .filter(|&(_destination_start, source_start, range)| {
+            source >= *source_start && source < *source_start + *range
+        })
+        .next()
+        .map(|(destination_start, source_start, _range)| {
+            destination_start + (source - source_start)
+        })
+        .unwrap_or(source)
+}
+
+fn solve_1(
+    almanac: &(
+        Vec<i64>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+    ),
+) -> i64 {
+    almanac
+        .0
+        .iter()
+        .map(|&seed| {
+            let soil = destination_to_source_mapping(seed, &almanac.1);
+            let fertilizer = destination_to_source_mapping(soil, &almanac.2);
+            let water = destination_to_source_mapping(fertilizer, &almanac.3);
+            let light = destination_to_source_mapping(water, &almanac.4);
+            let temperature = destination_to_source_mapping(light, &almanac.5);
+            let humidity = destination_to_source_mapping(temperature, &almanac.6);
+            destination_to_source_mapping(humidity, &almanac.7)
+        })
+        .min()
+        .unwrap()
+}
+
+fn search_range(
+    input_range: (i64, i64),
+    mappings: &Vec<(i64, i64, i64)>,
+) -> Option<(i64, i64, i64)> {
+    if mappings.is_empty() {
+        None
+    } else {
+        let mut index = mappings.len() / 2;
+        let mut lower = 0;
+        let mut upper = mappings.len() - 1;
+
+        while upper != lower {
+            if mappings[index].1 <= input_range.0
+                && mappings[index].1 + mappings[index].2 > input_range.0
+            {
+                return Some(mappings[index]);
+            } else if mappings[index].1 < input_range.0 {
+                lower = index;
+            } else {
+                upper = index - 1;
+            }
+            index = (upper + lower).div_ceil(2);
+        }
+
+        if index >= mappings.len() - 1 && mappings[index].1 + mappings[index].2 < input_range.1 {
+            None
+        } else if mappings[index].1 == input_range.0 {
+            mappings.get(index + 1).copied()
+        } else {
+            Some(mappings[index])
+        }
+    }
+}
+
+/// We will assume the mappings are sorted on the source, so we can more quickly, using binary search, find
+/// the suitable ranges. This is relevant because of the large numbers involved.
+fn get_suitable_range(input_range: (i64, i64), mappings: &Vec<(i64, i64, i64)>) -> Vec<(i64, i64)> {
+    let mut found_until = input_range.0;
+    let mut result = vec![];
+
+    while found_until < input_range.1 {
+        println!(
+            "{} {:?} {:?}",
+            found_until,
+            mappings,
+            search_range((found_until, input_range.1), mappings)
+        );
+        if let Some((destination_start, source_start, range)) =
+            search_range((found_until, input_range.1), mappings)
+        {
+            if source_start > found_until {
+                println!("ding");
+                result.push((found_until, std::cmp::min(source_start, input_range.1)));
+                found_until = std::cmp::min(source_start, input_range.1);
+            } else {
+                println!("dong");
+                let max_source = std::cmp::min(source_start + range, input_range.1);
+                result.push((
+                    found_until + (destination_start - source_start),
+                    destination_start + (max_source - source_start),
+                ));
+                found_until = max_source;
+            }
+        } else {
+            println!("dang");
+            result.push((found_until, input_range.1));
+            found_until = input_range.1;
+        }
+    }
+
+    result
+}
+
+fn get_suitable_ranges(
+    input_ranges: &Vec<(i64, i64)>,
+    mappings: &Vec<(i64, i64, i64)>,
+) -> Vec<(i64, i64)> {
+    let mut output_ranges_uncompressed = input_ranges
+        .iter()
+        .map(|&(range_start, range_length)| {
+            get_suitable_range((range_start, range_start + range_length), mappings)
+        })
+        .collect::<Vec<Vec<(i64, i64)>>>()
+        .into_iter()
+        .flatten()
+        .collect::<Vec<(i64, i64)>>();
+
+    output_ranges_uncompressed.sort_unstable();
+    let (mut lower, mut upper) = output_ranges_uncompressed[0];
+
+    let mut output_ranges = vec![];
+    for (range_low, range_up) in output_ranges_uncompressed {
+        if range_low <= upper {
+            upper = range_up;
+        } else {
+            output_ranges.push((lower, upper));
+            lower = range_low;
+            upper = range_up;
+        }
+    }
+    output_ranges.push((lower, upper));
+    output_ranges = output_ranges
+        .iter()
+        .map(|&(range_start, range_end)| (range_start, range_end - range_start))
+        .collect::<Vec<_>>();
+    output_ranges
+}
+
+fn solve_2(
+    almanac: &(
+        Vec<i64>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+        Vec<(i64, i64, i64)>,
+    ),
+) -> i64 {
+    let mut lowest_location_numbers = vec![];
+    let mut seed_iter = almanac.0.iter();
+
+    let mut soil_almanac = almanac.1.iter().map(|&n| n).collect::<Vec<_>>();
+    soil_almanac.sort_unstable_by(|&(_d1, source1, _r1), (_d2, source2, _r2)| source1.cmp(source2));
+    let mut fertilizer_almanac = almanac.2.iter().map(|&n| n).collect::<Vec<_>>();
+    fertilizer_almanac
+        .sort_unstable_by(|&(_d1, source1, _r1), (_d2, source2, _r2)| source1.cmp(source2));
+    let mut water_almanac = almanac.3.iter().map(|&n| n).collect::<Vec<_>>();
+    water_almanac
+        .sort_unstable_by(|&(_d1, source1, _r1), (_d2, source2, _r2)| source1.cmp(source2));
+    let mut light_almanac = almanac.4.iter().map(|&n| n).collect::<Vec<_>>();
+    light_almanac
+        .sort_unstable_by(|&(_d1, source1, _r1), (_d2, source2, _r2)| source1.cmp(source2));
+    let mut temperature_almanac = almanac.5.iter().map(|&n| n).collect::<Vec<_>>();
+    temperature_almanac
+        .sort_unstable_by(|&(_d1, source1, _r1), (_d2, source2, _r2)| source1.cmp(source2));
+    let mut humidity_almanac = almanac.6.iter().map(|&n| n).collect::<Vec<_>>();
+    humidity_almanac
+        .sort_unstable_by(|&(_d1, source1, _r1), (_d2, source2, _r2)| source1.cmp(source2));
+    let mut location_almanac = almanac.7.iter().map(|&n| n).collect::<Vec<_>>();
+    location_almanac
+        .sort_unstable_by(|&(_d1, source1, _r1), (_d2, source2, _r2)| source1.cmp(source2));
+
+    while let (Some(&lower_seed), Some(&range_length)) = (seed_iter.next(), seed_iter.next()) {
+        println!("ding");
+        let seed_range = vec![(lower_seed, range_length)];
+        let soil_ranges = get_suitable_ranges(&seed_range, &soil_almanac);
+        println!("soil");
+
+        let fertilizer_ranges = get_suitable_ranges(&soil_ranges, &fertilizer_almanac);
+        println!("fertilizer");
+
+        let water_ranges = get_suitable_ranges(&fertilizer_ranges, &water_almanac);
+        println!("water");
+
+        let light_ranges = get_suitable_ranges(&water_ranges, &light_almanac);
+        println!("light");
+
+        let temperature_ranges = get_suitable_ranges(&light_ranges, &temperature_almanac);
+        println!("temperature");
+
+        let humidity_ranges = get_suitable_ranges(&temperature_ranges, &humidity_almanac);
+        println!("humidity");
+
+        lowest_location_numbers.push(
+            get_suitable_ranges(&humidity_ranges, &location_almanac)
+                .iter()
+                .map(|&(range_min, _range_max)| range_min)
+                .min()
+                .unwrap(),
+        );
+    }
+
+    *lowest_location_numbers.iter().min().unwrap()
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input_text = include_str!("../input.txt");
+
+    let (_, almanac) = parse_input(input_text).unwrap();
+
+    println!(
+        "The lowest location number corresponding to the initial seed numbers is {}",
+        solve_1(&almanac)
+    );
+
+    println!(
+        "The lowest location number for any of the initial seed ranges is {}",
+        solve_2(&almanac)
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let input_text = include_str!("../test_input.txt");
+
+        let (_, almanac) = parse_input(input_text).unwrap();
+
+        assert_eq!(solve_1(&almanac), 35);
+    }
+
+    #[test]
+    fn test_2() {
+        let input_text = include_str!("../test_input.txt");
+
+        let (_, almanac) = parse_input(input_text).unwrap();
+
+        assert_eq!(solve_2(&almanac), 46);
+    }
+}

advent_of_code/2023/5/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

advent_of_code/2023/7/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2023/7/src/main.rs

@@ -0,0 +1,263 @@
+use std::{cmp::Ordering, collections::HashMap, iter::zip};
+
+use nom::{
+    character::complete::{alphanumeric1, multispace1, u64},
+    multi::separated_list1,
+    sequence::separated_pair,
+    IResult, Parser,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+enum HandType {
+    HighCard,
+    OnePair,
+    TwoPair,
+    ThreeKind,
+    FullHouse,
+    FourKind,
+    FiveKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+enum CardType {
+    Two,
+    Three,
+    Four,
+    Five,
+    Six,
+    Seven,
+    Eight,
+    Nine,
+    T,
+    Jack,
+    Queen,
+    King,
+    Ace,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+enum CardType2 {
+    Jack,
+    Two,
+    Three,
+    Four,
+    Five,
+    Six,
+    Seven,
+    Eight,
+    Nine,
+    T,
+    Queen,
+    King,
+    Ace,
+}
+
+fn parse_input(input: &str) -> IResult<&str, Vec<(String, u64)>> {
+    let (input, result) = separated_list1(
+        multispace1,
+        separated_pair(alphanumeric1::<&str, _>, multispace1, u64)
+            .map(|(hand, bid)| (hand.to_string(), bid)),
+    )(input)?;
+
+    Ok((input, result))
+}
+
+fn classify_hand(hand: &String) -> HandType {
+    use HandType::*;
+
+    let mut card_numbers: HashMap<char, i32> = HashMap::new();
+    for c in hand.to_owned().chars() {
+        card_numbers.insert(
+            c,
+            match card_numbers.get(&c) {
+                Some(n) => n + 1,
+                None => 1,
+            },
+        );
+    }
+
+    let mut card_numbers = card_numbers.values().collect::<Vec<_>>();
+    card_numbers.sort_unstable();
+    match card_numbers[..] {
+        [1, 1, 1, 1, 1] => HighCard,
+        [1, 1, 1, 2] => OnePair,
+        [1, 2, 2] => TwoPair,
+        [1, 1, 3] => ThreeKind,
+        [2, 3] => FullHouse,
+        [1, 4] => FourKind,
+        [5] => FiveKind,
+        _ => unreachable!(),
+    }
+}
+
+fn classify_hand2(hand: &String) -> HandType {
+    use HandType::*;
+
+    let mut card_numbers: HashMap<char, i32> = HashMap::new();
+    for c in hand.to_owned().chars() {
+        card_numbers.insert(
+            c,
+            match card_numbers.get(&c) {
+                Some(n) => n + 1,
+                None => 1,
+            },
+        );
+    }
+
+    if let Some(jokers) = card_numbers.remove(&'J') {
+        let mut card_numbers = card_numbers.values().collect::<Vec<_>>();
+        card_numbers.sort_unstable();
+        let highest = card_numbers.pop().unwrap_or(&0) + jokers;
+        card_numbers.push(&highest);
+
+        match card_numbers[..] {
+            [1, 1, 1, 2] => OnePair,
+            [1, 1, 3] => ThreeKind,
+            [2, 3] => FullHouse,
+            [1, 4] => FourKind,
+            [5] => FiveKind,
+            _ => unreachable!(),
+        }
+    } else {
+        let mut card_numbers = card_numbers.values().collect::<Vec<_>>();
+        card_numbers.sort_unstable();
+        match card_numbers[..] {
+            [1, 1, 1, 1, 1] => HighCard,
+            [1, 1, 1, 2] => OnePair,
+            [1, 2, 2] => TwoPair,
+            [1, 1, 3] => ThreeKind,
+            [2, 3] => FullHouse,
+            [1, 4] => FourKind,
+            [5] => FiveKind,
+            _ => unreachable!(),
+        }
+    }
+}
+
+fn classify_card(card: char) -> CardType {
+    use CardType::*;
+
+    match card {
+        'A' => Ace,
+        'K' => King,
+        'Q' => Queen,
+        'J' => Jack,
+        'T' => T,
+        '9' => Nine,
+        '8' => Eight,
+        '7' => Seven,
+        '6' => Six,
+        '5' => Five,
+        '4' => Four,
+        '3' => Three,
+        '2' => Two,
+        _ => unreachable!(),
+    }
+}
+
+fn classify_card2(card: char) -> CardType2 {
+    use CardType2::*;
+
+    match card {
+        'A' => Ace,
+        'K' => King,
+        'Q' => Queen,
+        'T' => T,
+        '9' => Nine,
+        '8' => Eight,
+        '7' => Seven,
+        '6' => Six,
+        '5' => Five,
+        '4' => Four,
+        '3' => Three,
+        '2' => Two,
+        'J' => Jack,
+        _ => unreachable!(),
+    }
+}
+
+fn compare_hands(hand_1: &String, hand_2: &String) -> Ordering {
+    let (hand_type_1, hand_type_2) = (classify_hand(hand_1), classify_hand(hand_2));
+    if hand_type_1 == hand_type_2 {
+        for (card_1, card_2) in zip(hand_1.to_owned().chars(), hand_2.to_owned().chars()) {
+            if card_1 != card_2 {
+                return classify_card(card_1).cmp(&classify_card(card_2));
+            }
+        }
+        Ordering::Equal
+    } else {
+        hand_type_1.cmp(&hand_type_2)
+    }
+}
+
+fn compare_hands2(hand_1: &String, hand_2: &String) -> Ordering {
+    let (hand_type_1, hand_type_2) = (classify_hand2(hand_1), classify_hand2(hand_2));
+    if hand_type_1 == hand_type_2 {
+        for (card_1, card_2) in zip(hand_1.to_owned().chars(), hand_2.to_owned().chars()) {
+            if card_1 != card_2 {
+                return classify_card2(card_1).cmp(&classify_card2(card_2));
+            }
+        }
+        Ordering::Equal
+    } else {
+        hand_type_1.cmp(&hand_type_2)
+    }
+}
+
+fn solve_1(plays: &Vec<(String, u64)>) -> u64 {
+    let mut plays = plays.clone();
+
+    plays.sort_unstable_by(|(hand_1, _bid1), (hand_2, _bid2)| compare_hands(hand_1, hand_2));
+
+    plays
+        .into_iter()
+        .enumerate()
+        .map(|(rank, (_hand, bid))| (rank as u64 + 1) * bid)
+        .sum()
+}
+
+fn solve_2(plays: &Vec<(String, u64)>) -> u64 {
+    let mut plays = plays.clone();
+
+    plays.sort_unstable_by(|(hand_1, _bid1), (hand_2, _bid2)| compare_hands2(hand_1, hand_2));
+
+    plays
+        .into_iter()
+        .enumerate()
+        .map(|(rank, (_hand, bid))| (rank as u64 + 1) * bid)
+        .sum()
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input_text = include_str!("../input.txt");
+
+    let (_, plays) = parse_input(input_text).unwrap();
+
+    println!("The total winnings are {}", solve_1(&plays));
+    println!("The new total winnings are {}", solve_2(&plays));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let input_text = include_str!("../test_input.txt");
+
+        let (_, plays) = parse_input(input_text).unwrap();
+
+        assert_eq!(solve_1(&plays), 6440);
+    }
+
+    #[test]
+    fn test_2() {
+        let input_text = include_str!("../test_input.txt");
+
+        let (_, plays) = parse_input(input_text).unwrap();
+
+        assert_eq!(solve_2(&plays), 5905);
+    }
+}

advent_of_code/2023/7/test_input.txt

@@ -0,0 +1,5 @@
+32T3K 765
+T55J5 684
+KK677 28
+KTJJT 220
+QQQJA 483

advent_of_code/2023/8/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2023/8/input.txt

@@ -0,0 +1,800 @@
+LLRLRLLRRLRLRLLRRLRRRLRRRLRRLRRLRLRLRRRLLRLRRLRLRRRLRLLRRLRLRLLRRRLLRLRRRLRLRRLRRLRLLRRLRRLRLRLRLLRLLRRLRRLRRLRRLRRLRLLRLRLRRRLRRRLRRLRLRLRRLRRRLRLRRRLRLRLRLRRRLRRLRRLRRRLLLLRRLRRLRLRRRLRLRRRLRRLLLLRLRLRRRLRRRLRLRRLLRLRLRRRLRLRLRRRLRLLRRRLRRLRLRLRRRLRLLRRLLRRRLRRRLRRRLRRLRLRLRRRLRRRLRRRLLRRRR
+
+NNN = (TNT, XDJ)
+GKJ = (TQD, PDP)
+VPC = (TST, FDJ)
+MNG = (GQS, RVK)
+JQF = (LLK, BQH)
+HPS = (XDJ, TNT)
+VSD = (GNK, HJS)
+VGT = (KXR, FMP)
+GQB = (GTX, HLC)
+PLJ = (QCS, TVN)
+BXM = (GMB, LBC)
+XJQ = (NHG, NQD)
+NKX = (KBJ, GTS)
+PKT = (XFK, SKR)
+HJB = (LRX, KQG)
+SNM = (PLN, CJT)
+LQD = (MTK, KMS)
+KTN = (SSC, KPL)
+LVJ = (CQJ, GPP)
+GSV = (SNM, JKK)
+CPH = (DCQ, FCP)
+TDV = (JFD, HKH)
+SBS = (NFC, CGC)
+DBG = (GST, LGH)
+LHS = (GHG, TRD)
+BPP = (DLF, NJT)
+TNT = (VNX, PTR)
+VTN = (XHM, NMQ)
+BRD = (KLF, HXJ)
+TJT = (BVD, PFN)
+GNK = (NMT, LLX)
+DVH = (GQS, RVK)
+KRJ = (QSP, TTQ)
+KQC = (TNX, MDC)
+XVS = (LRC, DLC)
+XLP = (XCH, BJQ)
+KQG = (LKK, TVP)
+QHB = (JPL, JPL)
+RGV = (SXB, FKH)
+GSK = (JQN, THB)
+XDT = (GLG, XKD)
+XCT = (MMN, XDM)
+KLF = (NPB, RRB)
+XLT = (QRB, VHB)
+HKS = (NNN, HPS)
+NMT = (MSL, VXC)
+PML = (NHN, FQH)
+FMQ = (HGC, FBH)
+JGG = (XTB, XTB)
+KMC = (PPS, SVT)
+GLG = (SPG, KFK)
+QJN = (HJB, QCP)
+SGH = (FDV, QPX)
+DFM = (BFX, PNS)
+CSK = (MDQ, GFX)
+MXG = (MXC, BJV)
+JTX = (SQN, JBK)
+KFN = (VQM, PFH)
+SFJ = (KDF, NKB)
+JNK = (DLK, LHV)
+DTG = (XHQ, DSR)
+SHC = (FQV, HKK)
+DBM = (VDP, PGK)
+PNC = (LMH, RXH)
+HXJ = (RRB, NPB)
+MKS = (KMX, FKS)
+NPA = (TPC, SNK)
+LJK = (FPF, SHP)
+LBH = (HQB, TTC)
+JML = (LTN, SFS)
+MXS = (FDL, SXH)
+HHV = (VRL, JVC)
+NQD = (KVJ, DXM)
+HMA = (TVC, RBX)
+BCP = (SQD, RGD)
+SLP = (CQF, HXG)
+KGF = (RPN, PKQ)
+TGG = (VQM, PFH)
+HQD = (MDV, GND)
+BJX = (LCN, QMG)
+NBQ = (NSV, VJR)
+BBX = (KHG, FDC)
+SSQ = (BNQ, MXX)
+TST = (MJB, TDV)
+JQL = (SDG, DLJ)
+TVN = (SJM, KMC)
+XHD = (DDG, RSG)
+GQA = (NQS, CNH)
+QFL = (QSQ, VVN)
+THG = (FBM, VQX)
+QLZ = (RBX, TVC)
+TPM = (DQN, MGG)
+QXV = (MTK, KMS)
+VNX = (PTP, VSD)
+STQ = (XDC, JFR)
+XVQ = (PJM, MRN)
+XTT = (BHF, RBR)
+LQS = (DBB, HNR)
+KXG = (FKS, KMX)
+XCP = (MXK, DBX)
+QRV = (JSK, STC)
+VVG = (DRF, QNR)
+FTC = (CSK, FPC)
+GFV = (VSK, GFQ)
+JSM = (LNC, XTF)
+LJC = (JFG, XBK)
+TQD = (XJQ, MFM)
+HJS = (LLX, NMT)
+CBP = (PTX, LGD)
+LGT = (CTD, CTD)
+HMP = (FQJ, KGC)
+MSL = (MSD, BFL)
+QPX = (QFH, JMK)
+KBH = (MGF, TMH)
+XMT = (MXC, BJV)
+XGR = (KPF, DLH)
+RGH = (MBM, KNT)
+CDP = (BLG, NVN)
+BLG = (TQC, DTD)
+MSD = (RVP, RQP)
+KXT = (CVM, JQL)
+MRN = (MNX, PNC)
+RLG = (BNP, VNR)
+PSH = (XQG, SLP)
+XTF = (NTT, VGT)
+KVJ = (JVX, HPJ)
+PGF = (KRJ, CRS)
+VSV = (NKQ, PJG)
+TLV = (QHJ, GFG)
+BNP = (NFR, PGR)
+XQG = (CQF, HXG)
+KGC = (FKF, KCS)
+HQF = (QPX, FDV)
+PFN = (JGX, FMQ)
+HFD = (DBG, CBD)
+KQZ = (HXJ, KLF)
+HPM = (VSV, LTR)
+FGX = (SVR, GQB)
+SGJ = (THB, JQN)
+NKK = (QHB, QHB)
+FLF = (RLC, MXP)
+SRV = (QHM, LQS)
+NPB = (BPG, CVQ)
+VNR = (NFR, PGR)
+FNF = (TXL, CXT)
+PTB = (QXQ, BDK)
+BXN = (HQF, SGH)
+RGT = (MGN, GFN)
+FSP = (VRK, QNN)
+GHT = (PML, HTJ)
+CBD = (LGH, GST)
+LMH = (TJC, DNN)
+PTP = (GNK, HJS)
+XDC = (GHT, JTR)
+HTJ = (NHN, FQH)
+XFK = (NKX, HTV)
+PBP = (CJJ, GKS)
+KMX = (XSJ, PMK)
+CVQ = (FKX, GXP)
+SFV = (MXS, FLR)
+BQH = (VMH, PKT)
+NFR = (RTX, SBJ)
+KCS = (XGR, JXT)
+GND = (SFJ, DGL)
+DTF = (JCC, LVC)
+KLM = (XLP, QRQ)
+VQV = (DNC, SST)
+NKF = (KFN, TGG)
+CJT = (LDP, QKM)
+NPF = (TNC, LXF)
+MHK = (MLX, NHX)
+LGD = (DLP, CNJ)
+MLF = (QKK, QRK)
+LQB = (NKJ, SHN)
+SNS = (KMV, HCG)
+VPN = (HFV, LNX)
+XTB = (XLT, VRF)
+LNX = (HFB, QVF)
+XGF = (NRN, KCF)
+PNS = (JNQ, MCT)
+BJG = (DNC, SST)
+PQN = (SCL, VPX)
+NGQ = (DGT, RLF)
+GGX = (LQS, QHM)
+VVT = (MHK, LTJ)
+QJH = (XTF, LNC)
+BBP = (FNX, RTK)
+DDP = (JBR, KLD)
+GDV = (KXT, BJT)
+GDT = (CFB, PSH)
+LGH = (CRK, SCF)
+JNB = (DXQ, FBK)
+DLH = (XJD, GDT)
+NCQ = (MXP, RLC)
+LXP = (SPR, RTF)
+GRQ = (FNX, RTK)
+KBJ = (DNB, TDP)
+LXK = (CTD, JML)
+DBB = (TJD, FNF)
+RBR = (JTX, XKN)
+GPD = (LXN, PLD)
+JNM = (QRM, MSV)
+LNC = (VGT, NTT)
+GVT = (VVN, QSQ)
+KCD = (GFB, MFL)
+HDG = (VFQ, DTF)
+RGD = (GGX, SRV)
+KJK = (SRJ, QGV)
+DSL = (MNG, DVH)
+DSR = (VQV, BJG)
+NHB = (HPS, NNN)
+JVX = (JRT, GDQ)
+TGB = (DCG, VXK)
+MXN = (PST, GBF)
+CTP = (XGM, SFV)
+BPG = (GXP, FKX)
+HRT = (LXF, TNC)
+SST = (HDG, VJS)
+PDP = (XJQ, MFM)
+BDK = (TFM, GRM)
+PPS = (RQV, BXN)
+SSS = (TJQ, GNQ)
+TXL = (QRV, PPH)
+RRQ = (RXF, PGF)
+PSX = (LLM, FXM)
+FBK = (JDQ, DSX)
+JLR = (LSM, NXT)
+SPR = (DTG, RKQ)
+PGC = (TJT, HXC)
+LLD = (LHS, RLV)
+NRH = (XBB, FGX)
+SXH = (HMP, LSK)
+JVC = (MLN, XKM)
+MGF = (GGT, XMS)
+TTS = (TNX, TNX)
+FCP = (PLJ, KND)
+LRX = (TVP, LKK)
+VKJ = (PGN, XPX)
+VRL = (XKM, MLN)
+RQV = (SGH, HQF)
+CRS = (QSP, TTQ)
+BJC = (FCJ, TSC)
+CSP = (BNM, FLN)
+XHQ = (BJG, VQV)
+CRK = (DKC, QQQ)
+HFB = (BVM, VMP)
+SQN = (QJN, KKV)
+DGK = (FVX, RGT)
+HTP = (HCF, HFR)
+RFT = (NMF, DRL)
+TRJ = (SHN, NKJ)
+XJD = (PSH, CFB)
+FQJ = (FKF, KCS)
+VHB = (KDM, DSB)
+SKR = (NKX, HTV)
+LCN = (TLV, FMC)
+MTC = (PST, GBF)
+QRK = (XNR, SPD)
+TCK = (MDK, BCP)
+DNN = (HHV, MVS)
+JNQ = (PBP, VDG)
+NKQ = (MKX, HVD)
+FTV = (MNG, DVH)
+SJM = (SVT, PPS)
+KCB = (NKK, CNF)
+KJN = (PRV, BVK)
+PRV = (SVP, FTM)
+HFV = (HFB, QVF)
+NFC = (FVC, TBN)
+LMC = (QRK, QKK)
+KNF = (CHN, GFV)
+XNP = (SGJ, GSK)
+QQB = (MLF, LMC)
+CVM = (DLJ, SDG)
+RSG = (LBH, TLD)
+PGR = (RTX, SBJ)
+VTD = (QGV, SRJ)
+LBC = (PRH, CSP)
+RKX = (NHL, XMM)
+MXK = (XJN, PTB)
+MJD = (DLC, LRC)
+GDR = (FCX, KNF)
+VXK = (THG, BPN)
+GPP = (NRC, DHQ)
+SDN = (FKH, SXB)
+KJH = (BJX, VHX)
+RNQ = (DNX, GPL)
+VQX = (RXP, SSS)
+PPH = (JSK, STC)
+KKV = (HJB, QCP)
+ZZZ = (FGX, XBB)
+PTN = (KCD, HPQ)
+GMP = (KHG, FDC)
+NTT = (KXR, FMP)
+GBF = (KXG, MKS)
+VPX = (JFB, HSN)
+SVG = (BPP, RPK)
+PJG = (MKX, HVD)
+HNR = (TJD, FNF)
+XBB = (SVR, GQB)
+FBM = (SSS, RXP)
+RTX = (QJQ, KJN)
+MSV = (KQH, LRF)
+MGN = (LGT, LXK)
+QDH = (CFV, DHZ)
+NPR = (GDR, DCF)
+HSN = (VLG, QNC)
+PTM = (VGG, CQX)
+VCP = (BCL, XDT)
+LBP = (MPD, MPD)
+NRK = (NNL, XKC)
+QCT = (BBL, SVH)
+RPL = (MMH, CDP)
+RXH = (TJC, DNN)
+DGL = (KDF, NKB)
+GTQ = (PGF, RXF)
+FXG = (BGH, MTH)
+FQH = (VCJ, HPM)
+LTN = (SCP, SCP)
+JMK = (LPX, JNM)
+SCL = (JFB, HSN)
+TKV = (XHC, HQD)
+BDT = (TTS, KQC)
+MXX = (SKB, LPC)
+RPN = (QJK, BXM)
+MFL = (NDC, TPM)
+DXM = (HPJ, JVX)
+QXM = (LHS, RLV)
+QHM = (HNR, DBB)
+QRB = (KDM, DSB)
+JMG = (PLD, LXN)
+QSQ = (BNS, XNC)
+CXA = (XLT, VRF)
+MXC = (LQD, QXV)
+CNJ = (QQP, PXV)
+BPM = (BRD, BRD)
+BFV = (FCJ, TSC)
+KPL = (RPL, HBT)
+JJR = (QNN, VRK)
+KHG = (VDS, LKJ)
+DRC = (HFR, HCF)
+DLF = (RFT, STN)
+GKS = (QQB, RLT)
+TBD = (LFP, PQN)
+XNC = (QBD, DDP)
+TGC = (JNB, JXF)
+KCF = (LBP, JHT)
+NKB = (CCJ, RGH)
+NPH = (JQF, QJC)
+BJQ = (LJC, QMT)
+GTS = (TDP, DNB)
+XSJ = (KTN, VXJ)
+QXQ = (GRM, TFM)
+FCJ = (FKJ, DSK)
+FPF = (CQH, HML)
+VCJ = (LTR, VSV)
+QJK = (LBC, GMB)
+PMK = (VXJ, KTN)
+FXM = (BNT, VVG)
+DDG = (TLD, LBH)
+MDB = (FDJ, TST)
+BSF = (VXK, DCG)
+BVK = (FTM, SVP)
+RTG = (JSH, LKD)
+BPN = (VQX, FBM)
+BJT = (CVM, JQL)
+DFS = (BCP, MDK)
+GRM = (MDB, VPC)
+TRD = (NRK, HPF)
+FKH = (XHD, SNT)
+LXF = (BDX, TKV)
+JBK = (KKV, QJN)
+JBP = (BNP, VNR)
+PKF = (BJX, VHX)
+DLK = (DGK, XST)
+TFM = (MDB, VPC)
+VDP = (VVR, MHR)
+RDP = (VJR, NSV)
+PTX = (CNJ, DLP)
+DCG = (THG, BPN)
+BCV = (LTJ, MHK)
+FKJ = (NBQ, RDP)
+PHK = (KGF, SBX)
+JDQ = (PTN, RFF)
+TNC = (BDX, TKV)
+KCJ = (RPK, BPP)
+DLJ = (FTC, TGF)
+FQG = (GVT, QFL)
+LFP = (SCL, VPX)
+PBG = (KNC, PFX)
+QCP = (LRX, KQG)
+NRC = (GPD, JMG)
+PHH = (DGT, RLF)
+XCH = (LJC, QMT)
+VXJ = (KPL, SSC)
+TNX = (BPM, BPM)
+PTR = (VSD, PTP)
+NDC = (DQN, DQN)
+SVT = (RQV, BXN)
+NTJ = (SHC, QCM)
+SHM = (SNM, JKK)
+TLD = (TTC, HQB)
+MMN = (JNK, RRS)
+NPC = (MTC, MXN)
+NMF = (QBM, CTP)
+CQX = (NRH, ZZZ)
+BNT = (DRF, QNR)
+BJZ = (CNH, NQS)
+KFK = (XCT, PPG)
+SDG = (TGF, FTC)
+CBB = (HFV, LNX)
+VFQ = (LVC, JCC)
+LRF = (KLM, JGL)
+TTC = (JLR, GFT)
+PFH = (SHG, XTT)
+RLT = (MLF, LMC)
+XPJ = (JPL, BJZ)
+PKQ = (BXM, QJK)
+TNS = (GDR, DCF)
+FKX = (PKG, QQL)
+MJB = (HKH, JFD)
+JTN = (JSM, QJH)
+QTG = (NRN, KCF)
+MPX = (CHR, TGC)
+JKK = (CJT, PLN)
+LKK = (DRC, HTP)
+RXF = (KRJ, CRS)
+QNC = (LFB, FQG)
+RKQ = (DSR, XHQ)
+LCX = (PGK, VDP)
+KSG = (LLD, QXM)
+RPK = (NJT, DLF)
+KDM = (KSG, PLL)
+TVP = (HTP, DRC)
+DCB = (NKK, NKK)
+DQN = (STJ, STJ)
+JSH = (TRS, GKJ)
+LDP = (XGS, LJK)
+QRM = (LRF, KQH)
+VGG = (NRH, NRH)
+LLK = (VMH, PKT)
+VSK = (PHH, NGQ)
+JFB = (VLG, QNC)
+BCL = (XKD, GLG)
+RTF = (RKQ, DTG)
+KPF = (GDT, XJD)
+DHZ = (SNK, TPC)
+LPC = (DCB, KCB)
+KDF = (RGH, CCJ)
+PLL = (QXM, LLD)
+XHS = (FXM, LLM)
+BHF = (JTX, XKN)
+RRS = (DLK, LHV)
+FFL = (HKS, NHB)
+VRF = (QRB, VHB)
+LSQ = (MRN, PJM)
+SCD = (MXK, DBX)
+SPD = (FXG, RDX)
+CFM = (PQN, LFP)
+QKK = (SPD, XNR)
+LVC = (JJR, FSP)
+RLV = (TRD, GHG)
+HKK = (SSP, XNP)
+JCC = (FSP, JJR)
+JHT = (MPD, SCN)
+RVP = (XVQ, LSQ)
+HPQ = (GFB, MFL)
+JRT = (VTN, SKP)
+DTD = (TGB, BSF)
+PKG = (SKX, DGB)
+VMP = (RLG, JBP)
+DSX = (RFF, PTN)
+QRQ = (BJQ, XCH)
+LLX = (VXC, MSL)
+SVH = (DFS, TCK)
+XNR = (RDX, FXG)
+QKM = (LJK, XGS)
+MMH = (BLG, NVN)
+SKB = (DCB, KCB)
+JXT = (KPF, DLH)
+SVV = (BCV, VVT)
+KLD = (MHM, PVJ)
+QNN = (SVV, NQK)
+FCX = (GFV, CHN)
+BNS = (QBD, DDP)
+SHP = (HML, CQH)
+TJD = (TXL, CXT)
+BQF = (FCP, DCQ)
+MKX = (SNS, CCN)
+JKF = (NPH, KGL)
+LFB = (QFL, GVT)
+DCQ = (PLJ, KND)
+SVP = (VGX, JCR)
+PGN = (XMT, MXG)
+NVZ = (VRF, XLT)
+VBR = (BDM, LXP)
+GTX = (PHK, DSN)
+BDX = (XHC, HQD)
+JGX = (HGC, FBH)
+BBL = (DFS, TCK)
+KNT = (BBX, GMP)
+TLP = (LXH, TKF)
+TDS = (CBB, VPN)
+CTD = (LTN, LTN)
+HCG = (RRQ, GTQ)
+VRG = (TTS, KQC)
+RLC = (TLP, FQX)
+FBH = (DBM, LCX)
+SCP = (TVC, RBX)
+CGC = (TBN, FVC)
+JFG = (NQP, GDV)
+BVM = (RLG, JBP)
+DCF = (KNF, FCX)
+BJV = (QXV, LQD)
+QBD = (JBR, KLD)
+QFG = (BBL, SVH)
+RFF = (HPQ, KCD)
+QJQ = (PRV, BVK)
+FMC = (QHJ, GFG)
+PXV = (STQ, VHK)
+VVN = (XNC, BNS)
+NHG = (DXM, KVJ)
+SSP = (SGJ, GSK)
+QMT = (JFG, XBK)
+VRK = (NQK, SVV)
+SNT = (DDG, RSG)
+RRB = (BPG, CVQ)
+DXQ = (JDQ, DSX)
+FMP = (SHM, GSV)
+VMF = (FJX, VBR)
+NKJ = (GKP, SBS)
+XGM = (FLR, MXS)
+SKX = (NLH, RTG)
+XMS = (FDP, PRK)
+SPG = (PPG, XCT)
+QNR = (MPX, SXC)
+MDC = (BPM, CTR)
+SMR = (TJT, HXC)
+TBN = (FJS, TDS)
+BGH = (NPF, HRT)
+VDS = (XHS, PSX)
+RBX = (CDJ, PBG)
+VLC = (CQJ, GPP)
+SVR = (GTX, HLC)
+MDV = (DGL, SFJ)
+GMB = (CSP, PRH)
+QSP = (TBD, CFM)
+GFQ = (PHH, NGQ)
+HXG = (BDT, VRG)
+PPG = (XDM, MMN)
+MSH = (SHC, QCM)
+CHR = (JXF, JNB)
+RDX = (MTH, BGH)
+VXC = (MSD, BFL)
+DLP = (PXV, QQP)
+MXP = (FQX, TLP)
+TTQ = (TBD, CFM)
+GHG = (HPF, NRK)
+SNK = (BQF, CPH)
+MGG = (STJ, QDH)
+CCJ = (MBM, KNT)
+NNL = (KBH, LKC)
+LKD = (GKJ, TRS)
+GFN = (LGT, LXK)
+QBM = (XGM, SFV)
+STJ = (CFV, CFV)
+DSK = (RDP, NBQ)
+TSC = (FKJ, DSK)
+NSV = (LQB, TRJ)
+FKF = (XGR, JXT)
+DNX = (NTJ, MSH)
+NLH = (JSH, LKD)
+CFV = (TPC, SNK)
+DRP = (VBR, FJX)
+BDM = (SPR, RTF)
+TGF = (FPC, CSK)
+CNH = (VXD, LFX)
+BFL = (RQP, RVP)
+XHC = (GND, MDV)
+CJJ = (RLT, QQB)
+HPH = (XMM, NHL)
+PRH = (FLN, BNM)
+JCR = (THT, VCP)
+VHK = (XDC, JFR)
+NQP = (KXT, BJT)
+CDJ = (KNC, PFX)
+SCF = (DKC, QQQ)
+JBR = (MHM, PVJ)
+TPC = (BQF, CPH)
+FDC = (LKJ, VDS)
+KNC = (XCQ, VKJ)
+VQM = (SHG, XTT)
+KND = (QCS, TVN)
+MDM = (GPL, DNX)
+FJX = (LXP, BDM)
+BDV = (XTB, NVZ)
+LBM = (KFN, TGG)
+XKC = (KBH, LKC)
+QVF = (VMP, BVM)
+SHG = (RBR, BHF)
+DNB = (SVC, SSQ)
+SCN = (JGG, BDV)
+SXC = (TGC, CHR)
+XSL = (KCJ, SVG)
+TKF = (VLC, LVJ)
+LKJ = (XHS, PSX)
+VHX = (QMG, LCN)
+HGC = (LCX, DBM)
+MLN = (HFD, KVM)
+XDM = (JNK, RRS)
+RTK = (PKD, NPC)
+QQQ = (DSL, FTV)
+VJS = (DTF, VFQ)
+LLM = (VVG, BNT)
+MFM = (NHG, NQD)
+NQK = (VVT, BCV)
+NHN = (HPM, VCJ)
+SKP = (NMQ, XHM)
+HXC = (BVD, PFN)
+LSK = (FQJ, KGC)
+FPC = (GFX, MDQ)
+STC = (RBF, PTM)
+CTR = (BRD, KQZ)
+BNQ = (SKB, LPC)
+QQL = (SKX, DGB)
+NHX = (RKX, HPH)
+QHJ = (GRQ, BBP)
+XCQ = (XPX, PGN)
+HTV = (GTS, KBJ)
+JXF = (DXQ, FBK)
+JTR = (HTJ, PML)
+JHB = (JSM, QJH)
+CQF = (BDT, VRG)
+GNQ = (QCT, QFG)
+TQC = (TGB, BSF)
+SFS = (SCP, QLZ)
+MDQ = (MJD, XVS)
+DLC = (TMM, DFM)
+FLN = (RGV, SDN)
+PVJ = (QTG, XGF)
+JFR = (JTR, GHT)
+PGK = (VVR, MHR)
+TDP = (SSQ, SVC)
+RLF = (RKP, SKK)
+HJN = (NHB, HKS)
+VJR = (TRJ, LQB)
+VGX = (VCP, THT)
+DSB = (PLL, KSG)
+FTM = (VGX, JCR)
+MHR = (LBM, NKF)
+JFD = (CBP, HLJ)
+HKH = (CBP, HLJ)
+FDV = (QFH, JMK)
+NHL = (RQG, JKF)
+CQJ = (DHQ, NRC)
+HVD = (SNS, CCN)
+PLN = (QKM, LDP)
+THT = (BCL, XDT)
+FDP = (SCD, XCP)
+TJC = (HHV, MVS)
+QCM = (HKK, FQV)
+TJQ = (QCT, QFG)
+HFR = (KJH, PKF)
+RQG = (NPH, KGL)
+SRJ = (TNS, NPR)
+LTR = (NKQ, PJG)
+XST = (FVX, RGT)
+MBM = (GMP, BBX)
+KVM = (CBD, DBG)
+MVS = (VRL, JVC)
+SSC = (RPL, HBT)
+QQP = (VHK, STQ)
+CHQ = (SVG, KCJ)
+BVD = (FMQ, JGX)
+FNX = (NPC, PKD)
+FJS = (CBB, VPN)
+PLD = (FFL, HJN)
+TVC = (CDJ, PBG)
+DBX = (XJN, PTB)
+MDK = (SQD, RGD)
+JPL = (NQS, CNH)
+VDG = (GKS, CJJ)
+HQB = (GFT, JLR)
+GQS = (VMF, DRP)
+PST = (MKS, KXG)
+XGS = (SHP, FPF)
+XDJ = (VNX, PTR)
+MHM = (QTG, XGF)
+SHN = (SBS, GKP)
+LFX = (FLF, NCQ)
+BFX = (JNQ, MCT)
+XHM = (RNQ, MDM)
+LXN = (HJN, FFL)
+HPJ = (JRT, GDQ)
+NVN = (DTD, TQC)
+KGL = (QJC, JQF)
+MCT = (PBP, VDG)
+QFH = (LPX, JNM)
+FVC = (FJS, TDS)
+DRL = (QBM, CTP)
+LTJ = (MLX, NHX)
+THB = (JTN, JHB)
+SBX = (RPN, PKQ)
+KMV = (RRQ, GTQ)
+MNX = (LMH, RXH)
+LKC = (TMH, MGF)
+TMM = (BFX, PNS)
+TMH = (XMS, GGT)
+LPX = (QRM, MSV)
+STN = (DRL, NMF)
+RKP = (CHQ, XSL)
+DNC = (HDG, VJS)
+XMM = (JKF, RQG)
+GFT = (LSM, NXT)
+LSM = (SMR, PGC)
+FKS = (XSJ, PMK)
+MPD = (JGG, JGG)
+DKC = (DSL, FTV)
+HLC = (DSN, PHK)
+KMS = (BJC, BFV)
+NJT = (RFT, STN)
+JSK = (RBF, RBF)
+HLJ = (LGD, PTX)
+QMG = (TLV, FMC)
+GPL = (NTJ, MSH)
+RQP = (XVQ, LSQ)
+GGT = (FDP, PRK)
+XKN = (JBK, SQN)
+FVX = (MGN, GFN)
+GST = (CRK, SCF)
+MTK = (BFV, BJC)
+CCN = (KMV, HCG)
+TRS = (PDP, TQD)
+NRN = (LBP, JHT)
+GFG = (GRQ, BBP)
+XBK = (NQP, GDV)
+CXT = (QRV, PPH)
+FQV = (SSP, XNP)
+GFB = (NDC, TPM)
+VXD = (NCQ, FLF)
+XPX = (MXG, XMT)
+SQD = (SRV, GGX)
+GKP = (NFC, CGC)
+AAA = (XBB, FGX)
+KXR = (SHM, GSV)
+DGB = (RTG, NLH)
+PJM = (PNC, MNX)
+QGV = (NPR, TNS)
+CFB = (SLP, XQG)
+FDJ = (TDV, MJB)
+DSN = (KGF, SBX)
+FLR = (FDL, SXH)
+JGL = (QRQ, XLP)
+JQN = (JTN, JHB)
+MTH = (NPF, HRT)
+PRK = (SCD, XCP)
+VHA = (KLF, HXJ)
+VVR = (NKF, LBM)
+CQH = (VTD, KJK)
+DRF = (MPX, SXC)
+FDL = (LSK, HMP)
+PFX = (XCQ, VKJ)
+HPF = (XKC, NNL)
+LXH = (LVJ, VLC)
+SVC = (MXX, BNQ)
+GFX = (XVS, MJD)
+DGT = (SKK, RKP)
+XKD = (KFK, SPG)
+XJN = (BDK, QXQ)
+KQH = (KLM, JGL)
+VMH = (SKR, XFK)
+CHN = (VSK, GFQ)
+LHV = (DGK, XST)
+HCF = (PKF, KJH)
+CNF = (QHB, XPJ)
+QCS = (SJM, KMC)
+GXP = (QQL, PKG)
+SBJ = (QJQ, KJN)
+DHQ = (GPD, JMG)
+VLG = (FQG, LFB)
+GDQ = (VTN, SKP)
+NMQ = (MDM, RNQ)
+XKM = (KVM, HFD)
+BNM = (SDN, RGV)
+MLX = (RKX, HPH)
+QJC = (LLK, BQH)
+HML = (KJK, VTD)
+SKK = (CHQ, XSL)
+FQX = (TKF, LXH)
+PKD = (MXN, MTC)
+NQS = (LFX, VXD)
+HBT = (CDP, MMH)
+LRC = (DFM, TMM)
+NXT = (SMR, PGC)
+SXB = (XHD, SNT)
+RBF = (VGG, VGG)
+RXP = (GNQ, TJQ)
+RVK = (DRP, VMF)

advent_of_code/2023/8/src/main.rs

@@ -0,0 +1,174 @@
+use nom::{
+    bytes::complete::tag,
+    character::complete::{alpha1, alphanumeric1, multispace1},
+    multi::separated_list1,
+    sequence::{separated_pair, tuple},
+    IResult, Parser,
+};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Copy)]
+enum Dir {
+    Right,
+    Left,
+}
+
+fn parse_input(input: &str) -> IResult<&str, (Vec<Dir>, Vec<(String, String, String)>)> {
+    use Dir::*;
+    let (input, result) = (separated_pair(
+        alpha1,
+        multispace1,
+        separated_list1(
+            multispace1,
+            tuple((
+                alphanumeric1::<&str, _>,
+                tag(" = ("),
+                alphanumeric1,
+                tag(", "),
+                alphanumeric1,
+                tag(")"),
+            ))
+            .map(|(start, _, left, _, right, _)| {
+                (start.to_string(), left.to_string(), right.to_string())
+            }),
+        ),
+    ))(input)?;
+
+    let result = (
+        result
+            .0
+            .chars()
+            .map(|c| match c {
+                'R' => Right,
+                'L' => Left,
+                _ => unreachable!(),
+            })
+            .collect(),
+        result.1,
+    );
+
+    Ok((input, result))
+}
+
+fn create_network(network: &[(String, String, String)]) -> HashMap<String, (String, String)> {
+    let mut result = HashMap::new();
+
+    for (source, left, right) in network {
+        result.insert(source.to_owned(), (left.to_owned(), right.to_owned()));
+    }
+
+    result
+}
+
+fn solve_1(route: &[Dir], network: &Vec<(String, String, String)>) -> u32 {
+    use Dir::*;
+
+    let network = create_network(&network[..]);
+    let mut current_node = "AAA".to_string();
+    let mut steps = 0;
+
+    let mut route_iter = route.iter();
+    loop {
+        if current_node == "ZZZ".to_string() {
+            return steps;
+        }
+
+        steps += 1;
+        let direction = match route_iter.next() {
+            None => {
+                route_iter = route.iter();
+                route_iter.next().unwrap()
+            }
+            Some(dir) => dir,
+        };
+        current_node = match direction {
+            Right => network.get(&current_node).unwrap().1.to_owned(),
+            Left => network.get(&current_node).unwrap().0.to_owned(),
+        }
+    }
+}
+
+fn solve_2(route: &[Dir], network: &Vec<(String, String, String)>) -> u32 {
+    use Dir::*;
+
+    let mut current_nodes = network
+        .iter()
+        .filter(|(start, _left, _right)| start.ends_with('A'))
+        .map(|(start, _left, _right)| start.to_owned())
+        .collect::<Vec<String>>();
+    let network = create_network(&network[..]);
+    let mut steps = 0;
+
+    let mut route_iter = route.iter();
+    loop {
+        if current_nodes.iter().all(|node| node.ends_with('Z')) {
+            return steps;
+        }
+
+        steps += 1;
+        let direction = match route_iter.next() {
+            None => {
+                route_iter = route.iter();
+                route_iter.next().unwrap()
+            }
+            Some(dir) => dir,
+        };
+        for node in current_nodes.iter_mut() {
+            let target_node = match direction {
+                Right => network.get(node).unwrap().1.to_owned(),
+                Left => network.get(node).unwrap().0.to_owned(),
+            };
+            *node = target_node.to_owned();
+        }
+    }
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input_text = include_str!("../input.txt");
+
+    let (_, (route, network)) = parse_input(input_text).unwrap();
+
+    println!(
+        "There are {} steps required to reach ZZZ",
+        solve_1(&route[..], &network)
+    );
+
+    println!(
+        "There are {} steps required to reach only nodes ending on Z, when starting from nodes ending only on A",
+        solve_2(&route[..], &network)
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test1_part1() {
+        let input_text = include_str!("../test_input1.txt");
+
+        let (_, (route, network)) = parse_input(input_text).unwrap();
+
+        assert_eq!(solve_1(&route[..], &network), 2);
+    }
+
+    #[test]
+    fn test2_part1() {
+        let input_text = include_str!("../test_input2.txt");
+
+        let (_, (route, network)) = parse_input(input_text).unwrap();
+
+        assert_eq!(solve_1(&route[..], &network), 6);
+    }
+
+    #[test]
+    fn test_part2() {
+        let input_text = include_str!("../test_input3.txt");
+
+        let (_, (route, network)) = parse_input(input_text).unwrap();
+
+        assert_eq!(solve_2(&route[..], &network), 6);
+    }
+}

advent_of_code/2023/8/test_input1.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)

advent_of_code/2023/8/test_input2.txt

@@ -0,0 +1,5 @@
+LLR
+
+AAA = (BBB, BBB)
+BBB = (AAA, ZZZ)
+ZZZ = (ZZZ, ZZZ)

advent_of_code/2023/8/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)

advent_of_code/2024/1/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

advent_of_code/2024/1/src/main.rs

@@ -0,0 +1,94 @@
+use std::{collections::HashMap, iter::zip};
+
+fn distance<A>(a: A, b: A) -> A
+where
+    A: std::ops::Sub<Output = A> + Ord,
+{
+    if a < b {
+        return b.sub(a);
+    } else {
+        return a.sub(b);
+    }
+}
+
+fn solve_1(input: &str) -> u32 {
+    let input: Vec<Vec<u32>> = input
+        .lines()
+        .map(|element| {
+            element
+                .split_ascii_whitespace()
+                .map(|numbers| numbers.parse::<u32>().unwrap())
+                .collect()
+        })
+        .collect();
+    // Double collect(), wowsers that's ugly but it works?
+
+    let mut left: Vec<u32> = input.iter().map(|v| v[0].to_owned()).collect();
+    let mut right: Vec<u32> = input.iter().map(|v| v[1].to_owned()).collect();
+
+    left.sort();
+    right.sort();
+
+    return zip(left, right).fold(0, |x, (l, r)| x + distance(l, r));
+}
+
+fn solve_2(input: &str) -> u32 {
+    let input: Vec<Vec<u32>> = input
+        .lines()
+        .map(|element| {
+            element
+                .split_ascii_whitespace()
+                .map(|numbers| numbers.parse::<u32>().unwrap())
+                .collect()
+        })
+        .collect();
+
+    let left: Vec<u32> = input.iter().map(|v| v[0].to_owned()).collect();
+    let right: Vec<u32> = input.iter().map(|v| v[1].to_owned()).collect();
+
+    let mut occurrences: HashMap<u32, u32> = HashMap::new();
+    for r in right.into_iter() {
+        occurrences.insert(
+            r,
+            match occurrences.get(&r) {
+                None => 1,
+                Some(v) => v + 1,
+            },
+        );
+    }
+
+    return left
+        .into_iter()
+        .fold(0, |s, l| s + l * occurrences.get(&l).unwrap_or(&0));
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input_text = include_str!("../input.txt");
+
+    let result_1 = solve_1(input_text);
+    println!("The total distance between the two lists is {}", result_1);
+
+    let result_2 = solve_2(input_text);
+    println!("The similarity score of the two lists is {}", result_2);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+
+        assert_eq!(solve_1(test_input), 11);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+
+        assert_eq!(solve_2(test_input), 31);
+    }
+}

advent_of_code/2024/1/test.txt

@@ -0,0 +1,6 @@
+3   4
+4   3
+2   5
+1   3
+3   9
+3   3

advent_of_code/2024/10/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

advent_of_code/2024/10/input.txt

@@ -0,0 +1,55 @@
+0123450128945212434498107654876212322345432110787870123
+1214563287654302345347278923945003411276741025696983254
+2307874390901201436256361010232156500985891234899874765
+3458965481896543457101454322121267898764210348760565856
+4547889332787612898654456541010128709654321409651487943
+9656971245610502348742363456723489214545670512342396512
+8746560330541461059231072019894876523039987651229603401
+0130450101232878762108981923785955432128896560318712101
+1221321432543969456676870831276843201017698431105657892
+4349898540158950387985106740189652122012587120234598761
+0456797643267341293234203651076561043403436011231034650
+1245687653212210982178312312345878654312345190345125141
+4334567064307807891089425405658969763233438987656776032
+5321018165616906702376596534787439890120107678949889120
+6910789278965215610345687321096521763011234589030672101
+7821898347654334321256786543212310652101347654121543432
+6734787658901223456105897610105432543276978903443430563
+2105676987911010897834978923076501034789877412352321694
+3456989876854323708929870134589632385676966543261430785
+4367810105763432612210165245678745690123457898170567014
+3210121234176501523878954354776544787430342347089698923
+2345665893080787438965410167889432156561231456798789654
+1058756702191898341014321054974321047892120321887018763
+0569845212012567634323015123125410430121011010986323454
+6578954307623498765487654304034543221030345654345432125
+5434356788545349854599001216787652107845210787216701034
+0125643699237898703678104325894567856956789891209834345
+7876212765103203612363215454383898945787698900340125876
+0980101894454114503054356965212432430694543215489876965
+1098234583467023212125407870106541021583210676098920145
+2347899602898908763256910187017865652678701587187813236
+3256678711743219854567823298894976569549652490296704367
+0100345620651278343289654350765987478230743321345410198
+9251201234230341230178760541034300300121890120034326789
+8349212945145650789078921632133211212010581631128965632
+7658767876054787632107634780124504321123498745489874541
+6107323945763096549616543995435665210898589654788103450
+5236014539892124328723012876343786789867670123694012367
+4345867622101015610654322301212891270184561054543231018
+2109988913412126789961001454309750301293432163210102309
+3458776804569234697872156545678543432789430673456943212
+4567566543678985586543267836787612545676521982987856103
+0103457012987876487434586927898707654568701201276547894
+1212388967876567393325698810989898965439632320567030985
+0327890658905058212016784543298781012344543011498121076
+9456541243014149801134569650185632307655676322399876125
+8767632332123232100123678745670546998764985431087565436
+3498234501104343034598988764321457884643891056016501098
+2567107698612352125667639058901210745012342347121432167
+1989278786783961012787540147654323654321435218930345236
+0876989695894878109896039236569456788760324306543210145
+0105874504185769854385128545478998699354413457850105256
+1234763213096854763014537654360187543263509766969876567
+2303452342187943212323456963201236984102678876878103498
+3212301056789810103410567870102345676101278987989012567

advent_of_code/2024/10/src/main.rs

@@ -0,0 +1,143 @@
+use std::collections::{HashMap, HashSet};
+
+fn parse(input: &str) -> Vec<Vec<u32>> {
+    const RADIX: u32 = 10;
+    input
+        .lines()
+        .map(|l| l.chars().map(|c| c.to_digit(RADIX).unwrap()).collect())
+        .collect()
+}
+
+fn solve_1(input: &str) -> u32 {
+    let map = parse(input);
+
+    let h = map.len();
+    let w = map[0].len();
+
+    let mut map_info: HashMap<(usize, usize), HashSet<(usize, usize)>> = HashMap::new();
+
+    for (j, row) in map.iter().enumerate() {
+        for (i, elevation) in row.iter().enumerate() {
+            if *elevation == 9 {
+                map_info.insert((i, j), HashSet::from([(i, j)]));
+            }
+        }
+    }
+
+    for e in (0..=8).rev() {
+        let mut new_map_info: HashMap<(usize, usize), HashSet<(usize, usize)>> = HashMap::new();
+
+        for ((i, j), trailheads) in map_info.into_iter() {
+            let mut positions = vec![];
+            if i > 0 {
+                positions.push((i - 1, j));
+            }
+            if i < w - 1 {
+                positions.push((i + 1, j));
+            }
+            if j > 0 {
+                positions.push((i, j - 1));
+            }
+            if j < h - 1 {
+                positions.push((i, j + 1));
+            }
+
+            for (x, y) in positions.into_iter() {
+                if map[y][x] == e {
+                    match new_map_info.get(&(x, y)) {
+                        None => new_map_info.insert((x, y), trailheads.clone()),
+                        Some(&ref t) => new_map_info.insert(
+                            (x, y),
+                            t.union(&trailheads).map(|ts| ts.to_owned()).collect(),
+                        ),
+                    };
+                }
+            }
+        }
+        map_info = new_map_info;
+    }
+
+    map_info
+        .values()
+        .map(|trailheads| trailheads.len() as u32)
+        .sum()
+}
+
+fn solve_2(input: &str) -> u32 {
+    let map = parse(input);
+
+    let h = map.len();
+    let w = map[0].len();
+
+    let mut map_info: HashMap<(usize, usize), u32> = HashMap::new();
+
+    for (j, row) in map.iter().enumerate() {
+        for (i, elevation) in row.iter().enumerate() {
+            if *elevation == 9 {
+                map_info.insert((i, j), 1);
+            }
+        }
+    }
+
+    for e in (0..=8).rev() {
+        let mut new_map_info: HashMap<(usize, usize), u32> = HashMap::new();
+
+        for ((i, j), rating) in map_info.into_iter() {
+            let mut positions = vec![];
+            if i > 0 {
+                positions.push((i - 1, j));
+            }
+            if i < w - 1 {
+                positions.push((i + 1, j));
+            }
+            if j > 0 {
+                positions.push((i, j - 1));
+            }
+            if j < h - 1 {
+                positions.push((i, j + 1));
+            }
+
+            for (x, y) in positions.into_iter() {
+                if map[y][x] == e {
+                    match new_map_info.get(&(x, y)) {
+                        None => new_map_info.insert((x, y), rating),
+                        Some(r) => new_map_info.insert((x, y), r + rating),
+                    };
+                }
+            }
+        }
+        map_info = new_map_info;
+    }
+
+    map_info.values().sum()
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The sum of scores of all trailheads is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The sum of ratings of all trailheads is {}", result_2);
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 36);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 81);
+    }
+}

advent_of_code/2024/10/test.txt

@@ -0,0 +1,8 @@
+89010123
+78121874
+87430965
+96549874
+45678903
+32019012
+01329801
+10456732

advent_of_code/2024/11/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

advent_of_code/2024/11/input.txt

@@ -0,0 +1 @@
+6563348 67 395 0 6 4425 89567 739318

advent_of_code/2024/11/src/main.rs

@@ -0,0 +1,121 @@
+use std::collections::HashMap;
+
+fn parse(input: &str) -> Vec<u64> {
+    input
+        .split_whitespace()
+        .map(|stone| stone.parse().unwrap())
+        .collect()
+}
+
+fn solve_1(input: &str) -> usize {
+    let stones = parse(input);
+    let mut current_stones = stones.clone();
+
+    // I know, this is very naive
+    for _ in 0..25 {
+        let mut new_stones = vec![];
+
+        for stone in current_stones {
+            if let 0 = stone {
+                new_stones.push(1);
+            } else {
+                let ss = stone.to_string();
+
+                if ss.len() % 2 == 0 {
+                    let (front, back) = ss.split_at(ss.len() / 2);
+                    new_stones.push(front.parse().unwrap());
+                    new_stones.push(back.parse().unwrap());
+                } else {
+                    new_stones.push(stone * 2024);
+                }
+            }
+        }
+        current_stones = new_stones;
+    }
+
+    current_stones.len()
+}
+
+fn solve_2(input: &str) -> u64 {
+    let stones = parse(input);
+
+    // Now for the dynamic programming version
+    let mut dp: HashMap<u64, u64> = HashMap::new();
+    for stone in stones {
+        dp.insert(stone, 1);
+    }
+
+    for _ in 0..75 {
+        let mut new_dp: HashMap<u64, u64> = HashMap::new();
+        for (stone, cnt) in dp.into_iter() {
+            let ss = stone.to_string();
+            if stone == 0 {
+                match new_dp.get_mut(&1) {
+                    None => {
+                        new_dp.insert(1, cnt);
+                    }
+                    Some(c) => *c += cnt,
+                };
+            } else if ss.len() % 2 == 0 {
+                let (front, back) = ss.split_at(ss.len() / 2);
+                let front = front.parse::<u64>().unwrap();
+                let back = back.parse::<u64>().unwrap();
+
+                match new_dp.get_mut(&front) {
+                    None => {
+                        new_dp.insert(front, cnt);
+                    }
+                    Some(c) => *c += cnt,
+                }
+                match new_dp.get_mut(&back) {
+                    None => {
+                        new_dp.insert(back, cnt);
+                    }
+                    Some(c) => *c += cnt,
+                }
+            } else {
+                let new_stone = 2024 * stone;
+                match new_dp.get_mut(&new_stone) {
+                    None => {
+                        new_dp.insert(new_stone, cnt);
+                    }
+                    Some(c) => *c += cnt,
+                }
+            }
+        }
+
+        dp = new_dp;
+    }
+
+    dp.values().sum()
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!(
+        "The number of stones after blinking 25 times is {}",
+        result_1
+    );
+
+    let result_2 = solve_2(input);
+    println!(
+        "After blinking 75 times, the number of stones is {}",
+        result_2
+    );
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 55312);
+    }
+}

advent_of_code/2024/11/test.txt

@@ -0,0 +1 @@
+125 17

advent_of_code/2024/12/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

advent_of_code/2024/12/input.txt

@@ -0,0 +1,140 @@
+UUUUUUUUUUUUUUUUHHHDDDDDDDDDDDDLLLLLLLLLLLLSSSSSSSBBBBBBBBBBHHHHHHKKHHHHHHHHHHHHHZZZZZZMMMMMMMMMMMMMVVVVVVVVVVVVVVVVHHHHHHUUUUUUUUTTTTTTTTTT
+UUUUUUUUUUUUUUUUUHHDDDDDDDDDDDLLLLLLLLLLLXLSSSSSSSBBBBBBBBBBBHHHHHHHHHHHHHHHHHHHHHHZZZZMMMMMMMMMMMMMVVVVVVVVVVVVVVVVHHHHHUUUUUUUTTTTTTTTTTTT
+UUUUUUUUUUUUUUUUUUHDDDDDDDDDDDLLLLLLLLLLLLFLLSSSSSBBBBBBBBBBBBHHHVVHHHHHHHHHHHHHHBHZZMMMMMMMMMMMMMMMDVVVVVVVVVVVVVVVWWHHHUUHUTTTTTTTTTTTTTTT
+UUUUUUUUUUUUUUUUDDDDDTDDDDDDLLLLLLLLLLLLLLLLFFSSSBBBBBBBBBBBBBBVVVHHHHHHHHHHHHHHHHHZZZMMMMMMMMMMMMMDDVVVVVVVVVVVVVVVHHHHHHHHUUTTTTTTTTTTTTTT
+UUUUUUUUUUUUUUUDDDDDDDDDDDDDDELLLLLLLLLLLLLLFFFSFBBBBBBBBBBBBVVVVVVVHHHHHHHHHHHZHHHZDZMMMMMMMMMMDDDDDDVVVVVVVVVVVVFHHHHHHHHHUUTTTTTTTTTTTTTT
+UUUUUUUUUUUUUUUDDDDDDDDDDDDDDEELLLLLLLLLLLLLFFFFFBBBBBBBBBBBBBVVVVVVHHHHHHHHHHZZHHXDDDDDMMMMMMMMMDDDDDDDVVVVVVVVVVHHHHHHHHHHUUUTTTTTTTTGGTTT
+UUUUUUUUUUUDUDUDDDDDDDDDDGGDDEEELLLLLLLLLLLFFFFFFFFFBBBBBBBBBBVVVVVVHVHHHHHHHHXXXXXDDDDMMMMMMMMMMDDDDDDVVNVVVVVVVVHHHHHHHHHHUUUTTTTTTTTTGGTT
+UUUUUUUUDDUDDDDDDDYDYDDDGGGGGEELLLLLLLLLLLFFFFFFFFFBBBBBBBBBBBVVVVVVVVVVHHHHHHHXXXXXXXDXXMMMMYYMYDDADDDLVVVVVVVVVHHHHHHHHHHHHUUTTGTGTTTTGGTT
+UUUUDDUDDDUDDDDDDDYYYYZZGGGGGEEEELLLLLLLLLFFFFFFFFBBBBBBBBBBQQVVVVVVVVVVHHHHHHHXXXXXXXXXMMMYYYYYYYYYDDDDTVVVVVVVVVHHHHHHHHHHHUUUGGGGTTGGGGTT
+UNUUUDUUDDDDDDDDDYYYYYYZZGGGGEEEELLLLLLFFEFFFFFFFFFFFBFSSBBBBVVVVVVVVVVVVHHHHHHXXXXXXXXXMMMMMYYYYYYYYDDDDVVVVVVVVVVHHHHHHHHHUUUUUUGGGGGGGGGG
+DUUUDDDDDDDDDDYYYYYYYYYZZGGGGGGLLLLLLLLLFFFFFFFFFFFFFFFSSSSBBBVVVVVVVVVVVVVHHHHXXXXXXXXXMMMYBYYYYYYYYDQQVVVVVVVJVVVHLHHHHBHHUUUUUUGGGGGGGGGG
+DDDDDDDDDDDDDDYYYYYYYZZZZSSSGGGLLJLLLLLLFFFFFFFFFFFFFFFFFSSSSSSSSSVVVVVVVVHHHXXXXXXXXXXMMMMYYYYYYYYYYYYYYYVVVSVJVZZHZSSHHHUUUUUUUGGGGGGGGGGG
+DDDDDDDDDDMDDYYYYYYYYYSSSSSSGGGGGJLLLJJJJJFFFFFFFFFFFFFFFSSSSSSSSSVVVVVVVVVVHVXXXXXXXXMMMMYYYYYYYYYYYYYYYYVVVSZZZZZZZSSSHHBUUUUUUUGGGGGGGGGG
+DDDCDDDDMMMMDYYYYYYYYSSSSSZSGGGGGOOOOOOOOOOFFFFFFFFFFFFCFFFSSSSSSSVVVVVVVVVVVVXXXXXXXMMMMYYYYYYYYYYYYYYYYYVVSSZZZZZZZSSSSHBBBUUUUUUGGGGGGGGG
+CCDCCCCDMMMMMZYFFFYSSSSSSZZGGRRRGOOOOOOOOOOOOOOOOOFFFFFFFFFSSSSSSSSVVVVVVVVVVVXXXXXXMMMMMMMMYYYYYYYYYYYYYYYYYSSZZZZZZSSSSBBBBBUUUUUUGGGGGGGG
+CCCCCCCDMMMMMMFFFFSSSSSSSZZRGRRJJOOOOOOOOOOOOOOOOOFFFFFKKSSSSSSSSSPVVVVVVVVVFVVXXXXXMMMMMMMYYYYYYYYYYYYYYYYYSSSZZZZZSSSBBBBBBUUUUUUGGGGGGGGG
+CCCCCCCMMMMMMMMFFSSSSSSSYYYRRRRRJOOOOOOOOOOOOOOOOOKKKFKKKSSSSSSSSVVVVVVVVVVVFFVVXXWWMMMMMMMYPPIIYYYYYYYYYYSSSSSSSSSSSSSSBBBBBUUUUUUGGGGGGGGG
+CCCCCCQMMMMMMMMMMSSSSSSSYOOOOOOOOOOOOOOOOOOOOOOOOOFKKKKKKSSSDSSDDDDVHHHVVVVVFFFXXXWWWMMMMQMMPPIIIYYYYYYYSSSSSSSSSSSSSSSSSBBBBUUUUUUUGGGGGGGG
+CCCCCMMMMMMMMMMMMYYSSYYYYOOOOOOOOOOOOOOOOOOOOOOOOOQQKKDDDDDDDDDDDDDHHHHVVVVYYFYZXXWWMMEEMMMMPPIIIIIIYYYSSSSSSSSSMMSSSSSSSSSSBBUUUUUUUUGGGGGG
+CCCCCMMMMMMMMMMMMMSSSSYYYOOOOOOOOOOOOOOOOOOOOOOOOOQQQKKLLLLDDDDDDDHHHHHHYVYYYYYYXWWWMEEEMPPPPPPIIIIFYYYSSSSSSSMMMMSSSSSSSSSSBBBUUUUUUUUGJGGG
+CCCCCMRMMMMMMMMMMWWWWWYYYOOOOOOOOOOOOOOOOOOOOOOOOOQQQKKLKLLLDDDDDDHHHHHYYYYYYYZZJWWWWCCCMPPPPPIIIIIFISYSSSSSMMMMMMSSSSSSSSSSBBBUUUUUUUGGJJGG
+CCCCCMMMMMMMMMMMWWWWWWWWYOOOOOOOOOOOOOOOOOOOOOOOOOQQQKLLLLLDDDLDDDDHHHYYYYYYJJJJJJJWCCCCCPPIIIIIIIIIISSSJJJSMMMMMMSSSSSSSSSSBUUUUNNNNNNGJJJG
+CCCCCCMMMMMMMMWWWWWWWWYYYOOOOOOOOOOOOOOOOOOOOOOOOOQNNKLLLLLIDLLDDHHHHHYYYYYYYJJJJCCCCCCCCPIIIIIIIIIISSSSJJJMMMMMMMSSSSSSSSSSUUUUUNNNNWNNNJJJ
+CCQCCCMMMMMMMMWWWWWWWWWYYOOOOOOOOOOOOOOOOOOOOQQNNNNNNLLLLLLLLLLLDDHHHHXYYJYYJJJJJJCCCCCCCIIIIUUIIISSSSSJJJMMMMMMMMMMMMMMMBNNUUNNNNNNNNNNNJNN
+QQQCCCCCMMYMMWWWWWWWWYYYYOOOOOOOOOOOOOOOOOOOOQQNNNNNNLLLLLLLLLLLHHHHMXXYYJJJJJJJJJJZCCCCCIIIUUIIISSJJJJJJJJMMMMMMMMMMMMLLLNNNUNNNNNNNNNNNNNB
+OQQQCCCCMMMCMWWWWWWWWYYYYYYYYYYYOOOOOOOOOOOOOQQNNNNNNLLLLLLLLLLHHHHHMXXPXXXJJJJJJJJIICCCIIIIIUIJIJSJJJJJJJMMMMMMMMMMLLLLLLLLNNNNNNNNNNNNNNNN
+OOQCCCCCMCCCCWWWWWWWWWYYYYYYYYYYYYYOOOOOOOOOOQNNNNNNNLLLLLLLJJJJHHMMMMXXXXXJJJJJJIIQIIIIIIIIIJIJJJJJJJJJJJMMTTMGMMMMLLLLLLLLLNNNNNNNNNNNNNNN
+OQQQQQCCCCCCCCCWWWWWWWYYYYYYYYYYYYSOOOOOOOOOOQNNNNNNNNLLLLLLJJJJHMMMMXXXXXXXXJDDDDDDDDIIIIIIJJJJJJJJJJJJJJJJJTMGGGLLLLLLLLLLLLLLNNNNNNNNNNNN
+QQQQQQQCCCCCCCWWWWWWWYYYYYYYYYYYYYGOOOOOOOOOCCMNNWWNNNLLLLLLJJJJJMMMMMXXXXXXXXDDDDDDDDIIIIIJJJJJJJJJJJJJJJJJTTTGGGVLLLLLLLLLLLLLNNNNNNNNNNNN
+QQQQQCCCCCCCCCWWWWWWWYYYYYYYYYGGYYGOOOOOOOOOCCWNNWWWNNLLLLLJJJJJJJMMMMMXXXXXXXDDDDDDDDIIIIIIJJJJJJJJJJJJJJTTTTTGGGVVVLLLLLLLLLLLNNNNNNNNNOON
+QQQQQCCCCCCCCCCCVVWVVYYYYYYYYGGGGGGGSCCCCCCCCWWWWWWWRRAAALLJJJJMJJMMMMMXXXXHXXDDDDDDDDZZIIIIJJJQJJJJJJJJJJTTTTTGHPVVLLLLLLLLLLLNNNNNNNNNOOOO
+QQQQQCCVECMMMMVVVVVVVVYYYYYYGGGGGGGSSCCCCCCCWWWWWWWWWAAAAAJJJJJMJMMMMMMMMXXMXXDDDDDDDDZZIIIIBJJJJJJJJJJJJJTTTTTTTPPPPLLLLLLLLLZNNNNNNNNOOOOO
+QQQQQCCCEEVVVVVVVVVVVVVVHYGGGGGUUGGGGCCCCCCCWWWWWWWWWAAAAAJJJJJMMMMMMMMMMMXMMMDDDDDDDDZZZJIILJJJPJJJJJJJJJTTTTTTPPPPPLLLLLLLLLZZZZNNNNNOOOOO
+RQQQQQCCEEEEVVVVVVVVVVVVVXYGYGGUUGGGCCCCCCCCWWWWWWWWWWAAAJJJJJJJMMMMMMMMMMMMMMTZZDDDZZZZZJIILLLLJJJJJJJJJTTTTTFFFPPPPLLLLLLLLLZZZNNNNNNOIOOO
+RRRRRRREEEEENNVVVVVVVVVVVXYYYYGYUUCCCCCCCCCCWWWWWWWWWSAAAAJJJJMMMMMMMMMMMEMMMMMMUDDDZZZZZZLLLKLLJJJJJJJZJJTTTFFFFTPPLLLLLLLLLLZZZNNNNNNOIIOO
+ZZRRRRRREEENNNNNVVVVVVVVVVYYYYYYYKKCCCCCCCCCWCWWWWWWWWAAAAJJJJMMMMMMIIMEEEEEMMMMMDDDZZZZZZZLLLLLLJLLLLJZTTTTFFFFFFLLLLLLLLLLLLLZZNNNOOOOIIII
+ZZZRRRRRENENNNNNVVVVVVVVVVYYYYYYYYYBCCCCCCZZZZZDWWWWWWAAAAJJJJJIMMIIIIMEEEEJJMDDDDDDZZZZZZZLLLLLLLLLLLJTTTLTFFWFFFFFFLLLLLLLLLZZZZZZIIOOIIII
+ZZRRRNNNNNNNNNNNNVVVVVVVVVYYYYYYYYYYEECCCCZZZZZDDDDLDWWJAAJJJJIIIMIIIIMEEEEEDDDDDDDDDDDZZZZLLLLLLLLLLLJLLTLLFFFFFFFFFLLLLLLLLLZZZZZZZIIIIIII
+ZZZZRNNNNNNNNNNNVVVVVVVVVVYYYYYYYYYYYYCCCCZZZZZDDDDLDJJJJJJJJJIUIIIIIMMEEEEEDDDDDDDDDDDZZZZLLLLLLLLLLLLLLLLLFFFFFFFFFLFLLLLLZLZZZZZZZIIIIIII
+ZZZZNNNNNNNNNNNNVVVVVVVVVVYYYYYYYYYYQQCCCCZZZZZDDDDDDDJJJJJIIIIIIIIIHIMMEEEEDDDDDDDDDDDZZZZLLLLLLLLLLLLLLLLOFFFFFFFFFFFLZLLZZZZZZZZZZZIIIIII
+ZZZZZZNNNNNNNNNVVVVVVVVVVVYYYYYYYYYYYYNNCCZZZZZDDDDDDDDJIIIIIIIIVVVVIIIMMEEEDDDDDDDDDDDJJZLLLLLLLLLLVVVVVLOOFFFFFFFFFFFZZZZZZZZZZZZZIIIIIIII
+ZZZZZNNNNNNNNNNVVVVRRVVVVVYYYYYYYYYHDNNNNNZZZZZDDDDDDDDJJIIIIIIIIIIIIIIMMMMMDDDDDDDDDDDJIZLLLLLLLLLVVVVVVVVVFFFFFFFFFFFZZZZZZDDDZZZZZZZEIIII
+ZZZZZNENNNNNNNNNVVVRRRVVVVVYYYYHHHHHHNNNNODDDDDDDDDDDDDJIIIIIIIIIIIIIIIIMMMMDDDDDDDDDDIIILLLLLLLLLVVVVVVVVVVVFFFFFFFFFFIIDDZZDDXDZZZZZEEENII
+ZZZZZNNNNNNNNNNNVVRRRRVYVVYYHHHHHHHHHNNNNNDDDDDDDDDDDBBIIIIIIIIIVVVIVVVMMMMMJJJJIIIIIIIIIILLLLVVVVVVVVVVVVVVVFFFFFFIFFFIIDDDZDDXDZZZZZEEENII
+ZZZZZZZNNNNNRRRRRVRRRYYYYYYYYHHHHHHHHHNNNNNCCDDDDDDDDBIIIIRIIIIVVVVVVVVVMMMRRRRJJIIIIIIIIILLLIVVVVVVVVVVVVVVVVFFFFFIIIIIEDDDDDDDDDDDZZZEENNN
+ZZZZZZZNNNNNNNNORRRRYYYYYYYYHHHHHHHHHHNNNNNNNKDDEDDDDBBBIIIIIIIVVVVVVVVQMMRRRRRRIIIIIIIIIIIIIIIIIIVVVVVVVVVVVVFFHIIIIIIIEDDDDDDDDDWDZZEEEENN
+ZZZZZZZNFNNNNOOOOORRYYYYYYYYHHHHHHHHHHNNNNNNNNTTFDDDDJJBIIIIIIIVVVQQVVQQQQRRRRRRIIIIIIIIIIIIIIIIVIVVVVVVVVVVVVVHHHHIIDIIDDXDDDDDDDDDDZEEEEEN
+ZZZZZZZNNNNNNUUOOOOOOYYYYYYYYHHHHHHHHHHNNNNNNNTFFFFDDJJBJJIIVIIIIVQQQQQQQDRRRRSRRIIIIIIIIIIIIIIIVVVVVVVVVVVVVVVHHHYIDDDIDDXXDDDDDDDDEEEEEEEE
+ZZZZZZNNNNNNNUUOOOOOOOOYYYYYYHHHHHHHHHHNNNNNNNFFFFFDDJJJJJJIVIIVVVQQQQQQQQRRRRRPPPPIQIIIIIIIIIIIVVVVVVVVVVVVVVHHHYYLYDDDDDDDDDDDDDEEEEEEEEEE
+ZZZZZZUUUUNNUUUUOOOOPPOYYYXYIIHHHHHHHHHNNNNUUFFFFFFDAJJJJNJJVIVVVVQQQQQQQQNRRRRPPPPQQILQQIIIIIIIVIIVVVVVVVVVVVYHYYYLYDDDDDDDDDDEEEEEEEEEEEEE
+ZZZZZUUUUUUUUUUOOOOPPPPYYYXYIIIHHHOHXXXNNNNNNJJFJFFJJJJJJJJJVVVVVVVQQQQQQRRRRRRPPPPQQQQQQQIIIIIIIIIVIVVVVVVVVVYYYYYYYDDDDDDDDDEEEEEEEEEEEEEE
+ZZZZZUUUUUUUUUUOUUUUUPYYYYYYYIIHHHHHXXXXXNXXXJJFJJFJJJJJJJJJJJVVVVVQQQQQRRRRRRRPPPQQQQQQQQEEEIIIIIIIIIIVVVVVVVYYYYYYYYDDDDDUUEEEEEEEEEEEEEEE
+ZZZZZZUUUUUUUUUUUUUUUPPPYYYYIIXHHHHHHXXXXXXXXXXXXFFJJVVVVJJJJJJVVVVQQQQQRRRRRRRRRPQQQQQQQEEEEEEEEIIIIHIKIVBBGGYYYYYYYDDDDDDUUUEEEEEEEEEEEXEE
+ZZZZZZUUUUUUUUUUUUUUUPPPPYYYXXXXXXXXXXXXXXXXXXXXDDJJJVVVVJJJJJJVVVVVVRRRRRRRRPPPPPQQQQQQEEEEEBEEEEIIIHIIIVBGGGYYYYYYYDDUUUUUUUUUEZEEEEEEEEEE
+ZZZZZUUUUUUUUUUUUUUUUPPPPYYYXXXXXXXXXXXXXXXXVVVXDDJJJVVVVJJJJJVVVVVVVRRRRRRRRRPPPPQQQQEEEEEEEEEEEEEIIHHJJGGGGGGGYYYYYYDDUUUUUUZUEZEEEEEEEEEE
+ZZZUUYUUUUUUUUUUUUUUUPPPPPYYWXXXXXXXXXXXXXXXVVVXPPVVVVVVVJJJJJJVVFVVVRRRRRRRRRPPPPKQKKKEEEEEEEEEEVVVHHHHJGGGGGGGYYYYYDDDDUUUUZZZZZEEEEEEEEEQ
+ZZZZUUUUUUUKKUUUUUUUPPPPPPPYWXXXXXXXXXXXXYYXVVVPPPVVVVVVVJJJJJJJJFVVVRRRRRNEEEKPKKKKKKKEEEEEEEEEEEEHHHHHHYYYGGGGYYYYYDDDDZZZZZZZZZEEEEEUEEEE
+ZZZZZUUUUUUKKUUUUUUUPPPPPPPXXXXXXXXXXXXYYYYVVVVVVVVVVVVVVJJJJJJJFFFFVRRRRKNNKKKKKKKKKKKKEEEEEEEEEEHHHHHHHYYYGGGGGGGGGYDDDZZZZZZZZZZZZZZUEEEE
+ZZZZZDUULLKKKUKKUUUPPPPPPPPXXXXXXXXXXXXYYYYVVVVVVVVVVVVVVYYJJJJJFFFFFRRRRRNNKKKKKKKKKEEKEEEEEEEEEEEHHQHHHYYYGGGGGGGGGDDDDZZZZZZZZZZZZZZZZQQQ
+XZZZZDKKKKKKKKKKFXXXXPPPPPPPXXXXXXXXYYYYYYYVVVVVVVVVVVVVVYJJJJJFFFFFRRFFFFFSSKKKKKKKKEEEEEEEEEEEEEQQQQHHHYYYGGGGGGGGGDDDZZZZZZZZZZZZZZZQQQQQ
+XZZZZKKKKKKKKKKKKXXXXPPPPPPPXXXXXXXXYYMYYYYVVVVVVVVVVVVPPPQJJJSFFFFFFFFFFFJSJJJJKKKKKKKKEEEEEEEEQQQQQQQHYYYYGGGGGGGGGDDDZZZZZTTTTTZZZZZQQQQQ
+XZWWKKKKKKKKKKKKKXXXXXPPPPPPMMXMMXXXXXMYYYYRRYPPPPVVVVVVVVQQJSSFGOFFFFFFFFJSJJJJKKKKKKKKKEKEEEEEQQQQQQQQEBYYGGGGGGGGGDEDZZZZZTTTTTZZZDDZQQQQ
+XXKWKKKKKKKKKKKKKKXXXXPPPPPPMMSMMMMMXMMXYYYYYYXPPPVVVVVVVVQQJOSSOOOFFFFFFFJJJJJJKKKKKKKKKEKKQEEEPQQQQQEQEEEEGGGGGGGGGDEEZZZZZTTTTTZZZZZZQQQQ
+KKKKKKKKKKKKKKKKKWXXXXXXPPPPMMMMMMMMMMMXXYXXYYXPPPVVVVVVVVQQQOOOOOFFFFFFFFFJJJJJJKKJKKKKKKKKKKKCPPPPQQEEEEEEGGGGGGGGGEEEZZZZZTTTTTZZZAZZQQQQ
+KKKKKKKKKKKKKKKKKKXXXXPPPPPMMMMMMMMMMMMXXXXXXXXXPPPPPPPPPQQQQOOOOOOOOFFFFJJJJJJJJJJJKKKKKKKKKKKCCCPPQQEEEEEEGGGGGGGGGDEEEEZZZTTTTTZTTTTTQQQQ
+FFKKKKKKKKKKKKKKKKXXXXPPPPPMKMMMMMMMMMMMMXXXTXXXXPPPPPPPQQQQOOOOOOOOOFFFJJLJJJJJJJJJJJKKKKKKKKPPPPPPQQEEEEEEGGGGGGGGGEEEEEZZITTTTTTTTTTTQWWQ
+KKKKKKKKKKKKKKKKKKKXXXXPPPPMKMMMMMMMMMMMXXXXTTXXXXXPPPPPQQQOOOOOOOOOUJJJJJJJJJJJJJJJJJKKKKKKKPPPPPPPEEEEEEEEGGGGGGGGGEDDEEZZZTTTTTTTTTTTWWWQ
+KKKKKKKKKKKKKKKKAAAAAAPPPKPKKMMMMMMMMMMMXXXXTTTXXXXXPPPPQQQOOOOOOOOOOJJJJJJJJJJJJJJJJKKKKKKKKPPPPPPPPEEEEEEEEEEGGGGGGDDDEEEIITTTTTTTTTTTWWWQ
+KKKKKKKKKKKKKLKAAAAAAAPPKKKKKMMMMMMMMMMMMTTTTTTXTTXXPPPQQQQQOOOOOOOOOJSSJJJJJJJJJJJKKKKKKKKKKKKPPPPPPZEVEEEEEEEGGGGGGDDDEEDIITTTTTTTTTTTWWWQ
+KKKKKKKKKKKLLLLLAAAAAAPKKKKKKMMMMMMMMMTMTTTTTTTTTTTXPXPQQQQQQOVOOOOOOOJJJJJJJJJTJJJPPDKKKKKKKKKPPPPPPZQQEEEEEEEGGGGGGDDDDDDIITTTTTTTTTWWWWWW
+KKKKKKKKKKKLLLLAAAAAAAKKKKKKKKKKMMOMMMTTTTTTTTTTTXXXXXPQQQQQQQQZOOOOTTTTJJJJJJJJJJJPPPKKKKKKKKPPPPPPPQQQEEEEEEEGGGGGGZDDZZZVITTTTTTTTTWWWWWW
+KKKKKKKKKKLLLLAAAAAAAKKKKKKKKKKKKMMMMMTTTTTTTTTTTTTXXXQQQQQQQQQQSOOTTTTTTTJTJJJJJJJJPPPPPKKKKPPPPPPPOOQQHEEEEEEGGGGGGZZZZZJIITTTTTTTTTWWWWWW
+KKKKKKKKKKKZZLAAAAAAAAKKKKKKKKKKKKKTTTTTTTTTTTTTTTTXUUQQQQQQQQQQTTTTTTTTTTTTJJJJJPPPPPPPPPKKKKKKKKOOOQQQHEEEEEEGGGGGGZZZZZJIITTTTTTTTTWWWWWW
+KKKKKKKKKZLZZZPPZAAAAAKKGKKKKKKKKKKKTTTTTTTTTTTTOTTTUUUQQQQQQQQQTTTTTTTTTTTTJPJPPPPPPPPPPKKKKKKKKOOOJOOOGGGGGGGGGGGGGZZZZZZIIIIIIIIWWWWWWWWW
+KKKKKKKKZZZZZZZZZZZAAAAKGKKKKKKKKKKKVTTTTNTTTTTTOTTUUUUUQQQQQQQQUTTTTTTTTTTTJPPPPPPPPPPPPPPKKOKOOOOOOCOOGGGGGGGGGGZZZZZZZZZIIQIIIWWWWWWWWWWW
+KKKKKKKKZZZZZZZZZZZZAKKKKKKKKKKKKVVVVTTTNNNNTTCCCCTUUUUUJJQQQQQUUTTTTTTTTTTTTPPPPPPPPPYPPPPOKOOOOOOOOOOOGGGGGGGGGGZZZZZZZZYYIWIIWWWWWWWWWWWV
+KKKKKKKZZZZZZZZZZZAAAKKKKKKKKKKKKKKKVNNTNNNNNNCCLCCCUUUUJJJJQQUUTTTTTTTTTTTTTPPPPPPPYYYKKKOOOOOOOOOOOOODGGGGGGGGGGZZZZZZZYYYYWWWWWWWWWWWWWWV
+KKKKZZZZZZZZZZZZZZZAAKOKKKKKKKVVVVVVVVNNNNNNNNCCCCCUUUUUUCCJQQQUTTWTTTTTTTTTTTPPPPPPPYYKKKKOOOOOOOOOOOODGGGGGGGGGGZZZZZZYYYYYWWWWWWWWWWWWWWW
+ZZZZZZZZZZZZZZZZZZAAAAKKKKKKKKVVVVVVBNNNNNNJNNCCCCUUUUCCCCCCRUUUUTWWTGTGGTTTTPPPPPPPPYYYKKOOOOOOOOOOOOODGGGGGGGGGGZZZZUUYYYYWWGGWWWWWWWWWWWW
+ZZZZZZZZZZZZZZZZAAAAAAKKKAKKKVVVBBBVBBNNNNNJNNCCCCCUCCCCCCCCRRRRRTWWWGGGTTTTPPPPPPPYYYYYOOOOOOOOOOOOOOOOGGGGGGGGGGZZZZUUYYYUUUUGWWWWWWWWGGGW
+EZZZZZZZZZZZZZZZZAAAAAAAAAAGBVVVBBBBBBNNNNNNNCCCCCCCCCQCCCCCQQQRTTWWRGGGGGTTPPPPPPPPYYYYYOOOOOOOOOOOOGGGGGGGGGGGGGZZZZUUUUUUUFFWWWWWWWWWGGGG
+EEEEESSSZZZZZRRRRRAAAAAAAAAPBBVVBBBBBBCCGGGGGGCCCCCCCQQCCCCQQQRRRRRRRGGGGTTPPPPPPPPKYYYYYPPOOOOOOOOOOGGGGGGGGUUUUUUUUUUUUUUUUUFFWWWWWETWWTTT
+EEEEESSSGGGZZRRRRRRRRAAAAAPPBBBBBBBBBBBCGGGGGGCCCCCCQQGGGGGGQRRRRRRRGGGGGMTMMPPPPPPKKYYYYPPOOOOOOOOOOGGGGGGGGUUUUUUUUUUUUUUUUUFWWFFFEETTTTTT
+EESEESSSGGSZZRRRRRRRRRRAAAPPBBBBBBBBBBBGGGGGGGGGGGGGGGGGGGGGGRRRRRRRGGGGGMMMMMPPMMPYYYYYYPPPOOOOOOOOOGGGGGGGGUUUUVVUUUUUUUUUVFFFWWFFEEEWTTTT
+SSSSSSSSSGSCCRRRRRRRRRQAAAVPBBBBBBBBBBHGGGGGGGGGGGGGGGGGGGGGGRRRRRRGGGGGGGGMMMPMMMMMMYMMMSSPPOROOROORGGGGGGGUUUGVVVUUUUUUUUUVVFFFFFEEEWWTTTT
+SSSSSSSSSSSSCRRRRRRRRRQQAAPPABBBBBBBHBHGGGGGGGGGGGGGGGGGGGGGGRRRGGGGGGGGGGGMMMMMMMMMMMMSSSSPSRROOROOOGGGGGGGUGGGGVVUUUUUUUUCVVVFFFFEFFTTTTTT
+SLLSSSSSSSSSRRRRRRRRRRRAAPPPBBPHBBBBHHHHGGGGGGGGGGGGGGGGGGGGGRRRFFGGGGGGGGMMMMMMMMMMMMMSSSSSSRRRRROORGGGGGGGUGGVVVVUUUUUUUVVVVVFVFFFFFFFTTTT
+SSSSSSSSSSSSSRRRRRRRRRHHPPPPPPPHBBHHHHHHGGGGGGGGGGGGGGQQQQQJJJJRFFGGGGGGGCMMMKMMMMMMMMMSSSSSSRRRRRRRRGGGGGGGGGVVVVVVLLUUUVVVVVVVVFFFFFFCTTTT
+VSSSSSSSSSSSSRRRRRRXXRHHHPPPPPPPPHHHHHHHGGGGGGGGGGGGGQQQLQQJJJJRRFFGGGGGGCCCKKMMMMMMMSSSSSSSSSRRRRRRRGGGGGGGGGRVVVIITTTTVVVVVVVVVVVFCCFCCECC
+SSSSSSSSSSSSSRRRRRRRXRHHHPPPPPPPPHHHHHHHGGGGGGGGGGGGGQQVMMJJMJMMMFFFFFFFGECKKKKMMMMMMMMMSSSSSSSSSRRRRGGGGGGGAGGVFTTITTTVVVVVVVVVVLCCCNCCCCCC
+SSSSSSSSSSSSSRRRRRRRRRHHPPPPPPPPIIHHHHHHHHHIGGGGGGGGGQMMMMJJMMMMFFFFFFFFGCCKKKKKMMMMMMMMMMMSSSHHHHRRRRGGGGAAAGGGFTTTTTTVVVVVVVVVVVVCCCCCCCCC
+SSSSSSSSSSSSRRRRRRRRXXPPPPPPPPPPHHHHHHHHHTIIGGGGGGGGGMMMMMMJMMMMMFFFFFFFCCCCKKKKMMMMMMMMMMMMSHHHHHHRRRGGGGGGGGGGTTTTTTTVTVVVVVVCCCCCCCCCCYCC
+SSSSSSSSSSHSRRRRRRRRXXPPDPPPPPPPHHHHHHHHHTIIGGGGGGGGGMMMMMMMMMMMMMFFFFFFCCBKKKKKMMMMMMMMMMMXXXHHHHHRHHYYGGGGGGGGTTTTTTTTTVVVVVVVCCCCCCCCCYCB
+VSSSSSSSSSSRRRRRRRRBBBMPPPPPPPPPEHHHHHHHHHIIIIIIIIIIMMMMMMMMMMMMMMFFFFFCCCCCCCKKKKKMMMMMMMMXXHHHHHRRHHYYGGGGGGGGTTTTTTTTHVVVVVVCCCCCCCCCCCBB
+SSSSSSSSSSSRRRRRRRBBBBMMPPPPPPPMHHHHHHHHHHYDDIIYYIIIIMMMMMMMMMMFFFFFFFFFCCCCCKKKKKKMMMMMMMXXXXHHHHHHHYYYGGGGGGGGTTTTTZZZVVVVVVVCCCCCCCCCCBBB
+NNNNNSSSSSSRRRRRRRBBBBMPPPPPPPPMHHHHPPHHHHYDYYIYYYMMMMMMMMMMMMFFFFFFFFFFCBBBBBBBBBBMMMMMHMMXXXHHHHHHHHHHHGGGGGGGTTTGGZZZVVVVVCCCCCCCCCCCCBBB
+NNNNNNNSRRRRRRRRRRRRBBMPPPPPPPMMMHHPPPPPHYYYYYIYYYYYYYMMMMMMMMFFFFFFFFFFKBBBBBBBBBBKMMMMBDDBXXBBHHHHHHHHHGGGGGGGGGGGGGZZVVVVVVVOOCCCCCCCCBBB
+NNNNNNNSRRRRRRRRRRRRRBMMPPPPPPMMMHHPPPPPPYYYYYYYYYYYYMMMMMMMMFFFFFFFFFFKKBBBBBBBBBBKKMMKBBBBBBBBHHHHHHHHHGGGGLGGGGGGGGGVVVVVVOOOOOCCCCCBCBBB
+NNNNNNNSSRRRRRRRRRRRRMMMMMMMMMMMMMHCCCPPYYLYYYYYYYYYYMMMMMMMMIIFFFFFFFKKKBBBBBBBBBBKKKKKBBBBBBBBYHHHHHHGHGGGGLLGGGGGZGGOVVVOOOOONNCCCCCBBBBB
+NNINNNNSSRRRRRRRRRRRRMRRMMMMMMMMMMCCCCBBBBBYYYYYYYYYMMMMMMMMMFIFFFFFFFFBBBBBBBBBBBBKKKKKBBBBBBBBBHHHHHJGGGLLLLLGGGGGGGGOVVOOOOOBBBBCCCCCBXBX
+IIIINNNNRRRRRRRRRRRRRRRRMMMMMMMMMMCCCJBBBBBBYYYYYYYYYMMMMMMFFFFFFFFFFFBBBBBBBBBBBBBKKKKKOOOBBBBBBHBHHHJJLLLLLLLLGGGGGGOOOOOOOOOBBBBCCBBBBXXX
+IIIIIIRRRRRRRRRRRRRRRRRRMMMMMMMMMCCCCCCCBBBBYYYYYYYYYMWWWWWFFFFFFFFFFFFBBBBBBBBBBBBKKKKOOOBBBBBBBCBHHHJJLLLLLLLGGGGGOOOOOOOOOBBBBBBBBBBBBBXX
+IIIIIIIIRIIRRRRRRRRRRRRMMMMMMMMMMMCCCCCCBBBBBBBYYYYYYMWWWWWWWFFFFFBBBBBBBBBBBBBBBBBKKKKKBBBBBBBBBBBBJJJLLLLLLLGGGGGGGOOOOOOOBBBBBBBBBBBBBBXX
+IIIIIIIIIIIRRRRRRRRRRMMMMMMMMMMMMMMCCBCCBBBBBBBYYYYYYMWWWWWTTGFFFFFFBBBBBBBBBBBBBBBKKKKKBBBBBBBBBBBBBJLLLLLLLLGGGGUGGGOOOOOOOBBBBBBBBBBBBBXX
+IIIIIIIIIIIRRRRRRRMMRMMMMMMMMMMMUUMMCBBBBBBBBBBYYYYYJJWWWWWTTTFGFFBBBBBBBBBBBBKHHHKKKKKKBBBBBBBBBBBBBJLLLLLJJJRGGUUGGGOOOOOOOOBBBBBBBBBBBBXX
+IIIIIIIOOIIIRRMRRMMMMMMMMMMMMMMMUUUCCUUUBBBBBBBBYJJYJJJJWTTTTTFGKRKKBBBBBBBBBBBTHHHHHHHHBBBBBBBBBBBBJJLQQJLJJJUUUUUOOGOOORORRBBBBBBBBBBBEEEE
+IIIIIIOOOIIIRRMMMMLLMMLLLLMMMMUUUUUUUUUUUBBBBBJOJJJJSJJWWWTTTTFKKKKBBBBBBBBBBTTTHHHHHHBBBBBBBBBBBBBBJJJQJJJJJFFUUUUUOOOOORRRRRBBBBBBBBCCEEEE
+TIIIIIOOOOIIIMMMMMLLLLLLLMMIIUUUUUUUUUUUUUBBBBJJJJJJJJJWXTTTTTKKKKKKKKBBBBBBBTTTTTTHHHHBBBBBBBBBBBBBVVJQJJJJJJFUUUUUOUUORRRRRRBBBBBBBBCCCECE
+IIIJJIOOOIIIIIIMMLLLLLLLLLLIIIIUIUUUUUUUUUBBDDJJJJJJJJJJXTTTTTKKKKKKKBBBBTTTTTTTTTTTHHBBBBBBBBBVVBBBVVVJJJJJJJUUUUUUUUUORRRRRRBBRBBBBBCCCECE
+IIIJJJOOOIIIIIIMMMCLLLLLLLLHIIIIIUUUUUUUUUDDDDJJJJJJJJXXXTTTKKKKKKKKKBBBBTTTTTTTTTTHHHHHHHBBBBBVVBBVVVVVVVJJJJPUUUUUPUUORRRRRRRRRBBBBCCCCECC
+PPJJJOOOOIIIIIIMMMRRULLLLLLHIIIIIIUUUUUUUUDDDJJJJJJJJJXXXTTKKKKKKKKKKBBBTTTTTTTTTTTTHHHHHHBBBBBBVVVVVVVVVVJJJJPUUUUUPUUORRRRRRRRRBBCCCCCCCCC
+PPPPJOOIIIIIIIIMMMRRRLLLLLHHIIIIIIIIUUUUUUUUJJJJJJJJJJXIIIKKKKKKKKKKKBBBTTTTTTTTTTYTHHHHHHHBBBVVVVVVVVVVVVJJPPPPPUPPPURRRRRRRRRRRTBBBCCCCCCG
+PPPPOOIIIIVVVIIRRRRRRHHHHHHIIIIIIUUUUUUUUUUDJJJJJJJJJJJOIIKKKKKKKKNKKBBTTTTTTTTTTTTTHQQQHHHBVVVVVVVVVVVVVVVJPPPPPUPPUUUUURRRRRRRMTBBBTTCCCCC
+PPVVVVVVVVVVIIRRRRRRRRHRHHHIIIIIIUYYYYUYUUUDDJJJJJJJJJJJIIKKKKKKKKNNNNNTTTTTTTTTTTTTQQQQHHHPVVVVVVVVVVVVVVVPPPPPPPPPUUUUUURRRRRXTTTTBTTCCCCC
+PVVVVVVVVVVVVRRRRRRRRRHRRHHHIIIHIYYYEEUUUUZMDDDJJJJJJJJJIIIIIIIKKNNNNNTTTTTTTTTTTTTTTQQQPPHPPPPPVVVVVVVVVEEEEPPPPPPJJXXXURRRRRRXXTTTTTTGTCCC
+PPPYVVVVVVVVRRRRRRRRRRRRHHHHHIHHIEEYEEEEEMMMMMJJJJJJIJIIIIIIIIINNQQNNNNNTTTTTTTTTTTTTQQQPPPPPGPPPVVVVVVVVVEEEEPPPFFSJJXFURRRRRVRXTTGTTTTTTKC
+PPPVVVVVVVVVVTRRRRRRRRRRRRRHHHHHHHEEEEEEEMMMMYMJJJJJIIIIIIIIIILNNNNNNNNTTTTTTTTTTTTTTEQQPPPPPPPPVVVVVVVEEEEEEEEEPFFFJJFFFFRRRRRRRCCTTTTTTTKK
+PPVVVVVVVVVVVVVRRRRRRRRRRRRHHHHHHHEEEEEEMMMMMMMMJJJJIIIIIIIIIILLNNNNNNNTTTTTTTTTTTTTTPPPPPPPPPPPVVVVVVEEEEEEEEPPPFFFQQFFIRRRRRRRRRCTTTTTTKKK
+PVVVVVVVVVVVVVVVRRRRRRRHRHHHHHHHHHHEEHEEEMMMMMMMMJJJIIIIIIIILLLLNNNNNNNNNTTTTTYTYTTTTTPPPPPNNNPPPPVVVVVEEEEEEEEEPFFFQFFFIIIRRRRRRKTTTTTTTTKK
+PPVVVVVVVVVVVVVRRRRRRERHHHHHHHHHHHHHHHEEEMMMMMMMMMMJJIIIIIIIILLLLNNNNNNNNOTYYTYYYTPVVPPPPPPNVNNNNNVVVVVEEEEEEEEEPPFFFFFFFFIIIIIRIKITTTTTTTVV
+PPVPVVVVVVVVVVWRRREEBERHHHHHHHHHHHHMHHEEMMMMMMMMMMMIJIIIIIILLLLGLGNNNNNOOOOOYYYYYPPPPPPPPPPNNNNNNNNNNVVEEEEEEEEFFFFFFFFFFIIIIIIIIIITTTVVVVVV
+PPPVVVVVVVVVVVVRREEEEEHHHHHHHHHHHHHMMMMMMMMMMMMMMMLIIIIIIIIIIGGGGGGNNNNOOOOOYYYYYPPPPPPPPPNNNNNNNNNNVVVVVEEEEEEEFFFFFFFFFIIIIIIIIIIMVVVVVVVV
+PPPVVVVVVVVVOVVRREEEEEEEEHEHHHHHHHMMMMMMMMMMMMMLLLLIIIIIIIIIIGGGGGNNNNNOOOOOYYYYYYPPPPPNPPNYNNNNNNNNNNVVVEEEEEEEFFFFFFFJJJIIIIIIIIVVVVVVVVVV
+PPPPVPPVVVVVOVVHREEEEEEEEEEHHHHHHHMMMMMMMMMMMLLLLLSLLLIIIIIIIGGGGGGQQOOOOOOOYYYYYYYPPPPNNNNYNNNNNNNNNVVVEEEEEEEEFFFFFFFFFJIIIIIIIIIIIVVVVVVV
+PPPPVPPVPPVOOVVHEEEEEEEEEEEEEHHHHHHHHHMMMMMMMLLLLLLLLJLILIYLLGGGGGQQQQOOOOOOOYYYYYYYYPPNNNNNNNNNNNVVVVVVVEEEYEEEFFFFFFFJJJIIIIIICCYIIIVVVVVV
+PPPPPPPPPPPOOOOESEEEEEEEEEEEEEIIHHIHHHMMMMMMLLLLLLLLLLLLLLLLLLGGGQQQQOOOOOOOOYYYYYYYYYNNNNNNNNNNNNVVVVVVVEEEYYYYFFFFFFJJJJIIIIIICCYYIIVVVVVV
+PPPPPPPPPPPPPOOEEEEEEEEEEEEEEIAIIIIHHHIYYMMMMMLLLLLLLLLLLLLLLLGGGQQQOOOOOOYOOYYYYYYYYYYYYYYYNNNDDNJVVVVVVEEYYGYTTTTFFJJJJJIIIIICCCCIIIIIVVVV
+PPPCPPPCCCCPPPOEQEEEEEEEEEEEIIIIIIIIIIIIIIMMMMLLLLLLLLLLLLLLLLLGGQRQQQOOQYYOYYYYYYYYYYYYYYZYNNNNDVVVVVVVVVGGYGTTTTTFFFJJJJJIIICCCIIIIIIIIVVV
+PPCCCCCCCCCCOOOOCEEECCEEEEBBOOIIIIIIIIIIVVMVVVVVVVVLLLLLLLLLLMGGGRRRQQOQQYYYYYYYYYYYYZZZZZZYNNNDDVVVVVVVVVGGGGGGTTTTFTTJJJJIICCCIIINIIIIIVVV
+PPCCCCCCCCCOOOOOCECCCCCCCNBBBBIIIIIIIIIIIVVVVVVVVVLLLLLLLLMMMMGGMMRCCQQQQQQQQYYYYYYYYZZZZZZZNDDDDDDDDDVVVGGGGGGGTTTTTTTJJJJJJCCCICINIYIYYYYV
+PPCCCCCCCCCCCOOCCECCCCCCQBBBBBIIIIIIIIIIVVVVVVVVVVLLLLLLLLLMMMMMMMRCCQQQQQCCCRYYYYAZZZZZZZZZZDDDDDDDDDVOOGGGGGTGGTTTTTJJJJJJCCCCCCIYYYYYYYYY
+PPCCCCCCCCCCOOOCCCCCCCCCCBBBBIIIIIIIIIIIVVVVVVVVVVLLLLLLLLLMMMMMMMCCCCCCCCCCRRYYRZZZZZZZZZZZZZDDDDDQQDQOQLGGGGGGTTTTTTJJJJJJJJCCYYYYYYYYYYYY
+PPCCCCCCCCCCOOCCCCCCCCCCBBBBBIIIIIIIIIIYYYYYVVVVVVVLLLLLLMMMMMMMCCCCCCCCCCCRRRRYRZZZZZZZZZZZZDDBDQQQQQQQQQQQGGGGTTTTTTTJJJJJCCCCYYYYYYYYYJYY
+PPPPCCCCCCCCCCCCCCCCCCCCCBBBBIIIIIIIIIICYYYYVVJVVVLLLLLLMMMMMMMMCCCCCCCCCCCRRRRRRRZFLLLZZZZZDDDBBBQQQQQQQQQQGGGGTTTTTTTTTJJJCCCCYYYYYYYYYYYY
+PPPPCCCCCCCCCCCCCCCCCCCCCBBBBBBIIIIPIIIIYYYYVJJJVVVLYYYLMRMMMMMMMDCCCCCCCCRRRRRRRRLLLLLLZZZZDDDBBBBBQQQQQQGGGGGTTTTTTTTTTJJJCCCCCUYYYYYYYYYY
+PPPPPPPCCCCCCLLLLCCCCCCCCCCBBBIIIIPPIIIIIIIYVJJJJJJJYYYYYMMMMMMMCCCCCCCCCCRCCCRRRRLLLLLZZZZZZBBBBBBBQQQQQGGGGGGTTTTTTTTTTTJJJCCPCYYYYYYYYYYY
+PEPEEPPPCLLLLLLLLCCCCCCCCCCCCIIIPPPPIIIIIIVVVJJJJJJJYYYYYYMMMMMMCCCCCCCCCCCCCRRRRLLLLLAAZZBBBBBBBBBBQQQQQQQQQGGGQTTTTTTTTTTRRCCPPPYYYYYYYYHY
+PEEEEEELLLLLLLLLLCCCCCCCCCCIIIIIPPPPPPPVIVVVVVVJJJJYYYYYYYYMMMMMMCCCCCCCCCCCCCRRLLLLLLLALLLLBBBBBBBBBQQQQQQQQQQQQTTTTTTTTTTCCCCCPPPYYYYYYYYD
+PEEEEEELLLLLLLLCCCCCCCCCCCCCCIIIPPPPPPPVVVVVVVJJJJYYYYYYYYMMMMMCCCCCCCCCCCCCCRRRRRLLLLLLLLLLBBBBBBBBBBBBBQQQQQQQQQTTTTTTTTTTUCZCPPPYYYYYYDDD
+EEEEEEELLLLLLLLCCCCCCCCCCCCCCIIPPPPPPPPPVVVVVJJEJJYYYYYYYYMMMMMCCCCCCCCCCCCCCRRRRRLLLLLLLLLPBBBBBBBBBBBRQQQQQQQQQQTTTTTTTTTTTZZCCPPYYYYDDDDD

advent_of_code/2024/12/src/main.rs

@@ -0,0 +1,193 @@
+use std::collections::{HashMap, HashSet};
+
+fn parse(input: &str) -> HashMap<(i64, i64), char> {
+    let mut result = HashMap::new();
+    for (j, l) in input.lines().enumerate() {
+        for (i, c) in l.chars().enumerate() {
+            result.insert((i as i64, j as i64), c);
+        }
+    }
+
+    result
+}
+
+fn solve_1(input: &str) -> i64 {
+    let original_map = parse(input);
+    let mut visited: HashSet<(i64, i64)> = HashSet::new();
+    let mut result = 0;
+
+    for (&(x, y), plant) in original_map.iter() {
+        if !visited.contains(&(x, y)) {
+            let mut stack = vec![(x, y)];
+            let mut area = 0;
+            let mut perimeter = 0;
+            visited.insert((x, y));
+
+            while !stack.is_empty() {
+                let cur = stack.pop().unwrap_or_default();
+
+                area += 1;
+
+                let up = (cur.0, cur.1 - 1);
+                let right = (cur.0 + 1, cur.1);
+                let down = (cur.0, cur.1 + 1);
+                let left = (cur.0 - 1, cur.1);
+
+                let candidates = vec![up, right, down, left];
+
+                for candidate in candidates {
+                    if let Some(p) = original_map.get(&candidate) {
+                        if p == plant {
+                            if !visited.contains(&candidate) {
+                                stack.push(candidate);
+                                visited.insert(candidate);
+                            }
+                        } else {
+                            perimeter += 1;
+                        }
+                    } else {
+                        perimeter += 1;
+                    }
+                }
+            }
+
+            result += area * perimeter;
+        }
+    }
+
+    result
+}
+
+fn turn(dir: (i64, i64)) -> (i64, i64) {
+    match dir {
+        (0, -1) => (1, 0),
+        (1, 0) => (0, 1),
+        (0, 1) => (-1, 0),
+        (-1, 0) => (0, -1),
+        _ => unreachable!(),
+    }
+}
+
+fn rev_turn(dir: (i64, i64)) -> (i64, i64) {
+    turn(turn(turn(dir)))
+}
+
+fn solve_2(input: &str) -> u64 {
+    let original_map = parse(input);
+    let mut visited: HashSet<(i64, i64)> = HashSet::new();
+    let mut result = 0;
+
+    for (&(x, y), plant) in original_map.iter() {
+        if !visited.contains(&(x, y)) {
+            let mut stack = vec![(x, y)];
+            let mut area = 0;
+            visited.insert((x, y));
+            let mut edges = HashSet::new();
+
+            while !stack.is_empty() {
+                let cur = stack.pop().unwrap_or_default();
+
+                area += 1;
+
+                let up = (0, -1);
+                let right = (1, 0);
+                let down = (0, 1);
+                let left = (-1, 0);
+                let candidates = vec![up, right, down, left];
+
+                for candidate in candidates {
+                    let cand_coord = (cur.0 + candidate.0, cur.1 + candidate.1);
+
+                    if let Some(p) = original_map.get(&cand_coord) {
+                        if p == plant {
+                            if !visited.contains(&cand_coord) {
+                                stack.push(cand_coord);
+                                visited.insert(cand_coord);
+                            }
+                        } else {
+                            edges.insert((cur, candidate));
+                        }
+                    } else {
+                        edges.insert((cur, candidate));
+                    }
+                }
+            }
+
+            let mut sides = 0;
+
+            while edges.len() > 0 {
+                let start_edge = edges.iter().next().unwrap().to_owned();
+
+                let edge_side = start_edge.1;
+
+                let start_dir = turn(edge_side);
+                let mut dir = start_dir.clone();
+                let mut cur_edge = start_edge.clone().0;
+                let mut visited_edges_dir: HashSet<((i64, i64), (i64, i64))> = HashSet::new();
+
+                while !visited_edges_dir.contains(&(start_edge.0, start_dir)) {
+                    let next = (cur_edge.0 + dir.0, cur_edge.1 + dir.1);
+
+                    if let Some(p) = original_map.get(&next) {
+                        if p == plant {
+                            cur_edge = next;
+
+                            let left = rev_turn(dir);
+                            let left_edge = (cur_edge.0 + left.0, cur_edge.1 + left.1);
+
+                            if let Some(p2) = original_map.get(&left_edge) {
+                                if p2 == plant {
+                                    dir = left;
+                                    cur_edge = left_edge;
+                                    sides += 1;
+                                }
+                            }
+                        } else {
+                            dir = turn(dir);
+                            sides += 1;
+                        }
+                    } else {
+                        dir = turn(dir);
+                        sides += 1;
+                    }
+
+                    edges.remove(&(cur_edge, rev_turn(dir)));
+                    visited_edges_dir.insert((cur_edge, dir));
+                }
+            }
+
+            result += area * sides;
+        }
+    }
+
+    result
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The total price of all fencing is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The new total price of all fencing is {}", result_2);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 1930);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 1206);
+    }
+}

advent_of_code/2024/12/test.txt

@@ -0,0 +1,10 @@
+RRRRIICCFF
+RRRRIICCCF
+VVRRRCCFFF
+VVRCCCJFFF
+VVVVCJJCFE
+VVIVCCJJEE
+VVIIICJJEE
+MIIIIIJJEE
+MIIISIJEEE
+MMMISSJEEE

advent_of_code/2024/13/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2024/13/src/main.rs

@@ -0,0 +1,163 @@
+use nom::{
+    bytes::complete::tag,
+    character::complete::{i64, multispace1},
+    multi::many1,
+    sequence::{delimited, separated_pair, tuple},
+    IResult,
+};
+
+fn parse(input: &str) -> IResult<&str, Vec<((i64, i64), (i64, i64), (i64, i64))>> {
+    let (_input, result) = many1(tuple((
+        delimited(
+            tag("Button A: X+"),
+            separated_pair(i64, tag(", Y+"), i64),
+            multispace1,
+        ),
+        delimited(
+            tag("Button B: X+"),
+            separated_pair(i64, tag(", Y+"), i64),
+            multispace1,
+        ),
+        delimited(
+            tag("Prize: X="),
+            separated_pair(i64, tag(", Y="), i64),
+            multispace1,
+        ),
+    )))(input)?;
+
+    Ok((input, result))
+}
+
+// For a / b
+fn divisible(a: f64, b: f64, epsilon: f64) -> bool {
+    let div = a / b;
+
+    (div - div.round()).abs() < epsilon
+}
+
+fn equal(a: f64, b: f64, epsilon: f64) -> bool {
+    (a - b).abs() < epsilon
+}
+
+fn linear_solve_1(a: (i64, i64), b: (i64, i64), prize: (i64, i64)) -> Option<i64> {
+    const EPS: f64 = 0.000001;
+
+    let (fa1, fb1) = (a.0 as f64, a.1 as f64);
+    let (fa2, fb2) = (b.0 as f64, b.1 as f64);
+    let (p1, p2) = (prize.0 as f64, prize.1 as f64);
+
+    let y_denominator = fb2 - fb1 * fa2 / fa1;
+    if equal(y_denominator, 0.0, EPS) {
+        return None;
+    }
+
+    let y_nominator = p2 - fb1 * p1 / fa1;
+    if !divisible(y_nominator, y_denominator, EPS) {
+        return None;
+    }
+
+    let x_nominator = p1 - fa2 * (p2 - fb1 * p1 / fa1) / (fb2 - fb1 * fa2 / fa1);
+    if !divisible(x_nominator, fa1, EPS) {
+        return None;
+    }
+
+    let y = (y_nominator / y_denominator).round() as i64;
+    let x = (x_nominator / fa1).round() as i64;
+
+    if x < 0 || y < 0 || x > 100 || y > 100 {
+        return None;
+    } else {
+        return Some(x * 3 + y);
+    }
+}
+
+fn linear_solve_2(a: (i64, i64), b: (i64, i64), prize: (i64, i64)) -> Option<i64> {
+    const EPS: f64 = 0.001;
+    const BONUS: i64 = 10000000000000;
+
+    let (fa1, fb1) = (a.0 as f64, a.1 as f64);
+    let (fa2, fb2) = (b.0 as f64, b.1 as f64);
+    let (p1, p2) = ((prize.0 + BONUS) as f64, (prize.1 + BONUS) as f64);
+
+    let y_denominator = fb2 - fb1 * fa2 / fa1;
+    if equal(y_denominator, 0.0, EPS) {
+        return None;
+    }
+
+    let y_nominator = p2 - fb1 * p1 / fa1;
+    if !divisible(y_nominator, y_denominator, EPS) {
+        return None;
+    }
+
+    let x_nominator = p1 - fa2 * (p2 - fb1 * p1 / fa1) / (fb2 - fb1 * fa2 / fa1);
+    if !divisible(x_nominator, fa1, EPS) {
+        return None;
+    }
+
+    let y = (y_nominator / y_denominator).round() as i64;
+    let x = (x_nominator / fa1).round() as i64;
+
+    if x < 0 || y < 0 {
+        return None;
+    } else {
+        return Some(x * 3 + y);
+    }
+}
+
+fn solve_1(input: &str) -> i64 {
+    let (_, result) = parse(input).unwrap();
+
+    result
+        .into_iter()
+        .filter_map(|(a, b, prize)| linear_solve_1(a, b, prize))
+        .sum()
+}
+
+fn solve_2(input: &str) -> i64 {
+    let (_, result) = parse(input).unwrap();
+
+    result
+        .into_iter()
+        .filter_map(|(a, b, prize)| linear_solve_2(a, b, prize))
+        .sum()
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The fewest tokens spent to get all prizes is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!(
+        "With the huge positions, the fewest tokens to get all prizes is now {}",
+        result_2
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 480);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        let ts = parse(test_input).unwrap().1;
+
+        for (i, t) in ts.into_iter().enumerate() {
+            if i % 2 == 0 {
+                assert!(linear_solve_2(t.0, t.1, t.2).is_none());
+            } else {
+                assert!(linear_solve_2(t.0, t.1, t.2).is_some());
+            }
+        }
+    }
+}

advent_of_code/2024/13/test.txt

@@ -0,0 +1,15 @@
+Button A: X+94, Y+34
+Button B: X+22, Y+67
+Prize: X=8400, Y=5400
+
+Button A: X+26, Y+66
+Button B: X+67, Y+21
+Prize: X=12748, Y=12176
+
+Button A: X+17, Y+86
+Button B: X+84, Y+37
+Prize: X=7870, Y=6450
+
+Button A: X+69, Y+23
+Button B: X+27, Y+71
+Prize: X=18641, Y=10279

advent_of_code/2024/14/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2024/14/input.txt

@@ -0,0 +1,500 @@
+p=62,65 v=-96,-93
+p=50,44 v=72,74
+p=33,42 v=-6,-83
+p=68,100 v=36,21
+p=45,36 v=3,-44
+p=9,48 v=-14,47
+p=55,21 v=-71,-7
+p=65,10 v=-58,-9
+p=22,11 v=93,36
+p=25,38 v=58,-46
+p=82,16 v=-73,49
+p=93,31 v=-51,-77
+p=42,70 v=32,35
+p=17,0 v=-46,-26
+p=36,55 v=70,85
+p=94,101 v=53,-18
+p=4,73 v=17,-39
+p=17,4 v=89,7
+p=99,17 v=-50,-40
+p=20,101 v=-49,11
+p=82,24 v=13,-71
+p=11,64 v=49,-76
+p=2,98 v=94,90
+p=41,62 v=69,-43
+p=100,99 v=-50,-26
+p=84,60 v=16,68
+p=8,20 v=16,-50
+p=50,6 v=34,52
+p=17,50 v=-40,41
+p=90,88 v=-62,74
+p=25,36 v=-11,-46
+p=93,29 v=12,22
+p=47,62 v=61,-25
+p=68,22 v=-97,-36
+p=49,70 v=67,58
+p=31,13 v=-74,-71
+p=22,29 v=-77,47
+p=8,81 v=-14,87
+p=24,31 v=-41,26
+p=16,77 v=17,-18
+p=18,89 v=-79,83
+p=98,44 v=83,20
+p=66,73 v=-58,-51
+p=96,49 v=-52,-25
+p=82,5 v=-26,56
+p=63,16 v=6,-36
+p=8,25 v=-38,48
+p=85,38 v=38,34
+p=39,48 v=-39,16
+p=64,29 v=43,-87
+p=99,33 v=26,60
+p=52,91 v=53,30
+p=0,98 v=-12,7
+p=45,93 v=64,85
+p=67,55 v=90,-39
+p=19,78 v=90,-14
+p=87,92 v=-86,-7
+p=14,50 v=55,47
+p=79,23 v=-63,32
+p=61,66 v=-78,-5
+p=55,67 v=1,16
+p=90,10 v=-57,94
+p=21,76 v=-78,60
+p=83,76 v=-89,-29
+p=24,8 v=57,-63
+p=71,55 v=-57,51
+p=66,62 v=71,-91
+p=86,11 v=-54,-17
+p=81,21 v=-22,18
+p=92,6 v=14,75
+p=30,24 v=89,-83
+p=63,0 v=63,-19
+p=16,59 v=17,-89
+p=61,27 v=-63,30
+p=93,27 v=49,14
+p=17,39 v=-77,51
+p=75,97 v=-98,77
+p=21,63 v=86,-4
+p=4,72 v=-95,-89
+p=92,96 v=79,-88
+p=94,20 v=-84,-1
+p=73,15 v=38,-65
+p=81,0 v=12,-57
+p=6,61 v=-83,-86
+p=59,29 v=67,47
+p=58,40 v=31,-50
+p=61,55 v=-99,-99
+p=24,82 v=-47,6
+p=16,60 v=-84,-68
+p=92,30 v=-87,-52
+p=56,10 v=64,-98
+p=75,86 v=54,-30
+p=50,15 v=28,80
+p=14,81 v=-12,-10
+p=90,87 v=-87,-26
+p=98,53 v=-18,35
+p=11,16 v=-48,63
+p=62,86 v=71,58
+p=97,95 v=-28,72
+p=16,63 v=-29,35
+p=63,51 v=41,-63
+p=44,16 v=41,35
+p=9,72 v=14,-1
+p=7,37 v=51,63
+p=63,60 v=4,10
+p=83,77 v=80,64
+p=42,0 v=-37,-84
+p=99,101 v=99,5
+p=66,92 v=8,95
+p=91,68 v=16,-82
+p=59,37 v=-66,82
+p=99,2 v=-52,9
+p=53,2 v=-99,5
+p=87,97 v=-10,4
+p=15,48 v=63,-29
+p=100,7 v=14,7
+p=93,85 v=15,25
+p=73,6 v=-60,15
+p=53,6 v=45,62
+p=83,79 v=-22,-43
+p=100,93 v=17,-84
+p=1,51 v=-83,76
+p=98,30 v=-86,12
+p=78,24 v=-27,-3
+p=53,73 v=2,29
+p=43,19 v=-3,-7
+p=42,35 v=-35,55
+p=55,70 v=73,-9
+p=55,73 v=-99,-12
+p=82,88 v=77,-84
+p=52,82 v=49,-50
+p=99,5 v=-18,-61
+p=96,87 v=6,-58
+p=73,93 v=41,79
+p=39,34 v=99,-46
+p=78,38 v=14,26
+p=38,39 v=-6,53
+p=68,27 v=73,90
+p=57,43 v=-24,57
+p=7,66 v=-87,43
+p=0,13 v=-18,67
+p=72,69 v=12,-43
+p=66,61 v=-12,-90
+p=67,0 v=-99,-55
+p=43,94 v=37,-84
+p=70,15 v=-94,-1
+p=4,83 v=52,25
+p=57,41 v=-3,47
+p=18,89 v=-46,21
+p=64,12 v=37,98
+p=36,84 v=-41,-37
+p=47,62 v=-68,66
+p=40,13 v=96,-30
+p=100,0 v=-84,-59
+p=14,62 v=88,-99
+p=90,27 v=13,-48
+p=14,50 v=-33,-95
+p=57,1 v=-46,-70
+p=25,42 v=87,7
+p=82,77 v=-90,-41
+p=79,11 v=8,48
+p=64,51 v=43,-64
+p=93,6 v=-92,5
+p=41,55 v=-1,-23
+p=20,89 v=88,-49
+p=31,2 v=-44,-42
+p=40,100 v=-73,-92
+p=62,14 v=-14,-97
+p=9,4 v=-56,94
+p=81,69 v=10,-45
+p=25,1 v=30,-36
+p=3,28 v=83,82
+p=62,79 v=-62,62
+p=4,74 v=16,31
+p=43,54 v=33,-4
+p=87,43 v=-87,53
+p=0,25 v=-52,4
+p=49,63 v=-94,18
+p=87,31 v=45,22
+p=53,30 v=79,-38
+p=80,92 v=41,5
+p=36,99 v=-77,56
+p=74,13 v=42,-25
+p=78,85 v=-97,-24
+p=42,33 v=-73,83
+p=62,66 v=1,4
+p=100,64 v=-46,-2
+p=53,86 v=-38,-92
+p=53,13 v=93,-67
+p=74,75 v=41,21
+p=16,25 v=2,19
+p=39,74 v=-5,-2
+p=79,56 v=-37,-94
+p=28,54 v=-80,-21
+p=50,18 v=-77,-83
+p=33,98 v=-11,1
+p=89,79 v=-16,-51
+p=88,96 v=80,9
+p=49,90 v=-71,39
+p=95,89 v=-67,-16
+p=48,80 v=-99,13
+p=4,0 v=-51,7
+p=94,61 v=53,76
+p=13,36 v=-31,-44
+p=21,25 v=59,-44
+p=8,3 v=-80,11
+p=13,0 v=-80,-59
+p=26,72 v=90,-29
+p=51,98 v=-9,41
+p=95,92 v=87,-49
+p=6,65 v=-16,23
+p=63,87 v=72,8
+p=7,29 v=85,-7
+p=58,56 v=69,-10
+p=87,68 v=7,39
+p=10,32 v=54,-13
+p=43,100 v=31,11
+p=46,19 v=74,6
+p=31,96 v=99,58
+p=39,34 v=44,-11
+p=30,55 v=58,76
+p=79,94 v=10,83
+p=85,99 v=-87,-47
+p=92,96 v=14,-92
+p=35,43 v=-40,-52
+p=73,57 v=7,-35
+p=6,7 v=-37,-43
+p=64,72 v=2,31
+p=89,100 v=14,50
+p=11,47 v=-14,76
+p=64,3 v=-61,41
+p=73,102 v=41,-4
+p=62,45 v=5,-52
+p=42,81 v=-72,-76
+p=55,18 v=70,-1
+p=74,72 v=-60,62
+p=69,100 v=-66,92
+p=74,45 v=-60,6
+p=70,23 v=6,24
+p=8,63 v=18,57
+p=83,58 v=44,2
+p=88,28 v=-50,34
+p=91,12 v=52,63
+p=56,94 v=-67,-97
+p=3,73 v=51,35
+p=3,48 v=6,-98
+p=83,83 v=-5,39
+p=40,13 v=-7,10
+p=9,21 v=-49,-85
+p=98,7 v=18,40
+p=58,42 v=3,20
+p=65,2 v=5,-30
+p=69,12 v=40,-79
+p=37,70 v=29,-70
+p=91,101 v=47,-96
+p=28,4 v=89,-18
+p=2,1 v=81,-3
+p=10,57 v=-13,-33
+p=22,31 v=-10,-13
+p=16,39 v=21,-83
+p=41,59 v=68,65
+p=34,19 v=-4,28
+p=38,33 v=59,-93
+p=42,26 v=23,-80
+p=56,10 v=5,94
+p=38,63 v=-73,-68
+p=59,94 v=-96,-65
+p=16,35 v=57,53
+p=30,62 v=-45,71
+p=32,98 v=-28,-42
+p=3,0 v=80,52
+p=39,84 v=-38,17
+p=58,17 v=36,-3
+p=14,9 v=-84,-77
+p=27,86 v=-75,60
+p=54,12 v=-97,5
+p=59,9 v=-30,-34
+p=57,1 v=-42,-53
+p=12,1 v=-9,-5
+p=5,59 v=-82,41
+p=30,34 v=56,-53
+p=15,84 v=30,-30
+p=44,13 v=-97,-97
+p=3,101 v=-16,88
+p=13,60 v=38,-63
+p=19,31 v=-42,61
+p=35,13 v=94,3
+p=22,52 v=-81,-4
+p=30,60 v=12,32
+p=74,84 v=80,-4
+p=11,44 v=68,23
+p=23,44 v=88,24
+p=48,24 v=-11,-72
+p=52,49 v=33,84
+p=27,47 v=-72,51
+p=80,31 v=76,88
+p=40,34 v=63,-50
+p=34,11 v=-41,-32
+p=3,84 v=90,-12
+p=57,76 v=-38,-61
+p=76,63 v=-92,-56
+p=6,80 v=-9,50
+p=77,62 v=77,4
+p=37,44 v=57,-22
+p=94,40 v=13,-19
+p=43,52 v=66,41
+p=18,91 v=-79,-55
+p=90,79 v=65,-40
+p=7,7 v=-87,32
+p=11,47 v=-47,-17
+p=47,0 v=-36,47
+p=66,37 v=10,-48
+p=34,96 v=30,-16
+p=83,81 v=16,-9
+p=13,85 v=-54,-41
+p=51,7 v=26,78
+p=5,94 v=47,-75
+p=33,90 v=59,91
+p=61,92 v=90,-53
+p=7,18 v=-75,-93
+p=8,32 v=89,-46
+p=86,28 v=80,-15
+p=49,88 v=5,-51
+p=12,99 v=-46,-47
+p=91,66 v=80,37
+p=69,35 v=7,90
+p=78,9 v=7,-61
+p=97,80 v=21,4
+p=39,70 v=1,-35
+p=0,77 v=50,-41
+p=38,43 v=71,2
+p=31,42 v=61,-15
+p=43,76 v=97,-63
+p=51,15 v=-32,69
+p=78,42 v=-87,6
+p=71,18 v=40,38
+p=95,4 v=-47,-13
+p=11,1 v=-82,44
+p=58,101 v=75,61
+p=57,5 v=93,20
+p=50,71 v=41,28
+p=89,78 v=-19,-33
+p=35,61 v=-63,-1
+p=56,12 v=35,-34
+p=91,76 v=-76,-69
+p=33,31 v=-11,-13
+p=88,84 v=12,-10
+p=89,90 v=-26,-86
+p=18,19 v=-10,-42
+p=37,95 v=61,-20
+p=48,83 v=84,-58
+p=15,85 v=-30,-50
+p=13,58 v=19,49
+p=45,35 v=94,-75
+p=46,81 v=-3,89
+p=74,6 v=-25,77
+p=91,22 v=-53,-7
+p=2,9 v=35,-88
+p=89,101 v=73,28
+p=20,11 v=-87,28
+p=48,71 v=-77,8
+p=1,69 v=22,-37
+p=36,57 v=97,84
+p=25,37 v=-82,-52
+p=25,87 v=62,7
+p=0,58 v=16,68
+p=77,73 v=79,-35
+p=66,91 v=-96,21
+p=44,83 v=33,-76
+p=29,29 v=-10,-64
+p=89,24 v=98,-5
+p=92,63 v=83,-66
+p=10,70 v=20,-39
+p=78,16 v=-88,90
+p=18,22 v=-11,-81
+p=8,54 v=-15,-23
+p=4,15 v=52,98
+p=32,68 v=68,-6
+p=19,98 v=-12,-24
+p=85,66 v=-24,33
+p=36,39 v=-75,-13
+p=81,66 v=-71,-19
+p=1,27 v=-87,-37
+p=2,87 v=-15,19
+p=92,41 v=13,78
+p=100,40 v=-97,-75
+p=31,53 v=-99,49
+p=24,99 v=57,35
+p=55,17 v=40,-30
+p=24,60 v=59,-37
+p=33,62 v=-73,41
+p=99,58 v=50,37
+p=5,84 v=-44,-80
+p=83,65 v=34,88
+p=84,33 v=-95,-77
+p=69,63 v=1,-64
+p=8,88 v=-16,-18
+p=24,29 v=60,-69
+p=9,0 v=21,79
+p=42,87 v=2,-16
+p=64,44 v=33,8
+p=78,66 v=-88,-25
+p=63,76 v=72,29
+p=98,31 v=82,26
+p=74,62 v=42,35
+p=97,66 v=-74,-41
+p=86,31 v=12,-77
+p=31,81 v=63,68
+p=51,31 v=1,51
+p=77,18 v=3,-10
+p=64,57 v=72,-27
+p=60,56 v=-64,-87
+p=69,60 v=34,32
+p=8,90 v=-53,5
+p=3,70 v=62,37
+p=62,71 v=-35,66
+p=64,42 v=-71,97
+p=6,93 v=-99,-1
+p=5,24 v=89,3
+p=19,42 v=-73,49
+p=92,20 v=-92,53
+p=35,66 v=-73,37
+p=93,86 v=-91,99
+p=92,87 v=-22,58
+p=14,8 v=-49,-55
+p=86,56 v=-24,41
+p=50,15 v=99,-65
+p=92,81 v=79,-43
+p=25,63 v=-41,2
+p=71,19 v=43,-71
+p=3,21 v=51,18
+p=73,55 v=-94,41
+p=74,6 v=80,-94
+p=23,9 v=-9,10
+p=18,82 v=-16,19
+p=10,20 v=66,-7
+p=18,57 v=56,6
+p=1,89 v=-86,-47
+p=72,55 v=-95,-29
+p=95,50 v=-61,1
+p=97,10 v=48,38
+p=80,57 v=79,-97
+p=71,19 v=69,36
+p=27,71 v=-41,-78
+p=35,58 v=29,62
+p=31,73 v=28,66
+p=37,32 v=65,59
+p=60,102 v=85,-78
+p=38,54 v=16,96
+p=11,41 v=-80,20
+p=14,68 v=22,99
+p=48,46 v=-20,-19
+p=3,79 v=17,19
+p=10,9 v=-91,-66
+p=79,0 v=-25,-28
+p=38,26 v=-69,30
+p=80,40 v=77,-58
+p=36,69 v=62,-33
+p=97,60 v=-68,41
+p=70,59 v=-29,-76
+p=81,22 v=-92,-11
+p=15,55 v=57,43
+p=59,19 v=75,-28
+p=41,47 v=-3,18
+p=28,72 v=23,68
+p=2,26 v=85,67
+p=91,13 v=42,-77
+p=64,78 v=71,97
+p=91,35 v=14,-17
+p=41,69 v=63,29
+p=35,7 v=-69,96
+p=19,64 v=-12,-68
+p=77,44 v=70,55
+p=84,21 v=46,-71
+p=28,38 v=-76,18
+p=81,82 v=-20,-19
+p=91,10 v=48,36
+p=23,10 v=57,-22
+p=49,34 v=-77,-4
+p=73,25 v=75,-48
+p=67,25 v=-95,-11
+p=79,16 v=-26,-34
+p=27,81 v=-3,-47
+p=3,102 v=61,-94
+p=85,82 v=-54,21
+p=84,27 v=-89,94
+p=40,94 v=64,15
+p=97,57 v=-98,1
+p=6,80 v=86,-12
+p=42,77 v=30,2
+p=44,5 v=74,-49
+p=65,99 v=-24,-34
+p=64,6 v=73,-69
+p=37,65 v=-5,-29
+p=23,60 v=-77,-95
+p=25,35 v=-38,30
+p=9,9 v=64,87
+p=54,27 v=-69,63
+p=53,21 v=-14,-36
+p=42,31 v=2,30

advent_of_code/2024/14/src/main.rs

@@ -0,0 +1,115 @@
+use nom::{
+    bytes::complete::tag,
+    character::complete::{i64, multispace1},
+    multi::separated_list1,
+    sequence::{preceded, separated_pair},
+    IResult,
+};
+
+fn parse(input: &str) -> IResult<&str, Vec<((i64, i64), (i64, i64))>> {
+    let (input, result) = separated_list1(
+        multispace1,
+        separated_pair(
+            separated_pair(preceded(tag("p="), i64), tag(","), i64),
+            tag(" v="),
+            separated_pair(i64, tag(","), i64),
+        ),
+    )(input)?;
+
+    Ok((input, result))
+}
+
+fn calc_pos(
+    start_pos: (i64, i64),
+    velocity: (i64, i64),
+    width: i64,
+    height: i64,
+    time: i64,
+) -> (i64, i64) {
+    let x = (start_pos.0 + velocity.0 * time).rem_euclid(width);
+    let y = (start_pos.1 + velocity.1 * time).rem_euclid(height);
+
+    (x, y)
+}
+
+fn solve_1(input: &str, width: i64, height: i64) -> i64 {
+    let (_, result) = parse(input).unwrap();
+
+    let (mut q1, mut q2, mut q3, mut q4) = (0, 0, 0, 0);
+    for (x_end, y_end) in result
+        .into_iter()
+        .map(|(pos, vel)| calc_pos(pos, vel, width, height, 100))
+    {
+        if x_end < width / 2 && y_end < height / 2 {
+            q1 += 1;
+        } else if x_end > width / 2 && y_end < height / 2 {
+            q2 += 1;
+        } else if x_end < width / 2 && y_end > height / 2 {
+            q3 += 1;
+        } else if x_end > width / 2 && y_end > height / 2 {
+            q4 += 1;
+        }
+    }
+
+    q1 * q2 * q3 * q4
+}
+
+fn solve_2(input: &str, width: i64, height: i64) -> i64 {
+    let (_, mut robots) = parse(input).unwrap();
+
+    let mut min_e = i64::MAX;
+    let mut time = 0;
+
+    for t in 0..=100000 {
+        let (mut q1, mut q2, mut q3, mut q4) = (0, 0, 0, 0);
+        for (pos, vel) in robots.iter_mut() {
+            *pos = calc_pos(*pos, *vel, width, height, 1);
+            if pos.0 < width / 2 && pos.1 < height / 2 {
+                q1 += 1;
+            } else if pos.0 > width / 2 && pos.1 < height / 2 {
+                q2 += 1;
+            } else if pos.0 < width / 2 && pos.1 > height / 2 {
+                q3 += 1;
+            } else if pos.0 > width / 2 && pos.1 > height / 2 {
+                q4 += 1;
+            }
+        }
+
+        let e = q1 * q2 * q3 * q4;
+        if min_e > e {
+            time = t;
+            min_e = e;
+        }
+    }
+
+    time + 1
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input, 101, 103);
+    println!("The safety factor will be {}", result_1);
+
+    let result_2 = solve_2(input, 101, 103);
+    println!("The time that the easter egg occurs is {}s", result_2);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input, 11, 7), 12);
+    }
+
+    //#[test]
+    //fn test_2() {
+    //    //let test_input = include_str!("../test.txt");
+    //    //assert_eq!(solve_2(test_input), _);
+    //}
+}

advent_of_code/2024/14/test.txt

@@ -0,0 +1,12 @@
+p=0,4 v=3,-3
+p=6,3 v=-1,-3
+p=10,3 v=-1,2
+p=2,0 v=2,-1
+p=0,0 v=1,3
+p=3,0 v=-2,-2
+p=7,6 v=-1,-3
+p=3,0 v=-1,-2
+p=9,3 v=2,3
+p=7,3 v=-1,2
+p=2,4 v=2,-3
+p=9,5 v=-3,-3

advent_of_code/2024/15/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2024/15/input.txt

@@ -0,0 +1,71 @@
+##################################################
+#.#..OO.OO...O..OO..#.....O....#OO.#....#..OO....#
+#O..O......O#...O.....#..OO..O....O...OO##O..O#..#
+##.O.O...O.#.O...O#O...O.#O..#..#....#O.O.OOO...##
+###...O...O.OO..OO....O.........OO..OO..#..O...#O#
+#OOOOO...O.OO.O..OO.O.....O.O...OO..O#......O.O.##
+#..#..#..##.OOO.#O..O....................O#.O..#.#
+#.....O.O.O.OO..#.#.O...OOO.O.#.........O.#......#
+#........#....O..O.OOO.OOO..O...O.O.OOO.O...O.O.O#
+#..O..O........O..O#...O.O....#..O......O..O.#O..#
+#O....O.O...O.........#...#.....OO....O......OOOO#
+#..O.....OOO#O..O.O.#.............O.#OO....OO.O.O#
+#...OO.....#....OO......O#..OOO....O.O..#OO......#
+#....O#.......O....#.#.O..#.OO#O..O...OO..#O#O..O#
+#..O..O.........O..#.OO.#O......OO.OO......O...#.#
+#...............#...#.#...O#............O.......O#
+#OO...O.OOOO#O.....O........OO.OOO.OO....OO#.#...#
+#.O.#O..OO.OO..O..#..#..#..O...OOOO...........O#.#
+#...OO......O...O..O...O.O.O#..OOO......O#..O....#
+##..OO....OO.....#.O...O..OO.O.O..O##..O....#....#
+#......O...O....#OO..#.OO.O.O.O.#.OO...O....OO.#.#
+##.....#.OO.O.............#O......OOO#..........O#
+#.........O...#OO.....#.....O..#.....OO.O.#O.....#
+#.........#O...OO..O...#.OOO......O....O...O.O.#.#
+#....O..#...OO.OOO......@..#..O.O..O.O.......#O.O#
+#.OO.#O.O..#..O.......OO.....#.O.O...##O.......#.#
+#..O....O.O.....#.O.OO..O...#OOO.O...OO.O..#.....#
+#.#.O.OO.#...O.....#...O#.O..#O#O.OO............##
+#....#.O....O..O...OO...........O.O.OO.O.OO..#.O.#
+#O..O.O.O.OOO.O..O...#O.O..OOO.O#O...#.O...OO.O.O#
+#OO....#.....O.O..#.#.O.O..........OO.#..O#......#
+#..O......O#..O...##O.O..O.O.#...O.OO.O....O..O..#
+#.#..O.O.....#O.O...OOOO....O#O.OO#....O......OOO#
+##..#...OO###.O..O.OOO.O.O.........#..O..O.O..O..#
+##...OOOOO.OOOO#..O##...O.....O.O..OO....OOO#....#
+#....O.O..OO..#O..#...O........OOO.O.##.O.#.##..O#
+#.....OO..OO..O...#.....O.......#..........O.#.#O#
+##..#.....#.O...O#..O.....#.....#..#...OO....O...#
+#.OO...O.OO..#O#...#...O.O.##..O..#O#.........O..#
+#......O.O..O.OO.#.O.O..O...OOO....#.O.OO.O..O...#
+#..#...O...O..OOO..............O.#...O..O....O.###
+#........OOO...O..#.....OO...OO....O......#.OOO#O#
+#.##.OO..O.....##.OO.OO.#.O.##..#..........OO....#
+#..O.O..O.O.#.OOO...#....O..#..#.O.O....#.O..O..##
+#O..O..O..O.O.............OOO.O..O..O..O..O.OO##.#
+#...O#OO..OO...O.....O..#O.O...O...O.OO...OO.....#
+#..O...#..#.O....#.....#.OOO#........O.....#.O...#
+#.OO...OOOO.....#O......#.....O..O.O.O.#.........#
+#.....O.O#.O..OO......O..O.O.O....##O#..O.#...#..#
+##################################################
+
+vvv>>><v^v<v>^<v>^^v<>v>^>^^>v<v^^^<^<<>v<^vvv<^<v^><><^^<v>^^^^^><<>v<vvv^>^^<^vv<>v^v<^<<^<<v^vvv>>><>v<>vv>^<><^^v^>^>^^^<^^^>^^<<<><v>vv^^<>><v^^<vv>^vv^v^<v^>>>>^v<^><vv<^<<<<>><^^^v^v<>v>^v^<^^>>^^>^<<^v<^<>v<>v<vv><^<^<^><>>><<<>>v>>>>v>v^<><<<><>^<>^<^v>><v^v>v<^^<<>vv^v^<v<<^v<v<^^vvv<^<^v<^<^^>v^>v^>vv<v>>>vv>>^>^v<v<>>><v<<^<>v<>v^^^v<>>v^<><<vv>vv^<^v^^>^vv<>^<^vvv<<<v<>^^><vv<<<>>^><>>>>^^^^^vv>><>^vv<>v><v>v^^^>>v<<><v^v<^<^^vv<<^v>>v^<v<^<<^><>vv<vvv^><><^v^v<^><>>>^^>^>^^<v<<^>>vv<<v^^><^<vv<vv<<vv<<><^^^<v<<^<<^>>>><<<>^<<vv>^<>vv^<<^>^<^<v^v>v^<<><>>v^<>vvv>^^<>^<v^<v>v^><v<^v>^vv<>^<^<>^<^><<<v^><v^>^>^^<^<v^^><<^v^^>>>v<>vv<<v<<<^><vv<>><>>^><vvv^vv>^<^vv>v<^^>^>>^>v^<<<>><^^vv>^^<^^>>^<<v>><>v^><^^v^^v>^<<>>v<v^v^><<><^>^>^<^<>^<<v>vvv^^^<<>>><v^<>^^><^v^>^<v>^>v><>><^>v^><^<><vv^<<<^><<>vv><^^><v<^v>v><<<><<>^><v^<<>^><v>^^v<>v>^^^<><><^v>>v><<^<v>>v^<^<>^^v>v>^>>>v><>^^>^^v>v^^v<v^>>vvvv^v^<^vv^>>^^<v<v><^^^><><v<>>v>v<v^>^vv<>>^^>^vvv>v^^v>>^<^>>^>v^>>v><vvvv^>v
+v<^<><v^<v<vv<<v>v^<>^><vv<<<<v^>^>v<^^>v<v>v<>>^>>v<^^^v^^>v^><v>^^>>>^>v>>>v^><><<><v^v^vv^^^^v<<^>>v<^><<v^>v^>^^<v<<><^v<><v^^<vv^^<v^>^>>^v<v^v^<v^v<<^<^>v^<><<v><vvv^<^^^^<><><^^^vv^^>vv^>v<v^^<<^^<<<<<>^v^vv^vv^>>>vv<^<vv<^v<><^^>>v<<<<^^<v>>>v^><>^>>vv>>v<<><v>>v>>><<v^<v>>^<>v><^<<^<<<<v^^^vv<^>v<v<^><><<>^v^vv><v>^vv><<^v^v>vv^v<v>>v>^>v>>><<><><><v^<v>^<>^<>^v^v<>vv>>^<>><>^v^v<<^>v<<v<^>><>>^^v>v^vv><vv>^^>^v^>v>><<v><vvvv><>>>^<^v>v<<>>v^<<v>^<><v^v<><^^v<>^vv>^>v<^vvv<><>>vv>^^<v>^v<<v^^^<><>>>^<<>vv<><v><<>v<v>v>>^v>>v<vvv><<^>^^<^<>>>>v<^v^^^<<<<<^>^>>>^<^<^><vv<>^>^^v^><v^>>^<<^>^<v^^vv>v<>v><v^><>>>vvv><>v<vv^>>v<<><^<>>v>>><vv<>v>><vvvvv^><<<^><>>^^><v^<^^^v<^<^>^<v^<v^^^><^<v>v>^<<^<>^>v^<v>vvvv>v>>>v^vvvv>><>^>>><>vvv^<^<v>^^^>>^vv>>^v>>^>^^>^>>vv^^>><^<>>^^^^<^v><>^>^v>>><^vvv^vvvv<>^><^vv>>^^v<>^<<^v<^^<v>>v^<v>^><^><vv<<^<<<v^vv<<>v<v^^<><>^^>^v<<^<><v^v^><v>^><<v>^vv>^v^^v^><<vv>v><vvv><>^<>v>v>^<<^<<>vvv>>>><<>vv<^<><>^<^v><^<vvv^<>^^>>vv>v<>v>^^^vv<><<^>v<v^v
+<>^<^^v<vv>^>>^<^>^<v^vv<v<<v<^>>v^^v>^^v>v<<<<^<<v^<v>>v>v^v<^^<><<^v>^^^<v^^><v>vv<^^^<>>^<><^v><>><><^>^<<<v<<v>v<<v^vv^v<v>^^>v<v>><>v<v<<^>v>^<<v><<>^^^>^v<vvv<^<>><<>>v<^<>^v<>v>v>v<<<><^<^<>^<^<v>^<v>>>^<v>>>v<^v<^^^^>^<v>^><^><<><v>^>vv^>^v<<>>>v^v<>^<v<><><><<><<>^>v<>><<>^v<^<<<^v^>v^^^^>>><<^v>>>^><^v^^<<^^v><>>v^^^>>v<>^>vv<vvv^>>>>v<v<v^<^<>>^v<vv>^>^v^vvv<<^^><v<^v^v<vv^v>><^^<^>vv<v^^v><>>v^>>v<<>v^^<<^>>><<><><<<>^v>><<vvv<v^v<^<>>>>><^<<^<^><v>v>v^>v^v><v>v<^<^>v>><>v^<<v<<><^>v<^>v<^<v^v<>v^v^v>vvv<<><<>><^>vv^<^^^^<>>^v>>v^v>>v<v<<<v<><v^<>>v>>^><^>^^><^^v<<<><^>^v^>><><^>v><<v^>>><>^^v<>^<^v>v><<><>^<><<<^v>^^><>>^>><^v^v>>^><>v>v<^>><<><v>v^>^>v^vv>vv<^v^^v><<vv>v>vvv>^><v>v<>v>^^^v^>>^>>v^^>^>vv>v><^<>><^v>v>>>^<v<^vvv<vv>^>>^<^>^<<>>v<<^^<v><<^<^<<vv>^<>>^<>v<>>^v>vv<>^v<v>^>>v>^v^>^^<><><vv<>^v<^><<vvv^<><><<>^<<^>>>vvvv^v^v^<^<v<vvv<v>^vv<<>v><>^><>^v>v>>v>^v>v>^^^v<v<^vv<><><vvvv>^><^v><>>>v^<^v^>^>>>>><><<<>vv><v^>^v^>v<>>>v^>vvv<>v^v<v<^><v<<v^vv^^><v^<v^<^v
+>>>v<v^<<><^>>v^<>v<<^>>>^>><<<<>><v>><v<>>>v<>><vv^<>vvv>v<v>v^^<<^>^<<^>^v^^^<<>v>^<><^^<vv<>v<^>^<^^>^^^vv>>^<v<v>v^vv>^><v<^^v^v><<<^^v<v<v^><v^v>>v>^>v>vv>>>^^vv>^vv<^>^><v^v<>vv^<v^<<<><>vv>>vv>v>v^>>^vv^>v^<^>^><<>v>>><<>><v>^>>>^<<vvv>>^v<<<><>v^v^<vvv>vv<>^<<>^v><vv><v^>v>v^>^<<v<^<^<<v<<^^^<^v<vvv>^>v<<<v>vvv>^><<^<v<v>^>vv^<>v>^^^^<><^>^<<<<v<<^vv<<^v<>v<<<v^<^vv^><<vv<>vv^v>v><<>vv^><v>^vv<^v<^><^^v^^^^vvv<>><^<<<>>v>^^>^<^^^><<>><<^^^^vv^<<><<<v>^v^^v>vv><>v<>^<><^<<><><>^<v>v<>^vv^^<><<^<<<v<<<<>v><><>v<>>^v^^<^<><vv<>>><v<^v<^v<v^v<^^^^^<vv<<v^<<^<<vv<<vvv><^v^^<>^v<^<><><<v>v^^^v^>^<<v>>v>v^vvv^>>^>^<>>vvv><v<v><^^><v^<<v^^<<>v><<<v^<><^><^v^<<^<v<<<<v^<^^v^<>v>v><<v>^v<>>v<v^v^v^>^<v^^^>><^^^^v^<^^<<^<>^<v^><vvv><v<><><^^^v>v>><^<v<<>^^vv<vvv>>>>v<vv^<v>vv^^><<>^vv<^^<^<v>>vvvvv^v^>>vv<v>v<v<^v<>v^^<v^vv<v^>^^<<v^<<><^<<>v>v>^^<v>^^>v<>v<vvv<>v>v<v^>^<vv^<>>v^v<<^^v^>^<vv^v<<^vvv^^<>^v<><v<^<vv<>vvvv<v<^v>^>>><<v^v^<<^vv^v>^>vv^^>>>^>^<^>^v^^<><>^<<v<<^v<^<^v^<^^vv^^vv
+>>v<^><<v^>>^<<^^v>^<<^<<v<vvvv<<^^<^v>^^<<<vv><v>^<^^^^v>v>^<^><^^<>^vv<v<>>v><^<vv>v<>^^^><>vvv<>vv>>vvv^>^><<<<<>^>v^>v^^<^<^><><<^<<><<^<>v>^>>v<^<^^<<^^<>>>>^v><><v^^^v^v>>>vv>v<^^v<^^>>>>^^^^<>^v>^^<^^>^^vvvv^v>v<<^v>^v<>^>^^v>^><>v>vv>^v>^^v^><<<^^>^v^v^v^v>^>^>v<^<^>>v^<<><v><^^^^>^>>>v<<v^^^<><^v<>v^>>>><^v<>>v><vv^>>>vv^<>>v>vv>^>^v>>^><>v<v<>v<^>>v<>^>^<<^v^>v<>><^^<^vv><^v<<<v^v^<^^^^v<^><<vv<<>^vvv<^v^v^^>^>^v^^v>^<><<vvv>v>^^^^><v<<vv>v^<v<^^vv<<v<^<<<<<^v<vv<v>^<<>>vv^v^><^^^^<v<v>^^^v^v^^vv<v^v^<^>>^^<<<^v>vvvvv<><<>^<v^<^v>vv^v^<v<v^>^^<v>>>>>v^<<>^><v<^^><<v^><>^^>>v>v^<>v^^>>>>><>v^v>^^v<<^<<<<><v^<<vv^>>v<<^<<v<v^>>^^<><v>v>>^vv<<<v<v><v^vvvv>vv^<v<<^vvv^^^^v>^<^>^<<><v<<^>>^><>^v<v>^<v><><<v<<<^<v^>^^v^v><v<<><v<vv^^<v<<^^>^<<^<vv<>v>^>^<<<^^^^>^<^^vv<<v<<vv>>>>v><<>>><vv><<>>>v><<v>^>><>v<v>v^^^<>^><^v><>v<><>v>>^^<<<>><^^<><^><>>v>vv^<v^>>>v<<<>v<^^<^^<v^><><>v^<v>^^>>v^>^>vv>^^^<vv>^v<<<v<^^^>v<^<<^^v^vv>^>^v<^v>^<vv>v^v^^^v<^v>^>v<<vv^<<^^^vv<<^>vv^<v^vv><<<v>>
+<^>v^>>><<^v<^>>v^v>vv<^v^>>>^>^>v<>v>v<^^><<>^>^v<><^^v^>^>><^>^>v^<>^><<>>>^>>v><><<^^v<<^^>^>^v>vvv>>>vv>v<^^v^^v<vv<^>^<vv><v<vv^^<<><^<>v^vv>>^^vvv^<vv^<<><<<v^^<>v^^v<^<v^>>>^>^^v^^^^^<<vv><^<<v^v<v>>v>v<><^<<v<>>^>v><v>v<>vv<>vv<<^<v><>^^<>v><v<^>^^>^^vv<v^^<<<>>^^v<>^^>^vv<>v<>^v^v^v<>v<>^v^^^v<^<><v^v^>>^v<<<^>v>^^^v<>v<v^><^v>v<<>v^vv<>>><^<v^>v^<v^^v>^v^<<^<v><v^<^^>^>v<^>><>^^^vv<>^v<v^<^^<<>vv^><v>v<v<vv^v>>v<><<>^>^^>^<>v>>^^>v>>><<<^v^v<^^^v>>v>v<<>>^>><v^v<>^v<>v<><<<^>>v>vv^<v>^>><^v^><><>v>>^v>^>^<<v^v>v<vv^vvv^<^>v<^>^<v<vvv<^^<<<><v^><<>^>v^vv^^^v<vv<v^<>v^<^^<<><<v<<v^>^><>^<>>>^v<vvv<v<<<>vv<v>^>>v>>v>>^<v^vv<^^^<>>v<^^^vv<^>v<<><<<v^<^^^^<^>v<<>>>^<^vv>>>><>^<<<v<>v^<>^><v<<>>^>^^^<^vv<<<v<v^^>v>>v>^^>^<<<^<>^>><v^v<^<^>>^vv^<^^vv<v<vvv<^^^>^vv>>>^^v<v<^<<<^vv<><^><>><<<^<<>^<<>v<<^v><>^^^<<>v><^>^><><^^^<^vv<^>^<<^>>>>^^^<>v<v<v>><><>>^^vvv><^v<>^<v^^<^v<v<vvv^<<vv<<v<^v^v<v>^^vv>>>v<<<>vv<vv<v^>>^vv^v^><^<^<^<v><v><^<v<<v^^>><><<v><^><vv^^<<v><vv<><<^vvvv<v^vv>
+><<<<>^>>>^><><<vv^<<<vv<v^<v<<><<^<v<^>>^><>^><<>><>^<v<><^<^^^^vv^>v^><>v^^<vv>>v<^<v^^^^^^>v>^>v<v>><><^vv>v>>>>v^v^^v<^^<v>v>>v^v><<>v>v^^><^<v<<><><<^>>^vv><<^v^vv^vv<<^vv>vv<^^v<^^vv<v^<<>v<>v^<^^v^<vvvv^v><vvv<vv^><vv<v>v>v<>^>>><v>v>>vv^^>vv<>>^<>^>^><v<>>>>><>>v><<>>^<<>vv^<>^^>><<^^^<><^<v<v>^<<<>v<v^v>v>^>vv>>^^vv^>><>><>v^v>><^^<>>^^>^^>^^^^vvv^>v>^>v><>>vv^><^^v<>v<v<vv><>>^^>>vv^^^v^^v^^<>v<^<v<v^^vv<vv^><^>v>>^<<^^><^<^vv<^><^^>^<^><v<^^^>>><^^<^^v<v>^>^vvv<<vv>^<^<>^v<<>^^v<^^^<><>>v^v^><>>vv^^^^^^<<^^^v^^^v><>v<vv>vv<^^^^<^v<v>^^^><v^<^v^v>^>><vv><v>vv>>^<>^^><<>>>^v<>>v^><^<^><^^><<v<v^>v<<<^^<v>>>vv<v^v^^^^^^^>>^^><^v^<vv<<<>^^v>v>v<vv^^<v^^^>^^^v<v>v^^>^v><>^>v>v^^v<><<>>>v>^^<v^>>vv^<^^^^<^^<>^^<^v>^><>v<>^^^<vv><<vvv^^<<^v>>vv<>vv<v^^>>^<v>><^<v>>^v^^<<v<>>^^>><v^^>vvv^v<^v<^^^v^^>v^><v^vv<>vvv<<^v>v<^>v><vvvv<^v>v<>>>^<><>^^^>^<<vv>^v>v<<<^<^>>v<<vv^>>^^<<>^^^>>>v>>^<^^^<<>v>vv<^v><<v>>v^^<<^<vv<<><^<<^^>^v><><>v^v>>^^>vv<v<vv<v<v>v<>vv>v^><^v<^>^^^><><<>^^v<v<v^
+><^<<v^><<<<<<^>>^^<^^<^^^>^vvv>^<>^vv<><^vvv><vv^v<<v>>v^v>v>>v^vv^^^^^vv<><v>v<>v^vv>><^v^>^<>v<><v<<v^v<<^v<<<^<^vv>>>><^><^>>^>^<vvvv><<>>v<^<v>>^<>vv<>vvv^>>v^^>vvv<vvv^>>><v^<>^<><>v^v<^<v><>^^<^^vv<<>>^><>v<<>^<<>^^>>^>><^<v^>^<<>v^><vv^v<^^>^<>^>>^v^<<>>^<<<<^>><<^^^<^^<v^>v^^vv><<^^<>v<<v<^<^><^>><>v^>^v<^v>>>^>vvv<v^>vv^<><<>>v<^v>v<><v>>><<<^^<^<v^<v<<><vv<><v<^<vv>v^>^v^^<^^<>^<v<<<v^vv^^>v>^>^v<>^>v^<^^<>^^>vv^v^v<^v<v<<^>^>v<<>v^>v>><^v<>^<>><<^^v><>^^>>v^v><<<vv<^^<>v>^>>^^vv>^^>>v<<v<vvvv^^><v>^>>v>v^^^v><<v^vv><>><^<>^<>>v^v<^^v<vv<<^<<>v<>v>vv<>^>vv^>^v<<v<vv^<><>>^vv<^<v>>v<vv^^^^vv^^<^>>>>><^^<<^<<v>v>vv>><^v^v<^<vv>><>^^>v><^><^>>v^^>^^>>^^<v<<v>>v<<<><>>v^>vv>><<^<^v<^v<^<v<<>vv>v<<><v<^^^>^^<<v<v^>>><^v^>^>v<<>>>>^>>><v^^>v^>><>><v>>vv<>^>vv>v>>>^<v<^vv^><vv<^^vv^><>^<v><^>v<>><<v<<v^<v>v><^>v>>><<v^^<<^>>>^vv^>><^>>vv^v>^>^v>^<^v^>^<>v^>><<v<>^v^^><vvv>^><>>>^v<^<>v<>^<<><^>^>^v<^<v>v>>^<^^^v<<<^^<^v>^>^>^>^>^v^<^>^>^<v^><>^<v<^><>>v>^>v<<><<<v<^v>^<<^v<<<<^<<><
+^<>^v^<^<><>^>><v<^<>^><<<>^v>v^^v><<>>^^^^v^^^>^^v>v^v^^>><<^<^v>^<>>^><v^>vv^vv^^v<vv<^>v>v<v>^>v>>v<>><v^>>v><^^<>^^<^^v<^>vvv^>^<>^^v>>^v>>>>v>vv<^^^^<>vv^><>^^vv<^<^>^<>^v>^vv><^^<^v><<>v^^v<vvvv<>v>>v<^^>^<<>^<>>><<>v>^><<^>^^v^<v<vv<><v><>>^<^v><v<>>><^>vvvvv^^v^>^^^>v<<<><<^^^<v>^<vv>>>^<<^<<<^<vv><^>^^><<<v<>v^^>vvv^v^^vv^>>><v<^vvvv>^<<<<>><v>v<v^<<^<^<<^^<^vv>^>>>^v^^>v^^vv>^^<^v^<v>^<vv>v^>^>><<v>^vvv>v<v<<>^<v>>><>^^<v^>^>^v>v<^>>^^>^>v^vv^>^<>^<^v^<^<v<v<>>><<><><>v^<>v^v^v><^^v^v^<vvv>^<>>v^<><<v^v^^v>v^^<><v^>v>^><^v<<<v<^v>v<^<>v><<><>v^<<v^<^v^v<<^><^<>v<v><^<^<vv^>^^>^vv^<^^<><v><^>^v>^><^v<>v<<<<<<^<<^v<^^><^<^<<>><<>^<v<<<<^>vvv>v^v<<>v<^<>><<><<^^<<v<><<vvv^<^^v>vv<v<vv<vv^<<><vv<<<><vvv>>v^^<vvv<v>vv^><><^>^>^<<v^vv>^>>vv^<v>><^<>>>^>^v^v^^^<^v<^^v^<^><v<v^^>v>>^^>vv>><^<>v><vv^^^^^^^><v^vv>v^v><^v<><v<<v>v<^^>vv<v<v>v^^^^^<>vv^v^<^>>v^^^vvv^>>v^<v<<<>v<>v<<^>>>v>v^v><>>^v^^^v<>>^><>><>vv<>^>>>v<>><>^<<>v<v<v^vv>v^^<><>v><<^<^vv<^v^>^><v^^^<>v<>^^>><<>><v>^v>vv^v
+><v^v<v<^>>vvv<><>><^^vv>vv>><>><><>><>^vvv>>>><v>^^>^^^v>>><^<<v^v>><^^><^v<><v<^<<<>><<v<^v^v<^<v^<vv<^^^^^v<<vv><^>^>v>>>^<v^<<^<<^^^>>^v<>><^vv>v^^>v>^^<v^^><>v>>^v^><>>^>v<<>>^vv><v<^^v<<v<v><v^<><^>>v^v>^<<>>^v^^vv>>^<<<v>^>>vv><vv>>^>^^v^vvvvv>>>vv><>^<<v^^v^<>v^v>>^<v<<v>v<^>vv^>^>v>><^v^v>>^<v><>v>^><^<^<v^v>^^v^<><^<<<^v^^<><v<v<vv^v>v^^<^<v<v<^<><^v<<<>v^>v^<<>vv>>v^><^<^^vv^<^<<v^v<<^>^<^<^>v^^<v<><>><^^v>^<<<^v<>vvv^>vv>>>>v^vvvv^^<^^^v^<<v<v<><<v<vv^<v<v<>v<v<v^^v^vv><<^<<>>v<>^<>vv>^^vvv^>>>v>>>v^v>vvv<>v<<^^v><<<><<>>v>vv<<v<^^vvv<<<v^v<vv<vv>>vvv>>^v<>>^vvv><v^<>^<v><<^<v<>v<<v<^>>v<>v^^^<>vv^>><^><^>v<^^<>^>v>>>><vv^<>^^^v<^^<^<>v<v>v<v^<v<^v<^v<><><v<><<><>^>>>>^>v<^^vv^><v<v^>^<^^>>>^<v^^vv<<<^^>^^^>>^<^<>^v<<><vv^<^^^^v^<v<><^<v<vv<>^v><<^<<^v><>><^<>v><^<>^<^v^<>^^>^v^^^^>^<<vvv<^<<v>^^<^>^<<>v<<v<v>>>>^>v>><v<v<>^<<^v><<>v^^v^>v^^<^v^^><v<<v<vv^<v^<<<^v>>^<vv>>v^v^v^^<^v>><><><>v>>vvv>^<<><^>vv<^v>^<>><><<^>^>><<<<^^^vv><v<>v>>^<vvv>>^v><>^^^v>v><<>v<v>v>^v^^v>^v
+>v<^^>>^^<v<><><<>^<>>>v^^^<><^v<v^v>><>>^<^<><v^^vv^<<<>>><>>vv^>^vv^<^vv><v^>><^^v^vvvv^v<^v^^<^>>v^<vvv><>^v<v^<<<>v<<<>^v<v>v^>^^v>><<>^v^<vv>><<<vv^v>^^v<<^<<^<>^vvvv<>v^>^>vv<v>^vvv<<^><<^><<v^^^v^<>><^>>><^^><v>^v^v<^<>v^^<^vv<^^>vvv<v<^^v^<>v<>v<<^>>>><v^vvv>^>v<<<v<<>v>>v<^<<>^v<v^<vv<^v><v>>^>>><v>><<<>>^<<<>vv<<<>^>><>^<^>><<>^<vv>^><>>v<^<^<>^><<>^v^<^vv<<>v^>>>^>>^>^v>^<^>v>>^^v>v>>>^v^^^><^<^v^>vvv>v<v^<vvv><<^>^>><<>^^^>v>^<>v<><v<v<^<^^v>><vv>v^^v^>>^v<^^vv><><v^<v<<^v>vv><<><<<v^<v<^><v<^vv>v^>vv^<v^<^<vv^^<v^><^>^^><<v><<^^<>v^<<v^>v^<^><v^v>>><>v><v>>>v><<vv^v>v^>^<>^<vv<>vv>v>v><v^>>^>v^<vv^<>^><<>>>>>><vvv><><v<^>><<<^<^^<<v^><>^vv^>>vv>vv<>>><<^^<><<^<^>vv<><^>vv^^v>v^^v^^v<^^<v<vv^<v>v^^>><<^<v><<<>><<>v<>>^>>>^^^>v<<>v><>><^>>v>vvv>v<>><>>v>^<><>>v^>><>>vv<^>^>>>^>^><vv^<^>v<^vvv><><v<<<>>^<<^>^^^^vv><^><^>><>^<^<>><>^^v^^<v>>>>^vv^vv>^<^vv<<v><>>^<<>^^^v<><<^^>>v>vvv><^>>^^<<>>v<>v^<^>>><v<v^^<<><><>^v><<<>v^vv<>^<v^><v>^><^^>^^<>^>^<^^v><^v<v<<>^<<^>^^v<<<v<<v
+v<<<>v^<<v><v^v^^<vv<v>^v<<^<^v><^v<>^^v><v^^>^<vv<^v<v>>>>^v<<vv><>><^^vv^><<<^<<^v>v><><>vv>^<^vvv<^v>^<v<v<<<>>><>>^vvv<v^^<>v^<>v^><<<>><<<<^^><<v^vv^v^v<vv^^v<><<v<<^^<v^^><><^v^>>vv>vv>v^^^vv<>>v<vv>v<>><<^^^<vv^>v^><v<<v<<vv^<<>>>vv<><^^>^>vv^^><vvv^<><^<>>^><v<<<^>v^<><^^>vv<<vv<vv<^^^vvv^>><><<v>^vv>v<<^>vv^^>^v>v>v>v>v<>>vv<<>>^><<v>><<>^<vv^<>vvv<>^v>^^v<^v<v><<v^<^>v>^^v<<>^v<>>vv<^^^<^<><<v^<^>vv^^v^>>vv>^^>vv>^>vv^>^^v^>v<<^>vv>v>^<^<v><<v>>>v><^<<^^<>^v^><^<<v<v<vv^v^^^>v^v<<<v<v>^^<><^>^>>>v<v<^<><<v>^v^><<^<v>^<v>^v^<<^><v>v^<>^vv><vv^^^<^><<<vvv<>v>v<<><v>^vv<v<^<>>>^^v^^v<<^v>v>>^>^<v^>vv^v>v>^<>>v><v>>>><^v<v^>v<<vv^<v>>><>^<<>><<<>><>>>^^>^<vv>>v<>v^v^^<<><^^><v^vv>v<vvv^<v^>^v>v>v>^>^v><^<v<><>>v<^>^>>>v^>v><v^<>v>^><v<^^>^<^>>>>^^^^<>^<>>^v^<>v<v^v<<^v^^^v<v<><^^><<^^vv<>^vv<vv<>><><^<^^><^><v<<^>>><>^^>v<<<>^vv<>^>v>>^^><v>^<^>>v<<<vv><v^<^^<<><^<>^v^<vv^<<^^<^v^>^<^^^<^><>><>>^<>^<^vv<^vv^^>v><^>v><^>><^<^v><v<<^^^^v<vv<^>^v><<^<>>^<vv<vvv^v^vv^<vv>>>v<<<>v<^v>
+^^<<v<^>^v^>>v>v>><v<>^><>vv>v<<^^^<>^><vv^v>>v><<^>^<<^^>vvv<v>^>v>^^vv<^v<v<v^<<<<vvv>v^^<<^><v><^v><vv^vv<^^^>>>v^^vv^><<>>v^<vvv<<<^^>^<>>>^<>^<><>><<><^v^vv^^><^^<>>^<vvv<^^>>vv^>^^<vvv^<^><^^^vv>>>>v^<^<^<>^<^>>^v^^>v^^^v<>><^>^<>^>v^v>vvv^>^<^^>v>^>>v^<^<<>v>vv<v^^>v<^^vvv<>vv^^v^<<>^v>>^<^<v<>^^><>^^v><>v^^^<^>vv<<>vvvv^^><><v>^<>^>>^<v^v<>^>^v>>^^v<><>v^<<><<<v<vv^<>v>>^v><>>v^v<^v<^v<v<>vv^v<^vvvv<^><^v^<>^>^^>v><^^^vv><<^^>v^<^>><>v>v>v^^vv<^<^^<^<v<v<<vvvv^<><<<<<^<>^><>^^><^^v^v>v^><^v^>^<^><^vv><>^vv<><^^^^v^>^><><><><><^v^v<<<>^<<^v>><<<>>>^^<<vv^v><v^<<^>v^v>^<^^<<>vvv<>><<>v><<^><vv<^><v>^>>>^^<>v>v>^>><^>v>v<^<>v<v<><vvv^v>><^^^<>v<>^vv><v><<v^vv<^<v<v^<<vv<^v^v<<^v<v>v<>^^v>v>^^<<<^<><v><vvvvv<>vv>><v<v^<>^>^^>><>^^^<^>^<>^>^<<>v>v>^^vvv^<>v<^><^^^>v<<^>>^^<<^^<v><vv<v>vvvv>v<<<<>v>^^^^<<<v^>v^^>><^><^^>^v^>v<<^<v^><><>>^^^^>^^^^v^^<<^^><<><v<<v<v^v^><><^<^^<>^<v<^<^^^v<>>^><v^vv>><^v<<<>^>^vv^>v>><^v>^<>^^^^<v<>v>>^<vv<^>v<v>v<>>><>^<<<<<<^v<>^>><^^>><v^>>><<v<^^><<
+^^v>>v^<^<vv^^^><^>v^>><<<<>^^^vv<>v<^v^v<<<v>>>vv^<^vv<^v^^<<v>^^<^v^><>v<>^^vv><^<^v>>vvv<^>v>^><<v>^<>^^>v>>>>^>v^v<v<>>v^v<v^^<<><><>v<>v<^^<<^v>v^<v><vvvv>>v<^v^v<<v^<<><<><^><^vv^v<>>v^>v^^v><^v^>^<<v>^>>vv<vv^<><^^^v^>^^^v^^^<<v<>v>^>^<>^v^><^v^>^^<<>^v<v<^v^v^>>><vvv<^v^>^^^v^<<^^v>^v^^^>>v^<v^vv><>v<v^>^v<<<<v^<^<v>vv>><^^v^v<<^^v<vv><>>v<^<>vv>>^<<v<v^><v^^v>>>^>^>v^>vvv>^^<^>>^<^v<<><v^<v^>^>^^vvvv>^v^<vv>>v>v<^v^<^<^vvv^<>v>^vvvv>>^>^<>v<<<^^^<^>v>^^<^>>v<v<<v<^>^><v<v^<^^v<v<^^<>vv>v<<<vv^vv<^><<><<^^v<^<>>v<<^^<<<><v>v>><^<>>^>>v^><vv<v<>v^v^>^<^vv<^<^>v^^>^^vv<>^vvv>><<^v>>>>vvvvv^^>>^^><vv>>>v^v<><^<>v<vv>^>vvv<<<<>>>^<<>vvvv<v<^<vv^>vv<>vv<v>>v^>^^>^v<>>>><>^v<v<>^<v<^^<>><><<vv<<<<^><<>><v^vv<<v<v><<<v^<<^^>^^^<<<>v^v><v<<<>vv<v>^<v<v<<v>><^<^vv>>^^<vv^^<>v<^^<>>vv<>^^^v>v^<<<><vv>v>vv<<^<<^<><v<^v^><>vv^<<^>^^^<^^<v^^>v><>^<<v^<^<<<<<<v><^>>v<<v>>^^^>>^<<v<vvvv^<v<v>v>v>vv<<v<<v^v>vv>v><><^^^v<^^>^vv<<v^<^<vvv<^<>v>^v>>vvv><>>>v<<>>>>^^<vv^>>>^v^>>v^^>><<^^v^>^<><^<v
+v<>^v^<^>^>v<v>v>>>v^<v>>>v><vvv^><^>^vv^>>v<^<v><v^>>>>v^v^>^^^<>^>^^vvv>v<<^vv>^<>vv<<><><^>>^^^<^^^v<^>^v^^^^>v<><<<>>>vv^^<v>^<^^^>vv<<vv<><>v^<><v^>^<v<>^<<<^<v^^v<<^<vv<><v>v^<<><^^vv<<<<<^<>^>>v<<<vv^<^^v>v^<<v<^v>><^^^>^<^^<<v>><^^vv^^v>^>>>vvvv>vv^^^<>^^v>>vvvvv>><><v<>^v^>vvv>^><^><^^v>v>v<<v>v^<<^v<v<<>>v>><v>^v^<<^vvv^<><>v^><v^<v>^>^vvv^v^^^vv^>^<<<v<v^^^>><^^^<^><<><^>^^v<v<vvv^^v^v>^><v>>><>^^v<<vv><v>>>>>>v>>>^<><v<>v>^vv<vv><^^v>vv>>^><<^^v>^>vv<>v^^<^>>v><<>>^<><><>v>^<v<>>v>>v<<^v>>>><v<>>>v><<><v><^<<><><v^^v^>^v>^>^^v^>v<v>^^>^><^vv^<v<><<v>^<<^^>>^><^^<<v^<^^^<>>>v^^v^^v<vvv<<<^^v^>^>>^<<^^vv<<^<v<<^^v>v<v<<^<<vv>>>vv><^vvv<>^>><>>><>v<vv>>v>><>vvv<^><vvv<v<>^v^>^^vv>^<<<^^vv>v<v<v^<^v^<^v>v^>vv><v^<^^><^^<>^v^<^<><<^>>v>vv<<^^^v^^v>v^v<>^v>>>>>^^^><v^^^^^^vv^vv<<>^<<<<<>^^<v<^v<>^vvv^>v^<<>^<>^v^>^<v^^v<^v<<^<>v><vv<<>>v>>v<vv>><v^v^<><<vv<>>>>>v^>^<<>>><^v^>>>v><>v^>^>^^^>vv><v<v^^v^<><><^v>>^^<vv<<>><>>vv<<>v<>v^^>^<v^<<v<<^^^v>>^^^<><^v<<^><^>><>^v^<<>^<<><vv^
+vv<<^v<>vv^>v^<<<v<v<><<^vv^>v>^<<<>>>vv^><<<v^^^vv><^^><^^<^<v>>>>v<^v<>^<>v^v^vv<^vv^^^<<v<<^v^^^>vv>>v<^>v>^v^>v^^v^^v><><^<<^^^>vv>^<v>^v<vvv^v>v^^<vv<^v>>v^v<>v>vvv^v<>><^<^^<>vv<>>^^<^^^^<>>^>vv>^vv>vv<v^v^v>v>>^>^v^>v<^^<<^>><<<v<v^<^^v><<vv<>^>^<v^^<v<^<>v^v<^>>vv>^>^vv^^vv^<^v<v><v^^<^<>^<>v>>>^v><v><v<v<^<^>^<vv^><^^>>>>>vv^>v^<>><v<>><><^^>>^>^^v^<>><>vvvvv<^><>^vv>>^>>v^v^^<^<v>>^vvv><<<^<<>v>>v<<<<<^>v^^^v<>^v<v>>><v<<^vv<^>>>>>^>>^^^<^<<<v<<^>>vvv>v<v>^^^^><^^^v>vv<v^v^^<v>^^<>^>v<>v<><^v>^^<^<<^^>>>vvv^>v^<v^^<<v^v>^v>><v^<>^v<^^>^<>^<>^v<<>^^v>^v^^v^v>^>>vvv^>><v<^>^^><><^^>>^<^<^vv>>vv><^<<vvvv^^^vv^>><v^^v<^>^v<>v><vvvv^<^^<<>v>><v>><<<v<v>>^>v<>>v^<<<^v<v>v<^v>>>v>v>>>v^v>^^v>^^v^<<<<<>v^<v>>^>vv><^>v<^>>>>>^>v>><vvv<v>>>>v<v^^<^^^><v<v^^v<v^v<^<>^>^^>>v>^^v>>>^<v<<>^<>><v>^<^v<><>^v<^<><<<^v^v^^<<^<>>>><>>^<^v<><vv>>>^>vv>^^^v^>>v>><<<>^vvv^v^v>vv<<<^<<^>><>^v>>^v>^>vv^^v><^^vv^^<>>^v>^^<<^v<v^<><v<><^><<v>><<v<v<^<<<<v^<<v>>v>^<^^<^><^^vv^<<<><>v>>^v^<>^>vvv>>vv<<v
+><v<vv>>><<<^v^>>v>vv><><^><v^^>v^<<<vvv^<>^v^^^^<^<>vvv^<vv>^^>^^v^v^>^>^v<v<>><<>^v^^v><v<><vv<v^>v>>>v^^>^<>v>v>^vv<<>vvvv^v>^<>^<^^vvvvv>>>v>^^^<>>v<^>vvv<<v><v>^v^vvv<>v<>^v^v>v^^<v^v^v^<^v>vvv^vv^^^<>>^^<^>vvvvv<<^^v>^>v<^^vv^>>>^v^^<v^<>^>>>>>^<vv<<<><v><v>>^v>^vv^<<<<>v>vv<<^<^>>>vv><v^<v^v<<<^>v>^<<><v^vvv><<^vv>^^>>>v>><^^><v<v>v>v>^>v^>>v^v>^<><<^<<<>>^>v<^<v<<^><<v<v>><vv^<>>vv><^>^v<v^<<>>v<vv>^><<^<>v><^<>^<<^^<<<^v^>^^><vv^^^>^><^^^^<vv>v^^v><<v>>vv^>><v^v^^>v^<v^^>^^>^^^^<<^>^vvv<^>v^^>>>>><<>v>v^v><^>><v<vvv^<^>^^^>v^<<^<^^<>><^^v<><<<>^><<>v^<<^^>^v>v<<<<<>><^^^^>v>><^v>v>>^>^v^v>^vv>^vv<<<^><v<^v>^v<^<><^><^>^><<vv>>>^^^^vv><<v><^^v<v^v^>^<>v>^^^<v<v>><^^^>v^^<>><^<<>>^>>v>^v>>vv^^v>v<v><v^^>><vv>^^<<^vvv^v<^vvv><v><v<><<><<<^<v^^<v<^>vvv>v<<<<^>>^^<vv<>>^v^vv<^v><<>><vv^^><vv>vv><v^v^vvv>^v^v>><vv^<>v^vv>v><v>^^v<^^^<^<vv^vv<vv>v<>v<>v^><vv^^vv>^v>v<^^>>>v><>><^^>^^><^^<>>><^v^>v<vv><<v<<^v<^v><^^^>^v<>v>^v^><vvvv^v<>>><<<v>vv^^<^v>>^<<>v>>>>^>v<^<^^^vvvv>^<<<<^>^<>
+v<^vvv>vv<^v<v^^v<vvv>^^>^<v<^vv><>v<>vv^>^^><^^<<<^<>v><v<>><^<>^v^<><><<<><<v<<>vv><<<vv^vv^>><v^<^<^>><v><<<v<<v^<^<vv<<v^^v^vv>^v<^^v<<^>>^<>^<<^>v>>v^>><<^>vv^v<vvv>v^<^^^^<<^^^>><>v^^v><vv^^v<^>^v^v>v^^^v>v^>>^>v^^^>^>vv^vv^<><^vv^^<^v>v>v>^^^v<v^>vv><>v>v<<v^^>^<v^<>>v>>><><^<<v^v>^^<><v^v<<v<^<<^<<vv<^^v<v<vv>>>^v^^^v<^^>^>>>^v^<v^>>>>^>>v<>^^<<<vvvv^><<^^^<><<<><><>>^v<>^>>^^><<><<v<<<^v^v^^^<<<<>v>v>><<><v<v>>^vv^>v<<<<^><v>^<<v>v<<v<^>^<^^><<>^v^>>vvv<<>><<vv>^v^^^^<^^><>v^<^>>>^v^<^<v<vvvv^>v<v^v<v>^v^v>v<<^^v^<<<v^><v>>v><^<vv>>v<>^vvv<<<<v^^>vv>^>>^<<^<<>v>^^vv<^<vvv^^<^v<v^<>>v<>><<>>><<v^<<^^v>><^<<^v><^<^^^<^>>>>v>>^<<<vv><v<vv^<><<>^vvvv>v>v>>v><^v^>v>v>^v>vv^<<vvvvv^<>^^<v><^vv<v>^>v><<v>>^>^vv<<<^<^>vv^<<><><>v^><vv><<>v^v>v>>v^^^<<v<^>v>v^^<<v<>>^>>^<v<v^v<>>>>>^<>^v<<><v<<^>^^^^<^v^^^<>>^^><v>>>v<><<<^<^<v<^>^vvv<^^><^v>^^vv<<^<<<^v^^>v<<vv^<v>v>><^v>vvv<v>>^>v<>>><<><<><<>v><v^^><><<<^<^<>>v^>>^v<>vvvv^<vv>>v<vv^v^v^^><<v^<<>^>v^v<<>v^v<v<<^<>><<>>><<^vv<<v>v^<^v
+^<^^^<><^^v<v><<^<<^<<>>v^<<vv<<^^><>^^^<>><>>>^<vvvvv^<>v<v^^>><vvv^<>v^>^<><v^^>>^><>>^v>^vvv^^vv<v>>v^<v<vvv>v<>^>>vv^^>v<vv<<<>v^^^<<>>>>v<<^v^^^>^<^^><>><<vv<<><>>v^vv>^><<><^^>><vv^>>>^<^v^<<<>^^v<>vv>>><^^^<v>v<>><<vv<>v^>v>>v<>^^><>^>v<^>^vvv^>^>^vv<^>^>^v^>v<<v<<^^^>>>>v>>v<<<<^<^<v><><vv^>>><>vv<<v^v><<^^v<^<>^v^v^>vv^>v^vvv><<v^<<^^v<<^^<<><vvv^<>vv>v<<vvv>^<v^v<>v>^^vvv><^v<<v^>><^vv^^^^v>>>>v<<>>>v^>^^<<>^^v^<^<^vv^>>><v^>>>^v^>v^^<^>vvv<>^^v^<v<<v^><>^^<><>^^>^^vv<><^>v^<><^vv^v>^>v<>v^^v<^>v><<v<<<<v^^^><vvvv^<v<>^v>^^v<<^<vv^v^<<<vv>v^v<^v^^<<^>>v^v>^v^>^<<^>v<<><^<^^vv>^v<vvv>v^^<^>^<^<^vv^^v>^<^^v<><^<^^vv<v^v<<vvvvv^v><v<<^^vvv^v^^>><>vv><<<><^>^v<>vv>vv^>^v><v<v<v<><v<<^<>^>>vv^v><^>>v><>^^v>^<<><vv>^<^v><>>>^<vv>^^vv^>><>>v<<><>vvv>^^v><^<>>>^>v><^>><^v>^<<v<^vv>^v^<^v<<v<v^>>v^v<^^v<^<v>>>>^v^>v^>^>>v<^^><<><><^>^>>^>^^^^^v^^<vv^>v^<>vvv^><v>^<><vv><>v<<><vv>v^<>v<^^^vv<v^<>>>>^vv>v<<>v<>^>>>v>^v>>^<<<><^vv^>>>>v<^v<^>v>><<v<<vv<<>^<><<>^v^<>vvv>vv<><v>>v^><<<<v^>
+>vv>v<^vv^^v>v>^^^<>vvv<^<>vv^^vvv>>v^<><^v<^v>>>>>^<<v<^^^><vv>^<^>v^^>v<>>>v^v>^^v^>^v<v>v<><>^^<^^^^>^^<<><^<>^^>v><^v>v^>vvv>>^>v><^<<>^v<v<>^^vv><^^<v<^v>>>^v>>>^<>v^^><v^<^<<<<<v^<^vvvv<v<v<<v><v>^<vv<<<v>>v^^<>v>^<>>^>v^<^<^^v^^<<v<^>^vvv>^<^v^<^<<vv<v^>>v<<vvv>>><v<v<vv^v><><>>>v><v><v<<^^>^<><><><>^<^<^^<<<v<v>>^vv^>>>v^>^vv^>^>^<v>><^v<><><>>>>v<^v^>vvv>v^<^^^>v^<^<^v<v^v<^<v<v>>>>v^v>>>^>vv^><^^>vv<^^<v>>^>^^<vv<^<vvv^v>vv^<><>>vvv><vv^<^vvv><^^>>v^^^<>v^^<<>v>>^<^v<>^>>vv<^vv>^^>>v^v^<<^^>^<<^^^<>v^^^^^<^^v<>^^><<><^^<^^>><^>>>>vv<v<v^<><>>^<vv><<vv>vvv^^vv^<><v<>^<v^vv><^vv>v<>>^>^<v<>v<>^<>^><^<^>vvv^^^<>v<>^v^v<^^^vv<><^<v>v^<^^<v>^<<<<>>^><<^v>vv<<^v<v<>v^v>vv<^v>^<<^^>vvv<>v^><^^>^^<<<<^vv<v<<^^<^<<v^>>v<^v>vv<><^v^vv^<<>^<>>>^>>>^><<v><^<><><^<^<>>v<^>v<^><<v<v^><><v^v^<v^vv^v<v><<<>^^><vv^^v>^vv>^>v^<v>><<<<^>^^<<^v<<<^>vv><<<>^^<^^^<v<>>v^>^>v<>v<^><<<v>^>^^>v^^<vvv<>^>vv>v<>^>>^v<^<><<>>>v^v<><<vv^><^<>>><vvv<vv<v>vv^><^<^>>^<>><<<^<^vv^<<^>v^<<><>>^>>v><<^>><^v<>^

advent_of_code/2024/15/src/main.rs

@@ -0,0 +1,392 @@
+use std::collections::HashSet;
+
+use nom::{
+    branch::alt,
+    character::complete::{char, multispace1},
+    multi::{many1, separated_list1},
+    sequence::separated_pair,
+    IResult, Parser,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum Tile {
+    Empty,
+    Wall,
+    Box,
+    Player,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum UpgradedTile {
+    Empty,
+    Wall,
+    Player,
+    LeftBox,
+    RightBox,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum Move {
+    Up,
+    Right,
+    Down,
+    Left,
+}
+
+fn parse(input: &str) -> IResult<&str, (Vec<Vec<Tile>>, Vec<Move>)> {
+    let (input, result) = separated_pair(
+        separated_list1(
+            multispace1,
+            many1(alt((char('#'), char('.'), char('@'), char('O'))).map(|c| {
+                use Tile::*;
+                match c {
+                    '#' => Wall,
+                    '.' => Empty,
+                    '@' => Player,
+                    'O' => Box,
+                    _ => unreachable!(),
+                }
+            })),
+        ),
+        multispace1,
+        separated_list1(
+            multispace1,
+            many1(alt((char('^'), char('>'), char('<'), char('v'))).map(|c| {
+                use Move::*;
+                match c {
+                    '^' => Up,
+                    '>' => Right,
+                    '<' => Left,
+                    'v' => Down,
+                    _ => unreachable!(),
+                }
+            })),
+        )
+        .map(|x| x.into_iter().flatten().collect()),
+    )(input)?;
+
+    Ok((input, result))
+}
+
+fn calc_score(map: &Vec<Vec<Tile>>) -> u64 {
+    let mut score = 0;
+
+    for (j, row) in map.iter().enumerate() {
+        for (i, t) in row.iter().enumerate() {
+            if *t == Tile::Box {
+                score += 100 * j + i;
+            }
+        }
+    }
+
+    score as u64
+}
+
+fn calc_upgraded_score(map: &Vec<Vec<UpgradedTile>>) -> u64 {
+    let mut score = 0;
+
+    for (j, row) in map.iter().enumerate() {
+        for (i, t) in row.iter().enumerate() {
+            if *t == UpgradedTile::LeftBox {
+                score += 100 * j + i;
+            }
+        }
+    }
+
+    score as u64
+}
+
+fn move_one(coord: &(usize, usize), m: &Move) -> (usize, usize) {
+    use Move::*;
+    let (x, y) = *coord;
+    match m {
+        Up => (x, y - 1),
+        Right => (x + 1, y),
+        Down => (x, y + 1),
+        Left => (x - 1, y),
+    }
+}
+
+fn move_player(map: &mut Vec<Vec<Tile>>, pos: &mut (usize, usize), m: Move) {
+    use Tile::*;
+
+    let (x, y) = *pos;
+    assert_eq!(map[y][x], Player);
+
+    let (tx, ty) = move_one(&pos, &m);
+
+    match map[ty][tx] {
+        Empty => {
+            map[y][x] = Empty;
+            map[ty][tx] = Player;
+            *pos = (tx, ty);
+        }
+        Wall => {}
+        Box => {
+            let (mut bx, mut by) = (tx, ty);
+            while map[by][bx] == Box {
+                (bx, by) = move_one(&(bx, by), &m);
+            }
+
+            match map[by][bx] {
+                Empty => {
+                    map[by][bx] = Box;
+                    map[ty][tx] = Player;
+                    map[y][x] = Empty;
+                    *pos = (tx, ty);
+                }
+                Wall => {}
+                Box => unreachable!(),
+                Player => unreachable!(),
+            }
+        }
+        Player => unreachable!(),
+    }
+}
+
+fn solve_1(input: &str) -> u64 {
+    use Tile::Player;
+
+    let (_, (mut map, moves)) = parse(input).unwrap();
+
+    let (mut x, mut y) = (0, 0);
+    for (j, row) in map.iter().enumerate() {
+        let mut found = false;
+        for (i, t) in row.iter().enumerate() {
+            if *t == Player {
+                x = i;
+                y = j;
+
+                found = true;
+                break;
+            }
+        }
+        if found {
+            break;
+        }
+    }
+
+    let mut pos = (x, y);
+    for m in moves {
+        move_player(&mut map, &mut pos, m);
+    }
+
+    calc_score(&map)
+}
+
+fn upgrade_map(map: &Vec<Vec<Tile>>) -> Vec<Vec<UpgradedTile>> {
+    let mut new_map = vec![];
+
+    for row in map {
+        let mut new_row = vec![];
+
+        for t in row {
+            match t {
+                Tile::Empty => {
+                    new_row.push(UpgradedTile::Empty);
+                    new_row.push(UpgradedTile::Empty);
+                }
+                Tile::Wall => {
+                    new_row.push(UpgradedTile::Wall);
+                    new_row.push(UpgradedTile::Wall);
+                }
+                Tile::Box => {
+                    new_row.push(UpgradedTile::LeftBox);
+                    new_row.push(UpgradedTile::RightBox);
+                }
+                Tile::Player => {
+                    new_row.push(UpgradedTile::Player);
+                    new_row.push(UpgradedTile::Empty);
+                }
+            }
+        }
+
+        new_map.push(new_row);
+    }
+
+    new_map
+}
+
+fn rev_move(m: &Move) -> Move {
+    use Move::*;
+    match m {
+        Up => Down,
+        Right => Left,
+        Down => Up,
+        Left => Right,
+    }
+}
+
+fn upgraded_move_player(map: &mut Vec<Vec<UpgradedTile>>, pos: &mut (usize, usize), m: Move) {
+    use Move::*;
+    use UpgradedTile::*;
+
+    let (x, y) = *pos;
+    assert_eq!(map[y][x], Player);
+
+    let (tx, ty) = move_one(&pos, &m);
+
+    // These are all the tiles that need to be checked yet
+    let mut stack = vec![];
+    // These are all the tiles we have checked, in order to shift them if needed
+    let mut visited = HashSet::new();
+
+    match map[ty][tx] {
+        Empty => {}
+        Wall => return,
+        Player => unreachable!(),
+        LeftBox => {
+            if m == Up || m == Down {
+                stack.push((tx, ty));
+                stack.push((tx + 1, ty));
+
+                visited.insert(((tx, ty), LeftBox));
+                visited.insert(((tx + 1, ty), RightBox));
+            } else if m == Right {
+                let (mut bx, mut by) = (tx, ty);
+
+                while map[by][bx] == LeftBox || map[by][bx] == RightBox {
+                    visited.insert(((bx, by), map[by][bx].clone()));
+                    (bx, by) = move_one(&(bx, by), &m);
+                }
+
+                match map[by][bx] {
+                    Empty => {}
+                    Wall => return,
+                    _ => unreachable!(),
+                }
+            } else {
+                unreachable!();
+            }
+        }
+        RightBox => {
+            if m == Up || m == Down {
+                stack.push((tx, ty));
+                stack.push((tx - 1, ty));
+
+                visited.insert(((tx, ty), RightBox));
+                visited.insert(((tx - 1, ty), LeftBox));
+            } else if m == Left {
+                let (mut bx, mut by) = (tx, ty);
+
+                while map[by][bx] == LeftBox || map[by][bx] == RightBox {
+                    visited.insert(((bx, by), map[by][bx].clone()));
+                    (bx, by) = move_one(&(bx, by), &m);
+                }
+
+                match map[by][bx] {
+                    Empty => {}
+                    Wall => return,
+                    _ => unreachable!(),
+                }
+            } else {
+                unreachable!();
+            }
+        }
+    }
+
+    while !stack.is_empty() {
+        let (sx, sy) = stack.pop().unwrap_or_default();
+        let (bx, by) = move_one(&(sx, sy), &m);
+
+        match map[by][bx] {
+            Empty => {}
+            Wall => return,
+            Player => unreachable!(),
+            LeftBox => {
+                if visited.insert(((bx, by), LeftBox)) {
+                    stack.push((bx, by));
+                }
+                if visited.insert(((bx + 1, by), RightBox)) {
+                    stack.push((bx + 1, by));
+                }
+            }
+            RightBox => {
+                if visited.insert(((bx, by), RightBox)) {
+                    stack.push((bx, by));
+                }
+                if visited.insert(((bx - 1, by), LeftBox)) {
+                    stack.push((bx - 1, by));
+                }
+            }
+        }
+    }
+    let old_map = map.clone();
+
+    // Because of early returns in case of wall and empty and the empty stack in the case of a
+    // horizontal move, we can always assume we hit a box somewhere along the way and we have
+    // to move all those boxes here
+    for ((vx, vy), vt) in visited.iter() {
+        let (px, py) = move_one(&(*vx, *vy), &rev_move(&m));
+        if !visited.contains(&((px, py), old_map[py][px].clone())) {
+            map[*vy][*vx] = Empty;
+        }
+
+        let (nx, ny) = move_one(&(*vx, *vy), &m);
+        map[ny][nx] = vt.clone();
+    }
+
+    map[y][x] = Empty;
+    map[ty][tx] = Player;
+    *pos = (tx, ty);
+}
+
+fn solve_2(input: &str) -> u64 {
+    use UpgradedTile::Player;
+
+    let (_, (map, moves)) = parse(input).unwrap();
+    let mut map = upgrade_map(&map);
+
+    let (mut x, mut y) = (0, 0);
+    for (j, row) in map.iter().enumerate() {
+        let mut found = false;
+        for (i, t) in row.iter().enumerate() {
+            if *t == Player {
+                x = i;
+                y = j;
+
+                found = true;
+                break;
+            }
+        }
+        if found {
+            break;
+        }
+    }
+
+    let mut pos = (x, y);
+    for m in moves {
+        upgraded_move_player(&mut map, &mut pos, m);
+    }
+
+    calc_upgraded_score(&map)
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The sum of all boxes' GPS coordinates is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The sum of all big boxes' GPS coordinates is {}", result_2);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 10092);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 9021);
+    }
+}

advent_of_code/2024/15/test.txt

@@ -0,0 +1,21 @@
+##########
+#..O..O.O#
+#......O.#
+#.OO..O.O#
+#..O@..O.#
+#O#..O...#
+#O..O..O.#
+#.OO.O.OO#
+#....O...#
+##########
+
+<vv>^<v^>v>^vv^v>v<>v^v<v<^vv<<<^><<><>>v<vvv<>^v^>^<<<><<v<<<v^vv^v>^
+vvv<<^>^v^^><<>>><>^<<><^vv^^<>vvv<>><^^v>^>vv<>v<<<<v<^v>^<^^>>>^<v<v
+><>vv>v^v^<>><>>>><^^>vv>v<^^^>>v^v^<^^>v^^>v^<^v>v<>>v^v^<v>v^^<^^vv<
+<<v<^>>^^^^>>>v^<>vvv^><v<<<>^^^vv^<vvv>^>v<^^^^v<>^>vvvv><>>v^<<^^^^^
+^><^><>>><>^^<<^^v>>><^<v>^<vv>>v>>>^v><>^v><<<<v>>v<v<v>vvv>^<><<>^><
+^>><>^v<><^vvv<^^<><v<<<<<><^v<<<><<<^^<v<^^^><^>>^<v^><<<^>>^v<v^v<v^
+>^>>^v>vv>^<<^v<>><<><<v<<v><>v<^vv<<<>^^v^>^^>>><<^v>>v^v><^^>>^<>vv^
+<><^^>^^^<><vvvvv^v<v<<>^v<v>v<<^><<><<><<<^^<<<^<<>><<><^^^>^^<>^>v<>
+^^>vv<^v^v<vv>^<><v<^v>^^^>>>^^vvv^>vvv<>>>^<^>>>>>^<<^v>^vvv<>^<><<v>
+v^^>>><<^^<>>^v^<v^vv<>v^<<>^<^v^v><^<<<><<^<v><v<>vv>>v><v^<vv<>v^<<^

advent_of_code/2024/16/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2024/16/input.txt

@@ -0,0 +1,141 @@
+#############################################################################################################################################
+#...#.............#...................#.....#.#...............#.....#...#.......#.................#...#.........#.......#..................E#
+#.###.#######.###.#.###.###.#########.#.###.#.#.#########.###.#.#.###.#.#.#.###.#####.#.#####.#.###.#.#.#######.#.#.###.###.#####.#.#.#######
+#.....#.....#...#.....#...#...#.....#...#.....#.#...#.......#.#.#...#...............#...#.....#.....#.#.....#...#.#...#...#.#.#...#.#.......#
+#.#####.#.#####.###.#.###.###.#.###.###.#######.###.#.###.#.#.#.###.#.#######.#.#.#.###.#.###.###.###.#####.#.###.###.###.#.#.#.#.#.#.#####.#
+#.....#.#.....#.#.#...#.....#.#...#.#...#.......#...#.....#.#.#...#.....#.....#...#...#.#.#.#...#...#.......#.....#...#.....#.#...#...#...#.#
+#####.#####.###.#.#.#########.#.###.#.###.#######.#.#####.#.#.###.#######.#####.#.###.#.#.#.#.#.#########.#########.#.#######.#.#.###.#.#.#.#
+#...#.#.....#...#.#.#.........#.#...#...#.....#...#...#...#.....#.#.............#...#.#...#...#.........#.#...#.....#.#...#.........#.#.....#
+###.#.#.#####.###.#.#.#########.#.#.#.#.#####.###.#.#.#.#.#######.#.#######.#######.#.#.###.#.###.#####.#.#.#.#.###.###.#.#####.#.#.#.#.#.#.#
+#...#...#.....#...#.#...#.......#.....#.......#...#...#.............................#.............#...#.#.#.#...#...#...#.#.....#...#.#.#.#.#
+#.#####.#.#####.###.#.#.#.#########.#.#.#.#####.###.#####.#########.#.###.#.#####.###.#.#.###.#####.#.#.#.#.#########.###.#.###.#.#.#.#.#.#.#
+#.......#.....#.....#.#.......#...#...#.........#.....#.......#...#.#...#.#.....#.#.....#.#...#.....#.#.#.#...#.........#.#.#.....#.....#.#.#
+#############.###.#.###########.#.#.#.###.#.#######.#.###.#.#.###.#.#####.#####.#.###.#####.#.#.#####.#.#.###.#.#########.#.#.#.#.###.###.#.#
+#.....#.....#...#...............#...................#.....#.#...#.#...#.......#.#...#.#.....#...#.....#.#...#...#.#.....#.#.#...#.#.....#.#.#
+#.#.#.#.###.###.###################.#.#.#.#.#.#####.#####.#.###.#.###.#.#####.#.###.###.#.#.#####.#####.#######.#.#.###.#.#.#.#.#.###.#.#.#.#
+#.#.#...#...#...#.....#.......#.....#.#.....#.#.#...#...#.#...#...#...#.....#.....#.#...#.......#.#...#.......#...#.#.#.#.....#.#...#...#.#.#
+#.#.#####.###.###.#####.###.#.#####.#.###.###.#.#.###.###.###.#####.###.###.#####.#.#.###########.#.#.#######.#####.#.#.#.#####.#.#.#.#.#.#.#
+#.#.....#...#...#...#.....#.#.#...#.#.........#.#...#.....#...#...#.#.#.#...#.......#.#.#...#.....#.#.......#.#.....#.#.#.#.....#.#.#.#.#.#.#
+#.#.#.#####.###.#.#.#.#####.#.#.#.#.###########.###.#.#####.#.#.#.#.#.#.#.###.#######.#.#.#.#.#####.#####.#.#.#.#####.#.#.#.###.###.#.#.#.#.#
+#.#.#.#...#.#...#.#...#.....#...#...#.#.............#...#...#.#.#...#...#.....#.......#...#.#...#.#.....#.#.#.#.#...#.#.#.#...#.....#...#.#.#
+#.#.###.#.#.#.###.#####.#.#######.#.#.#.###############.#.###.#.#######.#######.#######.###.###.#.###.#.#.###.#.#.#.#.#.#.###.#.#######.#.#.#
+#.#.....#.#...#...#.....#.#...#...#.#.#...#...#.......#...#...#.......#.......#...#...#.#...#...#...#.#.#.....#...#.#...#.#...#...#.....#...#
+#.#.###.#.#.#######.###.###.#.###.#.#.###.###.#.#####.#####.#########.#.#####.###.#.#.#.#.#.#.#####.#.#.###########.#.###.#.#.#.#.#.###.#.#.#
+#.....#.................#...#...#...#...#...#.#...#.#.........#.....#...#.......#.#.#...#.#.#.....#.#.#...............#.#.#.....#.#.........#
+#.#.#.#.###.#############.#####.#.#####.###.#.###.#.###########.###.###.#.#######.#.#####.#.#####.#.#.#.#############.#.#.#####.#.#.###.#.###
+#.................#...#...#...#.#...........#...#.#.#...........#.#...#.#...#.....#.#...#.......#.#...#...#...#.......#.#.#.................#
+###.#.#.#.#.#####.#.#.#.###.#.#.#######.###.#.#.#.#.#.###########.###.#.#####.#######.#.#.#.###.#.###.###.###.#.###.#.#.#.#.#.#.###.#.###.#.#
+#.#.#.#.#.......#.#.#.......#.#.#.......#...#.#.....#...#.........#.#.#.....#.#.#.....#.#.#...#.#...#...#...#.#...#.#.#...#.#.#.#.....#.....#
+#.#.#.#.###.#.#.#.#.#######.#.#.###.#####.###.###.#####.#.#####.#.#.#.#.###.#.#.#.#.###.#.###.#####.###.###.#.###.#.#.#.#.###.#.#.#######.###
+#...#.#.#.....#.#.#.....#...#.#...#.#.....#.......#.....#.#.#...#.#.#.#...#...#.#.....#.#.#...#.....#.#.#...#.....#.#.#.#.....#.....#.......#
+#.###.#.#.#.#####.###.###.#.###.#.###.#########.###.#####.#.#.###.#.#.#######.#.#.###.#.###.###.#####.#.#.#########.#.#.#####.###.#.#.#####.#
+#.#...#...#.......#...#...#...#.#...#.#.........#...#...#.....#.#.#.#.#.....#.#.....#.#.....#...#.........#...........#.....#.....#.......#.#
+###.#.#.###.#####.#.###.#####.#####.#.###.#.###.#.###.#.#####.#.#.#.#.#.###.#.#.#####.#####.#.###.###########.###.###.#.###.#####.#########.#
+#.......#...#.....#...#...#.#.....#...#...#...#.#.#...#.#.....#.#.#.#...#...#.#.#.....#.#...#...#...#.......#...#.#...#.#...#.....#...#...#.#
+#.###.#.#.#####.#####.###.#.#.###.#.###.#####.#.#.###.#.#.#####.#.#.#####.#.#.###.#####.#.#####.#####.#####.#.#.###.###.#####.###.#.#.#.#.#.#
+#.#...#.#.....#.#.......#.#.....#.#.#...#...#.#...#...#...#.........#.....#.#.....#...#.#.#...#...........#.#.#.....#...#.....#...#.#...#...#
+#.#.#.#.#####.###.#######.###.#.#.#.###.#.###.#.#.#.###########.###.#.###.#.#.#####.#.#.#.#.#.###########.#.#.#######.###.#####.#.#.#######.#
+#.#.....#...#.........#...#...#.#.#.....#.....#.#.#.#...#.....#.....#.#...#.#.#.....#.#.#.#.......#.#.......#.#.....#...........#.#.#.....#.#
+#.###.#.#.#.###.#######.###.###.#.#######.#######.#.#.#.#.###.#####.###.#.#.###.#.###.#.#.###.###.#.#.#####.#.#.###.#############.#.#.#####.#
+#.#...#...#.#...#.......#...#...#.....#...........#.#.#...#.#.....#.....#.#.....#.#...#.#.....#.....#.........#.#.....#.....#.......#.#...#.#
+#.#.#.#####.###.#.#####.#.###########.###.#########.#.#####.#####.#.#############.#.###.#.#####.#####.#####.###.#####.#.###.#.###.###.#.#.#.#
+#...#...#.#...#.#.......#.....#.....#...#.#...#.#.............#.#.#.#.....#.....#.#...#...#...#...#...#...#.#.....#.#.#...#...#.............#
+#####.#.#.###.#.#######.#####.#.#.#.###.###.#.#.#.###########.#.#.###.###.#.#.#.#.###.###.#.#.###.#.###.#.#.#####.#.#.###.#######.###.#######
+#.#.....#...#.#...#.....#...#.#.#.#...#.....#.#...#.........#...#...#.#.#.#.#.#.#...#...#.#.#...#.#.#...#.#.....#.#.#...#.......#...#...#...#
+#.#.#.###.#.#.#.###.#####.#.#.#.#.###########.#.###.#######.###.###.#.#.#.#.#.#.###.###.#.#.#.#.#.#.#.###.#####.#.#.###.#.#####.#.#.#.#.#.#.#
+#.#.#.....#.....#...#.....#...#.#.........#...#...#.......#...#.#.....#.#.#.#.#.....#.#.#.#.#...#.#...#...#...#.#.#...#.#.....#...#.#.#.#.#.#
+#.#.#.###.#######.###.#####.###.#####.###.#.#############.###.#.#.###.#.#.#.#.#####.#.#.###.#.#####.###.###.#.#.#.###.#.#########.#.#.#.###.#
+#.#...#.#.........#...#.....#.......#.#.#.#.............#.#...#.......#.#...#.#.#...#.......#.....#...#.#...#.#.#...#...........#.#.#.#.....#
+#.#####.#.#####.###.#####.###.#######.#.#.#########.#####.#.#####.#.###.#####.#.#.###.###########.#####.#.###.#.#.#.###########.#.#.#.#####.#
+#...............#.......#...#.#.....#.#...#.....#.#.#.....#.....#...#.........#.......#.........#.....#.....#.#.#.#...#.....#...............#
+#######.#.#####.#.#####.#####.#.###.#.#.###.###.#.#.#.#########.#.#####.###.#.#.#######.###.#########.#.#####.#.###.#.#.###.###.#.#.#.#.#.#.#
+#...............#.#...#.......#...#...#...........#...#.......#.#.#.....#...#.#.#.......#.#...........#...#...#...#.......#...#.#.#...#.....#
+#.###.###.#.#.###.#.#############.#######.#############.#.###.#.#.#.#.###.###.###.#######.#################.#####.#######.###.#.#.###.#####.#
+#.#.............#.#.............#...#.....#...........#...#...#.#.#.#.#...#...#...#.....#.......#...........#.....#...#...#.....#...#...#...#
+#.#.#####.###.#.#.###.#######.#####.#.#####.#########.#.#.#.###.#.###.#.###.#.#.###.###.#######.#.#.#########.#####.#.#.###.###.###.#.#.#.#.#
+#...........#...#.....#.......#.....#.#.....#.......#...#.#.#.#.#.....#...#.#.#.....#.#.......#...#.#.......#.#.....#.#...#...#...#...#.#...#
+#.###.#.#.###.#.#######.#.#.###.#.#####.#####.#####.#####.#.#.#.###.#####.#.#.#####.#.#######.#.###.#.#####.#.###.###.#.#####.###.###.#.#.#.#
+#...#.#.......#.#.......#.#.#...#.#.....#.....#.....#.....#.#.#.......#.#.#.........#.....#...#...#...#.....#.....#.#.#.#.................#.#
+###.#.###.###.#.#.#######.#.#.#####.#####.#####.#####.#.###.#.#######.#.#.#####.#####.###.#.###.#######.###########.#.###.#.#.#.###.#.###.#.#
+#...#.....#.#...#.#.......#.#.....#.#...#...#.#...#.......#.........#.#.#.#...#...#.....#.#.......#.....#...........#...#.#.#.#.#...#.#...#.#
+#.#######.#.#####.#.###.###.#####.#.###.###.#.###.###.###.#####.#####.#.#.#.#.###.#.###.#.#######.#.###########.#######.#.#.#.#.#.###.#.#.#.#
+#.....#.#.#.......#.....#...#...#...#...#...#...#...#...#...#...#.....#.#...#.#.#...#.....#...#.#...#.........#...#...#...#.#.#...#...#.#...#
+#.###.#.#.#######.#######.###.#.#####.###.###.#####.#######.#.#.#.#####.#####.#.#####.###.#.#.#.#####.###.###.###.#.#.#####.#.#.###.###.#.#.#
+#.#.#.#.........#.#.....#...#.#.......#...#.......#.........#...#.#.........#...#.....#...........#...#...#.....#.#.#...#...#.#.#...#...#...#
+#.#.#.#########.#.#.###.###.###.#####.#.###.###.###############.#.#####.#.#####.#.#############.#.#.#.#.#######.#.#.###.#.###.#.###.#######.#
+#...#.......#...#.#.#.#.............#.....#.#.#.........#...#...#.....#.#.......#...#...#.........#.#...#...#.....#...#.#...#.#...#.......#.#
+###.#######.#.###.#.#.###########.#.#####.#.#.###.#.#####.#.#.#####.#.#.#######.###.#.#.#####.#####.#.###.#.#####.###.#.###.#.###.#.#####.#.#
+#.................#.......#.......#.......#.#...#.#.#.....#.#.#.....#.#.#...........#.#.....#.....#.#.....#.....#...#.#.#...#.#.#.#.....#.#.#
+#.###.#.#.#.#####.#####.###.###############.#.###.###.#####.#.###.#.#.###.#######.###.#####.#######.###########.#####.#.#.###.#.#.#####.#.#.#
+#.#...#.#.#.#...#.#.....#...#.....#.....#...#.#...#...#...#...#...#.#...#...#.....#...#.....#...#...#.........#.......#.#...#.#.........#...#
+#.###.#.#.#.#.#.#.#.#####.###.#.#.#.#.#.#.###.#.###.#.#.#.#####.#.#.###.#.#.#####.#.###.#####.#.#.###.#######.#######.#.###.#.#########.#.###
+#...#...#.#...#.#...#.....#.#.#.#.#.#.#.#.#...#.#...#.#.#.#.....#...#.#.#.#.#...#.#.#.#.....#.#...#.......#.#.......#.....#.#...#...#...#...#
+###.#####.#####.###.#.#####.#.#.###.#.###.###.#.#.###.#.#.#.###.###.#.###.#.#.#.#.#.#.#####.#.#####.###.#.#.#.#####.#.###.#.###.#.#.#.#.###.#
+#...#.....#...#.....#.#.......#.....#.....#...#...#...#.#...#.#...#.#...#.#...#.#.#.#.#.....#...#...#...#.#.#.#...#.#...#.#...#...#.#.......#
+#.#.#.###.#.#####.###.###.#################.#.#######.#.#####.#.#.#.#.#.#.#####.###.#.#.###.###.#####.#.#.#.#.###.#.###.#.###.#####.###.###.#
+#...#.#...#.#.......#...#.............#.....#.#.....#.#.#.......#.#...#.#.....#.......#.#...#.#.#...#.#.#...#...#...#...#.#.#.#.....#.#.....#
+#.###.#.###.#.#####.###.#############.#.###.#.###.#.#.#.###.#####.#####.#####.#########.#.#.#.#.#.#.#.#.#######.#.###.###.#.#.#.#####.#.#####
+#.....#...#...#...#...#.......#.....#.#.#...#.....#.#.....#.#...#...#.#...#.....#.....#.#.....#...#.#.#.#.......#...#...#...#.#.#.........#.#
+#######.#.#.#.#.#####.#######.###.#.#.###.#########.#.###.#.#.#.###.#.###.#######.###.#.#####.#####.#.#.#.#####.#######.#####.#.#######.#.#.#
+#...#...#.#.#...#.......#...#...#...#...#.....#...#.#...#.#...#...#.#...#.......#.#...#.....#.....#...#.#.#.....#.....#.....#.#.....#...#.#.#
+#.#.#.#.#.#.#.###.###.###.#.#.#.#.#####.#.###.#.###.#.#.#.#######.#.###.#######.#.#.#####.#.###.#######.#.#.#####.###.#####.#.#####.#.#.#.#.#
+#.#.#.#.#.#...#...#...#...#.#.#.#.#...#.#...#.#.#...#.#...#.......#...#...#.......#.....#.#...#...........#.#.....#.#.....#.#.#...#...#.#...#
+###.#.#.#.#####.###.###.###.###.#.#.#.#.#####.#.#.#####.###.###.#####.#.#.#.###########.###.#.###.###########.#####.#####.#.#.#.#.#.###.###.#
+#...#.................#.#...#...#...#...#.....#.#.#...#.#...#...#.....#.#...#.....#.......#.#...#.#...#.......#.........#...#...#.#.#...#...#
+#.###.#.#####.#.#######.#.#.#.###.#.#####.#####.#.#.#.#.#.###.###.#######.###.###.#######.###.#.#.#.###.#######.###.#######.#####.###.#.#.###
+#.....#...#...#...#...#.#...#...#.#...#...#.........#.#.#.#.#...#.......#.#.....#.......#.....#.....#...#.......#.#.#.....#.#...#.#...#.....#
+#.#######.#.###.#.#.#.#.###.###.#.###.#.###.#########.#.#.#.###.###.#.#.###.#########.#.#####.#####.#.#.#.###.###.#.#.###.#.#.#.#.#.###.#.#.#
+#.......#.#...#.#.#.#...#.#...#.#.......#...#...#.....#.#.#.......#...#.....#.#.....#.#.#...#.....#.#.#.#...#.....#...#...#.#.#.#...#.....#.#
+#######.#.###.###.#.#####.###.#.#########.#.#.#.#.#.###.#.#.#####.###########.#.###.###.#.#.#####.###.#.#.#.#########.#.###.###.#####.#.###.#
+#...........#.....#.....#.......#...#.....#.#.#...#.#.....#.#...#.#.......#...#.#.......#.#.#.#.......#.#.#...........#.........#...#.#.....#
+#.###.#.###.#####.#####.#.#.#####.#.#.#####.#.#####.#.#######.#.#.#.#####.#.#.#.#######.#.#.#.#.#####.###.###########.#######.#.#.#.#.#.###.#
+#...#.#...#.....#...#...#.#...#...#.#.#.....#.#...#.........#.#.#...........#.#.....#...#.#.#.#...#.......#.........#...#.....#...#.#.#...#.#
+#.#.#.###.#####.###.#.###.#.###.###.#.#.#####.#.#.#####.###.#.#.#.#####.#########.#.#####.#.#.###.#.#######.#######.###.#.###.#####.#.#.#.#.#
+#.#.#.#...#.#.....#.#.#...#...#.#.#.#.#.........#.....#.#.#...#.#.#...#.#.......#.#.......#.#.....#.....#.#.....#.....#...#...#...#.#...#.#.#
+#.#.###.###.#.###.#.#.###.###.#.#.#.#################.#.#.#####.###.#.#.#.#####.#####.#####.#.#########.#.#.###.#.###.#####.###.#.#.#####.#.#
+#.#...#.....#...#.#.#.........#.#.#...........#.#...#.#.#.....#...#.#.#.#...#.......#...#...#.#.......#.#.....#...#...#.....#.#.#...#...#...#
+#.###.#####.###.#.#.###.#######.#.#####.#####.#.#.#.#.#.#.#.#.###.#.#.#####.#######.#####.###.#.#######.#.#####.#.#.#.#.#####.#.#####.#.###.#
+#...#.......#.#.#.#...#...#...#...#...#...#...#...#.....#.#.#...#...#.....#...#...#.#...................#.#.....#.#.#...#...#...#.....#...#.#
+###.#####.###.#.#.###.###.#.#.#.###.#.#.###.###.#.#.#####.#.#.###########.###.#.###.#.#########.#.#######.#.###.###.#####.#.#.###.#####.###.#
+#.#...#.#.....#.#...#.#.#...#...#...#...#...#...#.....#.....#.#.......#.#.....#.....#.....#.....#.#...#...#.#.#.#...#.....#.#...#.#...#.#...#
+#.###.#.#.###.#.#####.#.#########.###.###.#######.###.#.#####.#.#.###.#.#######.#####.###.#.#.#.#.###.#.###.#.#.#.#####.#.#####.###.#.#.#.###
+#.#...#...#...#.......#.......#.#...#...#.#.....#...#.#...#...#.#...#.........#.#...#...#.#.#.#.#...#.....#.#...#.....#.#.....#...#.#.#.#...#
+#.#.###.#.#.#.###.#####.#####.#.###.###.#.###.#.###.#.###.#.###.###.###########.#.#####.#.#.#.#####.#######.#.#######.#####.#.###.#.#.#.###.#
+#...........#.#.........#...#.....#.#.#.#...#.#.....#...#.#.#...#.#.........#...#.....#.#...#.....#...#.....#...#...#.....#.#.....#.#.#...#.#
+#.###.###.#.#.#########.###.#####.#.#.#.#.#.#.#########.#.###.###.#########.#.#######.#.#####.###.###.#.#######.#.#######.#.#######.#.#.#.#.#
+#...#.....#.#.#.....#...#.....#...#.#...#.#.#.#...#...#.#.#...#.....#.......#.......#...#...#.#.....#...#.#.....#.........#...#.....#...#.#.#
+#.#.#####.#.#.#.###.#.###.#.###.###.#.#####.#.###.#.#.#.#.#.#####.#.#.#####.#######.#####.#.###.#########.#.#####.#.#########.#####.#.#####.#
+#.#.....#...#...#...#.#...#.....#...#.......#...#...#.#.#.#...#...#...#.......#...#.#.....#...#...#.......#.......#.#.......#.......#.......#
+#.#####.#########.###.#.###.#.###.#############.#####.#.#.###.#.#.#.#####.###.#.#.#.#.#######.###.#.###.#.#####.###.#.#####.#######.#.#######
+#.....#...#.....#.....#...#.#...#...#...........#.....#.....#.#.#.#.......#.....#.#...#...#.#.....#...#.#.#.....#...#...#.#.#.....#.#...#...#
+#####.#.#.#.#####.#.###.#.#.###.###.#.#.#########.#########.#.#.#.#######.#####.#.###.#.#.#.###.###.###.#.#.#####.#.###.#.#.#.###.#.#.#.###.#
+#...#.#.#...#.....#...#.#.#.#...#...#.#.........#...........#.#.#.....#...#...#.#.....#.#.......#...#...#.#.#.....#.#.....#.#...#.....#.#...#
+###.#.#.#.###.#####.#.###.#.#.###.#.###.#.#####.#####.#####.#.#.#####.#.#.#.#.###.#####.#.#######.#.#.#####.#.#####.#.#.#.#.#########.#.#.###
+#...#.#.#.#...#.....#.#...#.#.#.#.....#.#.#...#.#...#.......#.#...#.....#.#.#.#.....#...#.....#...#.#.......#.#.#...#.#...#.....#.......#...#
+#.#.#.#.###.###.#####.#.#####.#.#####.#.#.#.#.#.#.#.#.#######.#.#.#.#####.#.#.#.#####.#######.#.###.#########.#.#.###.#.#######.#.###.###.#.#
+#.#.#.#...#.#...#...#.#...#...#...#.#.....#.#.#...#.#.#.....#.#.#.#.#.....#.....#.#...#.#...#...#.....#.....#.#.......#.#.....#.#...#.....#.#
+#.#.#.###.#.#####.#.#.#.#.#.###.#.#.#.###.#.#.#####.#.#.#.###.###.###.###.#.#####.#.###.#.#.#######.#.#.###.#.#########.#.###.#.###.#######.#
+#.#.#...#.#.#...#.#...#.#.#.........#...#.#.#...#...#.#.#...#...#.#...#...#.#.....#...#...#...#.....#...#...#.#.........#.#...#...#.........#
+#.#####.#.#.#.#.#.#######.###.#####.###.###.###.#.###.#####.###.#.#.#######.#.#######.#.###.#.###.###.#######.#.###########.#.#.#.#########.#
+#.........#.#.#.#.#.....#.#...#...#.#...#...#...#.#.......#...#...#.#.......#...#...#.#...#.#.....#...#.....#.#.#.#.........#.......#.....#.#
+#.#.#.#.#.#.#.#.#.#.###.#.#.###.#.###.###.###.###.#######.#.#####.#.#.#########.#.#.#.#####.#######.###.###.#.#.#.#.#.#.#.#####.#.#.#.#.#.#.#
+#.#.#...#.#.#.#...#.#...#.#...#.#...#...#...#.....#...#.....#.....#.#.....#.....#.#.#.#...#.#.....#.#.#.#.....#.#.#...#.......#.#...#.#.#.#.#
+#.#.#####.#.#.#.###.#.###.#.###.###.#.#.#.#.#.#####.#.#.#####.#####.#####.#.#.###.#.#.#.#.#.###.#.#.#.#.#####.#.#.#.#.#####.#.#.###.#.#.###.#
+#.#.....#.#.#.#.#...#.....#.#...#.#.#.#.#.#.#.......#.#...#...#.....#.....#.#.....#.#...#.#...#.#.#.#.#.#...#.#.#...#.......#.#...#.#.#.....#
+#.#####.#.#.#.###.#####.#.#.#.###.#.#.#.###.#.#######.#####.###.###.#.#####.#######.#####.###.#.#.#.#.#.#.#.#.#.#######.#.###.###.#.#.#####.#
+#...#...#.#.#.........#.#...#.#...#.#.#.#...#.#...#...#.....#...#.#.#.#.....#.#.........#.....#.#.#...#...#.#.#...#...#...#.....#.#.#.#.....#
+###.#.###.#.#.###.#####.#####.###.#.#.#.#.###.#.#.#.###.#####.#.#.#.#.#####.#.#.#######.#######.###.#.#####.#.###.#.#.###.#.###.#.#.#.#.#.#.#
+#...#.#...#.#.....#...#.....#.#...#.#.#.#.#...#.#.#.....#...#.#.....#.....#.#.#.....#.#.....#...#.....#.#...#...#.#.#.......#...#.#.#.#...#.#
+#.###.#.#.#.#####.#.#.#####.#.#.###.###.#.#.#####.#######.#.#.###.#######.#.#.#####.#.#####.#.#.#.#.###.#.###.#.#.#.#####.###.###.#.#.#.###.#
+#.....#.#.#.#...#.#.#.#.....#.#...#.....#...#.....#...#...#.#...#.#.....#.#.#.....#.#.........#.#.#.....#.......#.#.#...#...#...#.#.#.#...#.#
+#.#####.#.#.#.###.#.#.#.#####.###.#######.###.#####.#.#.###.#.#.#.###.#.#.#.#.###.#.#.#########.#.#.#.#.#####.#.#.#.#.#.#.#.#.###.#.#.#.#.#.#
+#.#.....#.#.#.....#.#...#.....#.........#.#...#.....#...#...#.#...........#...#...#.#.#.................#.......#...#.#.....#.#...#.#...#...#
+#.#.#####.#.#####.#.###.#.#####.#########.###.#.#########.###.#.#######.#######.#.#.#.###.#.#.#####.#.#.#.###.#######.###.###.#.###.###.###.#
+#.#...#...#.#...#.#.#.#.#.....#.............#...#.....#.#.#...#.......#.#.......#.#.#.....#.#...#...#...#.....................#.#.....#...#.#
+#.###.#.###.#.#.#.#.#.#.#####.#.###########.#.#.###.#.#.#.###########.#.#.#####.###.###.###.#.#.#.#.#.#.#####.###########.#.#.#.#######.#.#.#
+#.#.#.#...#...#.....#.......#.#.#...#.....#...#.....#...#.....#.....#.....#.........#...#...#.#.#...#.#.....#.........#...#.#.#.........#...#
+#.#.#.#####.#####.###.#.#####.#.#.###.###.#############.#####.#.###.#####.#####.#########.#.#.#.###.###.#.#.#######.#.#.#.#.#.#########.#####
+#.#.#.........#.....#.#.......#...#...#.#.........#...#...#...#.#.#.#...#.#...........#...#...#...#...#.#.#.#.....#.#.#.#...#.#.............#
+#.#.#######.###.#.###.#.###########.###.#######.###.#.###.#.###.#.#.#.#.###.#.#.#####.#.###.#.###.#.#.#.#.#.#.###.#.#.#.#####.#####.#######.#
+#S........#.....#.....#.......................#.....#.......................#.......#.......#...#.......#.....#.............................#
+#############################################################################################################################################

advent_of_code/2024/16/src/main.rs

@@ -0,0 +1,242 @@
+use std::collections::{HashMap, HashSet};
+
+use nom::{
+    character::complete::{multispace1, not_line_ending},
+    multi::separated_list1,
+    IResult, Parser,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum Tile {
+    Wall,
+    Empty,
+    Start,
+    End,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+enum Direction {
+    North,
+    East,
+    West,
+    South,
+}
+
+fn parse(input: &str) -> IResult<&str, Vec<Vec<Tile>>> {
+    use Tile::*;
+
+    let (input, result) = separated_list1(
+        multispace1,
+        not_line_ending.map(|s: &str| {
+            s.chars()
+                .map(|c| match c {
+                    '#' => Wall,
+                    '.' => Empty,
+                    'S' => Start,
+                    'E' => End,
+                    _ => unreachable!(),
+                })
+                .collect()
+        }),
+    )(input)?;
+
+    Ok((input, result))
+}
+
+fn move_one(pos: (usize, usize), dir: Direction) -> (usize, usize) {
+    use Direction::*;
+
+    let (x, y) = pos;
+    match dir {
+        North => (x, y - 1),
+        East => (x + 1, y),
+        West => (x - 1, y),
+        South => (x, y + 1),
+    }
+}
+
+fn dirs_to_checked(dir: Direction) -> Vec<Direction> {
+    use Direction::*;
+
+    match dir {
+        North => vec![North, East, West],
+        East => vec![East, North, South],
+        West => vec![West, North, South],
+        South => vec![South, East, West],
+    }
+}
+
+fn solve_1(input: &str) -> u64 {
+    use Direction::*;
+    use Tile::*;
+
+    let (_, map) = parse(input).unwrap();
+
+    let mut start = (0, 0);
+    let mut end = (0, 0);
+
+    for (j, row) in map.iter().enumerate() {
+        for (i, t) in row.iter().enumerate() {
+            if *t == Start {
+                start = (i, j);
+            } else if *t == End {
+                end = (i, j);
+            }
+        }
+    }
+
+    let mut stack = HashMap::new();
+    let mut visited = HashSet::new();
+    let mut points = 0;
+
+    stack.insert(0, vec![(start, East)]);
+    visited.insert((start, East));
+
+    loop {
+        if let Some(ss) = stack.get(&points) {
+            for &((x, y), dir) in ss.clone().iter() {
+                if (x, y) == end {
+                    return points;
+                }
+
+                for dn in dirs_to_checked(dir) {
+                    let (xn, yn) = move_one((x, y), dn);
+
+                    if !visited.contains(&((xn, yn), dn)) {
+                        match map[yn][xn] {
+                            Wall => {}
+                            _ => {
+                                let pn = points + if dir == dn { 1 } else { 1001 };
+
+                                let mut sn = match stack.get(&pn) {
+                                    None => vec![],
+                                    Some(snn) => snn.clone(),
+                                };
+
+                                sn.push(((xn, yn), dn));
+                                stack.insert(pn, sn);
+                            }
+                        };
+                    }
+                }
+
+                visited.insert(((x, y), dir));
+            }
+        }
+        points += 1;
+    }
+}
+
+fn solve_2(input: &str) -> u64 {
+    use Direction::*;
+    use Tile::*;
+
+    let (_, map) = parse(input).unwrap();
+
+    let mut start = (0, 0);
+    let mut end = (0, 0);
+
+    for (j, row) in map.iter().enumerate() {
+        for (i, t) in row.iter().enumerate() {
+            if *t == Start {
+                start = (i, j);
+            } else if *t == End {
+                end = (i, j);
+            }
+        }
+    }
+
+    let mut stack = HashMap::new();
+    let mut visited = HashSet::new();
+    let mut points = 0;
+    let mut found = vec![];
+
+    stack.insert(0, vec![(start, East, vec![])]);
+    visited.insert((start, East));
+
+    loop {
+        let maybe_s = stack.get(&points);
+
+        match maybe_s {
+            Some(ss) => {
+                let cs = ss.to_owned();
+
+                for ((x, y), dir, b) in cs.iter() {
+                    if (*x, *y) == end {
+                        found.push(b.to_owned());
+                    }
+
+                    for dn in dirs_to_checked(*dir) {
+                        let (xn, yn) = move_one((*x, *y), dn);
+
+                        if !visited.contains(&((xn, yn), dn)) {
+                            match map[yn][xn] {
+                                Wall => {}
+                                _ => {
+                                    let pn = points + if *dir == dn { 1 } else { 1001 };
+
+                                    let mut sn = match stack.get(&pn) {
+                                        None => vec![],
+                                        Some(snn) => snn.clone(),
+                                    };
+
+                                    let mut bn = b.clone();
+                                    bn.push((*x, *y));
+
+                                    sn.push(((xn, yn), dn, bn));
+                                    stack.insert(pn, sn);
+                                }
+                            };
+                        }
+                    }
+
+                    visited.insert(((*x, *y), *dir));
+                }
+
+                if found.len() > 0 {
+                    let mut found_set = HashSet::new();
+
+                    for ff in found {
+                        for f in ff {
+                            found_set.insert(f);
+                        }
+                    }
+
+                    // + 1 because of the end tile not being in the sets
+                    return found_set.len() as u64 + 1;
+                }
+            }
+            None => {}
+        }
+        points += 1;
+    }
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The optimal path costs {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The number of the best tiles are {}", result_2);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 7036);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 45);
+    }
+}

advent_of_code/2024/16/test.txt

@@ -0,0 +1,15 @@
+###############
+#.......#....E#
+#.#.###.#.###.#
+#.....#.#...#.#
+#.###.#####.#.#
+#.#.#.......#.#
+#.#.#####.###.#
+#...........#.#
+###.#.#####.#.#
+#...#.....#.#.#
+#.#.#.###.#.#.#
+#.....#...#.#.#
+#.###.#.#.#.#.#
+#S..#.....#...#
+###############

advent_of_code/2024/17/Cargo.toml

@@ -0,0 +1,4 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"

advent_of_code/2024/17/input.txt

@@ -0,0 +1,5 @@
+Register A: 52042868
+Register B: 0
+Register C: 0
+
+Program: 2,4,1,7,7,5,0,3,4,4,1,7,5,5,3,0

advent_of_code/2024/17/src/main.rs

@@ -0,0 +1,180 @@
+fn parse(input: &str) -> (u64, u64, u64, Vec<u64>) {
+    let lines: Vec<Vec<&str>> = input
+        .lines()
+        .map(|l| l.split_whitespace().collect())
+        .collect();
+
+    (
+        lines[0].last().unwrap().parse().unwrap(),
+        lines[1].last().unwrap().parse().unwrap(),
+        lines[2].last().unwrap().parse().unwrap(),
+        lines
+            .last()
+            .unwrap()
+            .last()
+            .unwrap()
+            .split(',')
+            .map(|i| i.parse().unwrap())
+            .collect(),
+    )
+}
+
+fn combo(a: u64, b: u64, c: u64, op: u64) -> u64 {
+    match op {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => a,
+        5 => b,
+        6 => c,
+        _ => unreachable!(),
+    }
+}
+
+fn solve_1(input: &str) -> String {
+    let (a, b, c, ops) = parse(input);
+
+    stringify(solve(a, b, c, ops))
+}
+
+fn solve(mut a: u64, mut b: u64, mut c: u64, ops: Vec<u64>) -> Vec<u64> {
+    let mut ip = 0;
+    let mut out: Vec<u64> = vec![];
+
+    while ip < ops.len() {
+        let ins = *ops.get(ip).unwrap();
+        let op = *ops.get(ip + 1).unwrap();
+        match ins {
+            0 => {
+                // adv
+                let result = a >> combo(a, b, c, op);
+                a = result;
+                ip += 2;
+            }
+            1 => {
+                // bxl
+                let result = b ^ op;
+                b = result;
+                ip += 2;
+            }
+            2 => {
+                // bst
+                let result = combo(a, b, c, op) % 8;
+                b = result;
+                ip += 2;
+            }
+            3 => {
+                // jnz
+                if a != 0 {
+                    ip = op as usize;
+                } else {
+                    ip += 2;
+                }
+            }
+            4 => {
+                // bxc
+                let result = b ^ c;
+                b = result;
+                ip += 2;
+            }
+            5 => {
+                // out
+                out.push(combo(a, b, c, op) % 8);
+                ip += 2;
+            }
+            6 => {
+                // bdv
+                let result = a >> combo(a, b, c, op);
+                b = result;
+                ip += 2;
+            }
+            7 => {
+                // cdv
+                let result = a >> combo(a, b, c, op);
+                c = result;
+                ip += 2;
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    out
+}
+
+fn stringify(ops: Vec<u64>) -> String {
+    let out = ops
+        .into_iter()
+        .fold("".to_string(), |result, n| result + "," + &n.to_string());
+
+    out.as_str()[1..].to_string()
+}
+
+// Decompilation of my program yields the following
+// 2,4,1,7,7,5,0,3,4,4,1,7,5,5,3,0
+//
+// while a:
+//     b = a % 8
+//     b = b ^ 7
+//     c = a >> b
+//     a = a >> 3
+//     b = b ^ c
+//     b = b ^ 7
+//     out(b % 8)
+
+fn solve_2(input: &str) -> u64 {
+    fn find(ops: &[u64], ans: u64) -> Option<u64> {
+        if ops.is_empty() {
+            return Some(ans);
+        }
+
+        for t in 0..8 {
+            let a = ans << 3 | t;
+
+            let mut b = a % 8;
+            b = b ^ 7;
+            let c = a >> b;
+            b = b ^ c;
+            b = b ^ 7;
+            let output = b % 8;
+
+            if output == *ops.last().unwrap() {
+                let sub = find(&ops[..ops.len() - 1], a);
+                if sub.is_some() {
+                    return sub;
+                }
+            }
+        }
+        return None;
+    }
+
+    let (_a, _b, _c, ops) = parse(input);
+
+    find(&ops[..], 0).unwrap()
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The final output of the program is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!(
+        "The lowest positive initial value for register A to get a copy of the program is {}",
+        result_2
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), "4,6,3,5,6,3,5,2,1,0");
+    }
+}

advent_of_code/2024/17/test.txt

@@ -0,0 +1,5 @@
+Register A: 729
+Register B: 0
+Register C: 0
+
+Program: 0,1,5,4,3,0

advent_of_code/2024/17/test2.txt

@@ -0,0 +1,5 @@
+Register A: 2024
+Register B: 0
+Register C: 0
+
+Program: 0,3,5,4,3,0

advent_of_code/2024/18/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

advent_of_code/2024/18/src/main.rs

@@ -0,0 +1,98 @@
+use std::collections::HashSet;
+
+fn parse(input: &str) -> Vec<(i64, i64)> {
+    input
+        .lines()
+        .map(|s| {
+            let (y, x) = s.split_once(',').unwrap();
+
+            (x.parse().unwrap(), y.parse().unwrap())
+        })
+        .collect()
+}
+
+fn solve_1(input: &str, steps: usize, range: i64) -> Option<i64> {
+    let memory = parse(input);
+    let memory: HashSet<_> = memory[..steps].into_iter().collect();
+
+    let mut visited: HashSet<(i64, i64)> = HashSet::new();
+    let mut path_length = 0;
+    let mut stack: HashSet<_> = [(0, 0)].into_iter().collect();
+
+    let dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)];
+
+    loop {
+        path_length += 1;
+        let mut new_stack = HashSet::new();
+
+        if stack.is_empty() {
+            return None;
+        }
+
+        for pos in stack {
+            if pos == (range, range) {
+                return Some(path_length - 1);
+            }
+
+            visited.insert(pos);
+
+            for dir in dirs {
+                let new_pos = (pos.0 + dir.0, pos.1 + dir.1);
+
+                if new_pos.0 >= 0 && new_pos.0 <= range && new_pos.1 >= 0 && new_pos.1 <= range {
+                    if !visited.contains(&new_pos) && !memory.contains(&new_pos) {
+                        new_stack.insert(new_pos);
+                    }
+                }
+            }
+        }
+        stack = new_stack;
+    }
+}
+
+fn solve_2(input: &str, range: i64) -> (i64, i64) {
+    let memory = parse(input);
+
+    for i in 0..memory.len() {
+        if solve_1(input, i, range).is_none() {
+            return memory[i - 1];
+        }
+    }
+
+    return (0, 0);
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input, 1024, 70);
+    println!(
+        "The number of steps of the shortest route from beginning to end is {}",
+        result_1.unwrap()
+    );
+
+    let result_2 = solve_2(input, 70);
+    println!(
+        "The first byte that prevents a path being laid is {},{}",
+        result_2.1, result_2.0
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input, 12, 6).unwrap(), 22);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input, 6), (1, 6));
+    }
+}

advent_of_code/2024/18/test.txt

@@ -0,0 +1,25 @@
+5,4
+4,2
+4,5
+3,0
+2,1
+6,3
+2,4
+1,5
+0,6
+3,3
+2,6
+5,1
+1,2
+5,5
+2,5
+6,5
+1,4
+0,4
+6,4
+1,1
+6,1
+1,0
+0,5
+1,6
+2,0

advent_of_code/2024/2/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

advent_of_code/2024/2/src/main.rs

@@ -0,0 +1,157 @@
+use std::collections::HashSet;
+
+fn distance<T>(a: T, b: T) -> T
+where
+    T: Ord + std::ops::Sub<Output = T>,
+{
+    if a < b {
+        return b - a;
+    } else {
+        return a - b;
+    }
+}
+
+fn check_line_safety_1(line: &Vec<u32>) -> bool {
+    let len = line.len();
+    let mut prev = line[0];
+    let up_or_down = line[0] < line[1];
+
+    for i in 1..len {
+        if prev == line[i] {
+            return false;
+        }
+
+        let dist = distance(prev, line[i]);
+        if dist < 1 || dist > 3 {
+            return false;
+        }
+
+        if up_or_down && prev > line[i] {
+            return false;
+        } else if !up_or_down && prev < line[i] {
+            return false;
+        }
+
+        prev = line[i];
+    }
+
+    return true;
+}
+
+fn solve_1(input: &str) -> u32 {
+    let data: Vec<Vec<u32>> = input
+        .lines()
+        .map(|line| {
+            line.split_whitespace()
+                .map(|number| number.parse::<u32>().unwrap())
+                .collect()
+        })
+        .collect();
+
+    return data.into_iter().filter(check_line_safety_1).count() as u32;
+}
+
+fn check_line_safety_2(line: &Vec<u32>) -> bool {
+    let len = line.len();
+    let mut prev = line[0];
+    let mut ups: HashSet<usize> = HashSet::new();
+    let mut downs: HashSet<usize> = HashSet::new();
+    let mut distance_violations: HashSet<usize> = HashSet::new();
+
+    for i in 1..len {
+        let dist = distance(prev, line[i]);
+
+        if dist < 1 || dist > 3 {
+            distance_violations.insert(i);
+        }
+
+        if prev < line[i] {
+            ups.insert(i);
+        } else if prev > line[i] {
+            downs.insert(i);
+        }
+
+        prev = line[i];
+    }
+
+    if ups.len() > 2 && downs.len() > 2 {
+        return false;
+    }
+    if distance_violations.len() > 2 {
+        return false;
+    } else if distance_violations.len() == 0 && (ups.len() == 0 || downs.len() == 0) {
+        return true;
+    }
+
+    let minor = if ups.len() > downs.len() {
+        downs.clone()
+    } else {
+        ups.clone()
+    };
+
+    let union: HashSet<_> = minor.union(&distance_violations).to_owned().collect();
+    if union.len() == 1 {
+        let mut line_copy_1 = line.clone();
+        let mut line_copy_2 = line.clone();
+        let delete_spot = *union.into_iter().next().unwrap();
+
+        line_copy_1.remove(delete_spot);
+        line_copy_2.remove(delete_spot - 1);
+
+        return check_line_safety_1(&line_copy_1) || check_line_safety_1(&line_copy_2);
+    } else {
+        let mut line_copy_1 = line.clone();
+        let mut line_copy_2 = line.clone();
+        let mut line_iter = union.into_iter();
+
+        line_copy_1.remove(*line_iter.next().unwrap());
+        line_copy_2.remove(*line_iter.next().unwrap());
+
+        return check_line_safety_1(&line_copy_1) || check_line_safety_1(&line_copy_2);
+    }
+}
+
+fn solve_2(input: &str) -> u32 {
+    let data: Vec<Vec<u32>> = input
+        .lines()
+        .map(|line| {
+            line.split_whitespace()
+                .map(|number| number.parse::<u32>().unwrap())
+                .collect()
+        })
+        .collect();
+
+    return data.into_iter().filter(check_line_safety_2).count() as u32;
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The number of safe reports is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The number of safe reports (version 2) is {}", result_2);
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+
+        assert_eq!(solve_1(test_input), 2);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+
+        assert_eq!(solve_2(test_input), 4);
+    }
+}

advent_of_code/2024/2/test.txt

@@ -0,0 +1,6 @@
+7 6 4 2 1
+1 2 7 8 9
+9 7 6 2 1
+1 3 2 4 5
+8 6 4 4 1
+1 3 6 7 9

advent_of_code/2024/3/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2024/3/input.txt

@@ -0,0 +1,6 @@
+}@/]({why()why()mul(857,200)}&)){!from()-mul(158,758):who():!who()what()@>%mul(953,214)from()why()when()$'[+mul(277,918)select()[~$)mul(708,736)^~from()/why()^#mul(588,753)who()]$where()mul(562,499)->')!don't()mul(677,889)#]##?,-?don't()&$when()$mul(554,958)how()?how() ~)(;don't()>+~when(){~what()+}'mul(446,878)/:&]how()!mul(207,471)}what()~-+/mul(398,851)where()how()@where()}-]how()mul(847,472)mul(244,19){-#:$mul(895,91)(!:mul(872,18)+}why(251,250)mul(630,73)%:,!who(981,677)!!mul(103,541)why(),how() )%:mul(749,545)what()^mul(22,489)mul(699,518)-~,where()[where()~mul(291,9)select()-when()]do()!<<select();who()}%mul(830,471):?@-how()when(){$how()(mul(528,980)from()what() [?&$mul(930,234)where()}mul(992,63)>,[what()!//+why()/mul(38,546):mul(297,2)why()<who()[what()$)#!don't()^#:?mul(458,249)<%^*)];&mul(816,429)* ;what()select()when()mul(15,824):#mul(669,34)from()$mul(363,251)$select(757,257)*@^?@~what()#mul(551,812)!>mul(745,860) mul(110,274)mul(30,694)'%#^)why()mul(491,133))]where(835,197)[/mul(212,917)+^*^{when(421,261)-where()<)mul(448,147)where()]mul(448,494);)!what()%~#?#~do()/?/@[why()//select()mul(992,463)/mul(447,526){-mul(907,965):!who()#how()mul(95,36)where()where()#;~+~mul(898,41)- !^-*#where()mul(63,801):^@from()^mul(742,163)where()*'mul(979,736)when(627,44)!who()mul(92,637)!~/%]>~^mul(723,185)select()~%]);^when(384,799)mul(597,721),%'* !mul(915,963)*;don't()select()how())~:,how()mul(498,757)'/mul(361,423)///where(){what()^who()$why()mul(700,270)[~what():from()mul(442,15)?)+mul(134,759)who()-@}select()when()'&who()<mul(197,114)+'@@:#;:+mul(456,291)when();[mul(810,734)&;select()mul(779,730)@mul(48,436)who()},],mul(856,377)how()@]mul(231,214)mul(289,948))how()from()where()/}why()select()mul(413,445)from()[who()@]mul(547,89)~'[(!who()@}mul(433,361)-how()?>who()?what(697,478)?-what(516,904)mul(435,284)@!> ^<mul(798,836)<(mul(701,253)}'#%}mul(896,763)mul(607,689)'where()'}^mul**when()why()<(what()why(127,499)%mul(124,832)%why()where()^] mul(815,705)@who()]mul(362,182)};mul,!mul(551,219)where()?)&(:[)mul(958,936)when()&$>what(){mul(118,686)&mul(478,122)when(586,470)$>mul(835,231){]@[do()~$$]%~;-mul(236,742){&,mul(512,497)[where()()where()mul(295,913)[mul(959,932)~+@mul(868,214)'>}'mul(549,147),'/<,mul(121,328)(how()-mul(262,843)what() ;&when()]mul(886,378)? {what()who()*mul(194,970)when()from()$who()mul(79>%don't()*~ :select()&mul(340,662) -<@;where()++)what()mul(367,860)}:/;why()/,-mul(973,473)what()-{)mul(775,358);what():@select()do())(from()]@<what(216,350)why()who()@mul(296(when(),&mul(441,314),++{:*who()mul(458,712)?]'$select()why()[@mul(228,934)select(){#%mul(800,434)mul(32,355)mul(895,206)$':from()!mul(238,945),}[?}$why()<mul(904,931)*$mul(948,562)where()]why(601,835):!!*}select(280,167)mul(541,249)who()<-~who()mul(323,779)>(%@when(764,373)mul(60,926)mul(998,76)[how()*/do()@who()*from()<+]^select()&mul(2,30)
+)who()select();mul(121,859)from()@},who():mul(606,797)from();what()what()*&,)*mul(478,201):/<;&from()}select(509,683)^mul(442,760) ],how()@ where()mul(325,315)mul(377,534)+when(953,408)how()/who()$@select()select(82,159)where()mul(590,633)how()>'why(136,599)&$~why()mul(44,530)*$mul'$what()+mul(634,476)[>{~-do()$mul(689,54)from()~+#%{,+!what()mul(360@[>/how()from()#,;mul(794,106)why()why()mul(822,201)}{)~?how()mul(440,483)where()who(356,874)+how(274,674);mul(114,558))how(),]})]}</mul(397,596),~<![#,:(do()%who()mul(969,996)~{/@how()],select()@mul(666,207),mul(692,414who();^)what()</ ]]mul(447,106)who()]>}^)&+:%mul(85,419)mulfrom(),why()))#[<?mul(162,336)!;[[->^how()#mul(711}*&:do()mul(832,303)what(720,682)}]^mul(848,34)#{)!,where()why()select()/mul(297,312);*(: <why(67,348)) }mul(167,517)) &+$where()&(*do()~#who()?&#});when(93,740)mul(516,233^: {#?&mul(549,677)&%:mul(506,998)where()~[/when()-<:,?mul(622,56),mul(710,886^mul(629,502)why()${;],{mul(7,729)why():#'>why();&[select()mul(835,973) >mul(976,433)where();'}?]@select()mul(613,866)-how()#mul(121,104)!-mul(25,379) ]*why(){~+mul@^~where()*[who()(/@mul(256,212)~what()mul(855,364) !?;mul>:/from(945,813)/mul(996,850)!&(mul(369,875)%<mul(891,144);from()%]<'<mul(631,980)[#~%why(),~mul(705,849)how()%+?;>mul(917,57)-select();mul(868,942)]?~{[mul(352,436)!~how()-@mul(629,784),%<}~&mul(648,951)from(153,561))&$why(917,532)mul(640,970)why():[ ?%mul^mul(428,879))what()mul(199,603))mul(845,646)!$:!,?[select()mul(792,917]when(),[*<mul(422,243)}select()who()>&+:,>mul(283,734);mul(799,547)<^from()@mul(113,216)@{^ mul@mul(679,251)[*mul(899,455)why() select()/[%mul(4,45)(*^what()^:select(923,55)-#<mul(701,340)who()<don't()!^)-@[mul>mul(191,622)when()'?mul(784,659)/where()$:where(46,726)why()/!];mul(96,630)mul(601,327)%;,mul(336%where()^#>;why():/mul(754,451)select()how(491,36){%!}]mul(868,7)$select()! $where()select()&$mul(814,614)mul(535,117)%:#;{]!{(mul(537,533)-!%>#mul(794,183)mul(135,122)!(>,)do()~'who()from(504,62);what(){mul(959,794)!}-(mul(890,934)>'what()from()mul(412,476)^~mul(852how()mul(277,740)!!<#%^]$where()mul(694,253)#~>@{mul(570@]}!&@$%select()'mul(492,943)where()/mul(893,661)}mul(343,224)from(178,398)!#what()+&^^who(){mul(197,133)from()mul(334,570)mul(374,818),&^ $[don't()mul(781,459)why()from(959,545)-;[@mul(147,509)select()!}when()mul(778,892)what()#mul(960,67)<[from(),select()!?how()mul(376,145)-!; (+from()> ^mul(780,339):,$what()+mul(491,818)+>*^>@how()[what(879,204)how()mul(70!'@$#,how()>mul(492,341)/from()?&<+?select()[how(707,662)mul(40,129)]where()select(501,969)-}+mul(651,382)mul(582,658)&>%<from()(>#who()mul(27,768)!how()when()who()why()mul(860,651)%^[from()*where())(mul(2,858)select()}#];$mul(654,738)mul(538,332)[{(@mul(270,261)]/~mul(756,771)/mul(311,298)how();]~>;{<mul(663,677)+>?mul(260,313)<}~;from()}why()!}mul(902,613)mul(458,68)@:how()when()@)[^from()>mul(651,358) when()?]select():%)~*mul(769,230)*%%how()<]from()do()?who() :!,mul(256,752)#select():who()what(){;+<&mul(429,732)[^~where()what(425,533),[',$mul(546,869)how() <mul(424,645)why()'(((mul(233,853)
+,:?[:}how():*mul(356,31)$~>what()do()who()!-#] +mul}}[#who()from()&-+*mul(613,565)#&-)<select()-mul(653,985)!#;mul(432,634),what()$/$[<don't()mul(203*${?]:>?mul(49,724)mul(250,187)mul(389,591)+from()*why()%:why()where()when()(mul(732,636)%~what()mul(170,116)+-}/%what()'mul(765,501)[^]?how()#mul(186,825))-}why()mul(302,601){]#where()*;from()mul(862,742)why()select()<where()where()mul(666,401)who()~who()[]+where()%^mul(874,116'mul(439,908)where()()where()when()!+mul(560,829),mul(286,115)}mul(273,259)+[#@*}mul(832,167)#<<(where()why()>!who()mul(51,136)$how()select()mul(116,301)mul*&(from()~> mul(456,87)?${%#mul(796,323),]>why()mul(622,227)']{~<how()mul(518,891)where()what()^]select()~'who(140,499)mul(616,446)mul(849,298)<+!+~]^where()mul(777,50)}%''<]+mulfrom(527,421)~mul(880,854)$+>'+where(){#-mul(37,539)?<)]why():[>mul(369,873) who()%from(342,759)&don't()}why()?mul(472,266)when()mul(413,298)when()[]$!@mul(739,890)+$'*who()mul(215,821)how()}%what()how()^mul(837,240)+}mul(882,381),;select()'~>[]}{mul(772,663)[^%,])who(){mul(398,367);}how() ,-who()-{who()mul(964,744)(mul(90,658)]<{[when()^@mul(216,425)}?[!mul(374,641);how(){]#^~where()from()mul(909,90)>:@{mul(491,477)<what()mul(338,691)(*why()-)?[mul(844,138)&+)mul(3$) mul(892,565)mul(913,244)**where()<who()/-&@*do()]&&&what()({![mul(239[why()]mul(643,590)/*-(mul(79,823)where(),%?~-~where()select(255,453)where()mul(634,892)-{ &how()[ <mul(50,27)+^:when()]+,*mul(706,164)#,~from(),>@$mul(932,629){][#+mul(993,863)]mul(405,521),+why(25,778)mul)@why(986,941)who()] >how())mul(163,617):-don't()when()? mul(144,275)>-when()/'~don't(){mul(111,133)],where(): }mul(351,780)select()why()mul(325,938)} where()#/'where()[what(){mul(936,880)select()%]$?^)@>mul(806?:what(){what()$who(992,398)@how()}mul(507,635);,when()/what(83,275)}?*;mul(905,828)+where()how()!mul(59,265)$>: ]},:-!do()when()where() why()<'*^mul(262,857/~@'{!what()$/select()'mul(669,373)mul(990,115)*select();{(mul(364,943)>> &{when()mul(338,512)>( #:mul(761,640)what()select()don't(),^select();why()'><when()]mul(942,498)what()$)why()mul(342,38)!?<@mul(959,310)**@mul(919,890)@!select()where()from()[where()what()+mulwhy()what(),>+-($?what()@mul(774,119)-how()!select()mul(578,919)when()>>-mul(744,442) -)^why()-mul(194,582)mul(112,346)+!from()mul(75,217)what()<don't()(<%why()mul(738$'^] '?*'&^mul(485,611)+who()&!-mul(970,390)who()select()@how()}!mul(748,964)'why()[how()select(),select()&who(),mul(731,138)}^&]>how()*@,mul(781,19)!]how()<?;<;mul(573,28);%$% ^%}mul(698,965)mul(440,100)<,<why()]:select()>}mul(840#~%+~~)mul(564,143)[% /<~}/mul(575,875)mul(386,110)*#{mul(913,496);why()-}mul(608,777)?@+>mul(264,527);;**mul(906,263)(':don't()mul(452,213)@when())when():(who()$!why()do()$}(!%[from() -mul(198,318)::)<<,&mul}[%#mul(919,501)/~#~mul(332,157)~<[select()mul(619,931),how():%where();how()mul(633,846) from()>}how(),%mul(456,751)when(), mul(896,30)~{how()]where()from()(why()+don't()![#!from()(-~mul(679,191)@+<select(),!who()mul(441,683)!mul(481,982)<how()/who()'what():mul(39,637)?what()select())mul(124,424)*@)]$' mulhow()~[{{'#!/usr/bin/perl!]where()mul(897,698)
+{select()[[),:[mul(28,169)]^/~from(),when()'!mul(929,62))mul(2,658)$>why(950,435)-mul(563,357)why()from()@who(),select(666,833)who()+mul(641*mul(110,352)-(from(257,512)select()%who()don't(){'mul(997,134)%**$mul(180,648)*when() -:/</mul(276,397)where()select()when()<how()why(){<']mul(425,558)why()&?:%)mul(259,204)]@[who()mul(349,64)what()$[?/))who()+how()mul(569,112)when()mul(831*{;[]@select()#'%don't()%mul(517~/&@mul(696,90)&)how()-mul(488,361)/@when()how():mul(696,154)when()select()]]?}#,what()who()mul(625,403):who(602,811)-&)select()'mul;@%mul(598,280)]!&![% do()!^select()'-mul(674,329)*why()-mul(336,597)*'$what()mul(762,169):#~#~>>!from(){mulselect()'[}?mul(760,580); </who()&don't()! (,<,mul(822,761)where()#what(),mul(621,508)why()$>mul(565,110)how(437,37)who()>-from()mul(171,296),/(select()!>!([]mul(951,550)&~&<what()'mul(78,890)how()#{how()who()!mul(858,123)-mul(808,41)}!<$;'select()mul(755*why()![ ^why()mul(178,567)^#$^who()-!mul(21,680)*how()-?mul(916,174) >,/(/mul(813,539)*+when(887,78)where()&why() / ?do()from()#:@}}~+$&mul(708,100);{'mul(490,889)mul(307,49)%}when()(#$why()mul(663,680) [$?[from()>don't()when()mul(503,241)///{!{select()mul(823,841)why()!>@>{!%@?mulwhen()+>?,>mul(244,508)~~}@mul(350,498){*from()-%from()mul(153,341)</where()*how()}*(select()mul(103,232))!%from();%+@?mulwhen()*when()(select()(#:@' do()'mul(826,640)~select()<who()>select(595,211)mul(790,795:,mul(906,897)%,$'why()[*&/>mul(8,207from()(#+who()don't()mul(459,429){@)select()how()why(),:#mulwhat()#who()what(121,599)%(how()-'mul(624,45)[+mul(808,781)>-@who()who(){where()}mul(924,821)what()$what(),:;~-mul(706,810)@-+what()&*'!mul(355,925)?how()]**from()from()*$*mul(741,733)how()'mul(341,144)<$select()from()@+do()>mul(152,910/select()~ select()]]{@mul(523,181)#+{mul(395,973)who()mul(64,860)?when()<from()don't()')why()(~mul(642,919)mul(689,633)>&mul(29,453)&mul(984,624)'~-mul(359,973)~what()mul(383,158)/(~mul(921,686)how(632,127) from()how() <from()))why()mul(407,977))what()+~+'{mul(638,303)(?why()mul(887,590)how()mul(508,492)@%^${}+mul(613,829)(what()where()%mul(488,38)do()+}~+what(538,242) %mul(813,912)<]mul(103,950)select()}who() who()#[mul(215,783)from()?(^mul(25,319)##&?,mul(922@when())/)%why()mul(544,417)what()(^{mul(137,343)}>:why()-/#^{where()mul(917,718)[]mul(434,737);+$*$mul(642,210))(why(),+mul(172,967)-$(!)from(268,882)(!mul(736,352)how(955,746)what()?&%mul(913,683)^mul(917,50)(#>'->&select() mul(7,425)@ (&?> <++do()^#-mul(116,337)*mul(65,555)where()) (#})?-mul(914,671)/;;${who()mul(909,642)from()& mul(118,302)when()^,do()+$:&mul(317,868)!<select() +]mul(734,951)who()what(607,933)why()^/*+what()when()don't()]> &@mul(797,580)when()from();?how(),who()!?mul%'mul(72,803)mul(623,829)?from()#~){mul(369,29)from()(('->}why()&why()mul(559,871)#)/how(454,608)who(299,39)what()why()from()mul(170,324)@/}mul(609,232)>,]<&from(){&{mul(573,297)(when()'[mul(113,821)where()where()what()$*mul(645,755)when()how()'{how()$-select()$mul(691,961)when()(-@mul(506,24)who():!},mul(271,406) mul(484,521)select()when(130,935)!,[mul(260,340)select()how()when()mul(271,829)select()'from(){[-}'-{don't()when():-who()what()$+mul(939,919)&}$-what()mul(527,489)<why()%}+when(826,514)mul(547,624?what()?<'-$*how(),mul(281,242)?:[who()when()when()select()mul)@mul(572,52)
+from()-^#*<)mul(704,198)*>what()>}{mul(992,257)*select() mul(613,810)why()?@*select()&;&@~mul(403,823)-*,](/why()mul(720,443)/$#how()who(){^mul(241,87)mul(650,931)<& -what()%!mul(547,874)]mul!mul(434,880)mul(775-!^where()$^,~from(40,598)what()where()don't() @how(519,628)from()(mul(302,37)<who()+mul(342,272)(>'mul(781,582)when()*select()):>~mul(779,697)>%'mul(943,75)what()!+#<(;]when()'do()what()mul(102,269)/@?(&#-who(542,407)mul(509,667select(274,878)^~<>how()#why()&#mul(268,871)[%why()~/[ ~!select()mul(767,191)>where()where()mul(933,796)$#%-who()**@-mul(203,818)where()mul(799,499)[*,+mul(909,701){$,mul(46,448)/][&}[,mul(310,979)from(),*;?-<when()mul(343,376),select() [{when(986,80)< ;mul(819,963)!mul(776,355)$who(128,894):,$~:mul(170,751)from()!*,where()}]mul(942,455)?{</@&,$mul(45,703)}<$''~[<mul(880,946);)?:)?+mul(746,737)-from()~do()when())mul(918,557):$&mul(710,332)from()<&/!what()mul(715,606),~^:how()when()~/&mul(438,91)+%~!~where()don't()((mul(457,120)when(121,808){(:^what()*from()mul(756why()from()]#]when()mul(399,120)<$@why()#from(288,288)]$who()mul(310,496)}mul(720,252)@#<:[]{mul(98@@%< mul(770,72)*why()mul(664,585)from()]+mul(737,351)!~$$)who()(mulwhere()how(267,616)where(62,517)how(){,),-[select(521,287)mul(858,912)how()-,-&mul(711,711)what()what()select(){^don't(),*~@mul(201,501)where()}'don't();-}+:mul(595,333) :~#,mul(95+<from()[:>$*%what()mul(34,562) what()'why(579,402)what();do()?/@/> </*what()mul(188{~how()mul(142,899)){#*<[ where(),mul(657,790)#who()why()mul(573,341)what()>&mul(230select()(,why(){{mul(780,887)?[@; mul(766,478)what()/ ?;do()/]-&when();  when():mul(426,588)[+ mul(687,427):!:$why()/who()who()from()^do()*>'mul(537,242),-;,#where()/~when()mul(362,214<what()^*how()mul(503,89))mul(773,824)]from()*;where()mul(758,993)+:why()what()mul(400,725)++{*[who(),:mul(707,292))do()mul(705,577>[where()/$#+where() mul(967,770)-+?/##>#mul(749,239)where()?(/why()#[mul(767,98)>+@^;#mul(378,187))%(< (do()@mul(958,879)[;#what()~^from()mul(892,531)( :&where()mul(173,372)mul(11,471)(where()where()}{$from()from()'mul(887,95)when()select():*$%mul(534,793)(^mul~~who()~when()from()%{>why()mul(507,869)where()where()<:mul(772,705)*who()what()do()how()/$mul(14,754)mul(966,261)when()>who()%& mul(795,477)$(:mul(381,47)^< select()from()mul(963,221)'mul(918,106)'what(344,90)who()where()@do())&mul(433,764)#(]/'&^, ~mul(22,392)<mul(380,322)mul(47,165)how()(>mul(998,135));how()~mul(280,141)mul(872,362)when())+who()what()#mul(342,86)]&-+<+^mul(996,141)>,*mul<how()+#from()%$why(520,611)mul(494,82)what(768,970)&mul(69,536)>)where()'/~*+mul(389,594)how()'where()don't()who()*&who()mul(962,541)mul(752,696)+mul(659,926);}when(){~!,^^who()mul(401,356)how()]&:}when()mul(84,233)where()<@/((}@*mul(149,810)how()'who()/>from()mul(535,710)who(358,296)mul(850<*@select()mul(695,834)why()$&select()when()*mul(225,980) )}mul(491,900),from()[{why()/from();mul(868,47)}%*select()'<!mul(877,658)^why(469,725)who()#;:don't()~)?mul(539,174)why()[where()'$}%<mul(64,491)/(where()mul(178,455) /@mul(423,219)mul(740,720)[who()$]--mul(717,716)mul(529,364)&' <what()how()'#-who()mul(923,495)
+)what(507,115)}<mul(343,622)*what():@~why(755,344)*select(786,77)<mul(253,810)! when() /select(400,692)mul(785,187)'$what(){mul(854,194)!why()where()%)from()<how()$:mul(978,677)why()-why()mul(707,444)+who()^mul(391,711)why()select()mul(221,80)-from(354,688),~*from()mul(697,532):%from()&mul(579,115)]^why()what()mul(81,717)]from()&from()<#@mul(715,125)~&)#from()why()who(629,830)]mul(845,52)where()mul(567,206)!select()*:]} ]mul(55,87)&why(),%&<$<:>mul(849,471)?$(mul(494,276)?*!-?!do(),what()*;mul(567,782)/^from()mul(905what()]]^((mul(75,486)where()where()select()mul(284,874)why()>mul(601,804))>]-from()from()where()]:&mul(330,34);{#mul(156,247)( ]+mul(999,763)$:mul(751,281){;*from()&?]mul(332,55)!-[&?mul(619,81)-?mul(96,239)?<>@#select()/mul(444,677)mul(618,319)why()%how()how(942,957))mul(748,564)}$++/mul(727,414)'mul(242,138)mul(931,661)@-what()mul(924,836)@mul(47,603)#>how()#mul(507,887)@/,#mul(146why()'don't(),))#who()select()select()when(374,670)mul(844,486]!-(where()^when()who()mul(415,866)%:%mul(544,385))/mul(426,967)where() +when();mul(20,241)]([@;[{who()}mul(90,379)where()}what()<what()where()select()[mul(436,687) )~)what()&mul(350,617)!why()>^@why()+,mul(20,933);*when()<?*;from()mul(491,830)<what()who(),where())[mul(821,946):how(712,542)mul(503,324)-$^*]mul(782,9)mul(981,296)&+who()$mul(763,721)]from(423,565)%how()^)^who()mul(207,493):-(where()}mul(357,921)+from()?who()(when()what()who()mul(179,292)what()don't()'[?]^}?)mul(520,59)-what()mul(670,986)]}select()select()>>&<^]mul(378,57){$mul(671,520)+mul(436,843)]mul(918,197)$[(:[#mul(280,176)%];>-(,why()why()when()mul(814,169)];+}mul(460,558)(*when()mul(948,922)}}?where()what()mul(751,374){+)@]mul(751,39)-:~~how()/!where()when(),mul(729,454)mul(76,943)mul(42,187)]:?#%mul(821,797)#%:[mul(329,209),#why()~$}select(302,971)when()?!mul(668,103)>when()%where()who()<^who()@/mul(882,873):$(&:@;' {mul(161,494)~mul(936,354);why()/how()why(186,585),;from(565,361)mul(642,336)[']*,!where()what(41,193)@mul(5,192)($$%mul(160,833)[@*where()mul(120,135)mul(301,599)?/mul(972,839):[from()who()#<how()mul(206,990)!>,[mul(936,580)*~why()?select()-/how()/-mul(781,329)from()}?'what()mul(838,340)?>#select()mul(40,712)>why()how(673,894)who()why()%mul(534,292)' /!mul(951,435)!?mul(656,237)^>%mul(937,63)from()/%#why()+>(#[mul(555,182)mul(956,211))}&?--~mul(101,767)@;who()()mul(639,997)@^{[</mul(31,930)&}how(993,334))%+:select()]why()mul(736,595)[&who()mul(54,475))from(204,393)'/<how()from()where()select()mul(769,146)mul(645,182):(^/{-:mul(654,200) ^how()'<!mul(40,655)'&^<mul(398,41):select()select(687,327)#@mul(688,746)&#-mul(973,150)-who(779,158)]'&what()mul(54,194)[who()$$when()-#>%/mul(658,528)mul(797,165)when(){@;what()who()(}mul(145,899)&{}:!#/mul(527,57)why(),]%-][$&,

advent_of_code/2024/3/src/main.rs

@@ -0,0 +1,81 @@
+use nom::{
+    bytes::complete::tag,
+    character::{complete::anychar, streaming::u32},
+    multi::many0,
+    sequence::{delimited, pair, tuple},
+};
+
+fn parse_input(input: &str) -> Vec<(u32, u32)> {
+    let input: Vec<&str> = input.split("mul(").collect();
+
+    input
+        .into_iter()
+        .filter_map(|s| {
+            let result = tuple((
+                u32::<&str, ()>,
+                delimited(tag(","), u32, pair(tag(")"), many0(anychar))),
+            ))(s);
+
+            match result {
+                Err(_) => None,
+                Ok(("", ns)) => Some(ns),
+                _ => None,
+            }
+        })
+        .collect()
+}
+
+fn solve_1(input: &str) -> u32 {
+    let input = parse_input(input);
+
+    input.into_iter().fold(0, |s, (a, b)| s + a * b)
+}
+
+fn parse_2(input: &str) -> Vec<(u32, u32)> {
+    let input: Vec<_> = input.split("do()").collect();
+    let input: Vec<_> = input
+        .into_iter()
+        .filter_map(|s| s.split("don't()").next())
+        .collect();
+
+    input
+        .into_iter()
+        .map(|s| parse_input(s))
+        .flatten()
+        .collect()
+}
+
+fn solve_2(input: &str) -> u32 {
+    let input = parse_2(input);
+    input.into_iter().fold(0, |s, (a, b)| s + a * b)
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The result of the multiplications is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The result of complicated multiplications is {}", result_2);
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 161);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test_2.txt");
+        assert_eq!(solve_2(test_input), 48);
+    }
+}

advent_of_code/2024/3/test.txt

@@ -0,0 +1 @@
+xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5))

advent_of_code/2024/3/test_2.txt

@@ -0,0 +1 @@
+xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))

advent_of_code/2024/4/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

advent_of_code/2024/4/input.txt

@@ -0,0 +1,140 @@
+SAMXMAXXAMAMSSSSSMXMAXXMSMMMMASAMXSAMXAMMSMXSAMXSSSSMMMAMXMMMMMSMSMSMMSXXASMXSMSMAAXSSXMXMAMASASAAXXSAMXXMASXMXAMXSSMMSAMXXMXXMAMXMSSSMXXSAS
+XMASMSSSXSAXXAXAAXXMAMSASAAMSAXASAMXMMSMAXMAMXMMMMMAASMSSXMASMAMMAAMMASXMMXMASAMMAMXAMXMAXSSXSAMXAASAMXXXMASMASMXMXMAAMSXMMSMMMSAMXAAAXXMXMM
+AMXMAAAAASAMMMMSMMMMASMASXMXMASXMAMAMSAMASMSSMMAAXSMMMAXMASASMASXMXMMASAMSAMMMAMSASMXSAXAMAAAMAMASMSXSMSSMAXAMAAAMASMMSAMAAAAAAMMSMMXMMAMASA
+SXAMMMMMXMAXXXAXMAMAMXMXMMXSAMMXMSSSXSMMXSAAAMSSMMXXXMMMSAMMSMMXAASMMASMMSASXMMMSASAASMSSSMMSMAMMXASMSMASMASXXSSXSASAMXMASXXXMMSASXSAMAXMAMX
+ASXSXXXSAXSAMMSSSMSASMSAASMSASAXSAAXAXXMAMMMSAAXMASMXMXAMASAMAXSSMAXMASAMMAMXXMAXAMMMSMAAAXAAMMMXMAMASMAXMASXAXAXMASXMAXMXMSSMXMASASXSMSXSXS
+MMMMMMMAXMXAXAAAAAXAXASXSMAXAMMMMMSMXMAMXSXXXMMSMSSXAMMSSMMAMAMXMAMXMMMAMSSSMMMMSMSXMXMMSMMXXMMXXMMMAXMMSMASMSMMMSXMXMAMMAMAAAXMXMMMXAAMAXAM
+XAAAAASMXMSMMMSSMMMSMMMMMMSMSMMAAXAAASXMAMXSMMMSMAMXXXAMAMSXMSAMXSXMMSSMMAMAASAXSXSASASAMASAMSSSMASMSSXMAMAMAAAXAMASAMMXSAMXSMXXSAAASMSMAMAM
+SSSSSMSXAMAXAAXMASAMAXMASXMMMAXSAXMMMXAMASASAMXXMASXSSXSAMAAMXASAMAMAAMASMSSMMSMXASMMAMASAMMSAAMSAMXAMXAMAXMSMXMASXMMASASAXXAMAXSXMXSAAMASAM
+MAMAMXSMXSMSMMXMXMAXAMMXMAXASMMASXMAMSASASASMMMSMMSAMXASXSMSSSXMASAMSSSXMXXAAAXSMMMMMSMAMAMXMMSMMMSSMSXSXMAMAAXSAMMXXMMASAMSASMMMXMXMXMMAMMM
+MMMSMASXXXMAMMMSSXSMMMSSSMMMSAMAAXMAXAAMMMMMMAAAAXMMMMXMASXXAMXAXMMMXXXMMXMSMMSAMXMXAXMMSASAMXAMXAAAAXAMXXXSXSXMASASMXMAMAMSAXAAAASASMSMXSMS
+MXAXMASXSMSSXSAAAAMAMAAXXXAASMMMSMMSSMXMMAMASMMSMMAXMMMMMMXSASXMASXSMMMASAMXAMXASMMMASMMSXSXMSXSMMSSMMAMASASAMMSAMXASAMXSSMMXSMMMMSASAAMASAA
+SMSSMXSXMASAAMMMXMSAMMXSAXMXSXMAMAAAAXSASASMSAMAAXXMMAMSSXASXMAMAAMAAMSASXXSAMXXSAASAMXASAMXXMAXMAMXMAXSASMMAMAMASAMMSMXMXAMXSXXAXMAMMMSAMMM
+XAAMMMMAMMMMMMXXMXMAMXMAMMXAMASAMMMXXMXASASASXMMMSAMMXSAXMMMMSXMSSMSMMMMMMMMMMMMSMMMMMMMMMMXAXMMMXMMXSXMAXXMAMMSAMAXAAMAMSAMAXSXSXMXMAXMAMXX
+MMMSAMSAMMAXMASMAXSSMMSMSSMASAMASXSSSSMXMAMAMMSAMAAMSMMMMXAAAXXAXMAMASMMMMXAXXMAMAMAAAAXXXXSMMXAXXMMXMASAMSSXSXMAMXMMMSAMSAMXSSXMASAMSMSSMMS
+MAAMMXSMMSXXMAMXMXAASAMXAAXAMASAMMXAAMMAMXMAMAMAMMAMAAMXASMSSXMXSXMXAAAAASMMSSMASASXSSSSMMMXSAMSMSAXSMASAAXAMSASMSSSMXSXMXMXMAXXXXMAMMAAXAMX
+SXSSXMXAXSMSSSMSMXSAMMSMSSMXSAMASXMMMMSASMSXMMXSMMAMSSMMXSXAMXSAMAXXXMMSMSAXAASXSXMAAAXAAXAMMXXAASMXAMXSMXXMAMAAAMAAMMMMSMMXSMMSAMXXSMMMSXMX
+XAXMXSMMMXAAAAAAAMMSSXMMAMXAMAMAMXAXMASXSASMXSAMASXMMAMXAXMXMASASXMMMXXMAXAMXXSXSXSMASMMSMMSASMMMMXSSSMXXMMXSSSMMMSMMAAAAAAAAAAMAXXAAMAAAMXM
+MSMMAAAMAMMMSMMMSXAAMASMMSMMSSMXSSMMSAXAMMMAAMXSAMMASAMMSSSSMXSXMXSAMASMSMSXMASAXMAMXXAXAAMMASMXSXMAAAMSAXMAMXAXMAAASXSSSSMASMMSSMMMMSMSMAMA
+MXAMXSSXSAAAXXXXXMMMSAMAXSAXAMXMMAMAMSSMMXMMMSAMXMXASAXSAAAXMXMAMMXASASAAMAASMMAMMXXMXMMMSMMMMMXMASMSMMSAAMMSMMMMSSXMAAMAMMMXMXXXMAAXAAMXSAX
+XSXMXXXXMMMSSMSXXMXAMXXSMMSMASXSSXMMSXXMAAXAXMXSSSMMSAMAMXMASMMAMMMXMMSMMMSXMAMXMAMMSSMAAAAMSAMXXMXXAAAMXMMMMAXAXXMXMMMMSMAXMXMMMSSMSXSAXASX
+XXSMMMMXMASXMMSAASMMSSMAMSXXMMMAMAMXSXMMSMSASMMAAAXAMXMMXAMSMASASMXSAMXXXXAXSMMXXAAAAAMMSSSMMXMMXSXMMMMSMSXAMMMXXXMXSAAAAMXMMAMAAAAMAAMASAMM
+XMAXAAAMAMXAMAMMMMAMAAXAMAAMSASASXMASAXAAXXAAXMXSSMSMSAXSXXAMXXAMAASAMAMSMSXSXSXSMSMSSMXMXMXSMSXAMMSAMXAAXSMMSMMMSMAXXMSSXSASXSMSSSMMSMAXXMA
+AXAXSXXXMAXMMAXAASAMSSMSSMSMSASASAMXSAMSSSXSMXMMAMAXAXAMAXSXMAMSMMMSXMASAAXASASMSAAAAXXASAMXMAAMXXAAAXSMSMSMAAAAAXMAMMXXMASAAAMAAAXAXXMMXMAS
+SMMXMASXSMSASMMSXSXXXXXXAAMAMAMASXXAMXMMAXAAMASAMMMMSMMMAXSMSMAAAAAXXMMMMSMAMAMAMSMMMSMMMXSAMMMSAMSSMMMAMAXSSSSSSSXAMMASMMMSMXMXMSSSMSASXAAM
+MAXASXMAAASMMXAXXMMSMSXSMMMAMAMXMXMASMSMMMSMSASXXSAAXASMXMMAAXMSSMSSMSSXMMMXMMMSMMXMAXMXSASMMSXMXXAAMAMXMMMXMXMAAMMMXAASAMAXMSSXAAAAXSAMSSMS
+SXMASAMMMMSAMMXMASAAASXSAMMASMSXAASXMASAMXXAMASMXMMXXAMXMAMXMSAAXXAAAAMASMMXSXAAXMAMSMMAMASAASMSMASMMMSAAXMASAXMMMSASMMMAMASMAAMMMSMMMAMAMXX
+AXMXXXMXXXSAMMXSAMSXXSASMMSASMMMSMSASXMAMXMAMXMXSSMSSXMAMMSAAMMAMXSMMMSMMAXAMMSSSSMMXAMXSASMXSAXMXMXXASXSASAXXMMXXSAAXASAMASMMSMSAMXXXAMASAM
+SSMSMXMXMASAMMMMMMXSAMXMXAMAXAAAAXSAMMSSMMMAMAAMAAAAMMSXSAMMXMMMSAAASAAASAMASXMAXXMASMMAMASMAMXMMAMMMXSSXXMASMSMSAMXMSMSAMASMXAMMASXSXMSAMXS
+XAAAMAXAAAMAMMAMXAXMXMASMSSMSMMMMXMAMMAAASXSSSMMSSMMSASXMASMXSAASXSMMXMXMXSAMXAMXSAAXMASMAMMXSSXMAMXAMMMSXMMMAAAMSMXMAXSAMASXMAXXAMMXAAMMSMA
+XMMASMSMSMSMMSMSMXSAMXAXAAAXSASAMMXAMMXSXSAAXAXAMXAAMMSAMAMMASMMSAMXMSSMMMMXMXSXAMMSXSAMMSMSMXMASMSMXAAAAXSAMMMMMXMAXAMSXMASMMMSMAMAXSMAXAXM
+SXXXXAAMAMAAMAAMXMAMMMMSAMXMMAMAXSMSSSXXMMMMSSMMSMMMSMXAMSAMMMSMMAMASASAASASXAXMASAXXMASXXAXXXMMXAAXXSMMXMMAMXAASMSMSSXMXMAXAMAAMXMSXMASMMSX
+AAASMSSSMSXSSMXMAMXSXSAAAXXXMAMSMXAMAMXXXAAAXAASXMAMXMMAMXAXMASXSAMXMASXMMASAXXXXMMSAMAMAMMMSAMAMSAMXAMMMSSSMSSXSAXMAMAMMSMSSMSMSSXMASAMAMAM
+MXMAAXAAAAAAXASMXSAAAMMSMMSMMXXXAMSMAMASMMMXSSMMASASAXXSMSMMMASXSXSAMXMMSMSMMMSSXMASXMASXMAAXMXSXMAMASXMXAAAAXMMMXMMASAMXAAXAAXAMXMSXMASXMAS
+SMMMSMSMMMXMMXSAAXMMAMAAAXAAAMAMXMXAXMASAAXAMAXMXMMMXSAAMMMSSMSASAMXSXAAXXMAXAXXSMASXSAMXSXSXXAMXMAMAMAMMMSMMMXMMAXSAMASMMAMMAMSMAASAMXMAMAM
+SAAXAAAAAXMXMAMMMMMXXMSMSXSMMMSMASXAMMXSXMMASAMMSSMXAMXMMAAAAAMAMXMASAMMSSSXMMSMXMAXAMSMXMAMMMXXAXMMXXAMAMAMXXAMSSXMXSAMAXSAMSAAMXMSAMASXMMS
+SXMSSMSXSXAAMXXMXSMAXXAAXMMXSAASASXSAXXMASMXMMSMAAXMXSSMSMSSMMMXMMMXSAMXXMASMSMASXSMXMAXAMXMXAXMMMMXMMMXMXAXSXMXAMAAXMMMSMXAMXSMMSAMXMAMMSAA
+SAXAMXMAMXXXSMMSAAMSSMMSMAXAMAXMXXAAXMSAMXMXSAAMSMMSMXMASAAXAAXAXXXMSAMXSMAMXAASAAMMXMAXSSSMMMSAMASASASASXMMSAMMSSMMMSAAMMSAMAMMAXAMMMXSAAMM
+SSMASAMAMMMXXMAMSSMAAAXXAMMXMXXMSMSMSMAMAMXAMXMMAAXAMXMXMASXSMSMMAXAMSMXSXMASMMMMXMAXMSSXAASAASAMXSASASASXMAMXMAMXAAAMMSSMMXMASMMSAMXXMAXMXX
+SASAMMSAAMSASMXMAXMXSSMMASMXMSAMXAAAAAMSSXMXSASMXSSXSAXXSXXMXMXXAXMSSXMMSAMXMXXSXMMMSAMAMSMMMXSXMXMAMAMAMAMASMMXSSSMSXXAAXMSMMSAASAMAMMASXMM
+SAMXSXSMAMMASXAMSSMXAMXSAMXAAXAAMSMSMSXAAAMAMAXXAMXXXMSMMMMMMAAAXSXXAAAASMMASASAMXAXMAMXMMMASXMASAMXMAMXXXMASXAXXXMAMXMSAMSAAXSMMSAMSXMASASX
+MAMMSAXAAXMXMXMAXMMAAXAMXSMSMSMSMXAXXXMMSMMAMXMMSSMSXAAMAAAAMMMMXXMAXMMMSASXSXSMMMSSSSMAXXXAAMAAXASXMXXMSSMASMXMXAMXMAMMAMSSSMSXMMAMMAMXXAMM
+SXSAMMMMMSAMXAMMSMSSMMSXMXAAAXAAAMXMMXSXXXSXSMAAAAAMMSMSMSSXSAMAXMMMSMXXSXMASAXXXAMAAAXMASMMSMMMSXMMMMSMAXMASAMMSXMASAXMAMMMMMMAASXMXAMAMSMM
+SAMXMXAMSXXMSXSAAMXAMXMAMMSMMMSMSMAXAAXXSAMAMXMMXSMSAAMXAMXXSAXSMSAAAXMASAMAMMMMMMSMSMXAAXXXAXAMAXSAMMAMMXAMXAMAAASASXMSAMXXAAXAMAASMSMSMMAS
+MAMMMMAMSASMSMMXSSSMMMSXMAXAMAXMAMAAMMSMMXMAMXXSAAAMMSXSASMMMSMAASMSSSSXMXSXMXMXAAMXAXXMSMMMSSXSSMSAXSAMXXSSSXMMSXMMSXMAMXXMMMSSMSXMAXAXMSAM
+SMMAMMMMMAMAMXAAMXAAMAMAMAXAMSMMMMMXSXAXMSSSMSASMMMMAMXAXSMSAXMMMMAXAAMMMASXMAXXMSXSMSXMAAAAASAMXAMAMSMMSMMAMMMXMMMMMMSSSSSSXMAXAMXMAMMMXMAS
+SMMMSAASMMMXSXMSSXSMMAXXMSSMMMASXAXAMXMSMXAMAMMXMAMMXSMMXXAMASMXSMMMMMMAMASMSSXSAMMSXMMSSSMSSMMMASMMMXAAAAMAMAXAMASAAMAXAAAASMSMAMMMMSSMMSAM
+MAAAMMXMAXSMSAAAMXXMSXMAXXAXAMMAXAMXMAMMMMAMXMXASMSMMAAXSMXMSMAAMAMSAAMSMAMAXAAMXMASAMXAMXXXAAXSAXASXSMSSSSSMMXAXASXSSMMMMMMMMXSMAAAMMAAXMAX
+SSMSSSXSAMXASMMMSASMAMSMMSAMXSSMASXMXAMAAXAMXXMXXAAAAXMMXMAMAMMMSAMASMMAMXSSMMMMAXAXAMXMAXAMMMXMASAMAMAMMMXMAXSSMASAMXXAAMAXXSAMXSSXMSSMMSSS
+MXMXAAAMXMMMMMAMXMMMXMAXMMSMXAAXSAAASXMSSSSSMAMMMSMXMSXSASAXASXAXMSMXSSSSMMMAAAMSXSMAMSASMMSAAXMAMMMXMAMXXMAMMAAMMMMMXXMMXAAMSASAMMMXMASMXAA
+MAMMMMMMASMMSSMMSXXAMSMSMAAMXSMXAMMMAAAXAAAAMXSAAXXAXSASASAMAMMAMXAXAAMASAAASMSMMAXSAMXAXAXSAMSXMMSSXSASXMAAXMXMMASASXSASMXMASAMXAAMXSAMXMSM
+SASAMXXSAXAMAAAASMMMMAAAMSMMXAXXMXSMSMMMMMSMMASMSMMSSMAMMMMAMXSASAMMMMSASMMMXAMAMSMSXSMAMMMMSMSAXSAAAXXSAXSMXSMAMMMAAAMAMAMSAMXMXSASXMMMAAAX
+XAMXMXMMXMAMSMMMMAAMMMXMMMASAMXSXAXMXMXAXXMMMMSMMMAMXMXMSAMXXMMASMXAAXMASMMAMSMAMAAXASMAMSMAAXSAMMMMMMMSAMXMAAAAMXMMMAMXMXAXXXMXMMAMXAASXSMX
+SSSSMASAMSMMMMSXSXMSASAMXSAMAXAMMMSMAMMMSAXAAXXXAMXSXSAMMASXMMMMMXSSSSMXXMAMXMMMXMXMXMXMXAMXXXMXMAXAXSAMXAAMXSXMSXXSAMXMASXSMAXMXMXMSSMSXMXM
+AAAXSAMXXAMAAMSASAASAXMSXMMSMMMSSMAMAXAAXMSSSSMMMSMXAXAASXMXMAAAMMMAMAMSMAMMMSASASAMMMSMSMSMSMAASXSMMMMSXSXSMMXSXMASMMAMXSAAMMMSAMAMXMASMMAA
+MMMMMSSXXMSSSSMAMMMMSMAAMMMAMSAXAMAMASMSMXAAXXAAAAMMXMMMAMMASASMSAMAMAMAAAMAASASASMSMAAXAXAAAASXSASMSMASXMXSAMMSAMXXASXSAMXMMMAMASXXAMASAXAS
+SAMXAMXMXMAAXAMAMXXAMMSMSASAXMASMSMSMAAAAMMSMMSMSMSAMMMMAMSASAMAXMSAXXSSSMSXXMMMMMXAMXXSMSMXMXAMXAXAAMXXAXAXSMASXMMMAMXMXSXMAMMXMMXMXMASMMMM
+SMSMASASMMMSMMSSSXMXSAAASASXXSAMXAAAAMSMSXAAAAMAXAXXMAAXAXSASAMSMMSAMXAMAAXMXMAMASMXMSAMAAAASXMMMMMSMSMMSMSMXMASAMAXSMSXMAASMSSXSASMAMXSXASM
+MAAXXSASAAAAAXAAMMSAMXMXMAMAXMASMMSMSXXXMMSMMMSMSMMMSSSMSXMAMMAMXMSAMXASMMMSASASASXMAAMMSMSMSASXAAAMAMXMAAXAXXAMMMSAMAXSAMAMAAAAMAMMAMXXMXXX
+MSMSXMASMMMSSMMAMAMSASXXMXMXMASMAMXMAXXAMAXAAMAAAAXXAAAMMAMXMMXMMMMMMSMMAAMSASAXXXAXXMXMXMAMSAMMMMMMSAMXMSMMSSSMSAMAMAMMMXSMMMMMMAMSSSSSMMSS
+MMAMXSAMXAXMAXXXMXXXXMAXMASMXMMMASASMSMSMASASMMSMMMSAMXMSAMMSXSMAMXSAXXMMMMMAMAMSXSMSXAMASAXMMMXSXMAMMMSXMASAAAAMXSXMAXSAMXAXXXXMMMAAMASAAAA
+AMAMXMAXSASXASXSMSMSMXMMSASAMXSSXMASXSAMXMXAMXAMAMXASXMXSAMMSAAXAMSMMSXSASXMMMMMSAAAXMMMAMXMXASAMAMXSAAMASXMMXMMMXMXASASASMXMSMSSSMMSAASMMSS
+MMAMAMXMSAMXMMAMAAMAMAXAXXXXAMMASMSMAMMMSAMSMXMSMMASMXMAXAXAMXMSMXAAMAAMMMAAMAXAMMMXMXSMSSSMXXMAMMMXSMMSAMXMXXASAMXMXMASXMMMAAAAAXXMAMXXAXAX
+XSSSSSSXXXMASMAMXMXASMSSMSMXSASAMMAMXMAAAAXAAAAMXSXMMXMMMSMSMSXAXSSXMMSMAMMMMSMMSXSXMMXAAAAXMMXMASMMXMXMASAASXMAXAXMXMXMASAXSMMMSMXSXMMSSMMM
+MMAAMAMAMXSAMSAMXSXMSAXXASAAAMMASXMSASMSXSMSAMXMAMAMXMASAXXMASMMMXMASXMXASMMMXAAMASAMAMMMSMSXMXXSAAXSXSMAMMSAAMAMMAMXSASXMAMMAAAXMAAAAAAMASA
+MMMMMASMMXMSXXMAXSAAMXMMXMAXSMSMMAXMAMAXXMAMXMAMASAMAMMMXSAMXSAMXAXXMASMXMAAXSMMMAXAMXSXMAAXMASXXMSMMSAXAXXMXSMAXSAMMMASAMXMSAMSAMXXXMXMMAMS
+XASAMASXXXAMXMXSASMMMMSXXXSAMAAXMXMMSMXMASMMSMXXXMMMASXSASXMAXAMMMMSSMMSMMSMMXMAMMSSMMMMSMSMXAXXXAXAXSMMMSAMAMXAXMMMSMMMMXMMXXSMXSSSMMXSMMMX
+SASASXMXMMMSSMAMXSXMAAAMXAXMMSMSSXAAMAXXAMAAXASASMSMAMAMASXXMSSMAAAXAAAXSAMXAASMSMAAAXXAAMAMMMXMMMMSMXXXAMXMAMXSSXSAMAXSAASXXXXAMXAASMASASXS
+AAXAMAMAAAASAMXSAMXMSSMMMAMAAMXMAXMASAMXSMMMMSMAXAAMAMAMMMAMMXMASMMSSMMAMXSAMMAXAMXSMMMSXSASASAMAASMMMXMXSASMSAAMAMXSMMSSXMAXSSMSMXMMMASAMAX
+MXSAMXSSSMXSAMXMASXMAMXAAAXMMMAXMMMAMMSXMASXMAMXMXMSXMMSXMMSAASMXAMMXAAMMASAMXMSXSMMMSMMASASASAXXXMAAAAXASMSAMMMMAMMAMAMXMMSMMAAAAXSMMASMMMM
+XMAMXMXAAXASXSXMMMMAMXXMSMXMMSSXXSXMSAMXSAMASMMXAMXAMMMSAAAXAXSXSAMXSXMASMMMMMXMAMMXAAAMAMAMXXXMSMMXXSXMASMMAMASXXSSMMXSAMAAAXMSMSMAAMAMAAXA
+MMMSAAMSMMMXXMASAASXSSXMAMAAMAMMAMAMSASAMASMMXSMSXSASXASXMMSMMSMSASASASMMMAMAXAMMMMMSMSMXMXMSMSMSAASMMMXXMAXSMXAXAXAXAXSAMXMXMXXAAMMMMSSSMSS
+AAAAXMAXAAXMSMASMXMSAAXSASXSMAMMAMXMSAMMMAMMMMAAXAMAMMMSXMASAAXASAMASAMMAXAMMSMSAAAAAAAASMMAXAAAMMMMAAAMXSMMAMXMMSXSMSMSAMXMSXSMSMSSXXAAXAXA
+XMXSSMMSMMMAAMASMAXMMMMMASXXMASXMMMXMMMSMMXAAAMSMMMXMAXMASASMMSXMXMXMASXMSMSAAASMSMSMMMMAAXMMSMSMMSSSMMSAAXSXMAXAAAXAXASXMAMAASAMXAAMAMSMXMX
+MSAMXMAAAXSSMMXSAMMSMAMMAMMXSAMAMXXMASASAMSSXXAXAAAASXXSAMMXMASXXMXMXAMXMAMMMMXMAXAMXMAMXAMXMMXMAAAXAAAMMSMMASMSMMXMAMMMMMSSMSMSSMXXMAXAAAMM
+AXXSAMMSSMAAXSAMASAAXXMAMSAAMMSMAXMASMASAMXMSAAMSMSMSXXMASXMMAXXAMASMMMXMAXSSMXMAMXMAXMSMSAMXXAMMMSSSXMMAXASAMMMXSMMAMAMAAAAXXMAXAXMSSSXSXSS
+MSMMMSMAMMSMMMASASXMMXXMXMMXSAAXXSAMMMAMAMSASMMXAXXASAXSXMASMXSMASASASMSSSMAAMXXSXMSXMAAAASXMMMSMXMAMXMMSSMMASMMASXSAMASMMMSMSMASXMMAMAMXMAX
+XMAAAMMAMMAXXSXMXMAXAMMMSXAMMMXSMMMXXSAXXMMAMXSSMSMAMMAMXMAMXAMMAMMXAMAAAAMXMMSMXAAAXSMMSMXXAAAAMMMMMSAAXMXSAMAMASASMSMSAAXXAXMMXMAMXXAAXMAM
+ASMMSSSSSSXSMSAXXXSMXMAMXMMSASXMAAASXSAXSAMSMXMAMMMAMXASAMXSMSSXMSAMSMXMMMMASAXASMMMMSAAXXASXMSMSXAXAMMSSMMMSSXMMMMMXAMXMMSMAMXMASXMSSMSXMAS
+MMXXXXAMXMAMASMMSXMAMSSMAMSMAXXSMMXSXMSMAAXXAMSSMASASMMSXSXXAXAAAMMSXAASXSSXSAMMMXXXAMAMMMMSAAAASMMMSXMMAMXAMXXAAMASXMSXXAAAAMASMSAAAAAAXMAS
+AMMMMMMMAMAMXMMAXAXAMAXXSSMMSMXXSXXMAMMMSMMMAMAMMMSXMXASMSXMMMMXMXXMMSMSAAAAMXMXMXSMSSXSAMMXMMMMMASAXAMSAMMSMSMSASAMAAXMMSXSASXSAXMMMMSMXMAS
+MSSXAAASXSSSMMMSSMSSMASMXAXSAXXAXMASAXAMXMASAMASAMMAMMMMASMMMAXAXMAXAAAMMMMMMSMXMAXAASMSMSMXSSSMXXMASAMXASAXXAXXAMMSMMMXAAAXXXXMMMMSAAAXXMAS
+XAAXXMXMXMAXAAAXAXAXMAMXMAMSASMMMSMSSSMMAXASASASAXSAMASMMMAAMSSSSXMAMXXMASAAAMAAMMSMMSMMAAMMMAAMSMMMMXMSMMASXXMSAMXAAAXMMMSMMSMXXAMXXXMSXSAS
+MMSSSMAMSMMSSMSSSMMSMASAMAMMAMAXMXAMAMMASMMXAMASAMMASASAASMMSMAMAMSXSMMSAMSMSSSMSAAXAXASXMMXMSMMAAAMXMMAMMSMMAAMAMSSSMSXXXAAAAAXSXSXSMXMXAAS
+XXAAASMXXAXAASAMXAAAMASMSSSMASMMXMMMMXSAMAXMMMAMXMSXMMSXMSXSAMXMAMSASMAMMXMXMAMAMMSMMSAMASXAMXXSSSMMXXSASXMASMSAMXAAAXXAMSSMMSSMMAMAMMAMXMMM
+MMMSMMXXSXMSSSXMSXMMMXXXAAXXMAMAXXXMMAMXSXMXXMSSMXAMSXXAMXMSAXXMASXMSMASXAXAXMMMMAXAMMASAMSAMXAMXMAMAMMMSXMAMXXAMMMSMMMAMXAMXMXAMAMAMMSXMXAS
+XAAMAMMMSAAMAXAXMASXMSXMAMSSSMXSAMMSMMSASMAMMMMAMSAMAMSMMMAMXMSXMAXAMXASMMSSMXAAAMMSMMXMAXAMXMXMASMMASAXMXMAXMMMMSAMAXXAMMSXMASMMMSASXMAXMMM
+SMMSAXSAMMXMASAMSMMAAAXSMMSXSXAMMXAAAXMXMAAAAASAMXAMMXAXAMSSSMMASAMMMMXMAXAAASXXXXAMXMMSXMSMSXXSXXXXXXXMXAMMMSASAXASXMMMSAMXSMXMAAMAMXSSMAAM
+MAMSAMMASXXMASAMXAXXMMMXAXMAMMSSXMSSMMSSXSMSSMSASXXMXSMSXMAAAAAAMXSXXMMSSMSXMAAXSMSMAMAXAXMAMMXMMMSSSXMAMXSAASMMMXMMMSAXMASMSAASMMSAMAAASMMS
+MAMMAMSMMMSMASAMSSMMAXSMXMMAMMAXMXXXXSAMXXAXXAMAMXMAXAXXXMSSSMMXSASASXAAAAASXMXMXAASAMXSMMMAMXAAAXMASMSSMAAMMMMSMXAAASXMSSXAMSMMAMXAMMSMMXMX
+SSSSMXMAMSMMASAMAMAMSMSXMXMAXMSSXXAMMMMSMMMMMSMMAXAMMXXMAXAAAASMMMSAMMMXMMXXXMASXSMSMSMSAAXXMMXMSMMMMMAAMMMXSAMAXSSMXMAMSMMMMXXXAMXXXMAXAXSM
+XMAXXAMAMXXXMMAMXSAMAAXXAMMSSXMAMMAMAMXAXAAAAXAMASXSAMXMSAMXMASAAAMXMXSSSMMSXMAXMMMSAAASMSMSMXSMMASXSMSSMAXXMAMXXXAXAMSMMAAAASMSASAMXMSMXMAS
+XMSMMSSSSSSMMSXSMSXSMSMMSMAXMMSASMSMSSSSSMSMSSXMAMAAMAMAAAXASXXXMXMSSXXAAMASMMSSMSAMSMMXAXAXAASAAMAAMAAMXMMMSXMMMSSMSXXAMSMMXXAAAXMAXMAMXAMX
+SMASXAAAAAXAXAAMASMSAMAAMMMMAXMASAMXMAMXAAXMAMXMASXMASMXXMMMSMSMSXMAMSMSMMAXAXXAAMAXXXMAMMAMMMSAMSMMMMMXMAAASAMXASAAMASAMMSXSMSMSMMSASASMSAM
+XSAMXMMMMMMSSMSMAMAMAMMMSAXSSMMAMXMXMMMSMMMMASASMSMXMXSSXMAMXAAAMMMAMSMMAMASMMMMMMMMSASMMMXSXXMMASXSAMXASMSXXAMMSXMMMAMXXMAMSAMAXAAXMSASMXAA
+XMXSXXAXAXAMAAXXAMXMXMAMXMXMMAMASMSMSXMMMMASASXSXXAXSAMXASMSMMMAMXSSXSASXMAXXAAMMAMXSAMXSXMAXXSXXMAXXXMXSMXXSMMXMMMXMASMSMMSMAMAMMMSXMXXMXAM
+MAMAMSMSSSMMMMMSMSMMXMXSAMAMMAMAMAXSAMXAAXMMAMAXXMSMMMSMMMMAXMMAMXSMAMXMAMXXMSSSSMSAMSMAMMSAMMSMAMAMSSMMSAMXAXSAMAAXSXSASAXAMXMAMXAMXMSAMXSM
+ASMSXAAAXXAAMAXAMMAMXMASAXAMMSSXMSMSMMSSMSMMSMMMSMAMAAAAMSSMMMSASMSMSMASMMSSMAXXAXMXSAMXSAMASAMSMMMMAAMAXMAMXXMASXMMMAMAMASXSSSMSMMMAXSAXMAA
+SXAAAMMMSMSMSMSMXSASAMXSSMMSMAAXMXAMXXMMMXMAAAAAASXXMSSSMASAAAMXMASAASMMSAAAMMSSXMMMXXSAMMSMMMMAMAMMSSMASXXSMASXMMSXMAMAMMXMXMAXAASMXMSXMAXM
+XMMMXXAAMXMXAAAMASMMAXAMXSAAMSMMXMAMSMMAMAASMXMXXXMAXXMAMASMMMXSMMMSMSMXMMSMMMAMXMSMSXMASASAMXSAMXXXAAMASASAAXMASXMXMASAMXMAMSSMSSMASAMXASMM
+SASMXMMXSAMSMSMSXSMSSMXSAMSSMXAAXSXMAMXAMXXAMMSMSMSXMASXMAMMSXXSAMXXXXAAMMXASMASMMAASMMXMASMMXSMSMMSSSMSSMSAXMSAMXAXXAXAMMASMAXAMAMAMAMXSAAA
+MASAMXAAMMMAAAXMASMAAAMMXXMXXXMMAMASMSSMSMMAMXAAXAAMMAMXMMSAMMASAMASASXMSASAMSASAMMSMAMAMXMAMAMMAAAXAAXXXAMAMMXAAXASXMXSAMAXMASMSXMMXSMMMMSS
+MMMMXMMSMXSMSMSSMSAMXSMMSMSAXXAXXSAMXMASAAXAMMMMMMMSMAMXXAAAXXAMAMASAMSXXAMAMMMSMMXMAXXAXXMSMASXSSMMSMMSMMMSMXSMSMMAAAAXAMASMXSAXXXAAXMSSMAA
+MASXAAAAMMSMAMXMXMXXAXAXAAMAMSSMMMMSASXSSSMSSXAXXXAXASMSMMSMMMMSSMMSASXXMASAMAASASMMMSSSSSMAMXMXAXXAASAMAXAXXXMAXAMSMMMSSMAXMAMMMSMMXSAAXMAX
+SASMMMXSXMSAMXAMAMMMASXMASMAMMASAAMSASAXAMAAAXMSAMXSMXMXAMXAXMXAAAXSXMXXXASAMMMSMMAAAMAMAASXSMMSMMMSXMXSXMXSXSMMXXMAAAAAXMSMMASAAXAAMMMMSSSM
+MXSAAMMXAMXXXSXXAMAMXSAAXXXXMAASXSXSAMXMMMMMSAMSASAXMASXSMSAMSMSMMMXMMMMMMMMMXXSASMMMMAMSMMSMAAXAAMMASMMMSXMXSAMSSSXMMMMXXXASASMXSMMSMMMAAAX
+SXSMMSASAMMSMMMSSSMSASMSSMMMMMMMAMXSXSASXAMMMAXSAMAMSASXAXMAMSAXXSAMAAAASASMSXAXASAMXSMMAXXAMMMSMXXMAMXXAMAXAMAMSAAASMMSAAMAMASMASAMAMAMMSMM
+SAMXXMXSXMXAAAAAAMMMASMMAMAASASXAAXXAXAMXAMASMMMSMMMMAXXAMXMXMAMAMMXSMSXXASAAMSMMMMMAAXSASMSSSMMMASMAMMMSSMSMSSMMMMMMAAAMMMAMXMXAXAMASXSMAAA
+MAMMXSXMAMSSSMMMMSAMXMASMMSMSASXXMSXMMSMMMMAXAAAAMXXMSMSMAAMMMXMXMMXMAMAMSMXMXMXSAXAMMXSAMAXXMAAMASAMXMAXAAMAAXXAAAAMMMMMASXSXMMMSSMXSXAMXSS
+SAMXAMASAMAAMAXSAXAXSSMSXXMASXMASXMASAXASAASMSMSSSMSAMASASXXAMSASMSAMAMMXMAXSXMASXMXMXAMAMXMAXMMMAXAAAMXXSAMMMSSSSSSSSMMSMMXSMSSXAMMASXMMMMM
+SMSAAXMASXSSMASXMSSMAMAMMAMMMAMXSASAMXSAMXMXAXAMAAAMAMAMAMMSSSMASXMASAMSAMXMSAMASXASXMMSSMSSSMSSMMSASMMSAMXXMXMAMAAAMMAAMAMAXMAMMMMMXSAMXSAX
+MAXMAMXXAXMAMXSAMAMMAMAMAXMAMAMXMAMXSAMXSXMMSMMMMMMMMMMMMMXAMAMAMASAMXSMSSXASAMASXMXAXAAAXAAAAXXAAAAAASMAMAXXAXAMMMMMXMMSXMMSMASXSASXSAMXMMM
+SAMXXMASMMSXMASXMAMXAXMSSMSAMXSSMSMMMXSMSAMSAMXMXMXMSAXAXXMSSSMASXMAMSAMXMAXSAMAMAMMMMMXXAMSMMMMXMMMMXMSXMMMSMSMMSMMAAXMSAAAMXMSASASASAMXAAA
+MASXSXMASAMAMXSXASXSSXMXXAMMSMAMAAXXMAXASAMAAAMXSAMXSXSMSMAMAASAXAMXXASMSXMMSXMASAMASXMAMSMXAXMASMXMMMAMXAAAAMMAASAMMMSAMXMMSMXMAMAMMXASXMAS
+XXAXSAMXMMSAMMMMSXAXAASMMMMAAMAMAMMXMASXSAMXSXMAMAMAMXMAAMMMSMMSSMMAXMASMAMXMASMSASXSAMMSAASMMSSMSMASXMXMXMSSSMMMSAMAAMAMMSAAMAMMMXMAMSAAASX
+MXMMSSMSAASXSASXAMMMSMMASAMSSSMSXAAXMASXSXMXXMMMSAMXSAMXMSMAAXAAMXMXMXMMSMMAMXXASXMMSMMSSXXMXAMAMXMASAMXSAAAAXXAAMAMMMSXMAMXAMXSAXASXMMSMMMS
+AMXAMMMMMMSXSMSXMASAXAMMSAXAMXAMMMSMMXXMMMSXMASASMSXAXSAAAMXMMMSSXMAAXXXAMXMMXMXMXMASXMMXMSMMMSAMXMASAMASMSMXMSMSSSMSXMMMMSSSMASMMXMAXMASAXX
+MXMMSAXXSXSAMAXMXMMMSAMASMMSSMXMASAMXMXAAAXMAMXMXAMXMASMSMXAXXAAMASXXSXSXSAMSMMMXAAMMXMAAAAAAAXAMXMXSXMASAMXAAAAXAAASMSXMSAAAMAMXASAMMMAMMSS
+SXSXSMXMMAMAMSMSSSSXMAMMMSAMMAMSMXXXAXMSMMXMSMMSMMMAXAXMMXSSMMMASAMXAMMMAMMXAAXAXSSMAAMXSSSMMSSSSSSMMAMXXAAMMMMSMSMMMAAAXMMSMMAXAAMASXXXSXAX
+AASMMXSAMXMMMXAXAAXSMASXAMMMMAMAMSSSMSAMAMSAXXAAXASAMMSMAMMAAASAMXSMMMAMMMSSSSMSAXAMSMSAXXAMXAAXAMAASXMSMMMSAMSMMAAAMSMMMXMXAMXXAXSAMMSMMMMS
+MSMAAAXXMMSXMMSMMMMXSASMSMXAMAMXXAAAXMMMAMMAMMSSSXAAAAAMASXSMMMMSMAAASMMXMAAAMAMXSAMAAMMMSMMMMSMMSSMMMAXAAAMAMXASMMSAMAAXAXSSMSMSXMASAAMAAMM
+MAMMMSMMMXMASXMAXXSAMXSAAASXMMSSMMSMMSSMSMMMMAXMMMSSMSSXMMXAMXXXAAMSMMAMXXMMMMSMMSXMMSMMAAAMXMMMXXXXAMMMMMMSAMSMMMAMASMMXMMMAMAAXMSXMMMXSXSS
+SMAXXMAMSASXMAMSSXMASAMXMMMAASAMAMXXAAXMASAAMXMAAAMAAXAASXSXMAMXSSMAXXAXSMXAAMAAMMMSAAAMSSMMAMAAAMMSMSAAXMAXAXXMASXSAMMAASASMSMSMAAXMASAMMAA
+AXMMSSSXAMMXMXMAMXMMMXMAXXMSMMASMMMAMMXSAXXXSXSMMSSMMMMMMAMMMXXAMAMASMSXAMSMSSSXMAAMXSAMXMASXSXSXAAAAMXSMMSSMMSMAMMAAMMXXMASMAXAASMXSAMASMAM
+SASXAAMAMXMXSAMXSAXAAASMMXMAXSAMMAXAAXXMAXSMMXSXAAXAAMSMMXMAXMMXMAMXMAAMMMAAXAXASMMSAAMMAMXMAMMXMMSXSMXMMAXAAAXMASXMMMXSAMSMMMSXMAXAMMSSMASX
+MXAMMSMSXMSASASASXSMSMMSSXSSMMASMXSMMXSMSMSAAAXMMMSSMMAXMAMMAXAMMSMSMAMMXSMSMASMMASAXMSSXMAMXMSAMMXAMXASMSSSMMSSXMAMAXAAAXMASXMMSMMXSMMASXMX
+SXMXXMAMAXMASAMASAXAXAAAXMAXSMXMMXMASMXAAAMAMSXXSAAMAXXXSASMSMMSAAAXAAMMXMSXMXMAXSMSXXMAASXSMXSASAMAXMXSAXAMAXMASXSMAMMSMMMAMXSASASAAASAMXSX
+XAXXAMAMAMMAMXMAMXMXMMMMSAXXXXSMSMSAMAMSMSMSMXAAMMXSXMSMMASAAAMMXMSXSXSXAMMMMMSASAAXMAMMMMAAXAMAMXSSMSMMXMAMSXSASXAMXSAXAXSSMAMMSAMSSMMMSAXM
+SMMSMSXMMSMSSMMASMMMSSSMMXAMSXSAAAMMSSMAAAAAAMMMMAXMMMAAMXMMMMMSXXMMMAMMSSMAAAMSAMXMASMMXMSMMSSSXMXMMSAASMAMMASAMMSMAXXSMMMAMMSAMAMXXXAAMASA
+MAAMXAAAMAMXAXSASAXAAMAASAMXAAMXMMMMXMMXXMSMSMMSXSASASMSMSAMXAAAMMMAMXMSMAMMMMSAMXAAXMAMSAMXAAAAXXAMASMMMMMSMAMAMAXMXSMXMASAMSMXSSMMASMMSASX
+SMMXMMMMXAMSSMMASXMMSSSMMXMAMMMAAXXSASMSSXXXAAMMAMXMAMAAXXMASMSXSAMMMAMASAMSMXMAXSMSASAMMAMXMMSMXMXMASASAXSXMMSMMASAMXAXSMSASMAMMXAMXMAXMASX
+AXMASXSMSSXMMAMXMAMXMAXMMAMASMSMSAASXMXAAXXXSSMMAMMMSMSMMMXMAMAASMSASASMMXXXAASAMAXAXMAXMAMAMMXXSMAMASAMMSMAXMAMMASMMMMXAXSMMMMMASXMAMXMMAMA
+MSSMSAXAAXAASXMSMMSAMAMXSXSAMAAAAMAMXMMXMMSAAAMMASMAXAXXAXAMAMMAMAXAXMMXMMMSSMSAMXXSMSSXSASMXSAMAXMSMMAMXAMSMMSXMASASAMSSMMSMXAMMMSMMSMMMSSM
+XAAAMXMMXSMMMMASAASAMSSMMMMMSSMSMMMMAMSMXAXMAMSSMSMXSMMMSXMMAMXMMAMSMSSSMAAMAXXXMAMXAXAXSAMXXXASAAXAMSSMSSSMAAXMMMSASAMXAAAAXMXMAAAMXAASAMXX
+AMMMMXXSASASXMAMMMXXMXAAMASAMXAAAXAXAMAXMASXMXMAASAAMAAAMASMSSSXMXSXAXAASMMSSMSSMSMMSMMMMXMSXSXMMXSAXAMXXMAMMMMMSAMXSAMSSMSMSAMSMSMSMSXMASXM
+SXSXSAAAAXAMXMASXMSSSXSMMMSASMSMSSMSSMMXSASAMASMMMMSSMMMSAMAXMAASMXMXMSMMSMAXAXMXAAMMMAAMMMAAXMAAASMMASMASXMMSAASASXXAMAMXMAMMMAMAMXXMASAMXA
+AMAAMASMSMSMMXAMAAAMXAXXSMXAMAAXXAAAAASAMXXASASXSAMXAMSMMMMMMMSMMAASAXXXAAMMMMMSMSSMAXXMMAAMXMSMMXSASAMMAMXMASAXMASASXMMSAMXMSSXSMMXMSMMMSSS
+ASMXMXMXAMMAAMXSMMMSMSMAXAMSMSSMMMMMSMMAMASXMASXSSSXSMMAAXAMAMXMASASMSSMSXSXMXASAAAMXSASXSMXMXAAMAXXMXXMAMASXMSMMXMASAASMMXAMAAXSMSAMXMAMAAA
+XXMMSMMSMSMMMSMAXMXAAMMSMSMMAAAMSMMXXXSAMAAAMXMMMMSXMASXMSMSMSAMXMASAAMMAAXASMASMMMMMAAAAXMASMMSMXSMMMSSMSAMAAAXXXMXMMSMAMSMSMMMMASXSAMXMMSS
+SASAMXAAXXAAAAMMMSAMXMAAAAAMMMSMAAXASXSAMASXMAAAAASMSAMAAAXAMXMXXMMMMMSMMSMAMMAMAAXXXMMMXMASMXXAXXAAAAMAXAASMMMSAMXXAXXMAXAAAASAMXMMSAMXSXAX
+SMMSSMSSSSSMSSXSAMXSSMAMSMSMXMAXSSMXSMSXMMAMSMSSMXSAMXSAASXMASMXAXSAMXXXAXMAMMASXMXSASMXMSXXMAXMSMSSMMSAMSXMASXAMMXMASXSMSMSSSMMXMAMSMMAAMMS

advent_of_code/2024/4/src/main.rs

@@ -0,0 +1,153 @@
+use std::cmp::{max, min};
+
+fn parse(input: &str) -> Vec<Vec<char>> {
+    input.lines().map(|s| s.chars().collect()).collect()
+}
+
+fn check_xmas(chars: &Vec<Vec<char>>, start: &(i32, i32), direction: (i32, i32)) -> bool {
+    let h = chars.len() as i32;
+    let w = chars[0].len() as i32;
+
+    if start.0 + 3 * direction.0 < 0
+        || start.0 + 3 * direction.0 >= w
+        || start.1 + 3 * direction.1 < 0
+        || start.1 + 3 * direction.1 >= h
+    {
+        return false;
+    }
+
+    let xmas = vec!['X', 'M', 'A', 'S'];
+
+    for x in 0..4 {
+        let cur_pos = (start.0 + x * direction.0, start.1 + x * direction.1);
+
+        if chars[cur_pos.1 as usize][cur_pos.0 as usize] != xmas[x as usize] {
+            return false;
+        }
+    }
+
+    true
+}
+
+fn solve_1(input: &str) -> usize {
+    let input = parse(input);
+
+    let h = input.len() as i32;
+    let w = input[0].len() as i32;
+
+    let mut result = 0;
+
+    for j in 0..h {
+        for i in 0..w {
+            if input[j as usize][i as usize] == 'X' {
+                for ii in max(0, i - 1)..=min(i + 1, w - 1) {
+                    for jj in max(0, j - 1)..=min(j + 1, h - 1) {
+                        if input[jj as usize][ii as usize] == 'M' {
+                            let dir = (ii - i, jj - j);
+
+                            if check_xmas(&input, &(i, j), dir) {
+                                result += 1;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    result
+}
+
+fn check_x_mas(chars: &Vec<Vec<char>>, candidate: (i32, i32)) -> usize {
+    let h = chars.len() as i32;
+    let w = chars[0].len() as i32;
+    let (x, y) = candidate;
+
+    if x == 0 || x == w - 1 || y == 0 || y == h - 1 {
+        return 0;
+    }
+
+    let mut result = 0;
+
+    let mut diagonal_ms = vec![];
+    let mut diagonal_ss = vec![];
+    for i in 0..2 {
+        for j in 0..2 {
+            let coord = (x as usize - 1 + 2 * i, y as usize - 1 + 2 * j);
+            match chars[coord.1][coord.0] {
+                'M' => diagonal_ms.push(coord),
+                'S' => diagonal_ss.push(coord),
+                _ => (),
+            }
+        }
+    }
+    if diagonal_ms.len() >= 2 && diagonal_ss.len() >= 2 {
+        if diagonal_ms
+            .into_iter()
+            .filter(|&(cx, cy)| {
+                let x_diff = cx as i32 - candidate.0;
+                let y_diff = cy as i32 - candidate.1;
+
+                diagonal_ss.contains(&(
+                    (candidate.0 - x_diff) as usize,
+                    (candidate.1 - y_diff) as usize,
+                ))
+            })
+            .count()
+            == 2
+        {
+            result += 1;
+        }
+    }
+
+    result
+}
+
+fn solve_2(input: &str) -> usize {
+    let input = parse(input);
+
+    let h = input.len() as i32;
+    let w = input[0].len() as i32;
+
+    let mut result = 0;
+
+    for j in 0..h {
+        for i in 0..w {
+            if input[j as usize][i as usize] == 'A' {
+                result += check_x_mas(&input, (i, j));
+            }
+        }
+    }
+
+    result
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The number of XMASs is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The number of X-MASs is {}", result_2);
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 18);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 9);
+    }
+}

advent_of_code/2024/4/test.txt

@@ -0,0 +1,10 @@
+MMMSXXMASM
+MSAMXMSMSA
+AMXSXMAAMM
+MSAMASMSMX
+XMASAMXAMM
+XXAMMXXAMA
+SMSMSASXSS
+SAXAMASAAA
+MAMMMXMMMM
+MXMXAXMASX

advent_of_code/2024/5/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2024/5/src/main.rs

@@ -0,0 +1,102 @@
+use std::collections::{HashMap, HashSet};
+
+use nom::{
+    bytes::complete::tag,
+    character::complete::{multispace1, u32},
+    multi::separated_list1,
+    sequence::separated_pair,
+    IResult,
+};
+
+fn parse(input: &str) -> IResult<&str, (Vec<(u32, u32)>, Vec<Vec<u32>>)> {
+    let (input, result) = separated_pair(
+        separated_list1(multispace1, separated_pair(u32, tag("|"), u32)),
+        multispace1,
+        separated_list1(multispace1, separated_list1(tag(","), u32)),
+    )(input)?;
+
+    Ok((input, result))
+}
+
+fn check_update(updates: &Vec<u32>, rules: &HashMap<u32, HashSet<u32>>) -> bool {
+    let mut forbidden: HashSet<u32> = HashSet::new();
+
+    updates.iter().all(|page| {
+        let lookup = forbidden.contains(page);
+
+        match rules.get(page) {
+            None => {}
+            Some(s) => {
+                for excl in s {
+                    forbidden.insert(*excl);
+                }
+            }
+        }
+
+        !lookup
+    })
+}
+
+fn solve_1(input: &str) -> u32 {
+    let (_, (rules, updates)) = parse(input).unwrap();
+
+    let mut exclusions: HashMap<u32, HashSet<u32>> = HashMap::new();
+    for (before, after) in rules.into_iter() {
+        match exclusions.get_mut(&after) {
+            None => {
+                exclusions.insert(after, HashSet::from([before]));
+            }
+            Some(s) => {
+                s.insert(before);
+            }
+        };
+    }
+
+    updates.into_iter().fold(0, |sum, update| {
+        sum + if check_update(&update, &exclusions) {
+            *update.get(update.len() / 2).unwrap()
+        } else {
+            0
+        }
+    })
+}
+
+fn solve_2(input: &str) -> u32 {
+    
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!(
+        "The sum of correctly ordered middle page updates is {}",
+        result_1
+    );
+
+    let result_2 = solve_2(input);
+    println!(
+        "The sum of the incorrectly ordered middle page updates is {}",
+        result_2
+    );
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 143);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 123);
+    }
+}

advent_of_code/2024/5/test.txt

@@ -0,0 +1,28 @@
+47|53
+97|13
+97|61
+97|47
+75|29
+61|13
+75|53
+29|13
+97|29
+53|29
+61|53
+97|53
+61|29
+47|13
+75|47
+97|75
+47|61
+75|61
+47|29
+75|13
+53|13
+
+75,47,61,53,29
+97,61,53,29,13
+75,29,13
+75,97,47,61,53
+61,13,29
+97,13,75,29,47

advent_of_code/2024/6/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2024/6/input.txt

@@ -0,0 +1,130 @@
+........#...#..................#.#............#....#....##.........#.............................................#................
+.#...............#...........................#..........#..........#....#........................................#............#...
+............#...........................................##.................#.......#............................................#.
+...#.......................##.........................................#..............................................#....#.......
+.......#....#......#...................................#............#............#.......#.......#.................#..............
+#......#........#..................................#..##........#...........#.....................#......#..................#.....
+......................#........#.....#.....................#.......##........#............#.#....#..#.......#.....................
+#.........................#.................#.............................................................#.......................
+.....#....#.................................#........#..#.........................#............#...#.........#...#..............##
+......................................................................................#...#......................#...#...#..#.....
+.................#........#.............................#........................#.....#..................#.......................
+...#.........................#.#..........#.....#..............................#..#...#...#.........#.............................
+.#............#.................#.....#..............#................#...........................................#...............
+...........#...#......#.........##................#...................................................#....#.#....................
+.................................#..................................................#..............................#...#..........
+.#...............#............#....................................#.....................#............#....................#.....#
+.#....#.....................#.....#.......................#......#......#...................................#.....#.........#...#.
+.............#...#...............................#...#...........#...............#....#....#..............................#.......
+...#......................................................................#.........................................#.............
+...#..................................#........#........#...................#.............#.......................................
+......................................................................................................................#........#..
+......................#.....................................#.....#.................#.........#..............#............#.......
+..........................#...................#....................................................................#........#.....
+...........#.....................................................#............#.....................#....................#........
+..............................#.....#......................................#..........#...#........#........................#.....
+.......................................#..................#.........#..#....................................................#..#..
+........................................................................#.................##..#...................................
+................#.#.....................#.......#..#..................#.........#.................................................
+........#......#......................#.........#..........................................#..........#....#..##....#.......#.....
+......................................#..........#...........................#..................................#......#..........
+..##...#..#......................#............................#...................#........#......................................
+.......#........#............#..................#....#...##.......................................................................
+....#......................#......#.............#................................#...#........#.........#.....................#..#
+......................#...#.........................#..................................###..............................#........#
+.....................................................................................#.....#...............#.......#..............
+............#.................................#..................#..........................................#.................#...
+..........#...................................#.............................#..........#................................#.........
+............................#..........................................................................#....#.............#.......
+...............#..#.........#.................................................................##........................#.......#.
+.............#..........................................................................#.........................................
+........................................#...#...#....................#...........#...........#....................................
+............................#................#..............#............................#.......#..#.............................
+................#...#.........#.............#.........#.......#...........................................#..#.....#..............
+.......#......#.#.............................................#.....#...#...........#.............................................
+.#....#...............#.........................#....................#........#..................................................#
+..........................................................#.................#.................................#...........##......
+....#.....................................#..........................#........#.....#........................#....................
+...##................................#........................................#..............#.....................#...#..#....#..
+..............#.......#..................................#..................#.....................#....#.....................#....
+.......................#......................................##..........#......#..............#.............................#...
+....#....................#............#.........................................................................................#.
+..........#..#.......#.....................#................#.#.....#.....#...........................#...........................
+.......................#..#.#.............................................#......#..........#.....................................
+...........#.........................................................................#..............#..............#..............
+............................................................#.....................................................................
+...................#....#..#..............#...........................................................#.......#.#.................
+..............#...#.#....#......#...........................................................................................#....#
+....................#.................................................................................#..#...#....................
+.......#...#...................#.............................................#..............###..........#........................
+...................................#................#.........................................................................#...
+..............#.......................#...................................#................................#......................
+...........................##........................#...............................#.........#..................................
+....................................................#..........##.......................................................#.........
+........................#................................##.................##.#...........................#.....................#
+..............................................................................................................#...................
+.............................#........#..........................#................................................................
+..........#..........#...............................................#...#................#......................................#
+................#...........#...............................................................................#................#....
+.....................#.............................................................................#..#................#.....#....
+#.................#....#.......................................#..........................#...###.......#..#.....#.#..#..........#
+............................................................^.............................#.#............................##....#..
+.#............#.................#......#..................................#....................##.................................
+......................................................................#.......#...............#..................#..........#.....
+.........................................#............................................#.....#.#.#..#..........................#...
+....................#.........................................................#.......#...#..#.....#..............................
+..........#......................................................##......#................#.....................#.................
+..........#.............................#..........................#...........#..#...............................................
+.................................#......#.............##...............................................................#..........
+........................................................................#.....#.....................##...##...........#...........
+..#..#.................................#......................#.........#.................#.......................##..............
+.....................................#..........................................................#.................................
+...................#...........#..........#............................#.........#................................................
+................#.................................................................................................................
+........................................#.....................##.......#........#................#....#................#..........
+.................#.............#........................#..................................#......................................
+......#............................#.......................................................#.....#........#.....#..............#..
+..........#..................................#.......................#............................................................
+...#..................................................#...........#....#....#.......................#.........................#...
+............................................#..#............................#..................#......#........#...........#..#...
+#........................#........................................................#...............................................
+.....#.#.#................................................##.#...................................#.....................#.#........
+....#................#..............#.....................................................#........#................#.............
+..........#........#...................................................#...........................#..............................
+....................#..#.........................#....#.......#....##.............#...............................................
+.................#...........................#...........#................................#...........................#...........
+......#...#....................................................................................................................#..
+......#.......#......................................#.........#.................#.#..........#.................................#.
+.......#........................###.........................#...................#................#.................#..............
+.##.........#.........#..............................................#...........................................#..#.#.........#.
+..........#..................#..........................................................#.....#..................#...............#
+......................#..............#.....................##................#..#.....#..........................#.#..............
+....#.#..#..............................#........#........................................................................#.......
+.........................#.....................#....#.....................#..........................................#............
+..#..#........#........................#................................#..................................#.#..................#.
+........#...#.....................##.........#.............................................................................#......
+....#...........#............................#.............................#...........#........#..............#..#...............
+......#...................#................#..................................................##.......#....................#.....
+.........#.##.....................................................................................................................
+........................................#......................#................#....#......................#...........#.........
+.#......#.#......#................#....#...#..............#...........#........................................#..................
+#...#......................................##.................................................................................#...
+.................#.........#...............................#......#.................#.......................................#...#.
+...#..#......#.........#...........#..............#...................................................................#.........#.
+...........#.#........................................#..............#............................................................
+...........................#.................................................................................#............#.......
+.............#......................................................#.................#..#..............#.........................
+...........#.....................................................#...............................#................#....#..........
+..........#....#........................#...........................................................................#.............
+.......................................................#..........................................#...................#...........
+..............#...........................................#.............................#..................#......................
+.................#....................................................#.....................................#...............#.....
+.......................................#........................#.........#................#........#............##.....#.........
+....#...#..............#........................#....................#........#...................................#...............
+......##.#......................................................................#.............#...................................
+....#.......................#..........#..#..............#..............#.#..........................#...............#....#.......
+.........................#......................#...........................#...............#......#.............#................
+.......#.........................#.......................................................................#........................
+.......................#........................................#...............##...........#...................#.....##...#.....
+.....#........................#.............#.........#.....#................#..............#..........................#..........
+.................#...................#....#...........#....#........................##.....#...#..................................

advent_of_code/2024/6/src/main.rs

@@ -0,0 +1,188 @@
+use std::{collections::HashSet, time::Instant};
+
+use nom::{
+    branch::alt,
+    character::complete::{char, multispace1},
+    multi::{many1, separated_list1},
+    IResult, Parser,
+};
+
+#[derive(Debug, PartialEq, Eq)]
+enum Tile {
+    Start,
+    Empty,
+    Wall,
+    Passed,
+}
+
+fn parse(input: &str) -> IResult<&str, Vec<Vec<Tile>>> {
+    let (input, result) = separated_list1(
+        multispace1,
+        many1(alt((char('.'), char('#'), char('^'))).map(|c| match c {
+            '.' => Tile::Empty,
+            '#' => Tile::Wall,
+            '^' => Tile::Start,
+            _ => unreachable!(),
+        })),
+    )(input)?;
+
+    Ok((input, result))
+}
+
+fn proc(
+    height: usize,
+    width: usize,
+    dir: &(i32, i32),
+    pos: &(usize, usize),
+) -> Option<(usize, usize)> {
+    let x = pos.0 as i32 + dir.0;
+    let y = pos.1 as i32 + dir.1;
+
+    if x < 0 || y < 0 || x >= width as i32 || y >= height as i32 {
+        None
+    } else {
+        Some((x as usize, y as usize))
+    }
+}
+
+fn turn(dir: (i32, i32)) -> (i32, i32) {
+    match dir {
+        (0, -1) => (1, 0),
+        (1, 0) => (0, 1),
+        (0, 1) => (-1, 0),
+        (-1, 0) => (0, -1),
+        _ => unreachable!(),
+    }
+}
+
+fn solve_1(input: &str) -> usize {
+    use Tile::*;
+
+    let (_, mut tiles) = parse(input).unwrap();
+
+    let mut pos = (0, 0);
+    for (y, row_of_tiles) in tiles.iter().enumerate() {
+        for (x, tile) in row_of_tiles.iter().enumerate() {
+            if let Start = tile {
+                pos = (x, y);
+                break;
+            }
+        }
+    }
+
+    let h = tiles.len();
+    let w = tiles[0].len();
+    let mut dir = (0, -1);
+
+    loop {
+        tiles[pos.1][pos.0] = Passed;
+
+        match proc(h, w, &dir, &pos) {
+            None => break,
+            Some(mut p) => {
+                while tiles[p.1][p.0] == Wall {
+                    dir = turn(dir);
+                    p = proc(h, w, &dir, &pos).unwrap();
+                }
+                pos = p;
+            }
+        }
+    }
+
+    tiles.into_iter().fold(0, |sum, row_of_tiles| {
+        sum + row_of_tiles
+            .into_iter()
+            .filter(|tile| *tile == Passed)
+            .count()
+    })
+}
+
+fn solve_2(input: &str) -> usize {
+    use Tile::*;
+
+    let (_, mut tiles) = parse(input).unwrap();
+
+    let mut pos = (0, 0);
+    for (y, row_of_tiles) in tiles.iter().enumerate() {
+        for (x, tile) in row_of_tiles.iter().enumerate() {
+            if let Start = tile {
+                pos = (x, y);
+                break;
+            }
+        }
+    }
+    let start = pos;
+
+    let h = tiles.len();
+    let w = tiles[0].len();
+    let mut result = 0;
+
+    for y in 0..h {
+        for x in 0..w {
+            match tiles[y][x] {
+                Wall => continue,
+                Start => continue,
+                _ => tiles[y][x] = Wall,
+            }
+            pos = start;
+            let mut visited = HashSet::new();
+            let mut dir = (0, -1);
+
+            loop {
+                if visited.contains(&(pos, dir)) {
+                    result += 1;
+                    break;
+                }
+                visited.insert((pos, dir));
+
+                match proc(h, w, &dir, &pos) {
+                    None => break,
+                    Some(mut p) => {
+                        while tiles[p.1][p.0] == Wall {
+                            dir = turn(dir);
+                            p = proc(h, w, &dir, &pos).unwrap();
+                        }
+                        pos = p;
+                    }
+                }
+            }
+
+            tiles[y][x] = Empty;
+        }
+    }
+
+    result
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+    let now = Instant::now();
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The number of walked tiles is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The number of possible obstructions is {}", result_2);
+
+    println!("Time passed: {:?}", Instant::now() - now);
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 41);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 6);
+    }
+}

advent_of_code/2024/6/test.txt

@@ -0,0 +1,10 @@
+....#.....
+.........#
+..........
+..#.......
+.......#..
+..........
+.#..^.....
+........#.
+#.........
+......#...

advent_of_code/2024/7/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2024/7/input.txt

@@ -0,0 +1,850 @@
+237069504000: 96 30 30 28 139 705
+355813: 50 702 120 7 59
+92316680: 92 22 9 66 77
+3255967: 4 7 6 10 17 420 5 1 6 97
+11052: 8 3 1 4 75 3 59 1 73 4 9
+1257: 9 45 312
+1891867: 69 96 20 573 968 1
+29274: 1 4 2 9 49 435 999
+735: 49 56 7
+178684952: 7 944 226 9 3 9 5 87 4
+931690: 6 9 6 2 21 7 1 4 8 67 53 8
+3111108: 5 12 52 6 5 7 924
+6367117: 386 98 15 877 97
+708411564: 602 3 712 22 7 6 97 7 6
+7437045: 6 4 664 6 969 77
+115221283: 5 761 2 12 83
+2508671041: 529 9 9 74 2 7 3 263 42
+273159250: 9 607 5 924 8
+43585420368: 3 2 8 42 824 6 2 9 15 9 9
+2500411: 61 85 66 4 14
+12278592: 919 8 275 72 803 4 6 8
+20222880: 6 47 6 18 8 779 1 7 5
+8485682784: 5 840 9 874 6 68 2 784
+372258: 75 8 737 872 6
+3814: 481 6 6 856 36
+49375365299: 259 87 19 65 299
+44237592313: 6 711 28 6 75 31 823
+3262097: 124 43 1 156 61
+12114: 12 1 3 657 18
+92866410: 86 8 5 3 3 5 1 58 765
+84381196: 843 81 11 8 6
+3474211523: 8 5 2 890 6 9 3 45 2 3
+3989216025: 89 409 6 52 80 19 4
+113683: 90 8 440 98 3
+35919085: 6 17 4 9 9 105 15 332 5
+1276027208: 7 8 9 45 8 6 3 364 205
+3755300: 47 5 188 85
+400540: 4 86 607 6 6 7 70 1 10
+136298: 1 2 3 1 8 9 5 7 3 30 3 128
+341550: 3 50 706 50 9
+466: 14 361 9 75 7
+993: 72 2 7 3 95 167
+2137: 1 7 14 90 6 889 8 9 8 2 9
+51007: 4 1 22 46 6 5 37 41
+115824871066: 98 30 694 3 90 9 8 8 6
+3049865: 209 912 8 16 9
+682764373: 95 819 747 6 370
+28117542: 1 2 28 6 15 2 8 3 698 5 2
+787360: 10 72 20 2 532
+272177752: 37 6 147 5 1 94 187 79
+270638934900305: 601 419 85 533 4 45 3
+177686786: 489 13 1 394 2 28 82 4
+8091273930: 15 299 531 996 6
+1297565607: 353 3 6 8 7 4 9 81 4 16 7
+406397250: 1 6 5 4 3 5 523 5 75 2 7 5
+792296: 81 68 97
+670106431: 97 7 86 661 630
+17279687695: 4 3 1 1 8 91 1 17 4 8 9 8
+16481196306: 3 5 4 841 518 69 4 999
+2700: 64 22 4 6 5
+1802736: 6 6 11 9 207 1 2 99 624
+148727240: 474 9 1 733 6 5 6 7
+14003808: 1 41 8 425 5 9 42 4 4
+7219781: 735 824 4 991 37 9 3 8
+17635772870: 7 7 769 4 9 9 90 6 7 13
+1238645: 825 3 91 5 690
+297593858: 5 595 934 4 57
+221224903: 5 63 232 661 61 7 3 52
+175925: 73 9 4 38 7 99
+40: 5 8 1
+98942419: 8 4 224 8 6 25 6 3 307
+8985535057: 641 82 39 28 7 4 5 86
+9070: 4 42 8 6 4 8 27 23 87 93
+6479532: 2 1 9 46 6 57
+27783036: 926 10 3 3 5
+175703: 10 5 16 4 7 5
+91287: 7 125 37 8 7
+7599577: 8 751 12 1 760 9 755
+41062428: 412 95 51 64 4 9 396 1
+132958: 9 8 36 38 66 34
+23980403928: 5 8 14 163 3 923 8 449
+36112462: 360 4 7 246 2
+9094648: 90 9 4 1 646
+348875652: 69 77 5 5 655
+2181061: 233 6 52 2 4 30 1
+1317288: 4 151 236 2 9 9 70 2 3 4
+510561: 4 710 3 82 71 9
+831427: 93 4 294 455 5 977
+1997: 7 8 55 3 6
+1167: 143 1 5 16 1 989 13 1
+169011360: 598 828 32 69 35 4 12
+4839: 67 72 15
+933064: 37 272 3 75 92
+291744440: 3 399 7 7 717 4 1 7 3 4 8
+23048: 5 8 36 4 2 4
+1909575240: 443 93 5 927 8 151 1
+98778: 7 8 220 4 4 7 99 2
+2649449: 916 329 56 38 9 80
+7996: 795 92 9 6 6
+2162145: 83 1 55 17 915
+12612783: 65 9 7 770 46 4
+41595: 4 7 27 3 3 3 8 9 6 7 608
+162017397: 385 755 42 28 1 6
+12360213: 409 521 7 58 645
+77734358: 6 612 6 5 67 7 103 5 9 8
+1042471: 5 883 31 9 78 3 1
+2832102: 43 94 3 86 7
+14118694632: 2 413 30 343 5 54 3 1 7
+5634124: 56 2 98 9 34 24
+596: 6 56 21 36 477
+281900625: 56 63 8 11 2 5 41 15 95
+5873677056: 7 7 29 1 552 20 8 936
+365947: 3 65 948
+431340: 847 7 12 695 65
+474147: 33 95 7 2 528
+64272120: 3 298 462 11 2 319 4 6
+4838900: 47 62 89 35 250 88 98
+1231: 5 80 3 3 26 3
+486173: 3 69 326 9 4 7 32 541
+204659: 204 8 8 930 59
+84678574: 7 1 760 66 9 1 46 85 74
+1160233201: 149 36 42 515 10 1
+25716872: 9 1 2 1 88 9 92 8 9 158 2
+302296176: 59 51 26 138 28
+1898800: 623 4 33 94 8
+15237: 73 7 35 5 688 549
+1551395933257: 7 2 8 1 62 79 9 7 321 4 4
+157899: 408 510 172
+218738622: 6 1 6 6 30 8 73 2 5 2 957
+25169: 63 288 83 29 2
+1831746686: 708 210 10 8 59 154
+39173640951: 69 645 9 9 6 88 8 72 79
+57468: 79 5 777 3 22 8 634
+46497: 23 47 7 371 9 6
+9073901: 96 528 94 10 259
+23869007: 119 8 938 390 93 2
+2296: 6 211 77 263 4 68
+96549347: 96 542 7 34 7
+871130324: 8 572 8 2 56 29 5 7 482
+637440160: 9 4 7 3 9 40 7 5 480 160
+65110: 44 2 739 76 2
+348: 3 40 6
+3788: 972 842 2 89 71
+15869846: 80 6 6 58 563 2
+37581151: 75 5 8 1 151
+2024944110: 326 9 5 147 939
+2346776: 58 12 68 17 697 72 4
+32691: 30 88 93 88 1
+128421240: 61 49 8 7 77 99 672 8 3
+89460: 71 7 4 5 9
+34930: 1 5 992 5 7
+9112: 23 3 2 6 6 6 2 66 50 17
+380311103943: 7 560 733 97 2 943
+39671: 33 12 6 2 9
+101958385429339: 57 5 6 718 70 469 7 7 9
+771912: 24 944 733 1 33 3 72 1
+124136: 2 218 876 94 808
+96205937575: 861 4 87 7 404 4 9 275
+10605: 4 8 4 6 4 3 56 1 9 781 1 3
+9208811: 99 3 9 2 875 6 3
+4122727366: 21 5 7 7 4 5 564 4 40 7
+7174362: 3 3 5 33 66 634 23 94
+823914: 82 38 46 3 64
+1697767030: 8 304 9 126 2 69 67 7 4
+3728: 335 97 33 4 2 8
+54243: 8 2 123 41 52 41
+199578543: 2 494 642 9 888 8 6
+47208016834: 2 62 266 6 1 9 3 2 4 1 7 2
+20468171570: 68 700 3 90 9 430
+221319: 16 5 199 428 891
+399: 2 1 12 377 8
+510: 6 1 85
+55746468: 3 55 3 368 51 918 6
+111380647958: 98 9 6 3 4 8 2 599 8 3 1 9
+5730: 7 9 97 78 20 871 99
+532422: 9 84 438 999 9 4 413
+46788865: 7 1 486 7 6 2 814 2 6 43
+6985667702: 39 395 7 846 2 3 906 2
+203274: 78 4 822 355 3
+2727144: 7 921 47 7 9
+398839: 741 55 97 68 5 14
+2347797: 891 9 6 4 4 645
+411362494: 528 7 36 6 1 778 440
+51628: 6 8 460 107 903 8
+49449627171: 7 2 96 9 73 14 7 1 7 7 9
+2414114: 90 1 893 3 3 330
+36287514: 7 439 812 723 11
+134576739: 278 8 9 9 528 1 4 8 3 1 2
+14360068890: 8 711 18 9 7 5 352 1 90
+23436: 5 88 7 8 217
+31865702400: 444 8 8 8 5 7 5 89 9
+20333: 5 3 6 6 26 3 3 7 491 52 8
+3038904: 2 336 70 455 1 36 3 6 9
+4103: 63 24 8 2 5 610 3
+362316954904: 807 3 44 7 51 452 2
+589186620: 713 43 328 6 5 32 6 66
+3154744619: 7 43 7 527 151 9 257
+1029422: 250 3 686 29 182 2
+503327166190: 4 80 6 1 8 2 2 6 93 61 89
+1007217: 99 6 50 68 23 1
+654480: 8 36 6 9 60 1 36
+434734: 688 5 627 9 214
+280500027: 925 9 927 42 9 3 905 7
+14482075: 5 67 6 24 31 72 3 561
+40750: 9 84 40 19 50 1
+9602155248: 8 51 5 6 4 9 9 6 56 7 98 8
+40018884: 183 18 6 33 52 51 7
+261: 30 3 2 8 69 4
+28553731: 327 74 59 4 5 79 12 1
+2446038: 7 85 6 685 588
+30736299: 819 3 8 859 6 13 53 9
+277196: 74 92 3 9 5 441 8 868
+8980472578: 6 7 8 64 7 467 1 22 647
+172874739239: 2 9 83 8 82 4 9 9 9 3 105
+20221385: 318 693 2 1 38 2
+2011: 10 3 1 8 3 8 5 89
+193812789: 19 300 4 17 3 788 789
+9636: 4 988 614 6
+166155567: 69 49 4 9 533 673 661
+717091552: 2 963 6 7 76 1 3 2 4 68 1
+116610: 83 7 101 47 4 74 39
+25697: 40 2 79 979 2 79 3 3 5 7
+14114: 546 437 48 6 522 9 83
+29160403: 405 6 12 269 5 129
+1510: 4 5 8 7 9 799
+291570: 8 60 534 8 598 476
+7946546: 132 657 5 654 7
+11666304: 22 4 6 76 2 492
+79766: 4 5 1 6 50 2 2 2 591 572
+12190: 16 4 4 7 2 46
+9239904443: 9 234 5 891 3 8 2 4 3 2 8
+239261124022: 242 766 999 2 1 646
+782666281: 7 7 6 139 7 38 9 8 73 8 1
+5578997760: 920 56 8 2 8 846
+510528: 163 6 5 31 2 9 4 7 6 4 8 6
+73981818418: 1 3 7 6 9 177 4 8 415 3
+213301702: 5 2 6 84 2 25 284 6 1
+19955520: 3 8 6 3 90 36 5 845 8 9 2
+595066500: 90 89 86 7 1 7 250 6
+286394460: 69 83 8 892 5
+5538831: 998 45 9 1 8 59 28
+1205296694: 704 8 3 80 71 68 9 5
+1173717: 1 2 74 6 469 8 4 3 44 3 9
+906238: 55 98 168 718
+383753: 1 7 685 7 549
+6905408: 690 433 14 93 7
+985142648: 345 7 34 932 3 8
+3620429290: 451 30 4 4 94 8 9 8 32 1
+678: 4 3 2 652 2
+293253492177: 5 199 5 3 6 94 14 1 35
+69905: 8 3 6 39 38 21 8 31
+9345568: 8 5 1 7 253 6 517 854 8
+646000: 4 97 441 750 500
+764501184889: 555 92 18 764 889
+52151238: 1 1 516 39 839 990 17
+25969550: 22 15 7 695 50
+11766013317: 9 2 2 7 4 75 6 642 7 2 9 7
+2859: 11 3 8 19 8
+64: 56 4 1 3
+376347: 12 544 3 7 3
+366815: 450 813 3 14 948
+6857620: 6 56 5 6 7 671 20
+1179612: 2 311 4 6 6 62
+1555199: 4 777 2 40 5
+9867484: 2 982 2 748 5
+478817: 7 684 11 6
+489547800: 2 1 5 7 880 7 500 7 81 2
+111801: 58 8 8 2 3 6 5 9 6 2 6 9
+9624: 12 1 40 442 1
+73892124: 2 8 5 754 7 7 8 2 8 5 5 69
+1965299158: 82 496 34 99 159
+5821016496: 379 5 202 257 4 8 73 4
+4291587636: 7 86 4 7 2 5 812 27 4 8 7
+1651005720: 78 9 1 83 3 14 642 13 6
+62578: 8 4 67 310 2 7 1 9 1 8 1 1
+99567955245: 287 7 5 45 74 9 552 48
+2605913046: 1 8 4 1 1 858 9 393 6 99
+13790287218: 813 17 569 11 73 1 4
+5516882: 7 788 3 18 564
+4055397: 427 95 549 736 92 37
+749152: 8 6 3 2 9 706 6 4 1 27 8 8
+68885: 688 8 5
+497344120: 8 91 9 19 149 917 4
+2647674: 7 42 1 8 6 9
+45468591: 4 5 46 85 89
+168921310163: 515 164 655 2 161
+2782959: 278 23 23 627 9
+3826134425890: 6 545 2 234 85 174 4 5
+142643443: 385 95 2 4 39 5
+31654497: 4 6 69 4 819 1 594 14 7
+3338528657: 6 5 2 8 1 9 7 965 13 385
+83238611: 69 8 835 2 6 6 7 1 5 5 8 3
+104191387: 3 84 2 7 1 8 1 191 378 7
+9913380: 8 9 374 93 3 4 8 4 3 12
+2622141784413: 7 6 4 2 5 365 3 66 2 47 6
+8378783370: 871 25 7 1 765 2 873
+160937: 447 360 8 9
+2440: 262 5 6 62 766 10
+260344: 6 7 7 3 5 3 87 716 2
+208727566608723: 4 9 6 94 2 516 814 721
+887972: 60 3 1 1 157 72 4 4 93 2
+147299: 917 555 1 4 85
+1391335886: 22 39 16 1 617 888
+23745790: 77 855 305 7 8
+4377065: 6 93 1 7 8 6 87 9 7 391
+54734505971281: 42 847 32 8 59 499 8 1
+435988544: 14 6 3 4 952 4 2 7 7 1 47
+5921364325140: 83 4 287 560 3 9 6 6 99
+11392192: 3 9 8 5 7 1 9 17 4 7 4 944
+1153645: 64 3 6 9 4 977 2 4 1 5 8 5
+5633136: 5 8 1 43 136
+2865654424: 4 894 5 2 8 6 120 683 8
+104876: 5 3 33 2 487 71 3 6
+44772705: 3 26 1 792 1 3 5 7 8 8 79
+5354298: 8 520 9 75 2 80 2 109
+2072744124: 4 87 65 419 974 836
+9592579: 95 916 9 7 6
+52518780: 5 2 466 4 7 8 9 15 6 34
+122260: 59 598 186 58 1
+8460202958: 29 4 71 4 9 627 91 956
+152: 6 81 65
+137650796900: 562 299 72 50 34
+216905: 1 2 2 351 611
+49805150: 17 68 861 787 50
+234855903: 275 1 8 4 34 5 2 7 9 5 3
+791572768: 879 9 59 413 766
+4328936: 538 3 8 899 34
+28075: 1 4 1 929 3 1 9 6 65 68
+1559: 71 46 9 9 425
+1038096490: 1 2 38 91 6 88 5 3 4 90
+847147248: 639 9 358 856 81 2
+268127: 757 246 5 44 53
+5750108: 754 1 4 2 136 7 20 8
+41916: 408 6 98 880 96 368
+7607: 2 839 1 9 38
+1872381: 159 368 8 4
+76433449: 8 9 93 7 9 2 1 8 276 8 79
+85116: 2 45 9 851 867
+3171592: 31 71 3 94 2 93 103
+47589719: 118 1 1 357 897 19
+43416749: 4 288 27 2 375
+92974345208: 701 417 837 5 38
+383334669: 47 911 33 5 3 34 8
+3303: 108 4 26 390 1
+1248898639: 84 9 1 83 3 6 8 1 2 1 6 39
+275175: 4 2 6 7 8 39 3 153 2 9
+364343670005: 7 183 5 702 6 4 5 810 2
+51244048440: 39 99 415 63 615 13 4
+170715797: 16 2 74 8 5 1 6 5 6 9 89 2
+32309: 257 56 5 9 950
+1043218: 141 85 6 87 1
+1458: 5 86 4 936 88
+40086: 91 5 88 38 6 2
+31644: 8 6 71 231 45
+36905: 42 9 26 8 55 55
+32361088: 854 64 8 37 8 2
+7922781: 80 44 484 4 11 5 3 654
+657865: 50 9 660 9 64 4 63 65
+884583: 8 845 83
+111180: 2 80 9 7 8 430 2 1 6 3 68
+7624: 75 42 37 38 8 1
+5892532: 19 8 5 4 99 29 4 410 5 7
+1047913: 89 253 6 5 3 5 51 730
+8301: 8 99 77 9 50 3
+1313532272: 107 124 990 94 180
+840: 67 3 770
+361138: 8 7 4 548 3 6 334 1 8 9 2
+174855991: 221 3 3 67 79
+833111: 302 55 476 11 2
+8754548349: 8 32 9 4 7 7 24 2 4 83 5 2
+601584: 948 633 253 833 414
+6126309: 983 5 694 78 7 2 169 7
+64819881584: 1 9 7 45 14 8 9 81 5 8 1
+5967559: 93 64 8 7 559
+16328160: 90 403 690 48 1
+513532: 258 2 6 6 36 9 3 310 6
+15655747: 9 3 9 1 6 7 572 34 91 7 9
+237684: 7 7 92 70 322 759 42 6
+27048: 6 98 65 4 8
+1048973: 52 70 55 38 281
+10939115: 45 963 5 69 252 47
+19837: 9 11 990 28 9
+473835: 8 93 3 21 5 3 6 633 7 2
+504234: 29 6 49 6 237
+5494944: 230 36 5 3 663
+69796160: 4 8 57 796 161
+29096760: 3 6 71 87 159 517 4 6 7
+12021: 64 26 18 4 1 6 8 78 7 2
+853987: 8 394 8 3 6 6 629 83
+6750233825: 31 296 5 4 3 8 343 714
+469826: 34 8 556 3 6 86 9 8
+347521988: 495 90 4 1 78 8
+549: 55 9 8 44 2
+398696370: 18 88 5 9 51 28 7 978 5
+865398616: 9 40 8 1 19 51 5 9 2 2 8 7
+56130: 9 7 9 3 1 7 1 45 39 7 5 5
+563500: 28 4 17 112 70 50
+4921246: 86 73 1 6 87 10 9 1
+716419908: 3 66 5 1 79 6 365 8 92 9
+47913: 4 1 74 5 1 10 3
+149522: 6 1 4 7 8 9 3 8 64 8 888 4
+140791326: 41 788 80 63 10 69
+24696560: 7 20 3 4 3 5 1 294 5 2 8 7
+83096679: 127 2 644 508 71
+64889: 9 913 7 34 7
+2984011: 8 6 89 357 6 61 196
+261145500: 9 350 98 285 3
+9066797: 452 48 86 50 4
+424912: 68 6 333 2 2 3 87 4
+408789: 42 4 752 88 524 274 5
+7029: 52 32 197 25 4
+25547: 33 4 9 319 293 1 3 9 5
+5668: 7 66 71 7 3 325
+235593690: 650 59 65 2 759 4 91
+494539813: 4 938 7 398 13
+748: 657 5 72 5 9
+50702: 3 770 434 2 3 7 8
+1379822126: 62 315 2 366 425 5
+23041257515: 40 3 63 8 617 8 9 5 14
+249356: 2 74 91 1 8
+4414939: 4 414 93 4 4
+5040197806: 86 372 726 526 217
+20347534480: 22 633 5 20 899
+18580386: 1 1 44 2 2 3 6 51 4 5 6 11
+1701511: 20 2 3 83 13
+310943: 4 26 8 9 3 419 1
+183224: 4 9 380 73 6 1 30 978 8
+73103: 61 296 3 4 68
+31772: 225 3 8 889 2
+1178: 6 96 5 554 43
+1165635: 4 5 6 37 7 50 6 95 6 34
+521557938: 651 1 2 4 74 6 9 2 7 2
+274204: 42 227 259 7 4
+149803482352: 156 8 4 5 9 48 9 5 118 3
+605018: 97 693 9 20 9
+6871840: 41 1 963 1 1 5 6 22 4 29
+8429236: 8 5 9 486 5 788
+26334230: 6 56 44 8 6 72 201 5 9
+354645: 318 136 978 8 837
+222371712: 7 9 4 579 9 26 7 79 3 7 9
+583654: 8 6 9 303 54 1 3 736 6
+2086560: 2 717 6 69 21
+1354419: 90 5 373 681 406 12 3
+1289: 46 40 6 427 339 5 2
+16998959: 5 910 4 934 71 88
+796: 8 7 655 84 1
+518817357: 3 929 658 94 309 9
+1619705: 8 337 2 19 59 2 25 1 3 2
+86126152: 89 3 6 8 4 84 131 2 6 5 3
+279794895: 41 512 1 4 68 2 1 7 5 7 9
+11992270: 802 941 860 48 5 8 3 3
+169258681081728: 4 2 314 670 2 7 4 1 72 8
+31080912061057: 662 939 24 12 21 1 5
+19148: 9 71 651 522 5 85 3 98
+899771738: 7 155 37 829 6
+341754594416: 4 5 85 271 54 7 4 67 3
+340337738: 95 44 1 2 8 33 4 5 9 9 3 6
+289414: 22 657 9 69 88 2
+63360363758: 94 6 68 21 51 4 87 27 8
+171845234: 9 3 7 8 8 61 9 8 5 97 34
+1121977715637: 98 71 75 1 5 43 635
+9144808: 7 87 65 330 71 5 2 4
+1481713: 3 82 63 14 2 31 82
+13345: 2 413 105 691 11 2 22
+74111931179: 92 959 2 895 8 76 420
+581756: 57 1 8 3 758
+12169: 747 543 9 5 554
+238685361: 34 1 75 6 716 711 8 4
+177684: 783 901 594 78
+36733617: 145 319 9 794 1
+85822: 6 2 40 8 5 3 73 94
+4243328964: 185 2 9 84 2 6 42 2 21
+8622560552: 1 82 9 9 5 5 5 59 8 7 5 3
+30722403: 327 77 5 632 75
+249734635: 3 543 87 417 349 3 4
+917934: 9 17 8 96 38
+22698: 6 9 42 9 6
+1813: 54 205 37 6 33 4
+15798: 72 83 2 91 9
+206141781120: 9 954 3 3 7 226 4 80
+1603475788: 5 8 9 8 9 2 457 7 1 6 53 5
+2834847: 288 41 4 3 5 60 377 70
+549488: 1 460 30 73 976
+528868: 1 1 2 674 78 8 20
+779390010: 4 7 5 4 3 6 361 65 91 7 5
+390488: 449 6 3 4 5 16 716 4 38
+173793107: 500 101 4 85 172 5 7
+37492680: 1 97 1 21 9 8 927 960 5
+4224: 301 78 9 9 9 2 412 237
+9492503: 943 293 8 20 2 3 8 7 8 8
+1649632415: 48 4 541 4 8 1 63 702 5
+362304: 8 40 629 6 2
+33100412: 6 353 8 1 78 10 7 6 9 96
+975: 2 719 39 209 6
+23945: 9 393 8 3 707 858 5 5
+1014: 4 6 1 4
+19452231: 84 310 9 83 351
+646720: 90 6 117 39 688 688
+1720919400: 358 5 4 604 391 60 2
+520067: 78 8 4 1 3 33 4 74 455 2
+122: 3 97 1 21 1
+73957341622897: 9 2 7 9 3 369 90 2 862 8
+566255566198: 785 1 1 4 6 6 9 5 77 4 8 6
+49622: 4 3 4 5 50 7 1 23
+139331: 39 42 1 860 2 4 7
+2062460: 7 343 177 8 58
+10823346606: 59 2 287 9 4 915 3 93
+820253: 3 6 89 8 6 44 3 56 2 9 6 5
+420736258837: 71 311 230 31 59 7
+38750: 51 630 23 55 31
+86950: 82 36 41 544 454
+10682880: 2 321 5 64 52
+34112010240: 96 968 8 57 805 1
+129014: 5 14 251
+25968364: 3 2 9 2 1 71 1 3 5 7 2 761
+258162800: 869 4 3 7 847 673 20
+30630: 335 46 8 2 12 1 9
+226110: 223 2 933 96 81
+634800: 5 2 9 175 269 2 690
+311: 9 11 7 2 169
+62617: 16 98 510 5 8 6 227 2
+182964015: 899 310 59 513 5
+1100758: 6 4 504 91 3 19
+3942347909: 7 5 2 547 65 6 8 33 6 2 3
+280898183289: 86 5 4 420 31 8 88 8 89
+9983283: 501 496 5 8 2 80
+10747859: 38 91 111 7 21 4 312
+938: 536 3 5 20 65 309
+22361: 8 211 4 58
+399654: 77 863 93 65 6
+108209773: 51 26 68 5 3 3 70 4 693
+305118: 41 397 68 9 67
+3424261494: 1 8 19 4 261 492
+43544170: 8 68 8 5 1 929 84 81 1
+611980072: 572 123 29 5 9 19 88
+13381485: 34 2 1 623 3 65
+2312486114: 362 117 769 71 68
+5316350: 2 261 9 63 51
+6018738: 1 3 90 6 4 7 64 1 7 7 2 6
+188: 14 7 67 8 92
+19913715: 81 4 241 4 5 255
+2271848065: 609 8 3 5 4 92 65
+11206: 91 396 23 4 1
+424434: 630 84 6 8 2 8 6 6 1 934
+40642395: 4 12 5 62 88 535 93
+4875: 62 7 2 16 56
+15714: 4 2 48 230 5 72 5 4
+183787176: 822 52 37 8 537
+259167840: 5 7 8 6 903 51 816 8 41
+637776878: 43 16 927 870 6
+3998250: 11 323 3 3 375
+14273886977: 199 2 292 566 25 217
+188: 9 4 2
+464170402: 928 331 9 8 50
+36738891: 77 477 9 8 83 8
+536328: 73 266 446 27
+1932: 4 163 90 65 6
+4471181453430: 9 70 6 6 5 2 59 853 9 3
+1010888: 39 72 36 8 3
+7283692: 867 84 8 91
+41750873: 3 25 36 653 8 9 8 9 17
+3506152: 4 688 637 46 6 2
+617650487: 38 4 1 1 11 4 402
+1530026: 6 78 38 7 86
+72172165: 344 6 22 8 8 645 538 3
+10275506472: 30 1 3 2 69 341 5 2 1 1 1
+14944995: 5 2 8 64 9 3 15 767
+8809031: 53 11 74 6 310 60 7 4
+386665: 4 32 9 49 85
+3433815: 861 5 4 1 991
+38882: 547 7 1 591
+206319558: 5 86 2 6 55 916 195 55
+35848233: 714 54 4 2 875 909
+278: 32 4 88 60 2
+4529: 624 1 23 7
+3056508000703: 7 351 40 50 622 69 3 9
+743851143: 103 7 4 8 51 4 7 2 3 3 7 4
+569: 7 57 80 1 90
+2477347208185: 2 478 53 18 541 8 187
+2211258037: 5 72 74 978 35 37
+131240: 330 76 323 97 5
+303451: 260 43 4 42 9
+1375045632: 6 7 9 6 7 37 6 6 6 8 96 3
+900: 3 9 81 7 9
+9017376: 2 81 793 8 1 4
+31854: 1 83 146 8 806 7 4 6 3
+8899350286: 5 6 3 711 530 894 463
+12087785589: 1 995 3 9 3 4 5 9 3 8 589
+3433209: 572 201 6
+711980: 51 5 68 411 970
+110044: 276 6 5 20 820 44
+34500428: 8 955 6 77 8 9 5 1 495
+10437: 7 6 8 6 9 8 96 54 2 2 7
+9526930631: 2 3 81 6 9 4 2 12 53 7 4
+5831: 7 8 3 13 289 7 2 866 5 1
+5841776: 8 104 1 15 8 8 3 3 7 184
+2012810: 3 7 8 6 3 5 245 191 625
+42840: 2 686 77 2 28
+16834553255: 417 724 44 641 403
+3578: 71 7 5 7 848
+214553838357: 861 655 7 249 356
+112137: 10 72 1 664 50 26 1 3 9
+86111527: 2 152 772 15 7 4 4
+1438: 6 3 7 92 5 6 93 2 9 142 9
+5963942: 6 33 556 55 5 842
+1809: 6 1 69 1 532 313 888
+1346526720: 85 9 8 8 725 7 184 704
+23746365: 15 685 72 9 255
+44157722065: 4 4 513 6 4 9 45 49 4 64
+19388160: 9 6 399 26 272 6 9 3
+31874414: 6 622 462 1 8 950 9 4 1
+155254467409: 7 34 38 3 9 4 8 7 6 7 409
+7488740: 26 8 6 6 740
+737225700: 50 65 504 276 2 6 8 75
+186743803: 14 4 674 3 126 676
+31374: 60 6 36 14 3 504 9 18
+858491: 5 422 335 6 221
+1404417: 844 8 26 8 1
+1824766: 320 60 7 686 6
+25867127169: 106 75 78 473 81 299
+6147278: 1 99 584 9 2 79
+65989578: 857 77 56 1 8
+1351: 24 605 710 12
+475680012600: 5 985 6 4 4 8 75 63 4 50
+1479825: 2 9 5 383 763 6 7 38 1
+3870766: 32 31 1 5 84 6 4 1 6 46
+222359: 80 25 7 42 78 5
+8037677: 46 60 52 28 2 536 5 16
+18009543: 178 45 1 8 8 20 3 72 40
+112178952: 3 24 824 7 9 7 566 3 8 9
+1923: 15 58 358 3 6
+6435890: 8 63 5 9 7 35 66 4 83
+2863025: 4 6 8 2 2 6 3 8 367 5 55
+40411: 9 9 36 22 4 243 11
+54585: 4 2 6 6 9 2 1 1 446 9 5 9
+267657: 9 9 8 6 3 34 82 9
+2796417: 5 20 7 5 77 117 93
+6722720550: 9 8 699 565 2 7 629 6 5
+21376691: 625 9 4 461 931
+129121866640: 5 86 401 5 2 187 34 4 3
+82: 4 2 74
+160724791752: 933 2 188 534 32 861
+1397630: 2 226 945 1 598 32
+104983: 721 8 9 8 2 7
+633707226: 2 8 99 1 4 3 26 346 22 6
+384219200: 6 9 4 86 4 63 3 857 8 41
+23133242293: 6 5 8 8 43 105 1 47 3 9
+176306130: 92 3 33 618 91
+27635920726: 112 6 5 1 5 9 1 520 7 2 6
+50564: 7 491 11 65 688
+1156: 11 48 4 7 1
+15416: 140 50 524 756 86
+161994: 7 8 3 5 8 1 4 9 31 8 67 6
+39386948: 7 66 89 783 94 8
+24255: 35 9 77
+120187745: 70 1 168 70 2 2 5 73 34
+47705: 4 7 8 836 3 9 7 22 3 8 3 1
+6090760: 3 57 42 26 845
+13881: 22 877 256 3 4 9 8 4
+46461312: 89 14 55 62 6 4 24
+6250228269: 18 8 68 121 432
+6383118: 1 7 9 612 726 9 14
+38781608135: 9 7 34 14 2 88 14 4 452
+92288: 737 29 882 7 8
+112928510456: 75 4 8 5 39 1 4 9 48 56
+3331441: 7 671 4 4 971 69 105 1
+7458037: 85 552 5 234 513 2 4
+1873: 8 8 3 699 871 42
+4144: 33 93 13 87 975
+93888361566: 78 3 8 7 4 995 4 4 1 5 64
+1625400: 207 8 9 4 3 9 3 432 15 7
+8548173: 85 4 8 171 2
+523899888: 41 678 66 7 138 8
+826762114: 4 5 205 5 9 3 898 1 456
+26131808416: 628 4 6 5 8 7 999 8 59 6
+579359: 8 723 80 2 877
+659088: 4 8 580 20 115 3 66 92
+91260: 2 6 9 61 540
+26960754744: 700 81 27 161 3 984
+38962: 38 35 944 8 730
+2477734: 3 4 4 748 24 922 3 8 4 9
+70122: 3 8 5 6 3 1 5 5 502 2 9 31
+17784: 18 96 43 50 24 2 6 38
+22593450: 6 60 76 26 825
+678: 2 2 8 4 278 384
+43998707: 283 69 6 797 373
+94836: 4 418 586 6 7
+1820590087408: 200 4 768 400 1 8 926
+688680: 978 45 7 490 15 15 6
+106631: 20 8 858 17 8 8
+5404060: 8 21 6 10 6 3 5 112 4 8 5
+1599066: 65 41 1 1 6
+2023517: 4 1 45 4 9 8 891 19 37
+939209242: 65 3 708 59 68 42
+174049: 6 2 6 1 4 634 8 9 2 37 6
+15021: 34 7 301 6 42 395 4 1 6
+14648089: 68 131 2 3 548 49
+6034061: 697 7 174 78 1 84 14 5
+11010: 9 3 12 6 5 9
+3221245: 2 1 22 12 4 5
+5573841: 7 3 5 4 401 2 7 5 8 33 8 9
+2209501: 8 9 934 7 5 139 6 5 780
+20210540773: 6 41 47 820 773
+84048: 2 420 16 22 9
+2271918080: 7 5 8 9 6 4 86 9 3 720 8 8
+42887611650: 2 944 7 1 58 23 5 390
+586845: 724 5 81
+9826292880: 7 360 907 984 30
+28679847: 7 3 3 185 3 9 44 1 1 2 1 7
+10776864: 23 6 63 66 6 812
+43111: 61 1 684 5 698
+19543780: 5 6 7 386 314 1 2 4 4 5 4
+8862: 97 5 223 7 4 1 6 5 883
+100858024: 2 110 9 580 23
+8795: 79 5 22 8 1 97
+11754330: 3 9 827 571 6 509 502
+8670: 5 5 6 69 3 34
+2460074832: 98 74 989 7 49 628
+4628655366749: 336 159 12 722 67 49
+818733616627: 8 11 4 3 73 354 7 6 630
+68629528: 404 2 8 12 18 22 7 4 8
+1893617: 35 75 1 5 80 9 9 6 2
+38138762: 5 499 40 720 7 835 9
+4166: 7 1 85 7 1
+9060263911: 7 3 83 7 6 6 950 9 9 9 4
+3189914: 474 41 9 7 3 22 4 4 91
+13525161849: 229 24 59 184 9
+604493820: 8 699 804 76 945
+1707917817904: 82 635 66 518 328
+4977357580: 96 50 3 9 287 5 68
+9076536: 621 8 21 87
+69769617: 697 6 9 619
+7004: 4 1 3 863 4 2 4
+1494087678076: 9 3 498 3 5 50 3 5 6 5 7 7
+50653588160: 47 590 4 2 733 94 623
+23676384741: 723 2 64 3 58 5 84 744
+43893055008: 23 729 4 888 737
+5274417095: 3 55 829 949 9 66 2 7 8
+2215: 6 838 45 532 782 12
+214112: 5 9 3 361 39
+12804634104: 3 40 5 5 876 81 74 316
+124884: 8 5 465 7 52 70 4 4 9 1 1
+2593468329: 9 3 15 6 6 111 6 2 2 6 5 2
+129276: 9 26 9 532
+1692128359129: 6 7 685 134 2 5 7 5 6 2 9
+579105175: 578 4 7 37 117 83 7 25
+7316537: 2 4 68 7 2 874 3 78 159
+3015: 9 38 9 1 7 281 365 3
+99097600: 6 3 7 7 9 38 64 70 280
+1042: 559 462 7 5 9
+13454: 8 3 926 957 7 36 69
+40525369: 82 641 771 1 67
+207940: 7 8 554 1 89 4 79 12
+482632192: 61 412 51 6 92 193
+499810500: 903 30 9 82 25
+80462: 8 76 841 55 765 2
+43767147: 4 376 714 9
+3457: 253 13 161 7
+760: 69 6 8 86 73 1
+531079911: 64 85 387 4 921
+588061416: 4 6 7 4 7 9 5 3 45 9 4
+27216918: 72 3 6 36 7 75 143
+385666677: 881 5 76 18 8 8 8 53
+130004820: 92 303 64 517 9
+49967040: 164 1 2 42 116 96 73
+3408: 62 164 7 193 8
+595446: 8 93 27 8 30
+1022124: 8 691 6 5 1 6 27 3 3 66
+499993425: 7 5 101 660 87 347 2 5
+88596602: 7 434 4 9 809 324 4 98
+420: 5 87 3 1 16 66 1 58 4
+48663888: 4 1 6 329 8 5 73 1 2 7 8 3
+265139504194: 1 39 87 4 659 8 81 9 91
+3260115: 383 6 59 9 93
+1490656: 2 7 7 2 82 164 766 2 7 6
+57342664: 907 3 2 63 62
+573144148101: 954 80 775 2 9 969
+15462181: 163 85 558 2
+920: 2 7 8 3 39 1 8
+665550: 178 3 805 9 75
+30508: 64 462 40 896 3
+481630: 48 1 32 5 302
+245688473: 9 473 646 8 8 469 58 9
+3760: 5 3 4 8 94
+34608191219: 11 846 1 42 93 952 35
+2176096: 74 39 12 4 400 1 9 14 4
+19441660: 997 195 3 13 10
+3560743358: 9 39 80 6 5 6 79 9 6 318
+33572702: 37 3 360 8 7 2 51 3 35 2
+374610584590: 81 5 1 326 7 4 6 6 331 9
+29793907695: 3 69 508 9 7 587 62 6 5
+2407: 1 1 4 1 79 518 741 828
+50857980: 47 486 67 3 740
+435912: 60 896 2 26 443
+61272: 4 6 835 43 69
+10516068: 65 4 2 813 3 3 9 162 2 3
+2122: 6 342 70
+131834: 425 4 68 500 5 58
+321214243: 237 92 45 57 3 51 4 3
+2971: 40 1 97 1 14 986 53
+116: 1 4 7 10 6
+432138: 52 9 3 8 3 63 97 3
+1866564: 3 72 4 9 710 46 5 3 3 36
+719413: 442 6 61 91 91 2 5 77
+2123870: 3 151 674 5 88
+7641: 37 811 9 9
+7462128862: 199 6 5 455 8 16 865
+3158238: 25 96 758 154 85
+30721860750: 6 512 185 63 37 7 48
+408: 5 15 5 5 8
+13552704: 8 2 5 982 6 7 5 2 2 8 46
+720972: 4 57 3 734 9 6 3 5 4 9 84
+3827862: 5 36 7 5 9 548 7 61 661
+94229670: 53 993 986 9 88 7 45
+94786045: 94 34 44 60 42
+1273534211: 453 7 619 247 2 213
+92180160893: 4 5 14 1 8 3 7 908 8 89 3
+1335205: 111 6 7 9 20 6
+179104519445: 878 669 8 605 63 5
+201325: 704 453 29 6 7
+4134394384: 6 89 6 394 381
+5636785: 97 95 2 368 3 4 7 4 3 1 7
+151650: 6 153 4 8 655 6
+5367: 731 8 6 6 927
+35432: 43 4 9 631 96
+258100658: 6 19 809 89 6 8 3 4 5 3 9
+2412169452: 473 413 49 3 84
+1143: 7 862 95 89 90
+10295096979: 3 499 924 7 54 301 68
+19843: 74 268 6 2 3
+85363464588: 2 34 304 2 20 47 12 23
+81113: 721 83 7 1 3
+45752: 7 7 295 7 19
+1433638: 3 452 7 9 50 57 320 11
+5595044: 2 220 12 3 21 5 8
+14283588: 5 9 26 8 241
+351804155: 983 4 502 19 5 8 71 4
+146764905: 7 182 6 315 7 13 7 4 77
+455788734: 49 65 18 34 51
+44513169: 25 89 6 581 2 7
+82172473: 1 362 73 9 3 9 9 31 25
+121716: 1 6 42 207 2
+61611946: 5 17 3 663 6 8 1 22 660
+445977: 1 48 1 91 76 1
+1295228700: 58 99 6 149 3 7 75 3 79
+143627: 6 98 738 2 7
+2659746: 4 9 9 6 84 146 2 6 3 6 6
+6125686: 76 13 1 62 86
+48086976: 53 8 41 346 487 168 8
+4043589: 8 6 9 347 5 3 6 8 3 5 4 5

advent_of_code/2024/7/src/main.rs

@@ -0,0 +1,127 @@
+use nom::{
+    bytes::complete::tag,
+    character::complete::{i64, multispace1},
+    multi::separated_list1,
+    sequence::separated_pair,
+    IResult,
+};
+
+fn parse(input: &str) -> IResult<&str, Vec<(i64, Vec<i64>)>> {
+    let (input, result) = separated_list1(
+        multispace1,
+        separated_pair(i64, tag(": "), separated_list1(tag(" "), i64)),
+    )(input)?;
+
+    Ok((input, result))
+}
+
+fn check(original_target: i64, line: &[i64]) -> Option<i64> {
+    let mut target = original_target;
+
+    for (i, number) in line.iter().enumerate().rev() {
+        if i == 0 && target == *number {
+            return Some(original_target);
+        }
+
+        if target % number == 0 {
+            if check(target - number, &line[..i]).is_some() {
+                return Some(original_target);
+            }
+
+            target /= number;
+        } else {
+            target -= number;
+        }
+    }
+
+    None
+}
+
+fn solve_1(input: &str) -> i64 {
+    let (_, lines) = parse(input).unwrap();
+
+    lines.into_iter().fold(0, |result, line| {
+        check(line.0, &line.1[..]).unwrap_or_default() + result
+    })
+}
+
+fn check_2(original_target: i64, numbers: &[i64]) -> Option<i64> {
+    if let Some((i, number)) = numbers.iter().enumerate().rev().next() {
+        if i == 0 && original_target == *number {
+            return Some(original_target);
+        }
+
+        if original_target % number == 0 {
+            if check_2(original_target / number, &numbers[..i]).is_some() {
+                return Some(original_target);
+            }
+        }
+        if original_target - number >= 0 {
+            if check_2(original_target - number, &numbers[..i]).is_some() {
+                return Some(original_target);
+            }
+        }
+        if let Some(head) = disconcat(original_target, *number) {
+            if check_2(head, &numbers[..i]).is_some() {
+                return Some(original_target);
+            }
+        }
+    }
+
+    None
+}
+
+fn disconcat(whole: i64, tail: i64) -> Option<i64> {
+    if tail > whole {
+        return None;
+    }
+
+    let mut whole_s = whole.to_string();
+    let tail_s = tail.to_string();
+
+    let whole_split = whole_s.split_off(whole_s.len() - tail_s.len());
+
+    if whole_split == tail_s {
+        Some(whole_s.parse().unwrap_or_default())
+    } else {
+        None
+    }
+}
+
+fn solve_2(input: &str) -> i64 {
+    let (_, lines) = parse(input).unwrap();
+
+    lines.into_iter().fold(0, |result, (target, numbers)| {
+        check_2(target, &numbers[..]).unwrap_or_default() + result
+    })
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The total calibration result is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The new total calibration result is {}", result_2);
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 3749);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 11387);
+    }
+}

advent_of_code/2024/7/test.txt

@@ -0,0 +1,9 @@
+190: 10 19
+3267: 81 40 27
+83: 17 5
+156: 15 6
+7290: 6 8 6 15
+161011: 16 10 13
+192: 17 8 14
+21037: 9 7 18 13
+292: 11 6 16 20

advent_of_code/2024/8/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "7.1.3"

advent_of_code/2024/8/input.txt

@@ -0,0 +1,50 @@
+..........1.............TE........................
+....................................R.............
+..................................................
+.......................j.....Q....................
+...................A................8.............
+...........................s.......9...........k..
+q.E..............6...............1R.w.........k...
+..6...E..............1.........R...............t..
+.....r.Q......6........Re..T..............9.......
+.............................T........9...........
+...............................................wv.
+.P............A..................8.v....s.k.......
+.q..................A......k.........8............
+..........o.....1.....W..H............8.......w...
+..Q........P.........O.........e...N.W............
+P................z.........o.............N.......w
+..............o.....p..........Z.s..........N.....
+.....O.x......K.....................v..aN.........
+..O...............U.....H.......t.................
+.E.......q...6.....i..............................
+..............z..........o...i...........aW.......
+....O........r.............e.....Wt...............
+...............U.7i........H......h........t......
+......Q.......n..2...I...A....i.p.................
+...........2...9n.................s........j......
+..q................Ur..........p..................
+.............n.................K..................
+.....S....z.........I.....H.............e.j.......
+..................7..prD..K...d...................
+S.........V.....7....K............................
+......................................0...........
+..................................................
+..................2..........I....j.Z.............
+....................X.............J..Z....a.......
+........SX............................x......0J...
+................U....n........x...............0...
+.........S......X................x....a...........
+...5.......X.......................02.............
+...............V.........................d...J....
+.............................u.......4............
+.....5...........................u.4..............
+....5.............................................
+......V................................3..........
+......D..........................................d
+....D.................................4...........
+.....h....................................d7......
+..............................P...................
+.........D......h........3................u...4...
+.............h..5.....3...........u.....I.........
+..........3......V.............................J..

advent_of_code/2024/8/src/main.rs

@@ -0,0 +1,131 @@
+use std::collections::{HashMap, HashSet};
+
+use nom::{
+    character::complete::{multispace1, not_line_ending},
+    error::VerboseError,
+    multi::separated_list1,
+};
+
+fn parse(input: &str) -> ((i32, i32), HashMap<char, Vec<(i32, i32)>>) {
+    let (input, parse_result) =
+        separated_list1(multispace1::<&str, VerboseError<_>>, not_line_ending)(input).unwrap();
+
+    if !input.is_empty() {
+        panic!("Parsing yields additional input");
+    }
+
+    let mut result: HashMap<char, Vec<(i32, i32)>> = HashMap::new();
+    let dim = (parse_result[0].len() as i32, parse_result.len() as i32 - 1);
+
+    for (y, line) in parse_result.into_iter().enumerate() {
+        for (x, c) in line.chars().enumerate() {
+            if c != '.' && c != '\n' {
+                match result.get_mut(&c) {
+                    None => {
+                        result.insert(c, vec![(x as i32, y as i32)]);
+                    }
+                    Some(v) => v.push((x as i32, y as i32)),
+                }
+            }
+        }
+    }
+
+    (dim, result)
+}
+
+fn check_in_rectangle(point: (i32, i32), h: i32, w: i32) -> bool {
+    point.0 >= 0 && point.1 >= 0 && point.0 < w && point.1 < h
+}
+
+fn solve_1(input: &str) -> usize {
+    let (dim, antennae) = parse(input);
+    let dim = (dim.0 as i32, dim.1 as i32);
+    let mut result: HashSet<(i32, i32)> = HashSet::new();
+
+    for (_, v) in antennae.into_iter() {
+        let l = v.len();
+        for i in 0..l {
+            let a = v[i];
+            for j in i + 1..l {
+                let b = v[j];
+
+                let dif = (a.0 - b.0, a.1 - b.1);
+
+                if check_in_rectangle((a.0 + dif.0, a.1 + dif.1), dim.1, dim.0) {
+                    result.insert((a.0 + dif.0, a.1 + dif.1));
+                }
+                if check_in_rectangle((b.0 - dif.0, b.1 - dif.1), dim.1, dim.0) {
+                    result.insert((b.0 - dif.0, b.1 - dif.1));
+                }
+            }
+        }
+    }
+
+    result.len()
+}
+
+fn solve_2(input: &str) -> usize {
+    let (dim, antennae) = parse(input);
+    let dim = (dim.0 as i32, dim.1 as i32);
+
+    let mut result: HashSet<(i32, i32)> = HashSet::new();
+
+    for (_, v) in antennae.into_iter() {
+        let l = v.len();
+        for i in 0..l {
+            for j in i + 1..l {
+                let mut a = v[i];
+                let mut b = v[j];
+
+                let dif = (a.0 - b.0, a.1 - b.1);
+
+                while check_in_rectangle(a, dim.1, dim.0) {
+                    result.insert(a);
+                    a = (a.0 + dif.0, a.1 + dif.1);
+                }
+                while check_in_rectangle(b, dim.1, dim.0) {
+                    result.insert(b);
+                    b = (b.0 - dif.0, b.1 - dif.1);
+                }
+            }
+        }
+    }
+
+    result.len()
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!(
+        "The number of unique locations with an antinode are {}",
+        result_1
+    );
+
+    let result_2 = solve_2(input);
+    println!(
+        "The new number of unique locations with an antinode are {}",
+        result_2
+    );
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 14);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 34);
+    }
+}

advent_of_code/2024/8/test.txt

@@ -0,0 +1,12 @@
+............
+........0...
+.....0......
+.......0....
+....0.......
+......A.....
+............
+............
+........A...
+.........A..
+............
+............

advent_of_code/2024/9/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

advent_of_code/2024/9/src/main.rs

@@ -0,0 +1,155 @@
+use std::collections::HashSet;
+
+#[derive(Debug, Clone)]
+enum File {
+    Empty,
+    File(u64),
+}
+
+#[derive(Debug, Clone)]
+enum Fs {
+    Empty(u64),
+    File(u64, u64),
+}
+
+fn parse(input: &str) -> Vec<u32> {
+    input.chars().filter_map(|c| c.to_digit(10)).collect()
+}
+
+fn solve_1(input: &str) -> u64 {
+    let original_filesystem: Vec<_> = parse(input).into_iter().map(|f| f as u64).collect();
+
+    let mut filesystem = vec![];
+    for (i, d) in original_filesystem.into_iter().enumerate() {
+        if i % 2 == 0 {
+            for _ in 0..d {
+                filesystem.push(File::File(i as u64 / 2));
+            }
+        } else {
+            for _ in 0..d {
+                filesystem.push(File::Empty);
+            }
+        }
+    }
+
+    for ei in 0..filesystem.len() {
+        if let Some(File::Empty) = filesystem.get(ei) {
+            while let Some(File::Empty) = filesystem.last() {
+                filesystem.pop();
+            }
+
+            if filesystem.len() > ei {
+                if let Some(File::File(fid)) = filesystem.pop() {
+                    filesystem[ei] = File::File(fid);
+                }
+            } else {
+                break;
+            }
+        }
+    }
+
+    filesystem.into_iter().enumerate().fold(0, |s, (i, f)| {
+        s + i as u64
+            * match f {
+                File::Empty => 0,
+                File::File(fid) => fid,
+            }
+    })
+}
+
+fn solve_2(input: &str) -> u64 {
+    let original_filesystem: Vec<_> = parse(input).into_iter().map(|f| f as u64).collect();
+
+    let mut filesystem = vec![];
+    let mut c = 0;
+    for (i, d) in original_filesystem.into_iter().enumerate() {
+        if i % 2 == 0 {
+            assert_ne!(0, d);
+
+            filesystem.push(Fs::File(i as u64 / 2, d));
+            c += 1;
+        } else if d != 0 {
+            filesystem.push(Fs::Empty(d));
+        }
+    }
+
+    for fid in (0..=c).rev() {
+        for i in (0..filesystem.len()).rev() {
+            if let Fs::File(file_id, wf) = filesystem[i] {
+                if file_id == fid {
+                    for j in 0..=i {
+                        if let Fs::Empty(we) = filesystem[j] {
+                            if we >= wf {
+                                filesystem[j] = Fs::File(fid, wf);
+
+                                if i > 0 {
+                                    if let Fs::Empty(el) = filesystem[i - 1] {
+                                        if let Some(Fs::Empty(er)) = filesystem.get(i + 1) {
+                                            filesystem[i - 1] = Fs::Empty(el + wf + er);
+                                            filesystem.remove(i + 1);
+                                            filesystem.remove(i);
+                                        } else {
+                                            filesystem[i - 1] = Fs::Empty(el + wf);
+                                            filesystem.remove(i);
+                                        }
+                                    } else if let Some(Fs::Empty(er)) = filesystem.get(i + 1) {
+                                        filesystem[i] = Fs::Empty(wf + er);
+                                        filesystem.remove(i + 1);
+                                    } else {
+                                        filesystem[i] = Fs::Empty(wf);
+                                    }
+                                }
+
+                                if we > wf {
+                                    filesystem.insert(j + 1, Fs::Empty(we - wf));
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    filesystem
+        .into_iter()
+        .fold((0, 0), |(s, i), f| match f {
+            Fs::Empty(w) => (s, i + w as usize),
+            Fs::File(fid, w) => (
+                s + (i..(i + w as usize)).map(|it| it as u64 * fid).sum::<u64>(),
+                i + w as usize,
+            ),
+        })
+        .0
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("The checksum is {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("The new checksum is {}", result_2);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 1928);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 2858);
+    }
+}

advent_of_code/2024/9/test.txt

@@ -0,0 +1 @@
+2333133121414131402

advent_of_code/2025/1/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "main"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

advent_of_code/2025/1/src/main.rs

@@ -0,0 +1,113 @@
+#[derive(Debug)]
+enum Dir {
+    Left,
+    Right,
+}
+
+fn parse_input(input: &str) -> Vec<(Dir, i32)> {
+    input
+        .lines()
+        .into_iter()
+        .map(|line| {
+            let dir = match line.chars().next().unwrap() {
+                'L' => Dir::Left,
+                'R' => Dir::Right,
+                _ => unreachable!(),
+            };
+
+            (dir, line[1..].parse::<i32>().unwrap())
+        })
+        .collect()
+}
+
+fn solve_1(input: &str) -> i32 {
+    let rots = parse_input(input);
+
+    rots.iter()
+        .fold((0, 50), |(zeroes, dial), x| {
+            let new_dial = (dial
+                + match x.0 {
+                    Dir::Left => -1,
+                    Dir::Right => 1,
+                } * x.1)
+                % 100;
+            (if new_dial == 0 { zeroes + 1 } else { zeroes }, new_dial)
+        })
+        .0
+}
+
+fn solve_2(input: &str) -> i32 {
+    let rots = parse_input(input);
+
+    rots.iter()
+        .fold((0, 50), |(zeroes, dial), x| {
+            let full_rots = x.1 / 100;
+            let remainder = x.1 % 100;
+
+            let new_dial = match x.0 {
+                Dir::Left => {
+                    if remainder <= dial {
+                        dial - remainder
+                    } else {
+                        100 - (remainder - dial)
+                    }
+                }
+                Dir::Right => {
+                    if remainder + dial >= 100 {
+                        remainder + dial - 100
+                    } else {
+                        remainder + dial
+                    }
+                }
+            };
+
+            let carry = match x.0 {
+                Dir::Left => {
+                    if remainder >= dial && dial != 0 {
+                        1
+                    } else {
+                        0
+                    }
+                }
+                Dir::Right => {
+                    if remainder + dial >= 100 {
+                        1
+                    } else {
+                        0
+                    }
+                }
+            };
+
+            (zeroes + full_rots + carry, new_dial)
+        })
+        .0
+}
+
+fn main() {
+    println!("Hello, this is Patrick!");
+
+    let input = include_str!("../input.txt");
+
+    let result_1 = solve_1(input);
+    println!("Number of zeroes: {}", result_1);
+
+    let result_2 = solve_2(input);
+    println!("Number of zero clicks: {}", result_2);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_1(test_input), 3);
+    }
+
+    #[test]
+    fn test_2() {
+        let test_input = include_str!("../test.txt");
+        assert_eq!(solve_2(test_input), 6);
+    }
+}

advent_of_code/2025/1/test.txt

@@ -0,0 +1,10 @@
+L68
+L30
+R48
+L5
+R60
+L55
+L1
+L99
+R14
+L82