集合综合练习(斗地主随机洗牌)

package com.zs.Demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class DouDiZhu {
        private static  Map<Integer,String> Pooker;
        private static ArrayList<Integer> Pookervalue;
        private static ArrayList<Integer> play1,play2,play3,dipai;
        DouDiZhu() {
        createPooker();
        ShufflePooker();
        faPooker();
        lookPooker("玩家1",play1);
        lookPooker("玩家2",play2);
        lookPooker("玩家3",play3);
        lookPooker("底牌",dipai);
    }

    private void lookPooker(String s,ArrayList<Integer> play1) {
        System.out.print(s+":");
        for (Integer pookernum : play1) {
            for (Integer index : Pooker.keySet()) {
                if(pookernum==index) {
                    String color = Pooker.get(index);
                    System.out.print(color+"\t");
                }
            }
        }
        System.out.println();
    }

    private void faPooker() {
        //创建三个数组分别代表三位玩家
         play1=new ArrayList<>();
         play2=new ArrayList<>();
         play3=new ArrayList<>();
         dipai=new ArrayList<>();
        int index=54;
        for (Integer pooker : Pookervalue) {
            if (index<=3)
                dipai.add(pooker);
            if(index%3==0)
                play1.add(pooker);
            if (index%3==1)
                play2.add(pooker);
            if (index%3==2)
                play3.add(pooker);
            index--;
        }
//        排序
        Collections.sort(play1);
        Collections.sort(play2);
        Collections.sort(play3);
        Collections.sort(dipai);
    }

    private void ShufflePooker() {
        //定义一个ArrayList集合接收Map集合的值,方便调用shuffle方法,因为只有List集合才能调用shuffle方法
        Pookervalue=new ArrayList<>();
        //遍历Map集合,并将Map集合的值传递给ArrayList集合
        for (Integer it : Pooker.keySet()) {
            Pookervalue.add(it);
        }
        //将ArrayList集合的顺序打乱,也就是洗牌
        Collections.shuffle(Pookervalue);
    }

    private void createPooker() {
        //创造保存扑克的Map集合,键-扑克;54张扑克牌,键为扑克牌号,值为扑克加花色
         Pooker= new HashMap<>();
        //定义扑克牌数字的数组,
        String[] pookerNum={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
        //定义扑克牌花色的数组
        String[] colors={"♥","♠","♣","♦"};
        //给Map集合添加元素大王小王
        Pooker.put(0,"大王");
        Pooker.put(1,"小王");
        //定义普通类牌的序号,从2开始,到53结束,52张普通拍,0,1为大小王;
        int index=2;
        for (String num : pookerNum) {
            for (String color : colors) {
                Pooker.put(index,color+num);
                index++;
            }
        }
        //System.out.println(Pooker);//{2=♥2, 3=♠2, 4=♣2, 5=♦2, 6=♥3, 7=♠3,。。。。50=♥A, 51=♠A, 52=♣A, 53=♦A}}

    }

    public static void main(String[] args) {
        new DouDiZhu();//
    }
   /* 玩家1:♥2    ♣3    ♦3    ♥4    ♣4    ♦4    ♥5    ♠5    ♦7    ♥9    ♠10    ♣10    ♥J    ♠J    ♣J    ♠Q    ♥K    ♥A
    玩家2:大王    小王    ♣2    ♦2    ♥3    ♣5    ♦5    ♥6    ♦6    ♥7    ♠7    ♥8    ♣9    ♣Q    ♦Q    ♠K    ♣K    ♦A
    玩家3:♠2    ♠3    ♠4    ♠6    ♣6    ♣7    ♠8    ♣8    ♦8    ♠9    ♦9    ♥10    ♦10    ♦J    ♥Q    ♦K    ♠A    ♣A
    底牌:♦7    ♣Q    ♠A    结果是随机的每次都不一样*/
}

原文地址:https://www.cnblogs.com/Zs-book1/p/10584150.html

时间: 2024-10-08 01:47:00

集合综合练习(斗地主随机洗牌)的相关文章

ArrayList模拟斗地主的洗牌,发牌和看牌

/* * ArrayList模拟斗地主的洗牌,发牌和看牌 * * 分析: * 1.创建一个牌盒 * 2.装牌 * 3.洗牌 * 4.发牌 * 5.看牌 */ 代码: import java.util.ArrayList; import java.util.Collections; /** * ArrayList模拟斗地主的洗牌,发牌和看牌 * @author TP * */ public class Doudizhu { /* * ArrayList模拟斗地主的洗牌,发牌和看牌 * * 分析:

写一个随机洗牌函数——概率题

题目描述: 写一个随机洗牌函数.要求洗出的52!种组合都是等概率的. 也就是你洗出的一种组合的概率是1/(52!).假设已经给你一个完美的随机数发生器. 解题思路: 这是一道概率题 随机洗牌,目的是要做到随机性,要求每一张牌出现的概率要相等. 我们常用的普通扑克牌54张,要做到每张牌出现的概率是1/(54!), 抽第一张牌概率:1/54: 抽第二张牌概率:1/53: 抽第三张牌概率:1/52: -- 一直这样随机地拿下去直到拿完最后1张,我们就从52!种可能中取出了一种排列, 这个排列对应的概率

随机洗牌算法

随机洗牌算法: 时间和空间复杂度都为O(n). 1 #include <bits/stdc++.h> 2 3 using namespace std; 4 5 const int maxn = 54; 6 7 void random_shuffle(vector<int> &a) 8 { 9 srand(int(time(0))); 10 int aSize = a.size(); 11 for(int i = 1; i != aSize; ++i) { 12 int j

随机洗牌算法Knuth Shuffle和错排公式

Knuth随机洗牌算法:譬如现在有54张牌,如何洗牌才能保证随机性.可以这么考虑,从最末尾一张牌开始洗,对于每一张牌,编号在该牌前面的牌中任意一张选一张和当前牌进行交换,直至洗到第一张牌为止.参考代码如下: void knuth() { for (int i = 54; i > 1; i--) { int id = rand() % (i - 1) + 1; swap(a[i], a[id]); } } 由上述方法可知,每一张牌经过洗牌之后一定不会出现在原来位置,那么一共会有多少情况呢,这其实就

Java学习笔记34(集合框架八:综合案例:模拟斗地主的洗牌发牌)

规则: 1.54张扑克牌,有花色 2.顺序打乱,一人一张依次发牌,一人17张,留三张作为底牌 3.看牌:按大小王2A....43的序排列打印 示例: package demo; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; public class DouDiZhu { public static void main(String[] args) { // 创建Map集合,键

一个数组实现扑克牌均匀随机洗牌------多次洗牌能否避免黑客的计算?

闲来无事,研究下纸牌发牌,按斗地主来发吧,思路如下: 1,新建一个数组,长度52,将四种花色和大小王存储进数组 2,循环0至51,在循环因子i至52之间取随机数(能取到下界,不能取到上界),取到的随机数作为数组元素下标取该元素,与第i个元素交换位置,循环结束即排序完毕 3,输出纸牌即可. 思路明确,"啪啪啪~~" 12秒之后 贴上代码 1初始化数组 //声明存放纸牌的数组 string[] Card = new string[54]; //初始化四种花色和大小王,分别用▲★◆■+数字和

随机洗牌

一.随机数洗牌 //pArray 要打乱的数组 //uCount 数组长度 //uItemSize 数组中每个元素的大小 void CGameConvenient::Shuffle(void *pArray,ushort uCount,ushort uItemSize) { if(nCount<=1) return; //记录下标 std::vector<ushort> IndexArray;  //原数组 IndexArray.resize(uCount); for(ushort i=

如何随机洗牌一个数组

在使用javascript的时候有可能会有随机打乱一个数组的需求,我们可以利用数组的sort方法和Math.random来随机排序 const arr = [1,2,3]; arr.sort(() => 0.5 - Math.random()) console.log(arr) 主要利用了Math.random()生成随机数与0.5的大小比较来排序,如果0.5 - Math.random()大于或等于0,数组中的两个数位置不变,小于0就交换位置. 乍一看这样是达到了随机排序的效果,但是实际上这个

随机洗牌算法---我们一起谈谈

看到这个问题是在知乎上, 一个回答: 实现一下 #include <iostream> #include <vector> #include <string> #include <algorithm> using namespace std; const int RAND_MAXNUM = 100; int bigRand() { return RAND_MAXNUM*rand() + rand(); } int randIn(int l, int u) {