init

d05/src/a1.rs

@@ -0,0 +1,117 @@
+
+struct CargoDock {
+    stacks : Vec<Vec<char>>,
+}
+
+impl CargoDock {
+
+    fn new() -> Self {
+        CargoDock { stacks: vec![] }
+    }
+
+    fn add_stacks(&mut self, s : Vec<Vec<char>>) {
+        self.stacks = s; 
+    }
+
+    fn parse_move(inp : String) -> Vec<i32> {
+        let mut out_vec = vec![]; 
+        inp.split(' ').for_each(|elem| {
+            match elem.parse::<i32>() {
+                Ok(r) => {
+                    out_vec.push(r); 
+                }
+
+                Err(_) => {}
+            }
+        }); 
+
+        out_vec
+    }
+
+    fn execute_move(&mut self, m : String) {
+
+        let parsed_move = CargoDock::parse_move(m); 
+        
+        let count = parsed_move[0]; 
+        let origin : usize = (parsed_move[1] - 1) as usize; 
+        let destination : usize = (parsed_move[2] - 1) as usize; 
+
+        for _ in 0..count {
+            let top = self.stacks[origin].pop().unwrap();  
+            self.stacks[destination].push(top); 
+        }
+
+    }
+
+    fn get_top_layer(&self) -> String {
+        let mut s = String::new(); 
+
+        self.stacks.iter().for_each(|vec| {
+            s.push(*vec.last().unwrap()); 
+        }); 
+
+        s 
+
+    }
+
+}
+
+fn parse_stack(inp : Vec<String>) -> Vec<Vec<char>> {
+    let mut vec : Vec<Vec<char>> = vec![]; 
+    vec.push(vec![]); 
+
+    inp.iter().for_each(|elem| {
+        if elem.contains('1') {
+            return; 
+        }
+
+        let res = elem.split(' ').collect::<Vec<&str>>();
+        let mut space_count = 0; 
+        let mut index = 0; 
+        for s in &res {
+            if s.is_empty() {
+                space_count += 1; 
+
+            } else {
+                let found_char = s.chars().nth(1).unwrap();
+                index += space_count / 4;
+                space_count = 0; 
+                while vec.len() < index + 1 {
+                    vec.push(vec![]); 
+                }
+                vec[index].push(found_char); 
+                index += 1; 
+            }
+
+        }
+    }); 
+
+    for v in &mut vec {
+        v.reverse(); 
+    }
+
+    vec
+}
+
+pub fn run(inp :Vec<String>) {
+    
+    let mut prev = 0; 
+
+    let mut cd = CargoDock::new(); 
+
+    for i in 0..inp.len() {
+        if inp[i].is_empty() {
+            let stacks = parse_stack(inp[0..i].to_vec());
+            cd.add_stacks(stacks); 
+            prev = i; 
+            break; 
+        }   
+    }
+
+    for i in (prev+1)..inp.len() {
+        cd.execute_move(inp[i].clone()); 
+    }
+
+    println!("a1: {:?}", cd.get_top_layer()); 
+
+}

d05/src/a2.rs

@@ -0,0 +1,116 @@
+
+struct CargoDock {
+    stacks : Vec<Vec<char>>,
+}
+
+impl CargoDock {
+
+    fn new() -> Self {
+        CargoDock { stacks: vec![] }
+    }
+
+    fn add_stacks(&mut self, s : Vec<Vec<char>>) {
+        self.stacks = s; 
+    }
+
+    fn parse_move(inp : String) -> Vec<i32> {
+        let mut out_vec = vec![]; 
+        inp.split(' ').for_each(|elem| {
+            match elem.parse::<i32>() {
+                Ok(i) => { out_vec.push(i); } 
+                
+                Err(_) => {}
+            }
+        }); 
+
+        out_vec
+    }
+
+    fn execute_move(&mut self, m : String) {
+
+        let parsed_move = CargoDock::parse_move(m); 
+        
+        let count = parsed_move[0]; 
+        let origin : usize = (parsed_move[1] - 1) as usize; 
+        let destination : usize = (parsed_move[2] - 1) as usize; 
+        let mut tmp_vec : Vec<char> = vec![]; 
+        for _ in 0..count {
+            let top = self.stacks[origin].pop().unwrap();  
+            tmp_vec.push(top); 
+        }
+        tmp_vec.reverse(); 
+        self.stacks[destination].append(&mut tmp_vec); 
+
+    }
+
+    fn get_top_layer(&self) -> String {
+        let mut s = String::new(); 
+
+        self.stacks.iter().for_each(|vec| {
+            s.push(*vec.last().unwrap()); 
+        }); 
+
+        s 
+
+    }
+
+}
+
+fn parse_stack(inp : Vec<String>) -> Vec<Vec<char>> {
+    let mut vec : Vec<Vec<char>> = vec![vec![]]; 
+
+    inp.iter().for_each(|elem| {
+        if elem.contains('1') {
+            return; 
+        }
+
+        let res = elem.split(' ').collect::<Vec<&str>>();
+        let mut space_count = 0; 
+        let mut index = 0; 
+        for s in &res {
+            if s.is_empty() {
+                space_count += 1; 
+
+            } else {
+                let found_char = s.chars().nth(1).unwrap();
+                index += space_count / 4;
+                space_count = 0; 
+                while vec.len() < index + 1 {
+                    vec.push(vec![]); 
+                }
+                vec[index].push(found_char); 
+                index += 1; 
+            }
+
+        }
+    }); 
+
+    for v in &mut vec {
+        v.reverse(); 
+    }
+
+    vec
+}
+
+pub fn run(inp :Vec<String>) {
+    
+    let mut prev = 0; 
+
+    let mut cd = CargoDock::new(); 
+
+    for i in 0..inp.len() {
+        if inp[i].is_empty() {
+            let stacks = parse_stack(inp[0..i].to_vec());
+            cd.add_stacks(stacks); 
+            prev = i; 
+            break; 
+        }   
+    }
+
+    for i in (prev+1)..inp.len() {
+        cd.execute_move(inp[i].clone()); 
+    }
+
+    println!("a2: {:?}", cd.get_top_layer()); 
+
+}

d05/src/main.rs

@@ -0,0 +1,38 @@
+use std::io::BufRead; 
+
+mod a1; 
+mod a2; 
+
+fn read_file(path :&str) -> Vec<String> {
+
+    return match std::fs::File::open(path) {
+     
+        Ok(handle) => {
+
+            let reader = std::io::BufReader::new(handle);
+
+            let mut vec : Vec<String> = vec![]; 
+
+            reader.lines().for_each(|elem| {
+                vec.push(elem.unwrap()); 
+            }); 
+
+            vec
+
+        }
+
+        Err(_) => vec![] 
+
+    }
+
+}
+
+fn main() {
+    
+    let inp :Vec<String> = read_file("input.txt"); 
+
+    a1::run(inp.clone()); 
+
+    a2::run(inp);
+    
+}