added Jun Yu's homework

HW1/HW01_ChuaJunYu.py

@@ -0,0 +1,148 @@
+""" Homework 1: Control """
+
+# Q1
+from operator import add, sub
+
+def a_plus_abs_b(a, b):
+    """Return a+abs(b), but without calling abs.
+
+    >>> a_plus_abs_b(2, 3)
+    5
+    >>> a_plus_abs_b(2, -3)
+    5
+    """
+    if b < 0:
+        f = lambda a, b: a - b
+    else:
+        f = lambda a, b: a + b
+    return f(a, b)
+
+
+# Q2
+def two_of_three(a, b, c):
+    """Return x*x + y*y, where x and y are the two largest members of the
+    positive numbers a, b, and c.
+
+    >>> two_of_three(1, 2, 3)
+    13
+    >>> two_of_three(5, 3, 1)
+    34
+    >>> two_of_three(10, 2, 8)
+    164
+    >>> two_of_three(5, 5, 5)
+    50
+    """
+
+    return (sorted([a, b, c])[1] ** 2 + sorted([a, b, c])[2] ** 2)
+
+
+# Q3
+def largest_factor(n):
+    """Return the largest factor of n that is smaller than n.
+
+    >>> largest_factor(15) # factors are 1, 3, 5
+    5
+    >>> largest_factor(80) # factors are 1, 2, 4, 5, 8, 10, 16, 20, 40
+    40
+    >>> largest_factor(13) # factor is 1 since 13 is prime
+    1
+    """
+    factors = []
+    for i in range(1, n):
+        if (n % i) == 0:
+            factors.append(i)
+
+    return factors[-1]        
+
+
+# Q4
+def if_function(condition, true_result, false_result):
+    """Return true_result if condition is a true value, and
+    false_result otherwise.
+
+    >>> if_function(True, 2, 3)
+    2
+    >>> if_function(False, 2, 3)
+    3
+    >>> if_function(3==2, 3+2, 3-2)
+    1
+    >>> if_function(3>2, 3+2, 3-2)
+    5
+    """
+    if condition:
+        return true_result
+    else:
+        return false_result
+
+
+def with_if_statement():
+    """
+    >>> result = with_if_statement()
+    2
+    >>> print(result)
+    None
+    """
+    if c():
+        return t()
+    else:
+        return f()
+
+
+def with_if_function():
+    """
+    >>> result = with_if_function()
+    1
+    2
+    >>> print(result)
+    None
+    """
+    return if_function(c(), t(), f())
+
+
+def c():
+    global x 
+    x = "2"
+    return False
+
+
+def t():
+    global x 
+    x = """1
+2"""
+
+
+def f():
+    global x
+    print(x)
+
+
+# Q5
+def hailstone(n):
+    """Print the hailstone sequence starting at n and return its
+    length.
+
+    >>> a = hailstone(10)
+    10
+    5
+    16
+    8
+    4
+    2
+    1
+    >>> a
+    7
+    """
+
+    print(n)
+    if n == 1:
+        return 1
+    elif (n % 2) == 0:
+        return hailstone(int(n/2)) + 1
+    else:
+        return hailstone(int(3 * n + 1)) + 1
+
+
+# Q6
+quine = """
+"*** YOUR CODE HERE ***"
+"""

HW3/HW03_ChuaJunYu.py

@@ -0,0 +1,145 @@
+HW_SOURCE_FILE = 'hw03.py'
+
+#############
+# Questions #
+#############
+
+from operator import add, mul, sub
+
+square = lambda x: x * x
+
+identity = lambda x: x
+
+triple = lambda x: 3 * x
+
+increment = lambda x: x + 1
+
+def has_seven(k):
+    """Returns True if at least one of the digits of k is a 7, False otherwise.
+
+    >>> has_seven(3)
+    False
+    >>> has_seven(7)
+    True
+    >>> has_seven(2734)
+    True
+    >>> has_seven(2634)
+    False
+    >>> has_seven(734)
+    True
+    >>> has_seven(7777)
+    True
+    >>> from construct_check import check
+    >>> check(HW_SOURCE_FILE, 'has_seven',
+    ...       ['Assign', 'AugAssign'])
+    True
+    """
+    if k % 10 == 7:
+        return True
+    elif k == 0:
+        return False
+    else:
+        return has_seven(k // 10)
+
+
+def pingpong(n):
+    """Return the nth element of the ping-pong sequence.
+
+    >>> pingpong(7)
+    7
+    >>> pingpong(8)
+    6
+    >>> pingpong(15)
+    1
+    >>> pingpong(21)
+    -1
+    >>> pingpong(22)
+    0
+    >>> pingpong(30)
+    6
+    >>> pingpong(68)
+    2
+    >>> pingpong(69)
+    1
+    >>> pingpong(70)
+    0
+    >>> pingpong(71)
+    1
+    >>> pingpong(72)
+    0
+    >>> pingpong(100)
+    2
+    >>> from construct_check import check
+    >>> check(HW_SOURCE_FILE, 'pingpong', ['Assign', 'AugAssign'])
+    True
+    """
+
+    def direction(n):
+        if n < 7:
+            return 1
+        # if previous n is multiple of 7 or has seven, change direction
+        elif has_seven(n - 1) or ((n-1) % 7) == 0:
+            return direction(n-1) * -1
+        # Else return same direction as previous n
+        else:
+            return direction(n-1)
+
+    if n < 7:
+        return n
+    else:
+        return pingpong(n-1) + direction(n)
+
+
+def accumulate(combiner, base, n, term):
+    """Return the result of combining the first n terms in a sequence and base.
+    The terms to be combined are term(1), term(2), ..., term(n).  combiner is a
+    two-argument, associative 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
+    """
+    total, k = base, 1
+    while k <= n:
+        total, k = combiner(total, term(k)), k + 1
+    return total
+
+def filtered_accumulate(combiner, base, pred, n, term):
+    """Return the result of combining the terms in a sequence of N terms
+    that satisfy the predicate pred. combiner is a two-argument function.
+    If v1, v2, ..., vk are the values in term(1), term(2), ..., term(N)
+    that satisfy pred, then the result is
+         base combiner v1 combiner v2 ... combiner vk
+    (treating combiner as if it were a binary operator, like +). The
+    implementation uses accumulate.
+
+    >>> filtered_accumulate(add, 0, lambda x: True, 5, identity)  # 0 + 1 + 2 + 3 + 4 + 5
+    15
+    >>> filtered_accumulate(add, 11, lambda x: False, 5, identity) # 11
+    11
+    >>> filtered_accumulate(add, 0, odd, 5, identity)   # 0 + 1 + 3 + 5
+    9
+    >>> filtered_accumulate(mul, 1, greater_than_5, 5, square)  # 1 * 9 * 16 * 25
+    3600
+    >>> # Do not use while/for loops or recursion
+    >>> from construct_check import check
+    >>> check(HW_SOURCE_FILE, 'filtered_accumulate',
+    ...       ['While', 'For', 'Recursion'])
+    True
+    """
+    def combine_if(x, y):
+        "*** YOUR CODE HERE ***"
+    return accumulate(combine_if, base, n, term)
+
+def odd(x):
+    return x % 2 == 1
+
+def greater_than_5(x):
+    return x > 5