Started Dec 16

december_15/example2.txt

@@ -0,0 +1,3 @@
+19999
+19111
+11191

december_15/src/main.rs

@@ -1,11 +1,16 @@
-use std::collections::BTreeMap;
+use std::collections::HashMap;
 use std::fs::File;
 use std::io::{BufReader};
 use std::io::prelude::*;
 
 const RADIX: u32 = 10;
 
-static mut shortest: u32 = 60000;
+struct Node {
+    distance: u32,
+    previous: Option<(usize, usize)>,
+    neigbours: Vec<(usize, usize)>,
+    visited: bool
+}
 
 fn main(){
     let file = File::open("./input.txt").expect("Read failed");
@@ -22,37 +27,86 @@ fn main(){
         weight_vec.push(temp_vec);
     }
 
+    let mut weight_vec_big_temp = Vec::new();
+    for line in 0..weight_vec.len() {
+        let mut new_line_vec = Vec::new();
+        for i in 0..weight_vec.len() * 5 {
+            let coordinate_from = i % weight_vec[line].len();
+            let add_val = i / weight_vec[line].len();
+            let mut new_value = weight_vec[line][coordinate_from] + add_val as u32;
+            if new_value > 9 {
+                new_value -= 9;
+            }
+            new_line_vec.push(new_value);
+        }
+        weight_vec_big_temp.push(new_line_vec);
+    }
+
+    let mut final_vector = Vec::new();
+
+    for line in 0..weight_vec_big_temp.len() * 5 {
+        let add_val = line / weight_vec_big_temp.len();
+        let mut temp_vec = Vec::new();
+        for i in 0..weight_vec_big_temp[0].len() {
+            let mut new_value = weight_vec_big_temp[line % weight_vec_big_temp.len()][i]  + add_val as u32;
+            if new_value > 9 {
+                new_value -= 9;
+            }
+            temp_vec.push(new_value)
+        }
+        final_vector.push(temp_vec);
+    }
+
+    println!("Finished generating Vec");
+    weight_vec = final_vector;
+
     let height = weight_vec.len();
     let width = weight_vec[0].len();
 
-    let visited: Vec<(usize, usize)> = Vec::new();
+    let mut graph = HashMap::new();
 
-    let out = get_shortest_weight(&weight_vec, 0, 0, 0, width, height, &visited);
-
-
-
-    println!("");
-}
-
-fn get_shortest_weight(weight_vec: &Vec<Vec<u32>>, x: usize, y: usize, current_weight: u32, width: usize, height: usize, visited: &Vec<(usize, usize)>) {
-    let mut visited_local = visited.to_owned();
-    unsafe {
-        if visited_local.contains(&(x,y)) || current_weight > shortest || visited_local.len() > 1000{
-            //println!("Breaking at {}, {}, {}", current_weight, visited_local.len(), shortest);
-            return;
+    for x in 0..width {
+        for y in 0..height {
+            let mut neighbours = Vec::new();
+            if x > 0 { neighbours.push((x-1,y)) }
+            if x < width - 1 { neighbours.push((x+1,y)) }
+            if y > 0 { neighbours.push((x,y-1)) }
+            if y < height - 1 { neighbours.push((x,y+1)) }
+            graph.insert((x,y) , Node{distance: u32::MAX, previous: None, neigbours: neighbours, visited: false});
         }
     }
-    if x == width - 1 && y == height - 1 {
-        unsafe {shortest = current_weight;
-        println!("Current length: {}, shortest now: {}", current_weight, shortest);}
-        return;
-    }
-    visited_local.push((x,y));
-    
-    let temp_weight = current_weight + weight_vec[y][x];
 
-    if x > 0 { get_shortest_weight(&weight_vec, x - 1, y, temp_weight, width, height, &visited_local); }
-    if x < width - 1 { get_shortest_weight(&weight_vec, x + 1, y, temp_weight, width, height, &visited_local); }
-    if y > 0 { get_shortest_weight(&weight_vec, x, y-1, temp_weight, width, height, &visited_local); }
-    if y < height - 1 { get_shortest_weight(&weight_vec, x, y+1, temp_weight, width, height, &visited_local); }
+    let default_node = Node { distance: 0, previous: None, neigbours: Vec::new(), visited: false };
+
+    let start_node = (0,0);
+    let end_node = (width-1, height-1);
+
+    graph.entry(start_node).or_insert(default_node).distance = 0;
+
+    loop {
+        let active_node = &graph.iter().filter(|x| x.1.visited == false).min_by_key(|x| x.1.distance).expect("").0.to_owned();
+
+        if active_node == &end_node {
+            break;
+        }
+        let distance = graph.get(active_node).expect("PANIK").distance;
+        //graph.entry(active_node.to_owned()).or_insert(Node { distance: 0, previous: None, neigbours: Vec::new(), visited: false }).visited = true;
+        graph.get_mut(active_node).unwrap().visited = true;
+
+        for neighbour in graph.get(active_node).expect("PANIK").neigbours.clone() {
+
+            let old_distance = graph.get(&neighbour).expect("PANIK").distance;
+            let new_distance = distance + weight_vec[neighbour.1][neighbour.0];
+            if new_distance < old_distance.to_owned() {
+                graph.get_mut(&neighbour).unwrap().distance = new_distance;
+                graph.get_mut(&neighbour).unwrap().previous = Some(active_node.to_owned());
+            }
+
+        }
+    }
+
+
+    let distance = graph.get(&end_node).unwrap().distance;
+
+    println!("{}", distance);
 }

december_16/example.txt

@@ -1 +1 @@
-D2FE28
+A0016C880162017C3686B18A3D4780

december_16/input.txt

@@ -0,0 +1 @@
+C20D42002ED333E7774EAAC3C2009670015692C61B65892239803536C53E2D307A600ACF324928380133D18361005B336D3600B4BF96E4A59FED94C029981C96409C4A964F995D2015DE6BD1C6E7256B004C0010A86B06A1F0002151AE0CC79866600ACC5CABC0151006238C46858200E4178F90F663FBA4FDEC0610096F8019B8803F19A1641C100722E4368C3351D0E9802D60084DC752739B8EA4ED377DE454C0119BBAFE80213F68CDC66A349B0B0053B23DDD61FF22CB874AD1C4C0139CA29580230A216C9FF54AD25A193002A2FA002AB3A63377C124205008A05CB4B66B24F33E06E014CF9CCDC3A2F22B72548E842721A573005E6E5F76D0042676BB33B5F8C46008F8023301B3F59E1464FB88DCBE6680F34C8C0115CDAA48F5EE45E278380019F9EC6395F6BE404016849E39DE2EF002013C873C8A401544EB2E002FF3D51B9CAF03C0010793E0344D00104E7611C284F5B2A10626776F785E6BD672200D3A801A798964E6671A3E9AF42A38400EF4C88CC32C24933B1006E7AC2F3E8728C8E008C759B45400B4A0B4A6CD23C4AF09646786B70028C00C002E6D00AEC1003440080024658086A401EE98070B50029400C0014FD00489000F7D400E000A60001E870038800AB9AB871005B12B37DB004266FC28988E52080462973DD0050401A8351DA0B00021D1B220C1E0013A0C0198410BE1C180370C21CC552004222FC1983A0018FCE2ACBDF109F76393751D965E3004E763DB4E169E436C0151007A10C20884000874698630708050C00043E24C188CC0008744A8311E4401D8B109A3290060BE00ACEA449214CD7B084B04F1A48025F8BD800AB4D64426B22CA00FC9BE4EA2C9EA6DC40181E802B39E009CB5B87539DD864A537DA7858C011B005E633E9F6EA133FA78EE53B7DE80

december_16/src/main.rs

@@ -1,9 +1,11 @@
-use std::fs::read_to_string;
+use std::{fs::read_to_string, env::current_exe};
 
 extern crate hex;
 
+static mut version_sum: u32 = 0;
+
 fn main() {
-    let input_char_vec = read_to_string("./example.txt").expect("ERROR reading file");
+    let input_char_vec = read_to_string("./input.txt").expect("ERROR reading file");
     //let split_input: Vec<char> = input_char_vec.chars().collect();
     let test  = hex::decode(input_char_vec).expect("Decoding failed");
 
@@ -15,11 +17,80 @@ fn main() {
         }
     }
     process_packet(bit_vec);
-    println!();
+    unsafe {println!("Package Version Sum: {}", version_sum);}
 }
 
-fn process_packet(bit_vec: Vec<bool>) {
+fn process_packet(bit_vec: Vec<bool>) -> usize {
     let version = (bit_vec[0] as u32 * 4) + (bit_vec[1] as u32 * 2) + (bit_vec[2] as u32);
     let packet_type = (bit_vec[3] as u32 * 4) + (bit_vec[4] as u32 * 2) + (bit_vec[5] as u32);
     println!("Packet Version: {}, Packet type: {}", version, packet_type);
+    unsafe { version_sum += version}
+    let mut end_bit = 0;
+    if packet_type == 4 {
+        // This is a decimal value, print for now return later
+        let mut last_bit = false;
+        let mut current_byte = 0;
+        let mut out_vec = Vec::new();
+        while !last_bit {
+            let last_bit_identifier = bit_vec[6 + (5*current_byte)];
+            let bit1 = bit_vec[7 + (5*current_byte)];
+            let bit2 = bit_vec[8 + (5*current_byte)];
+            let bit3 = bit_vec[9 + (5*current_byte)];
+            let bit4 = bit_vec[10 + (5*current_byte)];
+            if last_bit_identifier == false { last_bit = true }
+            end_bit = 10 + (5*current_byte) + 1;
+            current_byte += 1;
+            out_vec.push(bit1);
+            out_vec.push(bit2);
+            out_vec.push(bit3);
+            out_vec.push(bit4);
+        }
+
+        println!("{}", to_dec(out_vec));
+    } else {
+        let mut lenght_length = 0;
+        let mut length = 0;
+        let base: i32 = 2;
+        if bit_vec[6] {
+            lenght_length = 11;
+        } else {
+            lenght_length = 15;
+        }
+        for i in 1..=lenght_length {
+            length += bit_vec[ (7 + lenght_length) - i ] as i32 * base.pow((i - 1) as u32);
+        }
+
+        println!("length {}", length);
+        let mut data_end_bit = 0;
+        let mut end = false;
+
+        if lenght_length == 15 {
+            while !end {
+                let vec_start = 7+lenght_length + data_end_bit;
+                let vec_end = 7+lenght_length+length as usize;
+                let vec_slice: Vec<bool> = bit_vec[vec_start..vec_end].to_vec();
+                data_end_bit = process_packet(vec_slice);
+                end_bit = vec_start + data_end_bit;
+                if data_end_bit + vec_start >= vec_end { end = true}
+            }
+        } else {
+            for subblock in 0..length {
+                let vec_start = 7+lenght_length + data_end_bit;
+                let vec_end = bit_vec.len();
+                let vec_slice: Vec<bool> = bit_vec[vec_start..vec_end].to_vec();
+                data_end_bit += process_packet(vec_slice);
+                end_bit = vec_start + data_end_bit;
+            }
+        }
+    }
+    return end_bit;
+}
+
+fn to_dec(bit_vec: Vec<bool>) -> u128 {
+    let mut out_val = 0;
+    let base: i128 = 2;
+    for i in 1..=bit_vec.len() {
+        out_val += bit_vec[bit_vec.len() - i] as i128 * base.pow((i - 1) as u32);
+    }
+    return out_val as u128;
 }