魔術師發牌問題的java實現,魔術師發牌問題圖解

本文目錄一覽：

• 1、JAVA鬥地主如何實現發牌和出牌功能
• 2、java 52張 撲克牌 問題
• 3、撲克牌實現洗牌發牌，顯示各家手上的牌並統計各家的牌中有幾組對子，幾組三條（例如三個A），幾組同花
• 4、java52張撲克牌問題
• 5、用java程序編寫一個發牌的程序。。。跪求了。。。。

JAVA鬥地主如何實現發牌和出牌功能

用隨機的方式生成54張牌（即數字或者其他方式），按順時針方向，依次給每個人一個數字。直到剩最後三張。

出牌：先判斷出牌方選中的牌是否符合規則。是的話。則該人的數值列表中去掉相應的牌。桌面上顯示它出示的牌。出完牌還得判斷遊戲是否結束。如果他的牌下完了。遊戲就結束了

java 52張 撲克牌 問題

識別類：

一張牌：public class Card{};

一副牌：public class Poker{};

帶main方法的類用於實現洗牌和切牌：public class Shuffle{};

識別屬性：

class Card:

一張牌應該具有花色和點數這兩個屬性：

private color; //花色

private value; //點數

class Poker:

一副牌有54張牌，四種花色，每種花色都有2~A的點數：

static Card[] cards=new Card[54]；// 每副撲克都有54張牌；

static String[] colors={“紅桃”,”黑桃”,”方塊”,”梅花”}； //每副牌都有四種花色；

static String values[]={“2″,”3″,”4″,”5″,”6″,”7″,”8″,”9″,”10″,”J”,”Q”,”K”,”A”};//每個花

色的點數

定義類：

public class Card{

String color;

String value;

//定義一個構造函數用於初始化點數2~A的牌

public Card(String color,String value){

this.color = color;

this.value = value;

}

//定義一個構造函數用於初始化大王和小王

public Card(String value){

this.color=””; //如果不給color賦值的話，洗牌和切牌後的大小王前面會顯示“null”

this.value = value;

}

// 取一張牌的花色

public String getcolor() {

return color;

}

// 取一張牌的值

public String getvalue() {

return value;

}

}

public class Poker{

static Card[] cards=new Card[54];

static String[] colors={“紅桃”,”黑桃”,”方塊”,”梅花”};

static String values[]={“2″,”3″,”4″,”5″,”6″,”7″,”8″,”9″,”10″,”J”,”Q”,”K”,”A”};

//構造方法Poker（）用於初始化這副撲克

public Poker() {

for (int i = 0; i colors.length; i++) {

for (int j = 0; j values.length; j++) {

cards[i * 13 + j] = new Card(colors[i], values[j]);

}

}

cards[52] = new Card(“小王”);

cards[53] = new Card(“大王”);

}

//方法getCard()用於獲取一張牌的花色和點數

public Card[] getCard() {

return Poker.cards;

}

//方法Show()用於顯示一副新的撲克

public void Show() {

……………………

}

public class Shuffle {

static Poker poker = new Poker();

static Card[] cards = new Card[54];

//方法random用於返回一個不重複的數組

public static int[] random(int length) {

int[] a = new int[length];

for (int i = 0; i length; i++) {

a[i] = (int) (Math.random() * length);//產生一個0到length的隨機數

for (int j = 0; j i; j++) {

if (a[j] == a[i]) {//比較是否相等，如果相等則重新產生

i–;

break;

}

}

}

return a;

}

//方法xipai（）用於將所得的隨機數組的值賦值給牌的下標

public static void xipai() {

int[] b = new int[54];

b = random(54);//調用random方法產生一個長度為54的不重複的隨機數組

cards = poker.getCard();

Card temp = null;

for(int i = 0; i b.length; i++){ //開始遍曆數組實現重新排列

int k = b[i];

temp = cards[k];

cards[i] = cards[k];

cards[k] = temp;}

//輸出洗牌後的撲克

……………………

……………………

}

//方法qiepai（）實現撲克的切牌操作

public static void qiepai(int length) {

int number = (int) (Math.random() * length);//產生一個隨機數

System.out.println(“隨機數為:” + number);//顯示隨機數是多少

Card[] temp = new Card[length];

int start = number;//設置切牌後的起點位置

for (int i = 0; i length – number; i++) {

temp[i] = cards[start++];//將切點後面的牌暫時放入temp數組中

}

for (int j = 0; j number; j++) {

temp[length – number + j] = cards[j];//將切點前面的牌加入temp數組中

}

for (int k = 0; k length; k++) {

cards[k] = temp[k];}

//輸出切牌後的撲克

……………………

……………………

}

//main方法

public static void main(String[] args) {

Poker newpoker = new Poker();

newpoker.Show();//調用Show()方法顯示一副新撲克

xipai();//調用xipai()方法顯示洗牌過後的撲克

qiepai(54);//調用qiepai()方法顯示切牌以後的撲克

}

}

參考資料：

撲克牌實現洗牌發牌，顯示各家手上的牌並統計各家的牌中有幾組對子，幾組三條（例如三個A），幾組同花

1500行。。。。搞笑。200行左右。

這個對對子的處理，存在一個問題，就是有一個三條的存在，那麼該算成是幾對呢？

 按排列算法的話，是一共有三對，在這裡只算出了兩對，想要算出三對，會麻煩一些。

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.List;

import java.util.Random;

public class Cards {

public static void main(String[] args) {

ListCard list = new ArrayListCard();

for (int i = 0; i 4; i++) {

for (int j = 1; j = 13; j++) {

Card card = new Card();

card.type = i;

card.serial = j;

card.execute();

list.add(card);

}

}

//

Card[] west = licensing(list, 13);

Card[] east = licensing(list, 13);

Card[] north = licensing(list, 13);

Card[] south = licensing(list, 13);

System.out.println(“玩家[west]手中的牌是” + Arrays.toString(west));

System.out.println(“玩家[east]手中的牌是” + Arrays.toString(east));

System.out.println(“玩家[north]手中的牌是” + Arrays.toString(north));

System.out.println(“玩家[south]手中的牌是” + Arrays.toString(south));

assort(west, “west”);

assort(east, “east”);

assort(north, “north”);

assort(south, “south”);

}

// 發牌，隨機取出，相當於洗牌

public static Card[] licensing(ListCard list, int len) {

Random random = new Random();

Card[] cards = new Card[len];

int cardIndex = 0;

for (int i = 0; i len; i++) {

int index = random.nextInt(list.size());

cards[cardIndex++] = list.remove(index);

}

// 排序

Arrays.sort(cards, new ComparatorCard() {

@Override

public int compare(Card o1, Card o2) {

if (o1.type != o2.type) {

return o1.type – o2.type;

}

return o1.serial – o2.serial;

}

});

return cards;

}

public static void assort(Card[] cards, String username) {

System.out.print(“玩家[” + username + “]”);

ListCard[] towList = new ArrayListCard[]();

ListCard[] threeList = new ArrayListCard[]();

Card[] tow = null;

Card[] three = null;

for (int i = 0; i cards.length – 1; i++) {

tow = new Card[2];

three = new Card[3];

tow[0] = cards[i];

three[0] = cards[i];

for (int j = i + 1; j cards.length; j++) {

if (cards[i].type == cards[j].type) {

continue;

}

if (cards[i].serial == cards[j].serial) {

tow[1] = cards[j];

towList.add(tow);

three[1] = cards[j];

for (int k = 0; k cards.length; k++) {

if (three[0].type == cards[k].type

|| three[1].type == cards[k].type) {

continue;

}

if (three[1].serial == cards[k].serial) {

three[2] = cards[k];

threeList.add(three);

}

}

break;

}

}

}

ListCard[] flower = new ArrayListCard[]();

// 三張連續的即為同花

for (int i = 0; i cards.length – 2; i++) {

three = new Card[3];

three[0] = cards[i];

three[1] = cards[i + 1];

three[2] = cards[i + 2];

if (three[0].type != three[1].type

|| three[2].type != three[1].type) {

continue;

}

if (three[1].serial – three[0].serial != 1

|| three[2].serial – three[1].serial != 1) {

continue;

}

flower.add(three);

}

System.out.println();

System.out.print(“\t有對子” + towList.size() + “組”);

outList(towList);

System.out.println();

System.out.print(“\t有三條” + threeList.size() + “組”);

outList(threeList);

System.out.println();

System.out.print(“\t有同花” + threeList.size() + “組”);

outList(flower);

System.out.println();

}

public static void outList(ListCard[] list) {

for (int i = 0; i list.size(); i++) {

Card[] cards = list.get(i);

System.out.print(Arrays.toString(cards));

}

}

}

class Card {

String[] types = { “黑桃”, “紅桃”, “梅花”, “方塊” };

int type = 0;

int serial = 0;

String name = null;

public void execute() {

name = types[type];

switch (serial) {

case 1:

name += “A”;

break;

case 11:

name += “J”;

break;

case 12:

name += “Q”;

break;

case 13:

name += “K”;

break;

default:

name += serial;

break;

}

}

public String toString() {

return name;

}

}

java52張撲克牌問題

使用JAVA編寫以下程序：

1、請定義一個名為Card的撲克牌類，該類有兩個private訪問權限的字符串變量face和suit；分別描述一張牌的牌面值（如：A、K、Q、J、10、9、……3、2等）和花色（如：“黑桃”、“紅桃”、“梅花”、“方塊”）；定義Card類中的public訪問權限的構造方法，為類中的變量賦值；定義protected訪問權限的方法getFace()，得到撲克牌的牌面值；定義protected訪問權限的方法getSuit()，得到撲克牌的花色；定義方法toString()，返回表示撲克牌的花色和牌面值字符串（如“紅桃A”、“梅花10”等）。

2、若應用程序的main方法中，定義字符串數組f和s；分別表示撲克牌的牌面值和花色；定義52個元素的Card類型數組deck，用來存放4個花色的52張牌。如下所示。

String f[] = {“A”,”2″,”3″,”4″,”5″,”6″,”7″,”8″,”9″,”10″,”J”,”Q”,”K”};

String s[] = {“黑桃”,”紅桃”,”梅花”,”方塊”};

Card deck = new Card[52]；

（1）使用Card類的構造方法給deck數組的52張牌賦值，要求數組中先存放黑桃花色的A、2、3、……、K；然後是紅桃花色的A、2、3、……、K；梅花花色的A、2、3、……、K；方塊花色的A、2、3、……、K。請寫出實現上述功能的程序段。

（2）請編寫模擬洗牌的完整程序，即把數組deck中的撲克牌隨機打亂存放順序。

原題如下：

引用內容

private String face; // A, K, Q, J, 10, … 2

private String suit; // Spade, Heart, Club, Diamond

public Card(String suit, String face) {

this.face = face;

this.suit = suit;

}

protected String getFace() {

return face;

}

protected String getSuit() {

return suit;

}

public String toString() {

return suit + ” ” + face;

}

解題，完成程序解：

程序代碼

package poker;

public class Card {

private String face; // A, K, Q, J, 10, … 2

private String suit; // Spade, Heart, Club, Diamond

public Card(String suit, String face) {

this.face = face;

this.suit = suit;

}

protected String getFace() {

return face;

}

protected String getSuit() {

return suit;

}

public String toString() {

return suit + ” ” + face;

}

public static void shuffle(Card[] deck, int startIndex, int size,

int splitIndex) { //shuffle洗牌

System.out.println(“startIndex:” + startIndex);

if (splitIndex * 2 size) { //if rand is 30

Card.swap(deck, startIndex, splitIndex, size – splitIndex); //[52]、0、30、22

shuffle(deck, size – splitIndex, splitIndex, size – splitIndex); //[52]、22、30、22

} else if (splitIndex * 2 size) { //if rnd is 10

Card.swap(deck, startIndex, size – splitIndex, splitIndex); //[52]、0、42、10

shuffle(deck, startIndex, size – splitIndex, splitIndex); //[52]、0、42、10

} else {

Card.swap(deck, startIndex, splitIndex, splitIndex);

}

}

public static void swap(Card[] deck, int srcIndex, int dstIndex, int size) { //交換

//SRC是在本位置顯示：source的縮寫，源的意思 HREF是點擊後連接的目標：HyperlinkReference，超鏈接引用

String face = “”;

String suit = “”;

for (int i = 0; i size; i++) {

face = deck[srcIndex + i].face;

suit = deck[srcIndex + i].suit;

deck[srcIndex + i].face = deck[dstIndex + i].face;

deck[srcIndex + i].suit = deck[dstIndex + i].suit;

deck[dstIndex + i].face = face;

deck[dstIndex + i].suit = suit;

}

}

/**

* @param args

*/

public static void main(String[] args) {

//第一問解答

Card[] deck = new Card[52];

String f[] = {“A”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”, “J”,

“Q”, “K”};

String s[] = {“Spade”, “Heart”, “Club”, “Diamond”};

for (int i = 0; i s.length; i++) {

for (int j = 0; j f.length; j++) {

deck[i * 13 + j] = new Card(s[i], f[j]); //依次存入數組之中，每13張一回合

}

}

//第二問解答

int rnd = 0;

int numOfShuffle = 10;

for (int i = 0; i numOfShuffle; i++) {

rnd = (int) Math.abs(Math.random() * 52); //Math.random()返回大於或等於 0.0 但小於 1.0 的偽隨機 double 值。

Card.shuffle(deck, 0, deck.length, rnd);

}

// Test

/*

for (int i=0; ideck.length; i++)

{

System.out.println(deck[i]);

} */

}

}

用java程序編寫一個發牌的程序。。。跪求了。。。。

1、設計二維數組a[13][4],13代表2,3,4,5,…,K,A ， 4代表紅黑方梅 13*4=52

2、這樣a[0][0]就是紅桃2，a[12][3]就是梅花A

按照這麼來隨機發牌就很簡單了，直接隨機個一個a[i][j]就可以了。i和j都分別在13和4以內

思路明確了，代碼還是自己寫比較好