1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

//! # Day 25: The Halting Problem
//!
//! Following the twisty passageways deeper and deeper into the CPU, you finally reach the core of
//! the computer. Here, in the expansive central chamber, you find a grand apparatus that fills the
//! entire room, suspended nanometers above your head.
//!
//! You had always imagined CPUs to be noisy, chaotic places, bustling with activity. Instead, the
//! room is quiet, motionless, and dark.
//!
//! Suddenly, you and the CPU's **garbage collector** startle each other. "It's not often we get
//! many visitors here!", he says. You inquire about the stopped machinery.
//!
//! "It stopped milliseconds ago; not sure why. I'm a garbage collector, not a doctor." You ask what
//! the machine is for.
//!
//! "Programs these days, don't know their origins. That's the **Turing machine**! It's what makes
//! the whole computer work." You try to explain that Turing machines are merely models of
//! computation, but he cuts you off. "No, see, that's just what they **want** you to think.
//! Ultimately, inside every CPU, there's a Turing machine driving the whole thing! Too bad this
//! one's broken. [We're doomed!]"
//!
//! You ask how you can help. "Well, unfortunately, the only way to get the computer running again
//! would be to create a whole new Turing machine from scratch, but there's no **way** you can-" He
//! notices the look on your face, gives you a curious glance, shrugs, and goes back to sweeping the
//! floor.
//!
//! You find the **Turing machine blueprints** (your puzzle input) on a tablet in a nearby pile of
//! debris. Looking back up at the broken Turing machine above, you can start to identify its parts:
//!
//! - A **tape** which contains `0` repeated infinitely to the left and right.
//! - A **cursor**, which can move left or right along the tape and read or write values at its
//!   current position.
//! - A set of **states**, each containing rules about what to do based on the current value under
//!   the cursor.
//!
//! Each slot on the tape has two possible values: `0` (the starting value for all slots) and `1`.
//! Based on whether the cursor is pointing at a `0` or a `1`, the current state says **what value
//! to write** at the current position of the cursor, whether to **move the cursor** left or right
//! one slot, and **which state to use next**.
//!
//! For example, suppose you found the following blueprint:
//!
//! ```txt
//! Begin in state A.
//! Perform a diagnostic checksum after 6 steps.
//!
//! In state A:
//!   If the current value is 0:
//!     - Write the value 1.
//!     - Move one slot to the right.
//!     - Continue with state B.
//!   If the current value is 1:
//!     - Write the value 0.
//!     - Move one slot to the left.
//!     - Continue with state B.
//!
//! In state B:
//!   If the current value is 0:
//!     - Write the value 1.
//!     - Move one slot to the left.
//!     - Continue with state A.
//!   If the current value is 1:
//!     - Write the value 1.
//!     - Move one slot to the right.
//!     - Continue with state A.
//! ```
//!
//! Running it until the number of steps required to take the listed **diagnostic checksum** would
//! result in the following tape configurations (with the **cursor** marked in square brackets):
//!
//! ```txt
//! ... 0  0  0 [0] 0  0 ... (before any steps; about to run state A)
//! ... 0  0  0  1 [0] 0 ... (after 1 step;     about to run state B)
//! ... 0  0  0 [1] 1  0 ... (after 2 steps;    about to run state A)
//! ... 0  0 [0] 0  1  0 ... (after 3 steps;    about to run state B)
//! ... 0 [0] 1  0  1  0 ... (after 4 steps;    about to run state A)
//! ... 0  1 [1] 0  1  0 ... (after 5 steps;    about to run state B)
//! ... 0  1  1 [0] 1  0 ... (after 6 steps;    about to run state A)
//! ```
//!
//! The CPU can confirm that the Turing machine is working by taking a **diagnostic checksum** after
//! a specific number of steps (given in the blueprint). Once the specified number of steps have
//! been executed, the Turing machine should pause; once it does, count the number of times `1`
//! appears on the tape. In the above example, the **diagnostic checksum** is **`3`**.
//!
//! Recreate the Turing machine and save the computer! **What is the diagnostic checksum** it
//! produces once it's working again?
//!
//! [We're doomed!]: https://www.youtube.com/watch?v=cTwZZz0HV8I

use anyhow::Result;

pub const INPUT: &str = include_str!("d25.txt");

pub fn solve_part_one(input: &str) -> Result<i64> {
    Ok(0)
}

pub fn solve_part_two(input: &str) -> Result<i64> {
    Ok(0)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn part_one() {}

    #[test]
    fn part_two() {}
}