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

//! # Day 18: Like a Rogue
//!
//! As you enter this room, you hear a loud click! Some of the tiles in the floor here seem to be
//! pressure plates for [traps], and the trap you just triggered has run out of... whatever it tried
//! to do to you. You doubt you'll be so lucky next time.
//!
//! Upon closer examination, the traps and safe tiles in this room seem to follow a pattern. The
//! tiles are arranged into rows that are all the same width; you take note of the safe tiles (`.`)
//! and traps (`^`) in the first row (your puzzle input).
//!
//! The type of tile (trapped or safe) in each row is based on the types of the tiles in the same
//! position, and to either side of that position, in the previous row. (If either side is off
//! either end of the row, it counts as "safe" because there isn't a trap embedded in the wall.)
//!
//! For example, suppose you know the first row (with tiles marked by letters) and want to determine
//! the next row (with tiles marked by numbers):
//!
//! ```txt
//! ABCDE
//! 12345
//! ```
//!
//! The type of tile `2` is based on the types of tiles `A`, `B`, and `C`; the type of tile `5` is
//! based on tiles `D`, `E`, and an imaginary "safe" tile. Let's call these three tiles from the
//! previous row the **left**, **center**, and **right** tiles, respectively. Then, a new tile is a
//! **trap** only in one of the following situations:
//!
//! - Its **left** and **center** tiles are traps, but its **right** tile is not.
//! - Its **center** and **right** tiles are traps, but its **left** tile is not.
//! - Only its **left** tile is a trap.
//! - Only its **right** tile is a trap.
//!
//! In any other situation, the new tile is safe.
//!
//! Then, starting with the row `..^^.`, you can determine the next row by applying those rules to
//! each new tile:
//!
//! - The leftmost character on the next row considers the left (nonexistent, so we assume "safe"),
//!   center (the first `.`, which means "safe"), and right (the second `.`, also "safe") tiles on
//!   the previous row. Because all of the trap rules require a trap in at least one of the previous
//!   three tiles, the first tile on this new row is also safe, `.`.
//! - The second character on the next row considers its left (`.`), center (`.`), and right (`^`)
//!   tiles from the previous row. This matches the fourth rule: only the right tile is a trap.
//!   Therefore, the next tile in this new row is a trap, `^`.
//! - The third character considers `.^^`, which matches the second trap rule: its center and right
//!   tiles are traps, but its left tile is not. Therefore, this tile is also a trap, `^`.
//! - The last two characters in this new row match the first and third rules, respectively, and so
//!   they are both also traps, `^`.
//!
//! After these steps, we now know the next row of tiles in the room: `.^^^^`. Then, we continue on
//! to the next row, using the same rules, and get `^^..^`. After determining two new rows, our map
//! looks like this:
//!
//! ```txt
//! ..^^.
//! .^^^^
//! ^^..^
//! ```
//!
//! Here's a larger example with ten tiles per row and ten rows:
//!
//! ```txt
//! .^^.^.^^^^
//! ^^^...^..^
//! ^.^^.^.^^.
//! ..^^...^^^
//! .^^^^.^^.^
//! ^^..^.^^..
//! ^^^^..^^^.
//! ^..^^^^.^^
//! .^^^..^.^^
//! ^^.^^^..^^
//! ```
//!
//! In ten rows, this larger example has `38` safe tiles.
//!
//! Starting with the map in your puzzle input, in a total of `40` rows (including the starting
//! row), **how many safe tiles** are there?
//!
//! [traps]: https://nethackwiki.com/wiki/Trap

use anyhow::Result;

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