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

//! # Day 16: Permutation Promenade
//!
//! You come upon a very unusual sight; a group of programs here appear to be [dancing].
//!
//! There are sixteen programs in total, named `a` through `p`. They start by standing in a line:
//! `a` stands in position `0`, `b` stands in position `1`, and so on until `p`, which stands in
//! position `15`.
//!
//! The programs' **dance** consists of a sequence of **dance moves**:
//!
//! - **Spin**, written `sX`, makes `X` programs move from the end to the front, but maintain their
//!   order otherwise. (For example, `s3` on `abcde` produces `cdeab`).
//! - **Exchange**, written `xA/B`, makes the programs at positions `A` and `B` swap places.
//! - **Partner**, written `pA/B`, makes the programs named `A` and `B` swap places.
//!
//! For example, with only five programs standing in a line (`abcde`), they could do the following
//! dance:
//!
//! - `s1`, a spin of size `1`: `eabcd`.
//! - `x3/4`, swapping the last two programs: `eabdc`.
//! - `pe/b`, swapping programs `e` and `b`: `baedc`.
//!
//! After finishing their dance, the programs end up in order `baedc`.
//!
//! You watch the dance for a while and record their dance moves (your puzzle input). **In what
//! order are the programs standing** after their dance?
//!
//! [dancing]: https://www.youtube.com/watch?v=lyZQPjUT5B4&t=53

use anyhow::Result;

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