chris/aoc-2020
1
0
Fork 0
mirror of https://github.com/HenkKalkwater/aoc-2020 synced 2024-11-22 11:05:18 +00:00
Code Issues Releases Wiki Activity

Added day5 and brought more structure into days

Browse source
This commit is contained in:
Chris Josten 2020-12-05 12:16:58 +01:00
parent 2b14c8d6f6
commit 73aac14025
Signed by: chris
GPG key ID: 1795A594046530AB
8 changed files with 1026 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

945
in/5.txt Normal file
View file

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

16
source/app.d
View file

@ -4,20 +4,23 @@ import std.conv;
import std.format; import std.format;
import std.stdio; import std.stdio;
import std.getopt; import std.getopt;
import std.variant;
import day1; import day1;
import day2; import day2;
import day3; import day3;
import day4; import day4;
import day5;
import dayutil; import dayutil;
immutable string progName = "aoc-2020"; immutable string progName = "aoc-2020";
void function(string[])[] programs = [ Variant function(int, File, string[])[] programs = [
&day1.run, &day1.run,
&day2.run, &day2.run,
&day3.run, &day3.run,
&day4.run, &day4.run,
&day5.run,
]; ];
void printUsage(string name) { void printUsage(string name) {
@ -34,7 +37,7 @@ void printUsage(string name, string message) {
void main(string[] args) { void main(string[] args) {
int day; int day;
if (args.length < 2) { if (args.length < 3) {
printUsage(args[0]); printUsage(args[0]);
} }
try { try {
@ -47,9 +50,16 @@ void main(string[] args) {
printUsage(args[0], "[day] must be between 1 and %d".format(programs.length - 1)); printUsage(args[0], "[day] must be between 1 and %d".format(programs.length - 1));
} }
int part;
try {
part = to!int(args[2]);
} catch (ConvException e) {
printUsage(args[0], "[part] is not an integer");
}
try { try {
programs[day - 1](args[2..$]); Variant result = programs[day - 1](part, stdin, args[3..$]);
writeln(result);
} catch(ArgumentException e) { } catch(ArgumentException e) {
printUsage(args[0], e.msg); printUsage(args[0], e.msg);
} }

9
source/day1.d
View file

@ -6,22 +6,23 @@ import std.format;
import std.functional; import std.functional;
import std.range; import std.range;
import std.stdio; import std.stdio;
import std.variant;
import dayutil; import dayutil;
immutable string progName = "aoc-2020"; immutable string progName = "aoc-2020";
void run(string[] args) { Variant run(int part, File input, string[] args) {
/* For each line on stdin, copy it, map it to an integer and sort it. /* For each line on stdin, copy it, map it to an integer and sort it.
Sorting a range makes it a SortedRange and functions like contains(range, elem) Sorting a range makes it a SortedRange and functions like contains(range, elem)
will make use of optimised implementations, in the case of contains(range, elem) will make use of optimised implementations, in the case of contains(range, elem)
it will use a binary search instead of a linear search */ it will use a binary search instead of a linear search */
auto numbers = stdin.byLineCopy.map!(a => to!int(a)).array.sort; auto numbers = input.byLineCopy.map!(a => to!int(a)).array.sort;
int solution = parts!int(args, partial!(part1, numbers), partial!(part2, numbers)); Variant solution = parts!int(part, partial!(part1, numbers), partial!(part2, numbers));
enforce(solution >= 0, "No solutions found"); enforce(solution >= 0, "No solutions found");
writeln(solution); return solution;
} }
int part1(SortedRange!(int[]) numbers) { int part1(SortedRange!(int[]) numbers) {

13
source/day2.d
View file

@ -2,15 +2,16 @@ import std.algorithm;
import std.format; import std.format;
import std.functional; import std.functional;
import std.stdio; import std.stdio;
import std.variant;
import dayutil; import dayutil;
void run(string[] args) { Variant run(int day, File input, string[] args) {
ulong count = parts!ulong(args, auto lines = input.byLine;
() => stdin.byLine.count!(l => isPasswordValid1(l)), Variant count = parts!ulong(day,
() => stdin.byLine.count!(l => isPasswordValid2(l))); () => lines.count!(l => isPasswordValid1(l)),
writeln(count); () => lines.count!(l => isPasswordValid2(l)));
return count;
} }
/// Part 1 /// Part 1

14
source/day3.d
View file

@ -5,18 +5,18 @@ import std.range;
import std.stdio; import std.stdio;
import std.traits; import std.traits;
import std.uni; import std.uni;
import std.variant;
import dayutil; import dayutil;
void run(string[] args) { Variant run(int part, File input, string[] args) {
auto input = stdin.byLineCopy.array; auto inputData = stdin.byLineCopy.array;
ulong count = parts!ulong(args, Variant count = parts!size_t(part,
() => input.countTrees1, () => inputData.countTrees1,
() => [[1,1], [3,1], [5,1], [7,1], [1,2]] () => [[1,1], [3,1], [5,1], [7,1], [1,2]]
.map!(x => input.save.enumerate.countTrees2(x[0], x[1])) .map!(x => inputData.save.enumerate.countTrees2(x[0], x[1]))
.fold!((x, y) => x * y)); .fold!((x, y) => x * y));
return count;
writeln(count);
} }
ulong countTrees1(Range)(Range lines) if (isInputRange!Range && isSomeString!(ElementType!Range)) { ulong countTrees1(Range)(Range lines) if (isInputRange!Range && isSomeString!(ElementType!Range)) {

9
source/day4.d
View file

@ -4,6 +4,7 @@ import std.functional;
import std.range; import std.range;
import std.stdio; import std.stdio;
import std.traits; import std.traits;
import std.variant;
import dayutil; import dayutil;
@ -46,12 +47,12 @@ struct Passport {
&& eyeColour.length > 0 && passwordId.length > 0; && eyeColour.length > 0 && passwordId.length > 0;
} }
} }
void run(string[] args) { Variant run(int part, File input, string[] args) {
auto lines = stdin.byLineCopy.array; auto lines = input.byLineCopy.array;
size_t result = parts!size_t(args, Variant result = parts!size_t(part,
() => part1(lines), () => part1(lines),
() => part2(lines)); () => part2(lines));
writeln(result); return result;
} }
size_t part1(Range)(Range range) if (isInputRange!Range) { size_t part1(Range)(Range range) if (isInputRange!Range) {

42
source/day5.d Normal file
View file

@ -0,0 +1,42 @@
import std.algorithm;
import std.array;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.variant;
import dayutil;
Variant run(int part, File file, string[] args) {
auto lines = file.byLine;
Variant result = parts!int(part,
() => part1(lines));
return result;
}
int part1(Range)(Range range) if (isInputRange!Range) {
return range.map!(x => determineSeat(to!string(x.array))).maxElement;
}
int determineSeat(string code) {
int result = 0;
int marker = 0b1000000000;
foreach(char c; code[0..7]) {
if (c == 'B') result |= marker;
marker >>= 1;
}
//writeln("ROW: ", result >> 3);
foreach(char c; code[7..10]) {
if (c == 'R') result |= marker;
marker >>= 1;
}
//writeln("COL: ", result & 0x7);
return result;
}
unittest {
assert(determineSeat("BFFFBBFRRR") == 567);
assert(determineSeat("FFFBBBFRRR") == 119);
assert(determineSeat("BBFFBBFRLL") == 820);
}

9
source/dayutil.d
View file

@ -13,17 +13,12 @@ class ArgumentException : Exception{
goes out bounds. goes out bounds.
* *
* Params: * Params:
* args = Reference to string with arguments, usually from main. * part = The part to run.
* dgs = list of delegates. Which one will be called depends on args[0] * dgs = list of delegates. Which one will be called depends on args[0]
*/ */
R parts(R)(ref string[] args, R delegate()[] dgs ...) { R parts(R)(int part, R delegate()[] dgs ...) {
ulong len = dgs.length; ulong len = dgs.length;
enforce!ArgumentException(args.length >= 1, "Please provide a part to run as a command line argument");
int part = to!int(args[0]);
enforce!ArgumentException(part > 0 && part <= len, "This day supports parts %d to %d".format(1, len)); enforce!ArgumentException(part > 0 && part <= len, "This day supports parts %d to %d".format(1, len));
// Remove the first argument
args = args[1..$];
return dgs[part - 1](); return dgs[part - 1]();
} }