Added Rust solution for day3 and day4

4 files changed, 120 insertions, 0 deletions

diff --git a/2022/Rust/src/day1.rs b/2022/Rust/src/day1.rs
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/2022/Rust/src/day1.rs
diff --git a/2022/Rust/src/day2.rs b/2022/Rust/src/day2.rs
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/2022/Rust/src/day2.rs
diff --git a/2022/Rust/src/day3.rs b/2022/Rust/src/day3.rs
new file mode 100644
index 0000000..cb8db12
--- /dev/null
+++ b/2022/Rust/src/day3.rs
@@ -0,0 +1,52 @@
+use std::collections::HashSet;
+
+fn solve_part_one(data: &str) -> u32 {
+    data.lines()
+        .map(|line| -> u32 {
+            let (l, r) = line.split_at(line.len() / 2);
+            let l = l.chars().collect::<HashSet<_>>();
+            let r = r.chars().collect::<HashSet<_>>();
+            let mut acc = 0;
+            for x in l.intersection(&r) {
+                if x.is_ascii_uppercase() {
+                    acc += (*x as u8 - 'A' as u8 + 27) as u32;
+                } else {
+                    acc += (*x as u8 - 'a' as u8 + 1) as u32;
+                };
+            }
+            acc
+        })
+        .sum()
+}
+
+fn solve_part_two(data: &str) -> u32 {
+    let vecs: Vec<_> = data
+        .lines()
+        .map(|line| line.chars().collect::<HashSet<_>>())
+        .collect();
+
+    vecs.chunks(3)
+        .map(|x| -> u32 {
+            let mut acc : u32 = 0;
+            for i in x[0]
+                .iter()
+                .filter(|ch| x[1].contains(ch))
+                .filter(|ch| x[2].contains(ch))
+            {
+                if i.is_ascii_uppercase() {
+                    acc += (*i as u8 - 'A' as u8 + 27) as u32;
+                } else {
+                    acc += (*i as u8 - 'a' as u8 + 1) as u32;
+                };
+            }
+            acc
+        })
+        .sum()
+}
+
+
+fn main() {
+    let data = include_str!("../data/day3.prod");
+    println!("{}", solve_part_one(data));
+    println!("{}", solve_part_two(data));
+}
diff --git a/2022/Rust/src/day4.rs b/2022/Rust/src/day4.rs
new file mode 100644
index 0000000..ca50935
--- /dev/null
+++ b/2022/Rust/src/day4.rs
@@ -0,0 +1,68 @@
+use std::{num::ParseIntError, str::FromStr};
+
+#[derive(Debug)]
+struct Rng {
+    start: usize,
+    end: usize,
+}
+
+impl Rng {
+    fn intersects(&self, rng: &Rng) -> bool {
+        if self.start <= rng.end && rng.start <= self.end {
+            return true;
+        }
+        false
+    }
+
+    fn contains(&self, rng: &Rng) -> bool {
+        if self.start >= rng.start && self.end <= rng.end {
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl FromStr for Rng {
+    type Err = ParseIntError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (start, end) = s.split_once('-').unwrap();
+        let start_fromstr = start.parse::<usize>()?;
+        let end_fromstr = end.parse::<usize>()?;
+        Ok(Rng {
+            start: start_fromstr,
+            end: end_fromstr,
+        })
+    }
+}
+
+fn solve_part_one(data: &str) -> u32 {
+    data.lines()
+        .map(|line| -> u32 {
+            let l = line.split_once(',').unwrap();
+            let r1 = Rng::from_str(l.0).unwrap();
+            let r2 = Rng::from_str(l.1).unwrap();
+            (r1.contains(&r2) || r2.contains(&r1)) as u32
+        })
+        .sum()
+}
+
+fn solve_part_two(data: &str) -> u32 {
+    data.lines()
+        .map(|line| -> (Rng, Rng) {
+            let l = line.split_once(',').unwrap();
+            (Rng::from_str(l.0).unwrap(), Rng::from_str(l.1).unwrap())
+        })
+        .map(|rngs| rngs.0.intersects(&rngs.1) as u32)
+        .sum()
+}
+
+fn main() {
+    let data_test = include_str!("../data/day4.test");
+    let data_prod = include_str!("../data/day4.prod");
+    println!("{}", solve_part_one(data_test));
+    println!("{}", solve_part_two(data_test));
+    println!("{}", solve_part_one(data_prod));
+    println!("{}", solve_part_two(data_prod));
+}