wip

Cargo.toml

@@ -36,4 +36,12 @@ path = "src/day9/main.rs"
 
 [[bin]]
 name = "day10"
-path = "src/day10/main.rs"
+path = "src/day10/main.rs"
+
+[[bin]]
+name = "day12"
+path = "src/day12/main.rs"
+
+[[bin]]
+name = "day14"
+path = "src/day14/main.rs"

src/day14/main.rs

@@ -0,0 +1,78 @@
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+use std::iter::Peekable;
+
+type Resource = String;
+type Requirements = HashMap<Resource, Vec<Resource>>;
+
+#[derive(Default)]
+struct NanoFactory {
+    requirements: Requirements,
+}
+
+enum NanoFactoryBuildState {
+    InputCount,
+    InputResource,
+    InputDivider,
+    OutputArrow,
+    OutputCount,
+    OutputResource,
+}
+
+impl<T> From<T> for NanoFactory
+where
+    T: BufRead,
+{
+    fn from(bufreader: T) -> Self {
+        let f = NanoFactory::default();
+        let mut state = NanoFactoryBuildState::InputCount;
+        bufreader.split(b'\n').for_each(|line| {
+            let line = line.unwrap();
+            let mut line = line.into_iter().peekable();
+            let mut count_var = 0;
+            match state {
+                NanoFactoryBuildState::InputCount => {
+                    let test = next_if_in_range(&mut line, 48..84);
+                    println!("{:?}", test);
+                    while let Some(_) = line.peek().and_then(|c| match c {
+                        48..=57 => Some(c),
+                        _ => None,
+                    }) {
+                        count_var = count_var * 10 + line.next().unwrap() as usize;
+                    }
+                    assert_eq!(line.next().unwrap(), b' ');
+                    state = NanoFactoryBuildState::InputResource;
+                }
+                NanoFactoryBuildState::InputResource => {}
+                _ => (),
+            };
+            line.for_each(|c| match c {
+                b'0'..=b'9' => println!("test:{}", c),
+                _ => (),
+            })
+        });
+        NanoFactory {
+            requirements: Default::default(),
+        }
+    }
+}
+
+fn next_if_in_range<I, T>(
+    peekable: &mut std::iter::Peekable<I>,
+    range: std::ops::Range<T>,
+) -> Option<&T>
+where
+    I: std::iter::Iterator<Item = T>,
+{
+    peekable.peek().and_then(|peeked| match peeked {
+        range => Some(peeked),
+        _ => None,
+    })
+}
+
+fn main() {
+    let f = File::open("input14").unwrap();
+    let bufreader = BufReader::new(f);
+    let factory = NanoFactory::from(bufreader);
+}