cs61a 2021 fall hw03
网址 https://inst.eecs.berkeley.edu/~cs61a/fa21/hw/hw03/
problem1：用递归，一边判断当前的数字，一边加上除了当前的数字判断函数
peoblem2：这个函数的意思是从1到n，每一次加一，如果碰到数字中有8的数字或者可以整除数字8的则讲加一改为每次减一，此次类推，下次则把减一改为加一。
problem3：这个函数是输入一个数字n这个数字是非递减排序的，然后输出这个n第一个数字和最后一个数字之间所缺失的数字个数（可以重复）
problem4:这个类似动态规划，两种情况，一种是当前这种硬币取，一种是当前的硬币不取，取下一种硬币，把两种情况加起来。
problem5：哈诺塔经典问题了，递归的关键在于当作前面的问题已经全部解决，只要解决当前的问题就好了，这里就是当作除了最后一个disk其他全部解决了，
之间将最后一个disk移过去，然后再一次新的递归。
problem6：因为需要用到递归，所以需要将自己作为参数传过去，所以这个lambda需要两个参数，第一个参数是自己，第二个参数是数字，
每一次数字都减一直到数字为一为止，如果不为一，则传入自己和x-1.
HW_SOURCE_FILE = __file__
def num_eights(pos):
"""Returns the number of times 8 appears as a digit of pos.
>>> num_eights(3)
0
>>> num_eights(8)
1
>>> num_eights(88888888)
8
>>> num_eights(2638)
1
>>> num_eights(86380)
2
>>> num_eights(12345)
0
>>> from construct_check import check
>>> # ban all assignment statements
>>> check(HW_SOURCE_FILE, 'num_eights',
... ['Assign', 'AnnAssign', 'AugAssign', 'NamedExpr'])
True
"""
"*** YOUR CODE HERE ***"
if pos == 8:
return 1
elif pos != 8 and pos < 10:
return 0
return num_eights(pos//10) + num_eights(pos%10)
def pingpong(n):
"""Return the nth element of the ping-pong sequence.
>>> pingpong(8)
8
>>> pingpong(10)
6
>>> pingpong(15)
1
>>> pingpong(21)
-1
>>> pingpong(22)
-2
>>> pingpong(30)
-2
>>> pingpong(68)
0
>>> pingpong(69)
-1
>>> pingpong(80)
0
>>> pingpong(81)
1
>>> pingpong(82)
0
>>> pingpong(100)
-6
>>> from construct_check import check
>>> # ban assignment statements
>>> check(HW_SOURCE_FILE, 'pingpong',
... ['Assign', 'AnnAssign', 'AugAssign', 'NamedExpr'])
True
"""
"*** YOUR CODE HERE ***"
def func(flag,num,ans):
if num == n:
return ans
if num_eights(num) != 0 or num % 8 == 0:
return func(flag * -1, num + 1, ans + flag * -1)
else :
return func(flag, num + 1, ans + flag)
return func(1,1,1)
def missing_digits(n):
"""Given a number a that is in sorted, non-decreasing order,
return the number of missing digits in n. A missing digit is
a number between the first and last digit of a that is not in n.
>>> missing_digits(1248) # 3, 5, 6, 7
4
>>> missing_digits(19) # 2, 3, 4, 5, 6, 7, 8
7
>>> missing_digits(1122) # No missing numbers
0
>>> missing_digits(123456) # No missing numbers
0
>>> missing_digits(3558) # 4, 6, 7
3
>>> missing_digits(35578) # 4, 6
2
>>> missing_digits(12456) # 3
1
>>> missing_digits(16789) # 2, 3, 4, 5
4
>>> missing_digits(4) # No missing numbers between 4 and 4
0
>>> from construct_check import check
>>> # ban while or for loops
>>> check(HW_SOURCE_FILE, 'missing_digits', ['While', 'For'])
True
"""
"*** YOUR CODE HERE ***"
def func(num, ans):
if num // 10 == 0:
return ans
else :
if num % 10 != num % 100 // 10:
return func(int(num / 10),ans + ((num % 10 - 1) - (num % 100) // 10))
else:
return func(int(num / 10),ans)
return func(n,0)
def ascending_coin(coin):
"""Returns the next ascending coin in order.
>>> ascending_coin(1)
5
>>> ascending_coin(5)
10
>>> ascending_coin(10)
25
>>> ascending_coin(2) # Other values return None
"""
if coin == 1:
return 5
elif coin == 5:
return 10
elif coin == 10:
return 25
def descending_coin(coin):
"""Returns the next descending coin in order.
>>> descending_coin(25)
10
>>> descending_coin(10)
5
>>> descending_coin(5)
1
>>> descending_coin(2) # Other values return None
"""
if coin == 25:
return 10
elif coin == 10:
return 5
elif coin == 5:
return 1
def count_coins(change):
"""Return the number of ways to make change using coins of value of 1, 5, 10, 25.
>>> count_coins(15)
6
>>> count_coins(10)
4
>>> count_coins(20)
9
>>> count_coins(100) # How many ways to make change for a dollar?
242
>>> count_coins(200)
1463
>>> from construct_check import check
>>> # ban iteration
>>> check(HW_SOURCE_FILE, 'count_coins', ['While', 'For'])
True
"""
"*** YOUR CODE HERE ***"
def func(num_change, n):
if num_change == 0:
return 1
elif num_change < 0:
return 0
elif n == None:
return 0
else:
with_max = func(num_change ,ascending_coin(n))
Notwith_max = func(num_change - n,n)
return with_max + Notwith_max
return func(change, 1)
def print_move(origin, destination):
"""Print instructions to move a disk."""
print("Move the top disk from rod", origin, "to rod", destination)
def move_stack(n, start, end):
"""Print the moves required to move n disks on the start pole to the end
pole without violating the rules of Towers of Hanoi.
n -- number of disks
start -- a pole position, either 1, 2, or 3
end -- a pole position, either 1, 2, or 3
There are exactly three poles, and start and end must be different. Assume
that the start pole has at least n disks of increasing size, and the end
pole is either empty or has a top disk larger than the top n start disks.
>>> move_stack(1, 1, 3)
Move the top disk from rod 1 to rod 3
>>> move_stack(2, 1, 3)
Move the top disk from rod 1 to rod 2
Move the top disk from rod 1 to rod 3
Move the top disk from rod 2 to rod 3
>>> move_stack(3, 1, 3)
Move the top disk from rod 1 to rod 3
Move the top disk from rod 1 to rod 2
Move the top disk from rod 3 to rod 2
Move the top disk from rod 1 to rod 3
Move the top disk from rod 2 to rod 1
Move the top disk from rod 2 to rod 3
Move the top disk from rod 1 to rod 3
"""
assert 1 <= start <= 3 and 1 <= end <= 3 and start != end, "Bad start/end"
"*** YOUR CODE HERE ***"
if n == 1:
print_move(start, end)
else:
other = 6 - start - end
move_stack(n - 1, start, other)
move_stack(1, start, end)
move_stack(n-1, other, end)
from operator import sub, mul
def make_anonymous_factorial():
"""Return the value of an expression that computes factorial.
>>> make_anonymous_factorial()(5)
120
>>> from construct_check import check
>>> # ban any assignments or recursion
>>> check(HW_SOURCE_FILE, 'make_anonymous_factorial',
... ['Assign', 'AnnAssign', 'AugAssign', 'NamedExpr', 'FunctionDef', 'Recursion'])
True
"""
return (lambda f: f(f))(lambda f: lambda x: 1 if x == 0 else x * f(f)(x - 1))
