add initial data

aoc12/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aoc12"
+version = "0.1.0"

aoc12/Cargo.toml

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

aoc12/example1.txt

@@ -0,0 +1,7 @@
+start-A
+start-b
+A-c
+A-b
+b-d
+A-end
+b-end

aoc12/src/main.rs

@@ -0,0 +1,131 @@
+use std::collections::HashSet;
+use std::fs;
+
+#[derive(Eq, PartialEq, Hash, Clone, Debug)]
+enum CaveType {
+    Start,
+    End,
+    Big,
+    Small,
+}
+
+#[derive(Eq, PartialEq, Hash, Clone, Debug)]
+struct Cave {
+    cave_type: CaveType,
+    name: String,
+}
+
+struct Map {
+    caves: HashSet<Cave>,
+    connections: HashSet<(Cave, Cave)>,
+}
+
+impl Map {
+    fn from_file(filename: &str) -> Self {
+        let data = fs::read_to_string(filename).unwrap();
+
+        let mut caves = HashSet::new();
+        let mut connections = HashSet::new();
+
+        for line in data.split_whitespace() {
+            let (before, after) = line.split_once('-').unwrap();
+            let cave1 = Cave::from_string(before);
+            let cave2 = Cave::from_string(after);
+            caves.insert(cave1.clone());
+            caves.insert(cave2.clone());
+            connections.insert((cave1, cave2));
+        }
+
+        Self { caves, connections }
+    }
+
+    fn get_connected_caves(&self, cave: &Cave) -> Vec<&Cave> {
+        self.connections
+            .iter()
+            .filter_map(|conn| {
+                if &conn.0 == cave {
+                    Some(&conn.1)
+                } else if &conn.1 == cave {
+                    Some(&conn.0)
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+}
+
+impl Cave {
+    fn new(cave_type: CaveType, name: String) -> Self {
+        Self { cave_type, name }
+    }
+
+    fn from_string(value: &str) -> Self {
+        if value == "start" {
+            Self::get_start()
+        } else if value == "end" {
+            Self::get_end()
+        } else {
+            assert_eq!(value.len(), 1);
+            let char = value.chars().next().unwrap();
+            if char.is_uppercase() {
+                Self::new(CaveType::Big, value.to_string())
+            } else if char.is_lowercase() {
+                Self::new(CaveType::Small, value.to_string())
+            } else {
+                panic!()
+            }
+        }
+    }
+
+    fn get_start() -> Self {
+        Self::new(CaveType::Start, "start".to_string())
+    }
+
+    fn get_end() -> Self {
+        Self::new(CaveType::End, "end".to_string())
+    }
+}
+
+struct Solver<'a> {
+    map: Map,
+    start: Cave,
+    end: Cave,
+    routes: Vec<Vec<&'a Cave>>,
+}
+
+impl<'a> Solver<'a> {
+    fn new(map: Map, start: Cave, end: Cave) -> Self {
+        let routes = vec![];
+        Solver {
+            map,
+            start,
+            end,
+            routes,
+        }
+    }
+
+    fn find_routes(&mut self) {
+        let mut route: Vec<Cave> = self.new_route();
+        let mut connected = self.map.get_connected_caves(&self.start);
+
+        let cave = connected.get(0).unwrap();
+        route.push(**cave);
+
+        self.routes.push(route);
+    }
+
+    fn new_route(&self) -> Vec<Cave> {
+        vec![self.start]
+    }
+}
+
+fn main() {
+    let map = Map::from_file("example1.txt");
+
+    let start = Cave::get_start();
+    let end = Cave::get_end();
+
+    let mut solver = Solver::new(map, start, end);
+    solver.find_routes();
+}