110 lines
2.6 KiB
Rust
110 lines
2.6 KiB
Rust
use std::collections::HashMap;
|
|
#[derive(Debug, PartialOrd, PartialEq)]
|
|
struct CubeSet {
|
|
red: usize,
|
|
blue: usize,
|
|
green: usize,
|
|
}
|
|
|
|
type CubeMap = HashMap<usize, Vec<CubeSet>>;
|
|
|
|
fn parse_colors(raw_colors: Vec<&str>) -> CubeSet {
|
|
let mut red = 0usize;
|
|
let mut green = 0usize;
|
|
let mut blue = 0usize;
|
|
|
|
for raw_color in raw_colors {
|
|
let color_split: Vec<&str> = raw_color
|
|
.split(' ')
|
|
.map(|s| s.trim())
|
|
.filter(|s| s.len() > 0)
|
|
.collect();
|
|
let [num_str, color] = color_split[..] else {
|
|
panic!("Bad color row")
|
|
};
|
|
let num = num_str.parse::<usize>().unwrap();
|
|
|
|
match color {
|
|
"red" => {
|
|
red = num;
|
|
}
|
|
"blue" => {
|
|
blue = num;
|
|
}
|
|
"green" => {
|
|
green = num;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
CubeSet { red, blue, green }
|
|
}
|
|
|
|
fn parse_game(line: &str, map: &mut CubeMap) {
|
|
let mut draws: Vec<CubeSet> = Vec::new();
|
|
let raw: Vec<&str> = line.split(": ").map(|s| s.trim()).collect();
|
|
if raw.len() < 2 {
|
|
return;
|
|
}
|
|
let [raw_id, raw_game] = raw[..] else {
|
|
panic!("Bad input row")
|
|
};
|
|
let id = raw_id.replace("Game ", "").parse::<usize>().unwrap();
|
|
|
|
let pulls: Vec<&str> = raw_game.split(';').collect();
|
|
for i in 0..pulls.len() {
|
|
let raw_colors = pulls[i].split(", ").collect();
|
|
draws.push(parse_colors(raw_colors));
|
|
}
|
|
|
|
map.insert(id, draws);
|
|
}
|
|
|
|
fn is_valid(reference: &CubeSet, comparison: &CubeSet) -> bool {
|
|
reference.green >= comparison.green
|
|
&& reference.blue >= comparison.blue
|
|
&& reference.red >= comparison.red
|
|
}
|
|
|
|
fn filter_valid_games(reference: &CubeSet, games: CubeMap) -> CubeMap {
|
|
games
|
|
.into_iter()
|
|
.filter(|(_, cubes)| cubes.iter().all(|c| is_valid(reference, c)))
|
|
.collect()
|
|
}
|
|
|
|
fn validate_games(reference: &CubeSet, games: CubeMap) -> Vec<usize> {
|
|
filter_valid_games(reference, games)
|
|
.into_iter()
|
|
.map(|(id, _)| id)
|
|
.collect()
|
|
}
|
|
|
|
fn find_min_cubes(valid_games: &CubeMap) -> CubeMap {
|
|
let games = valid_games.clone().to_owned();
|
|
todo!();
|
|
}
|
|
|
|
fn main() {
|
|
let file_str = include_str!("input.txt");
|
|
let mut map: CubeMap = HashMap::new();
|
|
let reference = CubeSet {
|
|
red: 12,
|
|
green: 13,
|
|
blue: 14,
|
|
};
|
|
|
|
file_str
|
|
.split('\n')
|
|
.for_each(|line| parse_game(line, &mut map));
|
|
|
|
let valid = validate_games(&reference, map);
|
|
let sum: usize = valid.into_iter().sum();
|
|
|
|
println!("Part 1 Sum of valid games: {}", sum);
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {}
|