Add a bunch of 2020 days

Why did I do this?

Author: Lexicality

src/aoc.rs

@@ -10,6 +10,7 @@
 pub mod y2015;
 pub mod y2018;
 pub mod y2019;
+pub mod y2020;
 pub mod y2021;
 pub mod y2022;
 pub mod y2023;

src/aoc/y2020/day00.rs

@@ -0,0 +1,23 @@
+// Copyright (c) 2025 Lexi Robinson
+//
+// Licensed under the EUPL, Version 1.2
+//
+// You may not use this work except in compliance with the Licence.
+// You should have received a copy of the Licence along with this work. If not, see:
+// <https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12>.
+// See the Licence for the specific language governing permissions and limitations under the Licence.
+
+pub fn part_1(data: crate::DataIn) -> crate::AoCResult<String> {
+    let ret = data.count();
+    Ok(ret.to_string())
+}
+
+inventory::submit!(crate::AoCDay {
+    year: "2020",
+    day: "0",
+    part_1: crate::AoCPart {
+        main: part_1,
+        example: part_1
+    },
+    part_2: None
+});

src/aoc/y2020/day01.rs

@@ -0,0 +1,69 @@
+// Copyright (c) 2025 Lexi Robinson
+//
+// Licensed under the EUPL, Version 1.2
+//
+// You may not use this work except in compliance with the Licence.
+// You should have received a copy of the Licence along with this work. If not, see:
+// <https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12>.
+// See the Licence for the specific language governing permissions and limitations under the Licence.
+
+use std::collections::HashSet;
+
+use itertools::Itertools;
+
+use crate::AoCError;
+
+pub fn part_1(data: crate::DataIn) -> crate::AoCResult<String> {
+    let nums: Vec<u64> = data.map(|line| line.parse()).try_collect()?;
+    let num_set: HashSet<_> = nums.iter().copied().collect();
+
+    let ret = nums
+        .into_iter()
+        .find_map(|num| {
+            let target = 2020 - num;
+            if num_set.contains(&target) {
+                Some(num * target)
+            } else {
+                None
+            }
+        })
+        .ok_or(AoCError::new("No matching numbers found"))?;
+    Ok(ret.to_string())
+}
+
+pub fn part_2(data: crate::DataIn) -> crate::AoCResult<String> {
+    let nums: Vec<u64> = data.map(|line| line.parse()).try_collect()?;
+    let num_set: HashSet<_> = nums.iter().copied().collect();
+
+    let ret = nums
+        .iter()
+        .enumerate()
+        .find_map(|(i, num1)| {
+            nums.iter()
+                .skip(i + 1)
+                .filter(|num2| **num2 + *num1 < 2020)
+                .find_map(|num2| {
+                    let target = 2020 - num1 - num2;
+                    if num_set.contains(&target) {
+                        Some(num1 * num2 * target)
+                    } else {
+                        None
+                    }
+                })
+        })
+        .ok_or(AoCError::new("No matching numbers found"))?;
+    Ok(ret.to_string())
+}
+
+inventory::submit!(crate::AoCDay {
+    year: "2020",
+    day: "1",
+    part_1: crate::AoCPart {
+        main: part_1,
+        example: part_1
+    },
+    part_2: Some(crate::AoCPart {
+        main: part_2,
+        example: part_2
+    })
+});

src/aoc/y2020/day02.rs

@@ -0,0 +1,79 @@
+// Copyright (c) 2025 Lexi Robinson
+//
+// Licensed under the EUPL, Version 1.2
+//
+// You may not use this work except in compliance with the Licence.
+// You should have received a copy of the Licence along with this work. If not, see:
+// <https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12>.
+// See the Licence for the specific language governing permissions and limitations under the Licence.
+use std::str::FromStr;
+
+use itertools::Itertools;
+use lazy_static::lazy_static;
+use regex::Regex;
+
+struct Policy {
+    a: usize,
+    b: usize,
+    letter: char,
+    password: String,
+}
+
+impl FromStr for Policy {
+    type Err = crate::AoCError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        lazy_static! {
+            static ref RE: Regex = Regex::new(r"^(\d+).(\d+) (.): (.+)$").unwrap();
+        }
+
+        let matches = RE
+            .captures(s)
+            .ok_or_else(Self::Err::new_from_regex(s, &RE))?;
+
+        Ok(Self {
+            a: matches[1].parse()?,
+            b: matches[2].parse()?,
+            letter: matches[3].chars().next().unwrap(),
+            password: matches[4].to_owned(),
+        })
+    }
+}
+
+impl Policy {
+    fn part_1(&self) -> bool {
+        let range = self.a..=self.b;
+        range.contains(&(self.password.chars().filter(|c| *c == self.letter).count()))
+    }
+
+    fn part_2(&self) -> bool {
+        let chars = self.password.chars().collect_vec();
+        chars.get(self.a - 1).is_some_and(|c| *c == self.letter)
+            ^ chars.get(self.b - 1).is_some_and(|c| *c == self.letter)
+    }
+}
+
+pub fn part_1(data: crate::DataIn) -> crate::AoCResult<String> {
+    let policies: Vec<Policy> = data.map(|line| line.parse()).try_collect()?;
+    let ret = policies.into_iter().filter(|p| p.part_1()).count();
+    Ok(ret.to_string())
+}
+
+pub fn part_2(data: crate::DataIn) -> crate::AoCResult<String> {
+    let policies: Vec<Policy> = data.map(|line| line.parse()).try_collect()?;
+    let ret = policies.into_iter().filter(|p| p.part_2()).count();
+    Ok(ret.to_string())
+}
+
+inventory::submit!(crate::AoCDay {
+    year: "2020",
+    day: "2",
+    part_1: crate::AoCPart {
+        main: part_1,
+        example: part_1
+    },
+    part_2: Some(crate::AoCPart {
+        main: part_2,
+        example: part_2
+    }),
+});

src/aoc/y2020/day03.rs

@@ -0,0 +1,95 @@
+// Copyright (c) 2025 Lexi Robinson
+//
+// Licensed under the EUPL, Version 1.2
+//
+// You may not use this work except in compliance with the Licence.
+// You should have received a copy of the Licence along with this work. If not, see:
+// <https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12>.
+// See the Licence for the specific language governing permissions and limitations under the Licence.
+
+use std::fmt::Display;
+
+use crate::{CharGrid, CommonGrid, Coord2D, Grid, symbols};
+
+enum GridState {
+    Snow,
+    Tree,
+}
+
+impl TryFrom<char> for GridState {
+    type Error = crate::AoCError;
+
+    fn try_from(value: char) -> Result<Self, Self::Error> {
+        Ok(match value {
+            '.' => Self::Snow,
+            '#' => Self::Tree,
+            _ => return Err(Self::Error::new_from_char(value)),
+        })
+    }
+}
+
+impl Display for GridState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Snow => symbols::VOID,
+            Self::Tree => symbols::TREE,
+        }
+        .fmt(f)
+    }
+}
+
+fn toboggonate(grid: &Grid<GridState>, dir: Coord2D) -> usize {
+    let mut pos = Coord2D { x: 0, y: 0 };
+    let mut trees = 0;
+    loop {
+        match grid.get(&pos) {
+            Some(GridState::Tree) => trees += 1,
+            Some(_) => (),
+            None => {
+                log::debug!("Fell of the end of the map at {pos}");
+                break;
+            }
+        }
+        pos += dir;
+        pos.x %= grid.width as i32;
+    }
+
+    trees
+}
+
+pub fn part_1(data: crate::DataIn) -> crate::AoCResult<String> {
+    let grid: Grid<GridState> = Grid::new_from_chars(data)?;
+    log::debug!("\n{grid:#}");
+    let ret = toboggonate(&grid, Coord2D { x: 3, y: 1 });
+    Ok(ret.to_string())
+}
+
+pub fn part_2(data: crate::DataIn) -> crate::AoCResult<String> {
+    let grid: Grid<GridState> = Grid::new_from_chars(data)?;
+    log::debug!("\n{grid:#}");
+    let ret: usize = [
+        Coord2D { x: 1, y: 1 },
+        Coord2D { x: 3, y: 1 },
+        Coord2D { x: 5, y: 1 },
+        Coord2D { x: 7, y: 1 },
+        Coord2D { x: 1, y: 2 },
+    ]
+    .into_iter()
+    .map(|coord| toboggonate(&grid, coord))
+    .product();
+
+    Ok(ret.to_string())
+}
+
+inventory::submit!(crate::AoCDay {
+    year: "2020",
+    day: "3",
+    part_1: crate::AoCPart {
+        main: part_1,
+        example: part_1
+    },
+    part_2: Some(crate::AoCPart {
+        main: part_2,
+        example: part_2
+    }),
+});