斗地主算法的设计与实现--如何判断一手牌的类型(单,对子,三不带,三带一,四代二等)
斗地主春天打法教学设计
斗地主春天打法教学设计篇一：斗地主春天打法解析斗地主是一款广受欢迎的棋牌游戏，春天是斗地主中的一种特殊牌型。
春天的出现会使得地主一方在牌局中占据极大的优势，因此春天打法的掌握对于地主一方至关重要。
本文将针对斗地主春天打法进行详细的教学设计，帮助地主一方在游戏中取得更多的胜利。
一、春天的牌型组成春天是指地主一方在一轮出牌后，没有其他玩家出牌，即地主一方将整轮牌局打完。
春天是由地主一方的出牌技巧和策略决定的，下面将介绍几种常见的春天牌型组合：1. 单牌春天：地主一方只剩下一张牌，可以选择出一张单牌，使得其他玩家无法继续出牌。
2. 对子春天：地主一方只剩下一对相同的牌，可以选择出一对牌，使得其他玩家无法继续出牌。
3. 三带一春天：地主一方只剩下一手三带一的牌型，可以选择出这手牌，使得其他玩家无法继续出牌。
4. 炸弹春天：地主一方只剩下一手炸弹的牌型，可以选择出这手牌，使得其他玩家无法继续出牌。
二、春天打法的技巧和策略1. 快速出牌：地主一方在手牌中如果有春天的潜力，就应该尽快出牌，不要等待其他玩家出牌。
这样可以迅速压制其他玩家，增加春天的机会。
2. 节约牌力：尽量保留手牌中的单牌和对子，这样可以有效节约更强大的牌型组合，增加春天的可能性。
3. 反手出牌：地主一方在出牌时，应该尽量将较小的牌留在手中，以便在其他玩家出牌后能迅速反手出牌，压制对方的出牌速度。
4. 牌型组合策略：地主在组合牌型时，应该尽量选择三带一、炸弹等牌型作为春天的主要组合。
这些牌型在斗地主中较为强大，容易压制其他玩家，增加春天出现的机会。
5. 欺骗性出牌：地主一方可以刻意放弃一些较强的牌型组合，以达到欺骗其他玩家，使得对方放松警惕，增加春天的出现机会。
三、训练与提高春天打法的方法1. 多参加实战练习：地主一方应该多参加斗地主的实战练习，通过与其他玩家对战，来提升春天的打法水平。
2. 观摩高手对决：观摩一些斗地主高手的对局，学习他们的出牌技巧和策略，借鉴他们的春天打法经验。
斗地主策划书
斗地主策划书1. 引言斗地主是一种非常受欢迎的扑克牌游戏，它既考验了玩家的技巧和策略，又充满了竞争与乐趣。
本文档旨在为斗地主游戏的策划提供指导和建议，帮助开发团队设计出一款精彩而受欢迎的斗地主游戏。
2. 游戏概述斗地主是一种三人对战的扑克牌游戏，游戏目标是尽快出完手中的牌，最先出完牌的玩家获胜。
游戏中使用一副标准的扑克牌（不含大小王），牌面由大到小依次为：2、A、K、Q、J、10、9、8、7、6、5、4、3。
玩家可以通过出牌、抢地主等策略来增加自己的胜算。
3. 游戏规则3.1 牌型及权值•单牌：任意一张单独的牌。
•对子：两张牌点数相同的牌。
•三张：三张牌点数相同的牌。
•三带一：三张牌点数相同的牌加上一张单牌。
•三带二：三张牌点数相同的牌加上一对牌。
•顺子：五张或更多连续的单牌。
•连对：三对或更多连续的对子。
•飞机：两个或更多连续的三张牌。
•炸弹：四张点数相同的牌。
•王炸：一对大小王（即大王+小王）。
3.2 游戏流程1.初始化游戏，洗牌并发牌，确定地主位置。
2.地主首先出牌，然后按照逆时针顺序轮流出牌。
3.玩家需要出比上家牌更大的牌或者炸弹来压制对手。
4.如果一名玩家出完手中的牌，则游戏结束，该玩家获胜。
5.若轮到某玩家出牌时，其他两位玩家都选择不要，该玩家可以出任意合法的牌。
3.3 抢地主在斗地主游戏中，抢地主环节是非常重要的。
在游戏开始之前，玩家可以通过叫分的方式争夺地主的位置。
叫分的规则如下：•玩家可以选择不叫地主，叫1分、叫2分或叫3分。
•每个玩家只能叫一次分，且不能比上家叫的分低。
•若所有玩家都选择不叫分，则重新洗牌再次发牌。
4. 游戏设计4.1 界面设计斗地主游戏的界面设计应简洁、美观，并兼顾不同设备的屏幕尺寸。
主要界面应包括以下几个部分：•牌局信息：显示当前游戏状态、剩余牌数等信息。
•玩家手牌区：显示玩家手中的牌，并根据游戏规则进行排序。
•出牌区：显示上家出牌的牌型及权值，并提供出牌操作。
斗地主技术记牌的方法
斗地主技术记牌的方法斗地主是一款非常受欢迎的棋牌游戏，技术记牌是玩家在游戏中提高胜率的重要方法之一。
记牌技术需要玩家具备一定的数学运算能力、观察力和记忆力。
在斗地主游戏中，记牌技术可以让玩家更清楚地知道牌局中各个玩家手中可能拥有的牌，从而更好地制定出牌策略。
首先，要提高记牌技术，玩家需要对斗地主中的牌进行分类和归纳。
斗地主牌型大致可以分为单牌、对子、三张、炸弹、顺子、连对、三带一、三带一对等几种。
玩家可以通过观察出牌和自己手中的牌，来推测其他玩家可能拥有的牌型，从而更好地做出决策。
其次，玩家需要通过观察其他玩家的出牌情况，来推测他们手中的牌。
比如，如果一个玩家连续出单牌，那么很可能他手中没有大的牌或者炸弹；如果一个玩家连续出顺子或连对，那么很可能他手中没有炸弹或者大的单牌。
通过这种观察，玩家可以更好地判断其他玩家手中的牌，从而更好地制定出牌策略。
另外，玩家还可以通过数学运算来帮助记牌。
斗地主游戏中，一共有54张牌，每个玩家手中大概有17张牌，地主多一些，农民少一些。
通过数学运算，可以推测出其他玩家手中可能拥有的牌型和数量。
比如，如果自己手中有5张单牌，并且已经出了3张，那么很可能其他玩家手中也没有很多单牌。
通过这种数学推算，可以更好地帮助玩家记牌。
此外，还有一些记牌的小技巧可以帮助玩家提高记牌技术。
比如，玩家可以通过观察其他玩家摸牌的动作和表情来推测他们手中的牌；玩家可以通过观察其他玩家出牌的顺序和策略来推测他们可能拥有的牌型。
这些小技巧都可以帮助玩家更好地记牌。
总的来说，记牌技术是斗地主游戏中非常重要的一部分，可以帮助玩家更好地制定出牌策略，提高胜率。
记牌技术需要玩家具备一定的数学运算能力、观察力和记忆力。
通过分类和归纳牌型、观察其他玩家出牌和摸牌情况、数学运算、以及一些小技巧，玩家可以提高自己的记牌技术，从而在斗地主游戏中获得更好的成绩。
斗地主算法的设计与实现--如何判断一手牌的类型(单,对子,三不带,三带一,四代二等)
斗地主算法的设计与实现--如何判断一手牌的类型(单,对子,三不带,三带一,四代二等)斗地主游戏算法牌型项目研发本篇主要讲解斗地主中如何判断一手牌的牌型。
牌型火箭：即双王（大王和小王），最大的牌。
炸弹：四张点数相同的牌，如：7777。
单牌：任意一张单牌。
对牌：任意两张点数相同的牌。
三张：任意三张点数相同的牌，如888。
三带一：点数相同的三张牌+一张单牌或一对牌。
如：333+6 或444+99。
单顺：任意五张或五张以上点数相连的牌，如：45678或78910JQK。
不包括2和双王。
双顺：三对或更多的连续对牌，如：334455、7788991010JJ。
不包括2 点和双王。
三顺：二个或更多的连续三张牌，如：333444 、555666777888。
不包括2 点和双王。
飞机带翅膀：三顺＋同数量的单牌或同数量的对牌。
如：444555+79 或333444555+7799JJ四带二：四张牌＋两手牌。
（注意：四带二不是炸弹）。
如：5555＋3＋8 或4444＋55＋77 。
友情提示：本篇是接着上1篇讲述的，建议先看看上1篇一张牌Card的构造过程。
斗地主算法的设计与实现--项目介绍&如何定义和构造一张牌/*** 游戏规则牌的类型共有10种：** 1. 单2.对子3.3不带4.3带1 5.炸弹6.顺子7.4带2 8.连队9.飞机10.对王** @author LeiWen@,,* /FansUnion**/1.单1/**2 * 判断牌是否为单3 *4 * @param myCards5 * 牌的集合6 * @return 如果为单，返回true；否则，返回false。
7 */8public static boolean isDan(List<Card> myCards) { 9// 默认不是单10boolean flag = false;11if (myCards != null && myCards.size() == 1) {12 flag = true;13 }14return flag;15 }2.对子16/**17 * 判断牌是否为对子18 *19 * @param myCards20 * 牌的集合21 * @return 如果为对子，返回true；否则，返回false。
斗地主玩法基础教学设计
斗地主玩法基础教学设计1. 引言斗地主是中国最受欢迎的扑克牌游戏之一，玩法简单又有趣。
本文将介绍斗地主的基础玩法，帮助初学者快速上手。
2. 准备工作玩斗地主需要一副54张的扑克牌（包括大小王）。
游戏的参与者通常为三人，每人的牌数为17张，最后留下三张作为底牌。
3. 牌的大小斗地主的牌型以及牌的大小顺序如下：- 单牌：任意一张单独的牌；- 对子：两张点数相同的牌；- 三张：三张点数相同的牌；- 三带一：三张点数相同的牌加上一张单牌；- 三带二：三张点数相同的牌加上一对牌；- 顺子：至少五张连续点数的单牌；- 连对：至少三对连续点数的牌；- 飞机：至少两个连续点数的三带一或三带二；- 炸弹：四张点数相同的牌；- 火箭：即大小王组成的牌（最大）。
4. 游戏流程斗地主的游戏流程分为发牌、叫地主、出牌三个阶段。
- 发牌：首先，将一副扑克牌洗牌后，由一名玩家任意选择开始发牌。
每人轮流发牌，每人发17张牌，最后三张牌作为底牌放置在桌面上。
发牌时，需要确保每个人的牌面向下，不能看到牌的花色和点数。
- 叫地主：发牌完毕后，由三名玩家轮流叫地主。
每个玩家可以选择叫地主、不叫或者抢地主。
最后叫地主的玩家将获得底牌，并且可以先出牌开始游戏。
- 出牌：叫地主确定后，地主首先出牌，接下来是其他两名农民。
从地主开始，每个玩家轮流出牌。
玩家需要出比上家更大的牌型或者相同牌型但更大点数的牌。
如果不能出牌，可以选择不出或者出炸弹。
当一轮出牌结束时，下一个玩家继续出牌。
当其中两名玩家牌出完了，剩下的一名玩家也赢得了本轮。
5. 牌型与出牌策略- 单牌和对子是最基本的牌型，可以在任何时候出牌。
- 三张可以作为单牌或对子出牌。
- 三带一或三带二需要搭配单牌或对子，可以在单牌和对子出牌的基础上出牌。
- 顺子、连对和飞机需要至少五张或三对及以上的连续牌，可以出牌时一次性出完。
- 若手中有炸弹，可以适当时机出牌，因为炸弹是最大的牌型。
- 火箭可以在任何时候出牌，并且是可以覆盖地主的最佳牌型。
斗地主解析牌型解析算法
斗地主解析牌型解析算法由于近年来网络棋牌游戏的火爆导致个各个地区的特色棋牌游戏开发进入红火时期，也有越来越多的团队个人开始研究棋牌游戏的开发，所以本文主旨在于各个开发人员之间的交流。
每个游戏都有属于自己的规则，当然斗地主也不例外，常斗地主的朋友可能知道在斗地主里面一共有13种牌型，你所出的牌必须符合13种的一种才能够出得了牌，这个就叫地主的规则。
那么我们下面可以通过一个枚举结构来表示每一种的牌型，在这里我们把错误的牌型也当成是一种牌型。
那么在编程中我们该怎么来判断一组牌到底该属于哪一种牌型了？这就是接下来我们将解决的问题，本文中可能有些判断牌型的方法不是很好，如果你有更好的方法，欢迎留言指导！~(@^_^@)~！！首先我们可以根据穷举的方式来罗列一下。
在我以前写斗地主的时候我是根据出牌的张数来罗列牌型的，下面我也将使用这种方法，因为没有找到什么更好的方法，嘿嘿！！那就让我们开始吧！牌的张数 ? 可能的牌型1张牌 ? ? ? ? 单牌2张牌 ? ? ? ? 对子（排除对鬼，因为这个在出牌中出现的次数比较少）3张牌 ? ? ? ?3不带4张牌 ? ? ? 3带一 ?炸弹5张牌 ? ? ? 连牌，3带1对6,7,8,9………这里我们可以用出牌张数5作为分界线，因为5刚好是连牌的起始数并且出牌张数大于5之后就比较的复杂了。
我们首先定义一个数组来存放即将出牌的牌值。
在判断牌型之前将数组排序，排序规则：如果每张牌出现的次数一样，由小到大，如果不一样就将出现次数比较多的牌放在前面。
比如（7,7,3,7)排序之后就变为（7,7,7,3），这样便于我们后面的判断。
出牌张数<5我们只需判断第一张和最后一张牌的牌值时候相等（因为我们数组已经按照我们事先的规则排序了），如果相等则直接返回牌的张数，这里牌的张数刚好对应我们前面定义的枚举结构值。
如果不相等这里要分情况，当出牌的张数等于4时，判断第一张的牌值是否等于倒数第2张，如果相等我们可以直接返回THREE_ONE_CARD牌型，其余的情况可以直接返回ERROR_CARD 。
斗地主牌型分析
斗地主牌型分析斗地主是中国流行的一种纸牌游戏，也是一项具有竞技性和策略性的游戏。
作为一位嗜好和研究棋牌游戏多年的高手，我在斗地主的玩法中积累了丰富的经验，并且在国内多个比赛中获得了荣誉和奖项。
在这篇文章中，我将分享一些斗地主牌型的分析，希望能对广大斗地主玩家有所帮助。
首先，让我们来看看斗地主牌型的分类。
斗地主的牌型多种多样，但可以按照牌型的组合和大小进行分类。
常见的牌型有炸弹、三带一、顺子、连对、飞机等等。
在斗地主中，炸弹是最大的牌型，也是最具有威力的牌型，一旦出现炸弹，可以将其他牌型完全压制。
三带一是另一个强大的牌型，可以在牌局中发挥巨大的作用。
而顺子和连对则在牌局中用于出牌顺序上，可以掌握主动权。
其次，我们来分析一下斗地主牌型的特点。
不同的牌型具有不同的特点和优势。
炸弹牌型的特点是威力大，可以迅速扳回局势。
然而，炸弹在斗地主中并不常见，所以在牌局中准备炸弹要有一定的技巧和耐心。
三带一是一种相对稳定的牌型，可以在中游的时候出牌，来稳定自己的位置。
顺子和连对则是一种比较实用的牌型，在前期可以用来压制对手，并且在后期可以掌握主动权。
然后，我们来看一下斗地主中牌型的搭配技巧。
不同的牌型搭配方式有不同的技巧和策略。
以三带一为例，如果手上有连续的三张相同的牌和一张散牌，我们可以选择将连续的三张牌带出，这样可以保留身上的单牌，以备后面出牌的需要。
如果出牌顺序是顺子或连对，我们可以选择将较小的牌型先出，这样可以逼迫对手出更大的牌型，从而在后面的回合中取得主动。
总之，搭配牌型要根据具体的牌局情况和对手的出牌习惯来决策。
最后，我想再强调一下，在斗地主中，牌型只是游戏的基础，更重要的是运用牌型的策略。
斗地主是一种博弈游戏，胜利不仅仅取决于手上的牌型，还取决于玩家的智慧和决策能力。
在牌局中，我们要学会观察对手的出牌习惯，分析对手的牌型，合理运用自己的牌型和技巧，以取得最终的胜利。
牌型只是一种手段，关键在于运筹帷幄，决胜千里。
斗地主的玩法规则
斗地主的玩法规则
斗地主是一款热门的中国传统牌类游戏，它源于中国，深受中国朋友和世界各地的玩家的喜爱。
斗地主由三个玩家（可以由2-4人玩）参加，每个玩家使用一副54张扑克牌（多一张王牌），分别称为东、南、西和北四个方位。
斗地主的玩法很简单，游戏前需要确定底牌和地主，牌面及牌型都是和传统的一样的，最大的牌为2，最小的牌为A，一副牌有52张正常牌，另外2张王牌。
在斗地主中，底牌是由3张牌组成的，王牌也可以用来当作底牌，因此最多可以由3张王牌组成底牌。
确定底牌和地主后，底牌要被加入地主牌中，其他两家玩家可以看到地主的完整牌组。
接下来，地主会先叫牌，然后其他两家玩家轮流叫牌，如果有人不叫，地主可以继续叫牌，但他不能叫牌次数超过两次。
如果一家玩家连续叫牌两次，则必须出完整的牌组。
斗地主的牌型有单张、对子、三个不带、三代一、炸弹、四代二、顺子、连对和飞机，其中特殊的炸弹可以大过所有的牌，四代二可以大过其他除炸弹以外的所有牌，而顺子、连对和飞机必须比上家大才能生效。
本局游戏成功取胜的一方，是将牌全部出完或把对方逼出完牌的一方。
如果在一局游戏中没有人取得胜利，则表示游戏是平局，没有输赢。
在斗地主比赛中，玩家可以选择自己喜欢的叫法，只要让别的玩家听得懂就行。
玩家可以在游戏中增加趣味性，比如使用小报等。
总的来说，斗地主是一款非常有趣有趣味性的游戏，它的玩法简单易懂，每一局都充满了挑战性，而且比赛中会出现各种技巧，玩家们需要不断磨练细心的技巧，才能在游戏中获得胜利。
玩家们可以根据自己的实力熟练掌握斗地主，享受游戏中精彩的时刻。
斗地主
《斗地主游戏》一般在玩牌之前，可以商约出应有的规则单张：可以是手中的任意一张牌（如◆8 ）一对：两张牌点相同的牌，两张牌的花色可以不同（如88 ）三同张：三张牌点相同的牌，三张牌的花色可以不同（如888 ）三带一：三张牌点相同的牌和另外一张牌一起出。
( 如888+9) 三带二：三张牌点相同的牌和另外两张牌点相同的牌一起出。
( 如888+99)四带二单：必须带两张单牌，不能带大王，小王( 如8888+79) 四带二对：必须带两个对牌，对子可以不用相连。
如8888+7799) 单顺：必须5 张或5 张以上连续的单牌，且其中不能有2 或大小王( 如45678 或10JQKA)对顺( 连对) ：必须3 对或3 对以上连续的对牌，且其中不能有2 或大小王( 如667788 或3344556677)三顺（连三条）：必须2 个或2 个以上连续的三张牌，且其中不能有2 或大小王：如：333444 、555666777888 ）三顺带一：必须2 个或2 个以上连续的三张牌，加上相同牌数的任意单牌，且任意单牌中不能含有大小王（如：444555+79 ）三顺带对：类似三顺带一，区别是带牌必须为对牌（如：444555+77 或333444555+7799JJ ）炸弹：四张一样牌点的牌（如8888 ）火箭：大王跟小王一起为火箭斗地主牌型大小的对比第一：最大的牌是火箭，它可以大过任意的牌形或牌形组合。
第二：炸弹。
炸弹是除火箭之外的任意牌形。
第三：其它的牌型都要比火箭和炸弹小。
如何判断输赢：任意一家出完牌后结束游戏，若是地主先出完牌则地主胜，否则另外两家胜。
斗地主之必备技巧猜、算、堵、防、传是斗地主高手过招的必备技巧。
猜牌。
猜牌的唯一手段就是记牌，得从对方出了些什么牌猜起，最好能记住单张上10点以上出过哪些，对方出过哪些牌，这些牌是什么，从而猜测对方可能有哪些三带几及连子！如果对方在你出A 时犹豫着出2和小王，就有可以猜测到对方是双2分的，或是不是想顶大王。
记牌算牌技巧
记牌算牌技巧
记牌和算牌是斗地主游戏中的基本技巧，以下是一些有用的技巧和建议：
1. 记住牌型：尝试记住已经出过的牌型，包括单牌、对子、三连牌等，以便判断对手可能持有的牌。
2. 记住关键牌：记住王、2、A等关键牌的数量和分布情况，这些牌在游戏后期具有重要影响。
3. 观察出牌顺序：注意观察对手的出牌顺序，这可能暗示着他们的牌型和策略。
4. 判断地主牌型：如果自己是地主，要利用手中的信息和出牌情况来判断其他玩家的牌型，从而制定合理的出牌策略。
5. 预测牌型：根据对手的出牌情况和自己的手牌，预测接下来可能的牌型和出牌顺序。
6. 及时调整策略：根据游戏进程和自己的手牌情况，及时调整自己的出牌策略，例如是否选择抢地主、是否跟牌或顶地主等。
7. 多练习：记牌和算牌技巧需要不断地练习和经验积累，只有通过不断的实战才能提高自己的水平。
以上技巧和建议可以帮助你在斗地主游戏中提高记牌和算牌能力，从而更好地制定出牌策略，提高胜率。
斗地主比赛规则范文
斗地主比赛规则范文斗地主是一款十分流行的纸牌游戏，拥有广泛的玩家群体。
它可以两人以上参与，具有较高的策略性和竞技性。
在比赛中，参与者将通过出牌和抢地主等方式，争夺最终的胜利。
下面将介绍斗地主比赛的详细规则。
一、基本规则1.使用一副54张牌进行游戏，包括大王、小王、A到K的13种点数的牌，每种点数各4张。
2.比赛中分为抢地主和打牌两个阶段，抢地主阶段决定三方角色，打牌阶段实施出牌和计分。
3.三方角色分为地主和两名农民。
二、抢地主阶段1.由庄家先进行叫地主，逆时针轮流叫地主。
2.每人叫地主时可以选择叫分、不叫、抢地主。
3.叫分要高于上家叫分，最低为1分，最高为3分。
4.不叫表示放弃地主的机会。
5.抢地主表示当前玩家愿意成为地主，此时可以选择叫高于上家的分数或者加倍。
6.抢地主者需要支付所有参与玩家叫分总和的分数（如两名农民一共叫了5分，抢地主者需要支付5分）。
7.出第一个抢地主的玩家为地主，其余两名玩家为农民。
三、打牌阶段1.地主先出牌，然后逆时针轮流出牌。
2.出牌时必须按照牌型的大小进行出牌。
牌型包括单张、对子、三张、三带一、三带对、四张、炸弹、连对、顺子和王炸等。
3.炸弹为任意四张相同点数的牌。
4.王炸为大王和小王一起打出。
5.当其中一名玩家出完手中的牌时，该玩家获胜，其他玩家输掉比赛。
四、计分规则1.在打牌阶段，每名农民需要联合起来与地主进行对战。
2.地主赢时，每名农民要支付地主翻倍后的分数。
3.地主输时，地主需要支付每名农民的翻倍分数。
4.若其中一方出现王炸，则可以翻倍计分。
5.若其中一方在出完手中的牌之前请求解散比赛，经其他两方玩家同意，比赛结束，按照当前局面计分。
五、特殊规则1.连续3抢地主没有人叫分，将重新发牌。
2.玩家在出牌时可以选择不出，此时轮到下一玩家出牌。
3.若地主在第一轮出牌后不出，其他玩家也可以选择不出，将重新轮到地主出牌。
4.在出牌时，只有上家出的牌比当前玩家出的牌小，才能出牌或者压制。
斗地主的技巧
斗地主的技巧在斗地主这款经典的扑克牌游戏中，掌握一些技巧可以帮助玩家提高胜率。
本文将介绍斗地主的一些基本技巧和策略，以帮助玩家在游戏中取得更好的成绩。
一、牌型分析在斗地主中，牌型分析是非常重要的一项技巧。
不同的牌型有不同的胜率，玩家应该根据手中的牌型来决定出牌的策略。
1.单牌：单牌是最基本的牌型，通常用于压制对手或者打破对手的连续出牌。
2.对子：对子是两张相同点数的牌，比单牌大，可以用于逼迫对手出更大的牌。
3.三张：三张是三张相同点数的牌，比对子大，可以压制对手或者作为出牌的核心。
4.连对：连对是两对以上连续点数的牌，比三张大，可以作为主要的出牌策略。
5.三带一：三带一是带有一个单牌的三张牌，可以用于逼迫对手出更大的牌。
6.三带一对：三带一对是带有一对的三张牌，比三带一大，可以压制对手。
7.炸弹：炸弹是四张相同点数的牌，它比其他任何牌型都大，是最强大的牌型。
了解不同牌型的大小关系，可以在游戏中做出更明智的决策。
二、记牌技巧记牌是斗地主中的一项高级技巧。
通过统计已经出现过的牌，玩家可以推断剩余牌的分布，并据此做出更好的决策。
1.记牌原则：玩家应该重点关注已经出牌的牌型和数量，并且根据对手的出牌行为来推测对手手中的剩余牌。
2.记牌方法：可以使用纸笔记录已经出的牌，并据此分析牌的分布情况。
另一种方法是使用记牌软件，它可以自动记录已经出牌的情况。
记牌可以帮助玩家更准确地判断对手的手牌情况，从而做出更有利的决策。
三、策略与技巧除了牌型分析和记牌技巧外，斗地主还有一些策略和技巧可以帮助玩家在游戏中取得胜利。
1.主动出牌：在斗地主中，主动出牌是非常重要的策略。
保持主动可以掌控局势，逼迫对手出更大的牌。
当你手中有一些大牌时，应该尽量主动出牌。
2.留牌策略：当你手中有较多的大牌时，可以选择留牌策略，即将大牌保留到最后，出小牌压迫对手。
这样可以降低被逼迫出牌的概率。
3.抢地主策略：抢地主是游戏中的关键时刻，如果你的手牌较强，应该积极参与抢地主，争取获得最有利的位置。
斗地主出牌套路教学设计
斗地主出牌套路教学设计引言：斗地主是一款很受欢迎的扑克牌游戏，出牌的技巧是取得胜利的关键。
在斗地主游戏中，掌握一定的出牌套路可以提高胜率。
本文将介绍一些斗地主出牌的套路，帮助玩家更好地战胜对手。
一、明牌期的套路在斗地主游戏开始的明牌期，玩家可以根据手中的牌型选择出牌的套路。
以下是一些常见的明牌期出牌套路：1. 单牌套路：当玩家手中有单张牌时，可以优先选择出单牌，保留好牌不轻易暴露。
2. 对子套路：当玩家手中有对子时，可以选择出对子，这也有助于保护手中剩余的对子牌。
3. 三带一套路：当玩家手中有三张同样的牌时，可以选择出三带一，这样可以保留一张相同牌型的牌，有利于接下来的出牌。
4. 顺子套路：当玩家手中有连续的牌时，可以选择出顺子，例如34567，这种方式可以干扰对手，增加胜率。
二、跟牌的套路在斗地主出牌过程中，跟牌的技巧也是非常重要的。
以下是一些常见的跟牌套路：1. 单张跟牌套路：当对手出单张牌时，可以选择出手中最小的单牌进行跟牌，这样可以保留手中的大牌。
2. 对子跟牌套路：当对手出对子时，可以选择出手中相同点数的对子进行跟牌，这样既可以相互牵制对手，又可以保留好牌。
3. 三带一跟牌套路：当对手出三带一时，可以选择出手中相同点数的三带一进行跟牌，这样可以保留好牌并削弱对手的牌力。
4. 炸弹跟牌套路：当对手出炸弹时，可以选择出手中更大的炸弹进行跟牌，这样可以反击对手并扭转局势。
三、压牌的套路在斗地主游戏中，压牌是一种非常重要的策略。
以下是一些常见的压牌套路：1. 单张压牌套路：当对手出单张牌时，可以选择出手中更大的单牌进行压牌，这样可以牵制对手。
2. 对子压牌套路：当对手出对子时，可以选择出手中更大的对子进行压牌，这样可以确保自己手中的对子不被对手大过。
3. 三带一压牌套路：当对手出三带一时，可以选择出手中更大的三带一进行压牌，这样可以压制对手并掌握主动权。
4. 炸弹压牌套路：当对手出炸弹时，可以选择出更大的炸弹进行压牌，这样可以打乱对手的节奏并取得压倒性的优势。
斗地主新手必学攻略快速掌握游戏技巧
斗地主新手必学攻略快速掌握游戏技巧斗地主是一款备受欢迎的纸牌游戏，无论是在线上还是线下，都有众多玩家。
对于新手来说，想要快速上手并享受游戏的乐趣，掌握一些关键的技巧和策略是非常重要的。
以下就是为新手们准备的一份斗地主攻略，帮助大家快速提升游戏水平。
一、了解游戏规则这是玩好斗地主的基础。
斗地主使用一副 54 张的扑克牌，其中包括大小王。
游戏由三名玩家进行，分为地主和两个农民。
地主一方单独对抗两个农民。
牌型方面，有单牌、对子、三张相同的牌（称为三带）、顺子（至少五张连续的牌）、连对（至少三个连续的对子）、飞机（两个或更多的三张相同的牌带相同数量的单牌或对子）、炸弹（四张相同的牌）、王炸（大小王一起）等。
出牌时，按照逆时针方向依次出牌。
谁先出完手中的牌谁就获胜。
二、记牌和算牌记牌是斗地主中一项非常重要的技能。
虽然对于新手来说一开始可能有点困难，但通过不断练习是可以逐渐掌握的。
首先，要记住大小王和 2 、 A 这些大牌是否已经出过。
如果在游戏中期还没有看到这些大牌，那么很可能在其他玩家手中，出牌时就要小心。
其次，要留意 3 到 K 这些牌的出牌情况。
比如，如果已经出了很多7 、 8 、 9 这样的牌，那么顺子的可能性就比较小了。
通过记牌和简单的算牌，可以大致推测出其他玩家手中可能的牌型，从而更好地制定自己的出牌策略。
三、观察对手在游戏过程中，要时刻留意对手的出牌方式和习惯。
如果一个对手出牌很激进，总是抢先出牌并且出大牌，那么他可能手中的牌比较好，或者是在故意虚张声势。
另一个对手如果出牌比较谨慎，可能意味着他手中的牌不太好，或者在等待关键的时机。
同时，注意对手出的牌型，比如他经常出三带一，那么可能他手中这种牌型比较多。
四、合理叫地主叫地主是游戏开始的重要环节。
如果手中有大牌（如大小王、 2 、 A 较多），并且有比较整齐的牌型（如顺子、连对），那么可以考虑叫地主。
但如果手中牌比较散，没有什么大牌，最好还是不要冒险叫地主，以免成为地主后被农民围攻。
C语言实现斗地主的核心算法
C语⾔实现⽃地主的核⼼算法数据结构只选择了顺序表，没有选择链表，灵活性和抽象性不⾜，不能普适。
head.h#ifndef __HEAD_H__#define __HEAD_H__#define MAXLEVEL 15typedef struct CARD{int number;int level;char *flower;char point;}card;//卡typedef struct DECK{int top;int arr[55];}deck;//牌堆typedef struct PLAYERS{int id;int status;card handcard[21];int size;}players;//玩家typedef struct GAMES{int type;int level;int sum;int who;int count;int arr[16];}games;//桌⾯typedef struct BUFFERS{int arr[16];int brr[20];int sum;}buffers;//出牌缓冲区/*--------------------------------*/void game_init();void turning();void handcard_sort();void print();int win();void turn_switch();#endifop.c#include<stdio.h>#include<stdlib.h>#include"head.h"#include<string.h>static int type_buffer();static char point[]={'0','3','4','5','6','7','8','9','X','J','Q','K','A','2','w','W'};static char *farr[]={"⽅⽚","梅花","红桃","⿊桃"};static char* type_arr[]={"弃权","单张","对⼦","王炸","骷髅","骷髅单","炸弹","骷髅对","炸带单","顺⼦","炸带⼀对","飞机不带","连对","飞机单","飞机带对"};static char* sta_arr[2]={"农民","地主"};static players player[3];//玩家static games game;/*洗牌堆*/static deck* deck_init(){int i,j;srand(time(0));deck *p_deck=(deck*)malloc(sizeof(deck));if(!p_deck){printf("分配内存失败\n");return NULL;}for(i=1;i<=54;i++){p_deck->arr[i]=rand()%54;for(j=1;j<i;j++){if(p_deck->arr[i]==p_deck->arr[j]){i--;break;}}}p_deck->top=54;return p_deck;}/*初始化玩家(洗牌，id，⾝份⼿牌,总数)*/static void player_init(){int i,j;for(j=0;j<3;j++){for(i=1;i<=20;i++){player[j].handcard[i].number=100;player[j].handcard[i].level =0;}}deck *p=deck_init();if(!p){printf("没有牌堆\n");return ;}int which=0;which=rand()%3;game.who=which;for(i=0;i<3;i++){player[i].id=i;if(i==which){//地主player[i].status=1;for(j=1;j<=20;j++){player[i].handcard[j].number=p->arr[(p->top)--];}player[i].size=20;}else{//农民player[i].status=0;for(j=1;j<=17;j++){free(p);p=NULL;}/*⼿牌信息补完*/static void handcard_init(){int i,j;for(i=0;i<3;i++){for(j=1;j<=20;j++){int number=player[i].handcard[j].number;int *p_level=&(player[i].handcard[j].level);char **pp_flower=&(player[i].handcard[j].flower);char *p_point=&(player[i].handcard[j].point);if(number>=0&&number<=51){*p_level=number/4+1;*p_point=point[number/4+1];*pp_flower=farr[number%4];}else if(number==52){*p_level=14;*p_point='w';*pp_flower="⼩王";}else if(number==53){*p_level=15;*p_point='W';*pp_flower="⼤王";}else {*p_level=0;*p_point=' ';*pp_flower=" ";}}}}/*打印当前玩家⼿牌*/void print(){int i,j;for(i=0;i<3;i++){if (i!=game.who) continue;for(j=1;j<=player[i].size;j++){//printf("======");if(player[i].handcard[j].number == 100){printf(" ");}else {char *p_tmp=player[i].handcard[j].flower;printf("%s ",p_tmp);}}printf("\n");for(j=1;j<=player[i].size;j++){if(player[i].handcard[j].number == 100){printf(" ");}else {printf(" %c ",player[i].handcard[j].point);}}}printf("\n");for(j=1;j<=player[game.who].size;j++){if(! (j>9))printf("(%d) ",j);elseprintf("(%d) ",j);}printf("\n");}/*游戏初始化*/void game_init(){game.count=2;//弃权次数player_init();//洗牌发牌handcard_init();//⼿牌信息补完}int fcmp(const void *pa,const void *pb){//升序return *(int*)pa-*(int*)pb;}static void rehandcard_sort(players *p_player,int* p_number){//真正的排序函数 int *base=p_number;size_t nmemb=p_player->size;size_t size= sizeof(card);qsort(base,20,size,fcmp);}void handcard_sort(){//外壳排序函数rehandcard_sort(&player[0],&(player->handcard[1].number));rehandcard_sort(&player[1],&((player+1)->handcard[1].number));rehandcard_sort(&player[2],&((player+2)->handcard[1].number));}/*询问是否出牌*/static int require(){ //1表⽰出牌 0表⽰弃权if(game.type == 3 ){if(game.count != 2){printf("要不起!\n");return 0;}elsereturn 1;}if(game.count !=2){printf("出牌吗?(y表⽰出牌，n弃权):");char choice;scanf("%c",&choice);scanf("%*[^\n]");scanf("%*c");if(choice == 'n' || choice == 'N'){return 0;}else return 1;}else {buffers buffer={};//出牌缓冲区/*清空出牌缓冲区*/static void reset(){int a;for(a=0;a<16;a++)buffer.arr[a]=0;for(a=0;a<20;a++)buffer.brr[a]=0;buffer.sum=0;}/*放牌进⼊缓冲区*/static void buffer_put(){char intput[40]={};//把字符串转换为数字int brr[20]={};int i=0;int j;int sum;int flag=0;while(1){reset();sig: printf("请输⼊要放的牌...:");fgets(intput,40,stdin);if(strlen(intput)==39&&intput[38]!='\n'){scanf("%*[^\n]");scanf("%*c");}for(j=0,i=0,sum=0;i<strlen(intput);i++){//记录出牌下标if(intput[i]>='0'&&intput[i]<='9'){sum=sum*10+(intput[i]-'0');flag=1;}else {if(flag)brr[j] = sum;sum=0;j++;flag=0;}}int k;printf("要出: ");for(k=0;brr[k];k++)printf("%d ",brr[k]);printf("号牌\n");int who = game.who;players* p_player=&(player[who]);int index;for(i=0;brr[i];i++){//记录出的牌是什么index=brr[i];if(index>(p_player->size) || index<=0 ){//输⼊的字符串范围有误printf("输⼊内容超出范围，重新输⼊\n");goto sig;}else{int level=p_player->handcard[index].level;++(buffer.arr[level]);buffer.brr[i] =brr[i];}}for(i=1;i<=15;i++)//记录出了多少张牌buffer.sum+=buffer.arr[i];char aff= 'N';int type = type_buffer();if(type != -1)printf("要出的类型是:%s\n\n",type_arr[type]);else {printf("不存在此类型的牌\n\n");reset();return;}printf("确定要这样出吗?(确定输⼊y,否则按其它)");scanf("%c",&aff);scanf("%*[^\n]");scanf("%*c");if(aff == 'y' || aff =='Y')break;}}static void turnstart(){char u;printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n==============================================================⽃地主======================================================\n\n\n\n\n"); printf("轮到下⼀家");scanf("%c",&u);int i;printf("\n\n\n\n\n\n\n牌⾯张数为%d张\n",game.sum);printf("牌⾯类型为: %s%c\n",type_arr[game.type],point[game.level]);printf("=============================================================%s的回合==========================================================\n\n",sta_arr[player[game.who].status]);printf("现在轮到玩家%d",game.who+1);printf(" 玩家1(%s)⼿牌%d ",sta_arr[player[0].status],player[0].size);if(game.who==0) printf("<=====\n");else printf("\n");printf(" 玩家2(%s)⼿牌%d ",sta_arr[player[1].status],player[1].size);if(game.who == 1) printf("<=====\n"); else printf("\n");printf(" 玩家3(%s)⼿牌%d ",sta_arr[player[2].status],player[2].size);if(game.who == 2) printf("<=====\n"); else printf("\n");}/*判断是否连续*/static int continuum(int num,int total){int i,count=0;int flag=0;//有值则标记为1int sig=0;//从有到⽆改标记为1for(i=1;i<=15;i++){if(buffer.arr[i]==num){if(sig)return 0;//⾮连续count++;if(count==total)return 1;//连续flag=1;}else {if (flag)sig=1;}}}/*获取缓冲区牌类类型*/if(buffer.arr[i] == 1)one++;else if(buffer.arr[i] == 2)pair ++;else if(buffer.arr[i] == 3)triple ++;else if(buffer.arr[i] == 4)quattuor ++;else zero++;}//printf("单%d 对%d 三%d 四%d 零%d,sum%d===\n",one,pair,triple,quattuor,zero,buffer.sum);if(!(buffer.sum)){return -1;//⾮法}else if(buffer.sum<=5){//1~5if(one == 1 && !pair && !triple && !quattuor)//单张return 1;else if(pair == 1 && !one && !triple && !quattuor)//对⼦return 2;else if(one == 2 &&buffer.arr[14]&&buffer.arr[15])//王炸return 3;else if(triple == 1 && !one && !pair && !quattuor) //骷髅return 4;else if(one ==1 && !pair && triple == 1 && !quattuor )//骷髅单return 5;else if(!one && !pair && !triple && quattuor == 1)//炸return 6;else if(!one && pair == 1 && triple == 1 && !quattuor)//骷髅对return 7;else if(one == 1 && !pair && !triple && !quattuor){//炸带单return 8;}else if(!pair && !triple && !quattuor && (!buffer.arr[14] && !buffer.arr[15])&& buffer.sum == 5){//顺⼦ if( continuum(1,one))//所有1连续return 9;else {return -1;}}else return -1;}else if(buffer.sum>=6){if((!one) && (pair == 1) && (!triple) && (quattuor == 1) )//炸带对return 10;else if(!one && !pair && !quattuor){//只有2个以上个三张相同飞机不带if(continuum(3,triple))//所有3连续return 11;else return -1;}else if(!one && !triple && !quattuor){//连对if(continuum(2,pair))return 12;else return -1;}else if(buffer.sum == 4*triple){//飞机单if(continuum(3,triple))return 13;else return -1;}else if((buffer.sum == 5*triple) && (triple == pair)){//飞机对if(continuum(3,triple))return 14;else return -1;}else if(!pair && !triple && !quattuor &&(!buffer.arr[14] && !buffer.arr[15])){if(continuum(1,one))return 9;else return -1;}else return -1;}}/*最⼤下标*/static int maxindex(int count){int i;for (i=15;i>=1;i--){if(buffer.arr[i] == count)return i;}}/*获取缓冲区牌类等级*/static int level_buffer(int type){switch(type){case 1:return maxindex(1);break;case 2:return maxindex(2);break;case 3:return 15;break;case 4:return maxindex(3);break;case 5:return maxindex(3);break;case 6:return maxindex(4);break;case 7:return maxindex(3);break;case 8:return maxindex(4);break;case 9:return maxindex(1);break;case 10:return maxindex(4);break;case 11:return maxindex(3);break;case 13:return maxindex(3);break;case 14:return maxindex(3);break;}}/*消减⼿牌*/static void annealation(){int i=1;int j=0;int who=game.who;for(i = 1,j=0;buffer.brr[j];i++,j++){int index = buffer.brr[j];player[who].handcard[index].number = 100;player[who].size = player[who].size - 1;}game.sum=buffer.sum;game.count=0;handcard_sort();//printf("出牌成功\n");}/*回合进⾏中*/ //这个模块有很⼤的修改空间例如return 改为break... void turning(){turnstart(); /* 开始阶段 */handcard_sort();print();int level= 0;while(1){if(!require()){printf("\n\n\n\n\n\n\n\n不要\n");game.count++;if(game.count == 2){game.type=0;game.level=0;game.sum=0;}return ; /* 开始阶段 */}buffer_put(); /* 出牌阶段在这函数判断是否弃权⽐较好 */ int type = type_buffer();int level=level_buffer(type);if(type == -1){printf("牌类⾮法!-----\n");continue;}if(type == 3){//王炸printf("\n\n\n\n\n王炸!!\n");annealation();game.type=3;game.level=MAXLEVEL;return ;}else if(type == 6){//炸弹if(game.type != 6){printf("\n\n\n\n炸弹\n");annealation();game.type = 6;game.level = level_buffer(type);return;}else {if(level > game.level){printf("\n\n\n\n\n压死\n");annealation();//消减⼿牌game.type = 6;game.level = level;return;}else if(level < game.level||level == game.level){printf("牌的等级不够⼤\n");continue;}}}else if(game.count == 2 ){//两家弃权annealation();game.type = type;game.level = level;return ;}else {//除了炸弹两家弃权王炸⾮法以外的合理牌类if(type != game.type){ //不对应printf("类型不对应\n");continue;}else { //对应if(buffer.sum != game.sum){printf("数量不对应\n");continue;}if(level < game.level|| level==game.level){printf("牌的等级不够⼤\n");continue;}else if(level > game.level){printf("\n\n\n\n\n压死\n");annealation();game.type = type;game.level = level;return ;}}}}}/*0 1 2 3判断是否是谁胜利 0表⽰没有 1表⽰玩家⼀*/int win(){int now = game.who;if(!player[now].size)return now;else return 0;}/*切换当前玩家为下家*/game.who = who%3;}main.c#include<stdio.h>#include"head.h"int main(){while(1){int which;game_init();//初始化游戏while(1){turning();//回合进⾏中printf("\n\n\n");if(which=win())//是否产⽣胜者break;turn_switch();//切换出牌⽅}printf("胜负已出！胜利者是玩家%d\n",which+1);printf("是否重新游戏?(y为继续，其它退出程序):");char choice;scanf("%c",&choice);scanf("%*[^\n]");scanf("%*c");if(choice == 'y'||choice =='Y')continue;break;}printf("谢谢试玩\n");}以上所述就是本⽂的全部内容了，希望对⼤家熟练应⽤C语⾔能够有所帮助。
单机版斗地主的游戏算法的设计毕业设计论文
摘要随着科技的进步，计算机已经普及每个家庭，而计算机游戏也随之越来越多，越来越丰富。
网络游戏、单机游戏等休闲游戏让众多人喜欢，而斗地主也受广大群众的追捧。
本设计以一副牌规则为准，将整个游戏按照发牌,叫牌，拆牌，以及出牌的流程划分为4个部分，开始时由系统调用发牌函数每人随机分到17张牌，留存3张底牌，然后电脑AI根据自己手上牌值与牌型结合给定权值决定是否叫三张底牌当地主。
一旦叫牌成功，剩下两玩家就是农民，联合“斗地主”。
双方以是否出完牌来决定胜负。
如果地主的20张牌都出完了，则地主一方胜；如果两个农民中任何一人手中的17张牌出完了，则农民一方胜出。
本论文主要讲述了单机版斗地主的游戏算法的设计，以Visual C++语言编译的一个应用程序。
使用者可以简单方便的实现斗地主游戏。
本程序界面友好，操作简单，比较实用。
本程序在详细设计时不断地修正和完善，经过测试阶段反复调试和验证，最终形成达到设计要求的可行系统。
关键词: 斗地主;纸牌; Visual C++;游戏核心算法AbstractWith the progress of science and technology, computers have universal every family, and with more and more computer games, increasingly rich.The network game, LAN game and other casual games for many people like it, but Landlord also affected by the broad masses in both hands.This design will be subject to rules of a deck of cards, the entire game in accordance with the licensing, call, cards, as well as the process is divided into four parts.Licensing function is called by the system at the beginning, then 17 cards are randomly assigned to each person and three cards are also retained. After that, the computer AI decides whether to call cards based on it's own cards value and the cards type which all have a particular weight.Once the call is successful, the remaining two players is farmers, jointing "Landlords". Whether the two sides finish cards determine the winner. If the landlord's 20 cards are finished, the landlord side win; If any one of the two farmers finishes 17 cards , the farmers win.This paper tells the stand-alone Landlord game algorithm is designed to Visual c + + language compiled an application. Users can simple to realize Fight the Landlord game. This procedure friendly interface, the operation is simple, is more practical.This procedure in the detailed design constantly correction and perfect when, after testing phase repeated commissioning and validation, and finally form the feasible system to meet the design requirements.Key Words: Fight the landlord; Cards; Visual C++; Game core algorithm目录1 绪论1.1 课题背景 (1)1.2 研究现状 (1)1.3 研究项目及意义 (1)1.4 本文的结构安排 (1)1.5 系统开发工具及其介绍 (2)1.5.1 开发工具的选择 (2)1.6 Visual C++编程特点 (3)1.6.1 C++语言的发展 (3)1.6.2 Visual C++ 6.0简介 (3)1.6.3 Visual C++ 6.0的开发环境 (4)2 斗地主基本知识 (4)2.1 斗地主规则 (4)2.2游戏流程框架 (5)3 主要模块 (6)3.1发牌 (6)3.1.1 第一发牌方案 (6)3.1.2第二发牌方案 (7)3.1.3 发牌算法的代码实现 (8)3.2 叫牌 (10)3.2.1 叫牌判断 (10)3.2.2 牌型估值 (10)3.3 拆牌 (14)3.3.1拆牌原因 (14)3.3.2寻找拆牌方案 (15)3.3.3 拆牌实例 (22)3.4 出牌 (22)3.4.1 出牌方法产生 (22)3.4.2 产生方法 (23)3.4.3效率问题 (24)3.4.4逐个产生和全部产生 (24)3.4.5内存使用 (25)4 结论及展望 (25)致谢 (27)参考文献 (28)1 绪论1.1 课题背景“斗地主”起源于湖北，据传是一位叫吴修全的年轻人，根据当地流行的扑克玩法“跑的快”改编的。
[引]一个斗地主算法
![[引]一个斗地主算法](https://img.taocdn.com/s3/m/f9b2fa2042323968011ca300a6c30c225901f007.png)
[引]⼀个⽃地主算法此前，在公司的项⽬开发中，我负责着⼿解决这样⼀个问题：在⽃地主游戏中，根据玩家出的牌分析出这⼿牌的牌型。
⼤家知道，在⽃地主游戏中，总计有⼗⼀种牌型：⽕箭：即双王（⼤王和⼩王）。
炸弹：四张同数值牌（如四个7）。
单牌：单个牌（如红桃5）。
对牌：数值相同的两张牌（如梅花4+⽅块4）。
三张牌：数值相同的三张牌（如三个J）。
三带⼀：数值相同的三张牌 + ⼀张单牌或⼀对牌。
例如： 333+6或444+99单顺：五张或更多的连续单牌（如：45678或78910JQK）。
不包括2点和双王。
双顺：三对或更多的连续对牌（如：334455、7788991010JJ）。
不包括2点和双王。
三顺：⼆个或更多的连续三张牌（如：333444、555666777888）。
不包括2点和双王。
飞机带翅膀：三顺＋同数量的单牌（或同数量的对牌）。
如：444555+79 或333444555+7799JJ四带⼆：四张牌＋两⼿牌。
（注意：四带⼆不是炸弹）。
如：5555＋3＋8或4444＋55＋77。
那么，如何由玩家出的牌分析出这⼿牌到底是哪⼀种牌型呢？在我们试着⽤程序解决这个问题之前，先来回顾⼀下在现实的⽣活中是如何分辨⼀⼿牌的牌型的。
在⽃地主游戏中，确定不同牌型的⼀个重要依据是看这⼿牌中有多少张牌的数字是相同的。
⽐如⼀⼿这样的牌：梅花2＋⽅块3＋红桃3＋⿊桃3，在我们的思维中，⾸先会计算有最多相同数字的那些牌的个数，也就是这⾥的三个 3，在这⾥，3总计出现了3次。
根据最多出现相同数字的情况，我们可以把⼀⼿牌先分成四种情况：1、所有数字只出现⼀次2、相同数字的牌出现两次3、相同数字的牌出现三次4、相同数字的牌出现四次5、不可能出现的情况：相同数字的牌出现⼤于四次或⼩于1次。
其中，在以上的1、2、3、4中⼜可能分为多种情况，⽐如在1中，虽然相同数字最多只出现⼀次，但不能因此就断定它是单张，它也有可能是双王（这⾥假定⼤⼩王的数字不相同）或单顺；在2中，出现两次的情况下，⼜进⼀步分为：对⼦和双顺两种情况；在3中，出现三次的情况下，可能有以下牌型：单三张，三带⼀，三顺或飞机；在4中，出现4个相同数字牌的时候，可能有以下牌型：炸弹和四带⼆。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
斗地主算法的设计与实现--如何判断一手牌的类型(单,对子,三不带,三带一,四代二等)斗地主游戏算法牌型项目研发本篇主要讲解斗地主中如何判断一手牌的牌型。
牌型火箭：即双王（大王和小王），最大的牌。
炸弹：四张点数相同的牌，如：7777。
单牌：任意一张单牌。
对牌：任意两张点数相同的牌。
三张：任意三张点数相同的牌，如888。
三带一：点数相同的三张牌+一张单牌或一对牌。
如：333+6 或444+99。
单顺：任意五张或五张以上点数相连的牌，如：45678或78910JQK。
不包括2和双王。
双顺：三对或更多的连续对牌，如：334455、7788991010JJ。
不包括2 点和双王。
三顺：二个或更多的连续三张牌，如：333444 、555666777888。
不包括2 点和双王。
飞机带翅膀：三顺＋同数量的单牌或同数量的对牌。
如：444555+79 或333444555+7799JJ四带二：四张牌＋两手牌。
（注意：四带二不是炸弹）。
如：5555＋3＋8 或4444＋55＋77 。
友情提示：本篇是接着上1篇讲述的，建议先看看上1篇一张牌Card的构造过程。
斗地主算法的设计与实现--项目介绍&如何定义和构造一张牌/*** 游戏规则牌的类型共有10种：** 1. 单2.对子3.3不带4.3带1 5.炸弹6.顺子7.4带2 8.连队9.飞机10.对王** @author LeiWen@,,* /FansUnion**/1.单1/**2 * 判断牌是否为单3 *4 * @param myCards5 * 牌的集合6 * @return 如果为单，返回true；否则，返回false。
7 */8public static boolean isDan(List<Card> myCards) { 9// 默认不是单10boolean flag = false;11if (myCards != null && myCards.size() == 1) {12 flag = true;13 }14return flag;15 }2.对子16/**17 * 判断牌是否为对子18 *19 * @param myCards20 * 牌的集合21 * @return 如果为对子，返回true；否则，返回false。
22 */23public static boolean isDuiZi(List<Card> myCards) {24// 默认不是对子25boolean flag = false;2627if (myCards != null && myCards.size() == 2) {2829int grade1 = myCards.get(0).grade;30int grade2 = myCards.get(1).grade;31if (grade1 == grade2) {32 flag = true;33 }34 }3536return flag;3738 }3.3带1/**39* 判断牌是否为3带140 *41 * @param myCards42 * 牌的集合43 * @return如果为3带1，被带牌的位置，0或3，否则返回-1。
炸弹返回-1。
44 */45public static int isSanDaiYi(List<Card> myCards) {46int flag = -1;47// 默认不是3带148if (myCards != null && myCards.size() == 4) {49// 对牌进行排序50 CardUtil.sortCards(myCards);5152int[] grades = new int[4];53 grades[0] = myCards.get(0).grade;54 grades[1] = myCards.get(1).grade;55 grades[2] = myCards.get(2).grade;56 grades[3] = myCards.get(3).grade;5758// 暂时认为炸弹不为3带159if ((grades[1] == grades[0]) && (grades[2] == grades[0])60 && (grades[3] == grades[0])) {61return -1;62 }63// 3带1，被带的牌在牌头64else if ((grades[1] == grades[0] && grades[2] == grades[0])) { 65return0;66 }67// 3带1，被带的牌在牌尾68else if (grades[1] == grades[3] && grades[2] == grades[3]) { 69return3;70 }71 }72return flag;73 }4.3不带74/**75 * 判断牌是否为3不带76 *77 * @param myCards78 * 牌的集合79 * @return 如果为3不带，返回true；否则，返回false。
80 */81public static boolean isSanBuDai(List<Card> myCards) {82// 默认不是3不带83boolean flag = false;8485if (myCards != null && myCards.size() == 3) {86int grade0 = myCards.get(0).grade;87int grade1 = myCards.get(1).grade;88int grade2 = myCards.get(2).grade;8990if (grade0 == grade1 && grade2 == grade0) {91 flag = true;92 }93 }94return flag;95 }5.顺子96/**97 * 判断牌是否为顺子98 *99 * @param myCards100 * 牌的集合101 * @return 如果为顺子，返回true；否则，返回false。
102 */103public static boolean isShunZi(List<Card> myCards) {104// 默认是顺子105boolean flag = true;106107if (myCards != null) {108109int size = myCards.size();110// 顺子牌的个数在5到12之间111if (size < 5 || size > 12) {112return false;113 }114115// 对牌进行排序116 CardUtil.sortCards(myCards);117118for (int n = 0; n < size - 1; n++) {119int prev = myCards.get(n).grade;120int next = myCards.get(n + 1).grade;121// 小王、大王、2不能加入顺子122if (prev == 17 || prev == 16 || prev == 15 || next == 17 123 || next == 16 || next == 15) {124 flag = false;125break;126 } else {127if (prev - next != -1) {128 flag = false;129break;130 }131132 }133 }134 }135136return flag;137 }6.炸弹138/**139 * 判断牌是否为炸弹140 *141 * @param myCards142 * 牌的集合143 * @return 如果为炸弹，返回true；否则，返回false。
144 */145public static boolean isZhaDan(List<Card> myCards) {146// 默认不是炸弹147boolean flag = false;148if (myCards != null && myCards.size() == 4) {149150int[] grades = new int[4];151 grades[0] = myCards.get(0).grade;152 grades[1] = myCards.get(1).grade;153 grades[2] = myCards.get(2).grade;154 grades[3] = myCards.get(3).grade;155if ((grades[1] == grades[0]) && (grades[2] == grades[0]) 156 && (grades[3] == grades[0])) {157 flag = true;158 }159 }160return flag;161 }7.王炸162/**163 * 判断牌是否为王炸164 *165 * @param myCards166 * 牌的集合167 * @return 如果为王炸，返回true；否则，返回false。
168 */169public static boolean isDuiWang(List<Card> myCards) { 170// 默认不是对王171boolean flag = false;172173if (myCards != null && myCards.size() == 2) {174175int gradeOne = myCards.get(0).grade;176int gradeTwo = myCards.get(1).grade;177178// 只有小王和大王的等级之后才可能是33179if (gradeOne + gradeTwo == 33) {180 flag = true;181 }182 }183return flag;184 }8.连对185/**186 * 判断牌是否为连对187 *188 * @param myCards189 * 牌的集合190 * @return 如果为连对，返回true；否则，返回false。