From 2828ad3af3aa44a75b71ef542cd8c57876a4b0f4 Mon Sep 17 00:00:00 2001 From: David Ashby Date: Sat, 5 Dec 2020 12:04:37 -0500 Subject: [PATCH] more string parsing! and custom sorts in go --- 05/input | 799 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 05/main.go | 108 ++++++++ 2 files changed, 907 insertions(+) create mode 100644 05/input create mode 100644 05/main.go diff --git a/05/input b/05/input new file mode 100644 index 0000000..ed4891b --- /dev/null +++ b/05/input @@ -0,0 +1,799 @@ +FBBBFFFLRL +BFFBBBBLRL +FBFFFBBRRR +FBFBBFFLRL +FFFBFBBRLR +FBFBBBFRLL +BFBFFBFRLR +BFBFFFBRRL +BFBBFFBRLR +FBBFBBBRLL +FFFBBFFRRR +FFBBBFBRLR +BBFFBFBLLL +BBFFBBFRRR +BBFBFFBLLR +FFFBBBFLRR +BBFBBFFRLR +BBFFFBFRLL +FBFFBFBLLR +FBBFFFBRLR +BFFFFBFLRR +BBFFBBBLRL +FBFBBFFRRL +BBFFFFFLRR +BFBBBFBRRL +BBFFBBBRLR +FFBFBFBRLL +BFBFFBFLLR +FBBFBBFRLR +BBFFFBBRLR +BBFFBBFLLR +FFBBBBBRRL +BFFFBFBRRL +FFBFFFBRRL +FBBBBFBLLL +FBBFFBFLRR +BBFFFFBRRL +FFBFBFBLRR +FFBBFBBLLR +BFBFBBFRLL +BBFFFBFLLL +FBBBBFFRRR +BBFBFFFRLL +FFFBBFBRRR +FFBBFFFLRR +BFBBBFFRRR +BFFFFBFRLL +BFFFFBBRLR +FBFBBFBRRL +BFFBFFFLLL +FBFFBFBRLR +BFFFBBFRLR +BFBFBBBRLR +BFFBBBFLLR +BFBBBBFRRL +BFFFFFBLLL +BBFFFFFLRL +FBFFBBBRRL +FBBBFFFLLL +FBFBFBFRLL +BBFBFBBLRR +BBFBFBFLRR +FBFFBBFRRR +FBBBFBBLRR +FBFFBFFRLR +BFBBFFFLRL +FFBFFBFRLR +FBFBFFBRLL +BFFBBFFLLL +FBBFBFBLLR +FFBBFFBLLR +BFFBBFFRRR +FFFBBBFLLR +FFBBBBBLLR +FFBFFBBLLR +FFBFFFBRLR +BFBFBFFLLL +BBFFFFBRRR +BFBFFFFRLL +FBFBFFFRRL +FBFFFFBLRR +FFBFFBFLRR +FBBBBFBRLR +BFFFBBBLRR +FFBBBBFRRL +FFFBFBBRRR +BFBBBBBRRL +FFFBBBFLRL +BFFBBBBRLR +FBFBFFFLRL +FBBFFBFLRL +FBFBFFBRRL +FFBBBBBRRR +BFFBFBFLLR +FFBFBBBLLR +BBFBFBFRRR +FFBBFFFRRL +BFBBBBFRRR +BFBBBFBRRR +FBFBBFBLRL +BFBBBFBLLR +FBBBFFBRRL +FBBFBFFRRL +FBFBBBFLRL +FBFFFFFRRL +FBFFFFFRLL +FBBBFBFLLL +FFFBFBBRLL +FFBBFBFRLR +FBBFBFFLLL +FFBBBFFLRL +BFFBBFBLLR +BFBFBBFRRR +FFBBBBFRLL +BBFBBBFRRL +FBBBFFBLLR +FBFBFFBLLL +FBFBFFFRRR +FFBFBFFLLR +BBFBFFFLLL +FBFFFBFLRR +FBFFFFBRRL +FBBFBBBLRR +FBBFBBFRRL +BFBBFFBLRL +FBBFBBBLLL +BBFBFFFRRR +FFBFBBFRLR +FBBFFFFRRR +BFBFBFBRLR +FBFBBBFLLR +BFBBBBBRRR +BBFFFFFLLR +BFFFFFFLRL +FBBBFFFLRR +BFFBFBBLLL +FBFBFFFRLR +BBFBBBFLLL +FFFBBBFRRL +BFFBFBFLRL +BFBBFBBLLL +BBFFFBFRRL +BFFBBFFLRR +BBFBBFFLLR +BFBBFBFRLL +FBBFFBFLLL +FBBFFFBLLR +FFFBBBBLLL +FFFBBFFRRL +FBFFFBBLRR +BBFBFBBRLL +BBFBBFFLRR +BFFBFBBRRL +FBBFFFFLRR +FBBFFBBLRR +BFFFBFBLLR +BFFBFBBRLR +FBFBBFBRRR +FBBFFBBRLR +BFBFFBFRLL +FBFBBBFLLL +FFBFFFFRRL +FBFBFBFLRR +BFBFBBFRLR +FBBBBBFLLR +FBFFFFBRLL +BFFFBBBRLL +FBBBBBBRLR +FFBBFFBLLL +FBFBBBBRRL +BFFBBFBRRL +BFFFBBBLLL +FBFFBBBLRR +FBFBFFFLLR +FBBFFFFLLR +FBFBBBBLLL +FBBFBFBRRR +BFBFBFFRRL +FBFFFFFLLR +FBFFBBFLRR +BBFBFBBLRL +FBFFFFFLRL +BFBFBFBLRR +BFBFFBFLRR +FFBFFBBRLL +BFFBBFBRLL +FBBFFBBLLL +FBFFFFBLLR +BFBFFFFLRR +FBFFBFBRLL +FFBFBFFLRR +BFFFFBBLLL +FFFBBBBRLL +BFBBBBFLRR +FBFFBBBRLL +FBFFFBBRRL +BFFBBFFLLR +BFBFFBBLRR +BFBFFFBLLL +BFFFFFBRRL +BBFBFBBRRR +BBFBBFBLRL +FBBFBFBLRR +BFFFFBBRRL +BFBBFBBRLL +FFBBFBBRLL +FBFBBFFRLR +FFBBBFFLLR +FBFFFFBRLR +BBFBBFBLRR +BFFBFBBLLR +FBBFFFBLRL +BFFBBBBRLL +FBBFBBFLLR +BFBBFBBRRR +BBFFBFBRLR +FFBFFFFLLL +BFBFBBBLRR +FBBFBBBLLR +FBBFBBBRRL +BFFFBBBRLR +BBFFBBBLLL +FFBFBFFRRR +FBFFBFBLRL +FBBFFBFLLR +FFBFFFBRRR +BFFFBFBRLR +FBFFFBBLLL +BBFFFBFLRL +FFBBBFBLRL +BFFFBFBRLL +FFBFFBBLLL +BFFFBBFLLL +BFBFFBBRLR +BFBBBBFRLL +BFBBFFFLLL +BBFFFBBRRL +FBFBFBFRRL +BBFBFFBLRL +BFBFFFFLLL +FBBBFFBRLR +FFBBFBBLLL +FFBBBBFRRR +FFFBBBBLRL +FFBFBFFRLR +FFFBBFBLLR +BBFFBBBRLL +FBFFFBFRLL +FFBFBFBLLL +FBFBFBBLRL +FFFBBBFLLL +BFFFBBFLRL +FFBBBFFRLL +FBFBBBBRLR +FBBFBFBRLR +BFFFFFFRRR +FBFBFFFLRR +BBFFFBFLLR +FBBBBBBLRL +FBFBFFBRRR +FBBBBFFRRL +BFFBFBFRLR +BBFFBFBRRL +BBFFBFFLLR +FBBBFBBLLR +FBFBFFBLRL +BFBBBBFLLL +FBBBFBBRLL +FFBBFBFRLL +FFFBBFBRLR +BBFBBBFLLR +BBFBFFBRLR +BBFFBFFLRR +FBFFBFBRRL +FFBFFBFRLL +FFFBBFBLRL +FBBFFFFRLR +BFFFBBFRLL +FBBFBBFLLL +BFBFBFBRRL +BFFFFFBRLR +BBFBBFFRRL +BFFBBFFRLR +BFFBFFFRRR +FFBBFFBLRR +FBBBBBFRRR +BBFBFBFRRL +FFBFBBBLRR +BFBFBFBRLL +FFBBBBFLRR +BFFFBFFLLL +FBBBBFBRRR +BBFBFBBLLL +BFBFBBFRRL +FBBFBBFLRR +BFFFFFBLRR +BFFFBFFLRL +BFFBBBBLLR +FBBFFFBRLL +BFBBBBFLRL +BFFBBBBLLL +BFFFFFFRLL +FBBBBBBRRR +FFBFFFFLRL +FBFFFBBRLL +FBFFFFBLRL +FBBBBBBLRR +FBFFBBFLLR +BFBBBFFLRL +FBFFBBFRRL +BFBFFBBLLR +BFBBFBFRLR +FBBBBFFLRR +BFBFBBBLLL +FFFBBBFRLL +FFBFFFBLRL +BFFBBBFLLL +FFBFBBFLLR +FBBFBFBLLL +BBFFBFFRLL +FBBFFFFRRL +BFBFFFFLLR +BBFBBFBLLL +BBFBFFFLRL +BFBBBBBLLR +FFBFBBBLLL +FFBBBFBRRL +FFFBBBBRLR +BFFFBFBLRR +FBBFBBBRLR +BFBFFFBLRR +FBBBFFBLRR +FFFBBFBRLL +BFBBFBBRRL +FFBBBFBRLL +BBFBFBFLRL +BBFBBFBRRL +BFBBBBBRLR +FFBBFFFLLR +FFBBBFFRRL +FFBBFBFLRR +FBFBFBBRRR +BFBFBBBLRL +FBFFBFFLRR +BFFBFFBLRR +FFBBFFFLLL +BFFFBBBLRL +FFBFBFBRLR +BFBFBFBRRR +BFFBBFFLRL +BBFFBFFLLL +BBFBBFBRLL +BBFFFFBLLR +FBBBBBBLLR +FFFBBBBRRL +FBBBBFFLLL +BBFBBFBLLR +BFBBBFFRRL +BFBBBFBLRR +BBFFFFFRLL +FFBBFBFLRL +BFBFFFBRLL +FFBFFBBLRL +FBBBBBBLLL +FBBBFBBRLR +BBFFBBFRRL +BFBFFFBRLR +BFBFFBFRRR +BBFFFBFRRR +BBFBFFFRLR +FFBBBFFLRR +FFBBFFFRLR +BFFFBFBRRR +BFBBFFBRLL +FBBBBFBLLR +FFBFFBBRRL +FBFFBFFLLR +FBFBFBFRLR +FBFFBFFLRL +FBFBFBBRLL +FBFBBBFRRL +FBBBBFBLRR +FBFFFFFLRR +FFBBFFBLRL +BFFFFBFRRL +FBBFBFFLRL +FFBFFFBLLL +FFBFBBFLRL +FFBBBFFLLL +BFBBFFBLLR +FFFBBFFLRR +FBBBBBFRLR +FBBFFFFLLL +BBFBFFBRRL +FBFFBFFRRL +FFBBFFBRLL +BBFFFBBLRL +FFFBBFFRLL +FFFBBFBLLL +BFFFFBBLLR +FBFBBBBRRR +BFBBFBBRLR +FFBFFFFLLR +FBBFBFFLRR +FFBBFFFRRR +BFBFBFFLRL +BBFBFBFRLL +FBBBBFFLLR +FBBBBFFRLL +BFFBFFFLRL +FFFBFBBLRL +FBFFBFFRLL +FBBFBBBLRL +BFBBFFBLRR +FBBFFFBLRR +BFFFBFFLRR +FBBFBFFRLL +FBFFBFFRRR +BBFFBFFRRR +BBFFBBBRRL +BFBBFBFRRR +FFBFFBFRRR +FBBBFBBLLL +FFBBFFBRRL +FBBBFFBRLL +FBBBFFFRRL +FBBBBBFRRL +FBBBFBBLRL +FFBBBBFLLR +FBFFBBBLLL +BFFBBBBRRL +FBBFBFBRLL +FBFFBFBRRR +BFBBBBFRLR +FBFFBBFLRL +FFBBFBBRRR +FBBFFBBRRR +BBFFFFFLLL +BFFBFBFLLL +BFFFFFFLLR +BFBBFBFRRL +BBFBBFBRLR +FBFBBBBLLR +FBFBBFFLRR +FFBFBFBRRR +BFBBBBBLLL +FBBFFFFRLL +FFBFBBFRRR +BFBFBFBLLR +FFBFFFBLLR +FBBBFFFRRR +FBFBBFFLLL +FBBBFBFRRL +BFBFFFFRRR +FFBBBBFLLL +BFBFBBBRRR +BFBBFFFRRL +BFBBBBBRLL +BFFFFBBLRL +FFBBFBFRRL +BFFFBFFRRL +FFFBBBBLRR +BFBBFFFLLR +BFFFBBFLLR +BFBBFFBRRR +FBFBBFBLLR +FBBBFBFLLR +FBFBFBBLLR +BFBFFFFRRL +BBFFBFFLRL +BBFFFFFRLR +FFBFBFFRRL +FFBFBFBRRL +FFBFBBFRLL +FBFFBBBLLR +FBBFFFBRRR +FBBBBBFLRR +FBFBBFBLRR +BFBBFFFLRR +FBFFBFBLRR +FFFBBBFRLR +BFFFFFFLRR +BFFFFBFLLR +BFFFFBFLRL +BFBFBBFLLL +FBBBBBFRLL +BFBBBFFRLL +BFFBFFBRRR +FBBFFFBRRL +FBBBBBBRRL +BFFBBBBRRR +FBBBBFFRLR +BFFBFFFRLR +FBBBFFBRRR +BFFBFBFRRL +BFBFBBFLLR +BFBFFBBLLL +FBBBFFFRLR +FFBBBFFRLR +FFBFBBBRLR +BBFFBBBRRR +FBFFBBFRLR +BBFFBBBLRR +FFBBBBBLRL +BFFFBFFLLR +FBFFFBBRLR +BFFFFBBRRR +BFBFBBFLRL +BBFFFFBLLL +BBFFFBBRRR +BFBBFFBRRL +BFBFFBFRRL +FBFBBFFRLL +BFFBBBFRLR +BBFBBBFRLR +FBBFBBFLRL +FBBBFFFRLL +BFFBBFFRLL +BFBBBBFLLR +BFFBBFFRRL +FFBFFFFLRR +BBFBBBFRLL +BBFBFBFRLR +BBFFBBBLLR +FBFBBFFLLR +BFFBBBFRLL +FFBBFFBRLR +FFBBFBBLRL +BFFFBBFRRR +BBFBBFFRLL +BFFBBFBLRR +FBFFBBBRRR +BFFFBFFRLL +FFFBBBBRRR +BFBBFBFLRR +FFBBBBFLRL +FBFFFBFRRR +BFBFBFFLLR +BFBFBBBLLR +FFBFFBFLLL +FFBFFBFRRL +BFFBFFBLRL +BFBBFFFRLL +FBBFFBFRLR +BFFBBFBLLL +FFFBBBFRRR +FBFBFBFRRR +BFBFBBBRRL +FFBBFBBRLR +BFFBFFFLLR +BFBFBFFRRR +FBFFFFBRRR +BFBFFBBLRL +BFBBFBBLRR +BFFBFBFRLL +BFBFBFFRLL +FFBBFBFLLL +FBBFFBBRLL +BBFFBBFRLL +BBFFFFFRRL +FFFBBFFLLL +FBBBFBFRRR +BFBFFBFLLL +BBFBFFFLRR +FBBFBFBRRL +FFBFBFFRLL +FFBFFFBLRR +FFBBFBBLRR +FFBBFBFLLR +FBFFFBBLRL +FBFBFBFLLR +BBFFFBBLLR +FBFFFBFLLR +FBBBFBFLRR +BBFBBBBLLL +FBFBFFFLLL +FFBBBFBRRR +FFBBFFFRLL +BBFBBFFLRL +FBFBBFBRLR +BFFFBBFLRR +BFBFFBBRLL +BFFFBBFRRL +FFBBBFBLLL +FBFBBBFRLR +FBBBFFBLRL +BFBFFFFLRL +FFBFFBBLRR +FBFBBBBLRL +BBFBFBBLLR +FFBBFFFLRL +FBFFFFFRRR +FBBBBFFLRL +FFBBBFBLLR +BFBFFBBRRL +FBFFFBFLLL +FFFBBFBRRL +BBFBFBBRLR +BBFBBFBRRR +BBFBBBFLRR +BFFBFFBLLL +FFBFBBBRLL +BBFBFFFLLR +BBFFBBFRLR +FFBBFBFRRR +BFBBFBBLRL +BBFBFBFLLL +BFBFFBFLRL +BFBBBFBLLL +FFBFFBFLLR +BFFBBBFRRR +BFFFFBFLLL +BFBFBFBLRL +FBFBFBBRLR +FBFFFFFRLR +FFBBBBBLRR +BBFFFBBLRR +BBFBBBFLRL +FBFFBBBRLR +FFBBBBBLLL +FFBFBBBRRR +FFBBBBBRLR +BFFFFBBRLL +BFBBBBBLRL +FBBFBBFRLL +FBBBBBBRLL +BBFFBFFRLR +BBFFBFBLRL +BFFBFBBLRL +BBFFFFBLRR +FBBFBFBLRL +FFBFBBBRRL +BBFFFBBRLL +BFBFFFFRLR +BFBFBBFLRR +BBFFFBBLLL +FBBBBFBRRL +FFBBBFFRRR +FBBBFBBRRL +FBBFBFFRRR +FFBFFBBRLR +BFBBBFFLLL +FFBFFBFLRL +BFFBBBFLRR +BFBFFFBRRR +FBBFBBFRRR +BFFFBFFRRR +BBFBFFFRRL +BFFBFFBRLL +FFFBBFFRLR +FBFFBBFLLL +FBFFFBFRRL +FBBFBBBRRR +FFBFBFFLRL +BBFBFFBLLL +FBBFFBBRRL +BBFBFFBLRR +FBFBBFBLLL +FBFBFFBRLR +BFFFBFFRLR +BFBFBFFRLR +FFBBBBFRLR +FBBFFBFRRL +FFBFFFFRLR +BFBFFFBLLR +FFBFFFFRRR +FBBBFFFLLR +BFFBFFFRLL +FBBFFBBLRL +BFFBFBFRRR +BFFBFBBRLL +BFBBFBBLLR +BBFBFBBRRL +FBFBFFBLLR +FBFFFBFRLR +FFBFBBFLLL +FBBBFBFLRL +FBFFBBFRLL +BFFFBBBLLR +BFFBBFBLRL +FBFBFBBLLL +BBFFFFFRRR +FBFBBBFRRR +FBFBFFFRLL +FFBFBFBLRL +FBFBFBFLRL +BFFFFFFLLL +FFBBFFBRRR +FBBBBFBRLL +FFFBBFFLRL +BFFBBFBRRR +FBFBBFFRRR +BFBBFBFLLL +BFFFBBBRRR +FFBFBFBLLR +BFFBFBFLRR +BFBBBFFRLR +BFFFFFBRRR +BFFFFFBLLR +BFFBFFFLRR +BBFFFFBRLL +FBBFFBFRRR +BBFFBFBLLR +BBFFFFBRLR +BBFFFBFLRR +BFBBFBFLLR +BBFFBFBRLL +FBBBFBBRRR +FBFBFBBRRL +FFBFBBBLRL +BFFFBFBLLL +FBBFFBBLLR +FBBBFBFRLR +FBBBFBFRLL +BFBFBBBRLL +BBFBBFFRRR +FBFBBBBRLL +BFBBBBBLRR +BFFBFFBRRL +BBFFBBFLRL +BFFBBFBRLR +FFBFFFBRLL +FFFBFBBRRL +BFBFFFBLRL +BFFBFBBRRR +FBBFFFFLRL +BBFBFBFLLR +BFFBFFBLLR +BFFBBBBLRR +BFBBBFFLRR +FBBBBFBLRL +FBBBBBFLLL +FFBFFFFRLL +FFBBBBBRLL +BFFFFFBRLL +BFFFBBBRRL +BBFFFBFRLR +BFBBFBFLRL +BFFFBFBLRL +FBBFBFFRLR +BBFBFFBRLL +BBFFBFBRRR +BFBBBFBRLR +BFFBFFFRRL +BFBBBFBLRL +BFBBFFFRRR +FBFFFBFLRL +FFBFBBFRRL +BFFFFFFRLR +BFFBFBBLRR +FFFBBFBLRR +BFBBBFBRLL +FBFFFFFLLL +BFFBBBFLRL +FBFBFFBLRR +FBFFBBBLRL +FBFBBFBRLL +FFBFBBFLRR +BFBBFFBLLL +BBFBBBFRRR +FBFBBBBLRR +BFBFBFFLRR +FBBFFBFRLL +FBFBBBFLRR +FFFBFBBLLR +BBFBFFBRRR +FBFFBFFLLL +BBFFBFFRRL +FFBFBFFLLL +BFFBBBFRRL +FBBFBFFLLR +BFBBFFFRLR +BFBFBFBLLL +BFFBFFBRLR +FBBBBBFLRL +BFBBBFFLLR +FFFBFBBLRR +BBFBBFFLLL +FBBBFFBLLL +BBFFFFBLRL +FFBBFBBRRL +FFFBBBBLLR +FBFBFBFLLL +FBFBFBBLRR +BFFFFFFRRL +FFBFFBBRRR +FFFBBFFLLR +BFFFFBFRLR +FBFFBFBLLL +BFFFFBBLRR +BFBFFBBRRR +BBFFBBFLLL +FBBFFFBLLL +FBFFFFBLLL +FBFFFBBLLR +BBFFBBFLRR +FFBBBFBLRR +BFFFFBFRRR +BBFFBFBLRR \ No newline at end of file diff --git a/05/main.go b/05/main.go new file mode 100644 index 0000000..4e69551 --- /dev/null +++ b/05/main.go @@ -0,0 +1,108 @@ +package main + +import ( + "bufio" + "fmt" + "os" + "sort" +) + +func main() { + partOne() + partTwo() +} + +type boardingPass struct { + passID string + row int + seat int + id int +} + +func parsePassID(s string) (int, int) { + bottom := 0 + top := 127 + left := 0 + right := 7 + + for _, r := range s { + switch { + case r == 'F': + top = ((top - bottom - 1) / 2) + bottom + case r == 'B': + bottom = (top + bottom + 1) / 2 + case r == 'L': + right = ((right - left - 1) / 2) + left + case r == 'R': + left = (left + right + 1) / 2 + } + } + return top, left +} + +// Instead of zones or groups, this airline uses binary space partitioning to seat people. +// A seat might be specified like FBFBBFFRLR, where F means "front", B means "back", L means "left", and R means "right". +// Every seat also has a unique seat ID: multiply the row by 8, then add the column. +// Here are some other boarding passes: +// BFFFBBFRRR: row 70, column 7, seat ID 567. +// FFFBBBFRRR: row 14, column 7, seat ID 119. +// BBFFBBFRLL: row 102, column 4, seat ID 820. +// As a sanity check, look through your list of boarding passes. What is the highest seat ID on a boarding pass? + +func partOne() { + f, _ := os.Open("input") + reader := bufio.NewReader(f) + scanner := bufio.NewScanner(reader) + + passes := []boardingPass{} + maxID := 0 + + for scanner.Scan() { + line := scanner.Text() + row, column := parsePassID(line) + passes = append(passes, boardingPass{ + passID: line, + row: row, + seat: column, + id: (row * 8) + column, + }) + if (row*8)+column > maxID { + maxID = (row * 8) + column + } + } + + fmt.Println(maxID) +} + +// It's a completely full flight, so your seat should be the only missing boarding pass in your list. +// However, there's a catch: some of the seats at the very front and back of the plane don't exist on this aircraft, so they'll be missing from your list as well. +// Your seat wasn't at the very front or back, though; the seats with IDs +1 and -1 from yours will be in your list. + +func partTwo() { + f, _ := os.Open("input") + reader := bufio.NewReader(f) + scanner := bufio.NewScanner(reader) + + passes := []boardingPass{} + + for scanner.Scan() { + line := scanner.Text() + row, column := parsePassID(line) + passes = append(passes, boardingPass{ + passID: line, + row: row, + seat: column, + id: (row * 8) + column, + }) + } + + sort.Slice(passes, func(i, j int) bool { + return passes[i].id < passes[j].id + }) + + for i, s := range passes { + if i != 0 && passes[i-1].id != s.id-1 { + fmt.Println(s.id - 1) + } + } +}