cs61a 2021 fall hw02

网址 https://inst.eecs.berkeley.edu/~cs61a/fa21/hw/hw02/
problem1没什么难度
problem2注意python3 ok -q accumulate_syntax_check是要检查前面的两个函数product_using_accumulate和
summation_using_accumulate是否只有一句return，这两个函数要用到前一个函数accumulate
problem3不是很能理解题意但是这里引用一个别人的答案 https://www.cnblogs.com/Shimarin/p/13823520.html

    from operator import add, mul
    square = lambda x: x * x
    identity = lambda x: x
    triple = lambda x: 3 * x
    increment = lambda x: x + 1

    HW_SOURCE_FILE = __file__

    def product(n, term):
        """Return the product of the first n terms in a sequence.

        n: a positive integer
        term:  a function that takes one argument to produce the term

        >>> product(3, identity)  # 1 * 2 * 3
        6
        >>> product(5, identity)  # 1 * 2 * 3 * 4 * 5
        120
        >>> product(3, square)    # 1^2 * 2^2 * 3^2
        36
        >>> product(5, square)    # 1^2 * 2^2 * 3^2 * 4^2 * 5^2
        14400
        >>> product(3, increment) # (1+1) * (2+1) * (3+1)
        24
        >>> product(3, triple)    # 1*3 * 2*3 * 3*3
        162
        """
        "*** YOUR CODE HERE ***"
        ans = 1
        for i in range(1, n + 1):
            ans = ans * term(i)
        return ans

    def square(x):
        return x * x


    def accumulate(merger, base, n, term):
        """Return the result of merging the first n terms in a sequence and base.
        The terms to be merged are term(1), term(2), ..., term(n). merger is a
        two-argument commutative function.

        >>> accumulate(add, 0, 5, identity)  # 0 + 1 + 2 + 3 + 4 + 5
        15
        >>> accumulate(add, 11, 5, identity) # 11 + 1 + 2 + 3 + 4 + 5
        26
        >>> accumulate(add, 11, 0, identity) # 11
        11
        >>> accumulate(add, 11, 3, square)   # 11 + 1^2 + 2^2 + 3^2
        25
        >>> accumulate(mul, 2, 3, square)    # 2 * 1^2 * 2^2 * 3^2
        72
        >>> # 2 + (1^2 + 1) + (2^2 + 1) + (3^2 + 1)
        >>> accumulate(lambda x, y: x + y + 1, 2, 3, square)
        19
        >>> # ((2 * 1^2 * 2) * 2^2 * 2) * 3^2 * 2
        >>> accumulate(lambda x, y: 2 * x * y, 2, 3, square)
        576
        >>> accumulate(lambda x, y: (x + y) % 17, 19, 20, square)
        16
        """
        ans = base
        for i in range(1,n+1):
            ans = merger(ans,term(i))
        return ans

    def summation_using_accumulate(n, term):
        """Returns the sum: term(1) + ... + term(n), using accumulate.

        >>> summation_using_accumulate(5, square)
        55
        >>> summation_using_accumulate(5, triple)
        45
        """
        return accumulate(add,0,n,term)


    def product_using_accumulate(n, term):
        """Returns the product: term(1) * ... * term(n), using accumulate.

        >>> product_using_accumulate(4, square)
        576
        >>> product_using_accumulate(6, triple)
        524880
        """
        return accumulate(mul,0,n,term)


    def accumulate_syntax_check():
        """Checks that definitions of summation_using_accumulate and
        produce_using_accumulate are each a single return statement.

        >>> # You aren't expected to understand the code of this test.
        >>> # Check that the bodies of the functions are just return statements.
        >>> # If this errors, make sure you have removed the "***YOUR CODE HERE***".
        >>> import inspect, ast
        >>> [type(x).__name__ for x in ast.parse(inspect.getsource(summation_using_accumulate)).body[0].body]
        ['Expr', 'Return']
        >>> [type(x).__name__ for x in ast.parse(inspect.getsource(product_using_accumulate)).body[0].body]
        ['Expr', 'Return']
        """


    def zero(f):
        return lambda x: x


    def successor(n):
        return lambda f: lambda x: f(n(f)(x))


    def one(f):
        """Church numeral 1: same as successor(zero)"""
        "*** YOUR CODE HERE ***"
        return  lambda x: f(zero(f)(x))


    def two(f):
        """Church numeral 2: same as successor(successor(zero))"""
        "*** YOUR CODE HERE ***"
        return  lambda x :f(zero(f)(f(zero(f)(x))))


    three = successor(two)


    def church_to_int(n):
        """Convert the Church numeral n to a Python integer.

        >>> church_to_int(zero)
        0
        >>> church_to_int(one)
        1
        >>> church_to_int(two)
        2
        >>> church_to_int(three)
        3
        """
        "*** YOUR CODE HERE ***"


    def add_church(m, n):
        """Return the Church numeral for m + n, for Church numerals m and n.

        >>> church_to_int(add_church(two, three))
        5
        """
        "*** YOUR CODE HERE ***"


    def mul_church(m, n):
        """Return the Church numeral for m * n, for Church numerals m and n.

        >>> four = successor(three)
        >>> church_to_int(mul_church(two, three))
        6
        >>> church_to_int(mul_church(three, four))
        12
        """
        "*** YOUR CODE HERE ***"


    def pow_church(m, n):
        """Return the Church numeral m ** n, for Church numerals m and n.

        >>> church_to_int(pow_church(two, three))
        8
        >>> church_to_int(pow_church(three, two))
        9
        """
        "*** YOUR CODE HERE ***"