test

HW1/hw01_LohZhengLucas.py

@@ -0,0 +1,151 @@
+""" Homework 1: Control """
+
+# Q1
+from operator import add, index, 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 = sub       
+    else:
+        f = add
+    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 max(a*a+b*b, b*b+c*c, a*a+c*c)
+
+
+# Q3
+# range()
+# Q3
+# range()
+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
+    """
+    confirmed_divider = []
+    #check all numbers from 1-80 except 80
+    for possible_divider in range(1,n):
+        remainder = n%possible_divider
+        if remainder == 0:
+            confirmed_divider.append(possible_divider)
+    return confirmed_divider[-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():
+    return True
+
+def t():
+    print(1)
+
+def f():
+    print(2)
+
+
+# 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
+    """
+    "*** YOUR CODE HERE ***"
+    #
+    a = 1
+
+    while n != 1:
+        remainder = n%2
+        if remainder == 0:
+            n /= 2
+        else:
+            n = n * 3 + 1
+        #int(n) to remove dp since n always integer
+        print(int(n))
+        a += 1
+
+    return a
+
+
+# Q6
+quine = """
+"*** YOUR CODE HERE ***"
+"""

HW3/hw03_LohZhengLucas.py

@@ -0,0 +1,141 @@
+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
+    """
+    for char in str(k):
+        if char == '7':
+            return True
+    return False
+
+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 pingpong(n):
+    if n <= 7:
+        return n
+    else:
+        return pingpong(n-1) + direction(n-1)
+
+def direction(n):
+    if n < 7:
+        return 1        
+    else:
+        if n%7 == 0 or has_seven(n):
+            return -direction(n-1)
+        else:
+            return direction(n-1)
+
+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
+