diff --git a/Cargo.toml b/Cargo.toml index 6d88d84..2557c6d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,6 +10,7 @@ edition = "2018" alloc_counter = "0.0.4" anyhow = "1.0" itertools = "0.9" +thiserror = "1.0.22" [[bin]] name = "day01" @@ -26,3 +27,7 @@ path = "src/day03/main.rs" [[bin]] name = "day04" path = "src/day04/main.rs" + +[[bin]] +name = "day05" +path = "src/day05/main.rs" diff --git a/input05 b/input05 new file mode 100644 index 0000000..5ddea26 --- /dev/null +++ b/input05 @@ -0,0 +1,933 @@ +BBBFBFFRLR +BFFFFFFRLL +BFBBBBFLLL +BBFBFFFRRR +BBBFBFBRLR +FBFFBBBLRL +FBFFBFFRRL +FFBBFFFRRL +BBBFBFBLLL +BBBBFFFLLR +FBBFFBFRRR +BFFFBBBLRR +FFBBFFBRLR +FFBFFBFRRL +BBBBFBFRLL +BBBBBFFLRL +FFBBBFBRRR +FFFBBBFLLR +FFBFFBBLRL +FBBFBBFLRL +FFBBBBFRRR +BFBFBFFRLL +BBFBFFFLLL +FFFBBBFRRL +BBFFBFBRLL +FBFBFBFLLL +BBFFFFBLRR +FFBBBFFRRL +FFFBFBBLRL +FBBFBBBLLL +BBFBFFBRLR +FBFBFBBRLL +FFFBBFBLRL +FFBFFBFLRR +BBFBBBFRRL +BBFBBFBLLR +BBFBBBFRLL +BFFBBBBRLR +FBFBFBBRLR +FBBBFFBRRR +FBBBFBFLLR +FFBFBBFLRL +BFBFBFBRLL +BFFFBFBLRR +FFBBBFBRLR +BBFBFFBLRR +BFFFFBBLLL +BFFFFBFLLR +FBFBBBBRLR +BBFFBBFLRL +BFBFFBBRLR +FFFBFBFRLL +BFFFBBFRRL +BBFBFBFRLL +BFBFFFFRRL +FFBFBBBRLR +FBBFFFFLRR +FBFBBFBRLR +BBFFBFFLRR +BBBFFBFLRR +BFFFFFBRLR +FBBFFFBRRL +BFFFBBFRRR +BBBFBFBRLL +BFBBFBBRLR +BFBFBFBLLL +BBBFFFFRLL +BFFFFBFRLL +FFBBFFBLLL +FBFFBBFRRL +FFBBFBFRLR +FFBFFFFRLR +BFBBBFBLLL +FBBFFBFRRL +FBFBFFFLRR +BFFBBBFLRR +FBBFBBBRLL +FFBFBBFLLR +FFFBFFBRLR +BBFBBFFRRR +BFBBBFFLLL +BFBBFBBRRR +BBFFFBBLLR +BBFBFFBLLR +BFFBBFFRRL +FFFBBFBRRR +BBFBBFFLLR +BFFBBBBRLL +BFFBBFFRLR +FFFBFBFLRL +FBFFBBFLLR +BFBBFBFRRL +BFBFFFBRLL +FBBFBFFLRR +FFBFBBFLLL +BFBBFBBRRL +FBBBFFFLRR +BBBFBBFRRL +BBFBBBFRRR +BFFBFFFLRL +BFBFBBFRRL +FFBBFFFLLR +FBFFFFBLLL +BFBBBBFRLR +FFBFBFBRLL +FBFFFBFLRL +FFBFBFFLLL +FBBBFFBRLL +FBBBBBFLLR +FFBFBBBLLL +BFFBBBBLLL +BFFBBBFRLL +FBFFFFBLRL +BFBFFBFRRR +FFBFFFFRLL +BBFBBFFRRL +BBFBFBBLLL +FFBBBBBRRR +BBBFFFBLRL +FBFBBBFRLL +BFBFFFBRRL +FFBFBBBRLL +FBBBFBFLLL +FBFBFFBLRL +FBBBFFFLRL +FBBBFBBRRL +FBBFFBBRRR +FFBFFBBRRR +FBFFFFFLLL +FFBBBFFRLL +FBBFFFBRRR +BFBBBFBRRR +FFBFFBBRRL +FFFBFBFLLR +FBBFBFBRLL +FBFFBFFRLR +BFBBFFBLRR +FFBFBBBLRR +FFBFBBFLRR +BFFFBFFLRL +BBFFFBBRLL +FFFBBFFLRL +BBFBBFFLLL +BFFBFFBRLR +BBBFFBFRRR +FBFFBFBRLL +FBBBFFBLLR +FFFBBFFLRR +FFFBBFBLLL +FBFBFBBLLR +FBBBFBFRLR +BFBBBFBLRL +FBFBFFBLLL +FBFBBFBRRR +BFFBBBBRRR +BFFFBFBLLR +FFFBFBBRRL +BBBBFBBLLL +FBFFBFBLRR +BFFFFFFLLL +FFBFBFBRLR +FBBBFFFLLR +BBBFFFBLRR +FBFFFFBRRL +FBFFFFBRLR +FBFFBBBLRR +BBFBFBFRRL +BFFFBFBRLL +FBFBBFFRRR +BFFFFFFRLR +BFBBBBBLLR +FBBBBFBLRR +FBBFBBFRLR +BBFBBBFLRR +FBFFFBBLRR +BBBBFFFRLL +BFBFFBBRRR +FBFFFBBLLR +FFBBBFFRLR +FBBFFFBRLL +FBBFFBBRRL +BFFFFFFLLR +BBFBFBBRRL +FBFFFBFRRL +BBBBFFFLRL +FFBFFBBLRR +FBFFFFFRLL +BFFFFBFRRR +FFBFFFBRRR +FBFBBFBRRL +FFBFBFBLRR +BBFBFFFRLR +BBFFBBBRRR +BBFFFBFLRL +FBBBBBFLRL +FBBBFFBRLR +FBBFBBBLLR +FFBFBBFRLR +BFFBFBBLRL +BBBFBFBLRL +BFFBBFBRLR +BFFFFFBRRL +FBBFFBBLRR +BFBBBBFRRL +BBBBFFFRLR +BFFFFFBLLR +BBBBFBFRRR +BFFBFBBRLR +BFBFBFFLRL +BBFFBBBRLR +BBFFFBFLLR +FFBFFBFLLL +BBFFFFFRRR +BBFBFFFLLR +BFBFFFFLRR +FBFBFBBRRL +FBFFFFFRLR +BBBBFFBLLL +BBFFFBBLRR +FFBBBBBRLL +FBFFFFFLRR +BFFFBBFLRL +FBBBBFBLLL +FBFBBFFLLL +BBFFFBBRLR +FFFBFFBRRR +BBFFBBBRLL +BFBFFBBLLR +FFFBBBBRRL +BFFFFBFLLL +FBBFBBBRRR +BFBBFBBLLL +BFBFBBFLRL +FBFFBFFRRR +FBBFFFFRLL +FBBBFBFRRR +BBBFBFFLRR +BBFFBBBLRR +FFBBFBBRRR +BFBBBFBLLR +BBFBFFBRLL +FFBBFBBRLL +FFBBBFFLRL +BBFBBBBRRR +FFFBFFFLRR +BFBBBFBRLL +FFBBFBBLLR +BFBFBFFLRR +BBBBFBBRRL +FBBFFBFLLR +BFBBBFFRLL +BBBFFBBLLL +BFBFFBBLRR +FBFFBBBRLR +FBBFBFBRRL +FBFBBBFRRR +FBFFFBBRLR +BBFFFFFLRR +BBBBFFBRLL +BFFBFFFRRR +FFBFBFFLRR +FFFBFBFRLR +BFFFBBFRLL +FFBFBBBRRR +BFFFFBBRLR +BBBFFFFRRL +FBFBFBFRRR +FBBBBFBRLR +FBFBBBFRLR +BBBBFFFLRR +BFFBFFFRLR +BFFFBBBLLL +BFBBFFBRLR +BFBFFBFLLL +BFBFBBFRLL +BFFBBFBLLL +BFBBFFFRLL +FFBBFFBLRL +BBBBFFBRRL +FBBBFFBLRR +FFBBBBBLLR +FBFFFBFLLR +BBFFBFFRRL +BFBFBBBLLL +FBBBBFBRRL +FBFBBBBRRR +BBFBBFBRRR +FBFBFFFRLL +BFBFFBFLRL +BFBFFBBLRL +FFBFBFFRLR +BFBBFBBRLL +FBBBBBBRLR +BBFBBBBLRL +FFBBFBFLLL +FFBBFBBLLL +FFFBBFBRLR +BBBBFBFLLL +FBFBFFBLRR +FFBBFFFLRL +BBFBFFFRLL +FBFFFBFRLL +BBBFBBFLLL +FFBBFFBLRR +BBBBFBFLRR +FBFFFFFRRL +BFBFFBFRLR +FBFBFFBRLR +FBBFBBFRLL +BFFFFFFLRR +BBBFFFFLLL +FFFBBFFRLR +FFBBFFFRLR +BBBFFBBRRL +FBBFBFBLRL +BFFFBBBLRL +FBBFBBBRLR +BFBFFFBLLL +FBFFFBBLRL +FBFFBFFRLL +BFBFBFBLLR +BBFFBFBRLR +BBFFFFBRLR +FFFFBBBRRR +FFBBBBBLLL +BBFBBBBRRL +BBBBBFFLLR +FFFBFFFRLL +BFFBBFFLRR +BFFBBFFLRL +BBBFFBFRLL +FFBFBFBLLL +BFBBBBBLLL +FFBBBBFLRL +FBFFBBFLRL +BBFFFFBLRL +BBBFBBBRLL +BFBFFFBLLR +BFBFBFBRLR +BFBBFFFRRR +BFFBFBFLLL +FBBFBFBLLR +FBFBFBFLRR +FFBFFBFLLR +FFBFFFBLLL +FBFFBFFLRL +FFBBFBFLLR +BFFFBFFLRR +BBFFFBFRLL +FBFBBBFLRR +FFBBFFFLRR +FBBBFBBLLL +BFFBFBFRLR +FFBFBBBLLR +BBBFFBFLLR +BFBFFFBLRL +BFFBBFFLLL +FBFBFFFRRL +BFFBBBBLLR +FFBBBFFLLR +BBFFBBFRRL +FFBFFBFLRL +BBFFBFBRRL +BFBBBFFLRR +BFFBFBBRRR +FBBFBBBLRL +FFBFBFFRRR +BBFBFFFLRL +BBBFFBBLRR +FBBFBFBLRR +BFBBBBFLRL +FBFFFBBRRL +BFFFFBFLRR +BBFFBBFRLL +BFFBFBBLRR +FBBBBFFRLL +BFBFFFFLRL +FBBBBBBLLL +BFBBBBFRLL +BFBFFFFLLL +FFBBBFBLRL +BBFFFFBLLL +BFBBFBFLRR +FFFFBBBRRL +BFFBFBBLLL +FFBBFFFRLL +BFFFBFBRRR +FBBBFBBRRR +BBFBBFBLRR +BFFBFFBLRL +BBFFFBBLRL +BFFBBBFRRR +FFBFFBBRLR +BFFBFBFLLR +BFFBBFFRLL +FBBFBFBRLR +BFFFFFBLRR +BFBFFBFRRL +BFBBFFBLLL +FBFFFFBRRR +BBFFBFFLLL +FBBBBBBLLR +BFFFFFBRRR +BFBFBFFRRR +BBFFBFFRLR +FBBBFFBLLL +BFBFBBFLLL +BFBFBBFRLR +BBFFBFFLLR +FBBFFFBLRR +FBFFBBFLRR +BFFFFBBLLR +FFBFBFBLRL +FFFBBBFRLL +BFFBBFBRRR +BFFBBBFRLR +BBBBFFFRRR +FBBBBFBLRL +FBFFFFBLRR +BFFFBBBRLL +FBFBBFFRLR +FFBBBBFLLR +FFBFFBFRLR +FFBBBBBRRL +FBFFFFFLLR +BFBBBFFLLR +FBFFBBFRLL +BBFFFBFRRL +BBFFBFFLRL +FBFBFFFLLL +BBFFBFFRLL +FFFBFFBLLL +BBFBBFBLRL +BBFFBFBLRL +BFBFBFBRRL +FBBBFBBLRR +FBBBFBFLRL +FBBBBFFRLR +FFBFBFFLLR +BFFFBFBRLR +FBBFFBBRLR +BBFFBBFRRR +BBBFFBBRRR +FFBFFFBRLR +BBBBFFBLRR +BBFBFBFLLL +BBFFFBBLLL +BFBBFFBLRL +FBFBFBFRRL +BBFBBBFLLR +FBBBBBFRRL +BFBFBFBLRR +FBFBFFFRRR +BFBFFBFLLR +BBBFFBFRRL +BBBFBFFLLL +BFFFBFFRRR +FFFBBBBLRR +BFFBBFBLRR +BFFBFBFLRL +BBBBFFBLRL +FBBFBBFRRR +FFFBBBBLLL +FBFFFBBRRR +FBBBFFFLLL +FFBBBBBRLR +BFBFFFFRRR +FBBFFFFRRR +BBBFBFFLRL +BFFFBFFRLR +BFBFFFBLRR +BFBBFBFRLR +BBFFFFFRLR +BFFFBBFLLL +BBBFFFFLRL +BBFFBBBLLL +FBFFBFBRRL +BFBBBBBRLR +FBBFFFBLLL +FBBBFBFLRR +BBFBBBFLLL +FFBFFBBLLR +BFFFBBFLRR +BBBBFFBRRR +BBFFFFBRRL +FBFFFBFLLL +BBFFBBFLLL +BFFFFFFRRL +FBBFFBBRLL +FFBBFBFRRL +BBBFFBBRLL +BFBFBBFRRR +FFBFFFBLRL +BFFFFBBRRR +FFFBBFBRRL +BBBFFBFLRL +BFFBBFBLLR +FFFBFFBLRL +FBBBFBBRLL +BFBBFBBLLR +FBBFFFFLLR +FFBFBFBRRL +FBBFFBBLLL +BBBBFFFLLL +FBBBBBBLRR +FFFBBBBRLR +FBBBBFFRRL +BBFFBBBRRL +FBBFFFFRLR +FFBFBFFLRL +FBFFFBFRRR +FBBFBBFLLR +FBBBBBFLLL +FFBFBFFRLL +FFBFFFFLRR +FFBBBBFLRR +FFFBFBBLLR +BBBFBFBLRR +FFBBFBBRLR +FBFFFFBLLR +BBFBFBBRLR +FBBFFFFLLL +BBBBFBBLLR +BFBBBBFRRR +BBBFBFFRRR +BFFBBBBLRL +BBBFBBBRRR +FBFFBFFLLL +FFBFBFFRRL +BBBBFFBRLR +BFBBFFFRRL +FFBFFFBRLL +BBBBFBFLRL +FBBBFBBLRL +FFBBBFFLLL +FFFBFFBLLR +BFBBFBBLRR +FFBFBBBLRL +BFBBFFFLRR +FFFBFFFLLR +BFBBBBFLLR +BFFBFBFRLL +BFFBFBBRLL +BBFBFFFLRR +BBBFBBFLLR +FBFBFFFLRL +FBFFBFBLLL +FFFBFFBLRR +BFFFBFFRLL +BBFFBBFLLR +BBFFBBBLRL +FBFBBBBLLL +FBBFBBBLRR +FBBBBBFLRR +FBBBBBBLRL +FBFBBFBLLL +FFFBFFBRLL +FBFBBFBLRR +FBBFFBFRLR +BBFFFFFRLL +FFBBFBBRRL +BFBFBBBRLL +BBBFFFFLLR +FBFFFBFRLR +BFFFBFFLLL +BBBFFFBRLL +FBBBBFBLLR +FBBFBFBLLL +BBFBFBFLRR +BFBFBFBLRL +FBBBBBBRRL +BFBFFFFRLL +BBBFBBBLLL +BFBFFFBRLR +FFFBBBBRRR +FFBFFFBRRL +FBFBBBBLRL +BBFBBFBRRL +BBBFFBBLRL +FBFBFBBLLL +FBBBBBBRRR +FFFBFBBRLR +FBFFBFBRRR +FFBBFBBLRL +BBFBBBBLRR +BFFFFFFRRR +BBFFBFBLRR +FFFBBBFLRR +BBFFBBFLRR +BFBFBFFRLR +FBFBFFBRLL +FFBFFFFLLL +FBFBFFBLLR +BFFFFBBLRR +FBBBFFFRRR +FFFBFFFRRL +FBFBBBFRRL +FBBFFFBLRL +FBBBFFBRRL +BBBFBBFLRR +BFBBFBFRRR +FFBFFBFRLL +BBBFBBBRRL +FBBFBFFLRL +BBBFBFFRLL +FFBBBFBLLL +BFFFFFFLRL +FFFBFFFLRL +FBFBBFFLRL +BFFBFBFLRR +BBBFFFFRRR +FBFBBBFLLL +BFFBFBFRRL +BFFFFBFRLR +BFBBBFFLRL +FBBBFBFRRL +BFBBFBFLLR +BFBFBBBLRR +FFFBBBBLLR +FBFBBBBLRR +BFFBFFFLLR +BBFBBFFLRR +BBBBFBBRLR +FFFBBFBLLR +FFFBFBFLLL +BBFBBFFLRL +BFBBFFBRLL +BFBFFFBRRR +FFFBFBFLRR +FFFBBFFRLL +FFBBBBFRLL +BFBBBFFRRR +FBBFBBFRRL +BBFBBBFRLR +FBFBFBBLRL +FBFBFFFLLR +BFFFFBBRLL +BFFFBBBRRR +FBBFBFBRRR +FBFBFBBLRR +BFFBFFBLLL +FFBFFFBLLR +FBBBBBFRLL +FFFBBBFRRR +FFFBFFBRRL +BBFBBBBLLL +BBBBFBBLRL +BBFFFFBRLL +BFFFBBBRRL +FBBBFBFRLL +BFFBBFFRRR +BFFFFFBLRL +FBFBBFFLLR +BFBBBFBRRL +BBFBBFBRLR +BBBBFBFLLR +FBBBFBBRLR +FBFBFBFLRL +BBBFFBBRLR +BBBBBFFLLL +BFFBFBBRRL +BBFFBBFRLR +BFBBBBBLRR +FFBFFBFRRR +BFFFBBBLLR +BFFFBFBRRL +BFFFBFFLLR +FBBFBBFLRR +BBBFFFBRLR +BBBBFBBRRR +BFBFBFBRRR +BBBFBBBLLR +FBBFBFFRLL +BBBFBBFRRR +FFBFBBFRLL +BFFBFFBRLL +FBFBBFBLRL +BBBFBFBRRR +BFFFBBBRLR +BFFBFBFRRR +FFBFBFBRRR +BFBFBBBRLR +BBFFBFBLLR +FFBFFFFRRR +BFBBFFFLLL +BFFFFBBLRL +FBFFBFFLRR +BFFBFFFRLL +BBFBFFBRRL +FBBFFBFLRL +FBBFBFFLLL +FBFFFBFLRR +FBFBFFBRRR +FBBBBFFLLL +BFBFBBBRRR +BBFBFBFLLR +FFBBBFBRRL +BBFBFFBLLL +FBBBBFFRRR +FFFBFBBLRR +FFFBBBFRLR +BBBFFFBRRL +FFBBFBBLRR +FFBBFBFRLL +BBBFFFBRRR +BBFBBFFRLL +FBBFFBFLLL +FBFBBFFRLL +FFBBFBFRRR +BBBBFFBLLR +FBFFBBFLLL +FBFBBFBLLR +FFBBFFFRRR +BBBFBBFRLL +BFFBBFBRLL +FBBBBBBRLL +FBBFFFBRLR +FFBBBBBLRL +BFBBFBBLRL +BBFBFBFRLR +BFBFBBFLRR +FFBFBBFRRR +FFBFFFFLRL +BBFBFFBRRR +BBFBFBFLRL +FFBFFBBRLL +BBFFBFBLLL +BBFFBBBLLR +FBBFBFFLLR +FBBBBFBRLL +BBFFFFFLLL +BBFBFFFRRL +BBFFFBFRRR +BBBFBFFLLR +FFBBBFBLLR +FBFBBBBLLR +BBFFFFFRRL +FBFBFBFRLR +FFBFBBBRRL +FFFBBFFRRL +FFFBBBFLLL +BFBFFFFRLR +BFFBBBFRRL +BFFFBBFLLR +BFFBFFBRRL +BBFBBBBRLL +BBFBFBBRLL +BBFBBBBRLR +BFFFBBFRLR +FBBFFBBLRL +BBBBFBFRRL +BFFBFFBRRR +FFBBFFBLLR +FFBBBBFRLR +FBFFBBBLLR +FFBBFFBRRL +FBFBFFFRLR +BFFBFFBLLR +FBFFFBBLLL +BFBBFFFLRL +FFFBBFFRRR +BFBBFFFRLR +BFBFFBBRLL +BBFFFFBRRR +FBFFFFFLRL +BFFBBBFLRL +BFBBBFBLRR +FFBFFBBLLL +BFBFBBBRRL +FBBBFBBLLR +BFFFBFFRRL +FBBFFBBLLR +BBFFFFBLLR +BFBBFBFRLL +FBFBBBFLRL +BFFBFFFLLL +BBBBFBBRLL +BBBFBBFRLR +FBFFBBBRLL +FBFBBBFLLR +BFBBFFBRRL +FBBFFFFLRL +BFFBBBBRRL +FBFBFBFRLL +BFFBBBFLLR +FBFBFFBRRL +BBFBFBBRRR +FFFFBBBRLR +BBFFFBFRLR +FBBBFFFRLR +FBBBBFFLRR +BBFFFBFLRR +FBFBBFBRLL +BBFFFBBRRL +FFFBBBBLRL +BBFBBFBRLL +FBBBFFFRRL +BFBFBBBLRL +FFFBBBBRLL +BBFFFFFLRL +BBBBFBBLRR +BFBBBBBRRR +BBFFBFBRRR +BFFFBFBLRL +BFBFFBBLLL +BBFFFFFLLR +BFBBBFBRLR +FBFFBFBLRL +FFBFBFBLLR +FBBFBBBRRL +FBFBBBBRRL +BFBFBFFLLL +FBFFFFFRRR +BBFBBBFLRL +FFBFFFFRRL +BBFBFFBLRL +FFBFFFFLLR +FBFFBBBLLL +BBBBFBFRLR +BBBFFBBLLR +FFBBBBFLLL +FBBBBFBRRR +FBBBBBFRLR +FFFBBBFLRL +BBFFFBFLLL +FBFFBFBRLR +FFBBFBFLRL +FFFBBFFLLR +FFFBFFFRLR +BFBFFBBRRL +BBFFBFFRRR +FFFBFBBRRR +BFBFBFFLLR +FBBBFFBLRL +FFBBBBFRRL +BBFBFBBLRR +FFBBFFBRRR +BFBBBBFLRR +BFFBBBBLRR +FBBBBFFLRL +FBBFFFFRRL +FFBBFBFLRR +FFBBBFBRLL +FFFBFBFRRL +FFBBFFFLLL +FBBFBFFRRL +BBFFFBBRRR +BBBFFBFRLR +BFBFFBFRLL +FBBFFFBLLR +BFBBBBBRRL +BFBBFBFLLL +BBBFBFBRRL +FBFFFBBRLL +FBBFBFFRLR +BFFBBBFLLL +FFFBFBBRLL +BBBBFFFRRL +FBFBBFFLRR +BFFFFBBRRL +BBFBBFFRLR +FBFFBFFLLR +BBBFFBFLLL +BFBBBBBLRL +BFFFBFBLLL +BFBFBBBLLR +BBBFFFFLRR +FBBBBBFRRR +FBBFBFFRRR +BBFBFBFRRR +FFFBFFFLLL +FBFFBBBRRL +BBFBBBBLLR +FBFBFBBRRR +FFFBFBBLLL +FFBBBFFRRR +BBBFFFFRLR +BFBFFFFLLR +FBFFFFBRLL +FBBFFBFLRR +BFFBFFFRRL +BBFBFBBLRL +FFFBBFFLLL +BFBBFFBRRR +FFBBBBBLRR +BBBFFFBLLL +FFBFFFBLRR +FFFBFBFRRR +FFFBBFBLRR +FBFFBBFRLR +BFBBFFFLLR +BFFBFFBLRR +FBFFBBFRRR +FFBBFFBRLL +FBFBFBFLLR +FBBFBBFLLL +BFBBBBBRLL +FBFFBFBLLR +BFBBFBFLRL +BFBBBFFRRL +BBBFBFFRRL +FFBBBFFLRR +FBBBFFFRLL +FFFBBFBRLL +BFFBBFBRRL +BFBFBBFLLR +FFBFBBFRRL +FBBBBFFLLR +FFFBFFFRRR +BBBFFFBLLR +BBBFBBBLRR +BBFBBFBLLL +FFBBBFBLRR +BFBFFBFLRR +BFFBBFBLRL +BFBBFFBLLR +FBFFBBBRRR +BBBFBBFLRL +BFBFBFFRRL +BBBFBBBLRL +FBFBBBBRLL +BFFFFBFRRL +BFFFFFBRLL +BFFFFBFLRL +FBBFFBFRLL +BBBFBFBLLR +BBBFBBBRLR +BFFBFFFLRR +BFFBFBBLLR +FBFBBFFRRL +BBFBFBBLLR +BFFFFFBLLL +BFFBBFFLLR diff --git a/src/day05/main.rs b/src/day05/main.rs new file mode 100644 index 0000000..749c0d7 --- /dev/null +++ b/src/day05/main.rs @@ -0,0 +1,152 @@ +use anyhow::Result; +use std::convert::TryFrom; +use thiserror::Error; + +static INPUT: &str = include_str!("../../input05"); + +fn main() -> Result<()> { + part1()?; + part2()?; + Ok(()) + +} + +fn part1() -> Result<()> { + let reader = BinaryReader::from(INPUT); + let max_seat_id: Result = reader.into_iter().try_fold(0, |max, seat| { + let seat_id = seat?.calculate_sead_id(); + if seat_id > max { + Ok(seat_id) + } else { + Ok(max) + } + }); + println!("max seat id: {}", max_seat_id?); + Ok(()) +} + +fn part2() -> Result<()> { + let mut seats = BinaryReader::from(INPUT) + .into_iter() + .filter_map(|seat| match seat { + Ok(seat) => Some(seat.calculate_sead_id()), + Err(_) => None, + }) + .collect::>(); + seats.sort(); + let mut last = None; + for seat in seats.iter() { + if let Some(l) = last { + if l != seat - 1 { + println!("my seat is: {}", seat - 1); + break + }; + }; + last = Some(*seat) + } + Ok(()) +} + +#[derive(Error, Debug)] +enum Errors<'a> { + #[error("invalid input ({0}): {1}")] + InvalidInput(&'a str, &'a str), +} + +struct BinaryReader<'a> { + inner: &'a str, +} + +impl<'a> From<&'a str> for BinaryReader<'a> { + fn from(input: &'a str) -> Self { + BinaryReader { + inner: input.trim(), + } + } +} + +impl<'a> Iterator for BinaryReader<'a> { + type Item = Result>; + + fn next(&mut self) -> Option { + let mut splitted = self.inner.splitn(2, '\n'); + let line = splitted.next().unwrap(); + self.inner = splitted.next().or(Some(""))?; + + match line { + "" => None, + line => Some(Seat::try_from(line)), + } + } +} + +#[derive(Debug, Eq, PartialEq)] +struct Seat { + row: u32, + col: u32, +} + +impl<'a> TryFrom<&'a str> for Seat { + type Error = Errors<'a>; + + fn try_from(data: &'a str) -> Result { + if data.len() != 10 { + return Err(Errors::InvalidInput("seat code must be 10 chars log", data)); + } + let row = u32_from_str(&data[0..7], 'B', 'F')?; + let col = u32_from_str(&data[7..10], 'R', 'L')?; + Ok(Seat { row, col }) + } +} + +impl Seat { + fn calculate_sead_id(&self) -> u32 { + self.row * 8 + self.col + } +} + +fn u32_from_str<'a>(input: &'a str, one: char, zero: char) -> Result> { + let mut res = 0; + for c in input.chars() { + res = if c == zero { + res << 1 + } else if c == one { + (res << 1) + 1 + } else { + return Err(Errors::InvalidInput("invalid char", input)); + } + } + + Ok(res) +} + +#[cfg(test)] +mod test { + use super::*; + #[test] + fn examples_part1() { + let seat1 = Seat::try_from("BFFFBBFRRR").unwrap(); + assert_eq!(seat1, Seat { row: 70, col: 7 }); + assert_eq!(seat1.calculate_sead_id(), 567); + let seat2 = Seat::try_from("FFFBBBFRRR").unwrap(); + assert_eq!(seat2, Seat { row: 14, col: 7 }); + assert_eq!(seat2.calculate_sead_id(), 119); + let seat3 = Seat::try_from("BBFFBBFRLL").unwrap(); + assert_eq!(seat3, Seat { row: 102, col: 4 }); + assert_eq!(seat3.calculate_sead_id(), 820); + } + + #[test] + fn failures() { + let reader = BinaryReader::from(INPUT); + let max_seat_id: Result = reader.into_iter().try_fold(0, |max, seat| { + let seat_id = seat?.calculate_sead_id(); + if seat_id > max { + Ok(seat_id) + } else { + Ok(max) + } + }); + assert!(max_seat_id.unwrap() > 861); + } +}