Release

.gitignore

@@ -0,0 +1 @@
+*.DS_Store

challenge/advent/assignment/assignment.go

@@ -0,0 +1,78 @@
+package assignment
+
+import (
+    "io"
+    "fmt"
+    "strings"
+    "strconv"
+    "bufio"
+
+   "github.com/GPKyte/banter/challenge/advent/section"
+   "github.com/GPKyte/banter/challenge/advent/elf"
+)
+
+type Assignment struct {
+    s *section.SectionRange
+    e *elf.Elf
+}
+
+type AssignmentPair struct {
+    a, z *Assignment
+}
+
+func (ap *AssignmentPair) String() string {
+    return fmt.Sprintf("%d-%d,%d-%d",
+        ap.a.s.First(), ap.a.s.Last(), ap.z.s.First(), ap.z.s.Last())
+}
+
+func LoadFromPuzzleInput(from io.Reader) *[]*AssignmentPair {
+    aps := make([]*AssignmentPair, 0)
+
+    s := bufio.NewScanner(from)
+    s.Split(bufio.ScanLines) // Set token scan behavior to read line by line
+    for dataRemaining := s.Scan(); dataRemaining; dataRemaining = s.Scan() {
+        line := s.Text()
+        aps = append(aps, newPair(line))
+    }
+
+    return &aps
+}
+func newPair(s string) *AssignmentPair {
+    first, second := splitAtThe(",", s)
+
+    return &AssignmentPair{
+        a: New(first),
+        z: New(second),
+    }
+}
+func splitAtThe(sep, s string) (string, string) {
+    ss := strings.Split(s, sep)
+
+    if len(ss) != 2 {
+        panic("Could not properly split the input string: "+s)
+    }
+
+    return ss[0], ss[1]
+}
+func New(s string) *Assignment {
+    one, two := splitAtThe("-", s)
+    start, err := strconv.Atoi(one)
+    if err != nil {
+        panic("Could not parse the "+s+" string for new Assignment.")
+    }
+    end, err := strconv.Atoi(two)
+    if err != nil {
+        panic("Could not parse the "+s+" string for new Assignment.")
+    }
+    return &Assignment{
+        s: section.Range(start, end),
+        e: &elf.Elf{},
+    }
+}
+func (ap *AssignmentPair) AnyOverlap() bool {
+    return section.DoAnyOverlap(ap.a.s, ap.z.s)
+}
+
+func (ap *AssignmentPair) HasFullyRedundantSectionOverlap() bool {
+    return section.EitherContainsTheOther(ap.a.s, ap.z.s)
+}

challenge/advent/assignment/assignment_test.go

@@ -0,0 +1,42 @@
+package assignment
+
+import (
+    "testing"
+    "strings"
+)
+
+func TestImportFromString(t *testing.T) {
+    input := "2-4,8-9"
+    p := newPair(input)
+
+    if p.a.s.Len() != 3 || p.z.s.Len() != 2 {t.Fail()}
+
+    severalInputs := `0-9,5-9
+1-3,3-8
+4-5,9-20
+3-6,1-10`
+    severalAps := LoadFromPuzzleInput(strings.NewReader(severalInputs))
+    if len(*severalAps) != 4 {t.Fail()}
+}
+
+func TestRedundancyCheck(t *testing.T) {
+    with := newPair("20-30,10-50")
+    without := newPair("1-5,4-9")
+    equal := newPair("1-8,1-8")
+
+    if !with.HasFullyRedundantSectionOverlap() {t.Fail()}
+    if without.HasFullyRedundantSectionOverlap() {t.Fail()}
+    if !equal.HasFullyRedundantSectionOverlap() {t.Fail()}
+}
+
+func TestOverlap(t *testing.T) {
+    with := newPair("20-30,10-50")
+    without := newPair("1-5,4-9")
+    equal := newPair("1-8,1-8")
+    other := newPair("10-35,49-81")
+
+    if !with.AnyOverlap() {t.Fail()}
+    if !without.AnyOverlap() {t.Fail()}
+    if !equal.AnyOverlap() {t.Fail()}
+    if other.AnyOverlap() {t.Fail()}
+}

challenge/advent/common/file.go

@@ -0,0 +1,21 @@
+package common
+
+import (
+    "os"
+)
+
+func OpenFirstArgAsFileReader() *os.File {
+    if len(os.Args) < 2 {
+        panic("Specify which file to read from as first argument.")
+    }
+    fileAtRelativePath := os.Args[1]
+
+    file, err := os.Open(fileAtRelativePath)
+    if err != nil && os.IsNotExist(err) {
+        panic("File does not exist at "+fileAtRelativePath)
+    } else if err != nil {
+        panic("Could not open file "+fileAtRelativePath)
+    }
+
+    return file
+}

challenge/advent/crate/crate.go

@@ -0,0 +1,14 @@
+package crate
+
+type Crate string
+const CrateSize int = len("[C]") // characters needed to label a crate in the puzzle's input e.g. '[C]'
+
+func New(crate string) Crate {
+    return Crate(crate)
+}
+
+var NoCrate = Crate("")
+
+func (c Crate) DifferentThan(this Crate) bool {return c != this}
+func (c Crate) SameAs(this Crate) bool {return !c.DifferentThan(this)}
+func (c Crate) ShortString() string {return string(c[1:2])}

challenge/advent/crate/crate_test.go

@@ -0,0 +1,50 @@
+package crate
+
+import (
+    "testing"
+    "os"
+)
+
+func exampleHelper(t *testing.T, fn string) func(t *testing.T) {
+    return func(t *testing.T) {
+        ex, err := os.Open(fn)
+        if err != nil {
+            panic(err)
+        }
+        defer ex.Close()
+
+        stacks, usingTransfers := LoadPuzzle(ex)
+        stacks.rearrange(usingTransfers, true)
+        ex.Seek(int64(0), 0) // Reset reader
+        expectedStacks := loadPuzzleAnswer(ex)
+
+        if have, want := stacks.TopSummary(), expectedStacks.TopSummary(); have != want {
+            t.Fail()
+            t.Log(have, want)
+            t.Log(stacks)
+            t.Log(expectedStacks)
+        }
+    }
+}
+
+func TestPuzzleExample(t *testing.T) {
+
+    MultiCrateTransfer.Disable()
+
+    for _, fn := range []string{
+        "testdata/example-00.txt",
+        "testdata/example-01.txt",
+    } {
+        t.Run(fn, exampleHelper(t, fn))
+    }
+
+    MultiCrateTransfer.Enable()
+
+    for _, fn := range []string{
+        "testdata/example-10.txt",
+        "testdata/example-11.txt",
+    } {
+        t.Run(fn, exampleHelper(t, fn))
+    }
+}
+

challenge/advent/crate/input.go

@@ -0,0 +1,170 @@
+package crate
+
+import(
+    "io"
+    "bufio"
+    "strings"
+    "strconv"
+    "fmt"
+)
+
+func parseInstructions(s string) []Transfer {
+    instructions := make([]Transfer, 0)
+
+    i := bufio.NewScanner(strings.NewReader(s))
+    i.Split(bufio.ScanLines)
+    for ok := i.Scan(); ok; ok = i.Scan() {
+        var src, dst, qty int
+        _, err := fmt.Sscanf(i.Text(), "move %d from %d to %d", &qty, &src, &dst)
+        if err != nil {
+            panic(fmt.Errorf("Got the error (%w) and thus could not scan instructions from this input: %s\n", err, i.Text())) 
+        }
+        instructions = append(instructions, Transfer{
+            Source: src,
+            Destination: dst,
+            Quantity: qty,
+        })
+    }
+    return instructions
+}
+
+
+func LoadCrates(from io.Reader) map[int][]Crate {
+    // Track where each crate was found
+    properPlace := map[int][]Crate{}
+    transferCratesToProperPlace := func(m map[int]Crate) {
+        for key, crate := range m {
+            if _, ok := properPlace[key]; !ok {
+                properPlace[key] = make([]Crate, 0)
+            }
+            properPlace[key] = append(properPlace[key], crate)
+        }
+    }
+
+    s := bufio.NewScanner(from)
+    s.Split(bufio.ScanLines)
+    for dataRemaining := s.Scan(); dataRemaining; dataRemaining = s.Scan() {
+        if !strings.Contains(s.Text(), "[") {
+            break // Because the input no longer serves this function
+        }
+        transferCratesToProperPlace(
+            extractCratesFromLine(s.Text()))
+    }
+
+    return properPlace
+}
+
+func extractCratesFromLine(s string) map[int]Crate {
+    // cratesInSparseSlice := make([]Crate, len(s))
+    cratesByInputLocation := map[int]Crate{}
+
+    foundCrateLabel := false
+    for i, r := range s {
+        if foundCrateLabel {
+           cratesByInputLocation[i] = Crate("["+string(r)+"]") 
+        }
+        foundCrateLabel = r == '['
+    }
+    return cratesByInputLocation
+}
+
+func LoadPuzzle(input io.Reader) (*Stacks, []Transfer) {
+    puz := bufio.NewReader(input) // Once read in part, can no longer read said part without resetting
+    var stackDrawing, stackLabels, transferInstructions string
+
+    stackDrawing, _ = puz.ReadString('1')
+    puz.UnreadByte() // Give back the '1' so that it can be found in the stack labels
+    stackLabels, _ = puz.ReadString('\n')
+    puz.ReadLine() // Empty line before transferInstructions
+    transferInstructions, _ = puz.ReadString('-') // Read until EOF or puzzle answer separator
+    transferInstructions = string(transferInstructions[:len(transferInstructions) - 1])
+
+    howMany := parseNumberOfStacks(strings.NewReader(stackLabels))
+    stacks := createStacks(strings.NewReader(stackDrawing), howMany)
+    transfers := parseInstructions(transferInstructions)
+
+    return stacks, transfers
+}
+
+func brokenLoadPuzzle(input io.Reader) (*Stacks, []Transfer) {
+    // Worried that sharing io.Reader and varying implementation options of subfunctions could result in odd behavior, as though io.Reader may need to be reset.
+    copy := make([]byte, 0)
+    io.ReadFull(input, copy)
+
+    howMany := parseNumberOfStacks(strings.NewReader(string(copy)))
+    stacks := createStacks(strings.NewReader(string(copy)), howMany)
+
+    r := bufio.NewReader(strings.NewReader(string(copy)))
+    aid := []byte("1.")
+    r.ReadString(aid[0]) // Stack labels are written above the tranfer instructions
+    r.ReadLine() // Clear this line
+    i, _ := r.ReadString(aid[1]) // Won't find a period, will go to EOF
+    transfers := parseInstructions(i)
+
+    return stacks, transfers
+}
+
+func parseNumberOfStacks(input io.Reader) int {
+    r := bufio.NewReader(input)
+    discarded, err := r.ReadString('1')
+    if err != nil {
+        panic(
+            fmt.Errorf(
+                `Could not find start of stack labels because %w
+                Discarded this input: %s`,
+            err, discarded))
+    }
+    stackLabelsLineRaw, err := r.ReadString('\n')
+    if err != nil {
+        panic(fmt.Errorf("Could not read line of Stack Labels: %w", err))
+    }
+    stackLabelsLine := strings.Trim(stackLabelsLineRaw, " \n")
+    stackLabels := strings.Split(stackLabelsLine, " ")
+    lastLabel, err := strconv.Atoi(last(stackLabels))
+    if err != nil {
+        panic(fmt.Errorf("Could not parse last stack label due to: %w", err))
+    }
+
+    return lastLabel
+}
+
+func last(ss []string) string {
+    return ss[len(ss)-1]
+}
+
+func brokenParseNumberOfStacks(input io.Reader) int {
+    bs := bufio.NewScanner(input)
+    ok := bs.Scan()
+    asLongAsItTakesToFindTheLineWithStackLabels := func () bool {
+        continueWhileNotFound := ok
+        moveOnWhenReady := !strings.Contains(bs.Text(), "1") // Finding the number one breaks the for loop
+        return continueWhileNotFound && moveOnWhenReady
+    }
+
+    for asLongAsItTakesToFindTheLineWithStackLabels() {
+        ok = bs.Scan()
+    }
+    if !ok && !strings.Contains(bs.Text(), "1") {
+        panic("Could not find number of stacks. Most recent line scanned is: "+bs.Text())
+    }
+    stackLabels := strings.Split(bs.Text(), " ")
+    stackCount, err := strconv.Atoi(stackLabels[len(stackLabels)-2])
+    if err != nil {
+        panic(fmt.Errorf("Could not read last stack label from %v and find number of stacks. Encountered this error as a result: %w", stackLabels, err))
+    }
+    return stackCount
+}
+
+func loadPuzzleAnswer(input io.Reader) *Stacks {
+    s := bufio.NewReader(input)
+    s.ReadString('-') // "---" marks end of input and start of puzzle
+    s.ReadString('\n') // "--\n" is leftover after previous Read, clear the line
+    // Load remaining content as stacks
+
+    stackDrawing, _ := s.ReadString('1')
+    s.UnreadByte()
+    stackLabels, _ := s.ReadString('\n')
+
+    howMany := parseNumberOfStacks(strings.NewReader(stackLabels))
+    return createStacks(strings.NewReader(stackDrawing), howMany)
+}