Forem: Edvin

DAY 16 - Advent of Code 2020 w/ GoLang

Edvin — Wed, 16 Dec 2020 20:38:17 +0000

DAY16:

I just did not like the code I wrote for this one. Part one was fine and took about 5 lines of code (other than the input parsing). Part two had me flipping and filtering my matrix of fields and values in a lot of messy ways. Granted I could have done it cleaner but I did not revisit the code I should clean up. If I had some of the mapping and reducing functionality of JS, this would've been simpler. Not complaining that Go doesn't have those, but it is worth mentioning.

Oh.. also, my code will either return the correct answer or just hang..

package days

import (
    "fmt"
    "strings"

    inputs "../inputs"
)

// https://adventofcode.com/2020/day/16
// Sixteen : advent of code, day sixteen part1 and 2
func Sixteen() {

    /*
        This struct is being used for input

        type Tickets struct {
            Fields        map[string][]int
            Ticket        []int
            NearbyTickets [][]int
        }
    */
    input := inputs.Day16

    fmt.Print("(Part 1) - Sum of all bad field values: ")
    fmt.Println(sumAllInvalidValuesOnNearbyTickets(input))

    fmt.Println("(Part 2) - : ")

    withValidTicketsOnly := tossBadTickets(input)
    matchingFieldNames := getFieldNames(withValidTicketsOnly)

    departureTotal := 1

    for i, fieldName := range matchingFieldNames {
        if strings.Contains(fieldName, "departure") {
            departureTotal *= withValidTicketsOnly.Ticket[i]
        }
    }

    fmt.Println(departureTotal)
}

func sumAllInvalidValuesOnNearbyTickets(tickets inputs.Tickets) int {
    badSum := 0

    for _, ticket := range tickets.NearbyTickets {
        for _, fieldValue := range ticket {
            if !validForAnyField(fieldValue, tickets) {
                badSum = badSum + fieldValue
            }
        }
    }

    return badSum
}

func validForAnyField(fieldValue int, tickets inputs.Tickets) bool {
    isIt := false

    for _, ranges := range tickets.Fields {
        if (fieldValue >= ranges[0] && fieldValue <= ranges[1]) || (fieldValue >= ranges[2] && fieldValue <= ranges[3]) {
            isIt = true
            break
        } else {
            isIt = false
        }
    }

    return isIt
}

func tossBadTickets(tickets inputs.Tickets) inputs.Tickets {
    toReturn := inputs.Tickets{}
    toReturn.Fields = tickets.Fields
    toReturn.Ticket = tickets.Ticket
    toReturn.NearbyTickets = [][]int{}

    for _, ticket := range tickets.NearbyTickets {
        fullTicketMatch := true
        for _, fieldValue := range ticket {
            if !validForAnyField(fieldValue, tickets) {
                fullTicketMatch = false
                break
            }
        }
        if fullTicketMatch {
            toReturn.NearbyTickets = append(toReturn.NearbyTickets, ticket)
        }
    }

    return toReturn
}

func getFieldName(column []int, fields map[string][]int) []string {
    allMatchingFieldNames := []string{}

    for fieldName, ranges := range fields {
        fullMatch := true
        for _, val := range column {
            if !((val >= ranges[0] && val <= ranges[1]) || (val >= ranges[2] && val <= ranges[3])) {
                fullMatch = false
                break
            }
        }

        if fullMatch {
            allMatchingFieldNames = append(allMatchingFieldNames, fieldName)
        }
    }

    return allMatchingFieldNames
}

func getFieldNames(tickets inputs.Tickets) []string {
    columns := [][]int{}
    column := []int{}

    for col := 0; col < len(tickets.NearbyTickets[0]); col++ {
        column = []int{}
        for row := 0; row < len(tickets.NearbyTickets); row++ {
            column = append(column, tickets.NearbyTickets[row][col])
        }
        columns = append(columns, column)
    }

    matchingFieldNames := [][]string{}

    for _, col := range columns {
        matchingFieldNames = append(matchingFieldNames, getFieldName(col, tickets.Fields))
    }

    return filterFieldNames(matchingFieldNames)
}

func filterFieldNames(allMatchingFieldNames [][]string) []string {
    filtered := []string{}

    for !allSizeOne(allMatchingFieldNames) {
        for i, rows := range allMatchingFieldNames {
            for j, col := range rows {

                anotherOfMe := false

                for k, rowsInner := range allMatchingFieldNames {
                    for y, colInner := range rowsInner {
                        if y != j && k != y {
                            if col == colInner {
                                anotherOfMe = true
                            }
                        }
                    }
                }

                if !anotherOfMe {
                    allMatchingFieldNames[i] = []string{col}
                }
            }
        }
    }

    for _, fieldNameAsSlice := range allMatchingFieldNames {
        filtered = append(filtered, fieldNameAsSlice[0])
    }

    return filtered
}

func allSizeOne(doubleSlice [][]string) bool {
    res := true

    for _, v := range doubleSlice {
        if len(v) > 1 {
            res = false
            break
        }
    }

    return res
}

Link to Github source file

DAY 15 - Advent of Code 2020 w/ GoLang

Edvin — Tue, 15 Dec 2020 17:08:22 +0000

DAY15:

So, yesterday I thought I'd wrap up on Advent Of Code but today's problem just clicked. I'm assuming it was meant to be easier after those last few days.

It was odd that it took exactly zero lines of changes for part two. All you had to do was alter the final turn. It just took a bit longer. Mine timed in at about 7.6s

package days

import (
    "fmt"

    inputs "../inputs"
)

// https://adventofcode.com/2020/day/15
// Fifteen : advent of code, day Fifteen part1 and 2
func Fifteen() {
    inputSlice := inputs.Day15

    // k: number spoken | v: {num of times spoken, last time spoken}
    spoken := make(map[int][]int)

    for i, num := range inputSlice {
        spoken[num] = []int{1, i, i}
    }

    fmt.Print("(Part 1) - 2020th number spoken: ")
    fmt.Println(getLastNumberSpoken(spoken, 2020))
    fmt.Print("(Part 1) - 2020th number spoken: ")
    fmt.Println(getLastNumberSpoken(spoken, 30000000))
}

func getLastNumberSpoken(spoken map[int][]int, last int) int {
    nextNum := 0
    var lastNum int
    var lastTurn int
    for _, v := range spoken {
        if v[1] > lastTurn {
            lastTurn = v[1]
            lastNum = v[0]
        }
    }

    for i := len(spoken); i < last; i++ {
        if _, ok := spoken[lastNum]; ok {
            if spoken[lastNum][0] == 1 {
                nextNum = 0
            } else {
                nextNum = spoken[lastNum][1] - spoken[lastNum][2]
            }
        }

        if _, ok := spoken[nextNum]; ok {
            spoken[nextNum][0]++
            spoken[nextNum][2] = spoken[nextNum][1]
            spoken[nextNum][1] = i
            lastNum = nextNum
        } else {
            spoken[nextNum] = []int{1, i, i}
            lastNum = nextNum
        }
    }

    return nextNum
}

Link to Github source file

DAY 14 - Advent of Code 2020 w/ GoLang

Edvin — Mon, 14 Dec 2020 21:39:12 +0000

DAY14:

Well, crew. I think we found my probable stopping point. I hate bitwise. I'll admit. I'm not great at it. Definitely a sore point in my former CS courses as well 😅

I know there are other ways of solving this through string parsing, but I'm at the point where I'm spending less time solving these for fun and more time just trying to finish.

If I happen to sneak in a few more of these later problems, I'll keep the series updated.

Until then,
✨🍻 Happy Holidays! 🍾✨

DAY 13 - Advent of Code 2020 w/ GoLang

Edvin — Sun, 13 Dec 2020 21:37:02 +0000

DAY13:

TLDR: Use modulo and look at least common multiple

Again, part one went pretty well. Part two read like it would be a similar difficulty. It was about a similar difficulty level but if not optimized could potentially take hours to run. When I got the solution the first time, it was after passing all test cases and allowing my code to run for about 4 hours. While that was happening, I did some research (Google) and got reminded of least common multiple which after implemented, allowed my program to finish MUCH faster. Essentially it allows you to short circuit and skips forward to the next best potential timestamp without evaluating every single one in between.

package days

import (
    "fmt"
    "strconv"

    inputs "../inputs"
)

// https://adventofcode.com/2020/day/13
// Thirteen : advent of code, day thirteen part1 and 2
func Thirteen() {
    inputSlice := inputs.Day13
    earliestTimeStamp := inputs.Day13EarliestTimestamp
    buses := []int{}

    for bus := range inputSlice {
        if inputSlice[bus] == "x" {
            buses = append(buses, 1)
        } else {
            asInt, _ := strconv.Atoi(inputSlice[bus])
            buses = append(buses, asInt)
        }
    }

    fmt.Print("(Part 1) - Minutes to catch multiplied by the bus ID: ")
    fmt.Println(catchNextPossibleBus(buses, earliestTimeStamp))

    fmt.Print("(Part 2) - Earliest timestamp of subsequent series: ")
    fmt.Println(startStampOfSubsequentSeries(buses, 0))

}

func catchNextPossibleBus(buses []int, earliestTimeStamp int) int {
    busMap := make(map[int]int)

    for bus := range buses {
        if buses[bus] > 1 {
            busMap[buses[bus]] = buses[bus] - (earliestTimeStamp % buses[bus]) + earliestTimeStamp
        }
    }

    nextBusTimeStamp := 0
    nextBus := 0

    for k, v := range busMap {
        if v < nextBusTimeStamp || nextBusTimeStamp == 0 {
            nextBusTimeStamp = v
            nextBus = k
        }
    }

    return nextBus * (nextBusTimeStamp - earliestTimeStamp)
}

func startStampOfSubsequentSeries(buses []int, multiplier int) int {
    start := 0
    properBusSeries := false

    for !properBusSeries {
        skipFactor := 1
        properBusSeries, skipFactor = checkThisSeries(buses, start, skipFactor)
        if !properBusSeries {
            start = start + skipFactor
        }
    }

    return start
}

func checkThisSeries(buses []int, start int, skipFactor int) (bool, int) {
    for bus := 0; bus < len(buses); bus++ {

        if (start+bus)%buses[bus] != 0 {
            return false, skipFactor
        }

        skipFactor = skipFactor * buses[bus]
    }

    return true, skipFactor
}

Link to Github source file

DAY 12 - Advent of Code 2020 w/ GoLang

Edvin — Sun, 13 Dec 2020 01:48:54 +0000

DAY12:
Hey! Finished part 2 with a few 🍻 on this rainy Georgia saturday.

So part one was pretty straightforward. It just wanted you to walk the grid while tracking the x and y points and find the manhattan distance traveled.

Part two was slightly trickier, but it was boiled down to rotating one point around another. At least that was the main difference from part one. I used the same code structure from part one's main worker function and just modified it to take into account the rotation.

After struggling pretty hard on Day11, this was a nice problem to work through 😌

NOTE: Yeah, this is a bit verbose and much of the code was duplicated. I'm not pushing myself to get the perfect solution, but rather just getting the solution for fun. If you have questions, ask them in the comments!

package days

import (
    "fmt"
    "strconv"
    "strings"

    inputs "../inputs"
)

// https://adventofcode.com/2020/day/12
// Twelve : advent of code, day twelve part1 and 2
func Twelve() {
    inputSlice := inputs.Day12

    directions := [][]string{}
    directions = append(directions, []string{"E", "0"})
    for dir := range inputSlice {
        tmp := strings.Split(inputSlice[dir], " ")
        directions = append(directions, tmp)
    }

    waypointDirs := [][]string{}
    waypointDirs = append(waypointDirs, []string{"E", "0"})
    for dir := range inputSlice {
        tmp := strings.Split(inputSlice[dir], " ")
        waypointDirs = append(waypointDirs, tmp)
    }

    eastWest, northSouth := travel(directions)
    fmt.Print("(Part1) - Manhattan Distance of my ship: ")
    fmt.Println(absOfInt(eastWest) + absOfInt(northSouth))

    eastWest, northSouth = waypointTravel(waypointDirs)
    fmt.Print("(Part2) - Manhattan Distance of my ship: ")
    fmt.Println(absOfInt(eastWest) + absOfInt(northSouth))
}

func waypointTravel(directions [][]string) (int, int) {
    eastWest := 0
    northSouth := 0

    currentWaypointPosition := []int{eastWest + 10, northSouth + 1}

    for dir := range directions {
        asInt, _ := strconv.Atoi(directions[dir][1])
        switch directions[dir][0] {
        case "N":
            currentWaypointPosition[1] = currentWaypointPosition[1] + asInt
        case "S":
            currentWaypointPosition[1] = currentWaypointPosition[1] - asInt
        case "E":
            currentWaypointPosition[0] = currentWaypointPosition[0] + asInt
        case "W":
            currentWaypointPosition[0] = currentWaypointPosition[0] - asInt
        case "L":
            switch asInt {
            case 90:
                offsetEastWest := currentWaypointPosition[0] - eastWest
                offsetNorthSouth := currentWaypointPosition[1] - northSouth

                currentWaypointPosition[0] = eastWest - offsetNorthSouth
                currentWaypointPosition[1] = northSouth + offsetEastWest
            case 180:
                offsetEastWest := currentWaypointPosition[0] - eastWest
                offsetNorthSouth := currentWaypointPosition[1] - northSouth

                currentWaypointPosition[0] = eastWest - offsetEastWest
                currentWaypointPosition[1] = northSouth - offsetNorthSouth
            case 270:
                offsetEastWest := currentWaypointPosition[0] - eastWest
                offsetNorthSouth := currentWaypointPosition[1] - northSouth

                currentWaypointPosition[0] = eastWest + offsetNorthSouth
                currentWaypointPosition[1] = northSouth - offsetEastWest
            default:
                fmt.Println("shrug1.")
            }
        case "R":
            switch asInt {
            case 90:
                offsetEastWest := currentWaypointPosition[0] - eastWest
                offsetNorthSouth := currentWaypointPosition[1] - northSouth

                currentWaypointPosition[0] = eastWest + offsetNorthSouth
                currentWaypointPosition[1] = northSouth - offsetEastWest
            case 180:
                offsetEastWest := currentWaypointPosition[0] - eastWest
                offsetNorthSouth := currentWaypointPosition[1] - northSouth

                currentWaypointPosition[0] = eastWest - offsetEastWest
                currentWaypointPosition[1] = northSouth - offsetNorthSouth
            case 270:
                offsetEastWest := currentWaypointPosition[0] - eastWest
                offsetNorthSouth := currentWaypointPosition[1] - northSouth

                currentWaypointPosition[0] = eastWest - offsetNorthSouth
                currentWaypointPosition[1] = northSouth + offsetEastWest
            default:
                fmt.Println("shrug2.")
            }
        case "F":
            offsetEastWest := currentWaypointPosition[0] - eastWest
            offsetNorthSouth := currentWaypointPosition[1] - northSouth

            eastWest = eastWest + ((currentWaypointPosition[0] - eastWest) * asInt)
            northSouth = northSouth + ((currentWaypointPosition[1] - northSouth) * asInt)

            currentWaypointPosition[0] = eastWest + offsetEastWest
            currentWaypointPosition[1] = northSouth + offsetNorthSouth
        default:
            fmt.Println("shrug4.")
        }
    }

    return eastWest, northSouth
}

func travel(directions [][]string) (int, int) {
    eastWest := 0
    northSouth := 0
    compass := []string{
        "N",
        "E",
        "S",
        "W",
    }

    currentDirection := directions[0][0]

    for dir := range directions {
        asInt, _ := strconv.Atoi(directions[dir][1])
        switch directions[dir][0] {
        case "N":
            northSouth = northSouth + asInt
        case "S":
            northSouth = northSouth - asInt
        case "E":
            eastWest = eastWest + asInt
        case "W":
            eastWest = eastWest - asInt
        case "L":
            switch asInt {
            case 90:
                // find current in compass and move down 1
                for way := range compass {
                    if compass[way] == currentDirection {
                        if way-1 < 0 {
                            tmp := len(compass) - absOfInt(way-1)
                            currentDirection = compass[tmp]
                            break
                        } else {
                            currentDirection = compass[way-1]
                            break
                        }
                    }
                }
            case 180:
                // find current in compass and move down 2
                for way := range compass {
                    if compass[way] == currentDirection {
                        if way-2 < 0 {
                            tmp := len(compass) - absOfInt(way-2)
                            currentDirection = compass[tmp]
                            break
                        } else {
                            currentDirection = compass[way-2]
                            break
                        }
                    }
                }
            case 270:
                // find current in compass and move down 3
                for way := range compass {
                    if compass[way] == currentDirection {
                        if way-3 < 0 {
                            tmp := len(compass) - absOfInt(way-3)
                            currentDirection = compass[tmp]
                            break
                        } else {
                            currentDirection = compass[way-3]
                            break
                        }
                    }
                }
            default:
                fmt.Println("shrug1.")
            }
        case "R":
            switch asInt {
            case 90:
                // find current in compass and move down 1
                for way := range compass {
                    if compass[way] == currentDirection {
                        if way+1 >= len(compass) {
                            tmp := way + 1 - len(compass)
                            currentDirection = compass[tmp]
                            break
                        } else {
                            currentDirection = compass[way+1]
                            break
                        }
                    }
                }
            case 180:
                // find current in compass and move down 2
                for way := range compass {
                    if compass[way] == currentDirection {
                        if way+2 >= len(compass) {
                            tmp := way + 2 - len(compass)
                            currentDirection = compass[tmp]
                            break
                        } else {
                            currentDirection = compass[way+2]
                            break
                        }
                    }
                }
            case 270:
                // find current in compass and move down 3
                for way := range compass {
                    if compass[way] == currentDirection {
                        if way+3 >= len(compass) {
                            tmp := way + 3 - len(compass)
                            currentDirection = compass[tmp]
                            break
                        } else {
                            currentDirection = compass[way+3]
                            break
                        }
                    }
                }
            default:
                fmt.Println("shrug2.")
            }
        case "F":
            switch currentDirection {
            case "N":
                northSouth = northSouth + asInt
            case "S":
                northSouth = northSouth - asInt
            case "E":
                eastWest = eastWest + asInt
            case "W":
                eastWest = eastWest - asInt
            default:
                fmt.Println("shrug3.")
            }
        default:
            fmt.Println("shrug4.")
        }
    }

    return eastWest, northSouth
}

func absOfInt(val int) int {
    if val < 0 {
        val = -val
    }

    return val
}

Link to Github source file

DAY 11 - Advent of Code 2020 w/ GoLang

Edvin — Sat, 12 Dec 2020 03:43:22 +0000

This took me longer than I'd care to admit. I feel like I've built this kind of neighbor-visiting matrix traverser many times back in college. The only advice I can really give is to dust off some of those college CS notes, haha.

My code for this is kind of messy, and I thought about cleaning it up and reducing some of the duplication... but I really didn't want to after solving it. But if you have questions, I'm happy to answer!

package days

import (
    "fmt"
    "reflect"

    inputs "../inputs"
)

// https://adventofcode.com/2020/day/11
// Eleven : advent of code, day eleven part1 and 2.
func Eleven() {
    seatGridAsSlices := inputs.Day11

    seatGrid := [][]rune{}
    for seatRow := range seatGridAsSlices {
        asRunes := []rune(seatGridAsSlices[seatRow])
        seatGrid = append(seatGrid, asRunes)
    }

    snapshot := deepCopy2dSlice(seatGrid)
    scannedGrid := seatWalker(seatGrid)
    for !reflect.DeepEqual(snapshot, scannedGrid) {
        snapshot = deepCopy2dSlice(scannedGrid)
        tmp := deepCopy2dSlice(scannedGrid)
        scannedGrid = seatWalker(tmp)
    }

    fmt.Print("(Part1) - Final seat grid with ")
    fmt.Print(walkOccupied(scannedGrid))
    fmt.Println(" occupied.")

    snapshot2 := deepCopy2dSlice(seatGrid)
    scannedGrid2 := seatWalker2(seatGrid)
    for !reflect.DeepEqual(snapshot2, scannedGrid2) {
        snapshot2 = deepCopy2dSlice(scannedGrid2)
        tmp := deepCopy2dSlice(scannedGrid2)
        scannedGrid2 = seatWalker2(tmp)
    }

    fmt.Print("(Part2) - Final seat grid with ")
    fmt.Print(walkOccupied(scannedGrid2))
    fmt.Println(" occupied.")
}

func seatWalker(grid [][]rune) [][]rune {
    newGrid := deepCopy2dSlice(grid)

    for row, cols := range grid {
        for seat := range cols {
            if cols[seat] == 'L' && checkOccupied(row, seat, grid) == 0 {
                newGrid[row][seat] = '#'
            }

            if cols[seat] == '#' && checkOccupied(row, seat, grid) >= 4 {
                newGrid[row][seat] = 'L'
            }
        }
    }

    return newGrid
}

func seatWalker2(grid [][]rune) [][]rune {
    newGrid := deepCopy2dSlice(grid)

    for row, cols := range grid {
        for seat := range cols {
            if cols[seat] == 'L' && checkOccupied2(row, seat, grid) == 0 {
                newGrid[row][seat] = '#'
            }

            if cols[seat] == '#' && checkOccupied2(row, seat, grid) >= 5 {
                newGrid[row][seat] = 'L'
            }
        }
    }

    return newGrid
}

func walkOccupied(grid [][]rune) int {
    occupied := 0

    for _, cols := range grid {
        for seat := range cols {
            if cols[seat] == '#' {
                occupied++
            }
        }
    }

    return occupied
}

func checkOccupied(row int, seat int, grid [][]rune) int {
    occupied := 0
    /*
        col-1,row-1     col,row-1       col+1, row-1
        col-1,row           X           col+1, row
        col-1,row+1     col,row+1       col+1,row+1
    */

    for x := Max(0, row-1); x <= Min(row+1, len(grid)-1); x++ {
        for y := Max(0, seat-1); y <= Min(seat+1, len(grid[0])-1); y++ {
            if !(x == row && y == seat) {
                if grid[x][y] == '#' {
                    occupied++
                }
            }
        }
    }
    return occupied
}

func checkOccupied2(row int, seat int, grid [][]rune) int {
    occupied := 0
    /*
        col-1,row-1     col,row-1       col+1, row-1
        col-1,row           X           col+1, row
        col-1,row+1     col,row+1       col+1,row+1
    */

    for x := Max(0, row-1); x <= Min(row+1, len(grid)-1); x++ {
        for y := Max(0, seat-1); y <= Min(seat+1, len(grid[0])-1); y++ {
            if !(x == row && y == seat) {
                if grid[x][y] == '#' {
                    occupied++
                } else if grid[x][y] == '.' {
                    occupied = occupied + checkNextNeighbor(grid, x, y, getDir(row, seat, x, y))
                }
            }
        }
    }

    return occupied
}

func getDir(row int, seat int, x int, y int) string {

    if row == x && seat > y {
        return "left"
    }

    if row == x && seat < y {
        return "right"
    }

    if row > x && seat == y {
        return "up"
    }

    if row < x && seat == y {
        return "down"
    }

    if row > x && seat > y {
        return "diagUpLeft"
    }

    if row < x && seat > y {
        return "diagDownLeft"
    }

    if row > x && seat < y {
        return "diagUpRight"
    }

    if row < x && seat < y {
        return "diagDownRight"
    }

    return ""
}

func checkNextNeighbor(grid [][]rune, x int, y int, dir string) int {
    switch dir {
    case "left":
        if y-1 >= 0 {
            if grid[x][y-1] == '.' {
                return checkNextNeighbor(grid, x, y-1, "left")
            } else if grid[x][y-1] == '#' {
                return 1
            }
        }
    case "right":
        if y+1 < len(grid[x]) {
            if grid[x][y+1] == '.' {
                return checkNextNeighbor(grid, x, y+1, "right")
            } else if grid[x][y+1] == '#' {
                return 1
            }
        }
    case "up":
        if x-1 >= 0 {
            if grid[x-1][y] == '.' {
                return checkNextNeighbor(grid, x-1, y, "up")
            } else if grid[x-1][y] == '#' {
                return 1
            }
        }
    case "down":
        if x+1 < len(grid) {
            if grid[x+1][y] == '.' {
                return checkNextNeighbor(grid, x+1, y, "down")
            } else if grid[x+1][y] == '#' {
                return 1
            }
        }
    case "diagUpLeft":
        if x-1 >= 0 && y-1 >= 0 {
            if grid[x-1][y-1] == '.' {
                return checkNextNeighbor(grid, x-1, y-1, "diagUpLeft")
            } else if grid[x-1][y-1] == '#' {
                return 1
            }
        }
    case "diagDownLeft":
        if x+1 < len(grid) && y-1 >= 0 {
            if grid[x+1][y-1] == '.' {
                return checkNextNeighbor(grid, x+1, y-1, "diagDownLeft")
            } else if grid[x+1][y-1] == '#' {
                return 1
            }
        }
    case "diagUpRight":
        if x-1 >= 0 && y+1 < len(grid[x]) {
            if grid[x-1][y+1] == '.' {
                return checkNextNeighbor(grid, x-1, y+1, "diagUpRight")
            } else if grid[x-1][y+1] == '#' {
                return 1
            }
        }
    case "diagDownRight":
        if x+1 < len(grid) && y+1 < len(grid[x]) {
            if grid[x+1][y+1] == '.' {
                return checkNextNeighbor(grid, x+1, y+1, "diagDownRight")
            } else if grid[x+1][y+1] == '#' {
                return 1
            }
        }
    default:
        return 0
    }

    return 0
}

// Max returns the larger of x or y.
func Max(x, y int) int {
    if x < y {
        return y
    }
    return x
}

// Min returns the smaller of x or y.
func Min(x, y int) int {
    if x > y {
        return y
    }
    return x
}

func prettyGrid(seatGrid [][]rune) {
    for runes := range seatGrid {
        for rune := range seatGrid[runes] {
            fmt.Print(string(seatGrid[runes][rune]))
        }
        fmt.Println()
    }
}

func deepCopy2dSlice(twoDimensionalSlice [][]rune) [][]rune {
    copySlice := make([][]rune, len(twoDimensionalSlice))
    for i := range twoDimensionalSlice {
        copySlice[i] = make([]rune, len(twoDimensionalSlice[i]))
        copy(copySlice[i], twoDimensionalSlice[i])
    }

    return copySlice
}

Link to Github source file

DAY 10 - Advent of Code 2020 w/ GoLang

Edvin — Fri, 11 Dec 2020 02:57:50 +0000

DAY10:
Woof. Be warned, part one is DECIEVINGLY simple. Part two had me thinking about implementing a binary tree, which in Go gets terribly verbose. Half-ish way through that approach, I dumped it and started over. Then attempted to recurse while removing indexes after they'd been evaluated. That eventually evolved into implementing a sliding window recursion approach. I slid and evaluated on if the index landed within the acceptable joltage range. ALSO, don't forget the built-ins.

package days

import (
    "fmt"
    "sort"

    inputs "../inputs"
)

// https://adventofcode.com/2020/day/10
// Ten : advent of code, day ten part1 and 2
func Ten() {
    inputSlice := inputs.Day10

    // Adding in built-ins and sorting
    inputSlice = append(inputSlice, 0)
    sort.Ints(inputSlice)
    inputSlice = append(inputSlice, inputSlice[len(inputSlice)-1]+3)

    fmt.Print("(Part1) - result from multipling the 1 and 3 jolt jumps in the total adapter path: ")
    fmt.Println(numberOfOneAndThreeJoltJumpsInAdapterPath(inputSlice))

    fmt.Print("(Part2) - Number of adapter paths that result in the max joltage of is : ")
    fmt.Println(evaluateAdapterPath(inputSlice, 0))
}

func numberOfOneAndThreeJoltJumpsInAdapterPath(adapterSlice []int) int {
    ones := 0
    threes := 0

    for joltage := 0; joltage < len(adapterSlice)-1; joltage++ {
        if adapterSlice[joltage+1]-adapterSlice[joltage] == 1 {
            ones++
        } else if adapterSlice[joltage+1]-adapterSlice[joltage] == 3 {
            threes++
        }
    }
    return ones * threes
}

var adapterPathsTried = make(map[int]int)

func evaluateAdapterPath(adaptersTocheck []int, startAdapter int) int {
    workingAdapterPaths := 0
    nextAdapter := startAdapter + 1
    furthestPossibleAdapter := startAdapter + 3

    if furthestPossibleAdapter >= len(adaptersTocheck) {
        return 1
    } else if _, ok := adapterPathsTried[adaptersTocheck[startAdapter]]; ok {
        return adapterPathsTried[adaptersTocheck[startAdapter]]
    }

    for i := nextAdapter; i <= furthestPossibleAdapter; i++ {
        lower := adaptersTocheck[startAdapter]
        upper := adaptersTocheck[i]

        if (upper-lower) >= 1 && (upper-lower) <= 3 {
            workingAdapterPaths += evaluateAdapterPath(adaptersTocheck, i)
        }
    }

    adapterPathsTried[adaptersTocheck[startAdapter]] = workingAdapterPaths
    return workingAdapterPaths
}

Link to Github source file

DAY 9 - Advent of Code 2020 w/ GoLang

Edvin — Wed, 09 Dec 2020 16:42:27 +0000

DAY9:

This one felt good, for me. There are many loops, as you'll see. That is mainly because I had to write some utility functions for typical slice evaluation that Go doesn't have by default like other languages (not complaining, just pointing out.).

I do advise you split out the logic into helper functions. It could've gotten really messy if I did all of the work in the main function.

package days

import (
    "fmt"

    inputs "../inputs"
)

// https://adventofcode.com/2020/day/9
// Nine : advent of code, day nine part1 and 2
func Nine() {
    inputSlice := inputs.Day9

    part1 := getRuleBreaker(inputSlice, 25)
    fmt.Print("(Part 1) - Value that doesn't follow preamble rule: ")
    fmt.Println(part1)

    part2 := contiguousCheckSum(inputSlice, part1)
    fmt.Print("(Part 2) - Contiguous series sum (series max+min): ")
    fmt.Println(part2)
}

func getRuleBreaker(inputSlice []int, preambleSize int) int {
    for i := preambleSize; i < len(inputSlice); i++ {
        preamble := inputSlice[i-preambleSize : i]
        if !preambleEquator(preamble, inputSlice[i]) {
            return inputSlice[i]
        }
    }

    return 0
}

func contiguousCheckSum(inputSlice []int, toSum int) int {
    maxMinSum := 0

    for i := 0; i < len(inputSlice); i++ {
        for j := i + 1; j < len(inputSlice); j++ {
            if toSum != inputSlice[i] && toSum != inputSlice[j] {
                contiguousSeries := inputSlice[i:j]

                contSum := 0
                for c := 0; c < len(contiguousSeries); c++ {
                    contSum = contSum + contiguousSeries[c]
                }

                if contSum == toSum {
                    maxMinSum = maxMinSumation(contiguousSeries)
                }
            }
        }
    }

    return maxMinSum
}

func maxMinSumation(contiguousSeries []int) int {
    min := contiguousSeries[0]
    for v := 0; v < len(contiguousSeries); v++ {
        if contiguousSeries[v] < min {
            min = contiguousSeries[v]
        }
    }

    max := contiguousSeries[0]
    for v := 0; v < len(contiguousSeries); v++ {
        if contiguousSeries[v] > max {
            max = contiguousSeries[v]
        }
    }

    return min + max
}

func preambleEquator(preamble []int, current int) bool {
    worked := false
    for j := 0; j < len(preamble); j++ {
        for x := j + 1; x < len(preamble); x++ {
            if preamble[j]+preamble[x] == current {
                worked = true
                break
            }
        }
    }
    return worked
}

Link to Github source file

DAY 8 - Advent of Code 2020 w/ GoLang

Edvin — Tue, 08 Dec 2020 16:45:09 +0000

Part 1:
I checked which operation needed to happen and enacted it. I kept a running check to see if an index was revisited. If it was, I broke out of the loop and returned the accumulation.

Part 2:

I looked for the next jmp operation
I changed it to a nop
I reused the code from part1 to return the accumulation, BUT ALSO to return the index at which it terminated
If it terminated before the end of the program, I REVERTED the last changed nop back to jmp and started again on the next jmp NOTE: I followed the running changed index with a global slice to start from in the next recursion.
That recursion continued until I had changed only a single jmp and we reached the end of the program.

package days

import (
    "fmt"
    "strconv"
    "strings"

    inputs "../inputs"
)

// https://adventofcode.com/2020/day/8
// Eight : advent of code, day eight part1 and 2
func Eight() {
    inputSlice := inputs.Day8

    part1(inputSlice)
    part2(inputSlice)
}

func part1(inputSlice []string) {
    acc, _ := oppEvaluator(inputSlice)
    fmt.Print("(Part1) - Accumulator prior to infinite loop restarting: ")
    fmt.Println(acc)
}

var whichOpChanged = []int{0, 0}

func part2(inputSlice []string) {
    innerSlice := inputSlice

    for operation := whichOpChanged[0]; operation < len(innerSlice); operation++ {
        temp := strings.Split(innerSlice[operation], " ")

        typeOfOp := temp[0]
        signedNumber, _ := strconv.Atoi(temp[1])

        if typeOfOp == "nop" && whichOpChanged[0] == operation && whichOpChanged[1] == signedNumber {
            innerSlice[whichOpChanged[0]] = "jmp " + strconv.Itoa(whichOpChanged[1])
        }

        if typeOfOp == "jmp" {
            innerSlice[operation] = "nop " + strconv.Itoa(signedNumber)
            whichOpChanged = []int{operation, signedNumber}
            break
        }
    }

    acc, in := oppEvaluator(innerSlice)
    if in < len(inputSlice) {
        part2(innerSlice)
    } else {
        fmt.Print("(Part2) - Accumulator after termination: ")
        fmt.Println(acc)
    }

}

func oppEvaluator(inputSlice []string) (int, int) {
    accumulator := 0
    operationIndex := 0
    indexVisited := []int{0}

    for {
        temp := strings.Split(inputSlice[operationIndex], " ")

        typeOfOp := temp[0]
        signedNumber, _ := strconv.Atoi(temp[1])

        switch typeOfOp {
        case "acc":
            accumulator = accumulator + signedNumber
            operationIndex++
        case "jmp":
            operationIndex = operationIndex + signedNumber
        case "nop":
            operationIndex++
        default:
            fmt.Println("not an opp")
        }

        if intSliceContains(indexVisited, operationIndex) {
            break
        } else {
            indexVisited = append(indexVisited, operationIndex)
        }

        if operationIndex > len(inputSlice)-1 || operationIndex < 0 {
            break
        }
    }

    return accumulator, operationIndex
}

func intSliceContains(s []int, i int) bool {
    for _, a := range s {
        if a == i {
            return true
        }
    }
    return false
}

Link to Github source file

DAY 7 - Advent of Code 2020 w/ GoLang

Edvin — Mon, 07 Dec 2020 23:25:26 +0000

DAY7:
HAH. This one was not as fun for me. Both parts had dumb little bugs that took me waaaay longer to find than to actually fix.

Listen. The code is a little messy. I was stubborn and didn't want to build any trees. Just. Build. The. Tree.

All of the important functionality here is in the main method and the three following functions. The others are utility functions.

package days

import (
    "fmt"
    "strconv"
    "strings"

    inputs "../inputs"
)

var bagMap = make(map[string][]string)
var numberOfColorsThatHoldGold = []string{}

// Seven : advent of code, day seven part1 and 2
func Seven() {
    input := inputs.Day7

    inputCleanUp :=
        strings.Replace(
            strings.Replace(
                strings.Replace(
                    strings.Replace(input, "bags", "", -1), "bag", "", -1), ".", "", -1), " ", "", -1)

    bagLines := strings.Split(inputCleanUp, "\n")

    for line := range bagLines {
        temp := strings.Split(bagLines[line], "contain")
        bagMap[temp[0]] = strings.Split(temp[1], ",")
    }

    colorChecker([]string{"shinygold"})

    fmt.Print("(Part 1) - Total number of colors that can hold a shiny gold bag: ")
    numberOfColorsThatHoldGold = removeDuplicateValues(numberOfColorsThatHoldGold)
    fmt.Println(len(numberOfColorsThatHoldGold))

    fmt.Print("(Part 2) - Total number of bags in a shiny gold one: ")
    fmt.Println(bagInBagCalculator("shinygold"))
}

func colorChecker(colorsToCheck []string) {
    colorsToCheckAgain := []string{}

    for color := range colorsToCheck {
        for k := range bagMap {
            if doesContain(bagMap[k], colorsToCheck[color]) {
                numberOfColorsThatHoldGold = append(numberOfColorsThatHoldGold, k)
                colorsToCheckAgain = append(colorsToCheckAgain, k)
            }
        }
    }

    colorsToCheckAgain = removeDuplicateValues(colorsToCheckAgain)

    if len(colorsToCheckAgain) > 0 {
        colorChecker(colorsToCheckAgain)
    } else {
        return
    }
}

var totalBagsInBags = make(map[string][]int)

func bagInBagCalculator(colorToStart string) int {
    inThatBag := bagMap[colorToStart]

    for within := range inThatBag {
        splitNum, color := splitNumAndColor(inThatBag[within])
        totalBagsInBags[color] = []int{splitNum + splitNum*bagsInThisOne(color)}
    }

    total := 0
    for col := range totalBagsInBags {
        total = total + totalBagsInBags[col][0]
    }
    return total
}

func bagsInThisOne(color string) int {
    totes := 0
    inThatBag := bagMap[color]

    for within := range inThatBag {
        splitNum, nextColor := splitNumAndColor(inThatBag[within])
        totes = totes + splitNum + splitNum*bagsInThisOne(nextColor)
    }

    return totes
}

func splitNumAndColor(color string) (int, string) {
    toRune := []rune(color)
    splitNum, _ := strconv.Atoi(string(toRune[0]))
    nextColor := strings.Replace(color, string(toRune[0]), "", -1)

    return splitNum, nextColor
}

func doesContain(sliceToCheckFrom []string, stringToCheck string) bool {
    for toCheck := range sliceToCheckFrom {
        if strings.Contains(sliceToCheckFrom[toCheck], stringToCheck) {
            return true
        }
    }
    return false
}

func removeDuplicateValues(stringSlice []string) []string {
    keys := make(map[string]bool)
    list := []string{}

    for _, entry := range stringSlice {
        if _, value := keys[entry]; !value {
            keys[entry] = true
            list = append(list, entry)
        }
    }
    return list
}

}

Link to Github source file

DAY 6 - Advent of Code 2020 w/ GoLang

Edvin — Sun, 06 Dec 2020 17:19:56 +0000

DAY6:
Ooooohh the loops. So, I'm not sure if there are built-in functions or packages in Go that would've been helpful with some of this set-evaluation. If there is, let me know! But, I don't believe there is since I also had to write my own slice.contains() method since that doesn't seem to be a built-in.

I found it helpful to make a rune:int map per group in part 2 for tracking the answers.

package days

import (
    "fmt"
    "strings"

    inputs "../inputs"
)

// Six : advent of code, day six part1 and 2
func Six() {
    input := inputs.Day6

    groups := strings.Split(input, "\n\n")

    totalUniqueYesP1 := 0
    totalUniqueYesP2 := 0

    for group := range groups {
        people := strings.Split(groups[group], "\n")

        uniqueYesInGroup := []rune{}

        groupAlphaMap := map[rune]int{
            'a': 0,
            'b': 0,
            'c': 0,
            'd': 0,
            'e': 0,
            'f': 0,
            'g': 0,
            'h': 0,
            'i': 0,
            'j': 0,
            'k': 0,
            'l': 0,
            'm': 0,
            'n': 0,
            'o': 0,
            'p': 0,
            'q': 0,
            'r': 0,
            's': 0,
            't': 0,
            'u': 0,
            'v': 0,
            'w': 0,
            'x': 0,
            'y': 0,
            'z': 0,
        }

        for person := range people {
            personToRune := []rune(people[person])

            for answer := range personToRune {
                groupAlphaMap[personToRune[answer]]++

                if !runeSliceContains(uniqueYesInGroup, personToRune[answer]) {
                    uniqueYesInGroup = append(uniqueYesInGroup, personToRune[answer])
                }
            }
        }

        allSaidYes := 0

        for k := range groupAlphaMap {
            if groupAlphaMap[k] == len(people) {
                allSaidYes++
            }
        }

        totalUniqueYesP1 = totalUniqueYesP1 + len(uniqueYesInGroup)
        totalUniqueYesP2 = totalUniqueYesP2 + allSaidYes
    }

    fmt.Println("(Part1) Sum of unique answers from each group: ")
    fmt.Println(totalUniqueYesP1)
    fmt.Println("")
    fmt.Println("(Part2) Sum of unique answers each person in group answered YES: ")
    fmt.Println(totalUniqueYesP2)
}

func runeSliceContains(s []rune, r rune) bool {
    for _, a := range s {
        if a == r {
            return true
        }
    }
    return false
}

Link to Github source file

DAY 5 - Advent of Code 2020 w/ GoLang

Edvin — Sun, 06 Dec 2020 14:10:14 +0000

DAY5:
Didn't feel great about this code, but being able to use two iterators on a for loop really helped me out here. 🤷🏼‍♂️

I think the not feeling great was more because I spent waaaay long on a bug I couldn't find than actually making it work 🤦🏼‍♂️

package days

import (
    "fmt"
    "sort"

    inputs "../inputs"
)

// Five : advent of code, day five part1 and 2
func Five() {
    inputSlice := inputs.Day5

    seatIds := partOne(inputSlice)
    fmt.Println("")
    fmt.Println("Your seat ID is: ")
    fmt.Println(partTwo(seatIds))
}

func partOne(inputSlice []string) []int {
    seatIds := []int{}

    for dir := range inputSlice {
        toRune := []rune(inputSlice[dir])
        rowRange := []int{0, 128}
        colRange := []int{0, 8}
        finalRow := 0
        finalColumn := 0
        for i := 0; i < 7; i++ {
            if toRune[i] == 'F' {
                rowRange[1] = rowRange[1] - ((rowRange[1] - rowRange[0]) / 2)
            } else if toRune[i] == 'B' {
                rowRange[0] = rowRange[0] + ((rowRange[1] - rowRange[0]) / 2)
            }

            if i == 6 {
                finalRow = rowRange[0]
            }
        }

        for i := 0; i < 3; i++ {
            if toRune[i+7] == 'L' {
                colRange[1] = colRange[1] - ((colRange[1] - colRange[0]) / 2)
            } else if toRune[i+7] == 'R' {
                colRange[0] = colRange[0] + ((colRange[1] - colRange[0]) / 2)
            }

            if i == 2 {
                finalColumn = colRange[0]
            }
        }

        seatIds = append(seatIds, ((finalRow * 8) + finalColumn))
    }

    highest := 0
    for i := range seatIds {
        if seatIds[i] > highest {
            highest = seatIds[i]
        }
    }

    fmt.Print("Highest Seat ID: ")
    fmt.Println(highest)
    return seatIds
}

func partTwo(seatIds []int) int {
    sort.Ints(seatIds)
    seatsLeft := []int{}

    for i, seat := 0, seatIds[0]; seat < seatIds[len(seatIds)-1]; i, seat = i+1, seat+1 {
        if seat != seatIds[i] {
            seatsLeft = append(seatsLeft, seat)
            seat = seatIds[i]
        }
    }

    return seatsLeft[0]
}

Link to Github source file