chore: organization day19

day19/main.go

@@ -32,8 +32,34 @@ func run(scan *bufio.Scanner) (*result, error) {
 		}
 
 		// Is Part
-		if text[0] == '{' {
+		if p, ok := scanPart(text); ok {
+			parts = append(parts, p)
+			continue
+		}
+
+		if name, r, ok := scanRule(text); ok {
+			workflows[name] = r
+		}
+	}
+
+	var result result
+	result.valuePT1 = solveWorkflow(parts, workflows)
+
+	return &result, nil
+}
+
+type part struct {
+	x, m, a, s int
+}
+
+func (p part) String() string {
+	return fmt.Sprintf("{x:%v m:%v a:%v s:%v}", p.x, p.m, p.a, p.s)
+}
+func scanPart(text string) (part, bool) {
 	var p part
+
+	// Is Part
+	if text[0] == '{' {
 		for _, s := range strings.Split(text[1:], ",") {
 			a, b, _ := strings.Cut(s, "=")
 			i := aoc.Atoi(b)
@@ -48,10 +74,19 @@ func run(scan *bufio.Scanner) (*result, error) {
 				p.s = i
 			}
 		}
-			parts = append(parts, p)
+		return p, true
-			continue
+	}
+	return p, false
 }
 
+type rule struct {
+	match string
+	op    string
+	value int
+	queue string
+}
+
+func scanRule(text string) (string, []rule, bool) {
 	name, text, _ := strings.Cut(text, "{")
 	var r []rule
 	for _, s := range strings.Split(text, ",") {
@@ -81,9 +116,33 @@ func run(scan *bufio.Scanner) (*result, error) {
 		r = append(r, rule{queue: s})
 		break
 	}
-		workflows[name] = r
+	return name, r, len(r) > 0
+}
+func (r rule) Match(p part) bool {
+	var value int
+
+	switch r.match {
+	case "x":
+		value = p.x
+	case "m":
+		value = p.m
+	case "a":
+		value = p.a
+	case "s":
+		value = p.s
+	default:
+		return true // default to new queue
 	}
 
+	if r.op == ">" && value > r.value {
+		return true
+	} else if r.op == "<" && value < r.value {
+		return true
+	}
+	return false // no match
+}
+
+func solveWorkflow(parts []part, workflows map[string][]rule) int {
 	var rejected []part
 	var accepted []part
 
@@ -111,67 +170,86 @@ nextStep:
 
 				continue nextStep
 			}
-
 		}
 	}
 
 	fmt.Println("accepted", accepted)
 	fmt.Println("rejected", rejected)
 
-	var result result
+	sum := 0
-
 	for _, p := range accepted {
-		result.valuePT1 += p.x
+		sum += p.x
-		result.valuePT1 += p.m
+		sum += p.m
-		result.valuePT1 += p.a
+		sum += p.a
-		result.valuePT1 += p.s
+		sum += p.s
+	}
+	return sum
 }
 
-	return &result, nil
+/*
-}
+in{s<1351:px, s>=1351:qqz}
 
-type part struct {
+--> px{a<2006&&(x<1416||x>2662):A, a<2006&&x>=1416&&x<=2662:R, m>2090:A, a>=2006&&m<=2090&&s<537:R||x>2440:R, a>=2006&&m<=2090&&s<537&x<=2440:A}
-	x, m, a, s int
-}
-func (p part) String() string {
-	return fmt.Sprintf("{x:%v m:%v a:%v s:%v}", p.x,p.m,p.a,p.s)
-}
-type rule struct {
-	match string
-	op    string
-	value int
-	queue string
-}
-func (r rule) Match(p part) bool {
-	var value int
 
-	switch r.match {
+--> qqz{s>2770:A, m<1801&&m>838:A, m<1801&&a>1716:R, m<1801&&a<=1716:A, s<=2770&&m>=1801:R}
-	case "x":
-		value = p.x
-	case "m":
-		value = p.m
-	case "a":
-		value = p.a
-	case "s":
-		value = p.s
-	default:
-		return true // default to new queue
-	}
-
-	if r.op == ">" && value > r.value {
-		return true
-	} else if r.op == "<" && value < r.value {
-		return  true		
-	} 
-	return  false // no match
-}
 
 
-func in(n string, haystack ...string) bool {
+
-	for _, h := range haystack {
+
-		if n == h {
+
-			return true
+
-		}
+
-	}
+in [/]
-	return false
+--
-}
+s<1351 -> px
+s>=1351 -> qqz
+
+px [/]
+--
+s<1351 -> px
+
+a< 2006  -> qkq
+m> 2090  -> A
+a>=2006 -> ...
+m<=2090 -> rfg
+
+qqz [ ]
+--
+s>=1351 -> qqz
+
+s> 2770 -> qs
+m< 1801 -> hdj
+ -> R
+
+qkq [ ]
+--
+s< 1351 ->
+a< 2006 ->
+
+x< 1416 -> A
+x>=1416 -> crn
+
+rfg [ ]
+--
+s< 1351 -> px
+a>=2006 ->...
+m<=2090 -> rfg
+
+s<  537 -> gd
+x> 2440 -> R
+s>= 537 ->...
+x<=2440 -> A
+
+crn [ ]
+--
+s< 1351 -> px
+a< 2006 -> qkq
+x>=1416 -> crn
+
+x> 2662 -> A
+x<=2662 -> R
+
+A
+--
+
+*/

set.go

@@ -57,3 +57,12 @@ func (m *defaultMap[K, V]) Items() []pair[K, V] {
 	}
 	return items
 }
+
+func In[C comparable](n C, haystack ...C) bool {
+	for _, h := range haystack {
+		if n == h {
+			return true
+		}
+	}
+	return false
+}