小练习：20170109 在扑克游戏中玩家1能赢多少局？

冬雪雪冬 · 发表于 2017-1-8 21:09:19

马上注册，结交更多好友，享用更多功能^_^

您需要登录才可以下载或查看，没有账号？立即注册

x

本帖最后由冬雪雪冬于 2017-1-16 10:29 编辑

从现在开始我们要开展一批欧拉计划的习题练习。
其实在我们论坛中已有欧拉计划的板块，可能有些鱼油还没注意到。
什么是欧拉计划：http://bbs.fishc.com/thread-60405-1-1.html
我们欧拉板块现已给出了200余题，这批练习将从欧拉计划中选题。其实用python语言完成有很多的优势，可以更简洁更方便的实现。
如果大家有兴趣也可浏览欧拉的英文网站：https://projecteuler.net/archives
这里已经有了500余题。

登录/注册后可看大图

题目要求：
以python语言完成，如果是python2请注明。
程序以代码文字格式发帖。
注重程序效率和创意。
答题在一周内完成，即1.16 10：00之前，其后将公开大家的答案，并评比成绩。
另程序和答案可以在网上搜到，希望大家独立完成。题目不难，大家看看谁的效率高。

----回帖需写明解题思路，鼓励在程序中加上注释-----
----除列出程序外，请给出输出的结果。----

题目：

在扑克游戏中，一局牌由五张牌组成，组成的牌的大小由低向高如下：

High Card: 最高值的牌.
One Pair: 两张面值一样的牌.
Two Pairs: 两个值不同的One Pair.
Three of a Kind: 三张面值一样的牌.
Straight: 所有的牌面值为连续数值.
Flush: 所有的牌花色相同.
Full House: Three of a Kind 加一个One Pair.
Four of a Kind: 四张牌面值相同.
Straight Flush: 所有的牌花色相同并且为连续数值.
Royal Flush: 10，J，Q，K和A，并且为相同花色。

牌的面值大小排序如下：
2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King, Ace.

如果两个玩家的牌具有同样的排序（上面介绍的几种），那么他们牌的大小由手中最大的牌决定。例如，一对 8 比一对 5 大（见下面例一）；但是如果两个玩家都用一对 Q，那么他们手中最大的牌就用来比较大小（见下面例四）；如果他们最高面值的牌也相等，那么就用次高面值的牌比较，以此类推。

考虑下面的几个例子：

登录/注册后可看大图

文件

p054_poker.zip (29.3 KB, 下载次数: 42) （请将扩展名改为txt）包含一千局随机牌。每一行包含十张牌（用空格分隔）；前五张是玩家 1 的牌，后五张是玩家 2 的牌。所有的牌都是合理的（没有非法字符或者重复的牌）。每个玩家的牌没有顺序，并且每一局都有明确的输赢。

其中玩家 1 能赢多少局？

jerryxjr1220 · 发表于 2017-1-8 21:36:56

本帖最后由 jerryxjr1220 于 2017-1-12 18:44 编辑

这题到不是说难，而是比较繁琐，每一种情况都要考虑，从大到小依次写各种情况下的胜负判断。
思路就是按照优胜规则写的，判断依据写在注释里了。

#coding:utf-8
def evalHand(hand):
values = ['2','3','4','5','6','7','8','9','T','J','Q','K','A']
flush = 1
suit = hand[0][1]
for card in hand:
if card[1] != suit:
flush = 0
break
indices = []
royal = 1
straight = 1
for card in hand:
indices.append(values.index(card[0]))
indices.sort()
if indices[4] - indices[0] != 4 \
or indices.count(indices[0]) > 1 \
or indices.count(indices[1]) > 1 \
or indices.count(indices[2]) > 1 \
or indices.count(indices[3]) > 1 \
or indices.count(indices[4]) > 1:
straight = 0
if indices[0] != 8:
royal = 0
kinds = []
for value in indices:
count = indices.count(value)
if count > 1:
kind = [value, count]
if kind not in kinds:
kinds.append(kind)
if royal and flush:
# return "royal flush"
return [9, 0]
if straight and flush:
# return "straight flush"
return [8, indices[4]]
if len(kinds) == 1 and kinds[0][1] == 4:
# return "four of a kind"
return [7, kinds[0][0]]
if len(kinds) == 2 and (kinds[0][1] + kinds[1][1] == 5):
# return "full house"
return [6, kinds[0][0]]
if flush:
# return "flush"
return [5, indices[4]]
if straight:
# return "straight"
return [4, indices[4]]
if len(kinds) == 1 and kinds[0][1] == 3:
# return "three of a kind"
return [3, kinds[0][0]]
if len(kinds) == 2 and (kinds[0][1] + kinds[1][1] == 4):
# return "two pair"
return [2, max(kinds[0][0], kinds[1][0])]
if len(kinds) == 1 and kinds[0][1] == 2:
# return "one pair"
return [1, kinds[0][0]]
# return "high card"
return [0, max(indices)]
c = 0
with open('p054_poker.txt') as f:
lines = f.readlines()
for line in lines:
r = line.strip('\n').split()
p1 = evalHand(r[:5])
p2 = evalHand(r[5:])
if p1[0] > p2[0] or (p1[0] == p2[0] and p1[1] > p2[1]):
c += 1
print (c)

复制代码

输出：
376
[Finished in 0.3s]

余欲渔 · 发表于 2017-1-9 17:34:14

我只想知道T是什么

小Q学Python · 发表于 2017-1-10 14:28:39

本帖最后由小Q学Python 于 2017-1-10 15:09 编辑

对于新手的我来讲有点难，本打算用面向对象的办法来做，可转化不过来，放弃。
从看到题，到思考，找方法，花了不少时间，最终思路如下：
问题1.如何把5张牌定型为10种形态（其实是9种，最后的Royal Flush也属于Straight Flush）。
问题2.如何比较形态，如果形态相同，如何继续比较。
1. 5张牌的花色和数字分别处理，花色比较简单，如果都一样，即为“清一色”。数字定位比较麻烦，通过摸索，发现个规律：list的count函数，可以得出每个数字的出现次数，把5个数字的出现次数相加得到的总数，可以对应不同的形态。（如Four of a Kind，这个值为17，Full House的值为13）
2. 如果形态相同，每个形态继续比较的方式也不尽相同。（如Four of a Kind，就要找到4个相同的数字进行比较，Three of a Kind和Full House就要找三个相同的数字比较，而Two Pairs，不仅要对2对从大到小的对子进行比较，如果两对都相同，还要对单牌进行比较）。在这里，我把每个形态需要返回的比较值，按顺序通过list方式返回，同时，顺便把在list的第一位打上形态标志位。

import time
def datainit(a): # a like“8C TS KC 9H 4S”
'数据初始化，将扑克的数字和花色分开，数字转为int'
part1 = []
part2 = []
dict1 = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
'T': 10, 'J': 11, 'Q': 12, 'K': 13, 'A': 14} #创建个字典，T对应10，J-11，Q-12，K-13，A-14
for i in range(0, 14, 3):
part1.append(dict1[a[i]]) #将数字放入part1
for i in range(1, 14, 3):
part2.append(a[i]) #将花色放入part2
part1.sort() #数字排序
part1.reverse() #数字按从大往小排序
return [part1, part2]
def getflush(part2):
'判断是否同花'
if part2.count(part2[0]) == 5:
return True
else:
return False
def gettype(b):
'判断牌属于哪种类型，并回返比较值'
part1 = b[0]
counts = 0 #记录5张牌每张牌出现次数的总和
result = [] #返回牌的类型
count = [[], [], [], []] #其中第一个list为出现过1次的数字，第二个list为出现过2次的数字，以此类推
for i in range(5): #遍历5次
if part1.count(part1[i]) == 4: #当前数字如果list.count=4,则进入count的第4个list
count[3].append(part1[i])
elif part1.count(part1[i]) == 3:#当前数字如果list.count=3,则进入count的第3个list
count[2].append(part1[i])
elif part1.count(part1[i]) == 2:#同上
count[1].append(part1[i])
else:
count[0].append(part1[i]) #同上
counts += part1.count(part1[i])
# 为每个类型定义一个数值作为返回值result的第一位，最大的Straight Flush（Royal Flush也属于Straight Flush）为10，最小的High Card为2。以此类推。
if counts == 17: #Four of a Kind，相同的4个牌，每个牌出现4次，剩下的牌出现1次，总和为17.
result = [9] + [count[3][0]] #Four of a Kind定义为9，count[3][0]就是出现4次的数字
elif counts == 13: #Full House 3*3+2*2=13
result = [8] + [count[2][0]] #Full House 定义为8，[count[2][0]]为出现3次的数字
elif counts == 11: #Three of a Kind
result = [5] + [count[2][0]]
elif counts == 9: #Two Pairs
result = [4] + [count[1][0], count[1][2]] + count[0]
elif counts == 7: #One Pair
result = [3] + [count[1][0]] + count[0]
else: #counts为5，就是5张单牌
if part1[0] == part1[1]+1 == part1[2]+2 == part1[3]+3 == part1[4]+4: #part1是倒序，所以直接+1比较，判断是否顺子
if getflush(b[1]): #判断是否同花
result = [10] + [max(part1)] #Straight Flush定义为10 ，+ 同花顺中的最大值
else:
result = [6] + [max(part1)] #Straight 定义为6 ，+ 顺子中的最大值
else:
if getflush(b[1]):
result = [7] + part1 #Flush
else:
result = [2] + part1 #High Card
return result
start = time.time()
file = open('p054_poker.txt', 'r')
play1wins = 0 #记录play1赢的次数
for line in file:
play1 = line[:14] #取前5张牌
play2 = line[14:].strip() #取后5张牌
if gettype(datainit(play1)) > gettype(datainit(play2)): #list比较，第一位是类型大小，类型相同，再逐一比较
play1wins += 1
print(play1wins)
print('Time used: %.3f sec' % (time.time()-start))

复制代码

376
Time used: 0.031 sec

余欲渔 · 发表于 2017-1-10 15:37:55

本帖最后由余欲渔于 2017-1-11 11:38 编辑

每次看完别人的都觉得自己的写的好死板啊。。。。

cishu=0
f=open("F:/p054_poker.txt") #按文件位置打开所需文件
#下面的是ceshi函数，返回一个列表
def ceshi(zhi,hua):
s=[]
#第一个判断同花顺
if zhi[4]-zhi[3]==zhi[3]-zhi[2]==zhi[2]-zhi[1]==zhi[1]-zhi[0]==1 and len(set(hua))==1:
s.append(9);s.append(zhi[4])
#下面是四张，两种情况
elif zhi[0]==zhi[1]==zhi[2]==zhi[3] :
s.append(8);s.append(zhi[0])
elif zhi[4]==zhi[1]==zhi[2]==zhi[3]:
s.append(8);s.append(zhi[4])
#下面是葫芦，大二小三和大三小二两种可能
elif zhi[0]==zhi[1]==zhi[2] and zhi[3]==zhi[4]:
s.append(7);s.append(zhi[0])
elif zhi[3]==zhi[4]==zhi[2] and zhi[0]==zhi[1]:
s.append(7);s.append(zhi[4])
#下面是同花，只有一种可能
elif len(set(hua))==1:
s.append(6);s.append(zhi[4]);s.append(zhi[3]);s.append(zhi[2]);s.append(zhi[1]);s.append(zhi[0])
#下面是顺子，只有1种可能
elif zhi[4]-zhi[3]==zhi[3]-zhi[2]==zhi[2]-zhi[1]==zhi[1]-zhi[0]==1:
s.append(5);s.append(zhi[4])
#下面是三条，左中右三种可能
elif zhi[0]==zhi[1]==zhi[2] :
s.append(4);s.append(zhi[0])
elif zhi[3]==zhi[1]==zhi[2] :
s.append(4);s.append(zhi[1])
elif zhi[3]==zhi[4]==zhi[2]:
s.append(4);s.append(zhi[2])
#下面是两对，单张在左中右三种可能
elif zhi[0]==zhi[1]and zhi[2]==zhi[3]:
s.append(3);s.append(zhi[2]);s.append(zhi[1]);s.append(zhi[4])
elif zhi[1]==zhi[2]and zhi[3]==zhi[4]:
s.append(3);s.append(zhi[3]);s.append(zhi[2]);s.append(zhi[0])
elif zhi[0]==zhi[1]and zhi[3]==zhi[4]:
s.append(3);s.append(zhi[3]);s.append(zhi[1]);s.append(zhi[2])
#下面是对子，左三，左二右一，左一右二，右三，四种可能
elif zhi[0]==zhi[1] :
s.append(2);s.append(zhi[1]);s.append(zhi[4]);s.append(zhi[3]);s.append(zhi[2])
elif zhi[2]==zhi[1] :
s.append(2);s.append(zhi[2]);s.append(zhi[4]);s.append(zhi[3]);s.append(zhi[0])
elif zhi[2]==zhi[3] :
s.append(2);s.append(zhi[3]);s.append(zhi[4]);s.append(zhi[1]);s.append(zhi[0])
elif zhi[3]==zhi[4]:
s.append(2);s.append(zhi[4]);s.append(zhi[2]);s.append(zhi[1]);s.append(zhi[0])
#下面是单张
else:
s.append(1);s.append(zhi[4]);s.append(zhi[3]);s.append(zhi[2]);s.append(zhi[1]);s.append(zhi[0])
return s
def tihuan(wj): #把值部分字符换成数字
for i in range(5):
if wj[i]=='T':
wj[i]=10
elif wj[i]=='J':
wj[i]=11
elif wj[i]=='Q':
wj[i]=12
elif wj[i]=='K':
wj[i]=13
elif wj[i]=='A':
wj[i]=14
else:
wj[i]=int(wj[i])
return wj
for i in range(1000):
a=f.readline()
wj1zhi=[] #这里做的比较复杂，是把牌的值zhi和花色hua分开了
wj1hua=[]
wj2zhi=[]
wj2hua=[]
for i in range(5): #这个循环就是把读取到的一行数据分出来
wj1zhi.append(a[3*i:3*i+1])
wj1hua.append(a[3*i+1:3*i+2])
wj2zhi.append(a[3*(i+5):3*(i+5)+1])
wj2hua.append(a[3*(i+5)+1:3*(i+5)+2])
wj1zhi=tihuan(wj1zhi)
wj2zhi=tihuan(wj2zhi)
wj1zhi.sort() #排序，以便后面处理
wj2zhi.sort()
w1=ceshi(wj1zhi,wj1hua) #两个玩家的牌分别带入ceshi函数算出大小
w2=ceshi(wj2zhi,wj2hua)
if w1>w2: #判断大小
cishu+=1
f.close()
print("玩家1共计赢了%d次!"%cishu)

复制代码

= RESTART: C:\Users\ASUS\AppData\Local\Programs\Python\Python35-32\poker.py =
玩家1共计赢了376次!
>>>

复制代码

乌巴 · 发表于 2017-1-11 17:34:59

T是啥？

spur · 发表于 2017-1-11 19:55:42

看看~~~~~~~~~~~

ruofanchu · 发表于 2017-1-13 00:39:20

哈哈不错哦

调皮博士 · 发表于 2017-1-21 20:56:09

附件只有167b，下载之后是空压缩包。可以补一下档吗？
我也想做做看

Craigyu · 发表于 2017-2-18 18:10:03

jerryxjr1220 发表于 2017-1-8 21:36
这题到不是说难，而是比较繁琐，每一种情况都要考虑，从大到小依次写各种情况下的胜负判断。
思路就是按照 ...

感觉有个小问题，flush和high card的时候不能只返回最大值比较，two pairs的时候也是有可能要比剩下的单张大小的

Craigyu · 发表于 2017-2-18 18:18:49

理这个思路花了好久

nums = ('2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A')
def evalcard(cards):
flush = 0
straight = 0
royal = 0
# 判断手牌同花
suit = []
for card in cards:
if card[1] not in suit:
suit.append(card[1])
if len(suit) == 1:
flush == 1
# 统计手牌数字
handvalue = []
for card in cards:
handvalue.append(nums.index(card[0]))
handvalue.sort(reverse = True) #reverse便于后面列表比大小
#分辨牌型
if handvalue[4] == handvalue[3] - 1 \
== handvalue[2] - 2 \
== handvalue[1] - 3 \
== handvalue[0] - 4:
straight = 1 #判断顺子
if handvalue[0] == 12: #判断ACE
royal = 1
kinds = []
for each in handvalue:
kind = [handvalue.count(each), each]
if kind not in kinds:
kinds.append(kind)
kinds.sort(reverse = True)
if flush == 1 and straight == 1 and royal == 1:
return [9]
elif flush == 1 and straight == 1:
return [8, handvalue[0]]
elif kinds[0][0] == 4:
return [7, kinds[0][1]]
elif kinds[0][0] == 3 and kinds[1][0] == 2:
return [6]
elif flush == 1:
return [5, handvalue]
elif straight == 1:
return [4, handvalue[0]]
elif kinds[0][0] == 3:
return [3, kinds[0][1]]
elif kinds[0][0] == 2 and kinds[1][0] == 2:
return [2, [kinds[0][1], kinds[1][1], kinds[2][1]]]
elif kinds[0][0] == 2 and kinds[1][0] == 1:
return [1, [kinds[0][1], kinds[1][1], kinds[2][1], kinds[3][1]]]
else:
return [0, handvalue]
c = 0
with open('p054_poker.txt') as f:
lines = f.readlines()
for line in lines:
r = line.strip('\n').split()
p1 = evalcard(r[:5])
p2 = evalcard(r[5:])
if p1 > p2 or (p1[0] == p2[0] and p1[1] > p2[1]):
c += 1
print(c)

复制代码

账号		自动登录	找回密码
密码			立即注册

[技术交流] 小练习：20170109 在扑克游戏中玩家1能赢多少局？

马上注册，结交更多好友，享用更多功能^_^

评分

点评

评分

评分