219 lines
6.3 KiB
Go
219 lines
6.3 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"os"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"github.com/fatih/color"
|
|
)
|
|
|
|
func readFileLines(filename string) ([]string, error) {
|
|
var lines []string
|
|
|
|
file, err := os.Open(filename)
|
|
if err != nil {
|
|
return lines, err
|
|
}
|
|
fileScanner := bufio.NewScanner(file)
|
|
fileScanner.Split(bufio.ScanLines)
|
|
|
|
for fileScanner.Scan() {
|
|
lines = append(lines, fileScanner.Text())
|
|
}
|
|
|
|
return lines, nil
|
|
}
|
|
|
|
func parseInput(lines []string) (Input, []uint64, error) {
|
|
var input Input
|
|
var seeds []uint64
|
|
var seedMap, soilMap, fertilizerMap, waterMap, lightMap, temperatureMap, humidityMap bool
|
|
seedMap = false
|
|
soilMap = false
|
|
fertilizerMap = false
|
|
waterMap = false
|
|
lightMap = false
|
|
temperatureMap = false
|
|
humidityMap = false
|
|
for idx, line := range lines {
|
|
if idx == 0 {
|
|
numbers := strings.Split(strings.TrimSpace(strings.Split(line, ":")[1]), " ")
|
|
for _, num := range numbers {
|
|
seed, err := strconv.ParseUint(num, 10, 64)
|
|
if err != nil {
|
|
return input, seeds, err
|
|
}
|
|
seeds = append(seeds, seed)
|
|
}
|
|
} else {
|
|
if len(line) == 0 {
|
|
seedMap = false
|
|
soilMap = false
|
|
fertilizerMap = false
|
|
waterMap = false
|
|
lightMap = false
|
|
temperatureMap = false
|
|
humidityMap = false
|
|
} else if unicode.IsDigit(rune(line[0])) {
|
|
numbers := strings.Split(line, " ")
|
|
var mapper Mapper
|
|
source, err := strconv.ParseUint(numbers[1], 10, 64)
|
|
if err != nil {
|
|
return input, seeds, err
|
|
}
|
|
target, err := strconv.ParseUint(numbers[0], 10, 64)
|
|
if err != nil {
|
|
return input, seeds, err
|
|
}
|
|
count, err := strconv.ParseUint(numbers[2], 10, 64)
|
|
if err != nil {
|
|
return input, seeds, err
|
|
}
|
|
mapper.source = source
|
|
mapper.target = target
|
|
mapper.count = count
|
|
if seedMap {
|
|
input.seedToSoil = append(input.seedToSoil, mapper)
|
|
} else if soilMap {
|
|
input.soilToFertilizer = append(input.soilToFertilizer, mapper)
|
|
} else if fertilizerMap {
|
|
input.fertilizerToWater = append(input.fertilizerToWater, mapper)
|
|
} else if waterMap {
|
|
input.waterToLight = append(input.waterToLight, mapper)
|
|
} else if lightMap {
|
|
input.lightToTemperature = append(input.lightToTemperature, mapper)
|
|
} else if temperatureMap {
|
|
input.temperatureToHumidity = append(input.temperatureToHumidity, mapper)
|
|
} else if humidityMap {
|
|
input.humidityToLocation = append(input.humidityToLocation, mapper)
|
|
}
|
|
} else {
|
|
if line[:4] == "seed" {
|
|
seedMap = true
|
|
} else if line[:4] == "soil" {
|
|
soilMap = true
|
|
} else if line[:4] == "fert" {
|
|
fertilizerMap = true
|
|
} else if line[:4] == "wate" {
|
|
waterMap = true
|
|
} else if line[:4] == "ligh" {
|
|
lightMap = true
|
|
} else if line[:4] == "temp" {
|
|
temperatureMap = true
|
|
} else if line[:4] == "humi" {
|
|
humidityMap = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
sort.Sort(MapperSort(input.seedToSoil))
|
|
sort.Sort(MapperSort(input.soilToFertilizer))
|
|
sort.Sort(MapperSort(input.fertilizerToWater))
|
|
sort.Sort(MapperSort(input.waterToLight))
|
|
sort.Sort(MapperSort(input.lightToTemperature))
|
|
sort.Sort(MapperSort(input.temperatureToHumidity))
|
|
sort.Sort(MapperSort(input.humidityToLocation))
|
|
return input, seeds, nil
|
|
}
|
|
|
|
func calculateIntervals(intervals [][2]uint64, mapper []Mapper) [][2]uint64 {
|
|
var newIntervals [][2]uint64
|
|
for _, interval := range intervals {
|
|
finishedInterval := false
|
|
for _, mapper := range mapper {
|
|
if finishedInterval {
|
|
break
|
|
}
|
|
if interval[0] >= mapper.source && interval[0] < mapper.source+mapper.count {
|
|
parseInterval := interval
|
|
if interval[1] >= mapper.source+mapper.count {
|
|
parseInterval[1] = mapper.source + mapper.count - 1
|
|
interval[0] = mapper.source + mapper.count
|
|
} else {
|
|
finishedInterval = true
|
|
}
|
|
newIntervals = append(newIntervals, [2]uint64{parseInterval[0] - mapper.source + mapper.target, parseInterval[1] - mapper.source + mapper.target})
|
|
} else if interval[0] < mapper.source {
|
|
if interval[1] >= mapper.source {
|
|
newIntervals = append(newIntervals, [2]uint64{interval[0], mapper.source - 1})
|
|
interval = [2]uint64{mapper.source, interval[1]}
|
|
} else {
|
|
newIntervals = append(newIntervals, interval)
|
|
finishedInterval = true
|
|
}
|
|
}
|
|
}
|
|
if !finishedInterval {
|
|
newIntervals = append(newIntervals, interval)
|
|
}
|
|
}
|
|
sort.Sort(IntervalSort(newIntervals))
|
|
var returnIntervals [][2]uint64
|
|
for _, interval := range newIntervals {
|
|
if len(returnIntervals) == 0 {
|
|
returnIntervals = append(returnIntervals, interval)
|
|
}
|
|
if returnIntervals[len(returnIntervals)-1][1] == interval[0] {
|
|
returnIntervals[len(returnIntervals)-1][1] = interval[1]
|
|
} else {
|
|
returnIntervals = append(returnIntervals, interval)
|
|
}
|
|
}
|
|
return returnIntervals
|
|
}
|
|
|
|
func parseAlmanacTest(input Input) [][2]uint64 {
|
|
intervals := input.seedIntervals
|
|
intervals = calculateIntervals(intervals, input.seedToSoil)
|
|
intervals = calculateIntervals(intervals, input.soilToFertilizer)
|
|
intervals = calculateIntervals(intervals, input.fertilizerToWater)
|
|
intervals = calculateIntervals(intervals, input.waterToLight)
|
|
intervals = calculateIntervals(intervals, input.lightToTemperature)
|
|
intervals = calculateIntervals(intervals, input.temperatureToHumidity)
|
|
intervals = calculateIntervals(intervals, input.humidityToLocation)
|
|
return intervals
|
|
}
|
|
|
|
func main() {
|
|
redPrint := color.New(color.FgRed)
|
|
yellowPrint := color.New(color.FgYellow)
|
|
if len(os.Args) < 2 {
|
|
redPrint.Fprintln(os.Stderr, "You must provide the input file")
|
|
os.Exit(1)
|
|
}
|
|
lines, err := readFileLines(os.Args[1])
|
|
if err != nil {
|
|
redPrint.Fprintln(os.Stderr, "Could not read input file")
|
|
os.Exit(1)
|
|
}
|
|
|
|
input, seeds, err := parseInput(lines)
|
|
if err != nil {
|
|
redPrint.Fprintln(os.Stderr, err)
|
|
}
|
|
|
|
for _, seed := range seeds {
|
|
input.seedIntervals = append(input.seedIntervals, [2]uint64{seed, seed})
|
|
}
|
|
sort.Sort(IntervalSort(input.seedIntervals))
|
|
locationsNew := parseAlmanacTest(input)
|
|
fmt.Print("Part 1: ")
|
|
yellowPrint.Print(locationsNew[0][0])
|
|
fmt.Println()
|
|
|
|
input.seedIntervals = [][2]uint64{}
|
|
for i := 0; i < len(seeds); i += 2 {
|
|
input.seedIntervals = append(input.seedIntervals, [2]uint64{seeds[i], seeds[i] + seeds[i+1] - 1})
|
|
}
|
|
sort.Sort(IntervalSort(input.seedIntervals))
|
|
locationsNew2 := parseAlmanacTest(input)
|
|
fmt.Print("Part 2: ")
|
|
yellowPrint.Print(locationsNew2[0][0])
|
|
fmt.Println()
|
|
}
|