167 lines
2.8 KiB
Go
167 lines
2.8 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
const FILE_PATH = "./input.txt"
|
|
|
|
//const FILE_PATH = "./sample.txt"
|
|
|
|
func LoadInput(filename string) ([]string, error) {
|
|
file, err := os.Open(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer file.Close()
|
|
|
|
var lines []string
|
|
scanner := bufio.NewScanner(file)
|
|
for scanner.Scan() {
|
|
lines = append(lines, scanner.Text())
|
|
}
|
|
|
|
if err := scanner.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return lines, nil
|
|
}
|
|
|
|
type Rule struct {
|
|
definition int
|
|
limiter int
|
|
}
|
|
|
|
type structuredInput struct {
|
|
rules []Rule
|
|
updates [][]int
|
|
}
|
|
|
|
func TransformInput(lines []string) structuredInput {
|
|
var nums []string
|
|
var num1 int
|
|
var num2 int
|
|
var result structuredInput = structuredInput{}
|
|
var i = 0
|
|
for ; lines[i] != ""; i++ {
|
|
nums = strings.Split(lines[i], "|")
|
|
num1, _ = strconv.Atoi(nums[0])
|
|
num2, _ = strconv.Atoi(nums[1])
|
|
result.rules = append(result.rules, Rule{num1, num2})
|
|
}
|
|
i++
|
|
var c = 0
|
|
for ; i < len(lines); i++ {
|
|
result.updates = append(result.updates, make([]int, 0))
|
|
nums = strings.Split(lines[i], ",")
|
|
for _, num := range nums {
|
|
num1, _ = strconv.Atoi(num)
|
|
result.updates[c] = append(result.updates[c], num1)
|
|
}
|
|
|
|
c++
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func IsCorrect(rules []Rule, update []int) bool {
|
|
|
|
for i, page := range update {
|
|
for _, rule := range rules {
|
|
if rule.definition != page {
|
|
continue
|
|
}
|
|
|
|
for j := 0; j < i; j++ {
|
|
if update[j] == rule.limiter {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func Part1(input structuredInput) int {
|
|
var result = 0
|
|
|
|
for _, update := range input.updates {
|
|
if IsCorrect(input.rules, update) {
|
|
result += update[len(update)/2]
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func CorrectUpdate(rules []Rule, update []int) []int {
|
|
var result []int = make([]int, len(update))
|
|
copy(result, update)
|
|
|
|
var IsCorrect = false
|
|
var temp = 0
|
|
for !IsCorrect {
|
|
IsCorrect = true
|
|
|
|
for i, page := range result {
|
|
for _, rule := range rules {
|
|
if rule.definition != page {
|
|
continue
|
|
}
|
|
|
|
for j := 0; j < i; j++ {
|
|
if result[j] == rule.limiter {
|
|
temp = result[j]
|
|
result[j] = result[i]
|
|
result[i] = temp
|
|
IsCorrect = false
|
|
break
|
|
}
|
|
}
|
|
if !IsCorrect {
|
|
break
|
|
}
|
|
}
|
|
if !IsCorrect {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func Part2(input structuredInput) int {
|
|
var result = 0
|
|
|
|
for _, update := range input.updates {
|
|
if IsCorrect(input.rules, update) {
|
|
continue
|
|
}
|
|
|
|
result += CorrectUpdate(input.rules, update)[len(update)/2]
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func main() {
|
|
input, err := LoadInput(FILE_PATH)
|
|
if err != nil {
|
|
fmt.Println("Error loading input:", err)
|
|
return
|
|
}
|
|
|
|
structuredInput := TransformInput(input)
|
|
fmt.Println("Structured Input:", structuredInput)
|
|
|
|
fmt.Println("Solution Part 1: ", Part1(structuredInput))
|
|
fmt.Println("Solution Part 2: ", Part2(structuredInput))
|
|
}
|