Use instance functions and improve code readability

config.json~

@@ -1,346 +0,0 @@
-{
-  "slug": "java",
-  "language": "Java",
-  "repository": "https://github.com/exercism/xjava",
-  "active": true,
-  "exercises": [
-    {
-      "slug": "hello-world",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "rna-transcription",
-      "difficulty": 2,
-      "topics": []
-    },
-    {
-      "slug": "pangram",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "hamming",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "gigasecond",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "space-age",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "acronym",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "scrabble-score",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "raindrops",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "difference-of-squares",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "secret-handshake",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "sum-of-multiples",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "luhn",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "matrix",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "triangle",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "largest-series-product",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "sieve",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "twelve-days",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "nth-prime",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "diamond",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "flatten-array",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "pig-latin",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "phone-number",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "accumulate",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "nucleotide-count",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "word-count",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "robot-name",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "prime-factors",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "allergies",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "bob",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "pascals-triangle",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "bracket-push",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "series",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "atbash-cipher",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "strain",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "roman-numerals",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "beer-song",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "queen-attack",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "etl",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "linked-list",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "grade-school",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "robot-simulator",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "binary-search",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "minesweeper",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "wordy",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "all-your-base",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "anagram",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "sublist",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "simple-linked-list",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "binary-search-tree",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "rectangles",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "meetup",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "crypto-square",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "poker",
-      "difficulty": 7,
-      "topics": [
-        "Parsing",
-        "Sorting",
-        "Games"
-      ]
-    },
-    {
-      "slug": "simple-cipher",
-      "difficulty": 8,
-      "topics": []
-    },
-    {
-      "slug": "palindrome-products",
-      "difficulty": 8,
-      "topics": []
-    },
-    {
-      "slug": "pythagorean-triplet",
-      "difficulty": 9,
-      "topics": []
-    },
-    {
-      "slug": "custom-set",
-      "difficulty": 10,
-      "topics": []
-    },
-    {
-      "slug": "clock",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "perfect-numbers",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "change",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "list-ops",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "ocr-numbers",
-      "difficulty": 1,
-      "topics": []
-    }
-  ],
-  "deprecated": [
-    "binary",
-    "hexadecimal",
-    "octal",
-    "trinary"
-  ],
-  "ignored": [
-    "_template",
-    ".gradle",
-    "build",
-    "docs",
-    "gradle",
-    "scripts"
-  ],
-  "foregone": [
-    "leap",
-    "grains",
-    "say"
-  ]
-}

exercises/poker/src/example/java/Card.java

@@ -1,25 +1,25 @@
-public class Card {
-	private int rank;
-	private int suit;
-
-	public Card(String card) {
-		rank = parseRank(card);
-		suit = parseSuit(card);
-	}
-
-	public int getRank() {
-		return rank;
-	}
-
-	public int getSuit() {
-		return suit;
-	}
-
-	private static int parseRank(String card) {
-		return "..23456789TJQKA".indexOf(card.charAt(0));
-	}
-
-	private static int parseSuit(String card) {
-		return ".HSDC".indexOf(card.charAt(1));
-	}
+public class Card {
+	private int rank;
+	private int suit;
+
+	public Card(String card) {
+		rank = parseRank(card);
+		suit = parseSuit(card);
+	}
+
+	public int getRank() {
+		return rank;
+	}
+
+	public int getSuit() {
+		return suit;
+	}
+
+	private int parseRank(String card) {
+		return "..23456789TJQKA".indexOf(card.charAt(0));
+	}
+
+	private int parseSuit(String card) {
+		return ".HSDC".indexOf(card.charAt(1));
+	}
 }

exercises/poker/src/example/java/Hand.java

@@ -1,106 +1,104 @@
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-public class Hand {
-	private String input;
-	private int score;
-
-	public Hand(String hand) {
-		this.input = hand;
-		this.score = scoreHand(parseCards(hand));
-	}
-
-	public int getScore() {
-		return score;
-	}
-
-	public String getInput() {
-		return input;
-	}
-
-	private static List<Card> parseCards(String hand) {
-		ArrayList<Card> parsedCards = new ArrayList<Card>();
-		String[] parseString = hand.split(" ");
-		for (int i = 0; i < parseString.length; i++) {
-			parsedCards.add(new Card(parseString[i]));
-		}
-		return parsedCards;
-	}
-
-	private static Map<Integer, Integer> getFrequencyMap(List<Card> cards) {
-		Map<Integer, Integer> frequencymap = new HashMap<Integer, Integer>() ;
-		for (Card c : cards) {
-			if (frequencymap.containsKey(c.getRank())) {
-				frequencymap.put(c.getRank(), frequencymap.get(c.getRank()) + 1);
-			} else {
-				frequencymap.put(c.getRank(), 1);
-			}
-		}
-		return frequencymap;
-	}
-
-	private static int scoreHand(List<Card> cards) {
-		List<Card> cardsByRank = new ArrayList<Card>();
-
-		cardsByRank = cards.stream().sorted(Comparator.comparing(Card::getRank)).unordered()
-				.collect(Collectors.toList());
-
-		Map<Integer, Integer> frequencymap = getFrequencyMap(cards);
-		List<Integer> ranks = frequencymap.entrySet().stream().map(x -> x.getKey())
-				.sorted(Comparator.reverseOrder()).collect(Collectors.toList());
-
-		frequencymap = frequencymap.entrySet().stream()
-				.sorted(Map.Entry.comparingByValue(Collections.reverseOrder())).collect(Collectors
-						.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
-
-		List<Integer> rankCounts = frequencymap.entrySet().stream().map(x -> x.getValue())
-				.collect(Collectors.toList());
-
-		List<Integer> suits = cards.stream().map(s -> s.getSuit()).collect(Collectors.toList());
-
-		if (ranks.equals(Arrays.asList(14, 5, 4, 3, 2))) {
-			ranks = Arrays.asList(5, 4, 3, 2, 1);
-		}
-
-		boolean flush = suits.stream().distinct().count() == 1;
-		boolean straight = ranks.stream().distinct().count() == 5 && ranks.get(0) - ranks.get(4) == 4;
-		Iterator<Integer> itr = frequencymap.keySet().iterator();
-		int pairA = itr.next();
-
-		if (straight && flush) {
-			return 800 + frequencymap.keySet().iterator().next();
-		}
-		if (rankCounts.equals(Arrays.asList(4, 1))) {
-			return (700 + (cardsByRank.get(0)).getRank());
-		}
-		if (rankCounts.equals(Arrays.asList(3, 2))) {
-			return 600 + cardsByRank.get(0).getRank();
-		}
-		if (flush) {
-			return 500 + frequencymap.keySet().iterator().next();
-		}
-		if (straight) {
-			return 400 + frequencymap.keySet().iterator().next();
-		}
-		if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
-			return 300 + cardsByRank.get(0).getRank();
-		}
-		if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
-			return 200 + Math.max(pairA, itr.next());
-		}
-		if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
-			return 100 + pairA;
-		}
-		Collections.sort(ranks, (a, b) -> b.compareTo(a));
-		Collections.reverse(ranks);
-		return ranks.get(0);
-	}
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class Hand {
+	private String input;
+	private int score;
+
+	public Hand(String hand) {
+		this.input = hand;
+		this.score = scoreHand(parseCards(hand));
+	}
+
+	public int getScore() {
+		return score;
+	}
+
+	public String getInput() {
+		return input;
+	}
+
+	private List<Card> parseCards(String hand) {
+		ArrayList<Card> parsedCards = new ArrayList<Card>();
+		String[] parseString = hand.split(" ");
+		for (int i = 0; i < parseString.length; i++) {
+			parsedCards.add(new Card(parseString[i]));
+		}
+		return parsedCards;
+	}
+
+	private Map<Integer, Integer> getfrequencyMap(List<Card> cards) {
+		Map<Integer, Integer> frequencyMap = new HashMap<Integer, Integer>();
+		for (Card c : cards) {
+			if (frequencyMap.containsKey(c.getRank())) {
+				frequencyMap.put(c.getRank(), frequencyMap.get(c.getRank()) + 1);
+			} else {
+				frequencyMap.put(c.getRank(), 1);
+			}
+		}
+		return frequencyMap;
+	}
+
+	private int scoreHand(List<Card> cards) {
+		List<Card> cardsByRank = cards.stream().sorted(Comparator.comparing(Card::getRank)).unordered()
+				.collect(Collectors.toList());
+
+		Map<Integer, Integer> frequencyMap = getfrequencyMap(cards);
+		List<Integer> ranks = frequencyMap.entrySet().stream().map(x -> x.getKey()).sorted(Comparator.reverseOrder())
+				.collect(Collectors.toList());
+		frequencyMap = frequencyMap.entrySet().stream().sorted(Map.Entry.comparingByValue(Collections.reverseOrder()))
+				.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
+		List<Integer> rankCounts = frequencyMap.entrySet().stream().map(x -> x.getValue()).collect(Collectors.toList());
+		List<Integer> suits = cards.stream().map(s -> s.getSuit()).collect(Collectors.toList());
+
+		return calculatedScore(frequencyMap, cardsByRank, ranks, rankCounts, suits);
+	}
+
+	private int calculatedScore(Map<Integer, Integer> frequencyMap, List<Card> cardsByRank, List<Integer> ranks,
+			List<Integer> rankCounts, List<Integer> suits) {
+		if (ranks.equals(Arrays.asList(14, 5, 4, 3, 2))) {
+			ranks = Arrays.asList(5, 4, 3, 2, 1);
+		}
+
+		boolean flush = suits.stream().distinct().count() == 1;
+		boolean straight = ranks.stream().distinct().count() == 5 && ranks.get(0) - ranks.get(4) == 4;
+		Iterator<Integer> iteratorOverFrequencies = frequencyMap.keySet().iterator();
+		int highestFrequency = iteratorOverFrequencies.next();
+
+		if (straight && flush) {
+			return 800 + highestFrequency;
+		}
+		if (rankCounts.equals(Arrays.asList(4, 1))) {
+			return 700 + cardsByRank.get(0).getRank();
+		}
+		if (rankCounts.equals(Arrays.asList(3, 2))) {
+			return 600 + cardsByRank.get(0).getRank();
+		}
+		if (flush) {
+			return 500 + highestFrequency;
+		}
+		if (straight) {
+			return 400 + highestFrequency;
+		}
+		if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
+			return 300 + cardsByRank.get(0).getRank();
+		}
+		if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
+			return 200 + Math.max(highestFrequency, iteratorOverFrequencies.next());
+		}
+		if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
+			return 100 + highestFrequency;
+		}
+		Collections.sort(ranks, (a, b) -> b.compareTo(a));
+		Collections.reverse(ranks);
+		return ranks.get(0);
+	}
 }

exercises/poker/src/example/java/Poker.java

@@ -4,14 +4,24 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 public class Poker {
-			public static List<String> bestHands(List<String> hands) {
-				ArrayList<Hand> scoredHands = new ArrayList<Hand>();
+	private final List<String> bestHands;
 
-				for (String s : hands)
-					scoredHands.add(new Hand(s));
+	public Poker(final List<String> hands) {
+		bestHands = bestHands(hands);
+	}
 
-				int maxscore = scoredHands.stream().map(h -> h.getScore()).max(Comparator.naturalOrder()).get();
-				return scoredHands.stream().filter(h -> h.getScore() == maxscore).map(h -> h.getInput())
-						.collect(Collectors.toList());
-			}
+	public List<String> getBestHands() {
+		return bestHands;
+	}
+
+	public List<String> bestHands(final List<String> hands) {
+		ArrayList<Hand> scoredHands = new ArrayList<Hand>();
+
+		for (String s : hands) {
+			scoredHands.add(new Hand(s));
+		}
+		int maxscore = scoredHands.stream().map(h -> h.getScore()).max(Comparator.naturalOrder()).get();
+		return scoredHands.stream().filter(h -> h.getScore() == maxscore).map(h -> h.getInput())
+				.collect(Collectors.toList());
+	}
 }

exercises/poker/src/main/java/Poker.java

@@ -1,8 +1,12 @@
 import java.util.List;
-import sun.reflect.generics.reflectiveObjects.NotImplementedException;
 
 public class Poker {
-	public static List<String> bestHands(List<String> hands) {
-			throw new NotImplementedException();
+
+	Poker(List<String> hands) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+	List<String> bestHands() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
 	}
 }

exercises/poker/src/test/java/PokerTest.java

@@ -1,14 +1,16 @@
 import static org.junit.Assert.assertEquals;
+
 import java.util.Arrays;
-import org.junit.Ignore;
+
 import org.junit.Test;
 
-public class PokerTest
-{
+import jdk.nashorn.internal.ir.annotations.Ignore;
+
+public class PokerTest {
     @Test
     public void oneHand() {
         final String hand = "4S 5S 7H 8D JC";
-        assertEquals(Arrays.asList(hand),Poker.bestHands(Arrays.asList(hand)));
+        assertEquals(Arrays.asList(hand),new Poker(Arrays.asList(hand)).getBestHands());
     }
 
     @Test
@@ -16,7 +18,7 @@ public class PokerTest
     public void nothingVsOnePair() {
         final String nothing = "4S 5H 6S 8D JH";
         final String pairOf4 = "2S 4H 6S 4D JH";
-        assertEquals(Arrays.asList(pairOf4), Poker.bestHands(Arrays.asList(nothing, pairOf4)));
+        assertEquals(Arrays.asList(pairOf4),new Poker(Arrays.asList(nothing, pairOf4)).getBestHands());
     }
 
     @Test
@@ -24,7 +26,7 @@ public class PokerTest
     public void twoPairs() {
         final String pairOf2 = "4S 2H 6S 2D JH";
         final String pairOf4 = "2S 4H 6S 4D JH";
-        assertEquals(Arrays.asList(pairOf4), Poker.bestHands(Arrays.asList(pairOf2,pairOf4)));
+        assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(pairOf2,pairOf4)).getBestHands());
     }
 
     @Test
@@ -32,7 +34,7 @@ public class PokerTest
     public void onePairVsDoublePair() {
         final String pairOf8 = "2S 8H 6S 8D JH";
         final String doublePair = "4S 5H 4S 8D 5H";
-        assertEquals(Arrays.asList(doublePair), Poker.bestHands(Arrays.asList(pairOf8, doublePair)));
+        assertEquals(Arrays.asList(doublePair),  new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
     }
 
     @Test
@@ -40,7 +42,7 @@ public class PokerTest
     public void twoDoublePairs() {
         final String doublePair2And8 = "2S 8H 2S 8D JH";
         final String doublePair4And5 = "4S 5H 4S 8D 5H";
-        assertEquals(Arrays.asList(doublePair2And8), Poker.bestHands(Arrays.asList(doublePair2And8, doublePair4And5)));
+        assertEquals(Arrays.asList(doublePair2And8), new Poker(Arrays.asList(doublePair2And8, doublePair4And5)).getBestHands());
     }
 
     @Test
@@ -48,7 +50,7 @@ public class PokerTest
     public void doublePairVsThree() {
         final String doublePair2And8 = "2S 8H 2S 8D JH";
         final String threeOf4 = "4S 5H 4S 8D 4H";
-        assertEquals(Arrays.asList(threeOf4 ), Poker.bestHands(Arrays.asList(doublePair2And8, threeOf4 )));
+        assertEquals(Arrays.asList(threeOf4 ), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
     }
 
     @Test
@@ -56,7 +58,7 @@ public class PokerTest
     public void twoThrees() {
         final String threeOf2 = "2S 2H 2S 8D JH";
         final String threeOf1 = "4S AH AS 8D AH";
-        assertEquals(Arrays.asList(threeOf1), Poker.bestHands(Arrays.asList(threeOf2, threeOf1)));
+        assertEquals(Arrays.asList(threeOf1), new Poker(Arrays.asList(threeOf2, threeOf1)).getBestHands());
     }
 
     @Test
@@ -64,7 +66,7 @@ public class PokerTest
     public void threeVsStraight() {
         final String threeOf4 = "4S 5H 4S 8D 4H";
         final String straight = "3S 4H 2S 6D 5H";
-        assertEquals(Arrays.asList(straight), Poker.bestHands(Arrays.asList(threeOf4, straight )));
+        assertEquals(Arrays.asList(straight), new Poker(Arrays.asList(threeOf4, straight)).getBestHands());
     }
 
     @Test
@@ -72,11 +74,11 @@ public class PokerTest
     public void twoStraights() {
         final String straightTo8 = "4S 6H 7S 8D 5H";
         final String straightTo9 = "5S 7H 8S 9D 6H";
-        assertEquals(Arrays.asList(straightTo9 ), Poker.bestHands(Arrays.asList(straightTo8, straightTo9 )));
+        assertEquals(Arrays.asList(straightTo9 ), new Poker(Arrays.asList(straightTo8, straightTo9)).getBestHands());
 
         final String straightTo1 = "AS QH KS TD JH";
         final String straightTo5 = "4S AH 3S 2D 5H";
-        assertEquals(Arrays.asList(straightTo1), Poker.bestHands(Arrays.asList(straightTo1, straightTo5)));
+        assertEquals(Arrays.asList(straightTo1), new Poker(Arrays.asList(straightTo1, straightTo5)).getBestHands());
     }
 
     @Test
@@ -84,7 +86,7 @@ public class PokerTest
     public void straightVsFlush() {
         final String straightTo8 = "4S 6H 7S 8D 5H";
         final String flushTo7 = "2S 4S 5S 6S 7S";
-        assertEquals(Arrays.asList(flushTo7 ), Poker.bestHands(Arrays.asList(straightTo8, flushTo7 )));
+        assertEquals(Arrays.asList(flushTo7 ), new Poker(Arrays.asList(straightTo8, flushTo7)).getBestHands());
     }
 
     @Test
@@ -92,7 +94,7 @@ public class PokerTest
     public void twoFlushes() {
         final String flushTo8 = "3H 6H 7H 8H 5H";
         final String flushTo7 = "2S 4S 5S 6S 7S";
-        assertEquals(Arrays.asList(flushTo8), Poker.bestHands(Arrays.asList(flushTo8, flushTo7)));
+        assertEquals(Arrays.asList(flushTo8), new Poker(Arrays.asList(flushTo8, flushTo7)).getBestHands());
     }
 
     @Test
@@ -100,7 +102,7 @@ public class PokerTest
     public void flushVsFull() {
         final String flushTo8 = "3H 6H 7H 8H 5H";
         final String full = "4S 5H 4S 5D 4H";
-        assertEquals(Arrays.asList(full ), Poker.bestHands(Arrays.asList(full, flushTo8)));
+        assertEquals(Arrays.asList(full ), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
     }
 
     @Test
@@ -108,7 +110,7 @@ public class PokerTest
     public void twoFulls() {
         final String fullOf4By9 = "4H 4S 4D 9S 9D";
         final String fullOf5By8 = "5H 5S 5D 8S 8D";
-        assertEquals(Arrays.asList(fullOf5By8 ), Poker.bestHands(Arrays.asList(fullOf4By9, fullOf5By8)));
+        assertEquals(Arrays.asList(fullOf5By8 ), new Poker(Arrays.asList(fullOf4By9, fullOf5By8)).getBestHands());
     }
 
     @Test
@@ -116,7 +118,7 @@ public class PokerTest
     public void fullVsSquare() {
         final String full = "4S 5H 4S 5D 4H";
         final String squareOf3 = "3S 3H 2S 3D 3H";
-        assertEquals(Arrays.asList(squareOf3 ), Poker.bestHands(Arrays.asList(full, squareOf3 )));
+        assertEquals(Arrays.asList(squareOf3 ), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
     }
 
     @Test
@@ -124,7 +126,7 @@ public class PokerTest
     public void twoSquares() {
         final String squareOf2 = "2S 2H 2S 8D 2H";
         final String squareOf5 = "4S 5H 5S 5D 5H";
-        assertEquals(Arrays.asList(squareOf5), Poker.bestHands(Arrays.asList(squareOf2, squareOf5)));
+        assertEquals(Arrays.asList(squareOf5), new Poker(Arrays.asList(squareOf2, squareOf5)).getBestHands());
     }
 
     @Test
@@ -132,7 +134,7 @@ public class PokerTest
     public void squareVsStraightFlush() {
         final String squareOf5 = "4S 5H 5S 5D 5H";
         final String straightFlushTo9 = "5S 7S 8S 9S 6S";
-        assertEquals(Arrays.asList(straightFlushTo9 ), Poker.bestHands(Arrays.asList(squareOf5, straightFlushTo9 )));
+        assertEquals(Arrays.asList(straightFlushTo9 ), new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
     }
 
     @Test
@@ -140,7 +142,7 @@ public class PokerTest
     public void twoStraightFlushes() {
         final String straightFlushTo8 = "4H 6H 7H 8H 5H";
         final String straightFlushTo9 = "5S 7S 8S 9S 6S";
-        assertEquals(Arrays.asList(straightFlushTo9 ), Poker.bestHands(Arrays.asList(straightFlushTo8, straightFlushTo9)));
+        assertEquals(Arrays.asList(straightFlushTo9 ), new Poker(Arrays.asList(straightFlushTo8, straightFlushTo9)).getBestHands());
     }
 
     @Test
@@ -149,7 +151,7 @@ public class PokerTest
         final String spadeStraightTo9 = "9S 8S 7S 6S 5S";
         final String diamondStraightTo9 = "9D 8D 7D 6D 5D";
         final String threeOf4 = "4D 4S 4H QS KS";
-        assertEquals(Arrays.asList(spadeStraightTo9, diamondStraightTo9), Poker.bestHands(Arrays.asList(spadeStraightTo9, diamondStraightTo9, threeOf4)));
+        assertEquals(Arrays.asList(spadeStraightTo9, diamondStraightTo9), new Poker(Arrays.asList(spadeStraightTo9, diamondStraightTo9, threeOf4)).getBestHands());
     }
 
     @Test
@@ -157,6 +159,6 @@ public class PokerTest
     public void straightTo5AgainstAPairOfJacks() {
         final String straightTo5 = "2S 4D 5C 3S AS";
         final String twoJacks = "JD 8D 7D JC 5D";
-        assertEquals(Arrays.asList(straightTo5), Poker.bestHands(Arrays.asList(straightTo5, twoJacks)));
+        assertEquals(Arrays.asList(straightTo5), new Poker(Arrays.asList(straightTo5, twoJacks)).getBestHands());
     }
 }

exercises/settings.gradle

@@ -71,3 +71,4 @@ include 'twelve-days'
 include 'word-count'
 include 'word-search'
 include 'wordy'
+include 'poker'