advent_of_code/2023/05/main.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()
}