144 lines
2.5 KiB
Go
144 lines
2.5 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type Limitations struct {
|
|
red int
|
|
blue int
|
|
green int
|
|
}
|
|
|
|
type Draw struct {
|
|
red int
|
|
blue int
|
|
green int
|
|
}
|
|
|
|
type Game struct {
|
|
id int
|
|
draws []Draw
|
|
meta Meta
|
|
}
|
|
|
|
type Meta struct {
|
|
possible bool
|
|
red_min int
|
|
green_min int
|
|
blue_min int
|
|
}
|
|
|
|
func readInput() string {
|
|
stdin, err := io.ReadAll(os.Stdin)
|
|
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
str := string(stdin)
|
|
return str
|
|
}
|
|
|
|
func getColors(input string, color string) string {
|
|
rg := regexp.MustCompile(`[0-9]+ ` + regexp.QuoteMeta(color))
|
|
return rg.FindString(input)
|
|
}
|
|
|
|
func parseGameLine(line string, limits Limitations) Game {
|
|
splitted := strings.Split(line, ":")
|
|
draws_splitted := strings.Split(splitted[1], ";")
|
|
game_prefix := splitted[0]
|
|
|
|
id, _ := strconv.Atoi(strings.Split(game_prefix, " ")[1])
|
|
draws := []Draw{}
|
|
meta := Meta{}
|
|
red_min, green_min, blue_min := 0, 0, 0
|
|
meta.possible = true
|
|
for _, v := range draws_splitted {
|
|
red, _ := strconv.Atoi(strings.Split(getColors(v, "red"), " ")[0])
|
|
green, _ := strconv.Atoi(strings.Split(getColors(v, "green"), " ")[0])
|
|
blue, _ := strconv.Atoi(strings.Split(getColors(v, "blue"), " ")[0])
|
|
if (red > limits.red) || (green > limits.green) || (blue > limits.blue) {
|
|
meta.possible = false
|
|
}
|
|
if red_min < red {
|
|
red_min = red
|
|
}
|
|
if green_min < green {
|
|
green_min = green
|
|
}
|
|
if blue_min < blue {
|
|
blue_min = blue
|
|
}
|
|
draw := Draw{
|
|
red: red,
|
|
blue: blue,
|
|
green: green,
|
|
}
|
|
draws = append(draws, draw)
|
|
}
|
|
meta.blue_min = blue_min
|
|
meta.red_min = red_min
|
|
meta.green_min = green_min
|
|
game := Game{
|
|
id: id,
|
|
draws: draws,
|
|
meta: meta,
|
|
}
|
|
|
|
// fmt.Println(game)
|
|
return game
|
|
}
|
|
|
|
func part1(lines []string) {
|
|
limits := Limitations{
|
|
red: 12,
|
|
green: 13,
|
|
blue: 14,
|
|
}
|
|
var games []Game
|
|
sum_ids := 0
|
|
for _, l := range lines {
|
|
if len(l) == 0 {
|
|
continue
|
|
}
|
|
game := parseGameLine(l, limits)
|
|
if game.meta.possible {
|
|
games = append(games, game)
|
|
sum_ids += game.id
|
|
}
|
|
}
|
|
|
|
fmt.Println("Sum ids:", sum_ids)
|
|
}
|
|
|
|
func part2(lines []string) {
|
|
var games []Game
|
|
|
|
for _, l := range lines {
|
|
if len(l) == 0 {
|
|
continue
|
|
}
|
|
game := parseGameLine(l, Limitations{})
|
|
games = append(games, game)
|
|
}
|
|
sum := 0
|
|
for _, g := range games {
|
|
sum += (g.meta.red_min * g.meta.green_min * g.meta.blue_min)
|
|
}
|
|
fmt.Println(sum)
|
|
}
|
|
|
|
func main() {
|
|
input := readInput()
|
|
lines := strings.Split(input, "\n")
|
|
fmt.Println("---PART 1---")
|
|
part1(lines)
|
|
fmt.Println("---PART 2---")
|
|
part2(lines)
|
|
}
|