88 lines
2.6 KiB
Rust
88 lines
2.6 KiB
Rust
struct Crt {
|
|
screen: [bool; 40 * 6],
|
|
}
|
|
|
|
impl Crt {
|
|
fn new() -> Crt {
|
|
Crt {
|
|
screen: [false; 40 * 6],
|
|
}
|
|
}
|
|
|
|
fn process_cycle(&mut self, cycle: usize, x: i32) {
|
|
// Split cycle into corresponding line and column.
|
|
let col = (cycle as i32) % 40;
|
|
|
|
// Set the current pixel if the current column and the
|
|
// sprite painted by the current x value overlap.
|
|
self.screen[cycle] = (x - 1) == col || x == col || (x + 1) == col;
|
|
}
|
|
|
|
fn print(&self) {
|
|
for (i, x) in self.screen.iter().enumerate() {
|
|
// Print `##` or `. ` depending on bool value.
|
|
print!("{}", if *x { "##" } else { ". " });
|
|
// Print a newline every 40 characters.
|
|
if (i + 1) % 40 == 0 {
|
|
println!();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
// Use command line arguments to specify the input filename.
|
|
let args: Vec<String> = std::env::args().collect();
|
|
if args.len() < 2 {
|
|
panic!("Usage: ./main <input-file>\nNo input file provided. Exiting.");
|
|
}
|
|
|
|
// Next, read the contents of the input file into a string for easier processing.
|
|
let input = std::fs::read_to_string(&args[1]).expect("Error opening file");
|
|
// Line-by-line processing is easiest.
|
|
let input = input.lines();
|
|
|
|
// --- TASK BEGIN ---
|
|
|
|
// Keep track of the current value of X for all the instructions.
|
|
// We'll use one massive vector for that purpose.
|
|
let mut x_over_time: Vec<i32> = Vec::with_capacity(512);
|
|
|
|
// Keep track of the actual x as well.
|
|
let mut x = 1;
|
|
|
|
// Then, process line-by-line.
|
|
for line in input {
|
|
// Split by space.
|
|
let line: Vec<_> = line.split(' ').collect();
|
|
|
|
// Differentiate by instruction
|
|
match line[0] {
|
|
"noop" => {
|
|
// Nothing changes.
|
|
x_over_time.push(x);
|
|
}
|
|
"addx" => {
|
|
// Addition is complete *after* two cycles.
|
|
// So during those two cycles x has the old value still.
|
|
x_over_time.push(x);
|
|
x_over_time.push(x);
|
|
// Of course, afterwards the value of x is updated.
|
|
x += line[1].parse::<i32>().unwrap();
|
|
}
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
// Reserve the CRT and ...
|
|
let mut crt = Crt::new();
|
|
|
|
// ... iterate over all cycles to compute what would be shown on the screen.
|
|
for (i, x) in x_over_time.iter().enumerate() {
|
|
crt.process_cycle(i, *x);
|
|
}
|
|
|
|
// Finally, print said screen.
|
|
crt.print();
|
|
}
|