Committing all aoc from 2023... please dont judge me.

2023/day1/python/main.py

@@ -0,0 +1,44 @@
+import re
+import copy
+
+f = open('input.txt', 'r')
+# content = f.read()
+digits = [
+['one',     '1'],
+['two',     '2'],
+['three',   '3'],
+['four',    '4'],
+['five',    '5'],
+['six',     '6'],
+['seven',   '7'],
+['eight',   '8'],
+['nine',    '9'],]
+
+sum = 0
+while line := f.readline():
+    min_idx = len(line)
+    min_val = ''
+    max_idx = 0
+    max_val = ''
+    for digit in digits:
+        idx = line.find(digit[0])
+        if ((idx != -1) and (idx < min_idx)):
+            min_idx = copy.copy(idx)
+            min_val = digit[1]
+    line = line[:min_idx]+min_val+line[min_idx:]
+
+    for digit in digits:
+        idx = line.rfind(digit[0])
+        if idx > max_idx:
+            max_idx = copy.copy(idx)
+            max_val = digit[1]
+    line = line[:max_idx]+max_val+line[max_idx:]
+    
+    # print(line.rstrip())
+    new_line = re.sub("[^0-9]", "", line.rstrip())
+    num = int(new_line[0])*10+int(new_line[-1])
+    # print(num)
+    sum = sum + num
+f.close()
+
+print(sum)

2023/day1/rust/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "part_two.rs"

2023/day1/rust/part_one.rs

@@ -0,0 +1,33 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+
+fn process_line(line: String) -> u32 {
+    let mut first_digit: u32 = 0;
+    let mut last_digit: u32 = 0;
+    for i in line.chars() {
+        if i.is_numeric() {
+            first_digit = i as u32 - '0' as u32;
+            break;
+        }
+    }
+    for i in line.chars().rev() {
+        if i.is_numeric() {
+            last_digit = i as u32 - '0' as u32;
+            break;
+        }
+    }
+    println!("{}{}", first_digit, last_digit);
+    return first_digit*10+last_digit;
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum: u32 = 0;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        sum = process_line(line?) + sum;
+    }
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day1/rust/part_two.rs

@@ -0,0 +1,42 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+
+fn find_digit(line: String, match_array: &[&str]) -> u32 {
+    println!("{}", line);
+    for (i, item) in line.chars().enumerate(){
+        if item.is_numeric() {
+            return item as u32 - '0' as u32;
+        }
+        else {
+            for count in 0..match_array.len() {
+                if line[0..i+1].contains(match_array[count]) {
+                    return count as u32;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+static texts: [&str; 10] = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"];
+static rev_texts: [&str; 10] = ["orez", "eno", "owt", "eerht", "ruof", "evif", "xis", "neves", "thgie", "enin"];
+
+fn process_line(line: String) -> u32 {
+    let first_digit: u32 = find_digit(line.clone(), &texts);
+    let last_digit: u32 = find_digit(line.chars().rev().collect::<String>().clone(), &rev_texts);
+    println!("{}{}", first_digit, last_digit);
+    return first_digit*10+last_digit;
+}
+
+
+fn main() -> io::Result<()>  {
+    let mut sum: u32 = 0;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        sum = process_line(line?) + sum;
+    }
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day10/rust/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libmath = "0.2.1"
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day10/rust/src/part_one.rs

@@ -0,0 +1,158 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+fn find_S(line: &str) -> Vec<(i32, i32)> {
+    let re = Regex::new(r"\d+").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.range()).collect();
+    let mut return_vec: Vec<(i32, i32)> = vec![];
+    for i in matches {
+        return_vec.push((i.start as i32, i.end as i32));
+        // println!("first {}, Last {}", i.start, i.end); 
+        // println!("number {}", line.get(i.start..i.end).unwrap().parse::<u32>().unwrap()); 
+    }
+    return return_vec;
+}
+
+fn find_next_location(wall_of_text: &Vec<String>, current_location: (i32, i32), previous_location: (i32, i32)) -> (i32, i32)
+{
+    let current_char = wall_of_text[current_location.0 as usize].get(current_location.1 as usize..current_location.1 as usize+1).unwrap();
+    println!("current_char {}", current_char);
+    match current_char{
+        "|" => (current_location.0 + (current_location.0 - previous_location.0) , current_location.1),
+        "-" => (current_location.0, current_location.1 + (current_location.1 - previous_location.1)),
+        "L" => {
+            if current_location.0 == previous_location.0 {
+                (current_location.0-1 , current_location.1)
+            }
+            else
+            {
+                (current_location.0 , current_location.1+1)
+            }
+        },
+        "J" => {
+            if current_location.0 == previous_location.0 {
+                (current_location.0-1 , current_location.1)
+            }
+            else
+            {
+                (current_location.0 , current_location.1-1)
+            }
+        }
+        "7" => {
+            if current_location.0 == previous_location.0 {
+                (current_location.0+1 , current_location.1)
+            }
+            else
+            {
+                (current_location.0 , current_location.1-1)
+            }
+        }
+        "F" => {
+            if current_location.0 == previous_location.0 {
+                (current_location.0+1 , current_location.1)
+            }
+            else
+            {
+                (current_location.0 , current_location.1+1)
+            }
+        }
+        "." => (current_location.0 , current_location.1),
+        &_ => (current_location.0 , current_location.1),
+    }
+
+}
+
+fn process_text(wall_of_text: Vec<String>) -> u32 {
+    let mut starting_location = (0,0);
+    for (line_count, line) in wall_of_text.clone().into_iter().enumerate() {
+        let x = line.find("S");
+        
+        if x.is_some(){
+            println!("S is located at {} {}", line_count, x.unwrap());
+            starting_location = (line_count as i32, x.unwrap() as i32);
+            let _ignore = find_next_location(&wall_of_text, starting_location, starting_location);
+            break;
+        }
+    }
+    let mut cardinal_directions: Vec<_> = vec![];
+    let mut heads: Vec<(i32, i32)> = vec![];
+    let mut prev_locs: Vec<(i32, i32)> = vec![];
+    prev_locs.push(starting_location);
+    prev_locs.push(starting_location);
+    cardinal_directions.push(wall_of_text[(starting_location.0 - 1)  as usize].get(starting_location.1 as usize..starting_location.1 as usize+1).unwrap());
+    cardinal_directions.push(wall_of_text[(starting_location.0 + 1) as usize].get(starting_location.1 as usize..starting_location.1 as usize+1).unwrap());
+    cardinal_directions.push(wall_of_text[starting_location.0 as usize].get((starting_location.1 + 1) as usize..(starting_location.1 + 1) as usize+1).unwrap());
+    cardinal_directions.push(wall_of_text[starting_location.0 as usize].get((starting_location.1 - 1) as usize..(starting_location.1 - 1) as usize+1).unwrap());
+
+    if match cardinal_directions[0]{
+        "|" => true,
+        "-" => false,
+        "L" => false,
+        "J" => false,
+        "7" => true,
+        "F" => true,
+        "." => false,
+        &_ => false,
+    } {heads.push(((starting_location.0 - 1), (starting_location.1)))};
+
+    if match cardinal_directions[1]{
+        "|" => true,
+        "-" => false,
+        "L" => true,
+        "J" => true,
+        "7" => false,
+        "F" => false,
+        "." => false,
+        &_ => false,
+    } {heads.push(((starting_location.0 + 1), (starting_location.1)))};
+
+    if match cardinal_directions[2]{
+        "|" => false,
+        "-" => true,
+        "L" => false,
+        "J" => true,
+        "7" => true,
+        "F" => false,
+        "." => false,
+        &_ => false,
+    } {heads.push(((starting_location.0), (starting_location.1+1)))};
+
+    if match cardinal_directions[3]{
+        "|" => false,
+        "-" => true,
+        "L" => true,
+        "J" => false,
+        "7" => false,
+        "F" => true,
+        "." => false,
+        &_ => false,
+    } {heads.push(((starting_location.0), (starting_location.1-1)))};
+
+    let mut count = 1;
+    while heads[0] != heads[1]
+    {
+        let temp0 = heads[0];
+        let temp1 = heads[1];
+        heads[0] = find_next_location(&wall_of_text, heads[0], prev_locs[0]);
+        heads[1] = find_next_location(&wall_of_text, heads[1], prev_locs[1]);
+        prev_locs[0] = temp0;
+        prev_locs[1] = temp1;
+        count += 1;
+    }
+    
+    return count;
+}
+
+fn main() -> io::Result<()>  {
+    // let file = File::open("../test.txt")?;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer: u32 = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day10/rust/src/part_two.rs

@@ -0,0 +1,252 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+fn find_S(line: &str) -> Vec<(i32, i32)> {
+    let re = Regex::new(r"\d+").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.range()).collect();
+    let mut return_vec: Vec<(i32, i32)> = vec![];
+    for i in matches {
+        return_vec.push((i.start as i32, i.end as i32));
+        // println!("first {}, Last {}", i.start, i.end); 
+        // println!("number {}", line.get(i.start..i.end).unwrap().parse::<u32>().unwrap()); 
+    }
+    return return_vec;
+}
+
+fn find_next_location(wall_of_text: &Vec<String>, current_location: (i32, i32), previous_location: (i32, i32), left: bool, map: &mut Vec<Vec<i32>>) -> (i32, i32)
+{
+    let mut sign = 1;
+    if left { sign = -1;}
+    let current_char = wall_of_text[current_location.0 as usize].get(current_location.1 as usize..current_location.1 as usize+1).unwrap();
+    println!("current_char {}", current_char);
+    match current_char{
+        "|" => {
+                map[current_location.0 as usize][current_location.1 as usize] = sign*(previous_location.0 - current_location.0);
+                (current_location.0 + (current_location.0 - previous_location.0) , current_location.1)
+        },
+        "-" => {
+                map[current_location.0 as usize][current_location.1 as usize] = 3;
+                (current_location.0, current_location.1 + (current_location.1 - previous_location.1))
+        },
+        "L" => {
+            if current_location.0 == previous_location.0 {
+                map[current_location.0 as usize][current_location.1 as usize] = sign;
+                (current_location.0-1 , current_location.1)
+            }
+            else
+            {
+                map[current_location.0 as usize][current_location.1 as usize] = -sign;
+                (current_location.0 , current_location.1+1)
+            }
+        },
+        "J" => {
+            if current_location.0 == previous_location.0 {
+                map[current_location.0 as usize][current_location.1 as usize] = sign;
+                (current_location.0-1 , current_location.1)
+            }
+            else
+            {
+                map[current_location.0 as usize][current_location.1 as usize] = -sign;
+                (current_location.0 , current_location.1-1)
+            }
+        }
+        "7" => {
+            if current_location.0 == previous_location.0 {
+                map[current_location.0 as usize][current_location.1 as usize] = -sign;
+                (current_location.0+1 , current_location.1)
+            }
+            else
+            {
+                map[current_location.0 as usize][current_location.1 as usize] = sign;
+                (current_location.0 , current_location.1-1)
+            }
+        }
+        "F" => {
+            if current_location.0 == previous_location.0 {
+                map[current_location.0 as usize][current_location.1 as usize] = -sign;
+                (current_location.0+1 , current_location.1)
+            }
+            else
+            {
+                map[current_location.0 as usize][current_location.1 as usize] = sign;
+                (current_location.0 , current_location.1+1)
+            }
+        }
+        "." => (current_location.0 , current_location.1),
+        &_ => (current_location.0 , current_location.1),
+    }
+
+}
+
+fn set_map_val(wall_of_text: &Vec<String>, map: &mut Vec<Vec<i32>>, loc: (i32, i32)){
+    let current_char = wall_of_text[loc.0 as usize].get(loc.1 as usize..loc.1 as usize+1).unwrap();
+    map[loc.0 as usize][loc.1 as usize]= match current_char {
+        "-" => 3,
+        &_ => 1,
+    };
+}
+
+fn process_text(wall_of_text: Vec<String>) -> u32 {
+    let mut starting_location = (0,0);
+    let mut map: Vec<Vec<_>> = vec![];
+    for (line_count, line) in wall_of_text.clone().into_iter().enumerate() {
+        let x = line.find("S");
+        map.push(vec![0; line.len()]);
+        if x.is_some(){
+            println!("S is located at {} {}", line_count, x.unwrap());
+            starting_location = (line_count as i32, x.unwrap() as i32);
+            // break;
+        }
+    }
+    let mut cardinal_directions: Vec<_> = vec![];
+    let mut heads: Vec<(i32, i32)> = vec![];
+    let mut prev_locs: Vec<(i32, i32)> = vec![];
+    prev_locs.push(starting_location);
+    prev_locs.push(starting_location);
+    cardinal_directions.push(wall_of_text[(starting_location.0 - 1)  as usize].get(starting_location.1 as usize..starting_location.1 as usize+1).unwrap());
+    cardinal_directions.push(wall_of_text[(starting_location.0 + 1) as usize].get(starting_location.1 as usize..starting_location.1 as usize+1).unwrap());
+    cardinal_directions.push(wall_of_text[starting_location.0 as usize].get((starting_location.1 + 1) as usize..(starting_location.1 + 1) as usize+1).unwrap());
+    cardinal_directions.push(wall_of_text[starting_location.0 as usize].get((starting_location.1 - 1) as usize..(starting_location.1 - 1) as usize+1).unwrap());
+
+    if match cardinal_directions[0]{
+        "|" => true,
+        "-" => false,
+        "L" => false,
+        "J" => false,
+        "7" => true,
+        "F" => true,
+        "." => false,
+        &_ => false,
+    } {
+        map[starting_location.0 as usize][starting_location.1 as usize] = -1;
+        heads.push(((starting_location.0 - 1), (starting_location.1)))};
+
+    if match cardinal_directions[1]{
+        "|" => true,
+        "-" => false,
+        "L" => true,
+        "J" => true,
+        "7" => false,
+        "F" => false,
+        "." => false,
+        &_ => false,
+    } {
+        if heads.len() == 0 {
+            map[starting_location.0 as usize][starting_location.1 as usize] = 1;
+        }
+        heads.push(((starting_location.0 + 1), (starting_location.1)))};
+
+    if match cardinal_directions[2]{
+        "|" => false,
+        "-" => true,
+        "L" => false,
+        "J" => true,
+        "7" => true,
+        "F" => false,
+        "." => false,
+        &_ => false,
+    } {
+        if heads.len() == 0 {
+            map[starting_location.0 as usize][starting_location.1 as usize] = 3;
+        }
+        heads.push(((starting_location.0), (starting_location.1+1)))};
+
+    if match cardinal_directions[3]{
+        "|" => false,
+        "-" => true,
+        "L" => true,
+        "J" => false,
+        "7" => false,
+        "F" => true,
+        "." => false,
+        &_ => false,
+    } {heads.push(((starting_location.0), (starting_location.1-1)))};
+
+    let mut count = 1;
+    // set_map_val(&wall_of_text, &mut map, starting_location);
+    // set_map_val(&wall_of_text, &mut map, heads[0]);
+    // set_map_val(&wall_of_text, &mut map, heads[1]);
+    // map[starting_location.0 as usize][starting_location.1 as usize]=1;
+    // map[heads[0].0 as usize][heads[0].1 as usize]=1;
+    // map[heads[1].0 as usize][heads[1].1 as usize]=1;
+
+    while heads[0] != heads[1]
+    {
+        let temp0 = heads[0];
+        let temp1 = heads[1];
+        heads[0] = find_next_location(&wall_of_text, heads[0], prev_locs[0], true, &mut map);
+        heads[1] = find_next_location(&wall_of_text, heads[1], prev_locs[1], false, &mut map);
+        // set_map_val(&wall_of_text, &mut map, heads[0]);
+        // set_map_val(&wall_of_text, &mut map, heads[1]);
+
+        // map[heads[0].0 as usize][heads[0].1 as usize]=1;
+        // map[heads[1].0 as usize][heads[1].1 as usize]=1;
+        prev_locs[0] = temp0;
+        prev_locs[1] = temp1;
+        count += 1;
+    }
+    heads[0] = find_next_location(&wall_of_text, heads[0], prev_locs[0], true, &mut map);
+    heads[1] = find_next_location(&wall_of_text, heads[1], prev_locs[1], false, &mut map);
+
+    //now to count tiles inside
+    count = 0;
+    let mut inside;
+    for (counti, i) in map.clone().into_iter().enumerate() {
+        inside = false;
+        for (countj, j) in i.into_iter().enumerate() {
+            let ch = wall_of_text[counti as usize].get(countj as usize..countj as usize+1).unwrap();
+            if (j == 1 || j == -1) {
+
+                if ch == "F"{
+                    inside = !inside;
+                    // inside = true;
+                }
+                // if ch == "J"{
+                //     inside = !inside;
+                //     // inside = true;
+                // }
+                if ch == "7" {
+                    inside = !inside;
+                    // inside = false;
+                }
+                // if ch == "L" {
+                //     inside = !inside;
+                //     // inside = false;
+                // }
+                if ch == "|" {
+                    inside = !inside;
+                }
+            }
+            // if ch == "L" || ch == "J" {
+            //     inside = false;
+            // }
+            // // if j == 1 {
+            //     inside = false;
+            // }
+            if j== 0 {
+                if inside {
+                    map[counti][countj] = 2;
+                    count += 1;
+                }
+            }
+        }
+        println!("{:?}", map[counti]);
+    }
+    
+    
+    return count;
+}
+
+fn main() -> io::Result<()>  {
+    // let file = File::open("../test.txt")?;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer: u32 = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day11/main.py

@@ -0,0 +1,65 @@
+import re
+from tracemalloc import start
+import numpy as np
+
+
+
+
+
+
+f = open('input.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+
+my_grid = np.array(lines)
+
+print(my_grid[2:5])
+universe_list = []
+locations = []
+
+for line_count, line in enumerate(lines):
+    # finds = line.find_all("#")
+    # for find in finds:
+    #     locations.append([line_count, find])
+    universe_list.append(list(line))
+
+universe = np.array(universe_list)
+
+print(np.isin(universe[2:5, 3:30], '#').any())
+print(universe[2:5, 3:30])
+
+locations = np.where(universe=='#')
+original_locations = np.copy(locations)
+print(locations)
+
+#chech columns
+for i in range(len(universe[0])):
+    if not np.isin(universe[:, i], '#').any():
+        print(np.where(original_locations[1]>i)[0])
+        locations[1][[np.where(original_locations[1]>i)[0]]] += (1000000-1)
+
+#chech rows
+for i in range(len(universe)):
+    if not np.isin(universe[i], '#').any():
+        print(np.where(original_locations[0]>i)[0])
+        locations[0][[np.where(original_locations[0]>i)[0]]] += (1000000-1)
+
+
+# print(locations)
+print(locations)
+
+sum = 0
+
+for count_i in range(len(locations[0])-1):
+    for count_j in range(count_i+1, len(locations[0])):
+        temp_sum = abs(locations[0][count_j] - locations[0][count_i])
+        temp_sum += abs(locations[1][count_j] - locations[1][count_i])
+        sum += temp_sum
+        print(f"galaxy {count_i} to {count_j}", temp_sum)
+
+
+print(sum)
+
+
+
+f.close()

2023/day12/main.py

@@ -0,0 +1,52 @@
+import re
+from tracemalloc import start
+import numpy as np
+
+
+DP = {}
+
+def recursive_solve(data, numbers, num_idx, current_num):
+    key = (data, num_idx, current_num)
+    if key in DP:
+        return DP[key]
+    
+    if len(data) == 0:
+        if (len(numbers)-1 == num_idx and numbers[num_idx] == current_num):
+            return 1
+        elif num_idx == len(numbers) and 0 == current_num:
+            return 1
+        else:
+            return 0
+    ret = 0
+    for ch in ['.', '#']:
+        if data[0] == ch or data[0] == '?':
+            if ch == '.' and current_num == 0:
+                ret += recursive_solve(data[1:], numbers, num_idx, current_num)
+            elif ch == '.' and len(numbers) > num_idx and numbers[num_idx] == current_num:
+                ret += recursive_solve(data[1:], numbers, num_idx+1, 0)
+            elif ch == '#':
+                ret += recursive_solve(data[1:], numbers, num_idx, current_num+1)
+    DP[key] = ret
+    return ret
+
+
+# f = open('test.txt', 'r')
+f = open('input.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+sum = 0
+
+for line in lines:
+    data, numbers_str = line.split()
+    numbers = [int(x) for x in numbers_str.split(',')]*5
+    DP.clear()
+    data = data + '?' + data + '?' + data + '?' + data + '?' + data
+    
+    line_sum = recursive_solve(data, numbers, 0, 0)
+    print("ret ", line_sum)
+    
+    sum += line_sum
+print(sum)
+
+
+f.close()

2023/day13/rust/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day13/rust/src/part_one.rs

@@ -0,0 +1,79 @@
+use std::fs::File;
+use std::cmp;
+use std::io::{self, prelude::*, BufReader};
+
+
+
+fn get_column_symmetry(map: &Vec<String>) -> u32 {
+    let mut row_vec: Vec<String> = (0..map[1].len()).map(|col| {
+        (1..map.len())
+        .map(|row| map[row].get(col..col+1).unwrap())
+        .collect()
+    }).collect();
+    row_vec.insert(0, "".to_string());
+    return get_row_symmetry(&row_vec);
+    
+}
+
+fn get_row_symmetry(map: &Vec<String>) -> u32 {
+    let mut sum: u32 = 0;
+    for i in 1..map.len()-1 {
+        let min: usize = cmp::min(i as usize , map.len()-i-1 as usize);
+        let mut symmetric = true;
+        for j in 0..min {
+            if map[i as usize - j] != map[i as usize + j + 1]{
+                symmetric = false;
+                break;
+            }
+        }
+        if symmetric {
+            sum += u32::try_from(i).unwrap();
+            return sum;
+        }
+    }
+    sum
+}
+
+fn process_map(map: Vec<String>) -> u32 {
+    let mut ret = 0;
+    ret += get_row_symmetry(&map)*100;
+    ret += get_column_symmetry(&map);
+    return ret;
+}
+
+fn process_text(wall_of_text: Vec<String>) -> u32 {
+    let mut map_start = 0;
+    let mut map_end = 0;
+    let length = wall_of_text.len();
+    let mut answer = 0;
+    while map_end < length-1 {
+        for count in map_end+1..length {
+            if wall_of_text[count] == "" {
+                map_start = map_end;
+                map_end = count;
+                break;
+            }
+            else if count == length-1 {
+                map_start = map_end;
+                map_end = count+1;
+                break;
+            }
+        }
+        answer += process_map(wall_of_text.get(map_start..map_end).unwrap().to_vec());
+
+    }
+
+    return answer;
+}
+
+fn main() -> io::Result<()>  {
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+    
+
+    Ok(())
+}

2023/day13/rust/src/part_two.rs

@@ -0,0 +1,112 @@
+use std::fs::File;
+use std::cmp;
+use std::io::{self, prelude::*, BufReader};
+
+
+fn get_column_symmetry(map: &Vec<String>, last_ref: u32) -> u32 {
+    let mut row_vec: Vec<String> = (0..map[1].len()).map(|col| {
+        (1..map.len())
+        .map(|row| map[row].get(col..col+1).unwrap())
+        .collect()
+    }).collect();
+    row_vec.insert(0, "".to_string());
+    return get_row_symmetry(&row_vec, last_ref);
+    
+}
+
+fn get_row_symmetry(map: &Vec<String>, last_ref: u32) -> u32 {
+    let mut sum: u32 = 0;
+    for i in 1..map.len()-1 {
+        let min: usize = cmp::min(i as usize , map.len()-i-1 as usize);
+        // println!("min {}", min);
+        let mut symmetric = true;
+        for j in 0..min {
+            if map[i as usize - j] != map[i as usize + j + 1]{
+                symmetric = false;
+                break;
+            }
+        }
+        if symmetric {
+            if u32::try_from(i).unwrap() != last_ref{
+                sum += u32::try_from(i).unwrap();
+
+            }
+        }
+    }
+    sum
+}
+
+fn process_map(map: Vec<String>) -> u32 {
+    let mut ret = 0;
+    let row = get_row_symmetry(&map,0);
+    let col = get_column_symmetry(&map,0);
+    for i in 1..map.len(){
+        for j in 0..map[1].len(){
+            let c = map[i].get(j..j+1).unwrap();
+            let new_c;
+            if c == "."{
+                new_c = "#";
+            }
+            else if c == "#"{
+                new_c = ".";
+            }
+            else{
+                panic!();
+            }
+            let mut new_map = map.clone();
+            new_map[i].replace_range(j..j+1, new_c);
+            let new_row = get_row_symmetry(&new_map,row);
+            let new_col = get_column_symmetry(&new_map, col);
+            let mut matched = false;
+            if (new_row!=0 ) && ((new_row != row)){
+                ret += 100*new_row;
+                matched = true;
+            }
+            if (new_col!=0) && ((new_col != col)){
+                ret += new_col;
+                matched = true;
+            }
+            if matched {
+                return ret;
+            }
+        }
+    }
+    return ret;
+}
+
+fn process_text(wall_of_text: Vec<String>) -> u32 {
+    let mut map_start = 0;
+    let mut map_end = 0;
+    let length = wall_of_text.len();
+    let mut answer = 0;
+    while map_end < length-1 {
+        for count in map_end+1..length {
+            if wall_of_text[count] == "" {
+                map_start = map_end;
+                map_end = count;
+                break;
+            }
+            else if count == length-1 {
+                map_start = map_end;
+                map_end = count+1;
+                break;
+            }
+        }
+        answer += process_map(wall_of_text.get(map_start..map_end).unwrap().to_vec());
+
+    }
+
+    return answer;
+}
+
+fn main() -> io::Result<()>  {
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day14/rust/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day14/rust/src/part_one.rs

@@ -0,0 +1,51 @@
+use std::fs::File;
+use std::cmp;
+use std::io::{self, prelude::*, BufReader};
+
+
+
+fn process_text(mut wall_of_text: Vec<String>) -> u32 {
+    let mut map_start = 0;
+    let mut map_end = 0;
+    let length = wall_of_text.len();
+    let mut answer = 0;
+    for line in 1..length{
+        for column in 0..wall_of_text[line].len(){
+            if wall_of_text[line].get(column..column+1).unwrap() == "O"{
+                wall_of_text[line].replace_range(column..column+1, ".");
+                for i in (0..line).rev(){
+                    if wall_of_text[i].get(column..column+1).unwrap() == "#" || wall_of_text[i].get(column..column+1).unwrap() == "O"{
+                        wall_of_text[i+1].replace_range(column..column+1, "O");
+                        break;
+                    }
+                    else if i == 0  {
+                        wall_of_text[i].replace_range(column..column+1, "O");
+                    }
+                }
+            }
+        }
+    }
+
+    for line in 0..length{
+        for column in 0..wall_of_text[line].len(){
+            if wall_of_text[line].get(column..column+1).unwrap() == "O"{
+                answer += length-line;
+            }
+        }
+    }
+    println!("{wall_of_text:?}");
+
+    return answer.try_into().unwrap();
+}
+
+fn main() -> io::Result<()>  {
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+    
+
+    Ok(())
+}

2023/day14/rust/src/part_two.rs

@@ -0,0 +1,101 @@
+use std::fs::File;
+use std::cmp;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+
+fn do_cycle(mut wall_of_text: Vec<String>) -> Vec<String>{
+    for _i in 0..4 {
+        wall_of_text = move_to_top(wall_of_text);
+        wall_of_text = rotate_left(wall_of_text);
+    }
+    wall_of_text
+}
+
+fn move_to_top(mut wall_of_text: Vec<String>) -> Vec<String>{
+    let length = wall_of_text.len();
+    for line in 1..length{
+        for column in 0..wall_of_text[line].len(){
+            if wall_of_text[line].get(column..column+1).unwrap() == "O"{
+                wall_of_text[line].replace_range(column..column+1, ".");
+                for i in (0..line).rev(){
+                    if wall_of_text[i].get(column..column+1).unwrap() == "#" || wall_of_text[i].get(column..column+1).unwrap() == "O"{
+                        wall_of_text[i+1].replace_range(column..column+1, "O");
+                        break;
+                    }
+                    else if i == 0  {
+                        wall_of_text[i].replace_range(column..column+1, "O");
+                    }
+                }
+            }
+        }
+    }
+    wall_of_text
+}
+
+fn rotate_left(wall_of_text: Vec<String>) -> Vec<String> {
+    let rotate_text: Vec<String> = (0..wall_of_text[0].len()).map(|col| {
+        (0..wall_of_text.len()).rev()
+        .map(|row| wall_of_text[row].get(col..col+1).unwrap())
+        .collect()
+    }).collect();
+    rotate_text
+
+}
+
+fn process_text(mut wall_of_text: Vec<String>) -> u32 {
+    let mut answer = 0;
+    let length = wall_of_text.len();
+    let mut answers_vec = vec![];
+    let mut cycle_found = false;
+    for i in 0..1000000000 {
+        let original = wall_of_text.clone();
+        wall_of_text = do_cycle(wall_of_text);
+        if original == wall_of_text {
+            break;
+        }
+        let mut answer = 0;
+
+        for line in 0..length{
+            for column in 0..wall_of_text[line].len(){
+                if wall_of_text[line].get(column..column+1).unwrap() == "O"{
+                    answer += length-line;
+                }
+            }
+        }
+
+        // Some sketchy "look for a pattern and try to calculate the end result when one is found" type shit
+        answers_vec.push(answer);
+        for i in 0..answers_vec.len()
+        {
+            for j in i+10..answers_vec.len(){
+                if answers_vec[j] == answers_vec[i] && answers_vec.len()>j+j-i
+                {
+                    cycle_found = true;
+                    for k in 0..j-i{
+                        if answers_vec[j+k] != answers_vec[i+k]{
+                            cycle_found = false;
+                            break;
+                        }
+                    }
+                    if cycle_found {
+                        let temp_mod = (1000000000-1 - i) % (j - i);
+                        return answers_vec[i+temp_mod].try_into().unwrap();
+                    }
+                }
+            }
+        }
+    }
+
+    return answer.try_into().unwrap();
+}
+
+fn main() -> io::Result<()>  {
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day15/rust/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day15/rust/src/part_one.rs

@@ -0,0 +1,36 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+
+fn get_hash(line:  &str) -> u32 {
+    let mut ret = 0;
+    for s in line.chars(){
+        let ascii = s as u32;
+        ret += ascii;
+        ret = 17*ret;
+        ret = ret%256;
+        // println!("{}", ascii);
+    }
+    return ret;
+}
+
+fn process_text(parts: Vec<&str>) -> u32 {
+    let mut ret = 0;
+    for part in parts {
+        ret += get_hash(part);
+    }
+    return ret;
+}
+
+fn main() -> io::Result<()>  {
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let line = reader.lines().collect::<io::Result<Vec<String>>>().expect("failed");
+    let parts = line[0].split(&[',']).collect::<Vec<&str>>();
+    let answer = process_text(
+        parts
+    );
+    println!("{}", answer);
+    
+
+    Ok(())
+}

2023/day15/rust/src/part_two.rs

@@ -0,0 +1,102 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+
+fn get_hash(line:  &str) -> u32 {
+    let mut ret = 0;
+    for s in line.chars(){
+        let ascii = s as u32;
+        ret += ascii;
+        ret = 17*ret;
+        ret = ret%256;
+    }
+    // println!("{} {:?}", ret, line);
+    return ret;
+}
+
+fn process_text(parts: Vec<&str>) -> u32 {
+    let mut array_of_hash: HashMap<u32, Vec<(&str, u32)>> = HashMap::new();
+    let mut ret = 0;
+    for part in parts {
+        //look for symbol
+        for i in 0..part.len(){
+            if part.get(i..i+1).unwrap() == "-" || part.get(i..i+1).unwrap() == "="
+            {
+                let idx = get_hash(part.get(0..i).unwrap());
+                if part.get(i..i+1).unwrap() == "-"{
+                    let get_idx = array_of_hash.get(&idx);
+                    if get_idx.is_some() {
+                        array_of_hash.get_mut(&idx).map(|val| {
+                            for j in 0..val.len() {
+                                // println!("{j:?}");
+                                if val[j].0 == part.get(0..i).unwrap(){
+                                    // println!("Trying to remove {} {}", idx, val[j].0);
+                                    val.remove(j);
+                                    break;
+                                }
+                            }
+                            // val.remove(part.get(0..i).unwrap())
+                        });
+                        // array_of_hash[&idx].remove(part.get(0..i).unwrap());
+                    }
+                }
+                else{
+                    let get_idx = array_of_hash.get(&idx);
+                    if get_idx.is_some() {
+                        array_of_hash.get_mut(&idx).map(|val| {
+                            let mut found = false;
+                            for j in 0..val.len() {
+                                // println!("{j:?}");
+                                if val[j].0 == part.get(0..i).unwrap(){
+                                    val[j].1 = part.chars().nth(i+1).unwrap() as u32 - '0' as u32;
+                                    found = true;
+                                    break;
+                                }
+                            }
+                            if !found {
+                                val.push((part.get(0..i).unwrap(), part.chars().nth(i+1).unwrap() as u32 - '0' as u32));
+                            }});
+                        // array_of_hash[&idx].remove(part.get(0..i).unwrap());
+                    }
+                    else{
+                        let mut temp_hash = vec![];
+                        temp_hash.push((part.get(0..i).unwrap(), part.chars().nth(i+1).unwrap() as u32 - '0' as u32));
+                        array_of_hash.insert(idx, temp_hash);
+                    }
+                    // array_of_hash.entry(idx).or_insert(.entry(part.get(0..i).unwrap()).or_insert(part.chars().nth(i+1).unwrap() as u32 - '0' as u32));
+                }
+                break;
+                
+            }
+            // println!("HASH, {array_of_hash:?}");
+        }
+
+        // ret += get_hash(part);
+    }
+    for (idx, inner_hash) in &array_of_hash{
+        let mut slot = 1;
+        for (key, focal_length) in inner_hash{
+            let sum = (idx+1)*slot*focal_length;
+            ret += sum;
+            slot += 1;
+            // println!("HASH, {sum:?}");
+        }
+        
+    }
+    // println!("HASH, {array_of_hash:?}");
+    return ret;
+}
+
+fn main() -> io::Result<()>  {
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let line = reader.lines().collect::<io::Result<Vec<String>>>().expect("failed");
+    let parts = line[0].split(&[',']).collect::<Vec<&str>>();
+    let answer = process_text(
+        parts
+    );
+    println!("{}", answer);
+    
+
+    Ok(())
+}

2023/day16/rust/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libmath = "0.2.1"
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day16/rust/src/part_one.rs

@@ -0,0 +1,147 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+fn conv_i32_to_usize(var :i32) -> usize {
+    usize::try_from(var).unwrap()
+}
+
+fn process_ray(wall_of_text: &Vec<String>, mut rays_vec: Vec<[[i32; 2]; 2]>, ray_index: usize, mut past_rays: Vec<[[i32; 2]; 2]>) -> (Vec<[[i32; 2]; 2]>, Vec<[[i32; 2]; 2]>)
+{
+    let current_char = wall_of_text[conv_i32_to_usize(rays_vec[ray_index][0][1])].get(conv_i32_to_usize(rays_vec[ray_index][0][0])..conv_i32_to_usize(rays_vec[ray_index][0][0])+1).unwrap();
+    // println!("current_char {}", current_char);
+    let mut split = false;
+    past_rays.push(rays_vec[ray_index]);
+    let mut new_ray: [[i32; 2]; 2] = [[0,0],[0,0]];
+    match current_char{
+        "|" => { 
+            // If not moving left right, we must be moving up, down
+            if rays_vec[ray_index][1][0] == 0 {
+                rays_vec[ray_index][0][0] = rays_vec[ray_index][0][0] + rays_vec[ray_index][1][0];
+                rays_vec[ray_index][0][1] = rays_vec[ray_index][0][1] + rays_vec[ray_index][1][1];
+            }
+            else{
+                if rays_vec[ray_index][0][1] - 1 >= 0 {
+                    split = true;
+                    new_ray = [[rays_vec[ray_index][0][0], rays_vec[ray_index][0][1] - 1], [0, -1]];
+                }
+                rays_vec[ray_index] = [[rays_vec[ray_index][0][0], rays_vec[ray_index][0][1] + 1], [0, 1]];
+            }
+        },
+        "-" => {
+            // If not movine left right, we must be moving up, down
+            if rays_vec[ray_index][1][0] == 0 {
+                if rays_vec[ray_index][0][0] - 1 >= 0 {
+                    split = true;
+                    new_ray = [[rays_vec[ray_index][0][0] - 1  , rays_vec[ray_index][0][1]], [-1, 0]];
+                }
+                rays_vec[ray_index] = [[rays_vec[ray_index][0][0] + 1  , rays_vec[ray_index][0][1]], [1, 0]];
+            }
+            else{
+                rays_vec[ray_index][0][0] = rays_vec[ray_index][0][0] + rays_vec[ray_index][1][0];
+                rays_vec[ray_index][0][1] = rays_vec[ray_index][0][1] + rays_vec[ray_index][1][1];
+            }
+        },
+        "\\" => {
+            let ray = rays_vec[ray_index];
+            rays_vec[ray_index][1][0] = ray[1][1];
+            rays_vec[ray_index][1][1] = ray[1][0];
+            rays_vec[ray_index][0][0] = rays_vec[ray_index][0][0] + rays_vec[ray_index][1][0];
+            rays_vec[ray_index][0][1] = rays_vec[ray_index][0][1] + rays_vec[ray_index][1][1];
+        },
+        "/" => {
+            let ray = rays_vec[ray_index];
+            rays_vec[ray_index][1][0] = -ray[1][1];
+            rays_vec[ray_index][1][1] = -ray[1][0];
+            rays_vec[ray_index][0][0] = rays_vec[ray_index][0][0] + rays_vec[ray_index][1][0];
+            rays_vec[ray_index][0][1] = rays_vec[ray_index][0][1] + rays_vec[ray_index][1][1];
+        },
+        "." => {
+            rays_vec[ray_index][0][0] = rays_vec[ray_index][0][0] + rays_vec[ray_index][1][0];
+            rays_vec[ray_index][0][1] = rays_vec[ray_index][0][1] + rays_vec[ray_index][1][1];
+        },
+        &_ => panic!(),
+    }
+    
+    // println!("ray_index {}", ray_index);
+    let ray = rays_vec[ray_index];
+    let mut remove_ray = false;
+    if ((ray[0][0] < 0) || (ray[0][0] == wall_of_text.len().try_into().unwrap()) ||
+        (ray[0][1] < 0) || ray[0][1] == wall_of_text[0].len().try_into().unwrap())
+    {
+        // println!("REMOVING {}", ray_index);
+        remove_ray = true;
+    }
+    else{
+        for past_ray in &past_rays {
+            if past_ray == &ray {
+                // println!("REMOVING duplicate ray {}", ray_index);
+                remove_ray = true;
+                break;
+            }
+        }
+    }
+    
+    if remove_ray{
+        rays_vec.remove(ray_index);
+    }
+
+    if split {
+        rays_vec.push(new_ray);
+    }
+
+    
+
+    (rays_vec, past_rays)
+
+}
+
+fn process_text(wall_of_text: Vec<String>) -> u32 { 
+    let mut light_rays: Vec<[[i32; 2]; 2]> = vec![];
+    let mut past_rays: Vec<[[i32; 2]; 2]> = vec![];
+    light_rays.push([[0,0], [1, 0]]);
+    while (light_rays.len() > 0) {
+        // println!("{light_rays:?}");
+        // let mut temp_light_rays = .clone();
+        for ray in (0..light_rays.len()).rev() {
+            (light_rays, past_rays) = process_ray(&wall_of_text, light_rays, ray, past_rays);
+        }
+
+        // light_rays = temp_light_rays;
+    }
+
+    let mut count = 0;
+    let mut energized_set: Vec<[i32; 2]> = vec![];
+    // energized_set.push([0,0]);
+    for i in &past_rays{
+        if i[0][0] < 0 || i[0][0] >= wall_of_text.len().try_into().unwrap() ||
+        i[0][1] < 0 || i[0][1] >= wall_of_text[0].len().try_into().unwrap()
+    {
+        panic!();
+    }
+        if !energized_set.contains(&i[0]){
+            energized_set.push(i[0]);
+            count += 1;
+        }
+    }
+    
+    // println!("Len of past rays {}", count);
+    // println!("energized_set {energized_set:?}");
+    println!("energized_set {:?}", energized_set.len());
+    println!("past_rays {:?}", past_rays.len());
+    
+    return 0;
+}
+
+fn main() -> io::Result<()>  {
+    // let file = File::open("../test.txt")?;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer: u32 = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day16/rust/src/part_two.rs

@@ -0,0 +1,177 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+fn conv_i32_to_usize(var :i32) -> usize {
+    usize::try_from(var).unwrap()
+}
+
+fn process_ray(wall_of_text: &Vec<String>, mut rays_vec: Vec<[[i32; 2]; 2]>, ray_index: usize, mut past_rays: Vec<[[i32; 2]; 2]>) -> (Vec<[[i32; 2]; 2]>, Vec<[[i32; 2]; 2]>)
+{
+    let current_char = wall_of_text[conv_i32_to_usize(rays_vec[ray_index][0][1])].get(conv_i32_to_usize(rays_vec[ray_index][0][0])..conv_i32_to_usize(rays_vec[ray_index][0][0])+1).unwrap();
+    // println!("current_char {}", current_char);
+    let mut split = false;
+    past_rays.push(rays_vec[ray_index]);
+    let mut new_ray: [[i32; 2]; 2] = [[0,0],[0,0]];
+    match current_char{
+        "|" => { 
+            // If not moving left right, we must be moving up, down
+            if rays_vec[ray_index][1][0] == 0 {
+                rays_vec[ray_index][0][0] = rays_vec[ray_index][0][0] + rays_vec[ray_index][1][0];
+                rays_vec[ray_index][0][1] = rays_vec[ray_index][0][1] + rays_vec[ray_index][1][1];
+            }
+            else{
+                if rays_vec[ray_index][0][1] - 1 >= 0 {
+                    split = true;
+                    new_ray = [[rays_vec[ray_index][0][0], rays_vec[ray_index][0][1] - 1], [0, -1]];
+                }
+                rays_vec[ray_index] = [[rays_vec[ray_index][0][0], rays_vec[ray_index][0][1] + 1], [0, 1]];
+            }
+        },
+        "-" => {
+            // If not movine left right, we must be moving up, down
+            if rays_vec[ray_index][1][0] == 0 {
+                if rays_vec[ray_index][0][0] - 1 >= 0 {
+                    split = true;
+                    new_ray = [[rays_vec[ray_index][0][0] - 1  , rays_vec[ray_index][0][1]], [-1, 0]];
+                }
+                rays_vec[ray_index] = [[rays_vec[ray_index][0][0] + 1  , rays_vec[ray_index][0][1]], [1, 0]];
+            }
+            else{
+                rays_vec[ray_index][0][0] = rays_vec[ray_index][0][0] + rays_vec[ray_index][1][0];
+                rays_vec[ray_index][0][1] = rays_vec[ray_index][0][1] + rays_vec[ray_index][1][1];
+            }
+        },
+        "\\" => {
+            let ray = rays_vec[ray_index];
+            rays_vec[ray_index][1][0] = ray[1][1];
+            rays_vec[ray_index][1][1] = ray[1][0];
+            rays_vec[ray_index][0][0] = rays_vec[ray_index][0][0] + rays_vec[ray_index][1][0];
+            rays_vec[ray_index][0][1] = rays_vec[ray_index][0][1] + rays_vec[ray_index][1][1];
+        },
+        "/" => {
+            let ray = rays_vec[ray_index];
+            rays_vec[ray_index][1][0] = -ray[1][1];
+            rays_vec[ray_index][1][1] = -ray[1][0];
+            rays_vec[ray_index][0][0] = rays_vec[ray_index][0][0] + rays_vec[ray_index][1][0];
+            rays_vec[ray_index][0][1] = rays_vec[ray_index][0][1] + rays_vec[ray_index][1][1];
+        },
+        "." => {
+            rays_vec[ray_index][0][0] = rays_vec[ray_index][0][0] + rays_vec[ray_index][1][0];
+            rays_vec[ray_index][0][1] = rays_vec[ray_index][0][1] + rays_vec[ray_index][1][1];
+        },
+        &_ => panic!(),
+    }
+    
+    // println!("ray_index {}", ray_index);
+    let ray = rays_vec[ray_index];
+    let mut remove_ray = false;
+    if ray[0][0] < 0 || ray[0][0] == wall_of_text.len().try_into().unwrap() ||
+        ray[0][1] < 0 || ray[0][1] == wall_of_text[0].len().try_into().unwrap()
+    {
+        // println!("REMOVING {}", ray_index);
+        remove_ray = true;
+    }
+    else{
+        for past_ray in &past_rays {
+            if past_ray == &ray {
+                // println!("REMOVING duplicate ray {}", ray_index);
+                remove_ray = true;
+                break;
+            }
+        }
+    }
+    
+    if remove_ray{
+        rays_vec.remove(ray_index);
+    }
+    if split {
+        rays_vec.push(new_ray);
+    }
+
+    (rays_vec, past_rays)
+
+}
+
+fn process_text_wrapper(wall_of_text: Vec<String>) -> u32 {
+    let mut max = 0;
+    for i in 0..wall_of_text[0].len()
+    {
+        let ret_val = process_text(&wall_of_text, [[0,i.try_into().unwrap()],[1,0]]);
+        if ret_val > max{
+            max = ret_val;
+        }
+    }
+    for i in 0..wall_of_text[0].len()
+    {
+        let ret_val = process_text(&wall_of_text, [[<usize as TryInto<i32>>::try_into(wall_of_text.len()).unwrap()-1,i.try_into().unwrap()],[-1,0]]);
+        if ret_val > max{
+            max = ret_val;
+        }
+    }
+    for i in 0..wall_of_text.len()
+    {
+        let ret_val = process_text(&wall_of_text, [[i.try_into().unwrap(),0],[0,1]]);
+        if ret_val > max{
+            max = ret_val;
+        }
+    }
+    for i in 0..wall_of_text.len()
+    {
+        let ret_val = process_text(&wall_of_text, [[i.try_into().unwrap(), <usize as TryInto<i32>>::try_into(wall_of_text[0].len()).unwrap()-1],[0,-1]]);
+        if ret_val > max{
+            max = ret_val;
+        }
+    }
+    return max;
+}
+
+fn process_text(wall_of_text: &Vec<String>, starting_ray: [[i32; 2]; 2]) -> u32 { 
+    let mut light_rays: Vec<[[i32; 2]; 2]> = vec![];
+    let mut past_rays: Vec<[[i32; 2]; 2]> = vec![];
+    light_rays.push(starting_ray);
+    while light_rays.len() > 0 {
+        // println!("{light_rays:?}");
+        // let mut temp_light_rays = .clone();
+        for ray in (0..light_rays.len()).rev() {
+            (light_rays, past_rays) = process_ray(&wall_of_text, light_rays, ray, past_rays);
+        }
+
+        // light_rays = temp_light_rays;
+    }
+
+    let mut count = 0;
+    let mut energized_set: Vec<[i32; 2]> = vec![];
+    // energized_set.push([0,0]);
+    for i in &past_rays{
+        if i[0][0] < 0 || i[0][0] >= wall_of_text.len().try_into().unwrap() ||
+        i[0][1] < 0 || i[0][1] >= wall_of_text[0].len().try_into().unwrap()
+    {
+        panic!();
+    }
+        if !energized_set.contains(&i[0]){
+            energized_set.push(i[0]);
+            count += 1;
+        }
+    }
+    
+    // println!("Len of past rays {}", count);
+    // // println!("energized_set {energized_set:?}");
+    // println!("energized_set {:?}", energized_set.len());
+    // println!("past_rays {:?}", past_rays.len());
+    
+    return energized_set.len().try_into().unwrap();
+}
+
+fn main() -> io::Result<()>  {
+    // let file = File::open("../test.txt")?;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer: u32 = process_text_wrapper(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day17/main.py

@@ -0,0 +1,84 @@
+import re
+from tracemalloc import start
+import numpy as np
+
+
+list_of_nodes = []
+
+
+
+# f = open('test.txt', 'r')
+f = open('input.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+
+my_grid = np.array(lines)
+
+universe_list = []
+
+for line_count, line in enumerate(lines):
+    # finds = line.find_all("#")
+    # for find in finds:
+    #     locations.append([line_count, find])
+    line_list = []
+    for ch in line:
+        line_list.append(int(ch))
+    
+    universe_list.append(line_list)
+
+universe = np.array(universe_list)
+W = len(universe[0])
+H = len(universe[1])
+
+VISITED = {}
+
+best = 10000000
+
+finished = False
+list_of_nodes.append([[0,0],[1,0],0])
+list_of_nodes.append([[0,0],[0,1],0])
+while not finished:
+    print("Cycle")
+    min_node = list_of_nodes.pop(0)
+    for i in range(3):
+        #change direction
+        if i >= 1-1:
+            for j in [-1,1]:
+                dir = [j*min_node[1][1], j*min_node[1][0]]
+                pos = [min_node[0][0] + dir[0], min_node[0][1] + dir[1]]
+                if pos[0] >= 0 and pos[0] < W and pos[1] >= 0 and pos[1] < H:
+                    heat = min_node[2] + universe[pos[0]][pos[1]]
+                    key = (*pos, *dir)
+                    if (key in VISITED and VISITED[key] <= heat):
+                        continue
+                    else:
+                        list_of_nodes.append([pos, dir, heat])
+                        if pos == [W-1, H-1]:
+                            if heat < best:
+                                best = heat
+                        VISITED[key] = heat
+                
+        min_node[0] = [min_node[0][0] + min_node[1][0], min_node[0][1] + min_node[1][1]]
+        if min_node[0][0] >= 0 and min_node[0][0] < W and min_node[0][1] >= 0 and min_node[0][1] < H:
+            min_node[2] = min_node[2] + universe[min_node[0][0]][min_node[0][1]]
+            if min_node[0] == [W-1, H-1]:
+                if min_node[2] < best:
+                    best = min_node[2]
+        else:
+            break
+            
+    list_of_nodes.sort(key = lambda x: x[2])
+    finished = (len(list_of_nodes) == 0 or list_of_nodes[0][0] == [W-1, H-1])
+    
+print(best)
+# print(universe)
+print(list_of_nodes[0][2])
+# print(VISITED[(W-1, H-1, 0,1)])
+# print(VISITED[(W-1, H-1, 1,0)])
+sum = 0
+
+
+
+
+
+f.close()

2023/day17/part_two.py

@@ -0,0 +1,87 @@
+import re
+from tracemalloc import start
+import numpy as np
+
+
+list_of_nodes = []
+
+
+
+# f = open('test.txt', 'r')
+# f = open('test2.txt', 'r')
+f = open('input.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+
+my_grid = np.array(lines)
+
+universe_list = []
+
+for line_count, line in enumerate(lines):
+    # finds = line.find_all("#")
+    # for find in finds:
+    #     locations.append([line_count, find])
+    line_list = []
+    for ch in line:
+        line_list.append(int(ch))
+    
+    universe_list.append(line_list)
+
+universe = np.array(universe_list)
+H = len(universe[0])
+W = len(universe)
+
+VISITED = {}
+
+best = 10000000
+
+finished = False
+list_of_nodes.append([[0,0],[1,0],0])
+list_of_nodes.append([[0,0],[0,1],0])
+while not finished:
+    min_node = list_of_nodes.pop(0)
+    for j in [-1, 1]:
+        pos = min_node[0]
+        heat = min_node[2]
+        dir = [j*min_node[1][1], j*min_node[1][0]]
+        for i in range(10):
+        #change direction
+            pos = [pos[0] + dir[0], pos[1] + dir[1]]
+            if pos[0] >= 0 and pos[0] < W and pos[1] >= 0 and pos[1] < H:
+                heat += universe[pos[0]][pos[1]]
+                if i >= 4-1:
+                    key = (*pos, *dir)
+                    if (key in VISITED and VISITED[key] <= heat):
+                        continue
+                    else:
+                        list_of_nodes.append([pos, dir, heat])
+                        if pos == [W-1, H-1]:
+                            if heat < best:
+                                best = heat
+                        VISITED[key] = heat
+                
+        # min_node[0] = [min_node[0][0] + min_node[1][0], min_node[0][1] + min_node[1][1]]
+        # if min_node[0][0] >= 0 and min_node[0][0] < W and min_node[0][1] >= 0 and min_node[0][1] < H:
+        #     min_node[2] = min_node[2] + universe[min_node[0][0]][min_node[0][1]]
+        #     if min_node[0] == [W-1, H-1]:
+        #         if min_node[2] < best:
+        #             best = min_node[2]
+        # else:
+        #     break
+            
+    # list_of_nodes = new_list
+    list_of_nodes.sort(key = lambda x: x[2])
+    finished = (len(list_of_nodes) == 0 or list_of_nodes[0][0] == [W-1, H-1])
+    
+print(best)
+# print(universe)
+print(list_of_nodes)
+# print(VISITED[(W-1, H-1, 0,1)])
+# print(VISITED[(W-1, H-1, 1,0)])
+sum = 0
+
+
+
+
+
+f.close()

2023/day17/rust/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libmath = "0.2.1"
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day17/rust/src/part_one.rs

@@ -0,0 +1,151 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+struct Node{
+    straights: u8,
+    heat: u32,
+    location: (isize, isize),
+    direction: (isize, isize),
+    path: Vec<(isize, isize)>,
+}
+
+
+fn check_bound(x: isize , y: isize, max_x: isize, max_y: isize) -> bool {
+    return !(x >= max_x || x < 0 || y >= max_y || y < 0);
+}
+
+fn check_finished(nodes: &Vec<Node>, max_x: isize, max_y: isize) -> bool {
+    let mut min_node = std::u32::MAX;
+    let mut min_idx = 0;
+    for count in 0..nodes.len() {
+        if nodes[count].heat < min_node {
+            min_node = nodes[count].heat;
+            min_idx = count;
+        }
+    }
+    println!("heat {}", nodes[min_idx].heat);
+    println!("num_nodes {}", nodes.len());
+    println!("locs {} {}", nodes[min_idx].location.0, nodes[min_idx].location.1);
+    println!("path {:?}", nodes[min_idx].path);
+    return nodes[min_idx].location.0 == max_x-1 && nodes[min_idx].location.1 == max_y-1;
+
+}
+
+fn loc_not_in_locs(loc: Node, locs: &Vec<Node>) -> bool{
+    for current_loc in locs{
+        if (loc.location.0 == current_loc.location.0 && loc.location.1 == current_loc.location.1)// && loc.heat >= current_loc.heat+10)// && loc.direction.0 == current_loc.direction.0 && loc.direction.1 == current_loc.direction.1 && loc.straights == current_loc.straights && loc.heat >= current_loc.heat)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+fn take_step(map: &Vec<Vec<u32>>,  nodes: &mut Vec<Node>, visited_loc: &mut Vec<Node>) {
+    let mut min_node = std::u32::MAX;
+    let nodes_len = nodes.len();
+    let mut min_idx = 0;
+    for count in 0..nodes.len() {
+        if nodes[count].heat < min_node {
+            min_node = nodes[count].heat;
+            min_idx = count;
+        }
+    }
+
+
+    // Add a straight to the list
+    if nodes[min_idx].straights < 2{
+        let new_loc = (nodes[min_idx].location.0 + nodes[min_idx].direction.0, nodes[min_idx].location.1 + nodes[min_idx].direction.1);
+        if check_bound(new_loc.0, new_loc.1, map[0].len().try_into().unwrap(), map.len().try_into().unwrap())
+        {
+            let new_dir = nodes[min_idx].direction;
+            let new_heat = nodes[min_idx].heat + map[(new_loc.0) as usize][(new_loc.1) as usize];
+            let straight = nodes[min_idx].straights + 1;
+            let mut new_path = nodes[min_idx].path.clone();
+            new_path.push(nodes[min_idx].location);
+            let new_node: Node = {Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: new_path}};
+            if loc_not_in_locs({Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: vec![]}}, &visited_loc){
+                // println!("Adding {:?}", new_node.location);
+                // visited_loc.push({Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: vec![]}});
+                nodes.push(new_node);
+            }
+        }
+    }
+
+    // Add a turn left and right
+    for i in [-1, 1]{
+        // println!("{}", i);
+        let new_dir = (i * nodes[min_idx].direction.1, i * nodes[min_idx].direction.0);
+        let new_loc = (nodes[min_idx].location.0 + new_dir.0, nodes[min_idx].location.1 + new_dir.1);
+        if check_bound(new_loc.0, new_loc.1, map[0].len().try_into().unwrap(), map.len().try_into().unwrap())
+        {
+            let new_heat = nodes[min_idx].heat + map[(new_loc.0) as usize][(new_loc.1) as usize];
+            let straight = 0;
+            let mut new_path = nodes[min_idx].path.clone();
+            new_path.push(nodes[min_idx].location);
+            let new_node: Node = {Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: new_path}};
+            if loc_not_in_locs({Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: vec![]}}, &visited_loc){
+                // println!("Adding {:?}", new_node.location);
+                // visited_loc.push({Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: vec![]}});
+                nodes.push(new_node);
+            }
+        }
+    }
+    let n_loc = nodes[min_idx].location;
+    let n_s = nodes[min_idx].straights;
+    let n_dir = nodes[min_idx].direction;
+    let n_heat = nodes[min_idx].heat;
+    visited_loc.push({Node { straights: n_s, heat: n_heat, location: n_loc, direction: n_dir, path: vec![]}});
+    // if nodes[min_idx].path.len() > 3{
+        // let purge_location = nodes[min_idx].path[nodes[min_idx].path.len()-3-1];
+        // nodes.remove(min_idx);
+        for i in (0..nodes.len()).rev(){
+            if nodes[i].location.0 == n_loc.0 && nodes[i].location.1 == n_loc.1 && nodes[i].straights == n_s && nodes[i].direction.0 == n_dir.0 && nodes[i].direction.1 == n_dir.1 //&& nodes[i].heat >= n_heat
+            {
+                // println!("REMOVING {:?}", nodes[i].location);
+                nodes.remove(i);
+            }
+        }
+    // }
+    // else{
+    // nodes.remove(min_idx);
+
+    // }
+    // println!("REMOVING {:?}", nodes[min_idx].location);
+
+    // return nodes;
+}
+
+fn process_line(map: &Vec<Vec<u32>> ) -> i64 {
+    let mut nodes: Vec<Node> = vec![];
+    let mut visited_locs: Vec<Node> = vec![];
+    let mut finished = false;
+    nodes.push(Node { straights: 0, heat: 0, location: (0, 0), direction: (1, 0), path: vec![]});
+    nodes.push(Node { straights: 0, heat: 0, location: (0, 0), direction: (0, 1), path: vec![]});
+    while !finished {
+        take_step(&map, &mut nodes, &mut visited_locs);
+        finished = check_finished(&nodes, map[0].len().try_into().unwrap(), map.len().try_into().unwrap());
+    }
+
+    // let numbers = find_numbers(&line);
+    return 0;
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum = 0;
+    let mut map: Vec<Vec<u32>> = vec![];
+    // let file = File::open("../test.txt")?;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        map.push(line?.to_string().chars().map(|m| m.to_digit(10).unwrap()).collect());
+    }
+
+    sum = process_line(&map);
+    // println!("{map:?}");
+    // println!("{}", sum);
+
+    Ok(())
+}

2023/day18/main.py

@@ -0,0 +1,125 @@
+import re
+from tracemalloc import start
+import numpy as np
+import turtle
+
+wn = turtle.Screen()
+wn.bgcolor("light green")
+wn.title("Turtle")
+# skk = turtle.Turtle()
+
+wn.colormode(255)
+
+dir = {"L": [-1,0], "R": [1,0], "U": [0,-1], "D": [0,1]}
+
+# f = open('test.txt', 'r')
+f = open('input.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+
+current_pos = [0,0]
+positions = []
+positions.append(current_pos)
+extra = 1
+turtle.setpos(*current_pos)
+for line in lines:
+    parts = line.split(" ")
+    new_dir = dir[parts[0]]
+    current_pos = [current_pos[0] + int(parts[1])*new_dir[0], current_pos[1] + int(parts[1])*new_dir[1]]
+    positions.append(current_pos)
+    if parts[0] == "R" or parts[0] == "U":
+        extra += int(parts[1])
+    print(current_pos)
+    color_array = []
+    color_raw = parts[2].strip("(#)")
+    for i in range(3):
+        color_array.append(int(color_raw[i*2:i*2+2], 16))
+    # print(color_array)
+    # turtle.color(*color_array)
+    # turtle.goto(*current_pos)
+    print(parts)
+
+pos_np = np.array(positions)
+w = np.max(pos_np[:,0]) - np.min(pos_np[:,0])
+h = np.max(pos_np[:,1]) - np.min(pos_np[:,1])
+pos_np = pos_np-np.array([np.min(pos_np[:,0]), np.min(pos_np[:,1])])
+print(pos_np)
+grid = np.zeros((w+1,h+1))
+for pos_idx in range(1,len(pos_np)):
+    max_x = max(pos_np[pos_idx][0], pos_np[pos_idx-1][0])
+    min_x = min(pos_np[pos_idx][0], pos_np[pos_idx-1][0])
+    max_y = max(pos_np[pos_idx][1], pos_np[pos_idx-1][1])
+    min_y = min(pos_np[pos_idx][1], pos_np[pos_idx-1][1])
+    # grid[min_x:max_x+1,min_y:max_y+1]= 1
+    sign = 1 if pos_np[pos_idx][0] - pos_np[pos_idx-1][0] >= 0 else -1
+    # grid[min_x:max_x+1,min_y:max_y+1]= sign
+    if max_y - min_y == 0:
+        grid[min_x:max_x+1,min_y:max_y+1]= sign
+    else:
+        grid[min_x:max_x+1,min_y+1:max_y]= 1
+        # grid[min_x:max_x+1,max_y-1]= 1
+print(grid)
+from matplotlib import pyplot as plt
+plt.imshow(grid)
+plt.show()
+print(grid.sum())
+
+
+for row in range(len(grid)):
+    inside = False
+    for col in range(len(grid[0])):
+        if grid[row][col] == 1:
+            inside = True
+        elif grid[row][col] == -1:
+            inside = False
+            grid[row][col] = 1
+        else:
+            if inside:
+                grid[row][col] = 1
+
+# grid[0][0] = -1
+# for row in range(len(grid)):
+#     max_x = min(row+1, len(grid)-1)
+#     min_x = max(row-1, 0)
+#     inside = False
+#     for col in range(len(grid[0])):
+#         if grid[row][col] != 1:
+#             max_y = min(col+1, len(grid)-1)
+#             min_y = max(col-1, 0)
+#             grid[row][col] = np.min(grid[min_x:max_x+1,min_y:max_y+1])
+        
+                
+plt.imshow(grid)
+plt.show()
+# turtle.done()
+f.close()
+
+print(grid.sum())
+
+x=pos_np[:,0]
+y=pos_np[:,1]
+i=np.arange(len(x))
+
+def calc_area(points):
+    a = 0
+    for i in range(1, len(points)):
+        temp = points[i]-points[i-1]
+        # prinet(temp)
+        a += temp[0]*points[i][1]#*temp[1]
+        
+        # if temp[0] == 0:
+        #     a += np.abs(temp[1])*points[i][0]#*temp[1]
+        # else:
+        #     a += np.abs(temp[0])*points[i][1]#*temp[1]
+
+    return a
+
+Area = calc_area(pos_np)
+print(Area)
+
+x=pos_np[:,0]
+y=pos_np[:,1]
+i=np.arange(len(x))
+
+Area=np.abs(np.sum((x[i-1])*(y[i])-(x[i])*(y[i-1]))*0.5) 
+print(Area+extra)

2023/day18/part_two.py

@@ -0,0 +1,71 @@
+import re
+from tracemalloc import start
+import numpy as np
+import turtle
+
+# wn = turtle.Screen()
+# wn.bgcolor("light green")
+# wn.title("Turtle")
+# skk = turtle.Turtle()
+# wn.colormode(255)
+
+
+dir = {2: [-1,0], 0: [1,0], 3: [0,-1], 1: [0,1]}
+adders = {2: 0, 0: 0, 3: 0, 1: 0}
+extra = 1
+
+def polygon_area(points):  
+    """Return the area of the polygon whose vertices are given by the
+    sequence points.
+
+    """
+    area = 0
+    q = points[-1]
+    for p in points:  
+        area += (p[0] * q[1] - p[1] * q[0])/2
+        q = p
+    return area
+
+# f = open('test.txt', 'r')
+f = open('input.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+
+current_pos = [0,0]
+positions = []
+positions.append(current_pos)
+turtle.setpos(*current_pos)
+
+for line in lines:
+    parts = line.split(" ")
+    color_raw = parts[2].strip("(#)")
+    new_dir = dir[int(color_raw[-1])]
+    mult = int(color_raw[0:-1], 16)
+    # adder = 0 if int(color_raw[-1]) <= 1 else 1
+    adder = adders[int(color_raw[-1])]
+    current_pos = [current_pos[0] + (mult+adder)*new_dir[0], current_pos[1] + (mult+adder)*new_dir[1]]
+    if int(color_raw[-1]) == 0 or int(color_raw[-1]) == 3:
+        extra += int(color_raw[0:-1], 16)
+    positions.append(current_pos)
+    print(current_pos)
+    color_array = []
+    for i in range(3):
+        color_array.append(int(color_raw[i*2:i*2+2], 16))
+    # print(color_array)
+    # turtle.color(*color_array)
+    # turtle.goto(*current_pos)
+    print(parts)
+    
+pos_np = np.array(positions, dtype = np.float64)
+# pos_np = pos_np-np.array([np.min(pos_np[:,0]), np.min(pos_np[:,1])])
+print(polygon_area(pos_np))
+
+x=pos_np[:,0]
+y=pos_np[:,1]
+i=np.arange(len(x))
+
+Area=np.abs(np.sum((x[i-1])*(y[i])-(x[i])*(y[i-1]))*0.5) 
+print(Area)
+w = np.max(pos_np[:,0]) - np.min(pos_np[:,0])
+h = np.max(pos_np[:,1]) - np.min(pos_np[:,1])
+print(Area+extra)

2023/day18/rust/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libmath = "0.2.1"
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day18/rust/src/part_one.rs

@@ -0,0 +1,149 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+struct Node{
+    straights: u8,
+    heat: u32,
+    location: (isize, isize),
+    direction: (isize, isize),
+    path: Vec<(isize, isize)>,
+}
+
+
+fn check_bound(x: isize , y: isize, max_x: isize, max_y: isize) -> bool {
+    return !(x >= max_x || x < 0 || y >= max_y || y < 0);
+}
+
+fn check_finished(nodes: &Vec<Node>, max_x: isize, max_y: isize) -> bool {
+    let mut min_node = std::u32::MAX;
+    let mut min_idx = 0;
+    for count in 0..nodes.len() {
+        if nodes[count].heat < min_node {
+            min_node = nodes[count].heat;
+            min_idx = count;
+        }
+    }
+    println!("heat {}", nodes[min_idx].heat);
+    println!("num_nodes {}", nodes.len());
+    println!("locs {} {}", nodes[min_idx].location.0, nodes[min_idx].location.1);
+    println!("path {:?}", nodes[min_idx].path);
+    return nodes[min_idx].location.0 == max_x-1 && nodes[min_idx].location.1 == max_y-1;
+
+}
+
+fn loc_not_in_locs(loc: Node, locs: &Vec<Node>) -> bool{
+    for current_loc in locs{
+        if (loc.location.0 == current_loc.location.0 && loc.location.1 == current_loc.location.1 && loc.direction.0 == current_loc.direction.0 && loc.direction.1 == current_loc.direction.1 && loc.straights == current_loc.straights && loc.heat >= current_loc.heat)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+fn take_step(map: &Vec<Vec<u32>>,  nodes: &mut Vec<Node>, visited_loc: &mut Vec<Node>) {
+    let mut min_node = std::u32::MAX;
+    let nodes_len = nodes.len();
+    let mut min_idx = 0;
+    for count in 0..nodes.len() {
+        if nodes[count].heat < min_node {
+            min_node = nodes[count].heat;
+            min_idx = count;
+        }
+    }
+
+
+    // Add a straight to the list
+    if nodes[min_idx].straights < 2{
+        let new_loc = (nodes[min_idx].location.0 + nodes[min_idx].direction.0, nodes[min_idx].location.1 + nodes[min_idx].direction.1);
+        if check_bound(new_loc.0, new_loc.1, map[0].len().try_into().unwrap(), map.len().try_into().unwrap())
+        {
+            let new_dir = nodes[min_idx].direction;
+            let new_heat = nodes[min_idx].heat + map[(new_loc.0) as usize][(new_loc.1) as usize];
+            let straight = nodes[min_idx].straights + 1;
+            let mut new_path = nodes[min_idx].path.clone();
+            new_path.push(nodes[min_idx].location);
+            let new_node: Node = {Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: new_path}};
+            if loc_not_in_locs({Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: vec![]}}, &visited_loc){
+                // println!("Adding {:?}", new_node.location);
+                visited_loc.push({Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: vec![]}});
+                nodes.push(new_node);
+            }
+        }
+    }
+
+    // Add a turn left and right
+    for i in [-1, 1]{
+        // println!("{}", i);
+        let new_dir = (i * nodes[min_idx].direction.1, i * nodes[min_idx].direction.0);
+        let new_loc = (nodes[min_idx].location.0 + new_dir.0, nodes[min_idx].location.1 + new_dir.1);
+        if check_bound(new_loc.0, new_loc.1, map[0].len().try_into().unwrap(), map.len().try_into().unwrap())
+        {
+            let new_heat = nodes[min_idx].heat + map[(new_loc.0) as usize][(new_loc.1) as usize];
+            let straight = 0;
+            let mut new_path = nodes[min_idx].path.clone();
+            new_path.push(nodes[min_idx].location);
+            let new_node: Node = {Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: new_path}};
+            if loc_not_in_locs({Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: vec![]}}, &visited_loc){
+                // println!("Adding {:?}", new_node.location);
+                visited_loc.push({Node { straights: straight, heat: new_heat, location: new_loc, direction: new_dir, path: vec![]}});
+                nodes.push(new_node);
+            }
+        }
+    }
+    let n_loc = nodes[min_idx].location;
+    let n_s = nodes[min_idx].straights;
+    let n_dir = nodes[min_idx].direction;
+    let n_heat = nodes[min_idx].heat;
+    // visited_loc.push({Node { straights: n_s, heat: n_heat, location: n_loc, direction: n_dir, path: vec![]}});
+    // if nodes[min_idx].path.len() > 3{
+        // let purge_location = nodes[min_idx].path[nodes[min_idx].path.len()-3-1];
+        // nodes.remove(min_idx);
+        for i in (0..nodes.len()).rev(){
+            if nodes[i].location.0 == n_loc.0 && nodes[i].location.1 == n_loc.1 && nodes[i].straights == n_s && nodes[i].direction.0 == n_dir.0 && nodes[i].direction.1 == n_dir.1 && nodes[i].heat >= n_heat{
+                // println!("REMOVING {:?}", nodes[i].location);
+                nodes.remove(i);
+            }
+        }
+    // }
+    // else{
+    // nodes.remove(min_idx);
+
+    // }
+    // println!("REMOVING {:?}", nodes[min_idx].location);
+
+    // return nodes;
+}
+
+fn process_line(map: &Vec<Vec<u32>> ) -> i64 {
+    let mut nodes: Vec<Node> = vec![];
+    let mut visited_locs: Vec<Node> = vec![];
+    let mut finished = false;
+    nodes.push(Node { straights: 0, heat: 0, location: (0, 0), direction: (1, 0), path: vec![]});
+    while !finished {
+        take_step(&map, &mut nodes, &mut visited_locs);
+        finished = check_finished(&nodes, map[0].len().try_into().unwrap(), map.len().try_into().unwrap());
+    }
+
+    // let numbers = find_numbers(&line);
+    return 0;
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum = 0;
+    let mut map: Vec<Vec<u32>> = vec![];
+    // let file = File::open("../test.txt")?;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        map.push(line?.to_string().chars().map(|m| m.to_digit(10).unwrap()).collect());
+    }
+
+    sum = process_line(&map);
+    // println!("{map:?}");
+    // println!("{}", sum);
+
+    Ok(())
+}

2023/day19/part_one.py

@@ -0,0 +1,79 @@
+from dis import Instruction
+import re
+from tabnanny import check
+import numpy as np
+
+
+f = open('input.txt', 'r')
+# f = open('test.txt', 'r')
+content = f.read()
+# lines = content.splitlines()
+paragraphs = content.split("\n\n")
+sum = 0
+
+flows =  {}
+
+print(paragraphs[0].split("\n")[0].split('{')[1].strip("}"))
+for workflow in paragraphs[0].split("\n"):
+    sub_workflow = workflow.split('{')
+    name = sub_workflow[0]
+    instructions = sub_workflow[1].strip("}").split(",")
+    # print(instructions)
+    inst_list = []
+    for a in instructions:
+        if_stat = a.split(":")
+        logic = []
+        for ch in ["<", ">"]:
+            if ch in if_stat[0]:
+                temp = if_stat[0].split(ch)
+                logic = [temp[0], ch, int(temp[1])]
+                break
+        # inst
+        inst_list.append(logic+[if_stat[-1]])
+    print(inst_list)
+
+
+    flows[name] = inst_list
+
+vals = []
+
+for val in paragraphs[1].split("\n"):
+    current_val = {}
+    for i in val.strip("{}").split(","):
+        x = i.split("=")
+        print(x)
+        current_val[x[0]] = int(x[1])
+    vals.append(current_val)
+
+print(vals)
+
+
+print(flows)
+
+sum = 0
+
+for val in vals:
+    key = "in"
+    while key != "A" and key != "R":
+        print(key)
+        for inst in flows[key]:
+            # pass
+            if len(inst) == 1:
+                key = inst[-1]
+                break
+            else:
+                eq0 = val[inst[0]] if inst[1] == "<" else inst[2]
+                eq1 = val[inst[0]] if inst[1] == ">" else inst[2]
+
+                if eq0 < eq1:
+                    key = inst[-1] 
+                    break
+                else:
+                    continue
+
+    if key == "A":
+        sum += val["x"]+val["m"]+val["a"]+val["s"]
+
+print(sum)
+
+f.close()

2023/day19/part_two.py

@@ -0,0 +1,104 @@
+from dis import Instruction
+import re
+from tabnanny import check
+import numpy as np
+import copy
+
+file = open('input.txt', 'r')
+# file = open('test.txt', 'r')
+content = file.read()
+# lines = content.splitlines()
+paragraphs = content.split("\n\n")
+sum = 0
+
+flows =  {}
+
+print(paragraphs[0].split("\n")[0].split('{')[1].strip("}"))
+for workflow in paragraphs[0].split("\n"):
+    sub_workflow = workflow.split('{')
+    name = sub_workflow[0]
+    instructions = sub_workflow[1].strip("}").split(",")
+    # print(instructions)
+    inst_list = []
+    for a in instructions:
+        if_stat = a.split(":")
+        logic = []
+        for ch in ["<", ">"]:
+            if ch in if_stat[0]:
+                temp = if_stat[0].split(ch)
+                logic = [temp[0], ch, int(temp[1])]
+                break
+        # inst
+        inst_list.append(logic+[if_stat[-1]])
+    print(inst_list)
+
+
+    flows[name] = inst_list
+
+vals = []
+
+for val in paragraphs[1].split("\n"):
+    current_val = {}
+    for i in val.strip("{}").split(","):
+        x = i.split("=")
+        print(x)
+        current_val[x[0]] = int(x[1])
+    vals.append(current_val)
+
+print(vals)
+
+
+print(flows)
+
+sum = 0
+
+Possible = {
+    "x": {"min": 1, "max":4000},
+    "m": {"min": 1, "max":4000},
+    "a": {"min": 1, "max":4000},
+    "s": {"min": 1, "max":4000},
+    "keys": [],
+}
+
+total_list = []
+
+def f(key, possible_in):
+    
+    possible = copy.deepcopy(possible_in)
+    possible["keys"].append(key)
+    if key == "A":
+        total_list.append(possible)
+    elif key != "R":
+        for inst in flows[key]:
+            new_possible = copy.deepcopy(possible)
+            if len(inst) == 1:
+                f(inst[-1], possible)
+                break
+            else:
+                if inst[1] == "<":
+                    new_possible[inst[0]]["max"] = min(inst[2]-1, new_possible[inst[0]]["max"])
+                    f(inst[-1], new_possible)
+                    possible[inst[0]]["min"] = max(inst[2], possible[inst[0]]["min"])
+                elif inst[1] == ">":
+                    new_possible[inst[0]]["min"] = max(inst[2]+1, new_possible[inst[0]]["min"])
+                    f(inst[-1], new_possible)
+                    possible[inst[0]]["max"] = min(inst[2], possible[inst[0]]["max"])
+                else:
+                    print("PANIC!")
+
+
+
+key = "in"
+f(key, Possible)
+
+print(total_list)
+
+for entry in total_list:
+    temp = 1
+    for ch in ['x', 'm', 'a', 's']:
+        temp *= max(0, entry[ch]["max"]-entry[ch]["min"]+1)
+    sum += temp
+
+print(sum)
+
+file.close()

2023/day2/rust/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day2/rust/src/part_one.rs

@@ -0,0 +1,50 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use regex::Regex;
+
+fn get_number(line: &str) -> u32 {
+    let re = Regex::new(r"\d+").unwrap();
+    let num: u32 = re.find(line).unwrap().as_str().parse().unwrap();
+    return num;
+}
+
+static POSSIBLE_CUBES: [(&str, u32); 3] = [("red", 12), ("blue", 14), ("green", 13)];
+
+fn process_line(line: String) -> u32 {
+    let parts = line.split(&[':']).collect::<Vec<&str>>();
+    let game_number: u32 = get_number(parts[0]);
+    // Parts is a vector of strings? where the first index will be the game
+    // and all consecutive indeces will be the game "sets"
+    let sets = parts[1].split(&[';']);
+    for set in sets {
+        let colors = set.split(", ");
+        for color in colors {
+            let mut found = false; // flag to sanity check, and make sure that all colors are ones that we expect
+            for pos in POSSIBLE_CUBES {
+                if color.contains(pos.0) {
+                    found = true;
+                    if pos.1 < get_number(color) {
+                        return 0;
+                    }
+                }
+            }
+            if found != true {
+                println!("{} was present in Game {}", color, game_number);
+                return 0;
+            }
+        }
+    }
+    return game_number;
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum: u32 = 0;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        sum = process_line(line?) + sum;
+    }
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day2/rust/src/part_two.rs

@@ -0,0 +1,46 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use regex::Regex;
+
+fn get_number(line: &str) -> u32 {
+    let re = Regex::new(r"\d+").unwrap();
+    let num: u32 = re.find(line).unwrap().as_str().parse().unwrap();
+    return num;
+}
+
+
+fn process_line(line: String) -> u32 {
+    let parts = line.split(&[':']).collect::<Vec<&str>>();
+    // Parts is a vector of strings? where the first index will be the game
+    // and all consecutive indeces will be the game "sets"
+    let possible_colors = ["red", "blue", "green"];
+    let mut color_max = [0, 0, 0];
+    let sets = parts[1].split(&[';']);
+    for set in sets {
+        let colors = set.split(", ");
+        for color in colors {
+            for idx in 0..3 {
+                if color.contains(possible_colors[idx]) {
+                    if color_max[idx] < get_number(color) {
+                        color_max[idx] = get_number(color);
+                    }
+                }
+            }
+        }
+    }
+    
+    return color_max[0] * color_max[1] * color_max[2];
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum: u32 = 0;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        sum = process_line(line?) + sum;
+    }
+    // Print text to the console.
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day20/part_one.py

@@ -0,0 +1,82 @@
+import copy
+
+
+f = open('input.txt', 'r')
+# f = open('test.txt', 'r')
+# f = open('test2.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+modules =  {}
+
+for line in lines:
+    parts = line.split(" -> ")
+    outputs = parts[1].replace(" ", "").split(",")
+    
+    if "%" == parts[0][0]:
+        modules[parts[0][1:]] = {"type": parts[0][0], "state": False, "outputs": outputs}
+    elif "&" == parts[0][0]:
+        modules[parts[0][1:]] = {"type": parts[0][0], "in_states": {}, "outputs": outputs}
+    else:
+        modules[parts[0]] = {"type": "", "outputs": outputs}
+
+for mod in modules:
+    for i in modules[mod]["outputs"]:
+        if i in modules and modules[i]["type"] == "&":
+            modules[i]["in_states"][mod] = False
+
+ins = [{"too": "broadcaster", "from": "button", "signal": "low"}]
+outs = []
+
+low_pulses = 0
+high_pulses = 0
+
+for button_presses in range(1000000):
+    ins = [{"too": "broadcaster", "from": "button", "signal": "low"}]
+    while len(ins) != 0:
+        # print(ins)
+        # print(modules)
+        outs = []
+        for line in ins:
+            if line["signal"] == "low":
+                low_pulses += 1
+            elif line["signal"] == "high":
+                high_pulses += 1
+                
+            if line["too"] == "rx" and line["signal"] == "low":
+                out = []
+                print(button_presses)
+                break
+                
+            if line["too"] not in modules: continue
+            
+            if modules[line["too"]]["type"] == "":
+                for out in modules[line["too"]]["outputs"]:
+                    outs.append({"too": out, "from": line["too"], "signal": line["signal"]})
+                    
+            elif modules[line["too"]]["type"] == "%":
+                if line["signal"] == "low":
+                    modules[line["too"]]["state"] = not modules[line["too"]]["state"]
+                    sig = "high" if modules[line["too"]]["state"] else "low"
+                    for out in modules[line["too"]]["outputs"]:
+                        outs.append({"too": out, "from": line["too"], "signal": sig})
+            
+            elif modules[line["too"]]["type"] == "&":
+                modules[line["too"]]["in_states"][line["from"]] = line["signal"] == "high"
+                all_states_high = True
+                for state in modules[line["too"]]["in_states"]:
+                    if modules[line["too"]]["in_states"][state] != True:
+                        all_states_high = False
+                        break
+                sig = "low" if all_states_high else "high"
+                for out in modules[line["too"]]["outputs"]:
+                    outs.append({"too": out, "from": line["too"], "signal": sig})
+        ins = copy.deepcopy(outs)
+                    
+        
+
+
+
+print(low_pulses*high_pulses)
+print(low_pulses, high_pulses)
+
+f.close()

2023/day20/part_two.py

@@ -0,0 +1,147 @@
+import copy
+import math
+
+f = open('input.txt', 'r')
+# f = open('test.txt', 'r')
+# f = open('test2.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+modules =  {}
+
+for line in lines:
+    parts = line.split(" -> ")
+    outputs = parts[1].replace(" ", "").split(",")
+    
+    if "%" == parts[0][0]:
+        modules[parts[0][1:]] = {"inputs": [], "type": parts[0][0], "state": False, "outputs": outputs}
+    elif "&" == parts[0][0]:
+        modules[parts[0][1:]] = {"inputs": [], "type": parts[0][0], "in_states": {}, "outputs": outputs}
+    else:
+        modules[parts[0]] = {"inputs": [], "type": "", "outputs": outputs}
+keys = list(modules.keys())
+for mod in keys:
+    for i in modules[mod]["outputs"]:
+        if i in modules:
+            if modules[i]["type"] == "&":
+                modules[i]["in_states"][mod] = False
+        
+            modules[i]["inputs"].append(mod)
+        else:
+            modules[i] = {"inputs": [mod], "type": "output"}
+
+ins = [{"too": "broadcaster", "from": "button", "signal": "low"}]
+outs = []
+
+
+# def rec_fun(key, mod_state):
+#     number = 0
+#     if "broadcaster" == key:
+#         return 1
+    
+#     for inputs in mod_state[key]["inputs"]:
+#         num_presses = rec_fun(inputs, mod_state)
+        
+#         for button_presses in range(num_presses):
+#             ins = [{"too": "broadcaster", "from": "button", "signal": "low"}]
+#             while len(ins) != 0:
+#                 # print(ins)
+#                 # print(modules)
+#                 outs = []
+#                 for line in ins:
+#                     if line["signal"] == "low":
+#                         low_pulses += 1
+#                     elif line["signal"] == "high":
+#                         high_pulses += 1
+                        
+#                     if line["too"] == "rx" and line["signal"] == "low":
+#                         out = []
+#                         print(button_presses)
+#                         break
+                        
+#                     if line["too"] not in modules: continue
+                    
+#                     if modules[line["too"]]["type"] == "":
+#                         for out in modules[line["too"]]["outputs"]:
+#                             outs.append({"too": out, "from": line["too"], "signal": line["signal"]})
+                            
+#                     elif modules[line["too"]]["type"] == "%":
+#                         if line["signal"] == "low":
+#                             modules[line["too"]]["state"] = not modules[line["too"]]["state"]
+#                             sig = "high" if modules[line["too"]]["state"] else "low"
+#                             for out in modules[line["too"]]["outputs"]:
+#                                 outs.append({"too": out, "from": line["too"], "signal": sig})
+                    
+#                     elif modules[line["too"]]["type"] == "&":
+#                         modules[line["too"]]["in_states"][line["from"]] = line["signal"] == "high"
+#                         all_states_high = True
+#                         for state in modules[line["too"]]["in_states"]:
+#                             if modules[line["too"]]["in_states"][state] != True:
+#                                 all_states_high = False
+#                                 break
+#                         sig = "low" if all_states_high else "high"
+#                         for out in modules[line["too"]]["outputs"]:
+#                             outs.append({"too": out, "from": line["too"], "signal": sig})
+#                 ins = copy.deepcopy(outs)
+#     return 0
+        
+done = False
+# rec_fun("rx", modules)
+last_ins = []
+lcm_list = []
+for button_presses in range(1, 100000):
+    # print(last_ins)
+    ins = [{"too": "broadcaster", "from": "button", "signal": "low"}]
+    while len(ins) != 0:
+        # print(modules)
+        # print(ins)
+        outs = []
+        for line in ins:
+            if line["too"] == "rx" and line["signal"] == "low":
+                outs = []
+                done = True
+                print(button_presses)
+                break
+            
+            
+            # if line["too"] == "hp" and line["from"] == "rf" and line["signal"] == "high":
+            # if line["too"] == "hp" and line["from"] == "vq" and line["signal"] == "high":
+            if line["too"] == "hp" and line["signal"] == "high":
+            # if line["too"] == "hp" and line["from"] == "sn" and line["signal"] == "high":
+                outs = []
+                lcm_list.append(button_presses)
+                if len(lcm_list) == len(modules["hp"]["inputs"]):
+                    done = True
+                # break
+                
+            if line["too"] not in modules: continue
+            
+            if modules[line["too"]]["type"] == "":
+                for out in modules[line["too"]]["outputs"]:
+                    outs.append({"too": out, "from": line["too"], "signal": line["signal"]})
+                    
+            elif modules[line["too"]]["type"] == "%":
+                if line["signal"] == "low":
+                    modules[line["too"]]["state"] = not modules[line["too"]]["state"]
+                    sig = "high" if modules[line["too"]]["state"] else "low"
+                    for out in modules[line["too"]]["outputs"]:
+                        outs.append({"too": out, "from": line["too"], "signal": sig})
+            
+            elif modules[line["too"]]["type"] == "&":
+                modules[line["too"]]["in_states"][line["from"]] = line["signal"] == "high"
+                all_states_high = True
+                for state in modules[line["too"]]["in_states"]:
+                    if modules[line["too"]]["in_states"][state] != True:
+                        all_states_high = False
+                        break
+                sig = "low" if all_states_high else "high"
+                for out in modules[line["too"]]["outputs"]:
+                    outs.append({"too": out, "from": line["too"], "signal": sig})
+        last_ins = copy.deepcopy(ins)
+        ins = copy.deepcopy(outs)
+                    
+    if done:
+        break
+
+print(math.lcm(*lcm_list))
+
+f.close()

2023/day20/rust/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libmath = "0.2.1"
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day20/rust/src/part_one.rs

@@ -0,0 +1,47 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+enum ModuleType {
+    FlipFlop,
+    Conjunction,
+}
+
+struct Module {
+    kind: ModuleType,
+    states: Vec<bool>,
+    outputs: Vec<String>,
+}
+
+
+fn process_text(wall_of_text: Vec<String>) -> u32 { 
+    let mut modules:   Vec<Module> = vec![];
+    for line in wall_of_text{
+        let res = line.split(" -> ").collect::<Vec<&str>>();
+        println!("{:?}", res);
+        if res[0].get(0..1).unwrap() == "%" {
+            println!("%");
+            modules.push(Module { kind: ModuleType::FlipFlop, states: [true].to_vec(), outputs: vec![] });
+        }
+        else if res[0].get(0..1).unwrap() == "&" {
+            let temp_module = Module { kind: ModuleType::Conjunction, states: vec![], outputs: vec![] };
+            println!("{:?}", temp_module.states);
+            modules.push(temp_module);
+            println!("&");
+        }
+    }
+    return 0;
+}
+
+fn main() -> io::Result<()>  {
+    let file = File::open("../test.txt")?;
+    // let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer: u32 = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day21/main.py

@@ -0,0 +1,43 @@
+from dis import Instruction
+import re
+from tabnanny import check
+import numpy as np
+
+
+f = open('input.txt', 'r')
+# f = open('test.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+
+S_location = (0, 0)
+for count, line in enumerate(lines):
+    for ch in range(len(line)):
+        if line[ch] == "S":
+            S_location = (count, ch)
+            break
+    if S_location != (0, 0):
+        break
+
+locations = set()
+locations.add((S_location))
+
+for i in range(500):
+    new_set = set()
+    print(locations)
+    for loc in locations:
+        for index in [0, 1]:
+            for offset in [-1, 1]:
+                if loc[index]+offset >= 0 and loc[index]+offset < len(lines[0]):
+                    location = list(loc)
+                    location[index] += offset
+                    if lines[location[0]][location[1]] != "#":
+                        new_set.add(tuple(location))
+    locations = new_set.copy()
+
+
+print(len(locations))
+
+
+print(S_location)
+
+f.close()

2023/day21/part_two.py

@@ -0,0 +1,211 @@
+from dis import Instruction
+from hashlib import blake2b
+import re
+from tabnanny import check
+import numpy as np
+import sys
+
+
+# f = open('input.txt', 'r')
+# f = open('test.txt', 'r')
+f = open('test2.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+
+S_location = (0, 0)
+for count, line in enumerate(lines):
+    for ch in range(len(line)):
+        if line[ch] == "S":
+            S_location = (count, ch)
+            break
+    if S_location != (0, 0):
+        break
+
+locations = set()
+odd_set = set()
+even_set = set()
+locations.add((S_location))
+
+def get_num_steps_to_sat(loc_set, num_steps, tiles):
+    bleed_over_points = [[]]*4
+    second_to_last_count = len(loc_set)
+    last_count = len(loc_set)
+    # if list(loc_set)[0][0] == 0:
+    #     bleed_over_points[0] = [None]
+    # if list(loc_set)[0][1] == 0:
+    #     bleed_over_points[2] = [None]
+    # if list(loc_set)[0][0] >= len(lines[0]):
+    #     bleed_over_points[1] = [None]
+    # if list(loc_set)[0][1] >= len(lines[0]):
+    #     bleed_over_points[3] = [None]
+    count = 0
+    while count < num_steps:
+        new_set = set()
+        # print(locations)
+        for loc in loc_set:
+            for index in [0, 1]:
+                for offset in [-1, 1]:
+                    location = list(loc)
+                    new_tile = list(tiles)
+                    add = (offset + location[index]) / len(lines)
+                    if add < 0:
+                        add = -1
+                    elif add > 1:
+                        add = 1
+                    new_tile[index] += add
+                    location[index] = (offset + location[index])%len(lines)
+                    if loc[index]+offset >= 0:
+                        if loc[index]+offset < len(lines[0]):
+                            if lines[location[0]][location[1]] != "#":
+                                new_set.add(tuple(location))
+                        else:
+                            # if len(bleed_over_points[index*2 + 1]) == 0:
+                            bleed_over_points[index*2 + 1][location, count+1, tuple(new_tile)]
+                    else:
+                        # if len(bleed_over_points[index*2 + 0]) == 0:
+                        bleed_over_points[index*2 + 0] = [location, count+1, tuple(new_tile)]
+
+        
+        loc_set = new_set.copy()
+        if second_to_last_count == len(loc_set):
+            # print((second_to_last_count, last_count))
+            if (num_steps-count) % 2 == 0:
+                return count, bleed_over_points, last_count
+            else: 
+                return count, bleed_over_points, second_to_last_count
+        
+        count += 1
+        second_to_last_count = last_count
+        last_count = len(loc_set)
+    return 0, bleed_over_points, len(loc_set)
+        
+def get_positions(loc_set, num_steps, tiles):
+    bleed_over_points = [[]]*4
+    second_to_last_count = len(loc_set)
+    if list(loc_set)[0][0] == 0:
+        bleed_over_points[0] = [None]
+    if list(loc_set)[0][1] == 0:
+        bleed_over_points[2] = [None]
+    if list(loc_set)[0][0] >= len(lines[0]):
+        bleed_over_points[1] = [None]
+    if list(loc_set)[0][1] >= len(lines[0]):
+        bleed_over_points[3] = [None]
+    last_count = len(loc_set)
+    count = 1
+    while count < num_steps:
+        new_set = set()
+        # print(locations)
+        for loc in loc_set:
+            for index in [0, 1]:
+                for offset in [-1, 1]:
+                    location = list(loc)
+                    location[index] = (offset + location[index])%len(lines)
+                    new_tile = list(tiles)
+                    new_tile[index] += int((offset + location[index])/len(lines))
+                    if loc[index]+offset >= 0:
+                        if loc[index]+offset < len(lines[0]):
+                            if lines[location[0]][location[1]] != "#":
+                                new_set.add(tuple(location))
+                        else:
+                            bleed_over_points[index*2 + 1] = [*location, count, tuple(new_tile)]
+                    else:
+                        bleed_over_points[index*2 + 0] = [*location, count, tuple(new_tile)]
+
+        
+        loc_set = new_set.copy()
+        if second_to_last_count == len(loc_set):
+            if (num_steps-count) % 2 == 0:
+                return last_count
+            else: 
+                return second_to_last_count
+        
+        count += 1
+        second_to_last_count = last_count
+        last_count = len(loc_set)
+        
+    return len(loc_set)
+
+starting_set = set()
+
+# for i in range(2650):
+#     new_set = set()
+#     print(len(locations))
+#     for loc in locations:
+#         for index in [0, 1]:
+#             for offset in [-1, 1]:
+#                 location = list(loc)
+#                 location[index] += offset
+#                 set_of_int = even_set if i%2 == 0 else odd_set
+#                 # if tuple(location) not in set_of_int and lines[location[0]%len(lines)][location[1]%len(lines[0])] != "#":
+#                     set_of_int.add(tuple(location))
+#                     new_set.add(tuple(location))
+#     locations = new_set.copy()
+
+
+# 
+# print(get_num_steps_to_sat(locations))
+
+# for starting_loc in ((0,0),(0,len(lines)-1),(len(lines[0])-1,0),(len(lines[0])-1,len(lines)-1)):
+#     locations = set()
+#     locations.add(starting_loc)
+#     print(get_num_steps_to_sat(locations))
+
+# for starting_loc in ((0,S_location[1]),(len(lines)-1,S_location[1]),(S_location[0],0),(S_location[0],len(lines[0])-1)):
+#     locations = set()
+#     locations.add(starting_loc)
+#     print(get_num_steps_to_sat(locations))
+
+
+print(S_location)
+starting_set = set()
+starting_set.add(S_location)
+
+starting_points = set()
+starting_points.add(S_location)
+
+tile_set = set()
+tile_set.add((0,0))
+
+print(get_num_steps_to_sat(starting_points, 16, (0,0)))
+
+sys.setrecursionlimit(10**6)
+
+def rec_fun(set_of_interest, num, tile):
+    sum = 0
+    _, bleed_overs, count = get_num_steps_to_sat(set_of_interest, num, tile)
+    print("bleed over", bleed_overs)
+    print("count", count)
+    sum += count
+    # print(bleed_overs)
+    for point in bleed_overs:
+        if len(point) > 0 and point[2] not in tile_set:
+            print(point)
+            tile_set.add(point[2])
+            new_set = set()
+            new_set.add(tuple(point[0]))
+            
+            sum += rec_fun(new_set, num-point[1], point[2])
+        
+    return sum
+            
+
+print(rec_fun(starting_points, 500, (0,0)))
+# for i in starting_set:
+#     sat_num, bleed_overs = get_num_steps_to_sat(locations)
+#     for point in bleed_overs:
+
+
+# for starting_loc in ((0,0),(0,len(lines)-1),(len(lines[0])-1,0),(len(lines[0])-1,len(lines)-1)):
+#     locations = set()
+#     locations.add(starting_loc)
+#     print(get_num_steps_to_sat(locations, 500))
+
+# for starting_loc in ((0,S_location[1]),(len(lines)-1,S_location[1]),(S_location[0],0),(S_location[0],len(lines[0])-1)):
+#     locations = set()
+#     locations.add(starting_loc)
+#     print(get_num_steps_to_sat(locations, 500))
+
+
+# print(S_location)
+
+f.close()

2023/day22/main.py

@@ -0,0 +1,146 @@
+from dis import Instruction
+import re
+from tabnanny import check
+import numpy as np
+
+
+f = open('input.txt', 'r')
+# f = open('test.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+blocks = []
+
+for line in lines:
+    temp = line.split("~")
+    start_coor = [int(x) for x in temp[0].split(",")]
+    end_coor = [int(x) for x in temp[1].split(",")]
+    mismatch_count = 0
+    for i in range(3):
+        if start_coor[i] != end_coor[i]:
+            mismatch_count += 1
+    if mismatch_count > 1:
+        print(mismatch_count)
+    blocks.append([start_coor, end_coor])
+    
+blocks.sort(key = lambda x: x[0][2])
+
+def move_down_until_collision(i, j, blocks):
+    collide = True
+    for k in range(2):
+        min_i = min(blocks[i][0][k], blocks[i][1][k])
+        max_i = max(blocks[i][0][k], blocks[i][1][k])
+        min_j = min(blocks[j][0][k], blocks[j][1][k])
+        max_j = max(blocks[j][0][k], blocks[j][1][k])
+        
+        
+        # # for cur_blocks in [min_i, max_i]:
+        # for other_blocks in [min_j, max_j]:
+        #     if other_blocks < min_i or other_blocks > max_i:
+        #         print(f"no_collision between {i} and {j}")
+        #         collide = False
+        #         break
+        
+
+    if collide:
+        return blocks[i][0][2] - blocks[j][1][2]
+    else:
+        return blocks[i][0][2]
+
+num_holding_up = []#[[]]*len(blocks)
+being_held_by = []#[0]*len(blocks)
+
+def intersect(line1, line2):
+    col_x = False
+    col_y = False
+    for i in range(line1[0][0], line1[1][0]+1):
+        if i >= line2[0][0] and i <= line2[1][0]:
+            col_x = True
+            break
+        
+    for i in range(line1[0][1], line1[1][1]+1):
+        if i >= line2[0][1] and i <= line2[1][1]:
+            col_y = True
+            break
+        
+    if col_x and col_y:
+        return True
+    else: 
+        return False
+
+for i in range(len(blocks)):
+    num_holding_up.append([])
+    being_held_by.append([])
+    move_z = 1
+    collide = False
+    while not collide:
+        collision_count = 0
+        for j in range(0, i):
+            if blocks[j][1][2] == blocks[i][0][2]-1:
+                # for k in range(2):
+                #     idx_j = 1 if k == 0 else 0
+                #     min_i = min(blocks[i][0][k], blocks[i][1][k])
+                #     max_i = max(blocks[i][0][k], blocks[i][1][k])
+                #     min_j = min(blocks[j][0][idx_j], blocks[j][1][idx_j])
+                #     max_j = max(blocks[j][0][idx_j], blocks[j][1][idx_j])
+                    # min_i = blocks[i][1][k]
+                    # max_i = blocks[i][0][k]
+                    # min_j = blocks[j][0][idx_j]
+                    # max_j = blocks[j][1][idx_j]
+                    # if (max_i >= min_j and  min_i < min_j) or (max_i >= max_j and min_i < max_j ) or (max_i == min_j and min_j == min_i):
+                if intersect(blocks[j], blocks[i]):
+                    num_holding_up[j].append(i)
+                    being_held_by[i].append(j)
+                    collision_count +=1
+                    collide = True
+                    # break
+                
+        print(collision_count)
+        
+        if collide or blocks[i][1][2] == 1:
+            print("Potential collision")
+            collide = True
+        else:
+            for num_blocks in range(2):
+                blocks[i][num_blocks][2] -= move_z
+        
+        
+                
+    # if i == 0:
+    #     move_z = blocks[i][0][2]
+    #     for num_blocks in range(2):
+    #         blocks[i][num_blocks][2] -= move_z
+    # else:
+    #     for j in range(0, i):
+    #         if blocks[j][1][2] == blocks[i][0][2]-1:
+    #             print("Potential collision")
+    #         # new_z = move_down_until_collision(i, j, blocks)
+    #         # print("new_z", new_z)
+            
+    #         # if new_z < move_z:
+    #         #     move_z = new_z
+    #     print(move_z)
+        
+    #     for num_blocks in range(2):
+    #         blocks[i][num_blocks][2] -= move_z
+        
+    
+print(blocks)
+print(num_holding_up)
+print(being_held_by)
+sum = 0
+
+for count, i in enumerate(num_holding_up):
+    if len(i) == 0:
+        sum+=1
+    elif len(i) > 0:
+        removable = True
+        for j in i:
+            if len(being_held_by[j]) <= 1:
+                removable = False
+                break
+        if removable:
+            print(f"{count} is removable")
+            sum+=1
+            
+print(sum)
+f.close()

2023/day3/rust/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day3/rust/src/part_one.rs

@@ -0,0 +1,91 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use regex::Regex;
+
+fn find_numbers(line: &str) -> Vec<(i32, i32)> {
+    let re = Regex::new(r"\d+").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.range()).collect();
+    let mut return_vec: Vec<(i32, i32)> = vec![];
+    for i in matches {
+        return_vec.push((i.start as i32, i.end as i32));
+        // println!("first {}, Last {}", i.start, i.end); 
+        // println!("number {}", line.get(i.start..i.end).unwrap().parse::<u32>().unwrap()); 
+    }
+    return return_vec;
+}
+
+fn find_symbol(line: &str) -> Vec<u32> {
+    let re = Regex::new(r"[^A-Za-z0-9.]").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.range()).collect();
+    let mut return_vec: Vec<u32> = vec![];
+    for i in matches {
+        return_vec.push((i.start as i32).try_into().unwrap());
+        println!("first {}, Last {}", i.start, i.end); 
+        println!("symbol {}", line.get(i.start..i.end).unwrap()); 
+    }
+    return return_vec;
+}
+
+fn clip(val: i32, min:i32, max: i32) -> usize {
+    if val < min 
+    {
+        return min.try_into().unwrap();
+    }
+    if val > max 
+    {
+        return max.try_into().unwrap();
+    }
+    return val.try_into().unwrap();
+}
+
+fn does_window_contain_symbol(coordinates: (usize, usize, usize, usize), text: &Vec<String>) -> bool
+{
+    let re = Regex::new(r"[^A-Za-z0-9.]").unwrap();
+    let mut window_string = String::new();
+    let window = &text[coordinates.0..(coordinates.2+1)];
+    for i in window 
+    {
+        let var = i.get(coordinates.1..(coordinates.3)).unwrap();
+        window_string.push_str(var);
+        // println!("{}", i);
+    }
+    println!("{}", window_string);
+    return re.is_match(&window_string);
+}
+
+
+fn process_text(wall_of_text: Vec<String>) -> u32 {
+    let mut sum: u32 = 0;
+
+    for (line_count, line) in wall_of_text.clone().into_iter().enumerate() {
+        let x = find_numbers(&line);
+        // let y = find_symbol(&line);
+        for i in x {
+            let coor = (
+                clip(i32::try_from(line_count).unwrap()-1, 0, i32::try_from(wall_of_text.len()).unwrap()-1),
+                clip(i.0-1i32, 0, i32::try_from(line.len()).unwrap()-1), 
+                clip(i32::try_from(line_count).unwrap()+1, 0, i32::try_from(wall_of_text.len()).unwrap()-1),
+                clip(i.1+1, 0, i32::try_from(line.len()).unwrap()-1),
+                );
+            let engine_part = does_window_contain_symbol(coor, &wall_of_text);
+            if engine_part 
+            {
+                sum += line.get(i.0.try_into().unwrap()..i.1.try_into().unwrap()).unwrap().parse::<u32>().unwrap();
+            }
+        }
+    }
+    // let _throw_way = does_window_contain_symbol((2,2,4,4), wall_of_text);
+    return sum;
+}
+
+fn main() -> io::Result<()>  {
+    // let file = File::open("../test.txt")?;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer: u32 = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day3/rust/src/part_two.rs

@@ -0,0 +1,124 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use regex::Regex;
+
+fn find_numbers(line: &str) -> Vec<i32> {
+    let re = Regex::new(r"\d+").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.as_str().parse::<i32>().unwrap()).collect();
+    let mut return_vec: Vec<i32> = vec![];
+    for i in matches {
+        return_vec.push(i);
+        println!("number {}", i); 
+    }
+    return return_vec;
+}
+
+fn find_gear(line: &str) -> Vec<i32> {
+    let re = Regex::new(r"[*]").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.range()).collect();
+    let mut return_vec: Vec<i32> = vec![];
+    for i in matches {
+        return_vec.push((i.start as i32).try_into().unwrap());
+        println!("first {}, Last {}", i.start, i.end); 
+        println!("symbol {}", line.get(i.start..i.end).unwrap()); 
+    }
+    return return_vec;
+}
+
+fn clip(val: i32, min:i32, max: i32) -> usize {
+    if val < min 
+    {
+        return min.try_into().unwrap();
+    }
+    if val > max 
+    {
+        return max.try_into().unwrap();
+    }
+    return val.try_into().unwrap();
+}
+
+fn get_adjacent_gears(coordinates: (usize, usize, usize, usize), text: &Vec<String>) -> (bool, i32)
+{
+    let re = Regex::new(r"[^A-Za-z0-9.]").unwrap();
+    let mut window_string = String::new();
+    let window = &text[coordinates.0..(coordinates.1+1)];
+    for i in window {
+        let mut n = coordinates.2;
+        let mut temp_string = String::new();
+        temp_string.push(i.chars().nth(n).unwrap());
+        while n > 0 {
+            n -= 1;
+            let character = i.chars().nth(n).unwrap();
+            temp_string.insert(0, character);
+            if !character.is_numeric() {
+                break;
+            }
+        }
+
+        n = coordinates.2;
+        while n < coordinates.3-1    {
+            n += 1;
+            let character = i.chars().nth(n).unwrap();
+            temp_string.push(character);
+            if !character.is_numeric() {
+                break;
+            }
+
+        }
+        
+        window_string.push_str(&temp_string);
+    
+    }
+    let number_vec = find_numbers(&window_string);
+    let gear_ratio;
+    if number_vec.len() == 2
+    {
+        gear_ratio = number_vec[0]*number_vec[1];
+    }
+    else
+    {
+        gear_ratio = 0;
+    }
+
+
+    println!("{}", window_string);
+    return (re.is_match(&window_string), gear_ratio);
+}
+
+
+fn process_text(wall_of_text: Vec<String>) -> i32 {
+    let mut sum: i32 = 0;
+
+    for (line_count, line) in wall_of_text.clone().into_iter().enumerate() {
+        // let x = find_numbers(&line);
+        let y = find_gear(&line);
+        for i in y {
+            let coor = (
+                clip(i32::try_from(line_count).unwrap()-1, 0, i32::try_from(wall_of_text.len()).unwrap()-1),
+                clip(i32::try_from(line_count).unwrap()+1, 0, i32::try_from(wall_of_text.len()).unwrap()-1),
+                i.try_into().unwrap(), 
+                line.len(),
+            );
+
+            let (engine_part, ratio) = get_adjacent_gears(coor, &wall_of_text);
+            if engine_part 
+            {
+                sum += ratio;
+            }
+        }
+    }
+    // let _throw_way = get_adjacent_gears((2,2,4,4), wall_of_text);
+    return sum;
+}
+
+fn main() -> io::Result<()>  {
+    let file = File::open("../test.txt")?;
+    // let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer: i32 = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day4/python/main.py

@@ -0,0 +1,28 @@
+import re
+import numpy as np
+
+f = open('input.txt', 'r')
+content = f.read()
+lines = content.splitlines()
+num_instances = np.ones(len(lines))
+for line_count, line in enumerate(lines):
+    card_sum = 0
+    card = re.split(":", line)
+    card_number = re.findall(r'\d+', card[0])
+    numbers = re.split("\|", card[1])
+    my_numbers = [int(x) for x in filter(('').__ne__, re.split(" ", numbers[1]))]
+    winning_numbers = set(int(x) for x in filter(('').__ne__, re.split(" ", numbers[0])))
+
+    for num in my_numbers:
+        if num in winning_numbers:
+            card_sum += 1
+        
+    for x in range(card_sum):
+        num_instances[x+line_count+1] += num_instances[line_count]
+
+
+
+f.close()
+
+print(num_instances)
+print(np.sum(num_instances))

2023/day4/rust/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day4/rust/src/part_one.rs

@@ -0,0 +1,42 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use regex::Regex;
+
+fn find_numbers(line: &str) -> Vec<u32> {
+    let re = Regex::new(r"\d+").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.as_str().parse::<u32>().unwrap()).collect();
+    let mut return_vec: Vec<u32> = vec![];
+    for i in matches {
+        return_vec.push(i);
+    }
+    return return_vec;
+}
+
+fn process_line(line: String) -> u32 {
+    let parts = line.split(&[':']).collect::<Vec<&str>>();
+    let sets = parts[1].split("|").collect::<Vec<&str>>();
+    let winning_numbers = find_numbers(&sets[0]);
+    let mut card_sum = 0;
+    let my_numbers = find_numbers(&sets[1]);
+    for num in &my_numbers
+    {
+       for winning_num in &winning_numbers 
+       {
+           if num == winning_num { card_sum +=1; }
+       }
+    }
+    if card_sum > 0 {return 2u32.pow(card_sum-1); }
+    else { return 0; }
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum: u32 = 0;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        sum = process_line(line?) + sum;
+    }
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day4/rust/src/part_two.rs

@@ -0,0 +1,49 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use regex::Regex;
+
+fn find_numbers(line: &str) -> Vec<u64> {
+    let re = Regex::new(r"\d+").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.as_str().parse::<u64>().unwrap()).collect();
+    let mut return_vec: Vec<u64> = vec![];
+    for i in matches {
+        return_vec.push(i);
+    }
+    return return_vec;
+}
+
+fn process_line(line: String) -> u64 {
+    let parts = line.split(&[':']).collect::<Vec<&str>>();
+    let sets = parts[1].split("|").collect::<Vec<&str>>();
+    let winning_numbers = find_numbers(&sets[0]);
+    let mut card_sum = 0;
+    let my_numbers = find_numbers(&sets[1]);
+    for num in &my_numbers
+    {
+       for winning_num in &winning_numbers 
+       {
+           if num == winning_num { card_sum +=1; }
+       }
+    }
+    card_sum
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum: u64 = 0;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let mut instances: Vec<u64> = vec![];
+    for (count, line) in reader.lines().enumerate() {
+        if count >= instances.len() { instances.push(1);}
+        let num = process_line(line?);
+        for i in 0..num{
+            let idx = count + usize::try_from(i).unwrap() + 1;
+            if idx >= instances.len() { instances.push(1+instances[count]);}
+            else {instances[idx] += instances[count];}
+        }
+        sum += instances[count];
+    }
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day5/rust/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day5/rust/src/part_one.rs

@@ -0,0 +1,74 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use regex::Regex;
+
+
+fn find_numbers(line: &str) -> Vec<u64> {
+    let re = Regex::new(r"\d+").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.as_str().parse::<u64>().unwrap()).collect();
+    let mut return_vec: Vec<u64> = vec![];
+    for i in matches {
+        return_vec.push(i);
+        println!("number {}", i); 
+    }
+    return return_vec;
+}
+
+fn process_seed(seed: u64, translation_table: &Vec<Vec<Vec<u64>>>) -> u64
+{
+    let mut val = seed;
+    for block in translation_table
+    {
+        for line in block
+        {
+            if (val > line[1]) && (val < (line[1] + line[2]))
+            {
+                val = line[0] + (val - line[1]);
+                break;
+            }
+        }
+    }
+    val
+}
+
+fn process_text(wall_of_text: Vec<String>) -> u64 {
+    let mut minimum: u64 = std::u64::MAX;
+    let mut translation_table: Vec<Vec<Vec<u64>>> = vec![];
+    let seeds: Vec<u64> = find_numbers(&wall_of_text[0]);
+    let mut line_count = 3; //Start on line 3 to skip  the seeds header
+    while line_count < wall_of_text.len() {
+        let mut table_block: Vec<Vec<u64>> = vec![];
+        while line_count < wall_of_text.len() {
+            if wall_of_text[line_count].contains(":")
+            {
+                break;
+            }
+            if !wall_of_text[line_count].is_empty() {
+                let table_line = find_numbers(&wall_of_text[line_count]);
+                table_block.push(table_line);
+            }
+            else{println!("EMPTY LINE")};
+            line_count += 1;
+        }
+        translation_table.push(table_block);
+        line_count += 1;
+    }
+
+    for seed in seeds {
+        let val = process_seed(seed, &translation_table);
+        if val < minimum { minimum = val; }
+        println!("{}", val);
+    }
+    return minimum;
+}
+
+fn main() -> io::Result<()>  {
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer: u64 = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day5/rust/src/part_two.rs

@@ -0,0 +1,81 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use regex::Regex;
+
+
+fn find_numbers(line: &str) -> Vec<u64> {
+    let re = Regex::new(r"\d+").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.as_str().parse::<u64>().unwrap()).collect();
+    let mut return_vec: Vec<u64> = vec![];
+    for i in matches {
+        return_vec.push(i);
+        println!("number {}", i); 
+    }
+    return return_vec;
+}
+
+fn process_seed(seed: u64, translation_table: &Vec<Vec<Vec<u64>>>) -> (u64, u64)
+{
+    let mut val = seed;
+    let mut skip_num = std::u64::MAX;
+    for block in translation_table
+    {
+        for line in block
+        {
+            if (val >= line[1]) && (val < (line[1] + line[2]))
+            {
+                let skip_contender = (line[1] + line[2]) - val;
+                val = line[0] + (val - line[1]);
+                if skip_contender < skip_num {skip_num = skip_contender;}
+                break;
+            }
+        }
+    }
+    (val, skip_num)
+}
+
+fn process_text(wall_of_text: Vec<String>) -> u64 {
+    let mut minimum: u64 = std::u64::MAX;
+    let mut translation_table: Vec<Vec<Vec<u64>>> = vec![];
+    let seeds: Vec<u64> = find_numbers(&wall_of_text[0]);
+    let mut line_count = 3; //Start on line 3 to skip  the seeds header
+    while line_count < wall_of_text.len() {
+        let mut table_block: Vec<Vec<u64>> = vec![];
+        while line_count < wall_of_text.len() {
+            if wall_of_text[line_count].contains(":")
+            {
+                break;
+            }
+            if !wall_of_text[line_count].is_empty() {
+                let table_line = find_numbers(&wall_of_text[line_count]);
+                table_block.push(table_line);
+            }
+            else{println!("EMPTY LINE")};
+            line_count += 1;
+        }
+        translation_table.push(table_block);
+        line_count += 1;
+    }
+
+    for seed_group in 0..seeds.len()/2 {
+        let mut seed_number = 0;
+        let base = seeds[seed_group*2];
+        while seed_number < seeds[seed_group*2+1] {
+            let (val, skip_number) = process_seed(base+seed_number, &translation_table);
+            seed_number += skip_number;
+            if val < minimum { minimum = val; }
+        }
+    }
+    return minimum;
+}
+
+fn main() -> io::Result<()>  {
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    let answer: u64 = process_text(
+        reader.lines().collect::<io::Result<Vec<String>>>().expect("failed")
+    );
+    println!("{}", answer);
+
+    Ok(())
+}

2023/day6/python/main.py

@@ -0,0 +1,28 @@
+
+import numpy as np
+import math
+
+def quadratic_formula(a,b,c):
+    temp= np.sqrt((b**2)-(4*a*c))
+    return (np.ceil((-b+temp)/(2*a)+0.00000001), np.ceil((-b-temp)/(2*a)-0.00000001))
+
+# times = [63, 78, 94, 68]
+# distances = [411, 1274, 2047, 1035]
+
+times = [7,15,30]
+distances = [9,40,200]
+
+# times = [63789468]
+# distances = [411127420471035]
+
+# times = [71530]
+# distances = [940200]
+
+
+answer = 1
+for i in range(len(times)):
+    a, b = quadratic_formula(-1, times[i], -distances[i])
+    answer = answer * (b-a)
+    print(a,b,answer)
+
+print(answer)

2023/day6/rust/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libmath = "0.2.1"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day6/rust/src/part_one.rs

@@ -0,0 +1,22 @@
+use math;
+
+fn quadratic_formula(a: i32, b: i32, c: i32) -> (f64, f64)
+{
+    let square = b*b-4*a*c;
+    let temp = (square as f64).sqrt();
+    return (math::round::ceil(((-b as f64+temp)/((2*a) as f64)) +0.00001, 0), math::round::ceil(((-b as f64 -temp)/((2*a) as f64)) - 0.00001, 0));
+}
+
+fn main() {
+    let mut answer = 1.0;
+    // let times = [7,15,30];
+    // let distances = [9,40,200];
+    let times = [63,78,94,68];
+    let distances = [411,1274,2047,1035];
+    for index in 0..times.len() {
+        let (a, b) = quadratic_formula(-1, times[index], -distances[index]);
+        println!("{} {}", a, b);
+        answer = answer * (b-a);
+    }
+    println!("{}", answer);
+}

2023/day6/rust/src/part_two.rs

@@ -0,0 +1,22 @@
+use math;
+
+fn quadratic_formula(a: i64, b: i64, c: i64) -> (f64, f64)
+{
+    let square = b*b-4*a*c;
+    let temp = (square as f64).sqrt();
+    return (math::round::ceil(((-b as f64+temp)/((2*a) as f64)) +0.00001, 0), math::round::ceil(((-b as f64 -temp)/((2*a) as f64)) - 0.00001, 0));
+}
+
+fn main() {
+    let mut answer = 1.0;
+    // let times = [7,15,30];
+    // let distances = [9,40,200];
+    let times = [63789468];
+    let distances = [411127420471035];
+    for index in 0..times.len() {
+        let (a, b) = quadratic_formula(-1, times[index], -distances[index]);
+        println!("{} {}", a, b);
+        answer = answer * (b-a);
+    }
+    println!("{}", answer);
+}

2023/day7/rust/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libmath = "0.2.1"
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day7/rust/src/part_one.rs

@@ -0,0 +1,129 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+fn get_number(line: &str) -> u32 {
+    let re = Regex::new(r"\d+").unwrap();
+    let num: u32 = re.find(line).unwrap().as_str().parse().unwrap();
+    return num;
+}
+
+
+enum Hands{
+    HighCard=0,
+    OnePair,
+    TwoPair,
+    ThreeOfAKind,
+    FullHouse,
+    FourOfAKind,
+    FiveOfAKind,
+}
+
+fn get_hand(line: &str) -> Hands {
+    let mut cards = HashMap::new();
+    for ch in line.chars()
+    {
+        cards.entry(ch).and_modify(|counter| *counter += 1).or_insert(1);
+    }
+    let mut my_vec = cards.into_values().collect::<Vec<_>>();
+    my_vec.sort();
+    println!("{}", my_vec[my_vec.len()-1]);
+    let max = my_vec[my_vec.len()-1];
+    if max == 5
+    {
+        return Hands::FiveOfAKind;
+    }
+    if max == 4
+    {
+        return Hands::FourOfAKind;
+    }
+    let next_max = my_vec[my_vec.len()-2];
+    if max == 3
+    {
+        if next_max == 2
+        {
+            return Hands::FullHouse;
+        }
+        return Hands::ThreeOfAKind;
+    }
+    if max == 2
+    {
+        if next_max == 2 
+        { 
+            return Hands::TwoPair;
+        }
+        return Hands::OnePair;
+    }
+    return Hands::HighCard;
+}
+
+fn hand2num(line: &str) -> u32
+{
+    let num = line.chars().map( |m| match m {
+        'A' => 14,
+        'K' => 13,
+        'Q' => 12,
+        'J' => 11,
+        'T' => 10,
+        _ => m.to_digit(10).unwrap()
+    }).collect::<Vec<u32>>();
+    let mut sum = 0;
+    for i in 0..5
+    {
+        sum += num[i]*16_u32.pow((4-i).try_into().unwrap());
+    }
+    println!("{}", sum);
+    return sum;
+    
+
+}
+
+fn get_ranking(num: u32, bid: u32, ranking: &mut [Vec<(u32, u32)>; 7], hand: usize)
+{
+    let mut index = 0;
+    for i in &ranking[hand]
+    {
+        if i.0 >= num { break;}
+        index += 1;
+    }
+    ranking[hand].insert(index, (num, bid));
+}
+
+
+fn process_line(line: String, ranking: &mut [Vec<(u32, u32)>; 7]) {
+    let parts = line.split(&[' ']).collect::<Vec<&str>>();
+    let bid = get_number(parts[1]);
+    let hand = get_hand(parts[0]);
+    let hand_num = hand2num(parts[0]);
+    get_ranking(hand_num, bid, ranking, hand as usize);
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum: u32 = 0;
+    let file = File::open("../input.txt")?;
+    let mut ranks: [Vec<(u32, u32)>; 7] = [vec![],vec![],vec![],vec![],vec![],vec![],vec![]];
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        process_line(line?, &mut ranks);
+    }
+    let mut incrementer = 1;
+    println!("Listing Rankings");
+    for rank in &ranks {
+        for i in rank {
+            sum += incrementer*i.1;
+            incrementer += 1;
+            println!("{}", i.1);
+        }
+    }
+    println!("{}", ranks[0].len());
+    println!("{}", ranks[1].len());
+    println!("{}", ranks[2].len());
+    println!("{}", ranks[3].len());
+    println!("{}", ranks[4].len());
+    println!("{}", ranks[5].len());
+    println!("{}", ranks[6].len());
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day7/rust/src/part_two.rs

@@ -0,0 +1,138 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+fn get_number(line: &str) -> u32 {
+    let re = Regex::new(r"\d+").unwrap();
+    let num: u32 = re.find(line).unwrap().as_str().parse().unwrap();
+    return num;
+}
+
+enum Hands{
+    HighCard=0,
+    OnePair,
+    TwoPair,
+    ThreeOfAKind,
+    FullHouse,
+    FourOfAKind,
+    FiveOfAKind,
+}
+
+fn get_hand(line: &str) -> Hands {
+    let mut cards = HashMap::new();
+    for ch in line.chars().clone()
+    {
+        cards.entry(ch).and_modify(|counter| *counter += 1).or_insert(1);
+    }
+    let jays;
+    if cards.contains_key(&'J')
+    { 
+        jays = cards.remove(&'J').unwrap();
+    }
+    else
+    {
+        jays = 0;
+    }
+    let mut my_vec = cards.into_values().collect::<Vec<_>>();
+    if my_vec.is_empty()
+    {
+        return Hands::FiveOfAKind;
+    }
+    my_vec.sort();
+    let max = my_vec[my_vec.len()-1]+jays;
+    if max == 5
+    {
+        return Hands::FiveOfAKind;
+    }
+    if max == 4
+    {
+        return Hands::FourOfAKind;
+    }
+    let next_max = my_vec[my_vec.len()-2];
+    if max == 3
+    {
+        if next_max == 2
+        {
+            return Hands::FullHouse;
+        }
+        return Hands::ThreeOfAKind;
+    }
+    if max == 2
+    {
+        if next_max == 2 
+        { 
+            return Hands::TwoPair;
+        }
+        return Hands::OnePair;
+    }
+    return Hands::HighCard;
+}
+
+fn hand2num(line: &str) -> u32
+{
+    let num = line.chars().map( |m| match m {
+        'A' => 14,
+        'K' => 13,
+        'Q' => 12,
+        'J' => 1,
+        'T' => 10,
+        _ => m.to_digit(10).unwrap()
+    }).collect::<Vec<u32>>();
+    let mut sum = 0;
+    for i in 0..5
+    {
+        sum += num[i]*16_u32.pow((4-i).try_into().unwrap());
+    }
+    return sum;
+    
+
+}
+
+fn get_ranking(num: u32, bid: u32, ranking: &mut [Vec<(u32, u32)>; 7], hand: usize)
+{
+    let mut index = 0;
+    for i in &ranking[hand]
+    {
+        if i.0 > num { break;}
+        index += 1;
+    }
+    ranking[hand].insert(index, (num, bid));
+}
+
+
+fn process_line(line: String, ranking: &mut [Vec<(u32, u32)>; 7]) {
+    let parts = line.split(&[' ']).collect::<Vec<&str>>();
+    let bid = get_number(parts[1]);
+    let hand = get_hand(parts[0]);
+    let hand_num = hand2num(parts[0]);
+    get_ranking(hand_num, bid, ranking, hand as usize);
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum: u32 = 0;
+    let file = File::open("../input.txt")?;
+    let mut ranks: [Vec<(u32, u32)>; 7] = [vec![],vec![],vec![],vec![],vec![],vec![],vec![]];
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        process_line(line?, &mut ranks);
+    }
+    let mut incrementer = 1;
+    println!("Listing Rankings");
+    for rank in &ranks {
+        for i in rank {
+            sum += incrementer*i.1;
+            incrementer += 1;
+        }
+    }
+    println!("{}", ranks[0].len());
+    println!("{}", ranks[1].len());
+    println!("{}", ranks[2].len());
+    println!("{}", ranks[3].len());
+    println!("{}", ranks[4].len());
+    println!("{}", ranks[5].len());
+    println!("{}", ranks[6].len());
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day8/main.py

@@ -0,0 +1,104 @@
+import re
+from tracemalloc import start
+import numpy as np
+import graphviz
+
+def get_answer(graph, keys, inst):
+    inst_idx = 0
+    steps = 0
+
+    current_keys = keys
+    while True:
+        all_ending_in_z = True
+        for i in range(len(current_keys)):
+            current_keys[i] = graph[current_keys[i]][inst[inst_idx]]
+            if all_ending_in_z and (current_keys[i][2] != 'Z'):
+                all_ending_in_z = False
+        steps += 1
+        inst_idx = (inst_idx + 1)%len(inst)
+
+        if all_ending_in_z:
+            return steps
+        
+def visualize_graph(graph):
+    dot = graphviz.Digraph(comment='Advent of Code Day 8')
+    for i in graph:
+        for key in graph[i].keys():
+            dot.node(i)
+            dot.edge(i, graph[i][key])
+        
+    dot.render('day8.dot') 
+        
+
+
+
+f = open('input.txt', 'r')
+my_graph = dict(dict())
+content = f.read()
+lines = content.splitlines()
+instructions = []
+starting_keys = []
+ending_keys = []
+
+for line_count, line in enumerate(lines):
+    last_repeat = False
+    if line_count == 0:
+        instructions = line
+    else:
+        numbers = re.findall(r'[A-Za-z]+', line)
+        if len(numbers) == 3:
+            if numbers[0][2] == 'A':
+                starting_keys.append(numbers[0])
+                
+            my_graph[numbers[0]] = {"L": numbers[1], "R": numbers[2]}
+   
+counters = [0]*len(starting_keys)
+inst_idx = 0
+steps = 0
+
+# current_keys = starting_keys
+# while True:
+#     all_ending_in_z = True
+#     for i in range(len(current_keys)):
+#         current_keys[i] = my_graph[current_keys[i]][instructions[inst_idx]]
+#         if all_ending_in_z and (current_keys[i][2] != 'Z'):
+#             all_ending_in_z = False
+#     steps += 1
+#     inst_idx = (inst_idx + 1)%len(instructions)
+
+#     if all_ending_in_z:
+#         return steps
+
+starting_key = 'AAA'
+ending_key = 'ZZZ'
+inst_idx = 0
+list_steps = []
+for key in starting_keys:
+    steps = 0
+    current_key = key
+    loop = True
+    while loop:
+        current_key = my_graph[current_key][instructions[inst_idx]]
+        inst_idx = (inst_idx + 1)%len(instructions)
+        if (current_key[2] == 'Z'):
+            loop = False
+
+        steps += 1
+    print(steps)
+    list_steps.append(steps)
+
+# print(starting_keys)
+# ans = get_answer(my_graph, starting_keys, instructions)
+# print(ans)
+
+visualize_graph(my_graph)
+
+lcm = 1#np.lcm(list_steps[0], list_steps[1])
+print(lcm)  
+for i in range(len(list_steps)):
+    lcm = np.lcm(lcm, list_steps[i])
+    print(lcm)  
+    print(list_steps[i]/len(instructions))
+
+
+f.close()

2023/day8/part_one.py

@@ -0,0 +1,36 @@
+import re
+from tracemalloc import start
+import numpy as np
+
+f = open('input.txt', 'r')
+my_graph = dict(dict())
+content = f.read()
+lines = content.splitlines()
+instructions = []
+
+for line_count, line in enumerate(lines):
+    if line_count == 0:
+        instructions = line
+    else:
+        numbers = re.findall(r'[A-Za-z]+', line)
+        if len(numbers) == 3:
+            
+            my_graph[numbers[0]] = {"L": numbers[1], "R": numbers[2]}
+    
+print(my_graph)
+
+starting_key = 'AAA'
+ending_key = 'ZZZ'
+inst_idx = 0
+steps = 0
+
+current_key = starting_key
+while current_key != ending_key:
+    current_key = my_graph[current_key][instructions[inst_idx]]
+    steps += 1
+    inst_idx = (inst_idx + 1)%len(instructions)
+
+print(steps)
+
+
+f.close()

2023/day8/rust/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libmath = "0.2.1"
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day8/rust/src/part_one.rs

@@ -0,0 +1,129 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+fn get_number(line: &str) -> u32 {
+    let re = Regex::new(r"\d+").unwrap();
+    let num: u32 = re.find(line).unwrap().as_str().parse().unwrap();
+    return num;
+}
+
+
+enum Hands{
+    HighCard=0,
+    OnePair,
+    TwoPair,
+    ThreeOfAKind,
+    FullHouse,
+    FourOfAKind,
+    FiveOfAKind,
+}
+
+fn get_hand(line: &str) -> Hands {
+    let mut cards = HashMap::new();
+    for ch in line.chars()
+    {
+        cards.entry(ch).and_modify(|counter| *counter += 1).or_insert(1);
+    }
+    let mut my_vec = cards.into_values().collect::<Vec<_>>();
+    my_vec.sort();
+    println!("{}", my_vec[my_vec.len()-1]);
+    let max = my_vec[my_vec.len()-1];
+    if max == 5
+    {
+        return Hands::FiveOfAKind;
+    }
+    if max == 4
+    {
+        return Hands::FourOfAKind;
+    }
+    let next_max = my_vec[my_vec.len()-2];
+    if max == 3
+    {
+        if next_max == 2
+        {
+            return Hands::FullHouse;
+        }
+        return Hands::ThreeOfAKind;
+    }
+    if max == 2
+    {
+        if next_max == 2 
+        { 
+            return Hands::TwoPair;
+        }
+        return Hands::OnePair;
+    }
+    return Hands::HighCard;
+}
+
+fn hand2num(line: &str) -> u32
+{
+    let num = line.chars().map( |m| match m {
+        'A' => 14,
+        'K' => 13,
+        'Q' => 12,
+        'J' => 11,
+        'T' => 10,
+        _ => m.to_digit(10).unwrap()
+    }).collect::<Vec<u32>>();
+    let mut sum = 0;
+    for i in 0..5
+    {
+        sum += num[i]*16_u32.pow((4-i).try_into().unwrap());
+    }
+    println!("{}", sum);
+    return sum;
+    
+
+}
+
+fn get_ranking(num: u32, bid: u32, ranking: &mut [Vec<(u32, u32)>; 7], hand: usize)
+{
+    let mut index = 0;
+    for i in &ranking[hand]
+    {
+        if i.0 >= num { break;}
+        index += 1;
+    }
+    ranking[hand].insert(index, (num, bid));
+}
+
+
+fn process_line(line: String, ranking: &mut [Vec<(u32, u32)>; 7]) {
+    let parts = line.split(&[' ']).collect::<Vec<&str>>();
+    let bid = get_number(parts[1]);
+    let hand = get_hand(parts[0]);
+    let hand_num = hand2num(parts[0]);
+    get_ranking(hand_num, bid, ranking, hand as usize);
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum: u32 = 0;
+    let file = File::open("../input.txt")?;
+    let mut ranks: [Vec<(u32, u32)>; 7] = [vec![],vec![],vec![],vec![],vec![],vec![],vec![]];
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        process_line(line?, &mut ranks);
+    }
+    let mut incrementer = 1;
+    println!("Listing Rankings");
+    for rank in &ranks {
+        for i in rank {
+            sum += incrementer*i.1;
+            incrementer += 1;
+            println!("{}", i.1);
+        }
+    }
+    println!("{}", ranks[0].len());
+    println!("{}", ranks[1].len());
+    println!("{}", ranks[2].len());
+    println!("{}", ranks[3].len());
+    println!("{}", ranks[4].len());
+    println!("{}", ranks[5].len());
+    println!("{}", ranks[6].len());
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day8/rust/src/part_two.rs

@@ -0,0 +1,140 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+fn get_number(line: &str) -> u32 {
+    let re = Regex::new(r"\d+").unwrap();
+    let num: u32 = re.find(line).unwrap().as_str().parse().unwrap();
+    return num;
+}
+
+
+enum Hands{
+    HighCard=0,
+    OnePair,
+    TwoPair,
+    ThreeOfAKind,
+    FullHouse,
+    FourOfAKind,
+    FiveOfAKind,
+}
+
+fn get_hand(line: &str) -> Hands {
+    let mut cards = HashMap::new();
+    for ch in line.chars().clone()
+    {
+        cards.entry(ch).and_modify(|counter| *counter += 1).or_insert(1);
+    }
+    let jays;
+    if cards.contains_key(&'J')
+    { 
+        jays = cards.remove(&'J').unwrap();
+    }
+    else
+    {
+        jays = 0;
+    }
+    let mut my_vec = cards.into_values().collect::<Vec<_>>();
+    println!("Num J {}, Len {}", jays, my_vec.len());
+    if my_vec.is_empty()
+    {
+        return Hands::FiveOfAKind;
+    }
+    my_vec.sort();
+    let max = my_vec[my_vec.len()-1]+jays;
+    if max == 5
+    {
+        return Hands::FiveOfAKind;
+    }
+    if max == 4
+    {
+        return Hands::FourOfAKind;
+    }
+    let next_max = my_vec[my_vec.len()-2];
+    if max == 3
+    {
+        if next_max == 2
+        {
+            return Hands::FullHouse;
+        }
+        return Hands::ThreeOfAKind;
+    }
+    if max == 2
+    {
+        if next_max == 2 
+        { 
+            return Hands::TwoPair;
+        }
+        return Hands::OnePair;
+    }
+    return Hands::HighCard;
+}
+
+fn hand2num(line: &str) -> u32
+{
+    let num = line.chars().map( |m| match m {
+        'A' => 14,
+        'K' => 13,
+        'Q' => 12,
+        'J' => 1,
+        'T' => 10,
+        _ => m.to_digit(10).unwrap()
+    }).collect::<Vec<u32>>();
+    let mut sum = 0;
+    for i in 0..5
+    {
+        sum += num[i]*16_u32.pow((4-i).try_into().unwrap());
+    }
+    return sum;
+    
+
+}
+
+fn get_ranking(num: u32, bid: u32, ranking: &mut [Vec<(u32, u32)>; 7], hand: usize)
+{
+    let mut index = 0;
+    for i in &ranking[hand]
+    {
+        if i.0 > num { break;}
+        index += 1;
+    }
+    ranking[hand].insert(index, (num, bid));
+}
+
+
+fn process_line(line: String, ranking: &mut [Vec<(u32, u32)>; 7]) {
+    let parts = line.split(&[' ']).collect::<Vec<&str>>();
+    let bid = get_number(parts[1]);
+    let hand = get_hand(parts[0]);
+    let hand_num = hand2num(parts[0]);
+    get_ranking(hand_num, bid, ranking, hand as usize);
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum: u32 = 0;
+    let file = File::open("../input.txt")?;
+    let mut ranks: [Vec<(u32, u32)>; 7] = [vec![],vec![],vec![],vec![],vec![],vec![],vec![]];
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        process_line(line?, &mut ranks);
+    }
+    let mut incrementer = 1;
+    println!("Listing Rankings");
+    for rank in &ranks {
+        for i in rank {
+            sum += incrementer*i.1;
+            incrementer += 1;
+        }
+    }
+    println!("{}", ranks[0].len());
+    println!("{}", ranks[1].len());
+    println!("{}", ranks[2].len());
+    println!("{}", ranks[3].len());
+    println!("{}", ranks[4].len());
+    println!("{}", ranks[5].len());
+    println!("{}", ranks[6].len());
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day9/rust/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libmath = "0.2.1"
+regex = "1.10.2"
+
+[[bin]]
+name = "part_one"
+path = "src/part_one.rs"
+
+[[bin]]
+name = "part_two"
+path = "src/part_two.rs"

2023/day9/rust/src/part_one.rs

@@ -0,0 +1,53 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+
+fn find_numbers(line: &str) -> Vec<i64> {
+    let re = Regex::new(r"-?\d+").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.as_str().parse::<i64>().unwrap()).collect();
+    return matches;
+}
+
+fn predict_next_num(numbers: Vec<i64>) -> i64 {
+    let mut answer = 0;
+    let mut differences: Vec<Vec<i64>> = vec![];
+    let mut looping = true;
+    let mut index = 0;
+    differences.push(numbers);
+    while looping {
+        differences.push(vec![]);
+        let mut sum = 0;
+        for i in 1..differences[index].len(){
+            let diff = differences[index][i]-differences[index][i-1];
+            differences[index+1].push(diff);
+            sum += diff.abs();
+        }
+        looping = sum != 0;
+        index += 1;
+    }
+    for vector in (0..differences.len()).rev(){
+        answer += differences[vector][differences[vector].len()-1];
+    }
+
+    return answer;
+}
+
+
+fn process_line(line: String) -> i64 {
+    let numbers = find_numbers(&line);
+    return predict_next_num(numbers);
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum = 0;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        sum += process_line(line?);
+    }
+    println!("{}", sum);
+
+    Ok(())
+}

2023/day9/rust/src/part_two.rs

@@ -0,0 +1,55 @@
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader};
+use std::collections::HashMap;
+use regex::Regex;
+
+
+fn find_numbers(line: &str) -> Vec<i64> {
+    let re = Regex::new(r"-?\d+").unwrap();
+    let matches: Vec<_> = re.find_iter(line).map(|m| m.as_str().parse::<i64>().unwrap()).collect();
+    return matches;
+}
+
+fn predict_next_num(numbers: Vec<i64>) -> i64 {
+    let mut answer = 0;
+    let mut differences: Vec<Vec<i64>> = vec![];
+    let mut looping = true;
+    let mut index = 0;
+    differences.push(numbers);
+    while looping {
+        differences.push(vec![]);
+        let mut sum = 0;
+        for i in 1..differences[index].len(){
+            let diff = differences[index][i]-differences[index][i-1];
+            differences[index+1].push(diff);
+            sum += diff.abs();
+        }
+        println!("{:?}", differences[index]);
+        looping = sum != 0;
+        index += 1;
+    }
+    for vector in (0..differences.len()).rev(){
+        answer = differences[vector][0] - answer;
+    }
+    println!("answer {} \n", answer);
+
+    return answer;
+}
+
+
+fn process_line(line: String) -> i64 {
+    let numbers = find_numbers(&line);
+    return predict_next_num(numbers);
+}
+
+fn main() -> io::Result<()>  {
+    let mut sum = 0;
+    let file = File::open("../input.txt")?;
+    let reader = BufReader::new(file);
+    for line in reader.lines() {
+        sum += process_line(line?);
+    }
+    println!("{}", sum);
+
+    Ok(())
+}