ZennDev1337/Advent-of-Code
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

first commit

Browse source
This commit is contained in:
Zenn 2023-09-12 09:55:00 +02:00
commit cfe3798d17
42 changed files with 9617 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

195
2022/day5/src/main.rs Executable file
View file

@ -0,0 +1,195 @@
use std::{
fs::File,
io::{Read, Result},
};
#[derive(Debug)]
struct Playground {
stack1: Vec<char>,
stack2: Vec<char>,
stack3: Vec<char>,
stack4: Vec<char>,
stack5: Vec<char>,
stack6: Vec<char>,
stack7: Vec<char>,
stack8: Vec<char>,
stack9: Vec<char>,
}
impl Playground {
fn new() -> Playground {
Playground {
stack1: vec![],
stack2: vec![],
stack3: vec![],
stack4: vec![],
stack5: vec![],
stack6: vec![],
stack7: vec![],
stack8: vec![],
stack9: vec![],
}
}
fn print_result(&mut self) {
println!(
"{}{}{}{}{}{}{}{}{}",
self.stack1.pop().unwrap(),
self.stack2.pop().unwrap(),
self.stack3.pop().unwrap(),
self.stack4.pop().unwrap(),
self.stack5.pop().unwrap(),
self.stack6.pop().unwrap(),
self.stack7.pop().unwrap(),
self.stack8.pop().unwrap(),
self.stack9.pop().unwrap(),
)
}
fn move_crain(&mut self, turn: &Turn) {
for _ in 0..turn.amount {
let from = match turn.from {
1 => &mut self.stack1,
2 => &mut self.stack2,
3 => &mut self.stack3,
4 => &mut self.stack4,
5 => &mut self.stack5,
6 => &mut self.stack6,
7 => &mut self.stack7,
8 => &mut self.stack8,
9 => &mut self.stack9,
_ => &mut self.stack1,
};
let c = from.pop().unwrap().to_owned();
drop(from);
let to = match turn.to {
1 => &mut self.stack1,
2 => &mut self.stack2,
3 => &mut self.stack3,
4 => &mut self.stack4,
5 => &mut self.stack5,
6 => &mut self.stack6,
7 => &mut self.stack7,
8 => &mut self.stack8,
9 => &mut self.stack9,
_ => &mut self.stack1,
};
to.push(c)
}
}
fn move_crain9001(&mut self, turn: &Turn) {
let mut mov: Vec<char> = vec![];
for _ in 0..turn.amount {
let from = match turn.from {
1 => &mut self.stack1,
2 => &mut self.stack2,
3 => &mut self.stack3,
4 => &mut self.stack4,
5 => &mut self.stack5,
6 => &mut self.stack6,
7 => &mut self.stack7,
8 => &mut self.stack8,
9 => &mut self.stack9,
_ => &mut self.stack1,
};
let c = from.pop().unwrap().to_owned();
drop(from);
mov.push(c)
}
let to = match turn.to {
1 => &mut self.stack1,
2 => &mut self.stack2,
3 => &mut self.stack3,
4 => &mut self.stack4,
5 => &mut self.stack5,
6 => &mut self.stack6,
7 => &mut self.stack7,
8 => &mut self.stack8,
9 => &mut self.stack9,
_ => &mut self.stack1,
};
for _ in 0..mov.len() {
to.push(mov.pop().unwrap())
}
}
}
#[derive(Debug)]
struct Turn {
amount: i32,
from: i32,
to: i32,
}
fn load_playground_data(content: &String) -> Playground {
let mut playground = Playground::new();
let cont = content.lines().take(8).collect::<Vec<&str>>();
cont.iter().rev().for_each(|s| {
s.chars().enumerate().for_each(|(i, c)| {
if c == ' ' {
return;
}
let c = c.clone();
match i {
1 => playground.stack1.push(c),
5 => playground.stack2.push(c),
9 => playground.stack3.push(c),
13 => playground.stack4.push(c),
17 => playground.stack5.push(c),
21 => playground.stack6.push(c),
25 => playground.stack7.push(c),
29 => playground.stack8.push(c),
33 => playground.stack9.push(c),
_ => (),
}
});
});
playground
}
fn load_play_data(content: &String) -> Vec<Turn> {
let mut turns: Vec<Turn> = Vec::new();
let binding = content
.lines()
.collect::<Vec<&str>>()
.splice(10.., [])
.collect::<Vec<&str>>();
binding.iter().for_each(|s| {
let t = s
.split(" ")
.filter(|c| c.parse::<i32>().is_ok())
.map(|d| d.parse::<i32>().unwrap())
.collect::<Vec<i32>>();
turns.push(Turn {
amount: t[0],
from: t[1],
to: t[2],
})
});
turns
}
fn load_file() -> Result<String> {
let mut file = File::open("./data").expect("Data file not found");
let mut content = String::new();
file.read_to_string(&mut content)?;
Ok(content)
}
fn run(part: i32) {
let content = load_file().unwrap();
let mut playground = load_playground_data(&content);
let turns = load_play_data(&content);
for turn in turns.iter() {
if part == 1 {
playground.move_crain9001(turn);
} else {
playground.move_crain(turn);
}
}
println!("Result of part {}:", part);
playground.print_result();
}
fn main() -> Result<()> {
run(1);
run(2);
Ok(())
}