Handle pairs and two pairs

README.md

@@ -27,9 +27,9 @@ The following categories exists:
 
 - [x] Ones, Twos, Threes, Fours, Fives, Sixes: The player scores the sum of the dice that reads one, two, three, four,
   five or six, respectively. For example, 1, 1, 2, 4, 4 placed on “fours” gives 8 points.
-- [ ] Pair: The player scores the sum of the two highest matching dice. For example, 3, 3, 3, 4, 4 placed on “pair”
+- [x] Pair: The player scores the sum of the two highest matching dice. For example, 3, 3, 3, 4, 4 placed on “pair”
   gives 8.
-- [ ] Two pairs: If there are two pairs of dice with the same number, the player scores the sum of these dice. If not,
+- [x] Two pairs: If there are two pairs of dice with the same number, the player scores the sum of these dice. If not,
   the player scores 0. For example, 1, 1, 2, 3, 3 placed on “two pairs” gives 8.
 - [x] Three of a kind: If there are three dice with the same number, the player scores the sum of these dice. Otherwise,
   the player scores 0. For example, 3, 3, 3, 4, 5 places on “three of a kind” gives 9.

src/main/java/io/github/vbetsch/yams/CategoryEnum.java

@@ -1,12 +1,17 @@
 package io.github.vbetsch.yams;
 
 public enum CategoryEnum {
+    // --- TOP PART ---
     ACES,
     TWOS,
     THREES,
     FOURS,
     FIVES,
     SIXES,
+    // --- BONUS PART (kata) ---
+    PAIR,
+    TWO_PAIRS,
+    // --- BOTTOM PART ---
     THREE_OF_A_KIND,
     FOUR_OF_A_KIND,
 //    FULL_HOUSE,

src/main/java/io/github/vbetsch/yams/Yams.java

@@ -1,18 +1,48 @@
 package io.github.vbetsch.yams;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.IntStream;
+import java.util.stream.Stream;
 
 public class Yams {
     static final int DICES_COUNT = 5;
 
+    // Utils
+    private Map<Integer, Integer> getOccurrencesByValue(List<Integer> roll) {
+        Map<Integer, Integer> occurrencesByValue = new HashMap<>();
+        for (int index = 0; index < roll.size(); index++) {
+            int diceValue = roll.get(index);
+            occurrencesByValue.merge(diceValue, 1, Integer::sum);
+        }
+        IO.println(occurrencesByValue);
+        return occurrencesByValue;
+    }
+
+    private boolean containsAtLeastXDuplicatesOnAtLeastYDifferentDices(Map<Integer, Integer> occurrencesByValue, int duplicatesNumber, int differentDices) {
+        Stream<Map.Entry<Integer, Integer>> matchingOccurrences = occurrencesByValue
+                .entrySet()
+                .stream()
+                .filter(occurrenceByValue -> occurrenceByValue.getValue() >= duplicatesNumber);
+        return matchingOccurrences.count() >= differentDices;
+    }
+
     private int calculateSumOfDices(List<Integer> roll) {
         return roll
                 .stream()
                 .mapToInt(Integer::intValue)
                 .sum();
     }
 
+    private Stream<Map.Entry<Integer, Integer>> getAllPairsOccurrences(Map<Integer, Integer> occurrencesByValue) {
+        return occurrencesByValue
+                .entrySet()
+                .stream()
+                .filter(occurrenceByValue -> occurrenceByValue.getValue() >= 2);
+    }
+
+    // Handlers
     private int handleChanceScore(List<Integer> roll) {
         return this.calculateSumOfDices(roll);
     }
@@ -38,30 +68,47 @@ private int handleTopPartScores(List<Integer> roll, int target) {
                 .sum();
     }
 
-    private boolean containsDuplicatesNth(List<Integer> roll, int duplicatesNumber) {
-        IntStream reducedRoll = roll
-                .stream()
+    private int handlePairScore(List<Integer> roll) throws IllegalArgumentException {
+        Map<Integer, Integer> occurrencesByValue = this.getOccurrencesByValue(roll);
+        if (!this.containsAtLeastXDuplicatesOnAtLeastYDifferentDices(occurrencesByValue, 2, 1)) {
+            return 0;
+        }
+        return this.getAllPairsOccurrences(occurrencesByValue)
+                .map(Map.Entry::getKey)
+                .max(Integer::compare)
+                .orElse(0) * 2;
+    }
+
+    private int handleTwoPairsScore(List<Integer> roll) throws IllegalArgumentException {
+        Map<Integer, Integer> occurrencesByValue = this.getOccurrencesByValue(roll);
+        if (!this.containsAtLeastXDuplicatesOnAtLeastYDifferentDices(occurrencesByValue, 2, 2)) {
+            return 0;
+        }
+        return this.getAllPairsOccurrences(occurrencesByValue)
+                .map(occurrenceByValue -> occurrenceByValue.getKey() * 2)
                 .mapToInt(Integer::intValue)
-                .distinct();
-        return reducedRoll.count() == (Yams.DICES_COUNT - duplicatesNumber + 1);
+                .sum();
     }
 
     private int handleThreeOfAKindScore(List<Integer> roll) throws IllegalArgumentException {
-        if (!this.containsDuplicatesNth(roll, 3)) {
-            throw new CategoryNotAuthorizedForThisRollError(CategoryEnum.THREE_OF_A_KIND);
+        Map<Integer, Integer> occurrencesByValue = this.getOccurrencesByValue(roll);
+        if (!this.containsAtLeastXDuplicatesOnAtLeastYDifferentDices(occurrencesByValue, 3, 1)) {
+            return 0;
         }
         return this.calculateSumOfDices(roll);
     }
 
     private int handleFourOfAKindScore(List<Integer> roll) throws IllegalArgumentException {
-        if (!this.containsDuplicatesNth(roll, 4)) {
-            throw new CategoryNotAuthorizedForThisRollError(CategoryEnum.FOUR_OF_A_KIND);
+        Map<Integer, Integer> occurrencesByValue = this.getOccurrencesByValue(roll);
+        if (!this.containsAtLeastXDuplicatesOnAtLeastYDifferentDices(occurrencesByValue, 4, 1)) {
+            return 0;
         }
         return this.calculateSumOfDices(roll);
     }
 
+    // Public method
     public int computeScore(List<Integer> roll, CategoryEnum category) throws InvalidRollSizeError {
-        if(roll.size() != Yams.DICES_COUNT) {
+        if (roll.size() != Yams.DICES_COUNT) {
             throw new InvalidRollSizeError(roll.size());
         }
         return switch (category) {
@@ -73,6 +120,8 @@ public int computeScore(List<Integer> roll, CategoryEnum category) throws Invali
             case CategoryEnum.FOURS -> this.handleTopPartScores(roll, 4);
             case CategoryEnum.FIVES -> this.handleTopPartScores(roll, 5);
             case CategoryEnum.SIXES -> this.handleTopPartScores(roll, 6);
+            case CategoryEnum.PAIR -> this.handlePairScore(roll);
+            case CategoryEnum.TWO_PAIRS -> this.handleTwoPairsScore(roll);
             case CategoryEnum.THREE_OF_A_KIND -> this.handleThreeOfAKindScore(roll);
             case CategoryEnum.FOUR_OF_A_KIND -> this.handleFourOfAKindScore(roll);
             default -> 1000;