编程的乐趣：用Python解算法谜题 课后习题答案
说明：作者已经给了各章习题1的答案，其他的习题答案我来补充下，使用语言为Python3，有问题欢迎留言。
附习题一答案：https://mitpress.mit.edu/books/programming-puzzled
点击左下角 Code for Selected Puzzle Solutions 即可下载。
谜题 1 保持一致
1.10 习题(page11)
习题 2 修改pleaseConformOnepass，如习题1那样打印更自然一些的命令，并确保程序再输入是空列表时不会崩溃。
提示：你需要记住区间的起始位置（而不是在第6行打印）。
'''在line-opt.py上修改'''
def pleaseConformOnepass(caps):
if caps != []: #判断是否为空
caps = caps + [caps[0]]
for i in range(1, len(caps)):
if caps[i] != caps[i-1]:
if caps[i] != caps[0]:
temp = i #存储临时变量
print('People in positions', i, end='')
else:
if temp == i-1: #前后比较
print(' flip your caps!')
else:
print(' through', i-1, 'flip your caps!')
else:
print("You can't input a null list!")
难题3 假设在队伍中存在没戴帽子的人。我们用字符’H’代表他们。例如，有这样一组数据：
caps3 = [‘F’, ‘F’, ‘B’, ‘H’, ‘B’, ‘F’, ‘B’, ‘B’, ‘B’, ‘F’, ‘H’, ‘F’, ‘F’ ]
我们不想指示没戴帽子的人去转动不存在的帽子，这令人困惑，可能会导致有人试图从队伍前面的人那里偷帽子。因此我们希望跳过所有’H’位置。修改pleaseConform，使它生成正确并且最小数量的命令集合。对于上面的例子，它应当生成：
People in positions 2 flip your caps!
People in positions 4 flip your caps!
People in positions 6 through 8 flip your caps!
'''在line.py文件pleaseConform函数上修改'''
for i in range(1, len(caps)):
if caps[start] != caps[i]:
# each interval is a tuple with 3 elements (start, end, type)
if caps[start] == 'H': #在这边做下判断
start = i
continue
intervals.append((start, i - 1, caps[start]))
if caps[start] == 'F':
forward += 1
else:
backward += 1
start = i
习题 4 写一段程序实现简单的游程编码，将给定字符串（如BWWWWWBWWWW）转换为较短的字符串（1B5W1B4W），并且执行游程解码，将压缩过的字符串转换回原始字符串。你只能通过一次字符串遍历来执行压缩和解压缩过程。
str函数能将数字转换成字符串，例如str(12) = ‘12’。它在编码步骤汇总会很有用。
int函数能将字符串转换成数字，例如：int(‘12’) = 12。对于任意字符串s，如果s[i]是字母字符，则s[i].isalpha()将返回True，否则返回False。如果s中所有的字符都是字母字符，则s.isalpha()返回True，否则返回False。函数int和isalpha在解码步骤中会很有用。
"""
BWWWWWBWWWW ==> 1B5W1B4W
1B5W1B4W ==> BWWWWWBWWWW
"""
def encode(strs):
'''编码：每两个字符进行比较,如果不同输出前面的内容，
如果相同，开始累加，直到比较不同而输出为止，如此反复。'''
strs = strs + ' '
sum = 1
for c in strs[1:]:
if strs[0] != c:
print(sum, strs[0], sep='', end='')
sum = 1
else:
sum = sum + 1
strs = strs[1:]
print('')
def decode(strs):
'''解码：利用数字在先字母在后的特点，对处于索引偶数位的数字做记录，
对处于索引奇数位的字母做*运算'''
for n,s in enumerate(strs):
if n % 2 == 0:
num = int(s)
else:
print(s * num, end='')
n += 1
print('')
encode('BWTTTTWWBWQQQWW')
decode('1B1W4T2W1B1W3Q2W')
谜题 2 参加派对的最佳时间
2.4 习题(page20)
习题 2 有另一种方法， 可以不依赖时间精度来计算参加派对的最佳时间。我们依次选择每位名人的时间区间，并确定有多少其他名人的时间区间包含所选名人的开始时间。我们选择出某位名人，使他的开始时间被最大数量的其他名人时间区间所包含，并将他的开始时间作为参加派对的时间。编写代码实现该算法，并验证它的结果与基于排序算法的结果是否相同。
'''在文件partysmart.py文件结尾处添加'''
def ex2(sched):
'''双循环，让每一个起始时间和所有时间比较，如果在区间中则记录，最后取人数最多的那个。'''
count = max_count = 0
for i in sched:
for j in sched:
if i[0] >= j[0] and i[0] < j[1]:
count += 1
#print(i[0],count) #可详细输出所有的信息
if count > max_count:
max_count = count
best_time = i[0]
count = 0
print('Best time to attend the party is at', best_time, 'o\'clock :', max_count, 'celebrities will be attending!')
ex2(sched2)
#sched2 = [(6.0, 8.0), (6.5, 12.0), (6.5, 7.0), (7.0, 8.0), (7.5, 10.0), (8.0, 9.0),(8.0, 10.0), (9.0, 12.0), (9.5, 10.0), (10.0, 11.0), (10.0, 12.0), (11.0, 12.0)]
'''
print:
Best time to attend the party is at 9.5 o'clock : 5 celebrities will be attending!
原程序的结果为：
Best time to attend the party is at 9.5 o'clock : 5 celebrities will be attending!
结果完全相同，不过感觉习题2的算法更好理解和实现。
'''
难题 3 假设每位名人都有一个权重，取决于你对这位名人的喜爱程度。可以在时间表中将其表示为一个三元组，如(6.0, 8.0, 3)。开始时间是6.0，结束时间是8.0，权重是3。修改代码，找出最大化名人总权重的时间。例如…下面是一个更复杂的例子：
sched3 = [(6.0, 8.0, 2), (6.5, 12.0, 1), (6.5, 7.0, 2), (7.0, 8.0, 2), (7.5, 10.0, 3), (8.0, 9.0, 2), (8.0, 10.0, 1), (9.0, 12.0, 2), (9.5, 10.0, 4), (10.0, 11.0, 2), (10.0, 12.0, 3), (11.0, 12.0, 7)]
根据名人的日程安排，你想要在11点参加派对，此时参加派对名人权重之和是13，为最大值。
'''在上面的文件partysmart.py上再追加如下代码'''
sched3 = [(6.0, 8.0, 2), (6.5, 12.0, 1), (6.5, 7.0, 2), (7.0, 8.0, 2), (7.5, 10.0, 3), (8.0, 9.0, 2),
(8.0, 10.0, 1), (9.0, 12.0, 2), (9.5, 10.0, 4), (10.0, 11.0, 2), (10.0, 12.0, 3), (11.0, 12.0, 7)]
def ex3(sched):
count = max_count = 0
for i in sched:
for j in sched:
if i[0] >= j[0] and i[0] < j[1]:
count += j[2] #把之前的+1改为+j[2]即可
#print(i[0],count)
if count > max_count:
max_count = count
best_time = i[0]
count = 0
print('Best time to attend the party is at', best_time, 'o\'clock :', max_count, 'celebrities will be attending!')
ex3(sched3)
'''
print:
Best time to attend the party is at 11.0 o'clock : 13 celebrities will be attending!
'''
谜题 3 拥有（需要一点校准的）读心术
3.6 习题(page32)
习题 2 修改ComputerAssistant，以防存在两对同花色的牌，则在选择隐藏牌与第一张牌时，选择其中需要编码的数值更小的一对牌。
'''直接在magic-exercise1.py文件上修改函数outputFirstCard，ComputerAssistant并添加了一个函数least_elem'''
def least_elem(numbers, oneTwo):
'''取出两个卡牌差值最小的两个元素'''
oneTwo_new = []
for oneTwo_one in oneTwo: # 拆包，将超过2个的元组全部扩展成2个，用于处理含有3个及以上相同花色的卡牌，题目没有要求处理这种情况，但我也把这种情况算进去了。比如oneTwo的值为[(0, 1, 3)]，即三张牌同一花色。
oneTwo_new += [(i,j) for i in oneTwo_one for j in oneTwo_one if i < j ] # 如[(0, 1, 3)] ⇒ [(0, 1), (0, 3), (1, 3)]
oneTwo_least = 52 # 随便赋值一个较大的数
for oneTwo_one in oneTwo_new: #遍历所有元组，找出最小值
temp = min(((numbers[oneTwo_one[0]] - numbers[oneTwo_one[1]]) % 13), ((numbers[oneTwo_one[1]] - numbers[oneTwo_one[0]]) % 13))
if temp < oneTwo_least:
oneTwo_least = temp
oneTwo_really = oneTwo_one
return oneTwo_really #最后取出差值最小的两个元素
#This procedure figures out which card should be hidden based on the distance
#between the two cards that have the same suit.
#It returns the hidden card, the first exposed card, and the distance
def outputFirstCard(numbers, oneTwo, cards): #牌的数字，相同花色牌的列表[(0, 1), (2, 3)], 5张牌名
oneTwo = least_elem(numbers, oneTwo) #挑出最小的两个元素
encode = (numbers[oneTwo[0]] - numbers[oneTwo[1]]) % 13
if encode > 0 and encode <= 6:
hidden = oneTwo[0]
other = oneTwo[1]
else:
hidden = oneTwo[1]
other = oneTwo[0]
encode = (numbers[oneTwo[1]] - numbers[oneTwo[0]]) % 13
## #The following print statement is just for debugging!
## print ('Hidden card is:', cards[hidden], 'and need to encode', encode)
print ('First card is:', cards[other])
return hidden, other, encode
def ComputerAssistant():
print ('Cards are character strings as shown below.')
print ('Ordering is:', deck)
cards, cind, cardsuits, cnumbers = [], [], [], []
numsuits = [0, 0, 0, 0]
number = 0
while number < 99999:
number = int(input('Please give random number of at least 6 digits:'))
#Generate five "random" numbers from the input number
clist = []
i = 0
while len(clist) < 5:
number = number * (i + 1) // (i + 2)
n = number % 52
i += 1
if not n in clist:
clist.append(n)
#print (clist)
pairsuit = [] #创建一个列表
for i in range(5):
n = clist[i]
cards.append(deck[n]) #五张牌名，为了便于理解代码，下面随便举了个实例
cind.append(n)
cardsuits.append(n % 4) #五张牌的花色 [1, 1, 2, 2, 0]
cnumbers.append(n // 4) #五张牌的数字 [1, 3, 5, 2, 9] 两个数组 1_1代表2_D, 3_1代表4_D以此类推
numsuits[n % 4] += 1 #[1, 2, 2, 0] 算出红花各两张
if numsuits[n % 4] > 1:
pairsuit.append(n % 4) #将大于1的花色存储在列表中，防止被替换。 此时pairsuit值为[1, 2]
pairsuit = list(set(pairsuit)) #去重，防止2个以上的花色被多次记录在pairsuit中
## #Just for debugging
## print (cards)
cardh = []
cardh_tuple = [] #记录每个子列表
#print(pairsuit)
for pairsuit_one in pairsuit:
for i in range(5):
if cardsuits[i] == pairsuit_one:
cardh_tuple.append(i) #[0, 1] [2, 3]
cardh.append(tuple(cardh_tuple)) #[(0, 1), (2, 3)]
cardh_tuple = []
#print(cardh)
hidden, other, encode = outputFirstCard(cnumbers, cardh, cards)
remindices = []
for i in range(5):
if i != hidden and i != other:
remindices.append(cind[i])
sortList(remindices)
outputNext3Cards(encode, remindices)
# print(cards[hidden])
guess = input('What is the hidden card?')
if guess == cards[hidden]:
print ('You are a Mind Reader Extraordinaire!')
else:
print ('Sorry, not impressed!')
return
ComputerAssistant() #最后执行测试
'''
输入777777，会出现两对花色相同的情况，验证无误。
输入999999，会出现有三张同花色的情况，取三者之间差值最小的两个元素作为隐藏牌和第一张牌。
'''
习题 3 一些魔术师更喜欢按不同的方式对牌排序，将花色置为首要排序因子，而不是按数值排序，如下：
deck = [‘A_C’, ‘2_C’, ‘3_C’, ‘4_C’, ‘5_C’, ‘6_C’, ‘7_C’, ‘8_C’, ‘9_C’, ‘10_C’, ‘J_C’, ‘Q_C’, ‘K_C’, ‘A_D’, ‘2_D’, ‘3_D’, ‘4_D’, ‘5_D’, ‘6_D’, ‘7_D’, ‘8_D’, ‘9_D’, ‘10_D’, ‘J_D’, ‘Q_D’, ‘K_D’, ‘A_H’, ‘2_H’, ‘3_H’, ‘4_H’, ‘5_H’, ‘6_H’, ‘7_H’, ‘8_H’, ‘9_H’, ‘10_H’, ‘J_H’, ‘Q_H’, ‘K_H’, ‘A_S’, ‘2_S’, ‘3_S’, ‘4_S’, ‘5_S’, ‘6_S’, ‘7_S’, ‘8_S’, ‘9_S’, ‘10_S’, ‘J_S’, ‘Q_S’, ‘K_S’]
修改ComputerAssitant允许魔术师按如上的顺序排练。注意，按索引提取牌的牌号与花色的计算逻辑需要修改。同样，助手读牌的顺序也需要修改。需要正确处理一些细节，才能正确解出这道谜题的变体。
deck2 = ['A_C', '2_C', '3_C', '4_C', '5_C', '6_C', '7_C', '8_C', '9_C', '10_C', 'J_C', 'Q_C', 'K_C',
'A_D', '2_D', '3_D', '4_D', '5_D', '6_D', '7_D', '8_D', '9_D', '10_D', 'J_D', 'Q_D', 'K_D',
'A_H', '2_H', '3_H', '4_H', '5_H', '6_H', '7_H', '8_H', '9_H', '10_H', 'J_H', 'Q_H', 'K_H',
'A_S', '2_S', '3_S', '4_S', '5_S', '6_S', '7_S', '8_S', '9_S', '10_S', 'J_S', 'Q_S', 'K_S']
'''
将习题2修改后的文件经过如下修改：
'''
#ComputerAssistant()函数改动部分
......
for i in range(5):
n = clist[i]
cards.append(deck2[n])
cind.append(n)
cardsuits.append(n // 13)
cnumbers.append(n % 13)
numsuits[n // 13] += 1
if numsuits[n // 13] > 1:
pairsuit.append(n // 13)
pairsuit = list(set(pairsuit))
......
''' 再将代码中deck替换为deck2即可'''
难题 4 编写ComputerAssistant4Cards，允许排练这套4张牌的戏法。你可以选择上文描述的编码策略，利用这样的手段提供信息：(1)每张牌放置于桌面上的隐藏牌的左侧还是右侧；(2)所有3张牌是全部正面朝上还是正面朝下。你也可以设计自己的编码策略，确保对任意抽取的4张牌都能操作这套戏法。
#coding=utf-8
'''
一共有4张牌，除了隐藏牌以外，其他牌如果是正面朝上则代表1-8，背面朝上代表9-16。
我们把和隐藏牌最近的那张牌放在其右边，并将其视为一个整体c，这样和其他两张牌ab一共有6种组合，即
abc acb cab cba bca bac ，然后我们把和隐藏牌最近的那张牌放在其左边，并视为整体d，剩余两张牌只在其左边，
一共有2种组合，即 abd bad，这样8种表示方式就齐了，正反各8种，一共16种，足够表达了。
'''
deck = ['A_C', 'A_D', 'A_H', 'A_S', '2_C', '2_D', '2_H', '2_S', '3_C', '3_D', '3_H', '3_S',
'4_C', '4_D', '4_H', '4_S', '5_C', '5_D', '5_H', '5_S', '6_C', '6_D', '6_H', '6_S',
'7_C', '7_D', '7_H', '7_S', '8_C', '8_D', '8_H', '8_S', '9_C', '9_D', '9_H', '9_S',
'10_C', '10_D', '10_H', '10_S', 'J_C', 'J_D', 'J_H', 'J_S',
'Q_C', 'Q_D', 'Q_H', 'Q_S', 'K_C', 'K_D', 'K_H', 'K_S']
def shuru_shengcheng_4kapai():
number = 0
print('现在有扑克牌52张，分别为：', deck)
while number < 99999:
number = int(input('Please give random number of at least 6 digits:'))
clist = []
i = 0
while len(clist) < 4:
number = number * (i + 1) // (i + 2)
n = number % 52
i += 1
if not n in clist:
clist.append(n) #随机选择的卡牌索引 比如[13, 26, 6, 4]
#clist = [0, 13, 26, 39] #测试反面
return clist
def fenlei_shuchu(clist):
#选择差值最小的两位
cmp = [(i,j) for i in clist for j in clist if i != j]
min_cmp = 52
for i in cmp:
min_temp = (i[0] - i[1]) % 52
if min_temp < min_cmp:
min_cmp = min_temp
hide = i[0] #取出隐藏牌索引
bind = i[1] #取出绑定的牌索引
other = clist[:]
other.remove(hide)
other.remove(bind)
big = max(other) #取出大的牌索引
small = min(other) #取出小的牌索引
return hide, bind, big, small
def shengcheng_pailie(hide, bind, big, small):
print(hide, bind, big, small)
if (hide - bind) % 52 <= 8:
cha = (hide - bind) % 52
front = True
else:
cha = (hide - bind) % 52 - 8
front = False
if cha == 1:
return (big, small, bind, front, 2) #front代表正面还是反面，后面的数字表示hide的位置
elif cha == 2:
return (big, bind, small, front, 1)
elif cha == 3:
return (bind, big, small, front, 0)
elif cha == 4:
return (small, big, bind, front, 2)
elif cha == 5:
return (small, bind, big, front, 1)
elif cha == 6:
return (bind, small, big, front, 0)
elif cha == 7:
return (big, small, bind, front, 3)
elif cha == 8:
return (small, big, bind, front, 3)
def ComputerAssistant4Cards():
clist = shuru_shengcheng_4kapai()
hide, bind, big, small = fenlei_shuchu(clist)
res = shengcheng_pailie(hide, bind, big, small)
if res[-2]: #正面
print('助手把牌全都正面排列，且顺序如下：')
else:
print('助手把牌全都反面排列，且顺序如下：')
res2 = [deck[res[0]], deck[res[1]], deck[res[2]]]
res2.insert(res[-1], '???')
print(res2[0], res2[1], res2[2], res2[3])
magicin = input('请输入未知的卡牌：')
if magicin == deck[hide]:
print('恭喜你！猜的真准！')
else:
print('哎呀，演砸了！正确的卡牌应该是：', deck[hide])
ComputerAssistant4Cards()
谜题 4 让皇后保持分离
4.5 习题(page46)
难题 2 修改EightQueens的代码，在列表中某些位置上已放置过皇后的基础上，寻找解法。你可以使用一维列表localtion作为列表，该参数对应皇后的固定位置的某些列并且非负。例如，localtion = [-1, 4, -1, -1, -1, -1, -1, 0]，表示在第2列和第8列放置了两个皇后。你的代码应该生成[2, 4, 1, 7, 5, 3, 6, 0]，作为与现有皇后位置相符的解。
'''
在8queens-iterative-exercise1.py文件上修改，考虑到每个都循环8次，已经给的那列就不需要循环了，这可以理解成只循环1次，按照这个思路修改代码如下：
'''
def noConflicts(board, current):
for i in range(current):
if (board[i] == board[current]):
return False
#We have two diagonals hence need the abs()
if (current - i == abs(board[current] - board[i])):
return False
return True
#This procedure places 8 Queens on a board so they don't conflict.
#It assumes n = 8 and won't work with other n!
#Additional argument: number of solutions
#Non-default argument needs to be first!
def EightQueens(numsol, location, n=8):
board = location
sol = 0
xunhuan = []
for b in board: #将需要循环的次数放置到xunhuan列表中
if b == -1:
xunhuan.append(8)
else:
xunhuan.append(1)
for i in range(xunhuan[0]):
if xunhuan[0] != 1: #如果循环1，说明已经给了board的值，那么就不需要重新赋值了；如果循环不为1，说明未给确定值，则需要遍历。
board[0] = i
for j in range(xunhuan[1]):
if xunhuan[1] != 1:
board[1] = j
if not noConflicts(board, 1):
continue
for k in range(xunhuan[2]):
if xunhuan[2] != 1:
board[2] = k
if not noConflicts(board, 2):
continue
for l in range(xunhuan[3]):
if xunhuan[3] != 1:
board[3] = l
if not noConflicts(board, 3):
continue
for m in range(xunhuan[4]):
if xunhuan[4] != 1:
board[4] = m
if not noConflicts(board, 4):
continue
for o in range(xunhuan[5]):
if xunhuan[5] != 1:
board[5] = o
if not noConflicts(board, 5):
continue
for p in range(xunhuan[6]):
if xunhuan[6] != 1:
board[6] = p
if not noConflicts(board, 6):
continue
for q in range(xunhuan[7]):
if xunhuan[7] != 1:
board[7] = q
if noConflicts(board, 7):
if sol < numsol:
print (board)
sol += 1
else:
return
return
EightQueens(1, [-1, 4, -1, -1, -1, -1, -1, 0])
习题 3 使用continue语句减少FourQueens代码中的缩进级别，使两种解法都打印出来。这比你想象的更棘手一点。
'''题目没读懂......'''
谜题 6 寻找假币
6.5 习题(page61)
难题 2 编写CoinComparisonGeneral，它可以不假设假币更重便能确定哪一枚是假币，就像当前代码所做的那样。这将涉及findFakeGroupAndType，中为resultland2填写另外两种情况，然后为第一段分片（split）调用findFakeGroupAndType，为剩余的分片调用findFakeGroupHeavier或者findFakeGroupLighter。给出的过程findFakeGroup假设假币更重，你需要写一个伙伴过程，让他假设假币更轻并返回合适的硬币组。你的代码也应当处理没有假币的情况。
'''
在weighings.py文件上做了修改。
'''
import sys
def splitCoins(coinsList):
length = len(coinsList)
group1 = coinsList[0:length//3]
group2 = coinsList[length//3:length//3*2]
group3 = coinsList[length//3*2:length]
return group1, group2, group3
def compare(groupA, groupB):
if sum(groupA) > sum(groupB):
result = 'left'
elif sum(groupB) > sum(groupA):
result = 'right'
elif sum(groupB) == sum(groupA):
result = 'equal'
return result
def findFakeGroupAndType(group1, group2, group3):
result1and2 = compare(group1, group2)
if result1and2 == 'left':
result1and3 = compare(group1, group3)
if result1and3 == 'left':
fakeGroup = group1
type = 'heavier'
elif result1and3 == 'equal':
fakeGroup = group2
type = 'lighter'
elif result1and2 == 'right':
result1and3 = compare(group1, group3)
if result1and3 == 'right':
fakeGroup = group1
type = 'lighter'
elif result1and3 == 'equal':
fakeGroup = group2
type = 'heavier'
elif result1and2 == 'equal':
result1and3 = compare(group1, group3)
if result1and3 == 'left':
fakeGroup = group3
type = 'lighter'
elif result1and3 == 'right':
fakeGroup = group3
type = 'heavier'
else:
print('There is no fake coin!')
sys.exit()
return fakeGroup, type
def findFakeGroupHeavier(group1, group2, group3):
result1and2 = compare(group1, group2)
if result1and2 == 'left':
fakeGroup = group1
elif result1and2 == 'right':
fakeGroup = group2
elif result1and2 == 'equal':
fakeGroup = group3
return fakeGroup
def findFakeGroupLighter(group1, group2, group3):
result1and2 = compare(group1, group2)
if result1and2 == 'left':
fakeGroup = group2
elif result1and2 == 'right':
fakeGroup = group1
elif result1and2 == 'equal':
fakeGroup = group3
return fakeGroup
def CoinComparisonGeneral(coinsList):
currList = coinsList[:]
group1, group2, group3 = splitCoins(currList)
currList, type = findFakeGroupAndType(group1, group2, group3)
counter = 2
while len(currList) > 1:
group1, group2, group3 = splitCoins(currList)
if type == 'heavier':
currList = findFakeGroupHeavier(group1, group2, group3)
elif type == 'lighter':
currList = findFakeGroupLighter(group1, group2, group3)
counter += 1
fake = currList[0]
print ('The fake coin is coin', coinsList.index(fake) + 1, '.It\'s', type , 'than others.')
print ('Number of weighings:', counter)
#Pretend that you actually can't see the values in coinsList!
coinsList2 = [10, 10, 10, 10, 10, 10, 11, 10, 10]
coinsList = [10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 9, 10]
CoinComparisonGeneral(coinsList2)
CoinComparisonGeneral(coinsList)
习题 3 假设有两枚假币，他们看起来和其他硬币完全相同但比其他硬币更重。修改CoinComparison，找到其中一枚假币（两个假币中的一个）。注意，如果你有两组硬币，每组都有一枚硬币，天平将会显示这两组硬币重量相等。如果你选择了第三组硬币（不在比较范围中），你将会错过找到这枚假币。在修改过的代码中，不要为正确计算称量次数而费心。
'''
在weighings.py原文件上修改如下。
'''
import sys
def splitCoins(coinsList):
length = len(coinsList)
group1 = coinsList[0:length//3]
group2 = coinsList[length//3:length//3*2]
group3 = coinsList[length//3*2:length]
return group1, group2, group3
def compare(groupA, groupB):
if sum(groupA) > sum(groupB):
result = 'left'
elif sum(groupB) > sum(groupA):
result = 'right'
elif sum(groupB) == sum(groupA):
result = 'equal'
return result
def findFakeGroup(group1, group2, group3):
result1and2 = compare(group1, group2)
if result1and2 == 'left':
fakeGroup = group1
elif result1and2 == 'right':
fakeGroup = group2
elif result1and2 == 'equal': #Could just be an else
result1and3 = compare(group1, group3)
if result1and3 == 'right':
fakeGroup = group3
elif result1and3 == 'left':
fakeGroup = group1
elif result1and3 == 'equal':
print('There is no fake coin!')
sys.exit()
return fakeGroup
def CoinComparison(coinsList):
currList = coinsList[:]
while len(currList) > 1:
group1, group2, group3 = splitCoins(currList)
currList = findFakeGroup(group1, group2, group3)
fake = currList[0]
print ('The fake coin is coin', coinsList.index(fake) + 1, 'in the original list')
#Pretend that you actually can't see the values in coinsList!
coinsList2 = [10, 11, 10, 10, 10, 10, 11, 10, 10]
coinsList = [10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 11, 11, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10]
CoinComparison(coinsList2)
CoinComparison(coinsList)
谜题 7 跳到平方根
7.5 习题(page69)
习题 2 修改过程bsearch，多加一个参数：查找区间小于多少时，执行迭代顺序查找。当前的过程会持续二分搜索直到找到元素。实际上，当区间[lo, hi]的长度hi - lo 小于某特定长度时，不分割区间直接在区间内使用顺序查找反而可能更快。
'''
在bsearch.py文件上修改
'''
NOTFOUND = -1
Ls = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, \
71, 73, 79, 83, 89, 97] #len = 25
def lsearch(L, value, pre_index=0):
for i in range(len(L)):
if L[i] == value:
print ("Found at location", i + pre_index)
return i + pre_index
print ("Could not find the value", value)
return NOTFOUND
def bsearch(L, value, lenl=10):
lo, hi = 0, len(L)
pre_index = 0
while lo <= hi:
if hi - lo < lenl:
return lsearch(L[lo:hi+1], value, pre_index)
mid = (lo + hi) // 2
mid2 = (hi - lo) // 2
if L[mid] < value:
lo = mid + 1
pre_index += mid2 + 1
elif value < L[mid]:
hi = mid - 1
else:
print ("Found at location", mid)
return mid
lsearch(Ls, 89)
bsearch(Ls, 47, 3)
bsearch(Ls, 37, 7)