poker: sort settings.gradle and tidy up

Fix formatting and Intellij warnings. Remove starter implementation as
this is after the first 20 exercises. Move poker in settings.gradle so
that it's sorted alphabetically.

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

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

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

-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.*;
 import java.util.stream.Collectors;
 
-public class Hand {
-	private String input;
-	private int score;
+class Hand {
+    private String input;
+    private int score;
 
-	public Hand(String hand) {
-		this.input = hand;
-		this.score = scoreHand(parseCards(hand));
-	}
+    Hand(String hand) {
+        this.input = hand;
+        this.score = scoreHand(parseCards(hand));
+    }
 
-	public int getScore() {
-		return score;
-	}
+    int getScore() {
+        return score;
+    }
 
-	public String getInput() {
-		return input;
-	}
+    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 List<Card> parseCards(String hand) {
+        ArrayList<Card> parsedCards = new ArrayList<>();
+        String[] cardsToParse = hand.split(" ");
+        for (String cardToParse : cardsToParse) {
+            parsedCards.add(new Card(cardToParse));
+        }
+        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 Map<Integer, Integer> getFrequencyMap(List<Card> cards) {
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        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());
+    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());
+        Map<Integer, Integer> frequencyMap = getFrequencyMap(cards);
+        List<Integer> ranks = frequencyMap
+                .entrySet()
+                .stream()
+                .map(Map.Entry::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(Map.Entry::getValue)
+                .collect(Collectors.toList());
+        List<Integer> suits = cards.stream().map(Card::getSuit).collect(Collectors.toList());
 
-		return calculatedScore(frequencyMap, cardsByRank, ranks, rankCounts, suits);
-	}
+        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);
-		}
+    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();
+        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);
-	}
-}
+        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;
+        }
+        ranks.sort(Comparator.reverseOrder());
+        Collections.reverse(ranks);
+        return ranks.get(0);
+    }
+}

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

-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Collectors;
 
-public class Poker {
-	private final List<String> bestHands;
+class Poker {
+    private final List<String> bestHands;
 
-	public Poker(final List<String> hands) {
-		bestHands = bestHands(hands);
-	}
+    Poker(final List<String> hands) {
+        bestHands = bestHands(hands);
+    }
 
-	public List<String> getBestHands() {
-		return bestHands;
-	}
+    List<String> getBestHands() {
+        return bestHands;
+    }
 
-	public List<String> bestHands(final List<String> hands) {
-		ArrayList<Hand> scoredHands = new ArrayList<Hand>();
+    private List<String> bestHands(final List<String> hands) {
+        ArrayList<Hand> scoredHands = new ArrayList<>();
 
-		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());
-	}
+        for (String s : hands) {
+            scoredHands.add(new Hand(s));
+        }
+        Optional<Integer> maxScoreIfAny = scoredHands
+                .stream()
+                .map(Hand::getScore)
+                .max(Comparator.naturalOrder());
+        return maxScoreIfAny
+                .map(maxScore -> scoredHands
+                        .stream()
+                        .filter(h -> h.getScore() == maxScore)
+                        .map(Hand::getInput)
+                        .collect(Collectors.toList()))
+                .orElseGet(Collections::emptyList);
+
+    }
 }

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

-public class Poker {
-}

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

-import static org.junit.Assert.assertEquals;
+import org.junit.Ignore;
+import org.junit.Test;
 
 import java.util.Arrays;
 
-import org.junit.Test;
-
-import org.junit.Ignore;
+import static org.junit.Assert.assertEquals;
 
 public class PokerTest {
     @Test
     public void oneHand() {
         final String hand = "4S 5S 7H 8D JC";
-        assertEquals(Arrays.asList(hand),new Poker(Arrays.asList(hand)).getBestHands());
+        assertEquals(Arrays.asList(hand), new Poker(Arrays.asList(hand)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     public void nothingVsOnePair() {
         final String nothing = "4S 5H 6S 8D JH";
         final String pairOf4 = "2S 4H 6S 4D JH";
-        assertEquals(Arrays.asList(pairOf4),new Poker(Arrays.asList(nothing, pairOf4)).getBestHands());
+        assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(nothing, pairOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     public void twoPairs() {
         final String pairOf2 = "4S 2H 6S 2D JH";
         final String pairOf4 = "2S 4H 6S 4D JH";
-        assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(pairOf2,pairOf4)).getBestHands());
+        assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(pairOf2, pairOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     public void onePairVsDoublePair() {
         final String pairOf8 = "2S 8H 6S 8D JH";
         final String doublePair = "4S 5H 4S 8D 5H";
-        assertEquals(Arrays.asList(doublePair),  new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
+        assertEquals(Arrays.asList(doublePair), new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     public void doublePairVsThree() {
         final String doublePair2And8 = "2S 8H 2S 8D JH";
         final String threeOf4 = "4S 5H 4S 8D 4H";
-        assertEquals(Arrays.asList(threeOf4 ), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
+        assertEquals(Arrays.asList(threeOf4), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     public void twoStraights() {
         final String straightTo8 = "4S 6H 7S 8D 5H";
         final String straightTo9 = "5S 7H 8S 9D 6H";
-        assertEquals(Arrays.asList(straightTo9 ), new Poker(Arrays.asList(straightTo8, straightTo9)).getBestHands());
+        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";
     public void straightVsFlush() {
         final String straightTo8 = "4S 6H 7S 8D 5H";
         final String flushTo7 = "2S 4S 5S 6S 7S";
-        assertEquals(Arrays.asList(flushTo7 ), new Poker(Arrays.asList(straightTo8, flushTo7)).getBestHands());
+        assertEquals(Arrays.asList(flushTo7), new Poker(Arrays.asList(straightTo8, flushTo7)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     public void flushVsFull() {
         final String flushTo8 = "3H 6H 7H 8H 5H";
         final String full = "4S 5H 4S 5D 4H";
-        assertEquals(Arrays.asList(full ), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
+        assertEquals(Arrays.asList(full), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     public void twoFulls() {
         final String fullOf4By9 = "4H 4S 4D 9S 9D";
         final String fullOf5By8 = "5H 5S 5D 8S 8D";
-        assertEquals(Arrays.asList(fullOf5By8 ), new Poker(Arrays.asList(fullOf4By9, fullOf5By8)).getBestHands());
+        assertEquals(Arrays.asList(fullOf5By8), new Poker(Arrays.asList(fullOf4By9, fullOf5By8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     public void fullVsSquare() {
         final String full = "4S 5H 4S 5D 4H";
         final String squareOf3 = "3S 3H 2S 3D 3H";
-        assertEquals(Arrays.asList(squareOf3 ), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
+        assertEquals(Arrays.asList(squareOf3), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     public void squareVsStraightFlush() {
         final String squareOf5 = "4S 5H 5S 5D 5H";
         final String straightFlushTo9 = "5S 7S 8S 9S 6S";
-        assertEquals(Arrays.asList(straightFlushTo9 ), new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
+        assertEquals(Arrays.asList(straightFlushTo9), new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     public void twoStraightFlushes() {
         final String straightFlushTo8 = "4H 6H 7H 8H 5H";
         final String straightFlushTo9 = "5S 7S 8S 9S 6S";
-        assertEquals(Arrays.asList(straightFlushTo9 ), new Poker(Arrays.asList(straightFlushTo8, straightFlushTo9)).getBestHands());
+        assertEquals(Arrays.asList(straightFlushTo9), new Poker(Arrays.asList(straightFlushTo8, straightFlushTo9)).getBestHands());
     }
 
     @Ignore("Remove to run test")

exercises/settings.gradle

 include 'perfect-numbers'
 include 'phone-number'
 include 'pig-latin'
+include 'poker'
 include 'prime-factors'
 include 'pythagorean-triplet'
 include 'queen-attack'
 include 'word-count'
 include 'word-search'
 include 'wordy'
-include 'poker'