21点扑克游戏的出牌策略的研究

已于 2024-04-12 11:23:24 修改
阅读量4.4w 收藏 73
点赞数 19
分类专栏： Python编程 文章标签： python
于 2021-08-08 12:37:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gzroy/article/details/119509552
版权

21点是一个非常流行的扑克游戏，规则很简单，计算手中的牌，如果超过21点则输，不到21点则比谁的牌大。其中JQK都当成10点计算，A可以计算为1点或11点。

在澳门的娱乐场里面，21点的规则如下，庄家先给每位玩家发一张牌以及给自己发一张牌，然后庄家继续给玩家发一张牌。这时玩家手里有两张牌，庄家只有一张牌。玩家需要根据自己的牌以及庄家的牌来作出决策，是继续要牌，还是停牌，如果两张牌一致还可以选择分牌。庄家根据玩家的决策来进行相应的操作，并且计算点数，如果玩家的牌超过21点则算玩家负。等所有玩家的操作都完成后，庄家再继续给自己派牌，如果庄家的牌不包含A并且点数不超过16点（也称之为硬16点），庄家需要继续补牌，如果含A并且点数不超过17点（软17点），庄家也需要补牌。最后比较庄家和玩家的牌的大小来决定胜负。除此之外还有一些特殊的规则，例如玩家在刚开始拿到2张牌的时候，可以选择加倍，这是只能再拿一张牌，如果赢了则拿到双倍的筹码。当玩家刚开始拿到的2张牌是A和10, J, Q, K的任何一张时，叫做Black Jack，如果庄家的牌不是A,10,J,Q,K时，需要立即赔付玩家1.5倍的筹码，如果庄家的牌是A,10,J,Q,K，玩家可以选择先赢1倍的筹码并离场，或者等待庄家开牌之后，如果庄家不是Black Jack则赢1.5倍的筹码，或者庄家是Black Jack则打平。另外当庄家第一张牌是除A之外的其他牌时，玩家可以选择投降拿回一半的筹码。

网上已经有很多关于21点的基本出牌策略的介绍，这些出牌策略应该都是基于美国一位大学教授用概率的方法研究出来的，这种研究方法需要对概率学有很深的了解。另外在人工智能里面，基于强化学习来模拟21点游戏进行研究也是一个很基础的话题。在这里我想用另一种方法来研究21点的出牌策略，即用蒙特卡洛的方法来模拟很多局21点游戏，通过计算每种结果的取值来得出一个出牌策略，根据大数定律，当模拟的局数足够多时，得出的结果就会很接近真实的概率了。

首先我们先建立一个庄家的对象，负责模拟庄家的操作，代码如下：

class Dealer:
    flag_ace = False
    firstcard = 0
    cards = []

    def __init__(self, card):
        if card>10:
            card=10
        self.firstcard = card

    def getcard(self):
        card = randint(1,13)
        if card>10:
            card=10
        if card==1:
            self.flag_ace = True
        self.cards.append(card)

    def calculatescore(self):
        score = np.sum(np.array(self.cards))
        if self.flag_ace:
            if score<=11:
                score += 10    #This means one ace can be treat as 11 not 1
        return score

    def play(self):
        self.cards = [self.firstcard]
        if self.firstcard==1:
            self.flag_ace = True
        else:
            self.flag_ace = False
        while True:
            self.getcard()
            score = self.calculatescore()
            if self.flag_ace and score>17:
                break
            if self.flag_ace==False and score>16:
                break
        return score

然后我们建立一个玩家的对象，代码如下：

class Player:
    cards = []
    flag_ace = False

    def __init__(self, card1, card2):
        self.cards = [card1, card2]
        if card1==1 or card2==1:
            self.flag_ace = True

    def hit(self):
        card = randint(1,13)
        if card>10:
            card=10
        if card==1:
            self.flag_ace = True
        self.cards.append(card)

    def calculatescore(self):
        score = np.sum(np.array(self.cards))
        if self.flag_ace:
            if score<=11:
                score += 10    #This means one ace can be treat as 11 not 1
        return score

要牌/停牌策略的研究

接下来我们就可以通过模拟玩21点来研究策略了。首先研究的是当玩家没有拿到2张一样的牌的时候（即没有分牌这种可能性），玩家需要采用哪种策略最优（要牌，加倍，停牌）。为了得到最优策略，我们可以通过迭代的方法来进行模拟。首先设定当玩家两张手牌的和为21点的时候，无论庄家手牌是多少点我们都需要采取停牌的策略（这是显而易见的），那么当玩家手牌为20点时，模拟分别要牌，加倍或停牌这三种情况（因为玩家在20点时只要加倍或要牌，必然会到达21点或以上，这样我们就知道玩家的下一个采取的策略），看哪种策略获取的收益最高。当玩家手牌为20点时的策略全部确定下来之后，继续探索手牌为19点时的策略，如此循环下去，最终我们就能得到玩家手牌从4点到19点的所有最优策略。代码如下：

from random import randint
import numpy as np
policy = {}
policy['21'] = []
policy['A,10'] = []
for i in range(10):
    policy['21'].append('S')
    policy['A,10'].append('S')
for card1 in range(10, 1, -1):
    for card2 in range(10, 0, -1):
        if card2==1:
            key = 'A,'+str(card1)
        else:
            key = str(card1+card2)
        if key in policy:
            continue
        else:
            policy[key] = []
        for dealercard in range(1, 11):
            player1_money=10000
            player2_money=10000
            player3_money=10000
            bet = 100
            games = 100000
            player1_policy = 'S'
            player2_policy = 'D'  
            player3_policy = 'H'

            for i in range(games):
                #p = Player(player_card1,player_card2)
                p = Player(card1, card2)
                d = Dealer(dealercard)

                score1 = p.calculatescore()   #For player1, stand
                p.hit()
                score2 = p.calculatescore() 
                score3 = p.calculatescore()   #For player2 double, player3 hit

                while True:
                    if score3>=20:
                        break
                    if p.flag_ace:
                        cardsum = np.sum(np.array(p.cards))
                        if cardsum-1<11:
                            k = 'A,'+str(cardsum-1)
                        else:
                            k = str(score3)
                    else:
                        k = str(score3)
                    if policy[k][dealercard-1]=='S' or policy[k][dealercard-1]=='D/S':
                        break
                    else:
                        p.hit()
                        score3 = p.calculatescore()

                dealerscore = d.play()

                if score2>21:
                    if dealerscore>21:
                        player1_money += bet
                    else:
                        if score1>dealerscore:
                            player1_money += bet
                        if score1<dealerscore:
                            player1_money -= bet
                    player2_money -= 2*bet
                    player3_money -= bet
                else:
                    if score3>21:
                        player3_money -= bet
                        if dealerscore>21:
                            player1_money += bet
                            player2_money += 2*bet
                        else:
                            if score1>dealerscore:
                                player1_money += bet
                            if score1<dealerscore:
                                player1_money -= bet
                            if score2>dealerscore:
                                player2_money += 2*bet
                            if score2<dealerscore:
                                player2_money -= 2*bet
                            if dealerscore==21 and d.flag_ace==True and len(d.cards)==2:
                                if score2==21:
                                    player2_money -= 2*bet
                    else:    #score1<=21, score2<=21, score3<=21
                        if dealerscore>21:
                            player1_money += bet
                            player2_money += 2*bet
                            player3_money += bet
                        else:
                            if score1>dealerscore:
                                player1_money += bet
                            if score1<dealerscore:
                                player1_money -= bet
                            if score2>dealerscore:
                                player2_money += 2*bet
                            if score2<dealerscore:
                                player2_money -= 2*bet
                            if score3>dealerscore:
                                player3_money += bet
                            if score3<dealerscore:
                                player3_money -= bet
                            if dealerscore==21 and d.flag_ace==True and len(d.cards)==2:
                                if score2==21:
                                    player2_money -= 2*bet
                                if score3==21:
                                    player3_money -= bet
             
                del d,p

            max_money = max(player1_money, player2_money, player3_money)
            if max_money==player1_money:
                policy[key].append('S')
            if max_money==player2_money: 
                if player1_money>player3_money:
                    policy[key].append('D/S')
                else:
                    policy[key].append('D')
            if max_money==player3_money:
                policy[key].append('H')

保存这个出牌策略到CSV文件，然后用pandas dataframe来展现：

#调整policy中的Key的排序
keys = sorted(policy.keys())
sorted_keys = keys[12:18]
sorted_keys.extend(keys[:12])
sorted_keys.extend(keys[19:])
sorted_keys.append(keys[18])
with open('policy.csv', 'w') as f:
    policy_result = 'Player;2;3;4;5;6;7;8;9;10;A\n'
    for key in sorted_keys:
        policy_result += key+';'+';'.join(policy[key][1:])+';'+policy[key][0]+'\n'
    f.write(policy_result)
df_policy = pd.read_csv('policy.csv', header=0, index_col=0, sep=';')
df_policy.head(100)

策略如下，其中D表示加倍，H表示要牌，S表示停牌，D/S表示如果不能加倍则停牌。第一行表示庄家第一张牌的点数，第一列表示玩家两张牌的点数：

Player2345678910A
4HHHHHHHHHH
5HHHHHHHHHH
6HHHHHHHHHH
7HHHHHHHHHH
8HHHHDHHHHH
9HDDDDHHHHH
10DDDDDDDDHH
11DDDDDDDDHH
12HSSSSHHHHH
13SSSSSHHHHH
14SSSSSHHHHH
15SSSSSHHHHS
16SSSSSHHHSS
17SSSSSSSSSS
18SSSSSSSSSS
19SSSSSSSSSS
20SSSSSSSSSS
21SSSSSSSSSS
A,2HHHDDHHHHH
A,3HHHDDHHHHH
A,4HHDDDHHHHH
A,5HDDDDHHHHH
A,6DDDDDHHHHH
A,7D/SD/SD/SD/SDS    S    H    H    H    
A,8SSSSD/SSSSSS
A,9SSSSSSSSSS
A,10SSSSSSSSSS

分牌策略的研究

接下来我们需要继续补充当玩家头两张牌是一样的策略，是需要分牌，还是停牌，要牌等等。这个可以基于刚才得出的策略的基础上来进一步模拟。如以下代码：

split_result = {}
for i in trange(2,10):
    split_result[str(i)+","+str(i)]=[]
    for c in trange(1, 11):   #Dealer card 2-10, A
        lose_counts = 0
        win_counts = 0
        draw_counts = 0
        split_gain = 0
        nonsplit_gain = 0
        for j in range(steps):
            for k in range(3):     #k-0,1, Split card, k-2, not split
                d = Dealer(c)
                while True:
                    secondcard = randint(1,13)
                    if secondcard>10:
                        secondcard = 10
                    if secondcard!=i:
                        break
                if k==2:
                    secondcard = i
                p = Player(i, secondcard)
                hit_count = 0
                player_lose = False
                doublescaler = 1
                while True:
                    score = p.calculatescore()
                    if score>18 and score<=21:
                        break
                    if score>21:
                        player_lose = True
                        break
                    if p.flag_ace:
                        cardsum = np.sum(np.array(p.cards))
                        if cardsum-1<11:
                            key = 'A,'+str(cardsum-1)
                        else:
                            key = str(score)
                    else:
                        key = str(score)
                    action = policy[key][c-1]
                    if hit_count==0: 
                        if action=='D' or action=='D/S':
                            doublescaler = 2
                    if (hit_count==0 and action=='D/S') or action=='D' or action=='H':
                        p.hit()
                        hit_count += 1
                    else:
                        score = p.calculatescore()
                        if score>21:
                            lose_counts += 1*doublescaler
                            if k<2:
                                split_gain -= 1*doublescaler
                            else:
                                nonsplit_gain -= 1*doublescaler
                            player_lose = True
                            break
                        else:
                            player_lose = False
                            break
                if player_lose==False:
                    dealerscore = d.play()
                    if dealerscore>21:
                        win_counts += 1*doublescaler
                        if k<2:
                            split_gain += 1*doublescaler
                        else:
                            nonsplit_gain += 1*doublescaler
                    else:
                        if score<dealerscore:
                            lose_counts += 1*doublescaler
                            if k<2:
                                split_gain -= 1*doublescaler
                            else:
                                nonsplit_gain -= 1*doublescaler
                        elif score>dealerscore:
                            win_counts += 1*doublescaler
                            if k<2:
                                split_gain += 1*doublescaler
                            else:
                                nonsplit_gain += 1*doublescaler
                        else:
                            draw_counts += 1
                else:
                    if k<2:
                        split_gain -= 1*doublescaler
                    else:
                        nonsplit_gain -= 1*doublescaler
                del d, p
        split_result[str(i)+","+str(i)].append([split_gain,nonsplit_gain])   

split_policy = {}
for key in split_result:
    split_policy[key] = []
    for i in range(10):
        if split_result[key][i][0]<split_result[key][i][1]:
            policykey = str(int(key.split(',')[0])*2)
            split_policy[key].append(policy[policykey][i])
        else:
            split_policy[key].append('P')

split_policy_result = 'Player;2;3;4;5;6;7;8;9;10;A\n'
for key in split_policy:
    split_policy_result += key+';'+';'.join(split_policy[key][1:])+';'+split_policy[key][0]+'\n'
with open('split_policy.csv', 'w') as f:
    f.write(split_policy_result)
df_split = pd.read_csv('split_policy.csv', header=0, index_col=0, sep=';')
df_split.head(100)

分牌的策略如下：

Player2345678910A
2,2PPPPPPPHHH
3,3PPPPPPPHHH
4,4HHPPPHHHHH
5,5DDDDDDDDHH
6,6PPPPPPHHHH
7,7PPPPPPPHHH
8,8PPPPPPPPPS
9,9PPPPPSPPSS

评估策略的效果

现在有了策略之后，我们就可以模拟运行多局21点游戏，看看在实际表现如何。

首先把以上得到的两个策略合并为一个完整的策略，如以下的代码：

with open('policy.csv', 'r') as f:
    lines = f.readlines()
with open('split_policy.csv', 'r') as f:
    lines.extend(f.readlines()[1:])
complete_policy = {}
for l in lines[1:]:
    a = l.strip().split(';')
    complete_policy[a[0]] = [a[-1]]
    complete_policy[a[0]].extend(a[1:])

其次需要在原有的player对象中增添一个play方法，使得可以基于刚才得到的策略来进行要牌停牌的操作，代码如下，其中参数dealercard表示庄家的手牌，policy是一个字典，代表玩家要采取的策略，simulate表示是否模拟（这个参数在之后比较不同策略的时候会用到）

def play(self, dealercard, policy, simulate=False):
    card1 = self.cards[0]
    card2 = self.cards[1]
    hitcount = 0
    scale = 1.0
    count = 0
    while True:
        if self.flag_ace and len(self.cards)==2:
            if max(card1, card2)==10:
                scale=1.5
                score=21
                break
            else:
                key = "A,"+str(np.sum(np.array(self.cards))-1)
                action = policy[key][dealercard-1]
        else:
            score = self.calculatescore()
            if score>=18:
                break
            else:
                if self.flag_ace:
                    cardsum = np.sum(np.array(self.cards))
                    if cardsum<12:
                        key = 'A,'+str(cardsum-1)
                    else:
                        key = str(score)
                else:
                    key = str(score)
                action = policy[key][dealercard-1]
        if (action=='D' or action=='D/S') and hitcount==0:
            if simulate:
                self.hit(0)
            else:
                self.hit()
            score = self.calculatescore()
            scale = 2.0
            break
        elif action=='S' or (action=='D/S' and hitcount>0):
            score = self.calculatescore()
            break
        else:
            if simulate:
                self.hit(count)
            else:
                self.hit()
            score = self.calculatescore()
            if score>=18:
                break
            hitcount+=1
            count += 1
    return score, scale

然后我们就可以构建如下代码来模拟玩21点了，其中参数bet表示每局的下注量，games表示一共玩多少局，loops表示玩多少次，每次包括games这么多局。totalmoney表示玩家总的资金，debug参数开启后可以打印每一局玩家和庄家的要牌情况，代码如下：

bet = 100
games = 10
loops = 1
debug = True
money = []
for j in trange(loops):
    totalmoney = 1000
    for i in range(games):
        if debug:
            print('Game {}:'.format(i))
        dealercard = randint(1,13)
        if dealercard>10:
            dealercard = 10
        d = Dealer(dealercard)

        card1 = randint(1,13)
        scores = []
        if card1>10:
            card1 = 10
        card2 = randint(1,13)
        if card2>10:
            card2 = 10
        action = ''

        if card1==card2 and card1!=10:
            if card1==1:
                action = 'P'
            else:
                key = str(card1)+','+str(card2)
                action = complete_policy[key][dealercard-1]
        if action=='P':
            split_times = 2
            while split_times>0:
                card = randint(1,13)
                card_count += 1
                if card>10:
                    card=10
                if card!=card1:
                    p_temp = Player(card1, card)
                    score, scale = p_temp.play(dealercard, complete_policy, False)
                    playercards = [str(a) for a in p_temp.cards]
                    if debug:
                        print('Player:'+','.join(playercards))
                    del p_temp
                    scores.append((score, scale))
                    split_times -= 1
                else:
                    split_times += 1
        else:
            p = Player(card1, card2)
            score, scale = p.play(dealercard, complete_policy, False)
            scores.append((score, scale))
            playercards = [str(a) for a in p.cards]
            if debug:
                print('Player:'+','.join(playercards))
            del p

        dealerscore = d.play()
        dealercards = [str(a) for a in d.cards]
        if debug:
            print('Dealer:'+','.join(dealercards))

        for item in scores:
            score, scale = item
            if score>21:
                totalmoney -= bet
            else:
                if score==21 and scale==1.5:
                    if dealerscore==21 and len(d.cards)==2:
                        continue
                    else:
                        totalmoney += bet*1.5
                else:
                    if dealerscore>21:
                        totalmoney += bet*scale
                    elif dealerscore==21 and len(d.cards)==2:
                        if score==21 and scale==1.5:
                            continue
                        else:
                            totalmoney -= bet*scale
                    else:
                        if score>dealerscore:
                            totalmoney += bet*scale
                        elif score<dealerscore:
                            totalmoney -= bet*scale
                        else:
                            continue
        del d
        if debug:
            print("TotalMoney:{}".format(totalmoney))
    money.append(totalmoney)
print(money)

运行结果如下，玩家起始资金1000元，每次下注100元，玩10次，每次的过程以及最后资金量如下：

Game 0:
Player:10,5,10
Dealer:10,4,9
TotalMoney:900
Game 1:
Player:4,8
Dealer:4,10,10
TotalMoney:1000.0
Game 2:
Player:1,10
Dealer:2,4,9,8
TotalMoney:1150.0
Game 3:
Player:10,10
Dealer:4,9,6
TotalMoney:1250.0
Game 4:
Player:10,8
Dealer:5,10,10
TotalMoney:1350.0
Game 5:
Player:3,10
Dealer:2,1,8
TotalMoney:1250.0
Game 6:
Player:2,3,2,10
Dealer:7,9,4
TotalMoney:1150.0
Game 7:
Player:10,1
Dealer:8,10
TotalMoney:1300.0
Game 8:
Player:9,5
Dealer:3,6,6,5
TotalMoney:1200.0
Game 9:
Player:3,10
Dealer:4,10,10
TotalMoney:1300.0
[1300.0]

和标准策略的对比

比较主流的一种策略如下，红色表示与我的策略不同的地方，括号内的是我的策略：

Player2345678910A
8HHHHH(D)HHHHH
9HDDDDHHHHH
10DDDDDDDDHH
11DDDDDDDDD(H)H
12HH(S)SSSHHHHH
13SSSSSHHHHH
14SSSSSHHHHH
15SSSSSHHHHH(S)
16SSSSSHHHH(S)H(S)
17SSSSSSSSSS
18SSSSSSSSSS
19SSSSSSSSSS
A,2HHHDDHHHHH
A,3HHHDDHHHHH
A,4HHDDDHHHHH
A,5HH(D)DDDHHHHH
A,6H(D)DDDDHHHHH
A,7S(D/S)D/SD/SD/SD/S(D)SSHHH
A,8SSSSS(D/S)SSSSS
A,9SSSSSSSSSS
2,2PPPPPPH(P)HHH
3,3PPPPPPH(P)HHH
4,4HHH(P)PPHHHHH
5,5DDDDDDDDHH
6,6PPPPPH(P)HHHH
7,7PPPPPPH(P)HHH
8,8PPPPPPPPPP(S)
9,9PPPPPSPPSS
10,10SSSSSSSSSS

我们可以模拟实战一下，对比标准策略和我们得出的策略的表现。这里为了公平起见，比较不同策略的时候，玩家每一局里获取的牌在不同策略下是保持一致的，具体做法是，在每一局开始的时候，预先随机生成一些牌放在cardpool里面，然后每种策略都是从这个carpool来取牌。为此需要改造一下Player对象里面的hit方法，增加一个参数cardnum。

def hit(self, cardnum=-1):
    if cardnum>=0:
        card = self.cardpool[cardnum]
    else:
        card = randint(1,13)
    if card>10:
        card=10
    if card==1:
        self.flag_ace = True
    self.cards.append(card)

之后写代码，模拟运行1000次，每次玩100局，每100局玩完之后计算两种策略的金额的大小来决定胜负：

bet = 100
games = 100
loops = 1000
debug = False
money = []
mypolicywins = 0
stdpolicywins = 0
policys = [standard_policy, complete_policy]
for j in trange(loops):
    totalmoney = [100000,100000]
    for i in range(games):
        if debug:
            print('Game {}:'.format(i))
        dealercard = randint(1,13)
        if dealercard>10:
            dealercard = 10
        d = Dealer(dealercard)

        card1 = randint(1,13)
        scores = [[],[]]
        if card1>10:
            card1 = 10
        card2 = randint(1,13)
        if card2>10:
            card2 = 10
        cardpool = []
        splitpool = []
        for cardpoolnum in range(200):
            cardpool.append(randint(1,13))
        for splitpoolnum in range(10):
            splitpool.append([])
            for a in range(20):
                splitpool[-1].append(randint(1,13))
        action = ''
        for policyid in range(2):
            if debug:
                if policyid==0:
                    print("Standardpolicy")
                else:
                    print("completepolicy")
            if card1==card2 and card1!=10:
                if card1==1:
                    action = 'P'
                else:
                    key = str(card1)+','+str(card2)
                    action = policys[policyid][key][dealercard-1]
            if action=='P':
                split_times = 2
                split_count = 0
                card_count = 0
                while split_times>0:
                    card = cardpool[card_count]
                    card_count += 1
                    if card>10:
                        card=10
                    if card!=card1:
                        p_temp = Player(card1, card)
                        p_temp.cardpool = splitpool[split_count]
                        split_count += 1
                        score, scale = p_temp.play(dealercard, policys[policyid], True)
                        playercards = [str(a) for a in p_temp.cards]
                        if debug:
                            print('Player:'+','.join(playercards))
                        del p_temp
                        scores[policyid].append((score, scale))
                        split_times -= 1
                    else:
                        split_times += 1
            else:
                p = Player(card1, card2)
                p.cardpool = cardpool
                score, scale = p.play(dealercard, policys[policyid], True)
                scores[policyid].append((score, scale))
                playercards = [str(a) for a in p.cards]
                if debug:
                    print('Player:'+','.join(playercards))
                del p

        dealerscore = d.play()
        dealercards = [str(a) for a in d.cards]
        if debug:
            print('Dealer:'+','.join(dealercards))

        for policyid in range(2):
            for item in scores[policyid]:
                score, scale = item
                if score>21:
                    totalmoney[policyid] -= bet
                else:
                    if score==21 and scale==1.5:
                        if dealerscore==21 and len(d.cards)==2:
                            continue
                        else:
                            totalmoney[policyid] += bet*1.5
                    else:
                        if dealerscore>21:
                            totalmoney[policyid] += bet*scale
                        elif dealerscore==21 and len(d.cards)==2:
                            if score==21 and scale==1.5:
                                continue
                            else:
                                totalmoney[policyid] -= bet*scale
                        else:
                            if score>dealerscore:
                                totalmoney[policyid] += bet*scale
                            elif score<dealerscore:
                                totalmoney[policyid] -= bet*scale
                            else:
                                continue
        del d
        if debug:
            print("TotalMoney:{}".format(totalmoney))
    if totalmoney[0]<totalmoney[1]:
        #print('My policy win')
        mypolicywins += 1
    if totalmoney[0]>totalmoney[1]:
        stdpolicywins += 1
        #print('Standard policy win')
    
print(mypolicywins)
print(stdpolicywins)

总共运行五次

第一次：我的策略赢了464次，标准策略赢了391次，145次打平

第二次：我的策略赢了457次，标准策略赢了417次，126次打平

第三次：我的策略赢了448次，标准策略赢了420次，132次打平

第四次：我的策略赢了435次，标准策略赢了437次，128次打平

第五次：我的策略赢了450次，标准策略赢了402次，148次打平

总体来看我的策略比标准策略有所改进，能更好的提高胜率

最后附上我整理好的21点最佳出牌策略

gzroy
关注
  • 19
    点赞
  • 踩
  • 73
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
扑克21点作弊算法【综合文 FreeXploiT收集整理】仅供研究，不要非法使用
FreeXploiT
04-25 1万+
21点规则与基本玩法(中文)玩家需将赌注置于下注圈中央。然后，庄家给每个玩家发两张牌，牌面朝上；给自己发两张牌，一张牌面朝上，一张牌面朝下。K、Q、J 和 10 牌都算作 10 点。 A 牌既可算作 1 点也可算作 11 点，由玩家自己决定。其余所有 2 至 9 牌均按其原面值计算。 如果玩家拿到的前两张牌是一张 A 和一张 10，就拥有黑杰克 (Blackjack)；此时，如果庄家没有黑杰克，玩
二十一点
02-15
二十一点 根据“基本策略”模拟二十一点分析Black Jack模拟制作的数据框。 并演示如何演奏完美的《黑杰克》。 基本策略 基本策略是选择玩家动作的备忘单。 玩家通过比较自己的手和庄家的面朝上的牌来行动。 通常，您可以将手牌和面朝上的庄家的手牌范围缩小到290条。 基本策略根据每个模式中的期望值提供玩家的最佳动作。 细节 首先，二十一点没有心理战元素，完全是数学和概率论。 劫持基本策略和机械玩法是最期望的价值。 另外，交易者没有按照规则的意图，而是机械地行动。 因此，可以通过计算机模拟使用基本策略完全再现二十一点。 该项目可以通过模拟一个玩家与发牌人之间的战斗并在DataFrame中记录战斗结果来分析二十一点。 然后，我们将阐明根据基本策略实际行动的重要性。 使用该项目的功能和优点如下。 您可以获取二十一点游戏数据。 通过播放指定的次数可以执行更准确的分析。 可以使用分析类。 软件
蒙特卡洛方法实现21点最优策略寻找（MC）
qq_43790749的博客
11-07 9739
21点规则简介 二十一点是一种扑克牌游戏，目标是尽量使手中牌的总点数达到 21 点，或是接近 21 点，但不能超过，然后与庄家的点数进行比较。人头牌（J、Q、K）的点数是 10。王牌可以是 11 点或 1 点，11 点时“可用”。这种游戏的整副牌是有限的（或者可以替换）。游戏开始时，每个玩家和庄家的一张牌朝上，另一张牌朝下。玩家可以请求更多的牌 (hit=1) 并决定何时停止请求牌(stick=0) 或者超过 21 点（爆牌）。玩家停止请求牌后，庄家翻开扣着的牌，并抽牌，直到所有点数之和是 17 点或大于
java21点牌玩法_扑克牌玩法 21点规则和技巧原来那么多
weixin_34443284的博客
02-28 3129
经常玩纸牌的小伙伴们应该听过一种扑克牌玩法：21点，没有听过的小伙伴们也没有关系，今天小编就给大家介绍一下21点的规则，21点是有概率可遵循的，小编今天教给大家21点的玩法还有技巧，一起学习一下吧。21点游戏是现在很多玩家为之着迷的一种游戏。与一般的游戏不同，21点是有概率学可遵循的，不过心算速度得非常神速，而且记忆力必须非常超群。21点是非常考察脑力的游戏。拥有高点数的玩家获胜，其点数必须等于或...
强化学习丨蒙特卡洛方法及关于“二十一点”游戏的编程仿真
qq_56937808的博客
11-06 8406
一、蒙特卡洛方法简介 在上一篇文章中，笔者介绍了动态规划算法（Dynamic Programming）的概念和实现，不难发现，动态规划是基于贝尔曼方程提出的一种迭代解法，即利用策略评估迭代计算价值，利用策略改进让智能体进行策略学习，但该算法需要完备的环境知识，即动态函数，另一方面，动态规划算法的迭代过程是自举的过程，即当前价值估计需要基于其他价值的估计。 假设智能体处在一个未知的环境中（其实现实生活中这种环境占大多数），环境的动作收益和状态转移都不能提前预知，这时智能体就...
21点的游戏规则：
12-11 3266
21点的游戏规则：1.使用一套13*4=52张的扑克牌，不使用大小Joker2.每一局的开始首先轮流发给双方各两张牌。双方获得的第一张牌是对对手透明的，其他牌均不会被对手知道。3.各牌代表的分数如下：2=2分，3=3分，4=4分，5=5分，6=6分，7=7分，8=8分，9=9分，10=10分，J=10分，Q=10分，K=10分；A=1分或11分，记分时以对持牌者有利为准。不分花色。玩家拥有
21点扑克游戏
SOGD
05-02 3086
案例目的 本案例通过一个21点扑克牌游戏的设计和实现，了解使用Python数据类型、控制流程和输入输出。 案例内容 21点又名黑杰克（Blackjack），起源于法国，已流传到世界各地，有着悠久的历史。现在在世界各地的赌场中都可以看到二十一点，随着互联网的发展，二十一点开始走向网络时代。该游戏由2到6个人玩，使用除大小王之外的52张牌，游戏者的目标是使手中的牌的点数之和不超过21点且尽量大。 实验环境 Pycharm、Anaconda 案例研究 4.1 游戏规则 开局时，庄家（dealer）...
21点游戏A计算方法
cxm19830125的专栏
09-01 9927
1.A既可以作为1，也可以作为11，计算所有牌面的总点数 2.算法逻辑：不管有多少个A,只把第一个A先计算成11，加起来，总和如果超过21点，把第一个A变成1 3.代码： def count_points(foker_list): foker_list_tmp = [] foker_list_len = len(foker_list) for i in foker_list: foker_list_tmp.append(i) for i in ran...
控制智能体学习21点游戏最佳策略
技术札记
06-17 755
MC常量控制 最优策略 灰色:要牌 绿色:停牌 MC常量控制 有可用王牌 状态动作价值函数 MC常量控制 无可用王牌 状态动作价值函数
21点扑克牌游戏.rar
09-10
21点扑克牌游戏，也称为“Blackjack”，是一种广受欢迎的纸牌游戏，其规则简单却蕴含策略深度。在这个项目中，我们利用.NET框架和C#编程语言在Visual Studio 2017环境下构建了这样一个游戏。下面，我们将深入探讨这...
21点游戏
11-15
软件开发21点游戏软件开发21点游戏
C++21点游戏
10-31
C++实现的21点游戏 代码片段if(usersum>21) // 判断玩家点数是否超过二十一点，若超出，玩家判输，游戏结束 { cout<<"\n\n玩家输了"<<endl; return 0;} cout<<"\n电脑阶段\n"; //进入电脑阶段 ResetCards(); //重新洗牌 cout<<"电脑获得牌 "
21点小游戏
12-19
简单的小游戏 C#源代码 仅供初学者参考
21点游戏（21Point）
08-16
用C++做的21点游戏， 上个月生产实习时做的， 有需要的下吧
21点游戏C++模拟
10-27
21点是一个广受欢迎的游戏，这里用纯C++实现了21点游戏！
21点扑克牌.rar
04-03
标题“21点扑克牌.rar”暗示我们关注的是一个与21点游戏相关的资源，而这...总之，"21点扑克牌.rar"这个压缩包可能包含了21点游戏的规则、策略、模拟工具或者教育资源，帮助玩家理解和提升在这个经典纸牌游戏中的表现。
C++课程设计21点扑克牌游戏.pdf
10-02
C++课程设计21点扑克牌游戏.pdf 本程序设计了一款21点扑克牌游戏，游戏规则如下： 1. 玩家一共可以要五张牌，但如果牌的点数超过21，则自动出局； 2. 在不超过21点的情况下，玩家与庄家比牌的点数大小，大者为赢，...
易语言21点扑克牌
07-17
《易语言21点扑克牌》是一款基于易语言开发的桌面游戏，主要目的是为用户提供一个模拟21点扑克牌游戏的平台。21点扑克牌，又称为“黑杰克”，是世界上最流行的赌场游戏之一，它的规则简单而富有挑战性，深受玩家喜爱...
21点纸牌游戏课程设计
12-18
【21点纸牌游戏】是一种流行的扑克游戏，它的规则简单但富有策略性。在这个游戏中，每个玩家的目标是尽可能接近21点，但不能超过。游戏的核心在于如何判断何时要继续拿牌（hit）以增加分数，何时停止拿牌（stand）以...
21点扑克牌游戏c++
最新发布
11-07
21点是一个古老的扑克牌游戏，游戏规则是各个参与者设法使自己的牌达到总分21而不超过这个数值。扑克牌的分值取它们的面值，A充当1分或者11分(由玩家自己选择一种分值),J.Q和K 人头牌都是10分。在C++中，可以通过编写相应的代码来实现21点游戏。在提供的引用中，main.cpp文件中包含了21点游戏的代码，其中包括GameOf21Point类和相应的成员函数，以及一个主函数main()，通过调用GameOf21Point对象的Game()函数来运行游戏。在游戏中，用户可以选择是否再玩一次，直到得到否定回答为止。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gzroy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值