2023 day07 optimised

Author: liamgallear

2023/day07/.bench

@@ -1 +1 @@
-{"Lines":[{"Name":"Part 1","N":87,"NsPerOp":12566992,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0},{"Name":"Part 2","N":78,"NsPerOp":15769298,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0}],"Measured":1}
+{"Lines":[{"Name":"Part 1","N":708,"NsPerOp":1608818,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0},{"Name":"Part 2","N":655,"NsPerOp":1835345,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0}],"Measured":1}

2023/day07/main.go

@@ -2,8 +2,8 @@ package main
 
 import (
 	_ "embed"
-	"fmt"
 	"os"
+	"slices"
 	"strings"
 )
 
@@ -13,56 +13,121 @@ var input string
 //go:embed input_test.txt
 var inputTest string
 
+type Hand struct {
+	cards [5]int
+	bid   int
+}
+
+var hands []Hand
+
 func main() {
 	// Check argv if we use test input or not
 	if len(os.Args) > 1 && os.Args[1] == "test" {
 		input = inputTest
 	}
 
-	answer := doPartOne(input)
+	parseInput(input)
+
+	answer := doPartOne()
 	println(answer)
 
-	answer = doPartTwo(input)
+	answer = doPartTwo()
 	println(answer)
 }
 
-type Hands []Hand
-type Hand struct {
-	hand []int
-	bid  int
-}
-type Score struct {
-	hand     []int
-	strength int
+func parseInput(input string) {
+	lines := strings.Split(strings.TrimSpace(input), "\n")
+	hands = make([]Hand, len(lines))
+	
+	for i, line := range lines {
+		spaceIdx := strings.Index(line, " ")
+		
+		// Parse hand
+		var h Hand
+		for j := 0; j < 5; j++ {
+			h.cards[j] = cardValue(line[j])
+		}
+		
+		// Parse bid
+		bid := 0
+		for j := spaceIdx + 1; j < len(line); j++ {
+			bid = bid*10 + int(line[j]-'0')
+		}
+		h.bid = bid
+		
+		hands[i] = h
+	}
 }
 
-var (
-	handscores = []Score{
-		{[]int{5}, 10}, {[]int{1, 4}, 9}, {[]int{2, 3}, 8}, {[]int{1, 1, 3}, 7},
-		{[]int{1, 2, 2}, 6}, {[]int{1, 1, 1, 2}, 5}, {[]int{1, 1, 1, 1, 1}, 4},
+func cardValue(c byte) int {
+	switch c {
+	case 'A':
+		return 14
+	case 'K':
+		return 13
+	case 'Q':
+		return 12
+	case 'J':
+		return 11
+	case 'T':
+		return 10
+	default:
+		return int(c - '0')
 	}
+}
 
-	cardscore = map[rune]int{
-		'1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7,
-		'8': 8, '9': 9, 'T': 10, 'J': 11, 'Q': 12, 'K': 13, 'A': 14,
+// Calculate hand strength from card counts
+// Five of a kind: 6, Four of a kind: 5, Full house: 4, Three of a kind: 3, Two pair: 2, One pair: 1, High card: 0
+func handStrength(counts [5]int) int {
+	slices.Sort(counts[:])
+	// counts is now sorted, highest count at the end
+	switch counts[4] {
+	case 5:
+		return 6 // Five of a kind
+	case 4:
+		return 5 // Four of a kind
+	case 3:
+		if counts[3] == 2 {
+			return 4 // Full house
+		}
+		return 3 // Three of a kind
+	case 2:
+		if counts[3] == 2 {
+			return 2 // Two pair
+		}
+		return 1 // One pair
+	default:
+		return 0 // High card
 	}
-)
+}
 
-func getHands(input string, p2 bool) Hands {
-	var hands Hands
-	for _, line := range strings.Split(strings.TrimSpace(input), "\n") {
-		var H string
-		var B int
-		fmt.Sscanf(line, "%s %d", &H, &B)
-		hand := []int{}
-		for _, c := range H {
-			n := cardscore[c]
-			if c == 'J' && p2 {
-				n = 1
-			}
-			hand = append(hand, n)
-		}
-		hands = append(hands, Hand{hand, B})
+func getHandStrength(h Hand, jokerRule bool) int {
+	counts := [5]int{}
+	cardCounts := make(map[int]int)
+	
+	for _, card := range h.cards {
+		cardCounts[card]++
+	}
+	
+	// Handle jokers (value 11 in part 1, converted to 1 in part 2)
+	jokers := 0
+	if jokerRule {
+		jokers = cardCounts[1]
+		delete(cardCounts, 1)
+	}
+	
+	// Fill counts array
+	i := 0
+	for _, count := range cardCounts {
+		counts[i] = count
+		i++
+	}
+	
+	// Add jokers to the highest count
+	if jokers > 0 {
+		slices.Sort(counts[:])
+		counts[4] += jokers
 	}
-	return hands
+	
+	return handStrength(counts)
 }

2023/day07/main_test.go

@@ -3,13 +3,19 @@ package main
 import "testing"
 
 func BenchmarkPartOne(b *testing.B) {
+	parseInput(input)
+	b.ResetTimer()
+	
 	for n := 0; n < b.N; n++ {
-		doPartOne(input)
+		doPartOne()
 	}
 }
 
 func BenchmarkPartTwo(b *testing.B) {
+	parseInput(input)
+	b.ResetTimer()
+	
 	for n := 0; n < b.N; n++ {
-		doPartTwo(input)
+		doPartTwo()
 	}
 }

2023/day07/part1.go

@@ -1,52 +1,33 @@
 package main
 
-import (
-	"reflect"
-	"slices"
-)
+import "slices"
 
-func doPartOne(input string) int {
-	hands := getHands(input, false)
-	Counter := func(H Hand) int {
-		C := map[int]int{}
-		for _, c := range H.hand {
-			C[c]++
+func doPartOne() int {
+	// Create a copy for sorting
+	sortedHands := make([]Hand, len(hands))
+	copy(sortedHands, hands)
+	
+	slices.SortFunc(sortedHands, func(a, b Hand) int {
+		// Compare hand strengths
+		sa := getHandStrength(a, false)
+		sb := getHandStrength(b, false)
+		
+		if sa != sb {
+			return sa - sb
 		}
-		res := []int{}
-		for _, v := range C {
-			res = append(res, v)
-		}
-		slices.Sort(res)
-		for _, S := range handscores {
-			if reflect.DeepEqual(res, S.hand) {
-				return S.strength
-			}
-		}
-		return 0
-	}
-	slices.SortFunc(hands, func(a, b Hand) int {
-		Ca := Counter(a)
-		Cb := Counter(b)
-		if Ca < Cb {
-			return -1
-		}
-		if Ca > Cb {
-			return 1
-		}
-		// If we get here, they have the same score, and so need to iterate through the cards
-		for i := 0; i < len(a.hand); i++ {
-			if a.hand[i] < b.hand[i] {
-				return -1
-			}
-			if a.hand[i] > b.hand[i] {
-				return 1
+		
+		// Same strength, compare cards in order
+		for i := 0; i < 5; i++ {
+			if a.cards[i] != b.cards[i] {
+				return a.cards[i] - b.cards[i]
 			}
 		}
 		return 0
 	})
-	res := 0
-	for i, H := range hands {
-		res += (i + 1) * H.bid
+	
+	result := 0
+	for i, h := range sortedHands {
+		result += (i + 1) * h.bid
 	}
-	return res
+	return result
 }

2023/day07/part2.go

@@ -1,64 +1,45 @@
 package main
 
-import (
-	"reflect"
-	"slices"
-)
+import "slices"
 
-func doPartTwo(input string) int {
-	hands := getHands(input, true)
-	Counter := func(H Hand) int {
-		C := map[int]int{}
-		for _, c := range H.hand {
-			C[c]++
-		}
-		T := reflect.ValueOf(C).MapKeys()[0].Interface()
-		for k := range C {
-			if k != 1 {
-				if C[k] > C[T.(int)] || T == 1 {
-					T = k
-				}
-			}
-		}
-		if _, ok := C[1]; ok && T.(int) != 1 {
-			C[T.(int)] += C[1]
-			delete(C, 1)
-		}
-		res := []int{}
-		for _, v := range C {
-			res = append(res, v)
-		}
-		slices.Sort(res)
-		for _, S := range handscores {
-			if reflect.DeepEqual(res, S.hand) {
-				return S.strength
+func doPartTwo() int {
+	// Create a copy for sorting with joker rules
+	sortedHands := make([]Hand, len(hands))
+	for i, h := range hands {
+		// Convert J (11) to joker (1)
+		var newHand Hand
+		newHand.bid = h.bid
+		for j := 0; j < 5; j++ {
+			if h.cards[j] == 11 {
+				newHand.cards[j] = 1
+			} else {
+				newHand.cards[j] = h.cards[j]
 			}
 		}
-		return 0
+		sortedHands[i] = newHand
 	}
-	slices.SortFunc(hands, func(a, b Hand) int {
-		Ca := Counter(a)
-		Cb := Counter(b)
-		if Ca < Cb {
-			return -1
-		}
-		if Ca > Cb {
-			return 1
-		}
-		// If we get here, they have the same score, and so need to iterate through the cards
-		for i := 0; i < len(a.hand); i++ {
-			if a.hand[i] < b.hand[i] {
-				return -1
-			}
-			if a.hand[i] > b.hand[i] {
-				return 1
+	
+	slices.SortFunc(sortedHands, func(a, b Hand) int {
+		// Compare hand strengths with joker rule
+		sa := getHandStrength(a, true)
+		sb := getHandStrength(b, true)
+		
+		if sa != sb {
+			return sa - sb
+		}
+		
+		// Same strength, compare cards in order
+		for i := 0; i < 5; i++ {
+			if a.cards[i] != b.cards[i] {
+				return a.cards[i] - b.cards[i]
 			}
 		}
 		return 0
 	})
-	res := 0
-	for i, H := range hands {
-		res += (i + 1) * H.bid
+	
+	result := 0
+	for i, h := range sortedHands {
+		result += (i + 1) * h.bid
 	}
-	return res
+	return result
 }