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