advent2022

main.go (2492B)

---

 package main
 
 import (
 	"encoding/json"
 	"fmt"
 	"log"
 	"os"
 	"sort"
 	"strings"
 )
 
 type Packets []any
 
 func (p Packets) Len() int { return len(p) }
 func (p Packets) Swap(i, j int) {
 	p[i], p[j] = p[j], p[i]
 }
 func (p Packets) Less(i, j int) bool {
 	cmp, _ := Compare(p[i], p[j])
 	return cmp
 }
 
 func main() {
 	if len(os.Args) > 1 {
 		day13(os.Args[1])
 	} else if len(os.Args) == 1 {
 		fmt.Printf("usage: %s inputfile.txt\n", os.Args[0])
 	} else {
 		fmt.Println("No input data")
 	}
 }
 
 func day13(input_file string) {
 	fmt.Printf("day 13 input filename: %s\n", input_file)
 	input, err := os.ReadFile(input_file)
 	if err != nil {
 		log.Fatal(err)
 	}
 	pairs := strings.Split(string(input), "\n\n")
 	sum := 0
 	var packets Packets
 	for i, p := range pairs {
 		pair := strings.Split(p, "\n")
 		if len(pair) < 2 {
 			log.Fatal("Invalid pair", pair)
 		}
 		var p1, p2 any
 		if err = json.Unmarshal([]byte(pair[0]), &p1); err != nil {
 			log.Fatal(err)
 		}
 		if err = json.Unmarshal([]byte(pair[1]), &p2); err != nil {
 			log.Fatal(err)
 		}
 		res, _ := Compare(p1, p2)
 		if res {
 			sum += i + 1
 		}
 		packets = append(packets, p1, p2)
 	}
 	m1, m2 := "[[2]]", "[[6]]"
 	var marker1, marker2 any
 	json.Unmarshal([]byte(m1), &marker1)
 	json.Unmarshal([]byte(m2), &marker2)
 	packets = append(packets, marker1, marker2)
 
 	sort.Sort(packets)
 
 	v1, v2 := 0, 0
 	for i, p := range packets {
 		j, err := json.Marshal(p)
 		if err != nil {
 			log.Fatal(err)
 		}
 		if string(j) == m1 {
 			v1 = i + 1
 		}
 		if string(j) == m2 {
 			v2 = i + 1
 		}
 	}
 
 	fmt.Println("Part 1:", sum)
 	fmt.Println("Part 2:", v1*v2)
 }
 
 // returns (result, continue)
 func Compare(p1, p2 any) (bool, bool) {
 	p1ar, p2ar := IsArray(p1), IsArray(p2)
 	if !p1ar && !p2ar {
 		p1n, p2n := int(p1.(float64)), int(p2.(float64))
 		return p1n < p2n, p1n == p2n
 	} else if p1ar && p2ar {
 		return CompareArrays(p1.([]any), p2.([]any))
 	} else if p1ar {
 		return CompareArrays(p1.([]any), []any{p2})
 	} else if p2ar {
 		return CompareArrays([]any{p1}, p2.([]any))
 	}
 	log.Fatal("Invalid something")
 	return false, false
 }
 
 func CompareArrays(p1, p2 []any) (bool, bool) {
 	for i := 0; i < len(p1); i++ {
 		if i >= len(p2) {
 			return false, false
 		}
 		res, cont := Compare(p1[i], p2[i])
 		if !cont {
 			return res, false
 		}
 	}
 	return len(p1) < len(p2), len(p1) >= len(p2)
 }
 
 func IsArray(v any) bool {
 	switch v.(type) {
 	case float64:
 		return false
 	case []any:
 		return true
 	default:
 		log.Fatal("unknown value", v)
 		//return true
 	}
 	return false
 }