精华内容
下载资源
问答
  • 四人发牌洗牌程序

    2018-04-08 22:26:21
    编写一个模拟人工洗牌的程序,将洗好的牌分别...*4)可以设计成图形用户界面,通过按钮进行洗牌、发牌的动作,并按上面的要求显示东西南北四个人手上的牌型。 此代码按照要求做好,并有注释,方便根据个人需要修改。
  • 用上面的数组,生成一副扑克牌 5、遍历显示全副扑克牌 6、模拟给4个人随机发牌,每个11张牌 7、显示每个的牌和剩余的牌
  • 发牌到玩家手中;将玩家手中扑克牌按花色大小整理好。 思路一 import random import operator def auto(): pokers=[] poker=[] for i in [':heart_suit:',':spade_suit:',':diamond_suit:',':club_suit:']: for...
  • Java实现的发牌程序

    2018-10-16 15:06:30
    (4) 发牌完成后按花色(顺序为黑桃、红心、草花、方块)和牌面大小输出每个得到的牌。 例如: 输入扑克牌幅数:1 输入人数:3 输出如下: 第1个人: 黑桃:K 10 5 A 红心:10 3 2 草花:K 10 8 6 3 A 方块:Q J ...
  • 编写程序, 4名牌手打牌,计算机随机将52张(不含大小鬼)发给4名牌手,在屏幕上显示每位牌手的。 很多学习python,不知道从何学起。 很多学习python,掌握了基本语法过后,不知道在哪里寻找案例上手。 很...

    1. 题目

    编写程序, 4名牌手打牌,计算机随机将52张牌(不含大小鬼)发给4名牌手,在屏幕上显示每位牌手的牌。

    很多人学习python,不知道从何学起。
    很多人学习python,掌握了基本语法过后,不知道在哪里寻找案例上手。
    很多已经做案例的人,却不知道如何去学习更加高深的知识。
    那么针对这三类人,我给大家提供一个好的学习平台,免费领取视频教程,电子书籍,以及课程的源代码!
    QQ群:1097524789

    提示:

    设计出3个类:Card类、Hand类和Poke类。

    Card类代表一张牌,其中FaceNum字段指出是牌面数字1~13,Suit字段指出的是花色,值“梅”为梅花,“方”为方块,“红”为红心,“黑”为黑桃。

    Hand类代表一手牌,可以认为是一位牌手手里的牌,其中cards列表变量存储牌手手里的牌。可以增加牌、清空手里的牌、把一张牌给别的牌手。

    Poke类代表一副牌,可以把一副牌看作是有52张牌的牌手,所以继承Hand类。

    1.1 输出样例

    This is a module with classes for playing cards.

    牌手 1:红桃6 黑桃6 梅花A 方片6 黑桃2 梅花10 红桃3 方片4 方片10 黑桃J 红桃Q 红桃10 红桃8 

    牌手 2:梅花J 梅花9 红桃7 红桃2 方片K 黑桃K 梅花3 方片7 黑桃Q 黑桃10 梅花Q 梅花8 黑桃7 

    牌手 3:梅花2 方片A 黑桃3 方片9 黑桃4 红桃K 红桃J 梅花7 红桃4 方片2 梅花4 梅花6 红桃5 

    牌手 4:黑桃5 红桃9 方片8 梅花5 方片J 黑桃A 梅花K 方片5 黑桃9 方片3 黑桃8 方片Q 红桃A

    2. 题解

    2.1 代码

    # Card类:一张牌
    class Card:
      """A playing card.card"""
      RANKS = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
      SUITS = ['梅花', '方片', '红桃', '黑桃']
    
      def __init__(self, rank, suit, face_up=True):
        self.rank = rank        # 牌面数字1~13
        self.suit = suit        # 花色
        self.is_face_up = face_up    # 是否显示牌的正面,True为正面,False为反面
    
      def __str__(self):         # 重写print()方法,打印一张牌的信息
        if self.is_face_up:
          rep = self.suit + self.rank
        else:
          rep = 'XX'
        return rep
    
      def pic_order(self):       # 牌的顺序号
        if self.rank == 'A':
          FaceNum = 1
        elif self.rank == 'J':
          FaceNum = 11
        elif self.rank == 'Q':
          FaceNum = 12
        elif self.rank == 'K':
          FaceNum = 13
        else:
          FaceNum = int(self.rank)
        if self.suit == '梅花':
          Suit = 1
        elif self.suit == '方片':
          Suit = 2
        elif self.suit == '红桃':
          Suit = 3
        else:
          Suit = 4
        return (Suit - 1) * 13 + FaceNum
    
      def flip(self):         # 翻牌方法
        self.is_face_up = not self.is_face_up
    
    # Hand类:一手牌
    class Hand:
      """A hand of playing cards Hand"""
    
      def __init__(self):
        self.cards = []       # cards列表变量存储牌手手里的牌
    
      def __str__(self):        # 重写print()方法,打印出牌手的所有牌
        if self.cards:
          rep = ''
          for card in self.cards:
            rep += str(card) + '\t'
        else:
          rep = '无牌'
        return rep
    
      def clear(self):         # 清空手里的牌
        self.cards = []
    
      def add(self, card):       # 增加手里的牌
        self.cards.append(card)
    
      def give(self, card, other_hand):  # 把一张牌给其他选手
        self.cards.remove(card)
        other_hand.add(card)
        # other_hand.append(card)  # 上面两行可以用这一行代替
    
    # Poke类:一副牌
    # 继承Hand类
    class Poke(Hand):
      """Poke类代表一副牌,可以看做是有52张牌的牌手,所以继承Hand类。由于其中cards列表变量要存储52张牌
      而且要发牌,洗牌,所以增加方法如下方法:"""
    
      def populate(self):         # 生成一副牌
        for suit in Card.SUITS:
          for rank in Card.RANKS:
            self.add(Card(rank, suit))
    
      def shuffle(self):         # 洗牌
        import random
        random.shuffle(self.cards)   # 打乱牌的顺序
    
      def deal(self, hands, per_hand=13): # 将牌发给玩家,每人默认13张牌
        for rounds in range(per_hand):
          for hand in hands:
            if self.cards:
              top_card = self.cards[0]
              self.cards.remove(top_card)
              hand.add(top_card)
              # self.give(top_card,hand) #上两句可以用此句替换
            else:
              print('不能继续发牌了,牌已经发完了!')
    
    if __name__ == "__main__":
      print('This is a module with classes for playing cards.')
      players = [Hand(), Hand(), Hand(), Hand()]
      poke1 = Poke()
      poke1.populate()       # 生成一副牌
      poke1.shuffle()        # 洗牌
      poke1.deal(players, 13)    # 发给每人13张牌
      n = 1
      for hand in players:
        print('牌手', n, end=':')
        print(hand)
        n = n + 1

    到此这篇关于Python用类实现扑克牌发牌的示例代码的文章就介绍到这了,更多相关Python 扑克牌发牌内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

    时间:2020-06-01

    python实现扑克牌交互式界面发牌程序

    本文实例为大家分享了python实现扑克牌交互式界面发牌程序的具体代码,供大家参考,具体内容如下 注:图片自行在网上下载.替换即可 #coding=utf-8 class Card(): #扑克牌类 points=['1','2','3','4','5','6','7','8','9','10','11','12','13'] suits=['1','2','3','4'] #花色 def __init__(self,points,suits): self.points=points self.

    python利用wx实现界面按钮和按钮监听和字体改变的方法

    wxPython是Python语言的一套优秀的GUI图形库.允许Python程序员很方便的创建完整的.功能键全的GUI用户界面. wxPython是作为优秀的跨平台GUI库wxWidgets的Python封装和Python模块的方式提供给用户的. 只要介绍了如何利用wxPython实现吗按钮和对按钮的监听,并且改变了按钮的字体和颜色. python代码如下: #-*- coding:utf-8 -*- import wx class Frame(wx.Frame): def __init__(s

    python GUI库图形界面开发之PyQt5拖放控件实例详解

    本篇,我们学习PyQt5界面中拖放(Drag 和Drop)控件. 拖放动作 在GUI中,拖放指的是点击一个对象,并将其拖动到另一个对象上的动作.比如百度云PC客户端支持的拖放文件以快速移动文件: 拖放动作能够很直观很方便的在GUI程序中完成一些很复杂或繁琐的操作. 在PyQt中实现拖放 在PyQt5中,我们也可以很轻松地使用拖放功能. 使用Qt设计师或者使用API都可以实现.我们先使用Qt设计师将GUI的图形设计出来,在之前的GUI的基础上,我们新建一个选项卡. 我们新建了一个选项卡,然后在里面

    python GUI库图形界面开发之PyQt5信号与槽机制、自定义信号基础介绍

    信号和槽机制是 QT 的核心机制,要精通 QT 编程就必须对信号和槽有所了解.信号和槽是一种高级接口,应用于对象之间的通信,它是 QT 的核心特性,也是 QT 区别于其它工具包的重要地方. 在linux.windows等 GUI 工具包中,GUI组件都会注册回调函数用于处理组件所触发的动作,通常是注册对应的函数的函数指针.在之前关于Button的文章中提到了信号与槽的机制的使用,通过该机制可以很好的将组件的信号(如button的clocked.toggled.pressed等)和处理该信号的槽关

    python GUI库图形界面开发之PyQt5窗口类QMainWindow详细使用方法

    QMainWindow QMainWindow类中比较重要的方法 方法 描述 addToolBar() 添加工具栏 centralWidge() 返回窗口中心的一个控件,未设置时返回NULL menuBar() 返回主窗口的菜单栏 setCentralWidget() 设置窗口中心的控件 setStatusBar() 设置状态栏 statusBar() 获得状态栏对象后,调用状态栏对象的showMessage(message,int timeout=0)方法 显示状态栏信息,其中第一个参数是要显

    python GUI库图形界面开发之PyQt5中QMainWindow, QWidget以及QDialog的区别和选择

    PyQt中MainWindow, QWidget以及Dialog的区别和选择 1. Qt界面分类 在Qt Designer设计界面时,首先需要选择界面模板,主要分为三个类: Main Window Widget Dialog 2. 三种模板的区别(官方文档介绍) MainWindow QMainWindow类提供一个有菜单条.锚接窗口(例如工具条)和一个状态条的主应用程序窗口. 主窗口通常用在提供一个大的中央窗口部件(例如文本编辑或者绘制画布)以及周围菜单.工具条和一个状态条.QMainWind

    python GUI库图形界面开发之PyQt5结合Qt Designer创建信号与槽的详细方法与实例

    在下面这3篇文章中我们给出了手工输入代码的信号与槽的使用方法,因为采用这种方法介绍时,会简单一些,如果使用Qt Designer来介绍这些功能,那么任何一个简单的功能都会使用xxxx.ui xxxx.py call_xxxx.py三个文件 来实现,这样内容会显得很乱 python GUI库图形界面开发之PyQt5信号与槽基础使用方法与实例 python GUI库图形界面开发之PyQt5信号与槽的高级使用技巧(自定义信号与槽)详解与实例 python GUI库图形界面开发之PyQt5信号与槽的高级

    Python实现一个简单的验证码程序

    老师讲完random函数,自己写的,虽然和老师示例的不那么美观,智能,但是也自己想出来的,所以记录一下,代码就需要自己不断的自己练习,实战,才能提高啊!不然就像我们这些大部分靠自学的人,何时能学会.还有就是,这次听老师的,把自己的代码添加注释,所以这次把很简单的代码都写上了注释,而且很大白话,不管有没有接触过python的,我相信仔细看了,肯定能看懂.如果看完,再自己尝试着默写出来,那就是更好到了,好了进入正题: 自己写的: __Author__ = "Zhang Peng" impo

    Python实现简单的可逆加密程序实例

    本文实例讲述了Python实现简单的可逆加密程序.分享给大家供大家参考.具体如下: Python代码如下: 复制代码 代码如下: #coding=utf-8   '''''      Description: 可逆的加密与解密      Environment: python2.5.x      Author:idehong@gmail.com  ''' import os   import sys   class Code(object):       '''''可逆的加密与解密'''    

    WPF实现类似360安全卫士界面的程序源码分享

    下面通过图文并茂的方式给大家介绍WPF实现类似360安全卫士界面的程序源码分享,点击此处下载源码哦. 以前学习Windows Form编程的时候,总感觉自己做的界面很丑,看到360安全卫士.迅雷等软件的UI设计都非常美观,心里总是憧憬着要是自己能实现这样的UI效果该多好!!!另一个困扰我的问题是,这个UI皮肤是如何用技术实现的呢?!虽然好多年过去了,但心里的憧憬和疑惑一直没有消失,而且越来越强烈.在日常的工作和学习中,自己在网上也经常留意类似的技术或者文章.最近在学习WPF的过程中,看到网上也有

    不同版本中Python matplotlib.pyplot.draw()界面绘制异常问题的解决

    前言 本文主要给大家介绍了关于不同版本中Python matplotlib.pyplot.draw()界面绘制异常的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. 在 Ubuntu系统上进行如下配置: $ sudo apt-get update $ sudo apt-get upgrade $ sudo apt-get install python-dev $ sudo apt-get install python-pip $ sudo pip install --u

    展开全文
  • 24点游戏,可以随机产生四个数字,python描述 :24点游戏是经典的纸牌益智... 从扑克中每次取出4张。使用加减乘除,第一个能得出24者为赢。(其中,J代表11,Q代表12,K代表13,A代表1),按照要求编程解决24点游戏。
  • (1) 能洗牌,发牌; (2) 每次发一手牌(5 张);...(4) 可以模拟发牌人,程序评估发牌人的牌,根据这手牌的质量, 发牌人可以抓一张、两张、或三张牌,换掉手中不要的牌, 然后程序重新评估发牌人的牌。
  • 斗地主洗牌发牌算法

    2012-08-27 14:38:30
    斗地主算法类 适合初学者. 可以实现斗地主的洗牌发牌 无JFrame 简单易懂.
  • 发牌求同花顺概率.cpp

    2020-03-22 19:40:40
    用c语言写的随机发牌求一个发到同花顺的概率,也可以以此为模板求其他有关发牌的概率,用于完成某些概率论的实际编程作业。
  • 第3章 面向对象设计应用发牌游戏 主讲 夏敏捷 计算机学院副教授 3.1 发牌游戏功能介绍 案例采用扑克牌类设计扑克牌发牌程序 4名牌手打牌电脑随机将52张牌不含大小鬼发给4名打牌在屏幕上显示每位牌手的牌程序的运行...
  • 上个周的Java作业就是使用eclipse模拟三个人打牌,实现扑克牌的随机发牌、查询不同的姓名时,要显示每个拿的什么牌。这个作业早在大一的时候就有一个学长留给小苏了,可是当时初因为是大一的寒假,小苏最终还是...

    JAVA也会打牌?

    上个周的Java作业就是使用eclipse模拟三个人打牌,实现扑克牌的随机发牌、查询不同人的姓名时,要显示每个人拿的什么牌。这个作业早在大一的时候就有一个学长留给小苏了,可是当时初因为是大一的寒假,小苏最终还是没能做出来,所以今天小苏又重新的做了一下,小苏的设计偏向面向对象方法,主要有四个类分别是main.java、PokeNameSet.java、Pokeshuxing.java、user.java。

    首先扑克牌有三个属性,第一个是number,第二个是name,第三个是colour,所以新建类Pokeshuxing.java

    Pokeshuxing.java

    package poker;
    
    public class Pokeshuxing
    {
        //扑克牌对象的三个属性
        public int number;
        public String  name;
    	public String  colour;
    
    	Pokeshuxing(int number, String colour, String name)
    	{
        	this.number = number;
       		this.colour = colour;
        	this.name = name;
    	}
    
    	public void setName(String name) 
    	{
        	this.name = name;
    	}
    
    
    	public int getNumber() 
    	{
       		return number;
    	}
    
    
    	public String getName() 
    	{
        	return name;
    	}
    
    	public String getColour() 
    	{
        	return colour;
    	}
    }
    

    小苏用number存储值,name存储扑克牌的名称(2~10,A、J、Q、K),colour存储花色。打印出来的时候打印名称和花色!

    用数组存放54张扑克牌,然后在把数组装入ArrayList中,并调用方法Collections.shuffle打乱扑克牌(相当于洗牌)

    main.java中包含主函数,并且调用了PokeNameSet类里面的方法把下标为0、1、10、11、12、13、14的扑克牌的名称(name属性)对应为A、10、J、Q、K、小王、大王。

    main.java

    package poker;
    
    import java.util.ArrayList;
    import java.util.Collections;
    
    
    public class main
    {
    	static ArrayList<Object> list = new ArrayList();//存放装有扑克牌的数组
    
    	Object[] newPoke = new Object[54];//存放54张扑克牌对象
    
    
    	//初始化54张扑克牌,并调用PokeNameSet类里的方法setnewPoke()返回每个扑克牌的name属性
    	//把52张扑克牌(除大小王)分成4组,第一组1~13(A、J、Q、K)都为♠(黑桃),第二组都为♥(红桃),第三组都为♦(方块),第四组都为♣(梅花)
    	public void setnewPoke(PokeNameSet pns)
    	{
    		for(int arrayindex = 0; arrayindex < 13; arrayindex++)
        	{
        	    int j = arrayindex + 1;//j代表扑克牌的数值大小(1~13)
        	    String name1 = pns.setnewPoke(arrayindex);
        	    Pokeshuxing poke = new Pokeshuxing(j, "♠", name1);
        	    newPoke[arrayindex] = poke;  
        	}
    
        	for(int arrayindex = 13; arrayindex < 26; arrayindex++)
        	{
        	    int j = arrayindex - 12;//j代表扑克牌的数值大小(1~13)
        	    String name2 = pns.setnewPoke(arrayindex);
        	    Pokeshuxing poke = new Pokeshuxing(j, "♥", name2);
        	    newPoke[arrayindex] = poke;
        	}
        	
        	for(int arrayindex = 26; arrayindex < 38; arrayindex++)
        	{
        	    int j = arrayindex - 24;//j代表扑克牌的数值大小(1~13)
        	    String name3 = pns.setnewPoke(arrayindex);
        	    Pokeshuxing poke = new Pokeshuxing(j, "♦", name3);
        	    newPoke[arrayindex] = poke;
        	} 
        	
        	for(int arrayindex = 38; arrayindex < 52; arrayindex++)
        	{
        	    int j = arrayindex - 38;//j代表扑克牌的数值大小(1~13)
        	    String name4 = pns.setnewPoke(arrayindex);
        	    Pokeshuxing poke = new Pokeshuxing(j, "♣", name4);
        	    newPoke[arrayindex] = poke;
        	}   
        	
       		//初始化大小王
        	for(int arrayindex = 52;arrayindex < 54; arrayindex++)
        	{
        	    int j = arrayindex - 51;//j代表扑克牌的数值大小(1~2)
        	    if(j == 1)
        	    {
        	    	String name5 = pns.setnewPoke(arrayindex);
        	        Pokeshuxing poke = new Pokeshuxing(j, "小王", " ");
        	        newPoke[arrayindex] = poke;
        	    }
        	    else
        	    {
        	    	String name6 = pns.setnewPoke(arrayindex);
        	        Pokeshuxing poke = new Pokeshuxing(j, "大王", " ");
        	        newPoke[arrayindex] = poke;
        	    }            
        	}
        	
        	//把数组newPoke里的扑克牌对象装入list中,并调用方法Collections.shuffle打乱扑克牌
        	for(int listindex = 0; listindex < 54; listindex++)
        	{
        	    list.add(newPoke[listindex]);
        	}
        	
        	Collections.shuffle(list);//打乱扑克牌对象
    
        	//从list中打印出每个玩家的牌,洗牌后规定前18个为唐僧的牌,以此类推
        	System.out.println("唐僧的牌:");
        	for(int listindex = 0;listindex < 18; listindex++)
        	{
        	    Pokeshuxing pk1 = (Pokeshuxing)list.get(listindex);
        	    System.out.print(" " + pk1.getColour() + pk1.getName());
        	}
        	System.out.println	("\n--------------------------------------------------------------");
    
        	System.out.println("悟空的牌:");
        	for(int listindex = 18; listindex < 36; listindex++)
        	{
        		Pokeshuxing pk2 = (Pokeshuxing)list.get(listindex);
        	    System.out.print(" " + pk2.getColour() + pk2.getName());
        	}
        	System.out.println	("\n--------------------------------------------------------------");
    
        	System.out.println("八戒的牌:");
        	for(int listindex = 36; listindex < 54; listindex++)
        	{
        		Pokeshuxing pk3 = (Pokeshuxing)list.get(listindex);
        		System.out.print(" " + pk3.getColour() + pk3.getName());
        	}
        	System.out.println("");    
    }	
    
    
    	public static void main(String[] args) 
    	{
        	main main = new main();
        	PokeNameSet pns = new PokeNameSet();
        	user sup = new user();
        	main.setnewPoke(pns);   //初始化54张扑克牌,并打印出来
        	sup.setnewUserPoke();//分别把54张扑克牌转入三个玩家的数组中
    	}
    

    }

    PokeNameSet.java中是具体实现把数值为0、1、10、11、12、13、14的扑克牌的名称(name属性)对应为A、10、J、Q、K、小王、大王的方法。

    PokeNameSet.java

    package poker;
    
    public class PokeNameSet {
     	String name;
     	//设置扑克牌的name属性的方法;
     	public  String setnewPoke(int arrayindex)
     	{
    
        	 if(arrayindex < 13)
        	 {//数组下标0~12为第一组,传入的参数为0~12
    		     name = setName(arrayindex);
        	 }
        	 else if(arrayindex < 26 && arrayindex >= 13)
        	 {//数组下标13~25为第二组
        	     int j;
        	     j = arrayindex - 13;//j为了传入的参数与第一组的一样(0~12)
        	     name = setName(j);
        	 }
        	 else if(arrayindex < 39 && arrayindex >= 26)
        	 {//数组下标26~38为第三组
        	     int j;
        	     j = arrayindex - 26;//j为了传入的参数与第一组的一样(0~12)
        	     name = setName(j);
        	 }
        	 else if(arrayindex < 52 && arrayindex >= 39)
        	 {//数组下标39~51为第四组
        		 int j;
        		 j = arrayindex - 39;//j为了传入的参数与第一组的一样(0~12)
        	     name = setName(j);
        	 }
        	 return name;
    	 }	
    
      	 //把52张扑克牌按照花色分成4组,一维数组中第一组的开头下标为“0”的第一个为数字“1”代表"A"类推
      	 //第二组的开头下标为“13”的第一个为数字“1”代表"A",类推
      	public String setName(int i)
    	{
      	    String name;
    		if(i == 0)
    		{
    			name = "A";
      	    }
    		else if(i == 10)
    		{
      	        name = "J";
      	    }
    		else if(i == 11)
    		{
    			name = "Q";
      	    }
    		else if(i == 12)
    		{
    			name = "K";
    		}
      	    else if(i == 1)
      	    {
      	      	name = "10";
      	    }
      	    else if(i == 13)
      	    {
      	      	name = "小王";
      	    }
      	    else if(i == 14)
      	    {
      	      	name = "大王";
      	    }
      	    else
      	    {
    			name = String.valueOf(i);
      	    }
      	    return name;
      	  }
    }
    

    最后一个类user.java,就是把每个玩家的牌存入相应玩家的数组中保存。

    user.java

    package poker;
    
    public class user 
    {
    	static Object[] user1 = new Object[18];//存放玩家1的扑克牌
        static Object[] user2 = new Object[18];//存放玩家2的扑克牌
        static Object[] user3 = new Object[18];//存放玩家3的扑克牌
    
        public void setnewUserPoke()
        {
    
        	// 把list中的52张牌放入四个玩家的数组中,前13张为玩家1的牌,以此类推
        	for(int i = 0; i < 18; i++)
        	{
        		Pokeshuxing pk = (Pokeshuxing)main.list.get(i);
        		user1[i] = pk;
        	}
    
        	for(int i = 18; i < 36; i++)
        	{
        		Pokeshuxing pk = (Pokeshuxing)main.list.get(i);
        		int j = i - 18;  //j为了把list中下标与玩家2数组中的下标匹配
        		user2[j] = pk;
        	}
    
        	for(int i = 36; i < 54; i++)
        	{
        		Pokeshuxing pk = (Pokeshuxing)main.list.get(i);
        		int j = i - 36;//j为了把list中下标与玩家3数组中的下标匹配
        		user3[j] = pk;
        	}
    
        }
    
    }
    

    所有的程序到此就全部结束啦,最终运行结果如下:

    唐僧的牌:
     ♦9 ♣2 ♥10 ♠5 ♥6 ♠2 ♠4 ♠K ♣K ♦2 ♠8 ♥8 ♥Q ♠7 ♦10 ♣5 ♣J ♠6
    --------------------------------------------------------------
    悟空的牌:
     ♠3 ♣6 ♥4 ♥9 小王  ♥A ♦A ♠A ♣9 ♣4 ♣7 ♣3 ♥5 ♠9 ♦7 ♠J ♣A ♥7
    --------------------------------------------------------------
    八戒的牌:
     ♦5 ♦4 ♦6 ♥K ♣K ♥2 ♦8 ♥J ♣Q ♦Q ♠Q ♠10 ♣10 ♣8 大王  ♥3 ♦3 ♦J
    

    这是小苏第一次写java,可能其中有错误,希望大家多多指正昂!

    展开全文
  • 扑克牌发牌程序

    2011-10-01 21:24:47
    C语言 扑克牌发牌程序。研究生考试C语言试题。
  • C语言自动发牌系统

    2012-11-10 23:54:07
    C语言自动发牌系统。能够解决四人桥牌问题,代码很全,也是美斯坦福学生学习的重要资源
  • 54张牌要区分花色:黑桃、梅花、方块、红桃)并且存放在一个一维数组中。然后随机的发牌给三个玩家,其中任意一为地主,地主比其他玩家多三张牌。
  • java实现斗地主发牌

    千次阅读 2019-09-05 08:55:27
    说明 这是之前学习java时...首先考虑一个斗地主游戏中有什么对象,我认为斗地主中应该会有玩家,还有牌,另外还需要一个发牌,我比较懒,觉得玩家负责玩就好了,发牌,洗牌这种事就不自己动手了。所以分为Pla...

    说明

    这是之前学习java时关于面向对象的一个实验,对面向对象思想的掌握有一定的帮助,刚好整理到了,就写出来。

    斗地主发牌

    要显示出底牌;以及同一轮中,当一张牌已经被发给第一个人时,再发牌给下一个人这张牌不可以再出现。

    设计

    首先考虑一个斗地主游戏中有什么对象,我认为斗地主中应该会有玩家,还有牌,另外还需要一个发牌的人,我比较懒,觉得玩家负责玩就好了,发牌,洗牌这种事就不自己动手了。所以分为Player,Dealer,Poker,另外还有一个主类,这里命名为Game。
    直接看代码吧,代码中会有注释。

    实验环境

    JDKSE-1.8
    eclipse2017

    当时用的是JDK1.8版本,后来因为Android改用1.7版本了,相应的eclipse也不一样了。现在我又想把1.7卸了,下载1.8,但是不舍得动手,看看哪个节点能逼得我动手吧。

    代码

    首先看一下Poker类,可以看成就是一副扑克牌,那么扑克牌有什么,一副扑克牌当然有54张牌啦。本来花色是可以用图形显示的,但是因为我的eclipse没有设置好,所以花色会出现乱码,不过其他小伙伴还是可以试一下的。

    package deal;
    
    public class Poker {
    
       String[] numbers= {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};       //点数
    
       String[] colors= {"黑桃","红桃","方块","梅花"};                                     //花色
    
       String[] cards=new String[54];
    
       int[] array=new int[54];                                  //编号
    
       void setCards(String numbers[],String colors[],int array[])
    
       {
    
          for(int i=0;i<array.length;i++)
    
            array[i]=i;
    
          int k=0;
    
          for(int i=0;i<numbers.length;i++)
    
            for(int j=0;j<colors.length;j++)
    
            {
    
               cards[k]=colors[j]+numbers[i];     //将花色和点数拼接在一起存在cards数组中
    
               k=k+1;
             }
    
          cards[52]="大王";                 //将大王,小王加入牌中
    
          cards[53]="小王";
    
       }
    
    }
    
    

    然后看看Dealer类,把这个类看成一个洗牌的人,那么首先他需要有一副牌,然后需要洗牌,发牌,所以具有3个方法。注意:我这里的洗牌不是把牌数组给打乱,当然数组有打乱以及排序的功能,但是当时我还没有学到这里,所以用到的知识都是最简单的知识,希望能帮助到入门的人。我洗牌的过程其实是给了每张牌一个编号,从1到54,然后把这个编号打乱,再通过编号来取牌。数组中就是用另一个数组存储每张牌的下标,然后打乱这个数组,再通过这个下标数组来取牌,就像我发牌时不从第一个开始发,而是随机从牌中间抽一张发一样。

    
    package deal;
    
    import java.util.*;
    
    public class Dealer {
    
       int[] hand=new int[3];
    
       void shuffleCard(int array[])               //洗牌
    
       {
    
          int temp=0;
    
          int rd1,rd2;
    
          for(int i=0;i<array.length;i++)
    
          {
    
            Random r1=new Random();            //产生两个随机数
    
            Random r2=new Random();
    
            rd1=r1.nextInt(54);
    
            rd2=r2.nextInt(54);
    
            temp=array[rd1];
    
            array[rd1]=array[rd2];
    
            array[rd2]=temp;
    
          }
    
       }
    
     
    
       void sendCards(int array[],int array1[],int array2[],int array3[])   //发牌
    
       {
    
          for(int i=0;i<array.length;i++)
    
          {
    
            if(i<51)
    
            {
    
               if(i%3==0)
    
                  array1[i/3]=array[i];
    
               if(i%3==1)
    
                  array2[i/3]=array[i];
    
               if(i%3==2)
    
                  array3[i/3]=array[i];
    
            }
    
            else
    
               hand[i-51]=array[i];
    
          }
    
       }
    
       void showHand(int hand[],String cards[])                      //显示底牌
    
       {
    
          for(int i=0;i<hand.length;i++)
    
          {
    
            System.out.print(" "+cards[hand[i]]);
    
          }
    
       }
    
    }
    
    

    下面就是玩家类了,这里只给玩家两个方法,就是排序还有显示自己的牌。牌发下来了,当然是先把牌排好了。所以玩家得到的牌应该只有17张,共3个玩家,还剩3张牌作为底牌。说一下,排序算法有很多,这里采用的是冒泡排序法,更多方法可以看一下这篇文章排序算法

    package deal;
    
    
    public class Player {
    
       int[] card=new int[17];
    
       void sortCards(int card[])                       //将牌排序
    
       {
    
          int temp;
    
          for(int i=0;i<card.length-1;i++)              //冒泡排序法
    
            for(int j=0;j<card.length-1-i;j++)
    
            {
    
               if(card[j]>card[j+1])
    
               {
    
                  temp=card[j];
    
                  card[j]=card[j+1];
    
                  card[j+1]=temp;
    
               }
    
            }
    
       }
    
       
    
       void showCards(int card[],String cards[])        
    //将牌展示出来
    
       {
    
          for(int i=0;i<card.length;i++)
    
          {
    
            System.out.print(" "+cards[card[i]]);
    
          }
    
       }
       }
    

    最后看一下主类,看在斗地主游戏中是怎么发牌的。

    package deal;
    
    
    public class Game {
    
       public static void main(String[] args) {
    
          // TODO 自动生成的方法存根
    
          Poker pk=new Poker();             //实例化一个Poker对象
    
          Player pl1,pl2,pl3;               //实例化3个Player对象
    
          pl1=new Player();
    
          pl2=new Player();
    
          pl3=new Player();
    
          Dealer de=new Dealer();          //实例化一个Dealer对象
    
          pk.setCards(pk.numbers, pk.colors,pk.array);        
    //拿出一副扑克牌
    
          de.shuffleCard(pk.array);                            //发牌人洗牌
    
          de.sendCards(pk.array, pl1.card, pl2.card, pl3.card);  //发牌人发牌
    
          pl1.sortCards(pl1.card);                           //玩家1将牌排序
    
          pl2.sortCards(pl2.card);                           //玩家2将牌排序
    
          pl3.sortCards(pl3.card);                           //玩家3将牌排序
    
          System.out.println("\n玩家1的牌是:");
    
          pl1.showCards(pl1.card, pk.cards);
    
          System.out.println("\n玩家2的牌是:");
    
          pl2.showCards(pl2.card, pk.cards);
    
          System.out.println("\n玩家3的牌是:");
    
          pl3.showCards(pl3.card, pk.cards);
    
          System.out.println("\n底牌是:");
    
          de.showHand(de.hand, pk.cards);
    
       }
    
    }
    

    结果

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 本文实例为大家分享了C语言实现随机扑克的具体代码,供大家参考,具体内容如下 算法如下: 1、将1-10作为方块、2-20作为梅花,3-30作为红桃,4-40作为黑桃,JQK以及大小王分别排序共54张存放在一维数组中。 3、3...
  • java发牌程序

    千次阅读 2019-11-15 20:49:11
    实验5:发牌程序 题目类别: B作业 关键字: 掌握Java数组、方法的基本定义 内容要求: 编写程序,项目名和类名均为PokerGame。 实现功能: (1) 共有m幅扑克牌,每幅扑克牌不包括大王和小王共52张牌。 (2) 可能有n个人...

    实验5:发牌程序

    题目类别: B作业

    关键字: 掌握Java数组、方法的基本定义

    内容要求:

    1. 编写程序,项目名和类名均为PokerGame。
    2. 实现功能:
      (1) 共有m幅扑克牌,每幅扑克牌不包括大王和小王共52张牌。
      (2) 可能有n个人参与扑克游戏,2<=n<=52。
      (3) 程序运行时输入扑克牌幅数m和人数n,然后所有牌分别依次分发给n个人。不能整除时,每个人的牌数可以不同,如3个人1幅牌,则第1个人18张,第2个和第3个人17张牌。
      (4) 发牌完成后按花色(顺序为黑桃、红心、草花、方块)和牌面大小输出每个人得到的牌。
      例如:

    输入扑克牌幅数:1
    输入人数:3
    输出如下:

    第1个人:
    黑桃:K 10 5 A
    红心:10 3 2
    草花:K 10 8 6 3 A
    方块:Q J 5 2
    第2个人:

    第3个人:

    1. 实现要求:
      (1) 使用数组存放发牌情况。
      (2) 编写不同方法完成不同功能。

    思路:
    1.分牌,洗牌
    2.m副牌%n个人,剩余的牌依次分给不同的人
    3.平均分牌
    4.排序,先输出牌多的人(牌多的人从max-1到0),后输出牌少的人(牌少的人从max-2到0)

    package poker;
    import java.util.Scanner;
    import java.util.Arrays;
    
    public class PokerGame {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner input = new Scanner(System.in);
    		
    		System.out.println("输入扑克牌副数:");
    		int m = input.nextInt();
    		
    		System.out.println("输入人数:");
    		int n = input.nextInt();
    		
    		int[][] xp = new int[m][52];//洗牌用
    		String[] hs = {"黑桃","红心","草花","方块"};//花色
    		String[] ph = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};//牌号
    		int i,j;
    		
    		int max = (52*m)/n + 1;//每个人的最大牌数;
    		int extra = (52*m)%n;//多出来的牌数;
    		int[][] rpkps = new int[n][];//人数
    		
    		//分配空间,拥有多一张牌数的人空间大一;
    		for( i = 0;i<extra;i++) {
    			rpkps[i] = new int[max];
    		}
    		for(j=extra;j<n;j++)
    			rpkps[j] = new int[max-1];
    		
    		//牌初始化
    		for(i=0;i<m;i++)
    			for(j=0;j<52;j++)
    				xp[i][j]=j;
    		
    		//洗牌
    		for(int k=0;k<m;k++) {
    			for(i=0;i<52;i++) {
    			int index = (int)(Math.random()*52);
    		    int temp = xp[k][i];
    		    xp[k][i] = xp[k][index];
    		    xp[k][index] = temp;
    		  }
    	   }
    		
    		//多出来的几张牌,依次发给不同的人
    		for(i=0;i<extra;i++) {
    			rpkps[i][max-1] = xp[m-1][51-extra];
    		}
    		
    		//平均分牌
    		int w=0;//第几副牌
    		int k=0;//牌数
    		for(i=0;i<(52*m)/n;i++) {
    				for(j=0;j<n;j++) {
    					rpkps[j][i]=xp[w][k];
    					k++;
    					if(k==52) {
    						k=0;
    						w++;
    				}
    			}
    		}
    		
    		for(i=0;i<n;i++)
    			Arrays.sort(rpkps[i]);
    		
    		//先输出多的牌
    		for(i=0;i<extra;i++) {
    		    //输出花色名字:
    			int hei=0;
    			int hong=1;
    			int cao=2;
    			int fang=3;
    			
    			System.out.println("第"+(i+1)+"个人");
    			for(j=max-1;j>=0;j--) {
    				if(rpkps[i][j]>=39) {
    				if(hei == 0) {
    					System.out.print(hs[hei]+":");
    					hei = 1;
    				}
    				System.out.print(ph[rpkps[i][j]%13]+" ");
    				}
    				else if(rpkps[i][j]>=26&&rpkps[i][j]<=38) {
    					if(hong == 1) {
    						System.out.print("\n"+hs[hong]+":");
    						hong = 2;
    					}
    					System.out.print(ph[rpkps[i][j]%13]+" ");
    				}
    				else if(rpkps[i][j]>=13&&rpkps[i][j]<=25) {
    					if(cao == 2) {
    						System.out.print("\n"+hs[cao]+":");
    						cao = 3;
    					}
    					System.out.print(ph[rpkps[i][j]%13]+" ");
    				}
    				else if(rpkps[i][j]>=0&&rpkps[i][j]<=12){
    					if(fang == 3) {
    						System.out.print("\n"+hs[fang]+":");
    						fang = 4;
    					}
    					System.out.print(ph[rpkps[i][j]%13]+" ");
    				}
    			}
    			    System.out.println();
    	    }
    		
    		
    		for(i=extra;i<n;i++) {
    			int hei=0;
    			int hong=1;
    			int cao=2;
    			int fang=3;
    			System.out.println("第"+(i+1)+"个人");
    			for(j=max-2;j>=0;j--) {
    				if(rpkps[i][j]>=39) {
    				if(hei == 0) {
    					System.out.print(hs[hei]+":");
    					hei = 1;
    				}
    				System.out.print(ph[rpkps[i][j]%13]+" ");
    				}
    				else if(rpkps[i][j]>=26&&rpkps[i][j]<=38) {
    					if(hong == 1) {
    						System.out.print("\n"+hs[hong]+":");
    						hong = 2;
    					}
    					System.out.print(ph[rpkps[i][j]%13]+" ");
    				}
    				else if(rpkps[i][j]>=13&&rpkps[i][j]<=25) {
    					if(cao == 2) {
    						System.out.print("\n"+hs[cao]+":");
    						cao = 3;
    					}
    					System.out.print(ph[rpkps[i][j]%13]+" ");
    				}
    				else if(rpkps[i][j]>=0&&rpkps[i][j]<=12){
    					if(fang == 3) {
    						System.out.print("\n"+hs[fang]+":");
    						fang = 4;
    					}
    					System.out.print(ph[rpkps[i][j]%13]+" ");
    				}
    			}
    			    System.out.println();
    		}
    		input.close();
        }
    }
    
    
    展开全文
  • 发牌游戏java

    2014-11-26 16:32:02
    发牌完成后按花色(顺序为黑桃、红心、草花、方块)和牌面大小输出每个得到的牌。 例如: 输入人数:3 输出如下: 第1个人: 黑桃:K 10 5 A 红心:10 3 2 草花:K 10 8 6 3 A 方块:Q J 5 2 第2个人: ...
  • 三人斗地主(自动发牌程序)

    千次阅读 2018-08-17 09:22:35
    编写一个自动发牌程序,模拟三人斗地主的摸牌场景。首先要给出提示,谁首先开始摸牌,并且摸牌要和现实摸牌一样,三人循环摸牌,最后还要剩余三张底牌,同时给出地主牌,摸到地主牌的玩家拥有三张底牌。三张底牌三人...
  • java发牌游戏

    2013-04-04 13:07:02
    共有1幅扑克牌,不包括大王和小王共52张牌。 可能有n个人参与扑克游戏,2。 程序运行时输入n,然后52张牌分别依次分发给n个人。...发牌完成后按花色(顺序为黑桃、红心、草花、方块)和牌面大小输出每个得到的牌。
  • python练习题:使用列表实现斗地主的发牌设计 1.使用列表完成牌的设计 2.使用3个列表实现每个牌的设计 """ :spade_suit::从小到大排序:1—13 :heart_suit::从小到大排序:14—26 :club_suit::从小到大排序:...
  • 模拟发牌代码

    2013-09-04 22:17:11
    这程序是模拟发牌,运行它后你会看到每个出现的牌
  • 1)、将一副牌封装进入Map集合中,键为0-53的Integer数据,值为字符串 2)、洗牌:将Map集合的...3)、发牌:发给三个人,就是三个List加一个底牌的List 4)、看牌:将三人的List和底牌List的值进行排序(从大到小)
  • 我设计了四个类,分别是main.java、PokeNameSet.java、PokeVo.java、SetUserPoke.java首先扑克有三个属性,第一个是number,第二个是name,第三个是colour,所以新建类PokeVo.javapackage poke;public class ...
  • C语言发牌洗牌

    千次阅读 2020-03-16 20:28:53
    C语言发牌洗牌 1.模拟发牌程序 通过写两个函数模块来编写洗牌程序和打印的发牌程序 2.编写洗牌程序 void shuffle(char cards[][10],int n){ int i=54; char ca,cb,ct[10]; srand((unsigned)time(NULL)); while...
  • JS实现3斗地主发牌算法

    千次阅读 2018-07-15 09:41:17
    //用1——54的数组代表54张 function myCreateArray(n){ var arr = []; for(var i = 0; i &lt; n; i++){ arr[i] = i + 1; } return arr; } var cards = myCreateArray(54); console.log('Get A Deck of...
  • C# 发牌洗牌

    2010-09-03 13:29:10
    52张扑克,你可以选择洗的次数,洗后给四个玩家一人发13张,而且给出花色哦
  • C语言实现自动发牌

    千次阅读 2020-03-15 20:34:29
    C语言实现自动发牌 1.初始化54张扑克 2.随机洗牌 3.依次分发给三个人 4.显示每个手里的牌 注:花色依次用3,4,5,6对应的ASCII码表示,主要利用随机数、结构体和数组来实现 程序运行效果: 代码部分 : #include<...
  • 今天下午,找到了一个用Java代码实现发牌的功能,记录一下自己的思路。 这个问题可以有两种方法实现: 第一种方法:用Map和List这两个集合实现,思路如下: 一副斗地主的牌一般有54张牌其中 : 4中花色;1-54的编号;2-...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,473
精华内容 37,789
关键字:

发牌的人