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

//! # Day 13: A Maze of Twisty Little Cubicles
//!
//! You arrive at the first floor of this new building to discover a much less welcoming environment
//! than the shiny atrium of the last one. Instead, you are in a maze of twisty little cubicles, all
//! alike.
//!
//! Every location in this area is addressed by a pair of non-negative integers (`x,y`). Each such
//! coordinate is either a wall or an open space. You can't move diagonally. The cube maze starts at
//! `0,0` and seems to extend infinitely toward **positive** `x` and `y`; negative values are
//! **invalid**, as they represent a location outside the building. You are in a small waiting area
//! at `1,1`.
//!
//! While it seems chaotic, a nearby morale-boosting poster explains, the layout is actually quite
//! logical. You can determine whether a given `x,y` coordinate will be a wall or an open space
//! using a simple system:
//!
//! - Find `x*x + 3*x + 2*x*y + y + y*y`.
//! - Add the office designer's favorite number (your puzzle input).
//! - Find the [binary representation] of that sum; count the **number** of [bits] that are `1`.
//!   - If the number of bits that are `1` is **even**, it's an **open space**.
//!   - If the number of bits that are `1` is **odd**, it's a **wall**.
//!
//! For example, if the office designer's favorite number were `10`, drawing walls as `#` and open
//! spaces as `.`, the corner of the building containing `0,0` would look like this:
//!
//! ```txt
//!   0123456789
//! 0 .#.####.##
//! 1 ..#..#...#
//! 2 #....##...
//! 3 ###.#.###.
//! 4 .##..#..#.
//! 5 ..##....#.
//! 6 #...##.###
//! ```
//!
//! Now, suppose you wanted to reach `7,4`. The shortest route you could take is marked as `O`:
//!
//! ```txt
//!   0123456789
//! 0 .#.####.##
//! 1 .O#..#...#
//! 2 #OOO.##...
//! 3 ###O#.###.
//! 4 .##OO#OO#.
//! 5 ..##OOO.#.
//! 6 #...##.###
//! ```
//!
//! Thus, reaching `7,4` would take a minimum of `11` steps (starting from your current location,
//! `1,1`).
//!
//! What is the **fewest number of steps required** for you to reach `31,39`?
//!
//! [binary representation]: https://en.wikipedia.org/wiki/Binary_number
//! [bits]: https://en.wikipedia.org/wiki/Bit

use anyhow::Result;

pub const INPUT: &str = include_str!("d13.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() {}
}