refactor(golang/2017): structure days into packages

Author: markkovari

golang/2017/day01/solver.go

@@ -0,0 +1,34 @@
+package day01
+
+import (
+	"fmt"
+	"strings"
+)
+
+type Solver struct{}
+
+func (d Solver) Part1(input string) string {
+	input = strings.TrimSpace(input)
+	sum := 0
+	for i := 0; i < len(input); i++ {
+		next := (i + 1) % len(input)
+		if input[i] == input[next] {
+			sum += int(input[i] - '0')
+		}
+	}
+	return fmt.Sprintf("%d", sum)
+}
+
+func (d Solver) Part2(input string) string {
+	input = strings.TrimSpace(input)
+	sum := 0
+	length := len(input)
+	step := length / 2
+	for i := 0; i < length; i++ {
+		next := (i + step) % length
+		if input[i] == input[next] {
+			sum += int(input[i] - '0')
+		}
+	}
+	return fmt.Sprintf("%d", sum)
+}

golang/2017/day02/solver.go

@@ -0,0 +1,67 @@
+package day02
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type Solver struct{}
+
+func (d Solver) Part1(input string) string {
+	sum := 0
+	for _, line := range strings.Split(input, "\n") {
+		if line == "" {
+			continue
+		}
+		numbers := d.parseRow(line)
+		min, max := d.findSmallestAndBiggest(numbers)
+		sum += max - min
+	}
+	return fmt.Sprintf("%d", sum)
+}
+
+func (d Solver) Part2(input string) string {
+	sum := 0
+	for _, line := range strings.Split(input, "\n") {
+		if line == "" {
+			continue
+		}
+		numbers := d.parseRow(line)
+		sum += d.getDivisible(numbers)
+	}
+	return fmt.Sprintf("%d", sum)
+}
+
+func (d Solver) parseRow(line string) []int {
+	var row []int
+	for _, part := range strings.Fields(line) {
+		val, _ := strconv.Atoi(part)
+		row = append(row, val)
+	}
+	return row
+}
+
+func (d Solver) findSmallestAndBiggest(numbers []int) (int, int) {
+	smallest, biggest := numbers[0], numbers[0]
+	for _, num := range numbers {
+		if num < smallest {
+			smallest = num
+		}
+		if num > biggest {
+			biggest = num
+		}
+	}
+	return smallest, biggest
+}
+
+func (d Solver) getDivisible(numbers []int) int {
+	for i, num := range numbers {
+		for j, num2 := range numbers {
+			if i != j && num%num2 == 0 {
+				return num / num2
+			}
+		}
+	}
+	return 0
+}

golang/2017/day03/solver.go

@@ -0,0 +1,76 @@
+package day03
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+)
+
+type Solver struct{}
+
+func (d Solver) Part1(input string) string {
+	num, _ := strconv.Atoi(strings.TrimSpace(input))
+	return fmt.Sprintf("%d", d.calculateDistance(num))
+}
+
+func (d Solver) Part2(input string) string {
+	num, _ := strconv.Atoi(strings.TrimSpace(input))
+	return fmt.Sprintf("%d", d.calculateStressedDistance(num))
+}
+
+func (d Solver) abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+func (d Solver) calculateDistance(n int) int {
+	if n == 1 {
+		return 0
+	}
+	ring := int(math.Ceil((math.Sqrt(float64(n)) - 1) / 2))
+	side := 2*ring + 1
+	maxNum := side * side
+	sideLen := side - 1
+	midPoints := make([]int, 4)
+	for i := 0; i < 4; i++ {
+		midPoints[i] = maxNum - sideLen/2 - i*sideLen
+	}
+	minDist := d.abs(n - midPoints[0])
+	for _, midPoint := range midPoints {
+		dist := d.abs(n - midPoint)
+		if dist < minDist {
+			minDist = dist
+		}
+	}
+	return ring + minDist
+}
+
+func (d Solver) calculateStressedDistance(inputNum int) int {
+	directions := [][2]int{{0, 1}, {-1, 0}, {0, -1}, {1, 0}}
+	allNeighborDiffs := [][2]int{{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}}
+	coordsToNeighborSum := map[[2]int]int{{0, 0}: 1, {0, 1}: 1}
+	directionIndex := 0
+	row, col := 0, 1
+	for {
+		leftDiff := directions[(directionIndex+1)%4]
+		leftCoord := [2]int{row + leftDiff[0], col + leftDiff[1]}
+		if _, ok := coordsToNeighborSum[leftCoord]; !ok {
+			directionIndex = (directionIndex + 1) % 4
+		}
+		diff := directions[directionIndex]
+		row += diff[0]
+		col += diff[1]
+		next := [2]int{row, col}
+		var sum int
+		for _, d := range allNeighborDiffs {
+			sum += coordsToNeighborSum[[2]int{row + d[0], col + d[1]}]
+		}
+		if sum > inputNum {
+			return sum
+		}
+		coordsToNeighborSum[next] = sum
+	}
+}

golang/2017/day04/solver.go

@@ -0,0 +1,63 @@
+package day04
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+type Solver struct{}
+
+func (d Solver) Part1(input string) string {
+	countValid := 0
+	for _, line := range strings.Split(input, "\n") {
+		if line == "" {
+			continue
+		}
+		words := strings.Fields(line)
+		frequency := make(map[string]int)
+		valid := true
+		for _, word := range words {
+			frequency[word]++
+			if frequency[word] > 1 {
+				valid = false
+				break
+			}
+		}
+		if valid {
+			countValid++
+		}
+	}
+	return fmt.Sprintf("%d", countValid)
+}
+
+func (d Solver) Part2(input string) string {
+	countValid := 0
+	for _, line := range strings.Split(input, "\n") {
+		if line == "" {
+			continue
+		}
+		words := strings.Fields(line)
+		if !d.hasAnagram(words) {
+			countValid++
+		}
+	}
+	return fmt.Sprintf("%d", countValid)
+}
+
+func (d Solver) hasAnagram(words []string) bool {
+	sortedWords := make([]string, len(words))
+	for i, word := range words {
+		chars := strings.Split(word, "")
+		sort.Strings(chars)
+		sortedWords[i] = strings.Join(chars, "")
+	}
+	for i := 0; i < len(sortedWords); i++ {
+		for j := i + 1; j < len(sortedWords); j++ {
+			if sortedWords[i] == sortedWords[j] {
+				return true
+			}
+		}
+	}
+	return false
+}

golang/2017/day05/solver.go

@@ -0,0 +1,49 @@
+package day05
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type Solver struct{}
+
+func (d Solver) Part1(input string) string {
+	jumps := d.parse(input)
+	current, steps := 0, 0
+	for current >= 0 && current < len(jumps) {
+		jump := jumps[current]
+		jumps[current]++
+		current += jump
+		steps++
+	}
+	return fmt.Sprintf("%d", steps)
+}
+
+func (d Solver) Part2(input string) string {
+	jumps := d.parse(input)
+	current, steps := 0, 0
+	for current >= 0 && current < len(jumps) {
+		jump := jumps[current]
+		if jump >= 3 {
+			jumps[current]--
+		} else {
+			jumps[current]++
+		}
+		current += jump
+		steps++
+	}
+	return fmt.Sprintf("%d", steps)
+}
+
+func (d Solver) parse(input string) []int {
+	var nums []int
+	for _, line := range strings.Split(input, "\n") {
+		if line == "" {
+			continue
+		}
+		val, _ := strconv.Atoi(line)
+		nums = append(nums, val)
+	}
+	return nums
+}

golang/2017/day06/solver.go

@@ -0,0 +1,66 @@
+package day06
+
+import (
+	"fmt"
+	"strings"
+)
+
+type Solver struct{}
+
+func (d Solver) Part1(input string) string {
+	banks := d.parse(input)
+	seen := make(map[[16]int]int)
+	cycles := 0
+	for {
+		if _, ok := seen[banks]; ok {
+			return fmt.Sprintf("%d", cycles)
+		}
+		seen[banks] = cycles
+
+		maxIdx, maxVal := 0, banks[0]
+		for i, val := range banks {
+			if val > maxVal {
+				maxIdx, maxVal = i, val
+			}
+		}
+
+		banks[maxIdx] = 0
+		for i := 1; i <= maxVal; i++ {
+			banks[(maxIdx+i)%16]++
+		}
+		cycles++
+	}
+}
+
+func (d Solver) Part2(input string) string {
+	banks := d.parse(input)
+	seen := make(map[[16]int]int)
+	cycles := 0
+	for {
+		if firstSeen, ok := seen[banks]; ok {
+			return fmt.Sprintf("%d", cycles-firstSeen)
+		}
+		seen[banks] = cycles
+
+		maxIdx, maxVal := 0, banks[0]
+		for i, val := range banks {
+			if val > maxVal {
+				maxIdx, maxVal = i, val
+			}
+		}
+
+		banks[maxIdx] = 0
+		for i := 1; i <= maxVal; i++ {
+			banks[(maxIdx+i)%16]++
+		}
+		cycles++
+	}
+}
+
+func (d Solver) parse(input string) [16]int {
+	var banks [16]int
+	for i, s := range strings.Fields(input) {
+		fmt.Sscanf(s, "%d", &banks[i])
+	}
+	return banks
+}