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

//! # Day 24: Electromagnetic Moat
//!
//! The CPU itself is a large, black building surrounded by a bottomless pit. Enormous metal tubes
//! extend outward from the side of the building at regular intervals and descend down into the
//! void. There's no way to cross, but you need to get inside.
//!
//! No way, of course, other than building a **bridge** out of the magnetic components strewn about
//! nearby.
//!
//! Each component has two **ports**, one on each end. The ports come in all different types, and
//! only matching types can be connected. You take an inventory of the components by their port
//! types (your puzzle input). Each port is identified by the number of **pins** it uses; more pins
//! mean a stronger connection for your bridge. A `3/7` component, for example, has a type-`3` port
//! on one side, and a type-`7` port on the other.
//!
//! Your side of the pit is metallic; a perfect surface to connect a magnetic, **zero-pin port**.
//! Because of this, the first port you use must be of type `0`. It doesn't matter what type of port
//! you end with; your goal is just to make the bridge as strong as possible.
//!
//! The **strength** of a bridge is the sum of the port types in each component. For example, if
//! your bridge is made of components `0/3`, `3/7`, and `7/4`, your bridge has a strength of
//! `0+3 + 3+7 + 7+4 = 24`.
//!
//! For example, suppose you had the following components:
//!
//! ```txt
//! 0/2
//! 2/2
//! 2/3
//! 3/4
//! 3/5
//! 0/1
//! 10/1
//! 9/10
//! ```
//!
//! With them, you could make the following valid bridges:
//!
//! - `0/1`
//! - `0/1`--`10/1`
//! - `0/1`--`10/1`--`9/10`
//! - `0/2`
//! - `0/2`--`2/3`
//! - `0/2`--`2/3`--`3/4`
//! - `0/2`--`2/3`--`3/5`
//! - `0/2`--`2/2`
//! - `0/2`--`2/2`--`2/3`
//! - `0/2`--`2/2`--`2/3`--`3/4`
//! - `0/2`--`2/2`--`2/3`--`3/5`
//!
//! (Note how, as shown by `10/1`, order of ports within a component doesn't matter. However, you
//! may only use each port on a component once.)
//!
//! Of these bridges, the **strongest** one is `0/1`--`10/1`--`9/10`; it has a strength of
//! `0+1 + 1+10 + 10+9 = 31`.
//!
//! **What is the strength of the strongest bridge you can make** with the components you have
//! available?

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() {}
}