斗地主相关算法实现

  1 <!DOCTYPE html>
  2 <html lang="en">
  3 <head>
  4     <meta charset="UTF-8">
  5     <title>Title</title>
  6     <script>
  7         var PokerType = {
  8             danzhang: 1,
  9             duizi: 2,
 10             sanzhang: 3,
 11             sandaiyi: 4,
 12             sandaiyidui: 5,
 13             shunzi: 6,
 14             liandui: 7,
 15             feiji: 8,
 16             sidaier: 9,
 17             sidailiangdui: 10,
 18             zhadan: 11,
 19             wangzha: 12,
 20             error: 13
 21         };
 22
 23         var Poker = {
 24             sort: function (pokers) {
 25                 pokers.sort(function (prev, next) {
 26                     return next - prev
 27                 })
 28             },
 29
 30             getPokeValue: function (poker) {
 31                 if (poker == 52) {
 32                     return 16
 33                 }
 34
 35                 if (poker == 53) {
 36                     return 17
 37                 }
 38
 39                 return Math.floor(poker / 4) + 3
 40             },
 41
 42             getPokeType: function (pokers) {
 43                 var len = pokers.length;
 44                 var i = 0;
 45                 var countPoker = 0;
 46                 var duizi = false;
 47                 var sanzhang = false;
 48                 var zhadan = false;
 49                 var tempArray = [];
 50
 51                 if (len == 1) {
 52                     return PokerType.danzhang
 53                 }
 54
 55                 if (len == 2) {
 56                     if (pokers[0] == 53 && pokers[1] == 52) {
 57                         return PokeType.wangzha
 58                     }
 59
 60                     if (this.getPokeValue(pokers[0]) == this.getPokeValue(pokers[1])) {
 61                         return PokeType.duizi
 62                     }
 63                 }
 64
 65                 if (len == 3 && this.getPokeValue(pokers[0]) == this.getPokeValue(pokers[1]) && this.getPokeValue(pokers[1]) == this.getPokeValue(pokers[2])) {
 66                     return PokeType.sanzhang;
 67                 }
 68
 69                 if (len == 4) {
 70                     var countFirstPoker = this.getPokeCount(pokers, pokers[0])
 71                     if (countFirstPoker == 4) {
 72                         return PokerType.zhadan
 73                     }
 74
 75                     if (countFirstPoker == 3 || this.getPokeCount(pokers, pokers[1]) == 3) {
 76                         return PokeType.sandaiyi
 77                     }
 78                 }
 79
 80                 if (len == 5) {
 81                     sanzhang = false;
 82                     duizi = false;
 83                     for (i = 0; i < len; i++) {
 84                         countPoker = this.getPokeCount(pokers, pokers[i])
 85                         if (countPoker == 3) {
 86                             sanzhang = true
 87                         }
 88
 89                         if (countPoker == 2) {
 90                             duizi = true
 91                         }
 92                     }
 93
 94                     if (sanzhang && duizi) {
 95                         return PokerType.sandaiyidui
 96                     }
 97                 }
 98
 99                 if (len >= 5 && this.shunzi(pokers)) {
100                     return PokeType.shunzi;
101                 }
102
103                 if (len == 6) {
104                     if (pokers[0] == 53 && pokers[1] == 52) {
105                         return PokeType.error
106                     }
107
108                     zhadan = false;
109                     for (i = 0; i < len; i++) {
110                         if (this.getPokeCount(pokers, pokers[i]) == 4) {
111                             zhadan = true
112                         }
113                     }
114
115                     if (zhadan) {
116                         return PokeType.sidaier
117                     }
118                 }
119
120                 if (len >= 6 && len % 2 == 0) {
121                     duizi = true;
122                     for (i = 0; i < len; i++) {
123                         if (this.getPokeCount(pokers, pokers[i]) != 2) {
124                             duizi = false;
125                             break
126                         }
127                     }
128
129                     tempArray = [];
130                     if (duizi) {
131                         for (i = 0; i < len / 2; i++) {
132                             tempArray[i] = pokers[i * 2]
133                         }
134
135                         if (this.shunzi(tempArray)) {
136                             return PokerType.liandui
137                         }
138                     }
139                 }
140
141                 if (len >= 6 && len % 3 == 0) { // 飞机不带
142                     sanzhang = true;
143                     for (i = 0; i < len; i++) {
144                         if (this.getPokeCount(pokers, pokers[i]) != 3) {
145                             sanzhang = false;
146                             break
147                         }
148                     }
149
150                     tempArray = [];
151                     if (sanzhang) {
152                         for (i = 0; i < len / 3; i++) {
153                             tempArray[i] = pokers[i * 3]
154                         }
155
156                         if (this.shunzi(tempArray)) {
157                             return PokerType.feiji
158                         }
159                     }
160                 }
161
162                 if (len == 8) {
163                     duizi = false;
164                     zhadan = false;
165                     for (i = 0; i < len; i++) {
166                         countPoker = this.getPokeCount(pokers, pokers[i]);
167                         if (countPoker == 2) {
168                             duizi = true;
169                         } else if (countPoker == 4) {
170                             zhadan = true;
171                         } else {
172                             duizi = false;
173                             break
174                         }
175                     }
176
177                     if (duizi && zhadan) {
178                         return PokerType.sidailiangdui
179                     }
180                 }
181
182                 if (len >= 8 && len % 4 == 0) {
183                     if (pokers[0] == 53 && pokers[1] == 52) {
184                         return PokeType.error
185                     }
186
187                     tempArray = [];
188                     for (i = 0; i < len; i++) {
189                         countPoker = this.getPokeCount(pokers, pokers[i]);
190                         if (countPoker == 3) {
191                             tempArray.push(pokers[i])
192                         }
193                     }
194
195                     if (tempArray.length == len / 4 * 3 && this.getPokeType(tempArray) == PokerType.feiji) {
196                         return PokerType.feiji
197                     }
198                 }
199
200                 if (len >= 10 && len % 5 == 0) {
201                     duizi = false;
202
203                     tempArray = [];
204                     for (i = 0; i < len; i++) {
205                         countPoker = this.getPokeCount(pokers, pokers[i]);
206                         if (countPoker == 2) {
207                             duizi = true;
208                         } else if (countPoker == 3) {
209                             tempArray.push(pokers[i])
210                         } else {
211                             duizi = false;
212                             break
213                         }
214                     }
215
216                     if (duizi && tempArray.length == len / 5 * 3 && this.getPokeType(tempArray) == PokerType.feiji) {
217                         return PokerType.feiji
218                     }
219                 }
220
221                 return PokerType.error
222             },
223
224             shunzi: function (pokers) {
225                 var pokeValue = this.getPokeValue(pokers[0]);
226                 if (pokeValue >= 15) { // 2,大、小王
227                     return false
228                 }
229
230                 for (var i = 1; i < pokers.length; i++) {
231                     var pokeValue2 = this.getPokeValue(pokers[i]);
232                     if (pokeValue - pokeValue2 != 1) {
233                         return false
234                     }
235
236                     pokeValue = pokeValue2
237                 }
238
239                 return true
240             },
241
242             getPokeCount: function (pokers, poker) {
243                 var count = 0;
244                 for (var i = 0; i < pokers.length; i++) {
245                     if (this.getPokeValue(pokers[i]) == this.getPokeValue(poker)) {
246                         count++
247                     }
248                 }
249
250                 return count
251             },
252         }
253
254         var pokers = [];
255
256         // 0 代表方块3 1 代表梅花3 2 代表红桃3 3 代表黑桃3
257         for (var i = 0; i < 54; i++) {
258             pokers[i] = i
259         }
260
261         pokers = [0, 4, 8, 12, 16]; // 3、4、5、6、7
262         pokers = [0, 1, 2, 4, 5, 6]; // 333、444
263         pokers = [0, 1, 2, 3, 4, 5, 8, 9]; // 3333、 44、55
264         pokers = [0, 1, 2, 3, 4, 5, 6, 7]; // 3333、 4444
265         pokers = [0, 1, 2, 4, 5, 6, 8, 9]; // 333、444、55
266
267         Poker.sort(pokers);
268
269         if (Poker.shunzi(pokers)) {
270             console.log("顺子:", pokers)
271         }
272
273         console.log("牌型:" , Poker.getPokeType(pokers))
274     </script>
275 </head>
276 <body>
277
278 </body>
279 </html>
时间: 2024-08-02 13:21:45

斗地主相关算法实现的相关文章

探索推荐引擎内部的秘密,第 2 部分: 深入推荐引擎相关算法 - 协同过滤(转)

第 2 部分: 深入推荐引擎相关算法 - 协同过滤 本系列的第一篇为读者概要介绍了推荐引擎,下面几篇文章将深入介绍推荐引擎的相关算法,并帮助读者高效的实现这些算法. 在现今的推荐技术和算法中,最被大家广泛认可和采用的就是基于协同过滤的推荐方法.它以其方法模型简单,数据依赖性低,数据方便采集 , 推荐效果较优等多个优点成为大众眼里的推荐算法“No.1”.本文将带你深入了解协同过滤的秘密,并给出基于 Apache Mahout 的协同过滤算法的高效实现.Apache Mahout 是 ASF 的一个

数据结构(C语言版)顺序栈相关算法的代码实现

这两天完成了栈的顺序存储结构的相关算法,包括初始化.压栈.出栈.取栈顶元素.判断栈是否为空.返回栈长度.栈的遍历.清栈.销毁栈.这次的实现过程有两点收获,总结如下: 一.清楚遍历栈的概念 栈的遍历指的是从栈底想栈顶方向运行visit()函数,这是之前的学习中所忽略的:栈的遍历解除了栈的输出顺序只能从栈顶像栈底方向的限制. 二.清空栈时要不要将stacksize重置 网上看到有的人在实现清空栈这一功能时,将stacksize重置为0,我觉得有点问题,起初的想法是将其重置为初始化时的值,在与同学讨论

加密类型及其相关算法

在互联网通信过程中,如何保证数据的安全性? 在通信过程中,数据安全主要从三个方面考虑:机密性(数据的内容不能被窃取) 完整性(数据的内容不能被修改) 身份验证(确定通信双方的身份) 加密类型:1.对称加密,加密和解密使用同一个密钥,但是密钥如何安全传输比较重要,对称加密数度较快,适于加密数据 2.单向加密,提取数据指纹,主要用于保证数据的完整性 单向加密的特点:输入相同则输出一定相同 雪崩效应:输入的微小改变会引起结果的巨大反差 定长输出 3.非对称加密,使用一对密钥(public-key和pr

探索推荐引擎内部的秘密,第 3 部分: 深入推荐引擎相关算法 - 聚类

聚类分析 什么是聚类分析? 聚类 (Clustering) 就是将数据对象分组成为多个类或者簇 (Cluster),它的目标是:在同一个簇中的对象之间具有较高的相似度,而不同簇中的对象差别较大.所以,在很多应用中,一个簇中的数据对象可以被作为一个整体来对待,从而减少计算量或者提高计算质量. 其实聚类是一个人们日常生活的常见行为,即所谓"物以类聚,人以群分",核心的思想也就是聚类.人们总是不断地改进下意识中的聚类模式来学习如何区分各个事物和人.同时,聚类分析已经广泛的应用在许多应用中,包

linux学习之路之加密类型及其相关算法

加密类型及其相关算法 随着互联网越演越烈,互联网上的各种攻击层出不穷,因此在互联网上相互传递的信息越来越不安全,因此为了防止用户在互联网上传递的数据被窃取,因此我们很有必须加强传递的数据的安全性. 数据的安全性主要包括以下三个方面: 数据的机密性:保证传递的数据不被读取 要想使传递的数据不被读取,可以对这些数据进行加密,因为默认这些数据是以明文来传递的 整个加密过程可以这么来理解: 加密:plaintext--->转换规则--->ciphertext 解密:ciphertext--->转

二分查找的相关算法题

最近笔试经常遇到二分查找的相关算法题 1)旋转数组中的最小数字 2)在旋转数组中查找某个数 2)排序数组中某个数的出现次数 下面我来一一总结 1 旋转数组的最小数字 题目:把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转.输入一个递增排序的数组的一个旋转,输出旋转数组的最小元素.例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转,该数组的最小值为1. 实现数组的旋转见左旋转字符串. 和二分查找法一样,用两个指针分别指向数组的第一个元素和最后一个元素. 我们注意到旋转

深入推荐引擎相关算法 - 协同过滤

集体智慧和协同过滤 什么是集体智慧 集体智慧 (Collective Intelligence) 并不是 Web2.0 时代特有的,只是在 Web2.0 时代,大家在 Web 应用中利用集体智慧构建更加有趣的应用或者得到更好的用户体验.集体智慧是指在大量的人群的行为和数据中收集答案,帮助你对整个人群得到统计意义上的结论,这些结论是我们在单个个体上无法得到的,它往往是某种趋势或者人群中共性的部分. Wikipedia 和 Google 是两个典型的利用集体智慧的 Web 2.0 应用: Wikip

容器set相关算法

 set_union 算法set_union可构造S1.S2的并集.此集合内含S1或S2内的每一个元素.S1.S2及其并集都是以排序区间表示.返回值是一个迭代器,指向输出区间的尾端. 由于S1和S2内的每个元素都不需唯一,因此,如果某个值在S1出现n次,在S2出现m次,那么该值再输出区间中会出现max(m,n)次,其中n个来自S1,其余来自S2.在STL set容器内,m小于等于1,n小于等于1. template <class InputIterator1,classInputIterat

【目录】数据挖掘与机器学习相关算法文章总目录

本博客所有文章分类的总目录链接:http://www.cnblogs.com/asxinyu/p/4288836.html 数据挖掘与机器学习相关算法文章目录 1.数据挖掘之—基于ReliefF和K-means算法的医学应用实例  2.彩票数据预测算法(一):离散型马尔可夫链模型实现[附C#代码]