summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.vscode/launch.json21
-rw-r--r--Game.classbin0 -> 5582 bytes
-rw-r--r--Game.java364
-rw-r--r--GameTest.java527
-rw-r--r--card/Card$1.classbin0 -> 661 bytes
-rw-r--r--card/Card.classbin0 -> 1351 bytes
-rw-r--r--card/Card.java60
-rw-r--r--card/Suit.classbin0 -> 883 bytes
-rw-r--r--card/Suit.java8
-rw-r--r--lib/hamcrest-core-1.3.jarbin0 -> 45024 bytes
-rw-r--r--lib/junit-4.13.2.jarbin0 -> 384581 bytes
11 files changed, 980 insertions, 0 deletions
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..f571609
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,21 @@
+{
+ // Use IntelliSense to learn about possible attributes.
+ // Hover to view descriptions of existing attributes.
+ // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+ "version": "0.2.0",
+ "configurations": [
+ {
+ "type": "java",
+ "name": "Launch Current File",
+ "request": "launch",
+ "mainClass": "${file}"
+ },
+ {
+ "type": "java",
+ "name": "Launch Game",
+ "request": "launch",
+ "mainClass": "Game",
+ "projectName": "holdem_ed7e9667"
+ }
+ ]
+} \ No newline at end of file
diff --git a/Game.class b/Game.class
new file mode 100644
index 0000000..95ceca7
--- /dev/null
+++ b/Game.class
Binary files differ
diff --git a/Game.java b/Game.java
new file mode 100644
index 0000000..8959282
--- /dev/null
+++ b/Game.java
@@ -0,0 +1,364 @@
+import java.util.*;
+import card.*;
+
+class Game {
+ private List<Card> deck = new ArrayList<>();
+ private List<List<Card>> hands = new ArrayList<>();
+ private List<Integer> ranks = new ArrayList<>();
+
+ public Game() {
+ setDeck();
+ }
+
+ public Game(int handsNum) {
+ setDeck();
+ for (int i = 0; i < handsNum; i++) {
+ hands.add(setHand());
+ ranks.add(getRank(hands.get(i)));
+ }
+ }
+
+ public void setHands(List<List<Card>> hands) {
+ this.hands = hands;
+ }
+
+ public void setRanks(List<Integer> ranks) {
+ this.ranks = ranks;
+ }
+
+ public void setDeck() {
+ Suit s = Suit.CLUBS;
+ for (int i = 0; i < 4; i++) {
+ switch (i) {
+ case 0:
+ s = Suit.CLUBS;
+ break;
+ case 1:
+ s = Suit.DIAMONDS;
+ break;
+ case 2:
+ s = Suit.HEARTS;
+ break;
+ case 3:
+ s = Suit.SPADES;
+ break;
+ }
+ for (int j = 1; j <= 13; j++) {
+ Card card = new Card(j, s);
+ deck.add(card);
+ }
+ }
+ }
+
+ public List<Card> sort(List<Card> hand) {
+ if (hand.size() <= 1)
+ return hand;
+ int mid = hand.size() / 2;
+ List<Card> left = sort(hand.subList(0, mid));
+ List<Card> right = sort(hand.subList(mid, hand.size()));
+ return merge(left, right);
+ }
+
+ public List<Card> merge(List<Card> left, List<Card> right) {
+ List<Card> result = new ArrayList<>();
+ int l = 0, r = 0;
+ while (l < left.size() || r < right.size()) {
+ if (l < left.size() && (r == right.size()
+ || left.get(l).getValue() < right.get(r).getValue() )) {
+ result.add(left.get(l));
+ l++;
+ } else {
+ result.add(right.get(r));
+ r++;
+ }
+ }
+ return result;
+ }
+
+ public List<Card> setHand() {
+ List<Card> hand = new ArrayList<>();
+ Random rand = new Random();
+ for (int i = 0; i < 5; i++) {
+ int randInt = rand.nextInt(deck.size());
+ hand.add(deck.get(randInt));
+ deck.remove(randInt);
+ }
+ return sort(hand);
+ }
+
+ public void getHand(List<Card> hand) {
+ for (Card c : hand) {
+ System.out.println(c.displayCard());
+ }
+ }
+
+ public int getRank(List<Card> hand) {
+ if (isRoyalFlush(hand)) {
+ return 9;
+ } else if (isStraightFlush(hand)) {
+ return 8;
+ } else if (isFourOfKind(hand)) {
+ return 7;
+ } else if (isFullHouse(hand)) {
+ return 6;
+ } else if (isFlush(hand)) {
+ return 5;
+ } else if (isStraight(hand)) {
+ return 4;
+ } else if (isThreeOfKind(hand)) {
+ return 3;
+ } else if (isTwoPair(hand)) {
+ return 2;
+ } else if (isPair(hand)) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+
+ public void displayRank(List<Card> hand, int rank) {
+ switch (rank) {
+ case 8:
+ System.out.println("Straight flush");
+ break;
+ case 7:
+ System.out.println("Four of a kind");
+ break;
+ case 6:
+ System.out.println("Full house");
+ break;
+ case 5:
+ System.out.println("Flush");
+ break;
+ case 4:
+ System.out.println("Straight");
+ break;
+ case 3:
+ System.out.println("Three of a kind");
+ break;
+ case 2:
+ System.out.println("Two pair");
+ break;
+ case 1:
+ System.out.println("Pair");
+ break;
+ default:
+ System.out.println("High card " + highCard(hand));
+ }
+ }
+
+ public String highCard(List<Card> hand) {
+ if (hand.get(0).getValue() == 1)
+ return hand.get(0).displayCard();
+ return hand.get(hand.size() - 1).displayCard();
+ }
+
+ public boolean isPair(List<Card> hand) {
+ boolean pair = false;
+ for (int i = 0; i < hand.size() - 1; i++)
+ pair = pair || (hand.get(i).getValue() == hand.get(i + 1).getValue());
+ return pair;
+ }
+
+ public boolean isTwoPair(List<Card> hand) {
+ int numberOfPairs = 0;
+ int i = 0;
+ while (i < hand.size() - 1) {
+ if (isPair(hand.subList(i, i + 2))) {
+ numberOfPairs++;
+ i += 2;
+ } else {
+ i++;
+ }
+ }
+ return numberOfPairs == 2;
+ }
+
+ public boolean isThreeOfKind(List<Card> hand) {
+ boolean threeOfKind = false;
+ for (int i = 0; i < hand.size() - 2; i++)
+ threeOfKind = threeOfKind
+ || (hand.get(i).getValue() == hand.get(i + 2).getValue());
+ return threeOfKind;
+ }
+
+ // TODO: ace high straight
+ public boolean isStraight(List<Card> hand) {
+ int prev = hand.get(0).getValue();
+ int count = 0;
+ for (int i = 1; i < hand.size() && count < 4; i++) {
+ if (hand.get(i).getValue() - prev == 1) {
+ count++;
+ } else {
+ count = 0;
+ }
+ prev = hand.get(i).getValue();
+ }
+ return count == 4;
+ }
+
+ public boolean isFlush(List<Card> hand) {
+ boolean flush = true;
+ Suit suit = hand.get(0).getSuit();
+ for (int i = 1; i < hand.size(); i++)
+ flush = flush && (hand.get(i).getSuit() == suit);
+ return flush;
+ }
+
+ public boolean isFullHouse(List<Card> hand) {
+ boolean pairThreeOfKind = false;
+ boolean threeOfKindPair = false;
+
+ for (int i = 0; i < hand.size() - 4; i++)
+ pairThreeOfKind = (hand.get(i).getValue() == hand.get(i + 1).getValue())
+ && (hand.get(i + 2).getValue() == hand.get(i + 4).getValue());
+
+ for (int i = 0; i < hand.size() - 4; i++)
+ threeOfKindPair = (hand.get(i).getValue() == hand.get(i + 2).getValue())
+ && (hand.get(i + 3).getValue() == hand.get(i + 4).getValue());
+
+ return pairThreeOfKind || threeOfKindPair;
+ }
+
+ public boolean isFourOfKind(List<Card> hand) {
+ boolean fourOfKind = false;
+ for (int i = 0; i < hand.size() - 3; i++)
+ fourOfKind = fourOfKind
+ || (hand.get(i).getValue() == hand.get(i + 3).getValue());
+ return fourOfKind;
+ }
+
+ public boolean isStraightFlush(List<Card> hand) {
+ return isStraight(hand) && isFlush(hand);
+ }
+
+ // TODO: check A-10
+ public boolean isRoyalFlush(List<Card> hand) {
+ return isFlush(hand) && hand.get(0).getValue() == 1
+ && hand.get(1).getValue() == 10 && hand.get(4).getValue() == 13;
+ }
+
+ public boolean compareHighCard(List<Card> firstHand, List<Card> secondHand) {
+ if (firstHand.get(0).getValue() == 1) {
+ return true;
+ } else if (secondHand.get(0).getValue() == 1) {
+ return false;
+ }
+ for (int j = firstHand.size() - 1; j > 0; j--) {
+ if (firstHand.get(j).getValue()
+ > secondHand.get(j).getValue()) {
+ return true;
+ } else if (secondHand.get(j).getValue()
+ > firstHand.get(j).getValue()) {
+ return false;
+ }
+ }
+ return false;
+ }
+
+ public boolean comparePair(List<Card> firstHand, List<Card> secondHand) {
+ Set<Integer> temp = new HashSet<>();
+ int high = firstHand.get(0).getValue();
+ for (int i = 1; i < firstHand.size(); i++) {
+ Card c = firstHand.get(i);
+ if (temp.contains(c.getValue())) {
+ high = c.getValue();
+ } else {
+ temp.add(c.getValue());
+ }
+ }
+ temp.clear();
+ for (Card c : secondHand) {
+ if (temp.contains(c.getValue())) {
+ if (high > c.getValue())
+ return true;
+ } else {
+ temp.add(c.getValue());
+ }
+ }
+ return false;
+ }
+
+ // TODO: combine with comparePair and compareThreeOfKind
+ public boolean compareTwoPair(List<Card> firstHand, List<Card> secondHand) {
+ Set<Integer> temp = new HashSet<>();
+ int high = firstHand.get(0).getValue();
+ for (int i = 1; i < firstHand.size(); i++) {
+ Card c = firstHand.get(i);
+ if (temp.contains(c.getValue()) && c.getValue() > high) {
+ high = c.getValue();
+ } else {
+ temp.add(c.getValue());
+ }
+ }
+ temp.clear();
+ int greater = 0;
+ for (Card c : secondHand) {
+ if (temp.contains(c.getValue()) && high > c.getValue()) {
+ greater++;
+ } else {
+ temp.add(c.getValue());
+ }
+ }
+ return greater >= 2;
+ }
+
+ public int getWinner() {
+ int bestHand = 0, bestRank = 0;
+ for (int i = 0; i < ranks.size(); i++) {
+ if (ranks.get(i) > bestRank) {
+ bestHand = i;
+ bestRank = ranks.get(i);
+ } else if (ranks.get(i) == bestRank) {
+ switch (bestRank) {
+ case 7:
+ if (compareTwoPair(hands.get(i), hands.get(bestHand))) {
+ bestHand = i;
+ bestRank = ranks.get(i);
+ }
+ break;
+ case 6:
+ if (compareTwoPair(hands.get(i), hands.get(bestHand))) {
+ bestHand = i;
+ bestRank = ranks.get(i);
+ }
+ break;
+ case 3:
+ if (compareTwoPair(hands.get(i), hands.get(bestHand))) {
+ bestHand = i;
+ bestRank = ranks.get(i);
+ }
+ break;
+ case 2:
+ if (compareTwoPair(hands.get(i), hands.get(bestHand))) {
+ bestHand = i;
+ bestRank = ranks.get(i);
+ }
+ break;
+ case 1:
+ if (comparePair(hands.get(i), hands.get(bestHand))) {
+ bestHand = i;
+ bestRank = ranks.get(i);
+ }
+ break;
+ case 0:
+ if (compareHighCard(hands.get(i), hands.get(bestHand))) {
+ bestHand = i;
+ bestRank = ranks.get(i);
+ }
+ }
+ }
+ }
+ return bestHand;
+ }
+
+ public static void main(String args[]) {
+ Game g = new Game(10);
+ for (int i = 0; i < g.hands.size(); i++) {
+ g.getHand(g.hands.get(i));
+ g.displayRank(g.hands.get(i), g.ranks.get(i));
+ System.out.println();
+ }
+ System.out.println(g.getWinner());
+ }
+}
diff --git a/GameTest.java b/GameTest.java
new file mode 100644
index 0000000..4f67793
--- /dev/null
+++ b/GameTest.java
@@ -0,0 +1,527 @@
+import java.util.*;
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+import card.*;
+
+public class GameTest {
+ @Test
+ public void testPair() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(1, Suit.HEARTS));
+ firstHand.add(new Card(2, Suit.DIAMONDS));
+ firstHand.add(new Card(3, Suit.SPADES));
+ firstHand.add(new Card(4, Suit.HEARTS));
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(1), ranks);
+ }
+
+ @Test
+ public void testTwoPair() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(1, Suit.HEARTS));
+ firstHand.add(new Card(2, Suit.DIAMONDS));
+ firstHand.add(new Card(2, Suit.SPADES));
+ firstHand.add(new Card(4, Suit.HEARTS));
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(2), ranks);
+ }
+
+ @Test
+ public void testThreeOfKind() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(1, Suit.HEARTS));
+ firstHand.add(new Card(1, Suit.DIAMONDS));
+ firstHand.add(new Card(2, Suit.SPADES));
+ firstHand.add(new Card(4, Suit.HEARTS));
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(3), ranks);
+ }
+
+ @Test
+ public void testStraight() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(2, Suit.HEARTS));
+ firstHand.add(new Card(3, Suit.DIAMONDS));
+ firstHand.add(new Card(4, Suit.SPADES));
+ firstHand.add(new Card(5, Suit.HEARTS));
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(4), ranks);
+ }
+
+ @Test
+ public void testFlush() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.HEARTS));
+ firstHand.add(new Card(7, Suit.HEARTS));
+ firstHand.add(new Card(3, Suit.HEARTS));
+ firstHand.add(new Card(9, Suit.HEARTS));
+ firstHand.add(new Card(12, Suit.HEARTS));
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(5), ranks);
+ }
+
+ @Test
+ public void testFullHouse() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(1, Suit.HEARTS));
+ firstHand.add(new Card(1, Suit.DIAMONDS));
+ firstHand.add(new Card(2, Suit.SPADES));
+ firstHand.add(new Card(2, Suit.HEARTS));
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(6), ranks);
+ }
+
+ @Test
+ public void testFourOfKind() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(1, Suit.HEARTS));
+ firstHand.add(new Card(1, Suit.DIAMONDS));
+ firstHand.add(new Card(1, Suit.SPADES));
+ firstHand.add(new Card(2, Suit.HEARTS));
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(7), ranks);
+ }
+
+ @Test
+ public void testStraightFlush() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(2, Suit.CLUBS));
+ firstHand.add(new Card(3, Suit.CLUBS));
+ firstHand.add(new Card(4, Suit.CLUBS));
+ firstHand.add(new Card(5, Suit.CLUBS));
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(8), ranks);
+ }
+
+ @Test
+ public void testRoyalFlush() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(10, Suit.CLUBS));
+ firstHand.add(new Card(11, Suit.CLUBS));
+ firstHand.add(new Card(12, Suit.CLUBS));
+ firstHand.add(new Card(13, Suit.CLUBS));
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(9), ranks);
+ }
+
+ @Test
+ public void testUnsortedPair() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(2, Suit.CLUBS));
+ firstHand.add(new Card(9, Suit.HEARTS));
+ firstHand.add(new Card(2, Suit.DIAMONDS));
+ firstHand.add(new Card(13, Suit.SPADES));
+ firstHand.add(new Card(6, Suit.CLUBS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(1), ranks);
+ }
+
+ @Test
+ public void testUnsortedTwoPair() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(2, Suit.CLUBS));
+ firstHand.add(new Card(4, Suit.CLUBS));
+ firstHand.add(new Card(2, Suit.SPADES));
+ firstHand.add(new Card(1, Suit.HEARTS));
+ firstHand.add(new Card(4, Suit.DIAMONDS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(2), ranks);
+ }
+
+ @Test
+ public void testUnsortedThreeOfKind() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(7, Suit.CLUBS));
+ firstHand.add(new Card(4, Suit.DIAMONDS));
+ firstHand.add(new Card(7, Suit.HEARTS));
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(7, Suit.SPADES));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(3), ranks);
+ }
+
+ @Test
+ public void testUnsortedStraight() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(7, Suit.CLUBS));
+ firstHand.add(new Card(4, Suit.HEARTS));
+ firstHand.add(new Card(6, Suit.SPADES));
+ firstHand.add(new Card(8, Suit.DIAMONDS));
+ firstHand.add(new Card(5, Suit.CLUBS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(4), ranks);
+ }
+
+ @Test
+ public void testUnsortedFlush() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(7, Suit.SPADES));
+ firstHand.add(new Card(2, Suit.SPADES));
+ firstHand.add(new Card(6, Suit.SPADES));
+ firstHand.add(new Card(11, Suit.SPADES));
+ firstHand.add(new Card(3, Suit.SPADES));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(5), ranks);
+ }
+
+ @Test
+ public void testUnsortedFullHouse() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(4, Suit.CLUBS));
+ firstHand.add(new Card(8, Suit.HEARTS));
+ firstHand.add(new Card(4, Suit.DIAMONDS));
+ firstHand.add(new Card(8, Suit.SPADES));
+ firstHand.add(new Card(4, Suit.HEARTS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(6), ranks);
+ }
+
+ @Test
+ public void testUnsortedFourOfKind() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(1, Suit.HEARTS));
+ firstHand.add(new Card(2, Suit.DIAMONDS));
+ firstHand.add(new Card(1, Suit.SPADES));
+ firstHand.add(new Card(1, Suit.HEARTS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(7), ranks);
+ }
+
+ @Test
+ public void testUnsortedStraightFlush() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(2, Suit.CLUBS));
+ firstHand.add(new Card(4, Suit.CLUBS));
+ firstHand.add(new Card(3, Suit.CLUBS));
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(5, Suit.CLUBS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(8), ranks);
+ }
+
+ @Test
+ public void testUnsortedRoyalFlush() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(11, Suit.CLUBS));
+ firstHand.add(new Card(13, Suit.CLUBS));
+ firstHand.add(new Card(10, Suit.CLUBS));
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(12, Suit.CLUBS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ assertEquals(Arrays.asList(9), ranks);
+ }
+
+ @Test
+ public void highCardVsHighCard() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<Card> secondHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(11, Suit.CLUBS));
+ firstHand.add(new Card(3, Suit.DIAMONDS));
+ firstHand.add(new Card(8, Suit.SPADES));
+ firstHand.add(new Card(9, Suit.HEARTS));
+ firstHand.add(new Card(5, Suit.CLUBS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ secondHand.add(new Card(1, Suit.CLUBS));
+ secondHand.add(new Card(3, Suit.SPADES));
+ secondHand.add(new Card(9, Suit.SPADES));
+ secondHand.add(new Card(7, Suit.DIAMONDS));
+ secondHand.add(new Card(5, Suit.HEARTS));
+ secondHand = g.sort(secondHand);
+ hands.add(secondHand);
+ ranks.add(g.getRank(secondHand));
+ g.setHands(hands);
+ g.setRanks(ranks);
+ assertEquals(1, g.getWinner());
+ }
+
+ @Test
+ public void highCardVsPair() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<Card> secondHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(11, Suit.CLUBS));
+ firstHand.add(new Card(3, Suit.DIAMONDS));
+ firstHand.add(new Card(8, Suit.SPADES));
+ firstHand.add(new Card(9, Suit.HEARTS));
+ firstHand.add(new Card(5, Suit.CLUBS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ secondHand.add(new Card(4, Suit.CLUBS));
+ secondHand.add(new Card(3, Suit.SPADES));
+ secondHand.add(new Card(9, Suit.SPADES));
+ secondHand.add(new Card(9, Suit.DIAMONDS));
+ secondHand.add(new Card(5, Suit.HEARTS));
+ secondHand = g.sort(secondHand);
+ hands.add(secondHand);
+ ranks.add(g.getRank(secondHand));
+ g.setHands(hands);
+ g.setRanks(ranks);
+ assertEquals(1, g.getWinner());
+ }
+
+ @Test
+ public void pairVsPair() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<Card> secondHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(13, Suit.DIAMONDS));
+ firstHand.add(new Card(5, Suit.SPADES));
+ firstHand.add(new Card(6, Suit.DIAMONDS));
+ firstHand.add(new Card(5, Suit.CLUBS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ secondHand.add(new Card(11, Suit.HEARTS));
+ secondHand.add(new Card(2, Suit.CLUBS));
+ secondHand.add(new Card(12, Suit.HEARTS));
+ secondHand.add(new Card(9, Suit.SPADES));
+ secondHand.add(new Card(12, Suit.CLUBS));
+ secondHand = g.sort(secondHand);
+ hands.add(secondHand);
+ ranks.add(g.getRank(secondHand));
+ g.setHands(hands);
+ g.setRanks(ranks);
+ assertEquals(1, g.getWinner());
+ }
+
+ @Test
+ public void pairVsTwoPair() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<Card> secondHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(11, Suit.CLUBS));
+ firstHand.add(new Card(3, Suit.DIAMONDS));
+ firstHand.add(new Card(8, Suit.SPADES));
+ firstHand.add(new Card(9, Suit.HEARTS));
+ firstHand.add(new Card(8, Suit.CLUBS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ secondHand.add(new Card(4, Suit.CLUBS));
+ secondHand.add(new Card(3, Suit.SPADES));
+ secondHand.add(new Card(9, Suit.SPADES));
+ secondHand.add(new Card(9, Suit.DIAMONDS));
+ secondHand.add(new Card(3, Suit.HEARTS));
+ secondHand = g.sort(secondHand);
+ hands.add(secondHand);
+ ranks.add(g.getRank(secondHand));
+ g.setHands(hands);
+ g.setRanks(ranks);
+ assertEquals(1, g.getWinner());
+ }
+
+ @Test
+ public void twoPairVsTwoPair() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<Card> secondHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(1, Suit.CLUBS));
+ firstHand.add(new Card(8, Suit.SPADES));
+ firstHand.add(new Card(6, Suit.SPADES));
+ firstHand.add(new Card(8, Suit.HEARTS));
+ firstHand.add(new Card(6, Suit.CLUBS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ secondHand.add(new Card(12, Suit.HEARTS));
+ secondHand.add(new Card(9, Suit.CLUBS));
+ secondHand.add(new Card(9, Suit.SPADES));
+ secondHand.add(new Card(2, Suit.SPADES));
+ secondHand.add(new Card(12, Suit.DIAMONDS));
+ secondHand = g.sort(secondHand);
+ hands.add(secondHand);
+ ranks.add(g.getRank(secondHand));
+ g.setHands(hands);
+ g.setRanks(ranks);
+ assertEquals(1, g.getWinner());
+ }
+
+ @Test
+ public void threeOfKindVsThreeOfKind() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<Card> secondHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(11, Suit.CLUBS));
+ firstHand.add(new Card(2, Suit.CLUBS));
+ firstHand.add(new Card(11, Suit.SPADES));
+ firstHand.add(new Card(13, Suit.SPADES));
+ firstHand.add(new Card(11, Suit.DIAMONDS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ secondHand.add(new Card(9, Suit.HEARTS));
+ secondHand.add(new Card(12, Suit.CLUBS));
+ secondHand.add(new Card(8, Suit.HEARTS));
+ secondHand.add(new Card(12, Suit.HEARTS));
+ secondHand.add(new Card(12, Suit.SPADES));
+ secondHand = g.sort(secondHand);
+ hands.add(secondHand);
+ ranks.add(g.getRank(secondHand));
+ g.setHands(hands);
+ g.setRanks(ranks);
+ assertEquals(1, g.getWinner());
+ }
+
+ @Test
+ public void fullHouseVsfullHouse() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<Card> secondHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(11, Suit.CLUBS));
+ firstHand.add(new Card(11, Suit.HEARTS));
+ firstHand.add(new Card(11, Suit.SPADES));
+ firstHand.add(new Card(5, Suit.SPADES));
+ firstHand.add(new Card(5, Suit.DIAMONDS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ secondHand.add(new Card(12, Suit.HEARTS));
+ secondHand.add(new Card(12, Suit.CLUBS));
+ secondHand.add(new Card(8, Suit.HEARTS));
+ secondHand.add(new Card(12, Suit.DIAMONDS));
+ secondHand.add(new Card(8, Suit.SPADES));
+ secondHand = g.sort(secondHand);
+ hands.add(secondHand);
+ ranks.add(g.getRank(secondHand));
+ g.setHands(hands);
+ g.setRanks(ranks);
+ assertEquals(1, g.getWinner());
+ }
+
+ @Test
+ public void fourOfKindVsfourOfKind() {
+ Game g = new Game();
+ List<Card> firstHand = new ArrayList<>();
+ List<Card> secondHand = new ArrayList<>();
+ List<List<Card>> hands = new ArrayList<>();
+ List<Integer> ranks = new ArrayList<>();
+ firstHand.add(new Card(11, Suit.CLUBS));
+ firstHand.add(new Card(11, Suit.HEARTS));
+ firstHand.add(new Card(11, Suit.SPADES));
+ firstHand.add(new Card(13, Suit.SPADES));
+ firstHand.add(new Card(11, Suit.DIAMONDS));
+ firstHand = g.sort(firstHand);
+ hands.add(firstHand);
+ ranks.add(g.getRank(firstHand));
+ secondHand.add(new Card(12, Suit.HEARTS));
+ secondHand.add(new Card(12, Suit.CLUBS));
+ secondHand.add(new Card(8, Suit.HEARTS));
+ secondHand.add(new Card(12, Suit.DIAMONDS));
+ secondHand.add(new Card(12, Suit.SPADES));
+ secondHand = g.sort(secondHand);
+ hands.add(secondHand);
+ ranks.add(g.getRank(secondHand));
+ g.setHands(hands);
+ g.setRanks(ranks);
+ assertEquals(1, g.getWinner());
+ }
+}
diff --git a/card/Card$1.class b/card/Card$1.class
new file mode 100644
index 0000000..2e6a9e7
--- /dev/null
+++ b/card/Card$1.class
Binary files differ
diff --git a/card/Card.class b/card/Card.class
new file mode 100644
index 0000000..89c0106
--- /dev/null
+++ b/card/Card.class
Binary files differ
diff --git a/card/Card.java b/card/Card.java
new file mode 100644
index 0000000..fb42314
--- /dev/null
+++ b/card/Card.java
@@ -0,0 +1,60 @@
+package card;
+
+public class Card {
+ private int value;
+ private Suit suit;
+
+ public Card(int value, Suit suit) {
+ this.value = value;
+ this.suit = suit;
+ }
+
+ public int getValue() {
+ return this.value;
+ }
+
+ public Suit getSuit() {
+ return this.suit;
+ }
+
+ public String displayCard() {
+ String name = "";
+ if (this.value < 1 || this.value > 13) {
+ name += "UNKNOWN";
+ } else if (this.value > 1 && this.value < 11) {
+ name += this.value;
+ } else {
+ switch (this.value) {
+ case 1:
+ name += "ace";
+ break;
+ case 11:
+ name += "jack";
+ break;
+ case 12:
+ name += "queen";
+ break;
+ case 13:
+ name += "king";
+ break;
+ default:
+ name += "UNKNOWN";
+ }
+ }
+ switch (this.suit) {
+ case CLUBS:
+ name += " of clubs";
+ break;
+ case DIAMONDS:
+ name += " of diamonds";
+ break;
+ case HEARTS:
+ name += " of hearts";
+ break;
+ case SPADES:
+ name += " of spades";
+ break;
+ }
+ return name;
+ }
+}
diff --git a/card/Suit.class b/card/Suit.class
new file mode 100644
index 0000000..0450003
--- /dev/null
+++ b/card/Suit.class
Binary files differ
diff --git a/card/Suit.java b/card/Suit.java
new file mode 100644
index 0000000..f31de7e
--- /dev/null
+++ b/card/Suit.java
@@ -0,0 +1,8 @@
+package card;
+
+public enum Suit {
+ CLUBS,
+ DIAMONDS,
+ HEARTS,
+ SPADES
+}
diff --git a/lib/hamcrest-core-1.3.jar b/lib/hamcrest-core-1.3.jar
new file mode 100644
index 0000000..9d5fe16
--- /dev/null
+++ b/lib/hamcrest-core-1.3.jar
Binary files differ
diff --git a/lib/junit-4.13.2.jar b/lib/junit-4.13.2.jar
new file mode 100644
index 0000000..6da55d8
--- /dev/null
+++ b/lib/junit-4.13.2.jar
Binary files differ
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-06 14:20:54 +0000