小练习20160124：猜数----点评与结果

冬雪雪冬 · 发表于 2016-2-1 19:55:55

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

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

x

本帖最后由冬雪雪冬于 2016-2-4 11:02 编辑

本次练习大家答题踊跃，很多人给出了优秀的答案。
这次评判的原则是在符合题意的答案中看谁的尝试次数最少，谁的用时最短。答案正确的结果如下：

ID	尝试次数	用时
zooo	5.807	0.7647
DingRan	5.803	0.4479
wei_Y	8.367	2.165
Lnan95	6.063	0.954
USTC-ssj		1.495
落殇飞羽	5.688	0.5527
shuofxz	8.989	1.973
FDMa	5.808	0.4063

第一个答对的是 @zooo
结果最佳的是 @DingRan 和 @FDMa

@零度非安全的作业也非常优秀，采用2分法，并给出了详尽的注释。但出现了一个小BUG，他也在比赛结束后发现了并改正，为确保对其他参赛者的公平，只好忍痛割爱了。对他这种认真精神也将予以鼓励。

本次活动的结果请大家点评，如果有异议请于2.3 22：00前提出。
===========================================================

最终结果，最佳奖 @DingRan 和 @FDMa，
第一答对奖 @zooo

第一个给出答案的是 @debi999

import random
#新建空列表，用于存放猜数字的记数
count=[]
#定义猜数字函数
def funC():
a=int(random.uniform(1,100))
b=int(random.uniform(1,100))
for i in range(1,11):
if b==a:
break
else:
b=int(random.uniform(1,100))
count.append(int(i))
#循环执行100000次
for j in range(0,100000):
funC()
#定义猜中次数的计数器
a1=0
a2=0
a3=0
a4=0
a5=0
a6=0
a7=0
a8=0
a9=0
list1=[]
#判断猜中次数
for m in range(len(count)):
if count[m]==1:
a1+=1
elif count[m]==2:
a2+=1
elif count[m]==3:
a3+=1
elif count[m]==4:
a4+=1
elif count[m]==5:
a5+=1
elif count[m]==6:
a6+=1
elif count[m]==7:
a7+=1
elif count[m]==8:
a8+=1
elif count[m]==9:
a9+=1
list1.extend([a1,a2,a3,a4,a5,a6,a7,a8,a9])
#计算平均值
sum= (a1+a2+a3+a4+a5+a6+a7+a8+a9)
pjz=sum/(max(list1))
#输出
print('尝试 1 次猜中的有 %d 轮'%a1)
print('尝试 2 次猜中的有 %d 轮'%a2)
print('尝试 3 次猜中的有 %d 轮'%a3)
print('尝试 4 次猜中的有 %d 轮'%a4)
print('尝试 5 次猜中的有 %d 轮'%a5)
print('尝试 6 次猜中的有 %d 轮'%a6)
print('尝试 7 次猜中的有 %d 轮'%a7)
print('尝试 8 次猜中的有 %d 轮'%a8)
print('尝试 9 次猜中的有 %d 轮'%a9)
print ('平均 %.3f 次猜中'%pjz)

复制代码

很遗憾虽然整体思路是对的，但有些错误没有完成题意的要求。
1.用两个随机数来确定答案和猜数，并反复随机猜数来使两者相等，这样效率不高，且只比较10次无法保证每轮都能猜出答案。
2.用random.uniform函数得到的是实数，虽然用int取整，一是效率低，二是数字不是完全随机分布，出现100的可能性太低。

冬雪雪冬 · 发表于 2016-2-1 20:09:40

下一个参赛者是 @zooo

import random
gesTimes = [0,0,0,0,0,0,0]#每玩一次，猜的次数统计表
gameTimes = 100000 #玩的总轮数
for z in range(gameTimes):
maxNum = 102#经调试后确定的上限值->100+2
minNum = 0
ans = random.randint(1,100) #1,100的随机数
playTime = 1#每轮猜的次数
gesNum = (maxNum - minNum)/2
#二分法猜数
while ans != gesNum :
if gesNum > ans:#如果大了则要变小
maxNum = gesNum
gesNum -= (maxNum - minNum)//2#变小多少
else:#如果小了则要变大
minNum = gesNum
gesNum += (maxNum - minNum)//2#变大多少
playTime += 1
#调试代码（可以屏蔽）
if 10 <playTime:
print("error：",ans) #看看有哪个值漏了
break
#录表
for i in range(7):
if playTime == (i+1) :
gesTimes[i] += 1
break
#验证统计表中总数是否与游戏总轮数对应（可以屏蔽）
Sum = 0
for i in gesTimes:
Sum += i
print("统计次数总和:",Sum)
#输出结果
suum = 0
for i in range(7):
z = i + 1
suum += z*gesTimes[i]
print("尝试 %d 猜中的有 %d 轮"%(z,gesTimes[i]))
print("平均 %2.3f 次猜中"%(suum/gameTimes)) #%2.3f控制精度

复制代码

他采用二分法来确定猜数，效率较高，并根据实际运行情况调整了maxNum，使程序更合理。
实际运行结果：
统计次数总和: 100000
尝试 1 猜中的有 992 轮
尝试 2 猜中的有 1957 轮
尝试 3 猜中的有 3998 轮
尝试 4 猜中的有 7890 轮
尝试 5 猜中的有 15999 轮
尝试 6 猜中的有 31939 轮
尝试 7 猜中的有 37225 轮
平均 5.807 次猜中
用时：0.7647s
（注：用时为我在程序中加上time函数计算的，用时和平均猜中需要次数为实测值，后续的帖子相同）
优点：注释详尽，易读性好。
小建议：gesTimes = [0,0,0,0,0,0,0] 写成 gesTimes = [0] * 7 更简介明了。

冬雪雪冬 · 发表于 2016-2-1 20:15:56

本帖最后由冬雪雪冬于 2016-2-1 20:52 编辑

这是 @DingRan 的答案。

import random
#参数
gameRound = 100000 #运行轮数
bottom = 1 #猜数区间的下限
top = 100 #猜数区间的上限
#猜数并得出结果
result = [] #用来储存结果
for temp in range(gameRound):
attempt = 0 #初始化尝试次数
b = bottom
t = top
secret = random.randint(b,t) #生成随机数作为答案
while True:
guess = random.randint(b,t) #开猜
attempt += 1
if guess > secret: #猜大了
t = guess - 1
elif guess < secret: #猜小了
b = guess + 1
elif guess == secret : #猜对了
break
result.append(attempt) #储存结果
#输出
for n in range(min(result),max(result)+1):
if n in result:
print('尝试 %d 次猜中的有 %d 轮'%(n,result.count(n)))
print('平均 %.3f 次猜中'%(sum(result)/len(result)))

复制代码

方法与 @debi999 有些类似都是用随机数作为猜数，但每次根据比较的大小，调整猜数随机数的范围，大幅度提高了效率。
实际运行结果：
尝试 1 次猜中的有 995 轮
尝试 2 次猜中的有 1971 轮
尝试 3 次猜中的有 3706 轮
尝试 4 次猜中的有 6335 轮
尝试 5 次猜中的有 9883 轮
尝试 6 次猜中的有 13085 轮
尝试 7 次猜中的有 15042 轮
尝试 8 次猜中的有 14567 轮
尝试 9 次猜中的有 12186 轮
尝试 10 次猜中的有 9199 轮
尝试 11 次猜中的有 6117 轮
尝试 12 次猜中的有 3587 轮
尝试 13 次猜中的有 1877 轮
尝试 14 次猜中的有 839 轮
尝试 15 次猜中的有 381 轮
尝试 16 次猜中的有 148 轮
尝试 17 次猜中的有 55 轮
尝试 18 次猜中的有 21 轮
尝试 19 次猜中的有 3 轮
尝试 20 次猜中的有 3 轮
平均 7.488 次猜中
用时：1.8126s

他在后续的帖子给出了新的答案：

import random
#参数
gameRound = 100000 #运行轮数
bottom = 1 #猜数区间的下限
top = 100 #猜数区间的上限
#猜数并得出结果
result = [] #用来储存结果
for temp in range(gameRound):
attempt = 0 #初始化尝试次数
b = bottom
t = top
secret = random.randint(b,t) #生成随机数作为答案
while True:
guess = (b+t) // 2 #开猜
attempt += 1
if guess > secret: #猜大了
t = guess - 1
elif guess < secret: #猜小了
b = guess + 1
elif guess == secret : #猜对了
break
result.append(attempt) #储存结果
#输出
for n in range(min(result),max(result)+1):
if n in result:
print('尝试 %d 次猜中的有 %d 轮'%(n,result.count(n)))
print('平均 %.3f 次猜中'%(sum(result)/len(result)))

复制代码

采用变化的2分法，效率大幅提高。
实际运行结果：
尝试 1 次猜中的有 947 轮
尝试 2 次猜中的有 1910 轮
尝试 3 次猜中的有 3939 轮
尝试 4 次猜中的有 8053 轮
尝试 5 次猜中的有 16396 轮
尝试 6 次猜中的有 31725 轮
尝试 7 次猜中的有 37030 轮
平均 5.803 次猜中
用时：0.4479s

小建议：用result贮存100000个数，占用内存过大，可改进。

冬雪雪冬 · 发表于 2016-2-1 20:29:31

这是 @wei_Y 版主的答案。

import random
def ran_result():
# 生成结果。
for i in range(100000):
yield random.randint(1, 100)
def run():
guess_result = []
def guess(init, i, init_max=100, init_min=1, count=1):
# 猜测。
if init == i:
guess_result.append(count)
return
elif init < i:
init_min = init
elif init > i:
init_max = init
# 纯随机。
init = random.randint(init_min, init_max)
guess(init, i, init_max=init_max, init_min=init_min, count=count+1)
for x in ran_result():
guess(random.randint(1, 100), x)
return guess_result
def count_result():
# 统计。
result = run()
# 效率低，可修改最大值。
count = [0 for i in range(max(result))]
for x in result:
count[x-1] += 1
for i in range(len(count)):
print("尝试 %d 次猜中的有 %d 轮" % (i+1, count[i]))
print("平均需要: %.5f次" % (sum(map(lambda x: x*int(count.index(x))+1, count)) / 100000))
count_result()

复制代码

也是用随机数作为猜数，并根据比较大小调整随机数的边界。
实际运行结果：
尝试 1  次猜中的有 1038 轮
尝试 2  次猜中的有 1889 轮
尝试 3  次猜中的有 3242 轮
尝试 4  次猜中的有 4943 轮
尝试 5  次猜中的有 6807 轮
尝试 6  次猜中的有 8348 轮
尝试 7  次猜中的有 9482 轮
尝试 8  次猜中的有 9911 轮
尝试 9  次猜中的有 9730 轮
尝试 10  次猜中的有 8977 轮
尝试 11  次猜中的有 7908 轮
尝试 12  次猜中的有 6614 轮
尝试 13  次猜中的有 5286 轮
尝试 14  次猜中的有 4259 轮
尝试 15  次猜中的有 3221 轮
尝试 16  次猜中的有 2469 轮
尝试 17  次猜中的有 1727 轮
尝试 18  次猜中的有 1333 轮
尝试 19  次猜中的有 904 轮
尝试 20  次猜中的有 603 轮
尝试 21  次猜中的有 427 轮
尝试 22  次猜中的有 278 轮
尝试 23  次猜中的有 184 轮
尝试 24  次猜中的有 144 轮
尝试 25  次猜中的有 95 轮
尝试 26  次猜中的有 59 轮
尝试 27  次猜中的有 46 轮
尝试 28  次猜中的有 24 轮
尝试 29  次猜中的有 15 轮
尝试 30  次猜中的有 13 轮
尝试 31  次猜中的有 9 轮
尝试 32  次猜中的有 4 轮
尝试 33  次猜中的有 6 轮
尝试 34  次猜中的有 1 轮
尝试 35  次猜中的有 1 轮
尝试 36  次猜中的有 0 轮
尝试 37  次猜中的有 1 轮
尝试 38  次猜中的有 0 轮
尝试 39  次猜中的有 1 轮
尝试 40  次猜中的有 1 轮
平均需要: 8.36781次
用时：2.1650s
@wei_Y 设计了多个函数，是整个程序更易调整和修改，增强了可读性。

冬雪雪冬 · 发表于 2016-2-1 20:39:10

这是 @Lnan95 的答案。
她给出了2个答案。
采用2分法的。

#二分法猜数字
import random
lis = {}
for i in range(100000):
times = 0
y = random.randint(1,100)
x = random.randint(1,100)
rangex = [1,100]
result = 0
while True:
if x == y:
result += 1
lis.setdefault(result,0)
lis[result] += 1
break
elif x < y:
result += 1
rangex[0] = x
x = (1/2*(x+rangex[1]+1))//1
elif x > y:
result += 1
rangex[1] = x
x = (1/2*(x+rangex[0]))//1
for item in lis.items():
print("尝试 %-1d 次猜中的有%6d" % item,"轮")
#加权平均
summary =sum(lis.values())
sumvalues = sum([key*lis[key] for key in lis.keys()])
jq = sumvalues/summary
print("平均 %5f 次猜中" % jq)

复制代码

实际运行结果：
尝试 1 次猜中的有  1000 轮
尝试 2 次猜中的有  1972 轮
尝试 3 次猜中的有  3918 轮
尝试 4 次猜中的有  7549 轮
尝试 5 次猜中的有 14206 轮
尝试 6 次猜中的有 24428 轮
尝试 7 次猜中的有 33587 轮
尝试 8 次猜中的有 13340 轮
平均 6.063210 次猜中
用时：0.9540s

采用普通方法：

import random
lis = {}
for i in range(1000):
times = 0
y = random.randint(1,100)
x = random.randint(1,100)
rangex = [1,100]
result = 0
while True:
if x == y:
result += 1
lis.setdefault(result,0)
lis[result] += 1
break
elif x < y:
result += 1
rangex[0] = x + 1
x = random.randint(rangex[0],rangex[1])
elif x > y:
result += 1
rangex[1] = x -1
x = random.randint(rangex[0],rangex[1])
for item in lis.items():
print("尝试 %-2d 次猜中的有%6d" % item,"轮")
#加权平均
summary =sum(lis.values())
sumvalues = sum([key*lis[key] for key in lis.keys()])
jq = sumvalues/summary
print("平均 %5f 次猜中" % jq)

复制代码

总局数不对，我修改了一下。实际运行结果如下：
尝试 1  次猜中的有  1002 轮
尝试 2  次猜中的有  1994 轮
尝试 3  次猜中的有  3841 轮
尝试 4  次猜中的有  6411 轮
尝试 5  次猜中的有  9908 轮
尝试 6  次猜中的有 13362 轮
尝试 7  次猜中的有 14940 轮
尝试 8  次猜中的有 14422 轮
尝试 9  次猜中的有 12214 轮
尝试 10 次猜中的有  9061 轮
尝试 11 次猜中的有  5953 轮
尝试 12 次猜中的有  3570 轮
尝试 13 次猜中的有  1814 轮
尝试 14 次猜中的有 893 轮
尝试 15 次猜中的有 367 轮
尝试 16 次猜中的有 157 轮
尝试 17 次猜中的有 68 轮
尝试 18 次猜中的有 16 轮
尝试 19 次猜中的有    4 轮
尝试 20 次猜中的有    3 轮
平均 7.463650 次猜中
用时：1.877s

从两个对比可以看出2分法效率要高得多。

黑龍 · 发表于 2016-2-1 20:53:52

楼主真是python大神。。我想用C写来着不过发现C语言for到100000一运行就出了结果

冬雪雪冬 · 发表于 2016-2-1 20:59:11

这是 @USTC-ssj 是答案。

import random
secret = random.randint(1, 100)
result = [0]*100
for i in range(0,100000):
count = 0
guess = 0
num_max = 100
num_min = 0
while guess != secret:
if guess < secret:
num_min = guess
guess = random.randint(guess+1, num_max)
else:
num_max = guess
guess = random.randint(num_min+1, guess)
count += 1
result[count] += 1
for j in range(1,100):
if result[j] != 0:
print('尝试 %2d 次猜中的有 %7d 轮'%(j, result[j]))

复制代码

也是使用随机数作为猜数并调整范围。程序很简练。
实际运行结果：
尝试  1 次猜中的有 1060 轮
尝试  2 次猜中的有 3760 轮
尝试  3 次猜中的有 7545 轮
尝试  4 次猜中的有 11286 轮
尝试  5 次猜中的有 13761 轮
尝试  6 次猜中的有 14342 轮
尝试  7 次猜中的有 13287 轮
尝试  8 次猜中的有 11224 轮
尝试  9 次猜中的有 8493 轮
尝试 10 次猜中的有 5807 轮
尝试 11 次猜中的有 3847 轮
尝试 12 次猜中的有 2369 轮
尝试 13 次猜中的有 1440 轮
尝试 14 次猜中的有    856 轮
尝试 15 次猜中的有    406 轮
尝试 16 次猜中的有    237 轮
尝试 17 次猜中的有    124 轮
尝试 18 次猜中的有    87 轮
尝试 19 次猜中的有    37 轮
尝试 20 次猜中的有    13 轮
尝试 21 次猜中的有    9 轮
尝试 22 次猜中的有    6 轮
尝试 23 次猜中的有    3 轮
尝试 24 次猜中的有    1 轮
用时：1.495s

冬雪雪冬 · 发表于 2016-2-1 21:02:24

本帖最后由冬雪雪冬于 2016-2-2 10:16 编辑

这是 @零度非安全的答案。

import random
TryCount = [] #首先设一个空列表，用来放尝试的次数
Sumnumber = 0 #用来存放所有轮尝试的次数
def BinarySearch(answer,number): #定义一个函数，用来记录每轮猜测的次数
count = 0 #统计尝试的次数
low = 1
height = 100
while low < height: #利用折半查找法进行查找,折半查找的效率更高些
count += 1 #每次进行判断完count的次数自增1
number = (low + height) // 2
if number == answer:
break #若相等，则break终止循环并将count值返回
elif number < answer:
low = number + 1 #若小于，则在右半部分查找
else:
height = number - 1 #若大于，则在左半部分查找
return count
for i in range(1,100001): #题目要求进行100000轮猜测游戏
number = 0
answer = random.randint(1,100) #在1~100之间取随机数
TryCount.append(BinarySearch(answer,number)) #调用BinarySearch()函数，并将返回值依次压入列表中
for j in range(1,10): #经过多次测试，每次都是10次之内
while j in TryCount:
Sumnumber += j * TryCount.count(j)
print('尝试%d次猜中的有%5d轮'%(j,TryCount.count(j)))
break
print('平均%.3f次猜中'%(Sumnumber/100000))

复制代码

也是采用2分法。写了详尽的注释。
有个小BUG，作者后来也注意到了，就是 while low < height 应改为 while low <= height，这样就得到了预期的答案了。其实while循环有两处跳出循环的地方，这容易出现小错误，我认为改为 while True 可能更好。

冬雪雪冬 · 发表于 2016-2-1 21:11:22

这是 @落殇飞羽的答案：

#取得中位数
def two_split(first, last):
mid = (first + last) // 2
return mid
def compare(answer, guess, count1, count2, first1, last1):
#得到每轮猜中的次数，并放入列表
if guess == answer:
count1 += 1
#print(count2)
list2.append(count2)
#传入两个交换变量first1，last1以保存上一轮的列表中间数
elif guess > answer:
count2 += 1
if first1 == 0:
first1 = first
last1 = guess
else:
first1 = first1
last1 = guess
guess = two_split(first1, last1)
#print(guess)
compare(answer, guess, count1, count2, first1, last1)
else:
count2 += 1
if last1 == 0:
first1 = guess
last1 = last
else:
first1 = guess
last1 = last1
guess = two_split(first1, last1)
#print(guess)
compare(answer, guess, count1, count2, first1, last1)
import random
sum1 = sum0 = 0
i = 0
first = 1
last = 100
first1 = 0
last1 = 0
count1 = 0 #记录一轮猜中的次数
count2 = 1 #记录猜中的轮数
list1 = [1,100]
global list2
list2 = []
dic1 = {}
while i < 100000:
answer = random.randint(1,100)
if answer in list1:
guess = random.randint(1,2)
list2.append(guess)
#print(answer, guess)
else:
guess = two_split(first, last)
#print(answer, guess)
compare(answer, guess, count1, count2, first1, last1)
i += 1
#把次数和轮数对应起来
for each_1 in list2:
if each_1 not in dic1:
dic1[each_1] = 1
else:
dic1[each_1] += 1
#print(list2)
#按照key的从小到大排列输出次数与对应轮数
list3 = list(dic1)
list3.sort()
for each_2 in list3:
print('尝试%d次实验猜对的有%d轮'%(each_2, dic1[each_2]))
sum0 = each_2 * dic1[each_2]
sum1 += int(sum0)
print('平均%f次猜中'%(sum1/100000))

复制代码

也是采用2分法。并使用了函数。
实际运行结果：
尝试1次实验猜对的有1991轮
尝试2次实验猜对的有2980轮
尝试3次实验猜对的有3996轮
尝试4次实验猜对的有8040轮
尝试5次实验猜对的有16034轮
尝试6次实验猜对的有32101轮
尝试7次实验猜对的有34858轮
平均5.688810次猜中
用时：0.5527s
这它的第二个程序。

import random
answer = random.randint(1,100)
count = 0
count1 = 0 #count1统计每一轮出现所有猜对的次数
count2 = 1 #count2统计每轮猜对之前所实验的次数
count3 = 1 #count3统计实验次数相等的轮数
count4 = 0 #count4统计所有猜对的轮数
count5 = 0 #count5统计所有猜的次数之和
list1 = []#列表放置10000个所猜的数
list2 = []#列表放置每次猜中之前的次数
list3 = []#列表放置排序后的key值
#形成一个100000所猜数的列表
while count < 100000:
number = random.randint(1,100)
list1.append(number)
count += 1
#将实验次数与猜中的轮数对应放入一个字典
dic1 = {}
i = 0
while i < 100000:
if list1[i] == answer:
count4 += 1
count1 += 1
count5 += count2
list2.append(count2)
count1 = 0
count2 = 0
else:
count2 += 1
i += 1
for each_1 in list2:
if each_1 not in dic1:
dic1[each_1] = 1
else:
count3 += 1
dic1[each_1] = count3
#按照key的从小到大排列输出次数与对应轮数
list3 = list(dic1)
list3.sort()
for each_2 in list3:
print('尝试%d次实验猜对的有%d轮'%(each_2, dic1[each_2]))
print('共猜对%d轮'%count4)
if count4 != 0:
print('平均每轮猜中需要%d次'%(count5/count4))
#print(list1)
print(answer)

复制代码

这个我没太看懂，不过实际运行效果不理想。

冬雪雪冬 · 发表于 2016-2-1 21:19:23

这是 @shuofxz 的第一个程序。

import random
N = 0
guess = 0
G1 = G2 = G3 = G4 = G5 = G6 = G7 = G8 = G9 = 0
SUM = 0
while N < 100000:
AAA = random.randint(1,10)
N += 1
i =0
while guess != AAA:
SUM += 1
i += 1
guess = random.randint(1,10)
if i == 1:
G1 += 1
elif i == 2:
G2 += 1
elif i == 3:
G3 += 1
elif i == 4:
G4 += 1
elif i == 5:
G5 += 1
elif i == 6:
G6 += 1
elif i == 7:
G7 += 1
elif i == 8:
G8 += 1
elif i == 9:
G9 += 1
print('尝试1次猜中的有', G1, '轮')
print('尝试2次猜中的有', G2, '轮')
print('尝试3次猜中的有', G3, '轮')
print('尝试4次猜中的有', G4, '轮')
print('尝试5次猜中的有', G5, '轮')
print('尝试6次猜中的有', G6, '轮')
print('尝试7次猜中的有', G7, '轮')
print('尝试8次猜中的有', G8, '轮')
print('尝试9次猜中的有', G9, '轮')
print('平均', round(SUM/100000, 3), '次猜中')

复制代码

也是用随机数作为猜数。
实际运行结果：
尝试1次猜中的有 8973 轮
尝试2次猜中的有 8158 轮
尝试3次猜中的有 7293 轮
尝试4次猜中的有 6585 轮
尝试5次猜中的有 5935 轮
尝试6次猜中的有 5256 轮
尝试7次猜中的有 4798 轮
尝试8次猜中的有 4317 轮
尝试9次猜中的有 3951 轮
平均 8.989 次猜中
用时：1.973s

第二个程序。

import random
SUM = 0
result = [0,0,0,0,0,0,0,0,0,0]
N = 0
while N < 100001:
N += 1
AAA = random.randint(1,100)
i =0
MIN = 1
MAX = 100
while (MIN+MAX)//2 != AAA:
SUM += 1
i += 1
if (MIN+MAX)//2 < AAA:
MIN = (MIN+MAX)//2
else:
MAX = (MIN+MAX)//2
result[i] += 1
for i in range(0,10):
print('尝试%d次猜中的有 %3d 轮'%(i+1,result[i]))
print('平均', round(SUM/100000, 3), '次猜中')

复制代码

采用2分法，但有时会死循环，需修改。

冬雪雪冬 · 发表于 2016-2-1 21:21:50

这是 @房间里的大象的答案。

import random
x=random.randint(1,100)
n=100000
a=0
while n:
import random
y=random.randint(1,100)
if x==y:
a=a+1
n=n-1
print ('尝试1次猜测的有 '+a' 轮')

复制代码

也是用随机数作为猜数。可惜程序没有完成，建议参考其他人的答案自己再做一遍。

冬雪雪冬 · 发表于 2016-2-1 21:26:16

这是 @FDMa 的答案。

def guess(sre = 10):
time = 0
low = 0
high = 100
ges = (low + high) // 2
while ges != sre:
if ges == 99:
ges = 100
elif ges > sre:
high = ges
ges = (low + ges) // 2
else:
low = ges
ges = (high + ges) // 2
time += 1
return time
result_time = [0] * 8
for i in range(100000):
sre = random.randint(1,100)
result_time[guess(sre)] += 1
out = '''尝试 1 次猜中的有 {num1} 轮
尝试 2 次猜中的有 {num2} 轮
尝试 3 次猜中的有 {num3} 轮
尝试 4 次猜中的有 {num4} 轮
尝试 5 次猜中的有 {num5} 轮
尝试 6 次猜中的有 {num6} 轮
尝试 7 次猜中的有 {num7} 轮
尝试 8 次猜中的有 {num8} 轮
平均 {avg} 次猜中'''.format(num1=result_time[0], num2=result_time[1], num3=result_time[2], num4=result_time[3],
num5=result_time[4], num6=result_time[5], num7=result_time[6], num8=result_time[7],
avg=round(sum((i[0]+1)*i[1] for i in enumerate(result_time))/100000 , 3))
print(out)

复制代码

也是2分法，比较巧妙的是加入 if ges == 99: ges = 100避免死循环。比较遗憾的是没有 import random语句。
实际运行结果：
尝试 1 次猜中的有 909 轮
尝试 2 次猜中的有 2029 轮
尝试 3 次猜中的有 4019 轮
尝试 4 次猜中的有 8058 轮
尝试 5 次猜中的有 16218 轮
尝试 6 次猜中的有 31851 轮
尝试 7 次猜中的有 35947 轮
尝试 8 次猜中的有 969 轮
平均 5.808 次猜中
用时：0.4063s

冬雪雪冬 · 发表于 2016-2-1 21:27:35

本帖最后由冬雪雪冬于 2016-2-1 21:29 编辑

这是 @不爱穿内裤的答案。

import random as r
def one_round():
'''
输出一个数：计算机猜中需要尝试的次数
'''
ans = r.randint(0, 100)
guess = r.randint(0, 100)
try_time = 0
while 1:
try_time += 1
if guess == ans:
return try_time
elif guess > ans:
guess = r.randint(ans, guess)
elif guess < ans:
guess = r.randint(guess, ans)
def computer_play_game():
d = dict()
for i in range(100000):
try_time = one_round()
try:
d[try_time] += 1
except:
d[try_time] = 1
for key in d:
print('小机机尝试了 %d 次猜中的有 %d 轮' %(key, d[key]))

复制代码

也是采用随机数作为猜数，但很遗憾光有函数没有主程序。

冬雪雪冬 · 发表于 2016-2-1 21:31:44

这是 @kunaiai 的答案。

import random
secret = random.randint(1,100)
time = 1
time1 = 0
res = []
while time <= 100000:
guess = random.randint(1,100)
time1 += 1
if guess == secret:
res.append(time1);
time1 = 0
secret = random.randint(1,100)
time += 1
allRes = 0
for i in res:
allRes += i
count = len(res)
print('共猜中%d,平均%.3f轮猜中'%(count,allRes/count))

复制代码

也是随机数作为猜数，但并没有得到完全符合题意的结果。

冬雪雪冬 · 发表于 2016-2-1 21:34:48

这是 @swsfly 的答案。

import random
secret = random.randint(1,100)
count1 = count2 = count3 = count4 = count5 = count6 = count7 = count8 = count9 =0
for i in range (100000):
temp1 = random.randint(1,100)
guess1 = int(temp1)
if guess1 == secret:
count1 =count1 +1
else:
temp2 = random.randint(1,100)
guess2 = int(temp2)
if guess2 == secret:
count2 = count2 + 1
else:
temp3 = random.randint(1,100)
guess3 = int(temp3)
if guess3 == secret:
count3 = count3 + 1
else:
temp4 = random.randint(1,100)
guess4 = int(temp4)
if guess4 == secret:
count4 = count4 + 1
else:
temp5 = random.randint(1,100)
guess5 = int(temp5)
if guess5 == secret:
count5 = count5 + 1
else:
temp6 = random.randint(1,100)
guess6 = int(temp6)
if guess6 == secret:
count6 = count6 + 1
else:
temp7 = random.randint(1,100)
guess7 = int(temp7)
if guess7 == secret:
count7 = count7 + 1
else:
temp8 = random.randint(1,100)
guess8 = int(temp8)
if guess8 == secret:
count8 = count8 + 1
else:
temp9 = random.randint(1,100)
guess9 = int(temp9)
if guess9 == secret:
count9 = count9 + 1
a=100000/(count1+count2+count3+count4+count5+count6+count7+count8+count9)
print("尝试1次猜中的有 ",count1,'轮')
print("尝试2次猜中的有 ",count2,'轮')
print("尝试3次猜中的有 ",count3,'轮')
print("尝试4次猜中的有 ",count4,'轮')
print("尝试5次猜中的有 ",count5,'轮')
print("尝试6次猜中的有 ",count6,'轮')
print("尝试7次猜中的有 ",count7,'轮')
print("尝试8次猜中的有 ",count8,'轮')
print("尝试9次猜中的有 ",count9,'轮')
print("平均",a,'次猜中')

复制代码

也是采用随机数作为猜数，并使用了多级的if语句，但很遗憾只写到temp9没有给出全部答案。

冬雪雪冬 · 发表于 2016-2-1 21:55:46

黑龍发表于 2016-2-1 20:53
楼主真是python大神。。我想用C写来着不过发现C语言for到100000一运行就出了结果

黑龍版主，我还不会C语言，以后有机会向你学习。

Lnan95 · 发表于 2016-2-1 22:02:39

看来运行的速度也是个大学问啊

冬雪雪冬 · 发表于 2016-2-1 22:04:53

Lnan95 发表于 2016-2-1 22:02
看来运行的速度也是个大学问啊

是的，算法优化可以使用最少的步骤最短的时间完成任务。

zooo · 发表于 2016-2-1 22:29:24

发现我的第9行忘记用地板除了，影响了不少效率，优化程序中。。。

冬雪雪冬 · 发表于 2016-2-1 22:39:21

zooo 发表于 2016-2-1 22:29
发现我的第9行忘记用地板除了，影响了不少效率，优化程序中。。。

嗯，就是在不断的学习，不断的挑战自我中提高的。

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

[技术交流] 小练习20160124：猜数----点评与结果

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

评分

本帖被以下淘专辑推荐:

浏览过的版块