扑克牌的排序版本(制造扑克牌,发牌)

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

public class practice01 {
public static void main(String[] args) {
//封装扑克牌,四种花色
String[] colors={"?","?","?","?"};
String[] nums={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
//定义一个Map来装扑克牌,键是用来存储54张扑克牌对应的序号,值就是扑克牌的牌面
Map<Integer,String> pokerMap=new HashMap<>();
//来装扑克牌的54个序号
List<Integer> indexList=new ArrayList<>();
int index=1;
//用的是数字排序,所以必须把nums放在外层;如果用花色排序,则把colors放在外层
for (String n : nums) {
for(String c:colors){
pokerMap.put(index, c+n);
indexList.add(index);
index++;
}
}

//封装大小王,上一步完成之后,index=53
pokerMap.put(index, "小王");
indexList.add(index);
index++;
pokerMap.put(index, "大王");
indexList.add(index);
//洗扑克牌,集合工具类的方法
Collections.shuffle(indexList);
//发牌,用数组来装序号的数字,序号大于51的三张扑克牌作为底牌
List<Integer> user1=new ArrayList<>();
List<Integer> user2=new ArrayList<>();
List<Integer> user3=new ArrayList<>();
List<Integer> dipai=new ArrayList<>();
//根据取模3的余数来分配给玩家对应的扑克牌
for (int i = 0; i < indexList.size(); i++) {
if(i>=indexList.size()-3){
dipai.add(indexList.get(i));
}else if(i % 3==0){
user1.add(indexList.get(i));
}else if(i % 3==1){
user2.add(indexList.get(i));
}else if(i % 3==2){
user3.add(indexList.get(i));
}
}
//排序,每个玩家的扑克牌分别排序
Collections.sort(user1);
Collections.sort(user2);
Collections.sort(user3);
Collections.sort(dipai);
//看牌,用户的序号作为map的键找出与之对应的值
System.out.println("卡特的牌:");
printSee(pokerMap,user1);
System.out.println("盖伦的牌:");
printSee(pokerMap,user2);
System.out.println("剑圣的牌:");
printSee(pokerMap,user3);
System.out.println("底牌牌:");
printSee(pokerMap,dipai);
}

//写一个方法来看牌,降低代码的冗余性
private static void printSee(Map<Integer, String> map, List<Integer> user) {
//创建字符串容器,拼接每个玩家的扑克牌
StringBuilder bul=new StringBuilder("[");
for(int i=0;i<user.size();i++){
if(i<user.size()-1){
bul.append(map.get(user.get(i))).append(",");
}else{
bul.append(map.get(user.get(i))).append("]");
}
}
//转换成字符串方式
System.out.println(bul.toString());
}
}

原文地址:https://www.cnblogs.com/horse123/p/8535368.html

时间: 2024-11-12 21:36:20

扑克牌的排序版本(制造扑克牌,发牌)的相关文章

扑克牌的排序

问题描述: LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿!!“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13.上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”

内部排序-&gt;基数排序-&gt;链式基数排序

文字描述 基数排序是和前面各类排序方法完全不相同,前面几篇文章介绍的排序算法的实现主要是通过关键字间的比较和移动记录这两种操作,而实现基数排序不需要进行记录关键字间的比较.基数排序是一种借助多关键字排序的思想对单逻辑关键字进行排序的方法.先介绍下什么是多关键字排序,以引入链式基数排序算法. 先介绍什么是多关键字排序: 比如,对扑克牌进行排序,每张扑克牌有两个"关键字":花色(梅花<方块<红桃<黑桃)和面值(2<3<,-,A),且"花色"

JavaScript一个简易枚举类型实现扑克牌

<script type="text/javascript"> /** * 这个函数创建一个新的枚举类型,实参对象表示类的每个实例的名字和值 * 返回值是一个构造函数,它标识这个新类 * 注意,这个构造函数也会抛出异常,不能使用它来创建该类型的新实例 * 返回的构造函数包含名/值对的映射表 * 包括由值组成的数组,以及以个foreach()迭代器函数 */ function enumeration(namesToValues){ //这个虚拟的构造函数式返回值 var en

js运动框架之掉落的扑克牌(重心、弹起效果)

玩过电脑自带纸牌游戏的同志们应该都知道,游戏过关后扑克牌会依次从上空掉落,落下后又弹起,直至"滚出"屏幕. 效果如图:    这个案例的具体效果就是:点击开始运动,纸牌会从右上角掉落下来,之后弹起,运动的速度会逐渐减慢,直到越出屏幕后,全部纸牌消失,在右上角会重新出现一张纸牌,继续动作,一再往复. 具体代码如下: 1 <!DOCTYPE html> 2 <html> 3 <head lang="en"> 4 <meta ch

AOJ 491.扑克牌

Time Limit: 1000 ms   Case Time Limit: 1000 ms   Memory Limit: 64 MBTotal Submission: 54   Submission Accepted: 24 Description 扑克牌大家非常熟悉,扑克牌从小到大的顺序为:3,4,5,6,7,8,9,10,J,Q,K,A,2我们就做个简单的事,单张扑克牌比大小,并且还没有花色区别,也没有大小王. Input 第1行:一个整数T(T<=20),代表测试数据的组数.第2到T+

模拟斗地主洗牌发牌

(一)案例介绍: 按照斗地主的规则,完成洗牌发牌的动作. 具体规则: 1.组装54张扑克牌 2.将54张扑克牌的顺序打乱 3.三个玩家参与游戏,三人交替摸牌,没人17张牌,最后三张留作底牌. 4.查看三人各自手中的牌(按照牌的大小排序).底牌 手中扑克牌从大到小的摆放顺序:大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3 (二)案例需求分析 1.准备牌 完成数字与牌的映射关系 使用双列Map(HashMap)集合,完成一个数字与字符串字牌的对应关系(相当于一个字典). 2.洗牌

斗地主发牌程序

//洗牌函数 shuffle() 接收一个数组 let shuffle = function(pokers){ for(let i=0;i<pokers.length;i++) { let random = parseInt(Math.floor(Math.random()*54));//随机生成54张牌的一个随机数 //两张牌进行交换 let temp = pokers[i]; pokers[i] = pokers[random]; pokers[random] = temp; } } //对

数据结构学习笔记06排序 (快速排序、表排序)

1.快速排序 不稳定 分而治之 找主元pivot,小于主元划分为一个子集,大于主元的划分为一个子集 然后进行递归 最好情况:每次主元正好中分,T(N) = O( NlogN ) 选主元 的方法有很多,这里用 取头.中.尾的中位数. 直接选A[0]为pivot,时间复杂度T ( N ) = O( N ) + T ( N–1 ) = O( N ) + O ( N–1 ) + T( N–2 ) = = O( N ) + O ( N–1 ) + …+ O( 1 ) = O( N^2 ) 随机取pivot

各种排序算法的实现和比较

算法的稳定性 如果待排序表中有两个元素 Ri 和 Rj,其对应的关键字keyi = keyj,注意是关键字相等,且在排序前 Ri 排在 Rj 前面,如果使用某一算法排序后,Ri 仍在 Rj 前面,则称这个算法是稳定的,否则是不稳定的. 在排序过程中,根据元素是否完全在内存中,可以将排序算法分为两类:内部排序是指在排序期间元素全部存放在内存中的排序:外部排序是指在排序期间元素无法全部同时放在内存中,必须在排序过程中根据要求不断地在内外存之间移动. 以下所有代码基于此类结构: typedef int