代码写得很烂，有兴趣的人可以跑一跑：

# /usr/bin/env python

# -*- encoding=utf-8 -*-

import random

from itertools import permutations, combinations

class Guess3():

def __init__(self):

self.WIN = "4A0B"

self.LENGTH = 4

self.POOL = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

self.record = []

self.stair = -1

self.ai_memory = list(self.__gen_all_result_set())

self.WIN_NUMBER = self.__gen_random_number()

# 程序开始时调用，生成随机数

def __gen_random_number(self):

result = list(self.__gen_all_result_set())

ran_value = random.randrange(len(result))

result1 = list(result[ran_value])

for i in range(len(result1)):

result1[i] = str(result1[i])

return ''.join(result1)

# 返回所有组合的迭代器

def __gen_all_result_set(self):

return permutations(self.POOL, 4)

# 转换嵌套的列表为元组

def __changeListToTuple(self, l1=[]):

for i in range(len(l1)):

l1[i] = tuple(l1[i])

return l1

# 转换list中字符串元素为数字元素（没有健壮性）

def __str_to_int(self, list1):

for i in range(len(list1)):

list1[i] = eval(list1[i])

return list1

# 去除list1中的list2元素（没有健壮性）

def __gen_new_list(self, list1, list2):

for i in list2:

list1.remove(i)

return list1

# 根据输入的4位数字和答案返回对应的结果集

def gen_new_pool(self, number, index_a, index_b):

pool_orgin = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

# 根据传入的Number,组成新的NUMBERlist，用于组合新的number

pool_number = list(number)

pool_number = self.__str_to_int(pool_number)

# 结合传入的NUMBER，与0-9组成的数组取补集

pool_orgin_running = self.__gen_new_list(pool_orgin, pool_number)

# 控制下标

index_model = [0, 1, 2, 3]

# 参与组合返回的数字

result_null = ['', '', '', '']

# 将程序生成的数组放入result中，形成二位数组。最终返回result

result = []

# 0A0B-0A4B生成的结果集与剩余的结果集进行组合时，会非法形成空集，导致Bug

if index_a == 0:

if index_b == 0:

result_list = list(permutations(pool_orgin_running, 4))

result = result_list

if index_b == 1:

result1 = []

result_pack1 = list(combinations(pool_orgin_running, 3))

result_pack2 = list(combinations(pool_number, 1))

# print("result_pack1",result_pack1)

# print("result_pack2", result_pack2)

for i in range(len(result_pack1)):

for j in range(len(result_pack2)):

temp = (list(result_pack1[i]) + list(result_pack2[j]))

temp_1 = list(permutations(temp, 4))

# print("temp:",temp)

# print("temp_1:", temp_1)

for m in range(len(temp_1)):

result1.append(list(temp_1[m]))

result = result1

if index_b == 2:

result2 = []

result_pack1 = list(combinations(pool_orgin_running, 2))

result_pack2 = list(combinations(pool_number, 2))

# print("result_pack1",result_pack1)

# print("result_pack2", result_pack2)

for i in range(len(result_pack1)):

for j in range(len(result_pack2)):

temp = (list(result_pack1[i]) + list(result_pack2[j]))

temp_1 = list(permutations(temp, 4))

# print("temp:",temp)

# print("temp_1:", temp_1)

for m in range(len(temp_1)):

result2.append(list(temp_1[m]))

result = result2

if index_b == 3:

result3 = []

result_pack1 = list(combinations(pool_orgin_running, 1))

result_pack2 = list(combinations(pool_number, 3))

# print("result_pack1",result_pack1)

# print("result_pack2", result_pack2)

for i in range(len(result_pack1)):

for j in range(len(result_pack2)):

temp = (list(result_pack1[i]) + list(result_pack2[j]))

temp_1 = list(permutations(temp, 4))

# print("temp:", temp)

# print("temp_1:", temp_1)

for m in range(len(temp_1)):

result3.append(list(temp_1[m]))

result = result3

if index_b == 4:

result4 = []

result_pack2 = list(permutations(pool_number, 4))

for m in range(len(result_pack2)):

result4.append(list(result_pack2[m]))

# print(result4)

result = result4

elif index_a == 1:

for i in range(4):

result_orgin = pool_number.copy()

result1 = result_null.copy() # ['', '', '', '']

# 控制下标，因为后面要从6个元素的数组中取数字给4元素数字，所以需要控制4元素数组的下标

a1_index = index_model.copy() # [0, 1, 2, 3]

first = a1_index.pop(i)

result1[first] = result_orgin.pop(first)

# print("result1",result1)

if index_b == 0:

for m in range(6):

a1_index1 = a1_index.copy()

second = a1_index1.pop()

bl_list1 = pool_orgin_running.copy()

result2 = result1.copy()

result2[second] = bl_list1.pop(m)

for n in range(5):

a1_index2 = a1_index1.copy()

third = a1_index2.pop()

result3 = result2.copy()

bl_list2 = bl_list1.copy()

result3[third] = bl_list2.pop(n)

for h in range(4):

a1_index3 = a1_index2.copy()

fourth = a1_index3.pop()

result4 = result3.copy()

bl_list3 = bl_list2.copy()

result4[fourth] = bl_list3.pop(h)

result.append(result4)

# print(result4)

if index_b == 1:

result_orgin2 = result_orgin.copy()

for j in range(3):

index2 = a1_index.copy()

second = index2.pop(j)

result2 = result1.copy()

result2[second] = result_orgin2.pop(2-j)

# print(result2)

for k in range(2):

index3 = index2.copy()

third = index3.pop(k)

for n in range(6):

result3 = result2.copy()

result_orgin3 = pool_orgin_running.copy()

result3[third] = result_orgin3.pop(n)

# print(result3)

for m in range(5):

index4 = index3.copy()

fourth = index4.pop()

result4 = result3.copy()

result_orgin4 = result_orgin3.copy()

result4[fourth] = result_orgin4.pop(m)

if index_b == 2:

for j in range(0,3):

# 控制下标，因为后面要从6个元素的数组中取数字给4元素数字，所以需要控制4元素数组的下标

a1_index2 = a1_index.copy() # [0, 1, 2]

second = a1_index2.pop(j)

# 这是需要填充的数组，最终组合成4元素数组

result2 = result1.copy()

# 这是用于取数字的数组，从这个数组取元素给需要填充的数组

# 填充数组

result_orgin2 = result_orgin.copy()

result2[second] = result_orgin2.pop(2-j)

# print(result2)

for k in range(2):

# 控制下标，因为后面要从6个元素的数组中取数字给4元素数字，所以需要控制4元素数组的下标

a1_index3 = a1_index2.copy() # [0, 1]

third = a1_index3.pop(k) # [0]

result_orgin3 = result_orgin2.copy()

result3 = result2.copy()

result3[third] = result_orgin3.pop(1-k)

# print(result3)

for l in range(6):

# 控制下标，因为后面要从6个元素的数组中取数字给4元素数字，所以需要控制4元素数组的下标

a1_index4 = a1_index3.copy() # [0]

fourth = a1_index4.pop()

result4 = result3.copy()

result_orgin4 = pool_orgin_running.copy()

result4[fourth] = result_orgin4.pop(l)

# print(result4)

result.append(result4)

# print(result.__len__())

if index_b == 3:

for j in range(3):

# 控制下标，因为后面要从6个元素的数组中取数字给4元素数字，所以需要控制4元素数组的下标

a1_index2 = a1_index.copy() # [0, 1, 2]

second = a1_index2.pop() # [0, 1]

# 复制被填充的数组

result2 = result1.copy()

# 复制数据源

result_orgin2 = result_orgin.copy()

result2[second] = result_orgin2.pop(j)

# print(result2)

for k in range(2):

a1_index3 = a1_index2.copy() # [0, 1]

third = a1_index3.pop() # [0]

result_orgin3 = result_orgin2.copy()

result3 = result2.copy()

result3[third] = result_orgin3.pop(k)

# print(result3)

for l in range(1):

a1_index4 = a1_index3.copy() # [0, 1]

fourth = a1_index4.pop() # [0]

result_orgin4 = result_orgin3.copy()

result4 = result3.copy()

result4[fourth] = result_orgin4.pop(l)

# print(result4)

result.append(result4)

elif index_a == 2:

for i in range(4):

result_orgin = pool_number.copy()

result1 = result_null.copy() # ['', '', '', '']

# 控制下标，因为后面要从6个元素的数组中取数字给4元素数字，所以需要控制4元素数组的下标

a2_index = index_model.copy() # [0, 1, 2, 3]

first = a2_index.pop(i) # [0, 1, 2]

result1[first] = result_orgin.pop(first)

# print(result1)

for j in range(3):

# 控制下标，因为后面要从6个元素的数组中取数字给4元素数字，所以需要控制4元素数组的下标

a2_index2 = a2_index.copy() # [0, 1, 2]

second = a2_index2.pop(j) # [0, 1]

# 复制被填充的数组

result2 = result1.copy()

# 复制数据源

result_orgin2 = result_orgin.copy()

result2[second] = result_orgin2.pop(j)

# print(result2)

if index_b == 0:

for m in range(6):

a2_index3 = a2_index2.copy()

third = a2_index3.pop()

result_orgin3 = pool_orgin_running.copy()

result3 = result2.copy()

result3[third] = result_orgin3.pop(m)

# print(result3)

for n in range(5):

a2_index4 = a2_index3.copy()

fourth = a2_index4.pop()

result4 = result3.copy()

result_orgin4 = result_orgin3.copy()

result4[fourth] = result_orgin4.pop(n)

# print(result4)

result.append(result4)

if index_b == 1:

for m in range(2):

a2_index3 = a2_index2.copy()

third = a2_index3.pop(m)

result_orgin3 = result_orgin2.copy()

result3 = result2.copy()

result3[third] = result_orgin3.pop(1-m)

# print(result3)

for n in range(6):

a2_index4 = a2_index3.copy()

fourth = a2_index4.pop()

result4 = result3.copy()

result_orgin4 = pool_orgin_running.copy() #复制6元素数组

result4[fourth] = result_orgin4.pop(n)

# print(result4)

result.append(result4)

pass

if index_b == 2:

for m in range(2):

a2_index3 = a2_index2.copy()

third = a2_index3.pop()

result_orgin3 = result_orgin2.copy()

result3 = result2.copy()

result3[third] = result_orgin3.pop(m)

for l in range(1):

a2_index4 = a2_index3.copy()

fourth = a2_index4.pop()

result_orgin4 = result_orgin3.copy()

result4 = result3.copy()

result4[fourth] = result_orgin4.pop(l)

result.append(result4)

# print(result4)

elif index_a == 3:

for i in range(4):

result_orgin = pool_number.copy()

result1 = result_null.copy() # ['', '', '', '']

# 控制下标，因为后面要从6个元素的数组中取数字给4元素数字，所以需要控制4元素数组的下标

a3_index = index_model.copy() # [0, 1, 2, 3]

first = a3_index.pop(i) #[0, 1, 2]

result1[first] = result_orgin.pop(first)

# print(result1)

for j in range(3):

# 控制下标，因为后面要从6个元素的数组中取数字给4元素数字，所以需要控制4元素数组的下标

a3_index2 = a3_index.copy() #[0, 1, 2]

second = a3_index2.pop(j) #[0, 1]

# 复制被填充的数组

result2 = result1.copy()

# 复制数据源

result_orgin2 = result_orgin.copy()

result2[second] = result_orgin2.pop(j)

# print(result2)

for k in range(2):

a3_index3 = a3_index2.copy() #[0, 1]

third = a3_index3.pop(k) #[0]

result_orgin3 = result_orgin2.copy()

result3 = result2.copy()

result3[third] = result_orgin3.pop(k)

# print(result3)

for l in range(6):

a3_index4 = a3_index3.copy()

fourth = a3_index4.pop()

result_orgin4 = pool_orgin_running.copy()

result4 = result3.copy()

result4[fourth] = result_orgin4.pop(l)

result.append(result4)

temp = []

for x in result:

if x not in temp:

temp.append(x)

else:

pass

result = temp

return result

# 判断输入的数字是否有存在重复数字组合

def __repeat(self, number):

Flag = None

temp = list(number)

for i in range(len(temp)):

for j in range(i, len(temp)):

if i != j:

if temp[i] == temp[j]:

return False

else:

Flag = True

return Flag

# 获取用户输入的数字

def __get_user_number(self):

Flag = True

count = 0

try:

while Flag:

number = input("请输入4位没有重复的数：")

temp = list(number)

if eval(number) > 9999:

print("输入的数字太大>>>>>>>>")

elif eval(number) < 1000:

print("输入的数字太小>>>>>>>>")

elif self.__repeat(number):

return number

elif number == '\r':

print("123")

except Exception:

print("输入错误!程序终止>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")

# 根据输入的数字判断结果

def __logical(self, number):

first = 0

second = 0

for n in range(self.LENGTH):

if number[n] == self.WIN_NUMBER[n]:

first += 1

elif number[n] in self.WIN_NUMBER:

second += 1

else:

pass

result = "%sA%sB" % (first, second)

return result

# AI的大脑

def __ai_think(self, number, answer):

result = []

for i in range(len(self.ai_memory)):

self.ai_memory[i] = list(self.ai_memory[i])

# 根据答案计算可能的集合

self.temp = self.gen_new_pool(number,eval(answer[0]),eval(answer[2]))

# print("上个得到的AI集合：",self.ai_memory.__len__())

# print("上个结果的集合：",self.temp.__len__())

# 与历史结果集进行比较，生成最新结果集

self.ai_memory = [var for var in self.temp if var in self.ai_memory]

#将数字从数组组成字符串

for i in self.ai_memory:

temp = ""

for j in i:

temp += str(j)

result.append(temp)

# 去除已经猜测过的结果

for j in self.record:

if j in result:

result.remove(j)

temp2 = []

for j in result:

if j not in temp2:

temp2.append(j)

result = temp2

# print("result:", result.__len__(),result)

# 从result数组中取出一个随机元素作为作为AI计算结果返回

if result == []:

# 修复未知BUG，重置AI存储库（0A开头的结果会导致Bug，懒得修复了，该BUG经过修复后只会延长游戏时间，哈哈）

self.ai_memory = list(self.__gen_all_result_set())

# 出现0结果集的BUG时，返回一个已输入的结果作为答案

return self.record[random.randrange(len(self.record))]

else:

result = result[random.randrange(result.__len__())]

return result

# 游戏开始

def start(self):

print("作弊：", self.WIN_NUMBER)

win_flag = True

while win_flag:

print("-------------------用户回合--------------------")

user_guess_number = self.__get_user_number()

print("用户猜测的数字是：", user_guess_number)

user_guess_result = self.__logical(user_guess_number)

print("结果是：", user_guess_result)

if user_guess_number not in self.record:

self.record.append(user_guess_number)

if user_guess_result == "4A0B":

print("你赢了！！！！！")

break

print("-------------------AI回合--------------------")

ai_guess_number = self.__ai_think(user_guess_number, user_guess_result)

ai_guess_result = self.__logical(ai_guess_number)

print("AI猜测的数字是：", ai_guess_number)

print("结果是：", ai_guess_result)

if ai_guess_number not in self.record:

self.record.append(ai_guess_number)

if ai_guess_result == "4A0B":

print("你输了！！！！！")

break

else:

self.__ai_think(ai_guess_number, ai_guess_result)

a = Guess3()

a.start()

幼儿园python_[Python]猜数字游戏AI版的实现（幼儿园智商AI）相关推荐

1. python猜数字游戏简单-python猜数字游戏快速求解解决方案

   python猜数字游戏快速求解解决方案.使用方法: 1. 保存代码为guessall.py 2. 执行python guessall.py > result.txt 3. 打开result.tx ...

2. python猜数字游戏快速求解解决方案

   python猜数字游戏快速求解解决方案 参考文章: (1)python猜数字游戏快速求解解决方案 (2)https://www.cnblogs.com/lijianming180/p/12037940 ...

3. python猜数字游戏（无聊至极）

   python猜数字游戏 环境python3 库random,tkinter 源码: #随机生成a,数值在1-6之间 a=random.randint(1,6) b = input("请输入色 ...

4. python猜数字游戏代码多次_黄哥Python：猜数字游戏代码

   猜数字游戏,电脑随机生存一个[1, 100] 之间的正整数,人输入一个数字,输出大了,还是小了,猜对了,就退出游戏.由于初学者没有学异常,所以没有采用异常. """ 猜数 ...

5. python猜数字代码_Python版的文曲星猜数字游戏代码

   # -*- coding: utf-8 -*- import random #数字类 class NumberItem: #数字个数 _GUESS_NUMBER_COUNT_ = 4 def __in ...

6. python猜数字游戏实例_Python案例：猜数字小游戏，由浅入深！

   本案例只适合新手,老司机请绕路. 游戏介绍:程序自己有一个数字,用户输入一个数字,两个数字进行比较. 可以学到的知识点:input函数.字符串.while循环.if条件判断语句.break语句. 一. ...

7. python猜数字游戏编程入门_Python实现猜数字游戏

   Python实现猜数字游戏 游戏规则: 随机产生1到100之间的整数 共有6次猜测机会,每次猜测如果不正确会提示大于或小于目标值,6次机会用完退出程序 6次机会,包含第6次机会如果猜中,提示用户猜中 ...

8. python猜数字游戏编程入门_如何利用Python开发一个简单的猜数字游戏

   导读热词 前言 本文介绍如何使用Python制作一个简单的猜数字游戏. 游戏规则 玩家将猜测一个数字.如果猜测是正确的,玩家赢.如果不正确,程序会提示玩家所猜的数字与实际数字相比是"大(hi ...

9. python猜数字游戏编程循环_使用python进行简单的猜数字游戏（while循环）

   使用python进行简单的猜数字游戏(while循环) 本案例主要是练习while循环,需求:如果给出某人的年龄,让你猜,猜对的话打印出You guess right 如果猜的数字小于真实年龄值,那就 ...

最新文章

1. 你想要的宏基因组-微生物组知识全在这(180601)
2. php管理txt文件系统,PHP文件系统管理详解
3. Hubble.net 简介及与Lucene.net 对比测试
4. 每天一个linux命令(25)：linux文件属性详解
5. 日常办公会用到的python模块-用 Python 自动化办公能做到哪些有趣或有用的事情？...
6. mysql中Invalid default value for 'stime'问题
7. PHP如何保存当前用户
8. android R编译OTA时报“ExternalError: Invalid ro.product.property_source_order”解决方法
9. linux 截取列_Linux 常用命令汇总
10. 队列的基本操作c语言代码大全,数据结构――队列（循环队列）的基本操作（实现链队列逐一取出c语言代码）...
11. Linux网卡驱动发送超时看门狗,如何在linux嵌入式中更改看门狗定时器
12. 腾讯棋牌开发商(深圳泊众)：投身网络棋牌游戏有风险
13. ios(ipad,iphone)屏幕旋转检测通用方法
14. linux如何测试IP和端口是否能访问
15. hp计算机指纹功能用法,惠普笔记本电脑指纹登录教程（图文）
16. （一）Anaconda的安装和使用
17. 联想小新pad安装Google Play教程
18. 单目深度估计数据集：NYU Depth Dataset V2
19. Hbase下载安装部署详细步骤
20. Windows显示与隐藏文件扩展名

热门文章

1. C4D中重点、难点分析
2. Redis持久化实践及数据恢复
3. JSTL 格式化 BigDecimal对象
4. 在Linux系统下查看ora错误
5. 解决wget下载中文乱码的方法
6. MAC OS X 10.8 操作远程SSH服务器 ＋ 无密码输入使用SSH服务器
7. scau实验题 8596 Longest Ordered Subsequence
8. mysql出现多线程操作同一个表的情况，应该怎么办？
9. 集合论——二元关系的表示方法，特殊的二元关系及关系的运算
10. c#写的贪吃蛇小游戏