From 51c64d827b365ee056eecbf700b4eea0dd97f800 Mon Sep 17 00:00:00 2001 From: Andrew Glaze Date: Thu, 14 Dec 2023 10:46:45 -0500 Subject: [PATCH] delete accidental submodule --- old/AdventOfCode2023 | 1 - old/day01/Cargo.lock | 7 ++ old/day01/Cargo.toml | 8 ++ old/day01/src/main.rs | 48 +++++++++ old/day02/Cargo.lock | 7 ++ old/day02/Cargo.toml | 8 ++ old/day02/src/main.rs | 83 +++++++++++++++ old/day03/Cargo.lock | 16 +++ old/day03/Cargo.toml | 9 ++ old/day03/src/main.rs | 193 ++++++++++++++++++++++++++++++++++ old/day04/Cargo.lock | 7 ++ old/day04/Cargo.toml | 8 ++ old/day04/src/main.rs | 99 ++++++++++++++++++ old/day05/Cargo.lock | 7 ++ old/day05/Cargo.toml | 8 ++ old/day05/src/main.rs | 93 +++++++++++++++++ old/day06/Cargo.lock | 7 ++ old/day06/Cargo.toml | 8 ++ old/day06/src/main.rs | 56 ++++++++++ old/day07/Cargo.lock | 7 ++ old/day07/Cargo.toml | 8 ++ old/day07/src/main.rs | 183 +++++++++++++++++++++++++++++++++ old/day08/Cargo.lock | 7 ++ old/day08/Cargo.toml | 8 ++ old/day08/src/main.rs | 122 ++++++++++++++++++++++ old/day09/Cargo.lock | 7 ++ old/day09/Cargo.toml | 8 ++ old/day09/src/main.rs | 70 +++++++++++++ old/day10/Cargo.lock | 77 ++++++++++++++ old/day10/Cargo.toml | 10 ++ old/day10/src/main.rs | 234 ++++++++++++++++++++++++++++++++++++++++++ old/day11/Cargo.lock | 7 ++ old/day11/Cargo.toml | 8 ++ old/day11/src/main.rs | 121 ++++++++++++++++++++++ old/day12/Cargo.lock | 25 +++++ old/day12/Cargo.toml | 9 ++ old/day12/src/main.rs | 54 ++++++++++ 37 files changed, 1637 insertions(+), 1 deletion(-) delete mode 160000 old/AdventOfCode2023 create mode 100644 old/day01/Cargo.lock create mode 100644 old/day01/Cargo.toml create mode 100644 old/day01/src/main.rs create mode 100644 old/day02/Cargo.lock create mode 100644 old/day02/Cargo.toml create mode 100644 old/day02/src/main.rs create mode 100644 old/day03/Cargo.lock create mode 100644 old/day03/Cargo.toml create mode 100644 old/day03/src/main.rs create mode 100644 old/day04/Cargo.lock create mode 100644 old/day04/Cargo.toml create mode 100644 old/day04/src/main.rs create mode 100644 old/day05/Cargo.lock create mode 100644 old/day05/Cargo.toml create mode 100644 old/day05/src/main.rs create mode 100644 old/day06/Cargo.lock create mode 100644 old/day06/Cargo.toml create mode 100644 old/day06/src/main.rs create mode 100644 old/day07/Cargo.lock create mode 100644 old/day07/Cargo.toml create mode 100644 old/day07/src/main.rs create mode 100644 old/day08/Cargo.lock create mode 100644 old/day08/Cargo.toml create mode 100644 old/day08/src/main.rs create mode 100644 old/day09/Cargo.lock create mode 100644 old/day09/Cargo.toml create mode 100644 old/day09/src/main.rs create mode 100644 old/day10/Cargo.lock create mode 100644 old/day10/Cargo.toml create mode 100644 old/day10/src/main.rs create mode 100644 old/day11/Cargo.lock create mode 100644 old/day11/Cargo.toml create mode 100644 old/day11/src/main.rs create mode 100644 old/day12/Cargo.lock create mode 100644 old/day12/Cargo.toml create mode 100644 old/day12/src/main.rs diff --git a/old/AdventOfCode2023 b/old/AdventOfCode2023 deleted file mode 160000 index 78aab8a..0000000 --- a/old/AdventOfCode2023 +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 78aab8ab5ed7c65461663bf6a4c1b31fcdda6cca diff --git a/old/day01/Cargo.lock b/old/day01/Cargo.lock new file mode 100644 index 0000000..ae5bfe8 --- /dev/null +++ b/old/day01/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day1" +version = "0.1.0" diff --git a/old/day01/Cargo.toml b/old/day01/Cargo.toml new file mode 100644 index 0000000..a3c4e52 --- /dev/null +++ b/old/day01/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "day1" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/old/day01/src/main.rs b/old/day01/src/main.rs new file mode 100644 index 0000000..4f626d9 --- /dev/null +++ b/old/day01/src/main.rs @@ -0,0 +1,48 @@ +use std::fs; + +fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + let input = input.split('\n'); + let mut sum = 0; + for line in input { + let str_nums: Vec<(&str, &str)> = vec![("one", "1"), ("two", "2"), ("three", "3"), ("four", "4"), ("five", "5"), ("six", "6"), ("seven", "7"), ("eight", "8"), ("nine", "9")]; + let mut matches: Vec<(usize, &str)> = vec![]; + for str_num in str_nums { + // Get every alphabetic number in the string with it's index + let str_match: Vec<_> = line.match_indices(str_num.0).collect(); + // convert the string to a numeral + let mut str_match: Vec<_> = str_match.iter().map(|x| return (x.0, str_num.1)).collect(); + matches.append(&mut str_match); + } + // get the numerials from the line with their index + let mut num_matches: Vec<(usize, &str)> = line.match_indices(|x: char| x.is_numeric()).collect(); + matches.append(&mut num_matches); + // sort by index + matches.sort_by(|lhs, rhs| lhs.cmp(rhs)); + let num = (matches.first().unwrap().1).to_owned() + (matches.last().unwrap().1); + sum += num.parse::().unwrap(); + } + + println!("{}", sum); +} + + + + + +// use std::fs; + +// fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); +// let input = input.split('\n'); +// let mut sum = 0; +// for line in input { +// let chars: Vec= line.chars().filter(|x| x.is_numeric()).collect(); +// let mut num = chars.first().unwrap().to_string(); +// num += &chars.last().unwrap().to_string(); +// let num: u32 = num.parse().unwrap(); +// sum += num; +// } + +// println!("{}", sum); +// } diff --git a/old/day02/Cargo.lock b/old/day02/Cargo.lock new file mode 100644 index 0000000..63c2f60 --- /dev/null +++ b/old/day02/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day2" +version = "0.1.0" diff --git a/old/day02/Cargo.toml b/old/day02/Cargo.toml new file mode 100644 index 0000000..8aa34bb --- /dev/null +++ b/old/day02/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "day2" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/old/day02/src/main.rs b/old/day02/src/main.rs new file mode 100644 index 0000000..907bd3e --- /dev/null +++ b/old/day02/src/main.rs @@ -0,0 +1,83 @@ +use std::{fs, cmp::max}; + +fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + let input: Vec<_> = input.split('\n').collect(); + let mut sum = 0; + for line in input { + let split:Vec<_> = line.split(':').collect(); + let rounds: Vec<_> = split.last().unwrap().split(';').collect(); + let rounds: Vec<_> = rounds.iter() + .map(|x| { + x.split(',').collect::>() + }).collect(); + + let rounds: Vec<_> = rounds.iter() + .map(|x| { + x.iter().map(|x| { + x.trim().split(' ').collect::>() + }).collect::>() + }).collect(); + let (mut r_max, mut g_max, mut b_max) = (0, 0, 0); + for round in rounds { + for set in round { + let color = set.last().unwrap(); + let num: i32 = set.first().unwrap().parse().unwrap(); + match *color { + "red" => r_max = max(num, r_max), + "blue" => b_max = max(num, b_max), + "green" => g_max = max(num, g_max), + &_ => todo!() + } + } + + } + //println!("{}", r_max); + sum += r_max * g_max * b_max; + } + println!("{}", sum); + +} + + + +// use std::fs; + +// fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); +// let input: Vec<_> = input.split('\n').collect(); +// let mut game_id = 0; +// let (r_max, g_max, b_max) = (12, 13, 14); +// let mut sum = 0; +// for line in input { +// game_id += 1; +// let split:Vec<_> = line.split(':').collect(); +// let rounds: Vec<_> = split.last().unwrap().split(';').collect(); +// let rounds: Vec<_> = rounds.iter().map(|x| x.split(',').collect::>()).collect(); +// let rounds: Vec<_> = rounds.iter().map(|x| x.iter().map(|x| x.trim().split(' ').collect::>()).collect::>()).collect(); +// let mut sad = false; + +// for round in rounds { +// let (mut r_cur, mut g_cur, mut b_cur) = (0, 0, 0); +// for set in round { +// let color = set.last().unwrap(); +// let num: i32 = set.first().unwrap().parse().unwrap(); +// match *color { +// "red" => r_cur += num, +// "blue" => b_cur += num, +// "green" => g_cur += num, +// &_ => todo!() +// } +// } + +// if r_cur > r_max || b_cur > b_max || g_cur > g_max { +// sad = true; +// } +// } +// if !sad { +// sum += game_id; +// } +// } +// println!("{}", sum); + +// } diff --git a/old/day03/Cargo.lock b/old/day03/Cargo.lock new file mode 100644 index 0000000..bd1f69f --- /dev/null +++ b/old/day03/Cargo.lock @@ -0,0 +1,16 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "array2d" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79093d31d0a9c7832c71ad74dd945b7861f721e6f242aa67be253a5eecbac937" + +[[package]] +name = "day3" +version = "0.1.0" +dependencies = [ + "array2d", +] diff --git a/old/day03/Cargo.toml b/old/day03/Cargo.toml new file mode 100644 index 0000000..1ac740b --- /dev/null +++ b/old/day03/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "day3" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +array2d = "0.3.0" diff --git a/old/day03/src/main.rs b/old/day03/src/main.rs new file mode 100644 index 0000000..8efc4e6 --- /dev/null +++ b/old/day03/src/main.rs @@ -0,0 +1,193 @@ +use std::collections::HashMap; +use std::fs; + +use array2d::Array2D; + +// pub fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); +// let array_2d = get_map(&input); +// // let mut r = Vec::new(); +// let mut stars_count: HashMap<(usize, usize), Vec> = HashMap::new(); +// for (y, row_iter) in array_2d.rows_iter().enumerate() { +// let mut checked = false; +// for (x, element) in row_iter.enumerate() { +// let d: char = element.clone(); +// if d.is_digit(10) && !checked { +// let star_vec = get_neighboring_star(x, y, &array_2d); +// if !star_vec.is_empty() { +// let (x_star, y_star, _) = star_vec.first().unwrap().clone(); +// let key = (x_star, y_star); +// let gear = get_number(x, y, &array_2d); +// if stars_count.contains_key(&key) { +// let mut v: Vec = stars_count.get(&(x_star, y_star)).unwrap().clone(); +// v.push(gear); +// stars_count.insert(key, v); +// } else { +// stars_count.insert(key, vec![gear]); +// } +// checked = true +// } +// } else if !d.is_digit(10) { +// checked = false; +// } +// } +// } +// let r = stars_count.iter().fold(0u32, |acc, (_, gears)| { +// if gears.len() == 2 { +// acc + gears.first().unwrap() * gears.last().unwrap() +// } else { +// acc +// } +// }); + +// println!("{}", r); +// } + +pub fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + let array_2d = get_map(&input); + let mut r = 0; + for (y, row_iter) in array_2d.rows_iter().enumerate() { + let mut checked = false; + for (x, element) in row_iter.enumerate() { + let d: char = element.clone(); + if d.is_digit(10) && !checked { + if !get_neighbors(x, y, &array_2d).is_empty() { + checked = true; + + r += get_number(x, y, &array_2d) + } + } else if !d.is_digit(10) { + checked = false; + } + } + } + + println!("{}", r); +} + +fn get_map(input: &str) -> Array2D { + let rows: Vec<&str> = input.split("\n").collect(); + let mut array = Vec::new(); + for row in rows { + let row_vec: Vec = row.chars().collect(); + array.push(row_vec); + } + + Array2D::from_rows(&array).unwrap() +} + +fn get_number(x: usize, y: usize, array2d: &Array2D) -> u32 { + // We're dealing with only 3 digits numbers + let mut i = x.clone(); + let mut j = x.clone() - 1; + let mut next_neighbors = Vec::new(); + let mut prev_neighbors = Vec::new(); + while array2d.get(y, i).is_some() && array2d.get(y, i).unwrap().is_digit(10) { + next_neighbors.push(array2d.get(y, i).unwrap()); + i += 1 + } + while array2d.get(y, j).is_some() && array2d.get(y, j).unwrap().is_digit(10) { + prev_neighbors.push(array2d.get(y, j).unwrap()); + if j > 0 { + j -= 1 + } else { + break; + } + } + + let mut prev: Vec<&char> = prev_neighbors.clone().into_iter().rev().collect(); + prev.append(&mut next_neighbors); + + prev + .into_iter() + .fold(String::new(), |a, b| a + &b.to_string()) + .parse() + .unwrap() +} + +fn get_neighbors(x: usize, y: usize, array2d: &Array2D) -> Vec<&char> { + let mut neighbors = Vec::new(); + neighbors.push(array2d.get(y, x.checked_add(1).unwrap())); + if x > 0 { + neighbors.push(array2d.get(y, x.checked_sub(1).unwrap())); + neighbors.push(array2d.get(y.checked_add(1).unwrap(), x.checked_sub(1).unwrap())); + } + if y > 0 { + neighbors.push(array2d.get(y.checked_sub(1).unwrap(), x)); + neighbors.push(array2d.get(y.checked_sub(1).unwrap(), x.checked_add(1).unwrap())); + } + if x > 0 && y > 0 { + neighbors.push(array2d.get(y.checked_sub(1).unwrap(), x.checked_sub(1).unwrap())); + } + neighbors.push(array2d.get(y.checked_add(1).unwrap(), x)); + neighbors.push(array2d.get(y.checked_add(1).unwrap(), x.checked_add(1).unwrap())); + + neighbors + .into_iter() + .flatten() + .filter(|c| !c.is_digit(10) && **c != '.') + .collect() +} + +fn get_neighboring_star(x: usize, y: usize, array2d: &Array2D) -> Vec<(usize, usize, Option<&char>)> { + let mut neighbors: Vec<(usize, usize, Option<&char>)> = Vec::new(); + neighbors.push((x.checked_add(1).unwrap(), y, array2d.get(y, x.checked_add(1).unwrap()))); + if x > 0 { + neighbors.push((x.checked_sub(1).unwrap(), y, array2d.get(y, x.checked_sub(1).unwrap()))); + neighbors.push((x.checked_sub(1).unwrap(), y.checked_add(1).unwrap(), array2d.get(y.checked_add(1).unwrap(), x.checked_sub(1).unwrap()))); + } + if y > 0 { + neighbors.push((x, y.checked_sub(1).unwrap(), array2d.get(y.checked_sub(1).unwrap(), x))); + neighbors.push((x.checked_add(1).unwrap(), y.checked_sub(1).unwrap(), array2d.get(y.checked_sub(1).unwrap(), x.checked_add(1).unwrap()))); + } + if x > 0 && y > 0 { + neighbors.push((x.checked_sub(1).unwrap(), y.checked_sub(1).unwrap(), array2d.get(y.checked_sub(1).unwrap(), x.checked_sub(1).unwrap()))); + } + neighbors.push((x, y.checked_add(1).unwrap(), array2d.get(y.checked_add(1).unwrap(), x))); + neighbors.push((x.checked_add(1).unwrap(), y.checked_add(1).unwrap(), array2d.get(y.checked_add(1).unwrap(), x.checked_add(1).unwrap()))); + + neighbors + .into_iter() + .filter(|(_, _, c)| c.is_some() && c.unwrap() == &'*') + .collect::)>>() +} + +pub fn part_two(input: &str) -> Option { + let array_2d = get_map(input); + // let mut r = Vec::new(); + let mut stars_count: HashMap<(usize, usize), Vec> = HashMap::new(); + for (y, row_iter) in array_2d.rows_iter().enumerate() { + let mut checked = false; + for (x, element) in row_iter.enumerate() { + let d: char = element.clone(); + if d.is_digit(10) && !checked { + let star_vec = get_neighboring_star(x, y, &array_2d); + if !star_vec.is_empty() { + let (x_star, y_star, _) = star_vec.first().unwrap().clone(); + let key = (x_star, y_star); + let gear = get_number(x, y, &array_2d); + if stars_count.contains_key(&key) { + let mut v: Vec = stars_count.get(&(x_star, y_star)).unwrap().clone(); + v.push(gear); + stars_count.insert(key, v); + } else { + stars_count.insert(key, vec![gear]); + } + checked = true + } + } else if !d.is_digit(10) { + checked = false; + } + } + } + let r = stars_count.iter().fold(0u32, |acc, (_, gears)| { + if gears.len() == 2 { + acc + gears.first().unwrap() * gears.last().unwrap() + } else { + acc + } + }); + + Some(r) +} diff --git a/old/day04/Cargo.lock b/old/day04/Cargo.lock new file mode 100644 index 0000000..e92c02c --- /dev/null +++ b/old/day04/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day4" +version = "0.1.0" diff --git a/old/day04/Cargo.toml b/old/day04/Cargo.toml new file mode 100644 index 0000000..eb81094 --- /dev/null +++ b/old/day04/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "day4" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] \ No newline at end of file diff --git a/old/day04/src/main.rs b/old/day04/src/main.rs new file mode 100644 index 0000000..6053943 --- /dev/null +++ b/old/day04/src/main.rs @@ -0,0 +1,99 @@ +use std::fs; +use std::collections::VecDeque; + +fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + + // an array in this format [[card 1: [winning nums][ our nums]]] + let input: Vec<_> = input.split('\n') // split days + .map(|card| &card[(card.find(':').unwrap() + 1)..]) // remove day numbers + .map(|card| card.trim()) // trim extra whitespace + .map(|card| { + card.split('|') // split winning/own numbers + .map(|numbers| { + numbers.trim() // trim whitespace + .split(' ') // split into individual nums + .filter(|x| !x.is_empty()) // remove empty strings + .map(|x| {return x.parse::().unwrap()}) // convert to i32 + .collect::>() + }) + .collect::>() + }) + .collect(); + + let mut queue = VecDeque::from((0..input.len()).collect::>()); + + let mut total_cards = 0; + while !queue.is_empty() { + let card_num = queue.pop_front().unwrap(); + let card = input.get(card_num).unwrap(); + total_cards += 1; + let mut dup_cards = 0; + let winning_nums = card.first().unwrap(); + let our_nums = card.last().unwrap(); + + //dp would kill here, but im lazy + for num in our_nums { + if winning_nums.contains(num) { + dup_cards += 1; + } + } + for card in (card_num + 1)..=(card_num + dup_cards) { + if card < input.len() { + queue.push_back(card); + } + } + } + + + + println!("{:?}", total_cards); +} + + +// use std::fs; + +// fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); + +// // an array in this format [[card 1: [winning nums][ our nums]]] +// let input: Vec<_> = input.split('\n') // split days +// .map(|card| &card[(card.find(':').unwrap() + 1)..]) // remove day numbers +// .map(|card| card.trim()) // trim extra whitespace +// .map(|card| { +// card.split('|') // split winning/own numbers +// .map(|numbers| { +// numbers.trim() // trim whitespace +// .split(' ') // split into individual nums +// .filter(|x| !x.is_empty()) // remove empty strings +// .map(|x| {return x.parse::().unwrap()}) // convert to i32 +// .collect::>() +// }) +// .collect::>() +// }) +// .collect(); + +// let mut total_pts = 0; +// for card in input { +// let mut card_pts = 0; +// let winning_nums = card.first().unwrap(); +// let our_nums = card.last().unwrap(); + +// for num in our_nums { +// if winning_nums.contains(num) { +// if card_pts == 0 { +// card_pts = 1; +// } else { +// card_pts *= 2; +// } +// } +// } + +// //println!("{}", card_pts); +// total_pts += card_pts; +// } + + + +// println!("{:?}", total_pts); +// } diff --git a/old/day05/Cargo.lock b/old/day05/Cargo.lock new file mode 100644 index 0000000..7a62bb0 --- /dev/null +++ b/old/day05/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day5" +version = "0.1.0" diff --git a/old/day05/Cargo.toml b/old/day05/Cargo.toml new file mode 100644 index 0000000..f9b62bf --- /dev/null +++ b/old/day05/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "day5" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/old/day05/src/main.rs b/old/day05/src/main.rs new file mode 100644 index 0000000..8c0df6e --- /dev/null +++ b/old/day05/src/main.rs @@ -0,0 +1,93 @@ +use std::fs; + +fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + let mut mappers: Vec<_> = input.split("\n\n") + .map(|maps| &maps[(maps.find(':').unwrap() + 1)..]) + .map(|maps| maps.trim()) + .map(|maps| { + maps.split('\n') + .map(|range| { + range.split(' ') + .map(|num| num.parse::().unwrap()) + .collect::>() + }) + .collect::>() + }) + .collect(); + + let seeds = mappers.first().unwrap().first().unwrap().clone(); + let mappers: &mut [Vec>] = mappers.get_mut(1..).unwrap(); + + for mapper in mappers.into_iter() { + for range in mapper { + range[2] = range[1] + range[2] - 1; + } + } + + let mut cur_vals: Vec<_> = Vec::new(); + for i in 0..seeds.len() / 2 { + let end = seeds[i * 2] + seeds[(i * 2) + 1]; + let mut range: Vec<_> = (seeds[i * 2]..end).collect(); + cur_vals.append(&mut range); + } + println!("{}", cur_vals.len()); + for mapper in mappers { + for val in cur_vals.iter_mut() { + println!("{}", val); + for range in mapper.into_iter() { + if range[1] <= *val && *val <= range[2] { + let diff = *val - range[1]; + *val = range[0] + diff; + break; + } + } + } + } + + println!("{:?}", cur_vals.into_iter().min().unwrap()) +} + + +// use std::fs; + +// fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); +// let mut mappers: Vec<_> = input.split("\n\n") +// .map(|maps| &maps[(maps.find(':').unwrap() + 1)..]) +// .map(|maps| maps.trim()) +// .map(|maps| { +// maps.split('\n') +// .map(|range| { +// range.split(' ') +// .map(|num| num.parse::().unwrap()) +// .collect::>() +// }) +// .collect::>() +// }) +// .collect(); + +// let seeds = mappers.first().unwrap().first().unwrap().clone(); +// let mappers: &mut [Vec>] = mappers.get_mut(1..).unwrap(); + +// for mapper in mappers.into_iter() { +// for range in mapper { +// range[2] = range[1] + range[2] - 1; +// } +// } + +// let mut cur_vals: Vec<_> = seeds; +// for mapper in mappers { +// for val in cur_vals.iter_mut() { +// for range in mapper.into_iter() { +// if range[1] <= *val && *val <= range[2] { +// let diff = *val - range[1]; +// *val = range[0] + diff; +// break; +// } +// } +// } +// } + +// println!("{:?}", cur_vals.into_iter().min().unwrap()) +// } \ No newline at end of file diff --git a/old/day06/Cargo.lock b/old/day06/Cargo.lock new file mode 100644 index 0000000..a16c0bf --- /dev/null +++ b/old/day06/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day6" +version = "0.1.0" diff --git a/old/day06/Cargo.toml b/old/day06/Cargo.toml new file mode 100644 index 0000000..89d04ae --- /dev/null +++ b/old/day06/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "day6" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/old/day06/src/main.rs b/old/day06/src/main.rs new file mode 100644 index 0000000..a5f6430 --- /dev/null +++ b/old/day06/src/main.rs @@ -0,0 +1,56 @@ +use std::fs; + +fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + let input: Vec<_> = input.split('\n') // Separate the Time and Distance lines + .map(|line| { + line[line.find(':').unwrap() + 1..] // Drop "Time:" and "Distance:" + .split_whitespace() // Split the numbers into their own elements + .flat_map(|s| s.chars()).collect::() // Combine the strings into a single one + .parse::().expect("Couldn't parse number") // Parse numbers into i32 + }).collect(); // Collect into Vec + + let time = input[0]; + let dist = input[1]; + let mut valid = 0; + + for remaining_time in 0..time { + if (time - remaining_time) * remaining_time > dist { + valid += 1; + } + } + + println!("{}", valid); +} + + + +// use std::fs; + +// fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); +// let input: Vec<_> = input.split('\n') // Separate the Time and Distance lines +// .map(|line| { +// line[line.find(':').unwrap() + 1..] // Drop "Time:" and "Distance:" +// .split_whitespace() // Split the numbers into their own elements. +// .map(|num| num.parse::().expect("Couldn't parse number")) // Parse numbers into i32 +// .collect::>() +// }).collect(); // collect into Vec + +// let mut valid_total = 1; + +// for round in 0..input.first().unwrap().len() { +// let time = input[0][round]; +// let dist = input[1][round]; +// let mut valid = 0; + +// for remaining_time in 0..time { +// if (time - remaining_time) * remaining_time > dist { +// valid += 1; +// } +// } +// valid_total *= valid; +// } + +// println!("{}", valid_total); +// } diff --git a/old/day07/Cargo.lock b/old/day07/Cargo.lock new file mode 100644 index 0000000..cf14c74 --- /dev/null +++ b/old/day07/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day07" +version = "0.1.0" diff --git a/old/day07/Cargo.toml b/old/day07/Cargo.toml new file mode 100644 index 0000000..682e4ad --- /dev/null +++ b/old/day07/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "day07" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/old/day07/src/main.rs b/old/day07/src/main.rs new file mode 100644 index 0000000..d7d3eae --- /dev/null +++ b/old/day07/src/main.rs @@ -0,0 +1,183 @@ +use std::{fs, collections::HashMap}; + +fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + let mut input: Vec<_> = input.split('\n') + .map(|line| line.split(' ').collect::>()) + .collect(); + + for line in 0..input.len() { + let hand = input[line][0]; + if hand == "JJJJJ" { + input[line].push("7"); + continue; + } + let mut card_freq: HashMap = HashMap::new(); + let joker_count: i16 = hand.chars().filter(|c| c == &'J').count().try_into().unwrap(); + for card in hand.chars().filter(|c| c != &'J') { + card_freq.entry(card) + .and_modify(|count| *count += 1) + .or_insert(1); + } + + // The most helpful place for the jokers will always be with the max card count + let max = card_freq.clone().into_iter().max_by(|a, b| a.1.cmp(&b.1)).unwrap(); + card_freq.entry(max.0) + .and_modify(|count| *count += joker_count); + + let mut set_count: HashMap = HashMap::new(); + for i in 1..=5 { + let card_count = card_freq.values().filter(|x| **x == i).count().try_into().unwrap(); + if card_count != 0 { + set_count.insert(i, card_count); + } + } + + let power = match set_count { + x if x.contains_key(&5) => "7", + x if x.contains_key(&4) => "6", + x if x.contains_key(&3) && x.contains_key(&2) => "5", + x if x.contains_key(&3) => "4", + x if x.get(&2).unwrap_or(&0) >= &2 => "3", + x if x.get(&2).unwrap_or(&0) == &1 => "2", + HashMap { .. } => "1" + }; + + input[line].push(power); + } + + input.sort_by(|lhs, rhs| { + let lhs_power: i32 = lhs[2].parse().unwrap(); + let rhs_power: i32 = rhs[2].parse().unwrap(); + if lhs_power != rhs_power { + return lhs_power.cmp(&rhs_power); + } + + let lhs_hand: Vec = lhs[0].chars().map(card_value).collect(); + let rhs_hand: Vec = rhs[0].chars().map(card_value).collect(); + for i in 0..5 { + if lhs_hand[i] == rhs_hand[i] { continue; } + return lhs_hand[i].cmp(&rhs_hand[i]); + } + + panic!("Should not be reachable"); + }); + + + let mut total_winnings = 0; + for i in 0..input.len() { + let bid: usize = input[i][1].parse().unwrap(); + total_winnings += (i + 1) * bid; + } + + println!("{}", total_winnings); + + +} + + +fn card_value(card: char) -> i32 { + match card { + 'A' => 13, + 'K' => 12, + 'Q' => 11, + 'T' => 10, + '9' => 9, + '8' => 8, + '7' => 7, + '6' => 6, + '5' => 5, + '4' => 4, + '3' => 3, + '2' => 2, + 'J' => 1, + _ => panic!("invalid card") + } +} + +// use std::{fs, collections::HashMap}; + +// fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); +// let mut input: Vec<_> = input.split('\n') +// .map(|line| line.split(' ').collect::>()) +// .collect(); + +// for line in 0..input.len() { +// let hand = input[line][0]; +// let mut card_freq: HashMap = HashMap::new(); +// for card in hand.chars() { +// card_freq.entry(card) +// .and_modify(|count| *count += 1) +// .or_insert(1); +// } + +// let mut set_count: HashMap = HashMap::new(); +// for i in 1..=5 { +// let card_count = card_freq.values().filter(|x| **x == i).count().try_into().unwrap(); +// if card_count != 0 { +// set_count.insert(i, card_count); +// } +// } + +// let power = match set_count { +// x if x.contains_key(&5) => "7", +// x if x.contains_key(&4) => "6", +// x if x.contains_key(&3) && x.contains_key(&2) => "5", +// x if x.contains_key(&3) => "4", +// x if x.get(&2).unwrap_or(&0) >= &2 => "3", +// x if x.get(&2).unwrap_or(&0) == &1 => "2", +// HashMap { .. } => "1" +// }; + +// input[line].push(power); +// } + +// input.sort_by(|lhs, rhs| { +// let lhs_power: i32 = lhs[2].parse().unwrap(); +// let rhs_power: i32 = rhs[2].parse().unwrap(); +// if lhs_power != rhs_power { +// return lhs_power.cmp(&rhs_power); +// } + +// let lhs_hand: Vec = lhs[0].chars().map(card_value).collect(); +// let rhs_hand: Vec = rhs[0].chars().map(card_value).collect(); +// for i in 0..5 { +// if lhs_hand[i] == rhs_hand[i] { continue; } +// return lhs_hand[i].cmp(&rhs_hand[i]); +// } + +// panic!("Should not be reachable"); +// }); + + +// let mut total_winnings = 0; +// for i in 0..input.len() { +// let bid: usize = input[i][1].parse().unwrap(); +// total_winnings += (i + 1) * bid; +// } + +// println!("{}", total_winnings); + + +// } + + +// fn card_value(card: char) -> i32 { +// match card { +// 'A' => 13, +// 'K' => 12, +// 'Q' => 11, +// 'J' => 10, +// 'T' => 9, +// '9' => 8, +// '8' => 7, +// '7' => 6, +// '6' => 5, +// '5' => 4, +// '4' => 3, +// '3' => 2, +// '2' => 1, +// _ => panic!("invalid card") +// } +// } \ No newline at end of file diff --git a/old/day08/Cargo.lock b/old/day08/Cargo.lock new file mode 100644 index 0000000..1d4626c --- /dev/null +++ b/old/day08/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day08" +version = "0.1.0" diff --git a/old/day08/Cargo.toml b/old/day08/Cargo.toml new file mode 100644 index 0000000..7156aba --- /dev/null +++ b/old/day08/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "day08" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/old/day08/src/main.rs b/old/day08/src/main.rs new file mode 100644 index 0000000..a3ceb11 --- /dev/null +++ b/old/day08/src/main.rs @@ -0,0 +1,122 @@ +use std::{fs, collections::{HashMap, VecDeque}}; + +fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + let input: Vec<_> = input.split("\n\n").collect(); + let (directions, nodes) = (input[0], input[1]); + let directions: Vec<_> = directions.chars().map(|char| { + match char { + 'L' => Direction::Left, + 'R' => Direction::Right, + _ => panic!("Invalid direction!") + } + }).collect(); + + let nodes: HashMap<&str, (&str, &str)> = nodes.split('\n') + .map(|line| { + let line = line.split('=').map(|x| x.trim()).collect::>(); + let children: Vec<_> = line[1].trim_matches(|c| c == '(' || c == ')').split(", ").collect(); + (line[0], (children[0], children[1])) + }).collect(); + + let starts: Vec<_> = nodes.keys().filter(|x| x.ends_with('A')).collect(); + let dists: Vec<_> = starts.iter().map(|start| dist(&start, &directions, &nodes)).collect(); + + let gcf = gcf(&dists); + + let step_count = gcf * dists.iter().map(|value| value / gcf).product::(); + + println!("{:?}", step_count); +} + +fn gcf(values: &Vec) -> i64 { + let mut gcf = values[0]; + + for val in values { + gcf = find_gcf(gcf, *val); + + if gcf == 1 { + return 1; + } + } + + gcf +} + +fn find_gcf(a: i64, b: i64) -> i64 { + if a == 0 { + return b; + } + + find_gcf(b % a, a) +} + +fn dist(cur_node: &str, directions: &Vec, nodes: &HashMap<&str, (&str, &str)>) -> i64 { + let mut cur_node = cur_node; + let mut step_queue: VecDeque = VecDeque::from(directions.clone()); + let mut step_count = 0; + + while !cur_node.ends_with('Z') { + step_count += 1; + let cur_step = step_queue.pop_front().unwrap(); + match cur_step { + Direction::Left => cur_node = nodes[cur_node].0, + Direction::Right => cur_node = nodes[cur_node].1, + } + step_queue.push_back(cur_step); + } + + return step_count; +} + +#[derive(Clone)] +#[derive(Debug)] +enum Direction { + Left, + Right +} + + +// use std::{fs, collections::{HashMap, VecDeque}}; + +// fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); +// let input: Vec<_> = input.split("\n\n").collect(); +// let (directions, nodes) = (input[0], input[1]); +// let directions: Vec<_> = directions.chars().map(|char| { +// match char { +// 'L' => Direction::Left, +// 'R' => Direction::Right, +// _ => panic!("Invalid direction!") +// } +// }).collect(); + +// let nodes: HashMap<&str, (&str, &str)> = nodes.split('\n') +// .map(|line| { +// let line = line.split('=').map(|x| x.trim()).collect::>(); +// let children: Vec<_> = line[1].trim_matches(|c| c == '(' || c == ')').split(", ").collect(); +// (line[0], (children[0], children[1])) +// }).collect(); + +// let mut cur_node = "AAA"; +// let mut step_queue = VecDeque::from(directions); +// let mut step_count = 0; + +// while cur_node != "ZZZ" { +// step_count += 1; +// let cur_step = step_queue.pop_front().unwrap(); +// match cur_step { +// Direction::Left => cur_node = nodes[cur_node].0, +// Direction::Right => cur_node = nodes[cur_node].1, +// } +// step_queue.push_back(cur_step); +// } + +// println!("{:?}", step_count); +// } + +// #[derive(Debug)] +// enum Direction { +// Left, +// Right +// } diff --git a/old/day09/Cargo.lock b/old/day09/Cargo.lock new file mode 100644 index 0000000..8aa567a --- /dev/null +++ b/old/day09/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day09" +version = "0.1.0" diff --git a/old/day09/Cargo.toml b/old/day09/Cargo.toml new file mode 100644 index 0000000..15d9cf9 --- /dev/null +++ b/old/day09/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "day09" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/old/day09/src/main.rs b/old/day09/src/main.rs new file mode 100644 index 0000000..745222c --- /dev/null +++ b/old/day09/src/main.rs @@ -0,0 +1,70 @@ +use std::fs; + +fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + let input: Vec<_> = input.split('\n') + .map(|line| { + line.split_whitespace() + .map(|num| num.parse::().unwrap()) + .collect::>() + }).collect(); + + let mut total = 0; + + for line in input { + let mut line_starters: Vec = vec![*line.first().unwrap()]; + let mut cur_line: Vec = line; + while !cur_line.iter().all(|x| *x == 0) { + let mut next_line: Vec = vec![]; + for i in 1..cur_line.len() { + let diff = cur_line[i] - cur_line[i-1]; + next_line.push(diff) + } + line_starters.push(*next_line.first().unwrap()); + cur_line = next_line; + } + + let mut sum = 0; + for i in (1..line_starters.len()).rev() { + sum = line_starters[i - 1] - sum; + } + total += sum; + } + println!("{:?}", total) +} + + +// use std::fs; + +// fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); +// let input: Vec<_> = input.split('\n') +// .map(|line| { +// line.split_whitespace() +// .map(|num| num.parse::().unwrap()) +// .collect::>() +// }).collect(); + +// let mut total = 0; + +// for line in input { +// let mut line_enders: Vec = vec![*line.last().unwrap()]; +// let mut cur_line: Vec = line; +// while !cur_line.iter().all(|x| *x == 0) { +// let mut next_line: Vec = vec![]; +// for i in 1..cur_line.len() { +// let diff = cur_line[i] - cur_line[i-1]; +// next_line.push(diff) +// } +// line_enders.push(*next_line.last().unwrap()); +// cur_line = next_line; +// } + +// let mut sum = 0; +// for i in (1..line_enders.len()).rev() { +// sum = sum + line_enders[i - 1]; +// } +// total += sum; +// } +// println!("{:?}", total) +// } diff --git a/old/day10/Cargo.lock b/old/day10/Cargo.lock new file mode 100644 index 0000000..f5438c5 --- /dev/null +++ b/old/day10/Cargo.lock @@ -0,0 +1,77 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day10" +version = "0.1.0" +dependencies = [ + "strum", + "strum_macros", +] + +[[package]] +name = "heck" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" + +[[package]] +name = "proc-macro2" +version = "1.0.70" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39278fbbf5fb4f646ce651690877f89d1c5811a3d4acb27700c1cb3cdb78fd3b" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rustversion" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4" + +[[package]] +name = "strum" +version = "0.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125" + +[[package]] +name = "strum_macros" +version = "0.25.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "rustversion", + "syn", +] + +[[package]] +name = "syn" +version = "2.0.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44c8b28c477cc3bf0e7966561e3460130e1255f7a1cf71931075f1c5e7a7e269" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "unicode-ident" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" diff --git a/old/day10/Cargo.toml b/old/day10/Cargo.toml new file mode 100644 index 0000000..d7883d0 --- /dev/null +++ b/old/day10/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "day10" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +strum = "0.25.0" +strum_macros = "0.25" diff --git a/old/day10/src/main.rs b/old/day10/src/main.rs new file mode 100644 index 0000000..43aa4cc --- /dev/null +++ b/old/day10/src/main.rs @@ -0,0 +1,234 @@ +use std::fs; +use strum::IntoEnumIterator; +use strum_macros::EnumIter; + +fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + let input = parse_input(&input); + let start = find_start(&input); + + let mut start_dirs: Vec = vec![]; + for dir in Direction::iter().filter(|x| x != &Direction::Start) { + let (x, y) = ((start.0 as i32 + dir.to_ind().1), (start.1 as i32 + dir.to_ind().0)); + if x < 0 || y < 0 { + continue; + } + let neibhor = &input[x as usize][y as usize]; + if neibhor.contains(&dir.reverse()) { + start_dirs.push(dir); + } + } + + let mut finished = false; + + let mut pre = start_dirs[0].reverse(); + let mut pos = ((start.0 as i32 + start_dirs[0].to_ind().1) as usize, (start.1 as i32 + start_dirs[0].to_ind().0) as usize); + + let mut the_loop = vec![start, pos]; + let mut area = 0; + + while !finished { + let first_next = &input[pos.0][pos.1].iter().filter(|x| x != &&pre).next().unwrap(); + pos = ((pos.0 as i32 + first_next.to_ind().1) as usize, (pos.1 as i32 + first_next.to_ind().0) as usize); + pre = first_next.reverse(); + + finished = pos == start; + the_loop.push(pos); + } + + + for win in the_loop.windows(2) { + area += (win[0].1 * win[1].0) as i64; + area -= (win[0].0 * win[1].1) as i64; + } + let area = i64::abs(area) / 2; + + let spaces = area - (the_loop.len() as i64 / 2) + 1; + + println!("{}", spaces) + +} + +fn parse_input(input: &String) -> Vec>> { + let input: Vec<_> = input.split('\n') + .map(|line| { + line.chars() + .map(|char| { + match char { + '|' => vec![Direction::North, Direction::South], + '-' => vec![Direction::East, Direction::West], + 'L' => vec![Direction::North, Direction::East], + 'J' => vec![Direction::North, Direction::West], + '7' => vec![Direction::South, Direction::West], + 'F' => vec![Direction::South, Direction::East], + '.' => vec![], + 'S' => vec![Direction::Start], + _ => panic!("Invalid pipe char") + } + }).collect::>() + }).collect(); + return input; +} + +fn find_start(input: &Vec>>) -> (usize, usize) { + let mut start_point: Option<(usize, usize)> = None; + for i in 0..input.len() { + for j in 0..input[0].len() { + if input[i][j].contains(&Direction::Start) { + start_point = Some((i,j)); + } + } + } + + match start_point { + Some(x) => x, + None => panic!("No start point found! AHHHHH") + } +} + +#[derive(Debug, PartialEq, EnumIter)] +enum Direction { + North, + South, + East, + West, + Start +} + +impl Direction { + pub fn to_ind(&self) -> (i32, i32) { + match self { + Direction::North => (0,-1), + Direction::South => (0,1), + Direction::East => (1,0), + Direction::West => (-1,0), + Direction::Start => panic!("Start should never be converted to an index. AHH"), + } + } + + pub fn reverse(&self) -> Direction { + match self { + Direction::North => Direction::South, + Direction::South => Direction::North, + Direction::East => Direction::West, + Direction::West => Direction::East, + Direction::Start => panic!("Start should never be reversed. AHH"), + } + } +} + + +// use std::fs; +// use strum::IntoEnumIterator; +// use strum_macros::EnumIter; + +// fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); +// let input = parse_input(&input); +// let start = find_start(&input); + +// let mut start_dirs: Vec = vec![]; +// for dir in Direction::iter().filter(|x| x != &Direction::Start) { +// let (x, y) = ((start.0 as i32 + dir.to_ind().1), (start.1 as i32 + dir.to_ind().0)); +// if x < 0 || y < 0 { +// continue; +// } +// let neibhor = &input[x as usize][y as usize]; +// if neibhor.contains(&dir.reverse()) { +// start_dirs.push(dir); +// } +// } + +// let mut finished = false; +// let mut count = 1; + +// let mut first_pre = start_dirs[0].reverse(); +// let mut second_pre = start_dirs[1].reverse(); +// let mut first_pos = ((start.0 as i32 + start_dirs[0].to_ind().1) as usize, (start.1 as i32 + start_dirs[0].to_ind().0) as usize); +// let mut second_pos = ((start.0 as i32 + start_dirs[1].to_ind().1) as usize, (start.1 as i32 + start_dirs[1].to_ind().0) as usize); + +// while !finished { +// let first_next = &input[first_pos.0][first_pos.1].iter().filter(|x| x != &&first_pre).next().unwrap(); +// first_pos = ((first_pos.0 as i32 + first_next.to_ind().1) as usize, (first_pos.1 as i32 + first_next.to_ind().0) as usize); +// first_pre = first_next.reverse(); + +// let second_next = &input[second_pos.0][second_pos.1].iter().filter(|x| x != &&second_pre).next().unwrap(); +// second_pos = ((second_pos.0 as i32 + second_next.to_ind().1) as usize, (second_pos.1 as i32 + second_next.to_ind().0) as usize); +// second_pre = second_next.reverse(); + +// count += 1; +// finished = first_pos == second_pos; + +// } + + +// println!("{:?}", count) +// } + +// fn parse_input(input: &String) -> Vec>> { +// let input: Vec<_> = input.split('\n') +// .map(|line| { +// line.chars() +// .map(|char| { +// match char { +// '|' => vec![Direction::North, Direction::South], +// '-' => vec![Direction::East, Direction::West], +// 'L' => vec![Direction::North, Direction::East], +// 'J' => vec![Direction::North, Direction::West], +// '7' => vec![Direction::South, Direction::West], +// 'F' => vec![Direction::South, Direction::East], +// '.' => vec![], +// 'S' => vec![Direction::Start], +// _ => panic!("Invalid pipe char") +// } +// }).collect::>() +// }).collect(); +// return input; +// } + +// fn find_start(input: &Vec>>) -> (usize, usize) { +// let mut start_point: Option<(usize, usize)> = None; +// for i in 0..input.len() { +// for j in 0..input[0].len() { +// if input[i][j].contains(&Direction::Start) { +// start_point = Some((i,j)); +// } +// } +// } + +// match start_point { +// Some(x) => x, +// None => panic!("No start point found! AHHHHH") +// } +// } + +// #[derive(Debug, PartialEq, EnumIter)] +// enum Direction { +// North, +// South, +// East, +// West, +// Start +// } + +// impl Direction { +// pub fn to_ind(&self) -> (i32, i32) { +// match self { +// Direction::North => (0,-1), +// Direction::South => (0,1), +// Direction::East => (1,0), +// Direction::West => (-1,0), +// Direction::Start => panic!("Start should never be converted to an index. AHH"), +// } +// } + +// pub fn reverse(&self) -> Direction { +// match self { +// Direction::North => Direction::South, +// Direction::South => Direction::North, +// Direction::East => Direction::West, +// Direction::West => Direction::East, +// Direction::Start => panic!("Start should never be reversed. AHH"), +// } +// } +// } \ No newline at end of file diff --git a/old/day11/Cargo.lock b/old/day11/Cargo.lock new file mode 100644 index 0000000..4ab9be8 --- /dev/null +++ b/old/day11/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day11" +version = "0.1.0" diff --git a/old/day11/Cargo.toml b/old/day11/Cargo.toml new file mode 100644 index 0000000..8f5b9a5 --- /dev/null +++ b/old/day11/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "day11" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/old/day11/src/main.rs b/old/day11/src/main.rs new file mode 100644 index 0000000..2c1423b --- /dev/null +++ b/old/day11/src/main.rs @@ -0,0 +1,121 @@ +use std::fs; + +fn main() { + let input = fs::read_to_string("input.txt").unwrap(); + let input: Vec<_> = input.split('\n') + .map(|x| x.chars().collect::>()) + .collect(); + + let mut y_expand: Vec = vec![]; + for line in &input { + if line.iter().all(|char| char == &'.') { + y_expand.push(1); + } else { + y_expand.push(0); + } + } + + let mut x_expand: Vec = vec![]; + for j in 0..input[0].len() { + let mut is_empty = true; + for i in 0..input.len() { + if input[i][j] != '.' { + is_empty = false; + } + } + if is_empty { + x_expand.push(1); + } else { + x_expand.push(0); + } + } + + // println!("{:?}", x_expand); + + let mut galaxies: Vec<(i64, i64)> = vec![]; + + let mut y_offset: i64 = 0; + + for (i, line) in input.iter().enumerate() { + if y_expand[i] == 1 { + y_offset += 1000000 - 1; + } + let mut x_offset: i64 = 0; + + for (j, char) in line.iter().enumerate() { + if x_expand[j] == 1 { + x_offset += 1000000 - 1; + } + if char == &'#' { + galaxies.push((i as i64 + y_offset, j as i64 + x_offset)); + } + } + } + + let dist_total = galaxies.clone().into_iter().enumerate() + .fold(0, |mut acc, (i, gal)| { + for next in &galaxies[i + 1..] { + acc += gal.0.abs_diff(next.0) + gal.1.abs_diff(next.1); + } + acc + }); + + println!("{:?}", dist_total); + +} + +// use std::fs; + +// fn main() { +// let input = fs::read_to_string("input.txt").unwrap(); +// let input: Vec<_> = input.split('\n') +// .map(|x| x.chars().collect::>()) +// .collect(); + +// let mut rotate: Vec> = vec![]; +// for j in 0..input[0].len() { +// let mut tmp: Vec = vec![]; +// for i in 0..input.len() { +// tmp.push(input[i][j]); +// } + +// if tmp.iter().all(|x| x == &'.') { +// rotate.push(tmp.clone()); +// } +// rotate.push(tmp); +// } + + +// let mut expanded: Vec> = vec![]; +// for j in 0..rotate[0].len() { +// let mut tmp: Vec = vec![]; +// for i in 0..rotate.len() { +// tmp.push(rotate[i][j]); +// } +// if tmp.iter().all(|x| x == &'.') { +// expanded.push(tmp.clone()); +// } +// expanded.push(tmp); +// } + +// let mut galaxies: Vec<(i32, i32)> = vec![]; + +// for (i, line) in expanded.iter().enumerate() { +// for (j, char) in line.iter().enumerate() { +// if char == &'#' { +// galaxies.push((i as i32,j as i32)); +// } +// } +// } + +// let dist_total = galaxies.clone().into_iter().enumerate() +// .fold(0, |mut acc, (i, gal)| { +// for next in &galaxies[i + 1..] { +// acc += gal.0.abs_diff(next.0) + gal.1.abs_diff(next.1); +// } +// acc +// }); + +// println!("{:?}", dist_total); + +// } \ No newline at end of file diff --git a/old/day12/Cargo.lock b/old/day12/Cargo.lock new file mode 100644 index 0000000..5f2a393 --- /dev/null +++ b/old/day12/Cargo.lock @@ -0,0 +1,25 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day12" +version = "0.1.0" +dependencies = [ + "itertools", +] + +[[package]] +name = "either" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" + +[[package]] +name = "itertools" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25db6b064527c5d482d0423354fcd07a89a2dfe07b67892e62411946db7f07b0" +dependencies = [ + "either", +] diff --git a/old/day12/Cargo.toml b/old/day12/Cargo.toml new file mode 100644 index 0000000..caf7178 --- /dev/null +++ b/old/day12/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "day12" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +itertools = "0.12.0" diff --git a/old/day12/src/main.rs b/old/day12/src/main.rs new file mode 100644 index 0000000..84d7474 --- /dev/null +++ b/old/day12/src/main.rs @@ -0,0 +1,54 @@ +use std::fs; + +use itertools::Itertools; + +fn main() { + let input = parse_input(); + + for (springs, groups) in input { + println!("{:?} {:?}", springs, groups); + } +} + +fn parse_input() -> Vec<(Vec, Vec)> { + let input = fs::read_to_string("input.txt").unwrap(); + let input: Vec<(Vec, Vec)> = input.split('\n') + .map(|line| { + line.split(' ') + .collect_tuple() + .unwrap() + }).map(|(springs, groups)| { + let springs: Vec = springs.chars() + .map(|char| { + char.to_condition() + }).collect(); + + let groups: Vec<_> = groups.split(',') + .map(|num| num.parse::().expect("Failed to parse group len")) + .collect(); + (springs, groups) + }).collect(); + input +} + +#[derive(Debug)] +enum Condition { + Good, + Bad, + WhoKnows +} + +trait ConditionConvertable { + fn to_condition(self) -> Condition; +} + +impl ConditionConvertable for char { + fn to_condition(self) -> Condition { + match self { + '.' => Condition::Good, + '#' => Condition::Bad, + '?' => Condition::WhoKnows, + _ => panic!("Invalid spring char AHHH") + } + } +}