码龄0.3年的python成长之路（二）：骰子谜题

骰子原题：

小明参加了少年宫的一项趣味活动：每个小朋友发给一个空白的骰子（它的6个面是空白的，没有数字），要小朋友自己设计每个面写哪个数字。但有如下要求：
1. 每个面只能填写 0 至 8 中的某一个数字。
2. 不同面可以填写同样的数字，但6个面总和必须等于24。
填好后，小朋友可以用自己填写好数字的骰子向少年宫的两个机器人挑战----玩掷骰子游戏。规则如下：
三方同时掷出自己的骰子，如果出现任何相同的数字，则三方都不计分。
如果三方数字都不同，则最小数字一方扣 1 分，最大数字一方加 1 分。
小明看到了两个机器人手中的骰子分别是：
0 0 0 8 8 8
1 1 4 5 6 7
请你替小明算一下，他如何填写，才能使自己得分的概率最大。
请提交小明应该填写的6个数字，按升序排列，数字间用一个空格分开。
如果认为有多个答案，提交字母序最小的那个方案。
请严格按照格式，通过浏览器提交答案。
注意：只提交一行内容，含有6个被空格分开的数字。不要写其它附加内容，比如：说明性的文字。

思路逻辑：

• 生成器：骰子6面数字和 == 24，排列组合来说，这个规则限定了排列的可能性总量

• 随机生成小明骰子搭配所有的可能存为npz文档，读为ming_list_All

• 模拟投骰子一次的状况，判断win条件，True时win_count + 1

• 每一组ming_list，模拟10000次投骰子实验，
  计算对应此组ming_list的win_count值，
  并记录在列表win_count_list中(100个数字)

• 用max[win_count_list]，并index此数定位，找到对应该组的ming_list数字搭配

完成

代码部分

先做一个生成器

将生成的小明可写的数组组合存在ming_list.npy当中，等待调用

xlist = []
ming_list = []
def dice_generate():
    for x1 in range(0, 9):
        for x2 in range(0, 9):
            for x3 in range(0, 9):
                for x4 in range(0, 9):
                    for x5 in range(0, 9):
                        for x6 in range(0, 9):
                            xlist = [x1, x2, x3, x4, x5, x6]
                            if sum(xlist) == 24:
                                ming_list.append(xlist)
                            else:
                                continue
dice_generate()
np.save('ming_list.npy', ming_list)

生成的ming_list列表元素个数有32661个（满足和为24），这里明显32661个数据如果做迭代、并且打印（print）的话，会让机器运行时间过长。后期注意要用 if - else 条件语句缩短运行时间。

print(len(ming_list)) # 32661

这段代码写完后，开启另一个py文件，调用刚生成的ming_list.npy即可，否则后面的命名会复杂。

选择ming_list当中一个组来进行骰子投掷试验

另开新的py文档后，import numpy as np的部分我省略了，如需要复刻请加上。
以第234组数据作为小明的骰子，与两个机器人同时投掷一次的代码如下：

ming_list_All = np.load('ming_list.npy') 
ming_list_234 = ming_list_All[234]  # [0 1 5 6 8 4]
robot1_list = [0, 0, 0, 8, 8, 8]
robot2_list = [1, 1, 4, 5, 6, 7]    
def dice_once():
    r1 = robot1_list[np.random.randint(0, 6)]
    r2 = robot2_list[np.random.randint(0, 6)]
    ming = ming_list_234[np.random.randint(0, 6)]
    return r1, r2, ming

定义判断小明胜利的函数，计算10000次试验能有多少次胜利：

def Win():
    for i in range(10000):  # 执行10000次投骰子试验
        global win_count
        list = dice_once()
        r1 = list[0]
        r2 = list[1]
        ming = list[2]
        if (ming < r1) or (ming < r2):
            continue
        else:
            win_count += 1
Win()
print(win_count)

以第234组数据为例，计算出10000次同时投掷模拟，小明能胜出3549次。
以上完成，开始组装各个模块，判断3万多组数据中，win_count最大的那个，找到其编号，回溯ming_list_All便可找到胜率最大的组合。

建议另外开新的py文档来做组装

这应该是好的习惯，不然很多注释文档，前后查要晕，头秃了别怪代码，更不要怪我。

import numpy as np 
import time

start = time.time()

ming_list_All = np.load('ming_list.npy')  
# 重新定义ming_list列表为ming_list_All，稍后要对当中的每一行进行遍历
robot1_list = [0, 0, 0, 8, 8, 8]
robot2_list = [1, 1, 4, 5, 6, 7]

def dice_once():
    r1 = robot1_list[np.random.randint(0, 6)]
    r2 = robot2_list[np.random.randint(0, 6)]
    ming = ming_list_[np.random.randint(0, 6)]
    return r1, r2, ming

  # 遍历ming_list里所有的组合

for i in range(32661):
    ming_list_ = ming_list_All[i]
    win_count = 0    # 设置win_count初始值为0
    for j in range(10000):
        list = dice_once()
        r1 = list[0]
        r2 = list[1]
        ming = list[2]
        if (ming < r1) or (ming < r2):
            continue
        else:
            win_count += 1
    if win_count < 5000:
        continue
    else:
        print(i, win_count)
    # wincount_list.append(win_count)  # 这行代码运行时太长，时间无法计算
    continue

这里用“if win_count < 5000”来约束，减少计算机的计算时间。
同时，也是对小明的期许，如果写的骰子组合胜率还不能超过五成，那咱们就劝退小明吧！
最后打印出“（i , win_count）”代表（第几个循环，得胜次数）

我用了import time，来计算电脑运算这段代码所花费的时间，这里忽略。时间长到我写道这里，刚好运行完毕，约35分钟。

运行后结果：

120 5086
156 5029
2706 5037
2742 5033
3158 5004
29466 5035
29502 5063
32504 5006
32660 5045
计算用时：2131.7851秒

用人脑来看，最高得胜次数的组，编码是120，得胜次数是5086，组合是 [ 0, 0, 0, 8, 8, 8 ]，竟然和机器人1一样的组合，才得到五成胜率吗？

回去找ming_list_All编码是120的组合

这个时候疯了，回溯验证（将组合带入投掷模拟）的时候竟然胜率低于五成，说明模拟10000次的投掷，差别再上下100的胜率可能都没有意义。
试着改！x<5050的，直接pass掉。
然后，将上述代码 print(i, win_count) 改为
print ( i, win_count, ming_list_All [ i ] )

耐着性子再跑一次，谁叫自己码龄很低。
这样就不用回溯，直接得到胜率最高的一组。

结果：

2750 5093 [0 8 0 8 8 0]
29466 5094 [8 0 0 0 8 8]
29910 5055 [8 0 8 0 0 8]
计算用时：2292.9524秒

好嘛，小明好像没救了？结果一样。
不过，这结果也说明原始数据32661的量，有点虚大了，浪费计算资源。
脑子嗡得一下，好像得到啥启示，为什么不给32661个数据排序后做去重？？

ming_list_All的二维数据去重

由于原始数据是类似这样的结构：
[ 0, 0, 0, 8, 8, 8 ], [ ] ……[ 0, 1, 5, 6, 8, 4 ]
我们要将每一个组合进行升序排列，这样就会产生很多重复的数据。
然后用转元组tuple（特性是不允许重复数据的存在，会自动过滤重复数据）、再转回新列表的方法清洗数据。

这一步应该早点做，经验教训。

# 清洗：处理重复数据

import numpy as np

l1 = np.load('ming_list.npy')
l2 = []
for i in l1:
    new_i = sorted(i, reverse=False)
    l2.append(new_i)

dic = list(set([tuple(t) for t in l2]))
dic = [list(v) for v in dic]
print(len(dic))
print(dic)
np.save('dic.npy', dic)

好嘛，清洗后得到清爽的不重复的151个组合。真是清爽啊！
把 dic.npy 替换掉主程序的ming_list.npy。
增大模拟投掷次数到1000000次，还是一样，如果小过五成胜率，劝退小明。
由于模拟投掷次数增大100倍，结果会越接近真实得胜概率。

原汁原味代码如下：

import numpy as np 
import time

start = time.time()

ming_list_All = np.load('dic.npy')  
# 重新定义ming_list列表为ming_list_All，稍后要对当中的每一行进行遍历
robot1_list = [0, 0, 0, 8, 8, 8]
robot2_list = [1, 1, 4, 5, 6, 7]

def dice_once():
    r1 = robot1_list[np.random.randint(0, 6)]
    r2 = robot2_list[np.random.randint(0, 6)]
    ming = ming_list_[np.random.randint(0, 6)]
    return r1, r2, ming
  
# 遍历ming_list里所有的组合
for i in range(151):
    ming_list_ = ming_list_All[i]
    win_count = 0    # 设置win_count初始值为0
    for j in range(1000000):
        list = dice_once()
        r1 = list[0]
        r2 = list[1]
        ming = list[2]
        if (ming < r1) or (ming < r2):
            continue
        else:
            win_count += 1
    if win_count < 500000:
        continue
    else:
        print(i, win_count, ming_list_All[i])
    # wincount_list.append(win_count)  # 这行代码运行时太长，时间无法计算
    continue

end = time.time()
print("计算用时：%0.4f秒" % (end - start))

运算结论

模拟投掷次数一百万时，结果如下，也将近花了20多分钟：

4 500054 [0 0 0 8 8 8]

如果调整模拟投掷次数降到十万，结果出来的快很多：

4 50093 [0 0 0 8 8 8]
计算用时：111.9557秒

结论：够了，小明洗洗睡吧。

最后，小明最高胜率五成，骰子字儿为：[ 0, 0, 0, 8, 8, 8 ]