Skip to content

Commit fe2139b

Browse files
ZaldrickZaldrick
committed
code improvements (adding Card & Hand classes)
1 parent 46dabc3 commit fe2139b

5 files changed

Lines changed: 151 additions & 168 deletions

File tree

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

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
public class Card {
2+
private int rank;
3+
private int suit;
4+
5+
public Card(String card) {
6+
rank = parseRank(card);
7+
suit = parseSuit(card);
8+
}
9+
10+
public int getRank() {
11+
return rank;
12+
}
13+
14+
public int getSuit() {
15+
return suit;
16+
}
17+
18+
private static int parseRank(String card) {
19+
return "..23456789TJQKA".indexOf(card.charAt(0));
20+
}
21+
22+
private static int parseSuit(String card) {
23+
return ".HSDC".indexOf(card.charAt(1));
24+
}
25+
}

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

Lines changed: 106 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,106 @@
1+
import java.util.ArrayList;
2+
import java.util.Arrays;
3+
import java.util.Collections;
4+
import java.util.Comparator;
5+
import java.util.HashMap;
6+
import java.util.Iterator;
7+
import java.util.LinkedHashMap;
8+
import java.util.List;
9+
import java.util.Map;
10+
import java.util.stream.Collectors;
11+
12+
public class Hand {
13+
private String input;
14+
private int score;
15+
16+
public Hand(String hand) {
17+
this.input = hand;
18+
this.score = scoreHand(parseCards(hand));
19+
}
20+
21+
public int getScore() {
22+
return score;
23+
}
24+
25+
public String getInput() {
26+
return input;
27+
}
28+
29+
private static List<Card> parseCards(String hand) {
30+
ArrayList<Card> parsedCards = new ArrayList<Card>();
31+
String[] parseString = hand.split(" ");
32+
for (int i = 0; i < parseString.length; i++) {
33+
parsedCards.add(new Card(parseString[i]));
34+
}
35+
return parsedCards;
36+
}
37+
38+
private static Map<Integer, Integer> getFrequencyMap(List<Card> cards) {
39+
Map<Integer, Integer> frequencymap = new HashMap<Integer, Integer>() ;
40+
for (Card c : cards) {
41+
if (frequencymap.containsKey(c.getRank())) {
42+
frequencymap.put(c.getRank(), frequencymap.get(c.getRank()) + 1);
43+
} else {
44+
frequencymap.put(c.getRank(), 1);
45+
}
46+
}
47+
return frequencymap;
48+
}
49+
50+
private static int scoreHand(List<Card> cards) {
51+
List<Card> cardsByRank = new ArrayList<Card>();
52+
53+
cardsByRank = cards.stream().sorted(Comparator.comparing(Card::getRank)).unordered()
54+
.collect(Collectors.toList());
55+
56+
Map<Integer, Integer> frequencymap = getFrequencyMap(cards);
57+
List<Integer> ranks = frequencymap.entrySet().stream().map(x -> x.getKey())
58+
.sorted(Comparator.reverseOrder()).collect(Collectors.toList());
59+
60+
frequencymap = frequencymap.entrySet().stream()
61+
.sorted(Map.Entry.comparingByValue(Collections.reverseOrder())).collect(Collectors
62+
.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
63+
64+
List<Integer> rankCounts = frequencymap.entrySet().stream().map(x -> x.getValue())
65+
.collect(Collectors.toList());
66+
67+
List<Integer> suits = cards.stream().map(s -> s.getSuit()).collect(Collectors.toList());
68+
69+
if (ranks.equals(Arrays.asList(14, 5, 4, 3, 2))) {
70+
ranks = Arrays.asList(5, 4, 3, 2, 1);
71+
}
72+
73+
boolean flush = suits.stream().distinct().count() == 1;
74+
boolean straight = ranks.stream().distinct().count() == 5 && ranks.get(0) - ranks.get(4) == 4;
75+
Iterator<Integer> itr = frequencymap.keySet().iterator();
76+
int pairA = itr.next();
77+
78+
if (straight && flush) {
79+
return 800 + frequencymap.keySet().iterator().next();
80+
}
81+
if (rankCounts.equals(Arrays.asList(4, 1))) {
82+
return (700 + (cardsByRank.get(0)).getRank());
83+
}
84+
if (rankCounts.equals(Arrays.asList(3, 2))) {
85+
return 600 + cardsByRank.get(0).getRank();
86+
}
87+
if (flush) {
88+
return 500 + frequencymap.keySet().iterator().next();
89+
}
90+
if (straight) {
91+
return 400 + frequencymap.keySet().iterator().next();
92+
}
93+
if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
94+
return 300 + cardsByRank.get(0).getRank();
95+
}
96+
if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
97+
return 200 + Math.max(pairA, itr.next());
98+
}
99+
if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
100+
return 100 + pairA;
101+
}
102+
Collections.sort(ranks, (a, b) -> b.compareTo(a));
103+
Collections.reverse(ranks);
104+
return ranks.get(0);
105+
}
106+
}

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

Lines changed: 1 addition & 126 deletions
Original file line numberDiff line numberDiff line change
@@ -1,139 +1,14 @@
11
import java.util.ArrayList;
2-
import java.util.Arrays;
3-
import java.util.Collections;
42
import java.util.Comparator;
5-
import java.util.HashMap;
6-
import java.util.Iterator;
7-
import java.util.LinkedHashMap;
83
import java.util.List;
9-
import java.util.Map;
104
import java.util.stream.Collectors;
115

126
public class Poker {
13-
private static class Card {
14-
private int rank;
15-
private int suit;
16-
17-
public Card(String card) {
18-
rank = parseRank(card);
19-
suit = parseSuit(card);
20-
}
21-
22-
private int getRank() {
23-
return rank;
24-
}
25-
26-
private int getSuit() {
27-
return suit;
28-
}
29-
30-
private static int parseRank(String card) {
31-
return "..23456789TJQKA".indexOf(card.charAt(0));
32-
}
33-
34-
private static int parseSuit(String card) {
35-
return ".HSDC".indexOf(card.charAt(1));
36-
}
37-
}
38-
39-
private static class Hand {
40-
private String input;
41-
private int score;
42-
43-
private Hand(String hand) {
44-
this.input = hand;
45-
this.score = scoreHand(parseCards(hand));
46-
}
47-
48-
private int getScore() {
49-
return score;
50-
}
51-
52-
private String getInput() {
53-
return input;
54-
}
55-
56-
private static List<Card> parseCards(String hand) {
57-
ArrayList<Card> parseCards = new ArrayList<Card>();
58-
String[] parseString = hand.split(" ");
59-
for (int i = 0; i < parseString.length; i++) {
60-
parseCards.add(new Poker.Card(parseString[i]));
61-
}
62-
return parseCards;
63-
}
64-
65-
private static int scoreHand(List<Card> cards) {
66-
67-
List<Card> cardsByrank = new ArrayList<Card>();
68-
69-
cardsByrank = cards.stream().sorted(Comparator.comparing(Card::getRank)).unordered()
70-
.collect(Collectors.toList());
71-
72-
Map<Integer, Integer> frequencymap = new HashMap<Integer, Integer>();
73-
for (Card c : cards) {
74-
if (frequencymap.containsKey(c.rank)) {
75-
frequencymap.put(c.getRank(), frequencymap.get(c.getRank()) + 1);
76-
} else {
77-
frequencymap.put(c.getRank(), 1);
78-
}
79-
}
80-
81-
List<Integer> ranks = frequencymap.entrySet().stream().map(x -> x.getKey())
82-
.sorted(Comparator.reverseOrder()).collect(Collectors.toList());
83-
84-
frequencymap = frequencymap.entrySet().stream()
85-
.sorted(Map.Entry.comparingByValue(Collections.reverseOrder())).collect(Collectors
86-
.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
87-
88-
List<Integer> rankCounts = frequencymap.entrySet().stream().map(x -> x.getValue())
89-
.collect(Collectors.toList());
90-
91-
List<Integer> suits = cards.stream().map(s -> s.getSuit()).collect(Collectors.toList());
92-
93-
if (ranks.equals(Arrays.asList(14, 5, 4, 3, 2))) {
94-
ranks = Arrays.asList(5, 4, 3, 2, 1);
95-
}
96-
97-
boolean flush = suits.stream().distinct().count() == 1;
98-
boolean straight = ranks.stream().distinct().count() == 5 && ranks.get(0) - ranks.get(4) == 4;
99-
Iterator<Integer> itr = frequencymap.keySet().iterator();
100-
int pairA = itr.next();
101-
102-
if (straight && flush) {
103-
return 800 + frequencymap.keySet().iterator().next();
104-
}
105-
if (rankCounts.equals(Arrays.asList(4, 1))) {
106-
return (700 + (cardsByrank.get(0)).getRank());
107-
}
108-
if (rankCounts.equals(Arrays.asList(3, 2))) {
109-
return 600 + cardsByrank.get(0).getRank();
110-
}
111-
if (flush) {
112-
return 500 + frequencymap.keySet().iterator().next();
113-
}
114-
if (straight) {
115-
return 400 + frequencymap.keySet().iterator().next();
116-
}
117-
if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
118-
return 300 + cardsByrank.get(0).getRank();
119-
}
120-
if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
121-
return 200 + Math.max(pairA, itr.next());
122-
}
123-
if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
124-
return 100 + pairA;
125-
}
126-
Collections.sort(ranks, (a, b) -> b.compareTo(a));
127-
Collections.reverse(ranks);
128-
return ranks.get(0);
129-
}
130-
}
1317
public static List<String> bestHands(List<String> hands) {
1328
ArrayList<Hand> scoredHands = new ArrayList<Hand>();
1339

134-
for (String s : hands) {
10+
for (String s : hands)
13511
scoredHands.add(new Hand(s));
136-
}
13712

13813
int maxscore = scoredHands.stream().map(h -> h.getScore()).max(Comparator.naturalOrder()).get();
13914
return scoredHands.stream().filter(h -> h.getScore() == maxscore).map(h -> h.getInput())

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

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,8 @@
11
import java.util.List;
2-
32
import sun.reflect.generics.reflectiveObjects.NotImplementedException;
43

54
public class Poker {
6-
75
public static List<String> bestHands(List<String> hands) {
8-
{
96
throw new NotImplementedException();
10-
}
117
}
128
}

0 commit comments

Comments
 (0)