Merge branch 'Day7'

Author: gvelim

src/bin/day7/README.md

@@ -1,15 +1,14 @@
 # Day 7
 ## Input
-You get a list of hands, and your goal is to order them based on the strength of each hand. A hand consists of five cards labeled one of `A, K, Q, J, T, 9, 8, 7, 6, 5, 4, 3, or 2`.
-
-The relative strength of each card follows this order, where `A` is the highest and `2` is the lowest
+You get a list of hands & bids pairs, and your goal is to order them based on the strength of each hand. 
 ```
 32T3K 765
 T55J5 684
 KK677 28
 KTJJT 220
 QQQJA 483
 ```
+A hand consists of five cards labeled one of `A, K, Q, J, T, 9, 8, 7, 6, 5, 4, 3, or 2`. The relative strength of each card follows this order, where `A` is the highest and `2` is the lowest
 Every hand is exactly one type. From strongest to weakest, they are:
 
 * **Five of a kind**, where all five cards have the same label: `AAAAA`
@@ -24,12 +23,13 @@ If two hands have the same type, a second ordering rule takes effect. Start by c
 ## Part 1: Output
 Find the rank of every hand in your set and calculate the total winnings of this set of hands by adding up the result of multiplying each hand's bid with its rank
 ```
-Rank 0 - ("32T3K", OnePair) => "32T3K"
-Rank 1 - ("JJ958", OnePair) => "JJ958"
+Rank 1 - ("32T3K", OnePair) => "32T3K"
 Rank 2 - ("KTJJT", TwoPair) => "KTJJT"
 Rank 3 - ("KK677", TwoPair) => "KK677"
 Rank 4 - ("T55J5", ThreeOfAKind) => "T55J5"
 Rank 5 - ("QQQJA", ThreeOfAKind) => "QQQJA
+
+765 * 1 + 220 * 2 + 28 * 3 + 684 * 4 + 483 * 5 = 6440
 ```
 ## Part 2: Output
 Now, `J` cards are jokers - wildcards that can act like whatever card would make the hand the strongest type possible.
@@ -38,19 +38,20 @@ To balance this, `J` cards are now the weakest individual cards, weaker even tha
 
 Using the new joker rule, find the rank of every hand in your set. What are the new total winnings?
 ```
-Rank 0 - ("32T3K", OnePair) => "32T3K"
-Rank 1 - ("KK677", TwoPair) => "KK677"
-Rank 2 - ("JJ958", ThreeOfAKind) => "JJ958"
+Rank 1 - ("32T3K", OnePair) => "32T3K"
+Rank 2 - ("KK677", TwoPair) => "KK677"
 Rank 3 - ("T55J5", FourOfAKind) => "T55J5"
 Rank 4 - ("QQQJA", FourOfAKind) => "QQQJA"
 Rank 5 - ("KTJJT", FourOfAKind) => "KTJJT"
+
+765 * 1 + 28 * 2 + 684 * 3 + 483 * 4 + 220 * 5 = 5905
 ```
 ## Approach
-To find the type of hand, use a Hashmap to extract the counts for character in the string, then convert the Hashmap to a Vector and reverse sort it. Now you should have in reverse order all the unique cards and card frequency.
+To find the type of hand, use a `Hashmap` to extract the frequency per character in the hand, then convert the `Hashmap` to a `Vector` and reverse sort it. Now you should have in reverse order all the unique cards and card frequency i.e. `[('A',2),('J',2),('2',1)]`
 
-Hence the types are derived from two values (a) number of unique cards & (b) the highest card freq
+Hence, the types are derived from two values (a) number of unique cards; `array.len()` & (b) the highest card freq; `array[0].freq`
 ```
-match array_length {
+match array.len() {
     1 => HandType::FiveOfAKind,
     2 if array[0].freq ==4 => HandType::FourOfAKind,
     2 => HandType::FullHouse,
@@ -65,5 +66,5 @@ The Joker card affects the two key parameters like this
 2. `new highest card freq` = highest card freq + Joker card frequency
 
 Watch out for unique hand cases like 
-1. `JJ123`', hence if Joker is the most frequency card you have to pick the card with `highest card freq` coming after the joker
-2. '`JJJJ`' ignore the Joker logic 
+1. `JJ123`, hence if the Joker is the most frequent card, you have to pick the next in order card that has the highest card frequency after the joker one.
+2. `JJJJJ` no joker logic applies in this case 

src/bin/day7/hand.rs

@@ -17,28 +17,25 @@ pub(crate) struct Hand {
     pub(crate) layout: String,
     pub(crate) hands_type: HandType,
     pub(crate) ord_layout: String,
-    pub(crate) cards: Vec<(char,u8)>
+    pub(crate) cards: Vec<(char,u8)>,
+    joker_pos: Option<usize>
 }
 impl Hand {
-    pub(crate) fn get_type(&self, joker: Option<char>) -> HandType {
+    pub(crate) fn get_type(&self) -> HandType {
         let mut unique_cards = self.cards.len() as u32;
-        let mut most_freq = self.cards[0].1;
+        let mut freq = self.cards[0].1;
 
-        // watch out for cases like `JJ234` or `JJJJJ`
-        // Joker is the most common card or the only card
-        if joker.is_some() && unique_cards > 1 {
-            let j = joker.unwrap();
-            if let Some(&(_, joker_freq)) = self.cards.iter().find(|(card,_)| card.eq(&j)) {
-                unique_cards -= 1;
-                most_freq += if self.cards[0].0 == j { self.cards[1].1 } else { joker_freq };
-            }
+        // if we have joker position && and is not a 'JJJJJ' case
+        if self.joker_pos.is_some() && unique_cards > 1 {
+            unique_cards -= 1;
+            freq += self.cards[self.joker_pos.unwrap()].1;
         }
 
         match unique_cards {
             1 => HandType::FiveOfAKind,
-            2 if most_freq ==4 => HandType::FourOfAKind,
+            2 if freq == 4 => HandType::FourOfAKind,
             2 => HandType::FullHouse,
-            3 if most_freq ==3 => HandType::ThreeOfAKind,
+            3 if freq == 3 => HandType::ThreeOfAKind,
             3 => HandType::TwoPair,
             4 => HandType::OnePair,
             _ => HandType::HighCard
@@ -51,24 +48,46 @@ impl Hand {
             .map(|(&i,o)| (i,o) )
             .collect::<HashMap<char,char>>();
 
+        let mut joker_pos = None;
         let (cards,ord_layout)= input.chars()
             .fold((HashMap::with_capacity(5),String::with_capacity(5)), |(mut cards, mut ord_layout), card| {
                 *cards.entry(card).or_insert(0) += 1;
                 ord_layout.push( ord_card[&card]);
                 (cards, ord_layout)
             });
 
+        // extract the HashMap onto an array
         let mut cards= cards.into_iter().collect::<Vec<_>>();
-        cards.sort_by_key(|(_,d)| *d);
+        // reverse sort the array by order of card freq
+        // hence the most frequent is 1st, then then 2nd least freq, etc
+        cards.sort_by_key(|(_,freq)| *freq);
         cards.reverse();
 
+        // if we are dealing with a Joker case
+        joker
+            .is_some_and(|joker| {
+                // find Joker's freq order i.e. 1st, 2nd, etc and store it for later
+                // if there is no Joker in the hand, we exit this with None
+                // no position == no Joker
+                joker_pos = cards.iter().position(|(card,_)| joker.eq(card));
+                // if it is 1st and not the only card in the hand; we deal with JJ123 cases
+                cards.len() > 1 && joker_pos.eq(&Some(0))
+            })
+            .then(|| {
+                // move to the last place & update its position
+                cards.rotate_left(1);
+                joker_pos = Some(cards.len()-1);
+                Some(())
+            });
+
         let mut hand = Hand {
             layout: String::from(input),
             ord_layout,
             hands_type: HandType::HighCard,
-            cards
+            cards,
+            joker_pos
         };
-        hand.hands_type = hand.get_type(joker);
+        hand.hands_type = hand.get_type();
         hand
     }
 }
@@ -104,7 +123,7 @@ impl Debug for Hand {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.write_fmt(format_args!("Layout {:?}, ",&self.layout))?;
         f.debug_struct("Hand")
-            .field("type",&self.hands_type)
+            .field("Type",&self.hands_type)
             .finish()?;
         f.write_str(", Cards ")?;
         f.debug_map()

src/bin/day7/main.rs

@@ -1,6 +1,6 @@
 mod hand;
 
-use crate::hand::{Hand,HandType};
+use crate::hand::Hand;
 use std::time::Instant;
 
 static CAMEL_ORDER_PART1: [char; 13] = [ '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A' ];
@@ -38,6 +38,7 @@ fn main() {
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::hand::HandType;
 
     #[test]
     fn test_card_ordering_joker() {
@@ -91,7 +92,7 @@ mod test {
             vec![OnePair, FourOfAKind, TwoPair, FourOfAKind, FourOfAKind, ThreeOfAKind],
             hands.iter()
                 .inspect(|h| print!("{:?} => ",(&h.layout,&h.ord_layout)))
-                .map(|h| h.get_type(Some('J')) )
+                .map(|h| h.get_type() )
                 .inspect(|ht| println!("{:?}",ht))
                 .collect::<Vec<HandType>>()
         )