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

//! # Day 24: Lobby Layout
//!
//! Your raft makes it to the tropical island; it turns out that the small crab was an excellent
//! navigator. You make your way to the resort.
//!
//! As you enter the lobby, you discover a small problem: the floor is being renovated. You can't
//! even reach the check-in desk until they've finished installing the **new tile floor**.
//!
//! The tiles are all **hexagonal**; they need to be arranged in a [hex grid] with a very specific
//! color pattern. Not in the mood to wait, you offer to help figure out the pattern.
//!
//! The tiles are all **white** on one side and **black** on the other. They start with the white
//! side facing up. The lobby is large enough to fit whatever pattern might need to appear there.
//!
//! A member of the renovation crew gives you a **list of the tiles that need to be flipped over**
//! (your puzzle input). Each line in the list identifies a single tile that needs to be flipped by
//! giving a series of steps starting from a **reference tile** in the very center of the room.
//! (Every line starts from the same reference tile.)
//!
//! Because the tiles are hexagonal, every tile has **six neighbors**: east, southeast, southwest,
//! west, northwest, and northeast. These directions are given in your list, respectively, as `e`,
//! `se`, `sw`, `w`, `nw`, and `ne`. A tile is identified by a series of these directions with **no
//! delimiters**; for example, `esenee` identifies the tile you land on if you start at the
//! reference tile and then move one tile east, one tile southeast, one tile northeast, and one tile
//! east.
//!
//! Each time a tile is identified, it flips from white to black or from black to white. Tiles might
//! be flipped more than once. For example, a line like `esew` flips a tile immediately adjacent to
//! the reference tile, and a line like `nwwswee` flips the reference tile itself.
//!
//! Here is a larger example:
//!
//! ```txt
//! sesenwnenenewseeswwswswwnenewsewsw
//! neeenesenwnwwswnenewnwwsewnenwseswesw
//! seswneswswsenwwnwse
//! nwnwneseeswswnenewneswwnewseswneseene
//! swweswneswnenwsewnwneneseenw
//! eesenwseswswnenwswnwnwsewwnwsene
//! sewnenenenesenwsewnenwwwse
//! wenwwweseeeweswwwnwwe
//! wsweesenenewnwwnwsenewsenwwsesesenwne
//! neeswseenwwswnwswswnw
//! nenwswwsewswnenenewsenwsenwnesesenew
//! enewnwewneswsewnwswenweswnenwsenwsw
//! sweneswneswneneenwnewenewwneswswnese
//! swwesenesewenwneswnwwneseswwne
//! enesenwswwswneneswsenwnewswseenwsese
//! wnwnesenesenenwwnenwsewesewsesesew
//! nenewswnwewswnenesenwnesewesw
//! eneswnwswnwsenenwnwnwwseeswneewsenese
//! neswnwewnwnwseenwseesewsenwsweewe
//! wseweeenwnesenwwwswnew
//! ```
//!
//! In the above example, 10 tiles are flipped once (to black), and 5 more are flipped twice (to
//! black, then back to white). After all of these instructions have been followed, a total of
//! **`10`** tiles are **black**.
//!
//! Go through the renovation crew's list and determine which tiles they need to flip. After all of
//! the instructions have been followed, **how many tiles are left with the black side up?**
//!
//! [hex grid]: https://en.wikipedia.org/wiki/Hexagonal_tiling

use anyhow::Result;

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