Shuffling JAVA Write an object oriented program with the following classes. ===
ID: 3795382 • Letter: S
Question
Shuffling JAVA
Write an object oriented program with the following classes.
=== Deck ===
The Deck class represents a standard 52-card deck; Ace high
Each card is in one of two states -- dealt (D) and not-yet-dealt (ND)
Cards are ordered. The D and ND cards each have their own order
When created, all 52 cards are ND, and are in order, by suit (clubs 2 through A, diamonds 2 through A, hearts 2 through A, spades 2 through A)
methods:
dealOne() -- moves the top card from ND to D and returns the card
print() -- prints non-dealt cards and dealt-cards (in order, as separate lists)
shuffle(goodness) -- goodness is a floating point number between 0 and 1.
Goodness of 0 is perfect shuffle (cards are in a completely random order). Goodness of 1 is no shuffling (deck is unchanged). As you change goodness from 0 to 1 the shuffle gets progressively worse. You can make up your own shuffle algorithm. Include a description of your shuffle algorithm in the README file.
=== Card ===
The Card class represents a single card
methods:
print() -- prints the type of card
=== Hand ===
The Hand class represents a set of cards. From 0 to 52 cards, total
Cards are always in a definite order
methods:
print() -- prints the hand (in order)
addCard(card) -- adds a card to the hand
sortBySuit() -- sorts the cards by suit, and then by value
sortByValue() -- sorts by value, then by suit
hasStraight(len, sameSuit) -- returns true if hand contains a straight of the given length. If sameSuit is true, counts only straight with cards in the same suit (flushes); If sameSuit if not true, any straight is counted. A "straight" is simply when you have cards of consecutive values. For ex: A 3-card straight with sameSuit = false. The three cards may be of different suits, and it still counts as a 3-card straight if there are more than three consecutive cards. This hand has a 3-card straight:
4 of clubs, 5 of spades, 6 of diamonds 7 of clubs, K of clubs
This hand does not:
4 of clubs, 5 of clubs, 7 of clubs, 8 of spades, K of clubs
Write a test program called CardDealer.java that takes three commandline arguments <number of runs> <number of players> <goodness>
for ex: java CardDealer 100 5 0.5
will run the following steps 100 times
1. Create a deck of cards
2. Shuffle using the goodness factor
3. Deal 5 hands (going in order player1, player2, ... player5, player1....etc)
4. Count the number of 3 card straights.
After 100 runs, compute the chances of getting a 3 card straight (this is defined as <number of 3 card straights>/<total number of hands>). For this run total number of hands will be 500.
Run your program for goodness values of (0, 0.3, 0.5, 1, 0.9). Tabulate your results in the README file.
Explanation / Answer
//Deck Class
class Deck {
private String[] SUITS = {
"Clubs", "Diamonds", "Hearts", "Spades"
};
private String[] RANKS = {
"2", "3", "4", "5", "6", "7", "8", "9", "10",
"Jack", "Queen", "King", "Ace"
};
private int dealtCounter;
// initialize deck
private int n = SUITS.length * RANKS.length;
private int []D = new int[52]; // D = 1 then dealt D = 0 then no-dealt
public Card[] deck = new Card[52];;
public Deck()
{
int cardCt = 0; // How many cards have been created so far.
for ( int suit = 0; suit <= 3; suit++ ) {
for ( int value = 1; value <= 13; value++ ) {
deck[cardCt] = new Card(value,suit);
D[cardCt] = 0;
cardCt++;
}
}
dealtCounter = 0;
}
// shuffle
public void shuffle(double goodness)
{
for (int i = 0; i < n; i++) {
int r = i + (int) (Math.random() * (goodness));
Card temp = deck[r];
deck[r] = deck[i];
deck[i] = temp;
}
}
public Card dealOne() {
if (dealtCounter == deck.length)
throw new IllegalStateException("No cards are left in the deck.");
dealtCounter++;
return deck[dealtCounter - 1];
}
// print shuffled deck
public void print(){
for (int i = 0; i < n; i++) {
System.out.println(deck[i]);
}
}
}
-----------------------------------------------------------------------------------------------------------------------
//Card Class
/*
An object of class card represents one of the 52 cards in a
standard deck of playing cards. Each card has a suit and
a value.
*/
public class Card {
public final static int SPADES = 0, // Codes for the 4 suits.
HEARTS = 1,
DIAMONDS = 2,
CLUBS = 3;
public final static int ACE = 1, // Codes for the non-numeric cards.
JACK = 11, // Cards 2 through 10 have their
QUEEN = 12, // numerical values for their codes.
KING = 13;
private final int suit; // The suit of this card, one of the constants
// SPADES, HEARTS, DIAMONDS, CLUBS.
private final int value; // The value of this card, from 1 to 11.
public Card(int theValue, int theSuit) {
// Construct a card with the specified value and suit.
// Value must be between 1 and 13. Suit must be between
// 0 and 3. If the parameters are outside these ranges,
// the constructed card object will be invalid.
value = theValue;
suit = theSuit;
}
public int getSuit() {
// Return the int that codes for this card's suit.
return suit;
}
public int getValue() {
// Return the int that codes for this card's value.
return value;
}
public String getSuitAsString() {
// Return a String representing the card's suit.
// (If the card's suit is invalid, "??" is returned.)
switch ( suit ) {
case SPADES: return "Spades";
case HEARTS: return "Hearts";
case DIAMONDS: return "Diamonds";
case CLUBS: return "Clubs";
default: return "??";
}
}
public String getValueAsString() {
// Return a String representing the card's value.
// If the card's value is invalid, "??" is returned.
switch ( value ) {
case 1: return "Ace";
case 2: return "2";
case 3: return "3";
case 4: return "4";
case 5: return "5";
case 6: return "6";
case 7: return "7";
case 8: return "8";
case 9: return "9";
case 10: return "10";
case 11: return "Jack";
case 12: return "Queen";
case 13: return "King";
default: return "??";
}
}
public String toString() {
// Return a String representation of this card, such as
// "10 of Hearts" or "Queen of Spades".
return getValueAsString() + " of " + getSuitAsString();
}
public void printCardType() {
System.out.println("Type of card "+ getSuitAsString());
}
} // end class Card
---------------------------------------------------------------------------------------------------------------
//Hand class
/**
* An object of type Hand represents a hand of cards. The
* cards belong to the class Card. A hand is empty when it
* is created, and any number of cards can be added to it.
*/
import java.util.ArrayList;
public class Hand {
private ArrayList<Card> hand; // The cards in the hand.
/**
* Create a hand that is initially empty.
*/
public Hand() {
hand = new ArrayList<Card>();
}
/**
* Remove all cards from the hand, leaving it empty.
*/
public void clear() {
hand.clear();
}
//print hand
public void print() {
for (int i = 0; i < hand.size(); i++) {
System.out.println(hand.get(i));
}
}
/**
* Add a card to the hand. It is added at the end of the current hand.
* @param c the non-null card to be added.
* @throws NullPointerException if the parameter c is null.
*/
public void addCard(Card c) {
if (c == null)
throw new NullPointerException("Can't add a null card to a hand.");
hand.add(c);
}
/**
* Remove a card from the hand, if present.
* @param c the card to be removed. If c is null or if the card is not in
* the hand, then nothing is done.
*/
public void removeCard(Card c) {
hand.remove(c);
}
/**
* Remove the card in a specified position from the hand.
* @param position the position of the card that is to be removed, where
* positions are starting from zero.
* @throws IllegalArgumentException if the position does not exist in
* the hand, that is if the position is less than 0 or greater than
* or equal to the number of cards in the hand.
*/
public void removeCard(int position) {
if (position < 0 || position >= hand.size())
throw new IllegalArgumentException("Position does not exist in hand: "
+ position);
hand.remove(position);
}
/**
* Returns the number of cards in the hand.
*/
public int getCardCount() {
return hand.size();
}
/**
* Gets the card in a specified position in the hand. (Note that this card
* is not removed from the hand!)
* @param position the position of the card that is to be returned
* @throws IllegalArgumentException if position does not exist in the hand
*/
public Card getCard(int position) {
if (position < 0 || position >= hand.size())
throw new IllegalArgumentException("Position does not exist in hand: "
+ position);
return hand.get(position);
}
/**
* Sorts the cards in the hand so that cards of the same suit are
* grouped together, and within a suit the cards are sorted by value.
* Note that aces are considered to have the lowest value, 1.
*/
public void sortBySuit() {
ArrayList<Card> newHand = new ArrayList<Card>();
while (hand.size() > 0) {
int pos = 0; // Position of minimal card.
Card c = hand.get(0); // Minimal card.
for (int i = 1; i < hand.size(); i++) {
Card c1 = hand.get(i);
if ( c1.getSuit() < c.getSuit() ||
(c1.getSuit() == c.getSuit() && c1.getValue() < c.getValue()) ) {
pos = i;
c = c1;
}
}
hand.remove(pos);
newHand.add(c);
}
hand = newHand;
}
/**
* Sorts the cards in the hand so that cards of the same value are
* grouped together. Cards with the same value are sorted by suit.
* Note that aces are considered to have the lowest value, 1.
*/
public void sortByValue() {
ArrayList<Card> newHand = new ArrayList<Card>();
while (hand.size() > 0) {
int pos = 0; // Position of minimal card.
Card c = hand.get(0); // Minimal card.
for (int i = 1; i < hand.size(); i++) {
Card c1 = hand.get(i);
if ( c1.getValue() < c.getValue() ||
(c1.getValue() == c.getValue() && c1.getSuit() < c.getSuit()) ) {
pos = i;
c = c1;
}
}
hand.remove(pos);
newHand.add(c);
}
hand = newHand;
}
public boolean hasStraight(int len, boolean sameSuit) {
if(sameSuit) {
if(hand.size() < len)
return false;
else{
for(int i=0;i<hand.size()-2;i++) {
int suit = hand.get(i).getSuit();
int j;
for(j=i+1;j<2;j++) {
if(hand.get(j).getSuit() != suit)
break;
}
if(j==2)
return true;
}
return false;
}
}
else {
for(int i=0;i<hand.size()-2;i++) {
int value = hand.get(i).getValue();
int j;
for(j=i+1;j<2;j++) {
if(hand.get(j).getValue() != value + 1)
break;
else
value++;
}
if(j==2)
return true;
}
return false;
}
}
}
-----------------------------------------------------------------------------------------------------------------------------
//CardDealer class
import java.util.Scanner;
public class CardDealer {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int noOfRun=sc.nextInt();
int noOfPlayers=sc.nextInt();
double goodness=sc.nextDouble();
int N=noOfRun;
int M=noOfPlayers;
int totalHands = M*N;
Hand hands[] = new Hand[noOfPlayers];
while(noOfRun > 0) {
Deck deck = new Deck(); //create Deck of cards
deck.shuffle(goodness); //deck based on goodness factor
int i=0;
while(noOfPlayers > 0)
{
hands[i] = new Hand();
hands[i].addCard(deck.deck[(int)Math.random()%52]);
Card c = deck.dealOne();
i++;
noOfPlayers--;
}
noOfRun--;
}
int count =0;
for(int i=0;i<5;i++)
{
if(hands[i].hasStraight(3,false))
count++;
}
System.out.println("chances of getting a 3 card straight: "+ count/totalHands);
}
} // end class CardDealer
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.