From a0d4b47e16042fb2d3dce0bd86aa404578cd1a89 Mon Sep 17 00:00:00 2001
From: Andrew Ekstedt <andrew.ekstedt@gmail.com>
Date: Thu, 7 Dec 2023 07:01:53 +0000
Subject: [PATCH] day 7 part 2

---
 day06/sol.py  |  1 -
 day07/sol.tcl | 82 ++++++++++++++++++++++++++++++++++++++-------------
 2 files changed, 61 insertions(+), 22 deletions(-)

diff --git a/day06/sol.py b/day06/sol.py
index fd5d776..355c955 100644
--- a/day06/sol.py
+++ b/day06/sol.py
@@ -71,5 +71,4 @@ def part2(data):
 print(solve(part2(sample)))
 print(fancy_solve(part2(sample)))
 print(fancy_solve(part2(input)))
-                
 
diff --git a/day07/sol.tcl b/day07/sol.tcl
index 1aa1c23..284d306 100644
--- a/day07/sol.tcl
+++ b/day07/sol.tcl
@@ -1,5 +1,6 @@
 #!/usr/bin/env tclsh
 #source ../prelude.tcl
+proc {#} args {}
 
 proc parse input {
     return [join [split [read $input] "\n"]]
@@ -7,21 +8,26 @@ proc parse input {
 
 proc solve hands {
     foreach {hand bid} $hands {
-        puts $hand\ [type $hand]
+        puts "$hand: [type $hand] [typeJ $hand]"
     }
-    set sorted [lsort -index 0 -stride 2 -decreasing -command beats $hands]
-    #puts $sorted
-    set i 0
-    set t 0
-    foreach {hand bid} $sorted {
-        incr i
-        incr t [expr {$i*$bid}]
+    set result {}
+    foreach cmp {beats beatsJ} {
+        set sorted [lsort -index 0 -stride 2 -decreasing -command $cmp $hands]
+        #puts $sorted
+        set i 0
+        set t 0
+        foreach {hand bid} $sorted {
+            incr i
+            incr t [expr {$i*$bid}]
+        }
+        #puts [lmap {a b} $sorted {list $b}]
+        lappend result $t
     }
-    #puts [lmap {a b} $sorted {list $b}]
-    return $t
+    return $result
 }
 
 proc index {c} { return [lsearch {A K Q J T 9 8 7 6 5 4 3 2} $c] }
+proc indexJ {c} { return [lsearch {A K Q T 9 8 7 6 5 4 3 2 J} $c] }
 
 
 proc type hand {
@@ -32,12 +38,43 @@ proc type hand {
     set groups [lsort -decreasing -stride 2 -index 1 -integer [array get n]]
     #puts $groups
     return [switch -glob $groups {
-        {? 5} {list 1}
-        {? 4 *} {list 2}
-        {? 3 ? 2} {list 3}
-        {? 3 *} {list 4}
-        {? 2 ? 2 *} {list 5}
-        {? 2 *} {list 6}
+        {? 5}       {{#} Five of a kind;  list 1}
+        {? 4 *}     {{#} Four of a kind;  list 2}
+        {? 3 ? 2}   {{#} Full house;      list 3}
+        {? 3 *}     {{#} Three of a kind; list 4}
+        {? 2 ? 2 *} {{#} Two pair;        list 5}
+        {? 2 *}     {{#} One pair;        list 6}
+        default {list 7}
+    }]
+}
+
+proc typeJ hand {
+    # type of hand, but with jokers replaced by the best card
+    if {$hand eq "JJJJJ"} {
+        # all jokers!
+        return 1
+    }
+    array set n {}
+    set j 0
+    foreach c [split $hand ""] {
+        if {$c ne "J"} {
+            incr n($c)
+        } else {
+            incr j
+        }
+    }
+    set groups [lsort -decreasing -stride 2 -index 1 -integer [array get n]]
+    # more of the same card is always better,
+    # so add the jokers to the most frequent card
+    lset groups 1 [expr {$j + [lindex $groups 1]}]
+    #puts $groups
+    return [switch -glob $groups {
+        {? 5}       {{#} Five of a kind;  list 1}
+        {? 4 *}     {{#} Four of a kind;  list 2}
+        {? 3 ? 2}   {{#} Full house;      list 3}
+        {? 3 *}     {{#} Three of a kind; list 4}
+        {? 2 ? 2 *} {{#} Two pair;        list 5}
+        {? 2 *}     {{#} One pair;        list 6}
         default {list 7}
     }]
 }
@@ -52,10 +89,13 @@ proc xbeats {hand1 hand2} {
     return $x
 }
 
-proc beats {hand1 hand2} {
+proc beats {hand1 hand2} { return [generic_beats type index $hand1 $hand2]}
+proc beatsJ {hand1 hand2} { return [generic_beats typeJ indexJ $hand1 $hand2]}
+
+proc generic_beats {typef indexf hand1 hand2} {
     #puts "cmp $hand1 $hand2"
-    set r1 [type $hand1]
-    set r2 [type $hand2]
+    set r1 [$typef $hand1]
+    set r2 [$typef $hand2]
     if {$r1 != $r2} {
         return [cmp $r1 $r2]
     }
@@ -63,8 +103,8 @@ proc beats {hand1 hand2} {
     foreach c1 [split $hand1 ""] c2 [split $hand2 ""] {
         #puts "c=$c1 $c2"
         if {$c1 ne $c2} {
-            set i1 [index $c1]
-            set i2 [index $c2]
+            set i1 [$indexf $c1]
+            set i2 [$indexf $c2]
             #puts "i=$i1 $i2"
             return [cmp $i1 $i2]
         }