網址 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))