1.7 Recursive Functions

Author: Mr_he

Chapter 1-Building Abstractions with Functions/1.7 Recursive Functions/recursive.py

@@ -0,0 +1,62 @@
+def cascade(n):
+	print(n)
+	if n >= 10:
+		cascade(n//10)
+		print(n)
+
+#cascade(233431)
+
+def is_event(n):
+	return n % 2 == 0
+
+def play_alice(n):
+	if n == 0:
+		print("Bob win!")
+	else:
+		play_bob(n-1)
+
+def play_bob(n):
+	if n == 0:
+		print("Alice win!")
+	else:
+		if is_event(n):
+			play_alice(n-2)
+		else:
+			play_alice(n-1)
+
+def inverse_cascade(n):
+	grow(n)
+	print(n)
+	shrink(n)
+
+def f_then_g(f, g, n):
+	if n:
+		f(n)
+		g(n)
+
+grow = lambda n: f_then_g(grow, print, n // 10)
+shrink = lambda n: f_then_g(print, shrink, n // 10)
+
+def count_partitions(n, m):
+	if n == 0:
+	    return 1
+	elif n < 0:
+	    return 0
+	elif m == 0:
+	    return 0
+	else:
+		return count_partitions(n-m, m) + count_partitions(n, m-1)
+
+print(count_partitions(20,20))
+
+
+
+
+
+
+
+
+
+
+
+

Chapter 1-Building Abstractions with Functions/1.7 Recursive Functions/sumOfDigits.py

@@ -0,0 +1,25 @@
+def split(n):
+	return n // 10, n % 10
+
+def sum_digits(n):
+	if n < 10:
+		return n
+	else:
+		all_but_last, last = split(n)
+		return last + sum_digits(all_but_last)
+
+def luhn_sum(n):
+	if n < 10:
+		return n
+	else:
+		all_but_last, last = split(n)
+		return luhn_sum_double(n) + last
+
+def luhn_sum_double(n):
+	all_but_last, last = split(n)
+	luhn_digit = sum_digits(2 * last)
+	if n < 10:
+		return luhn_digit
+	else:
+		return luhn_sum(all_but_last) + luhn_digit
+

cs61a/lab/lab02/.ok_history

@@ -0,0 +1,32 @@
+{
+    "name": "Lab 2",
+    "endpoint": "cal/cs61a/sp16/lab02",
+    "src": [
+        "lab02.py",
+        "lab02_extra.py"
+    ],
+    "tests": {
+        "tests/lambda.py": "ok_test",
+        "tests/hof.py": "ok_test",
+        "lab02.py:lambda_curry2": "doctest",
+        "lab02.py:adder": "doctest",
+        "tests/factorial_ok.py": "ok_test",
+        "tests/skip_mul_ok.py": "ok_test",
+        "lab02.py:skip_mul": "doctest",
+        "tests/count_up_ok.py": "ok_test",
+        "lab02.py:count_up": "doctest",
+        "lab02.py:gcd": "doctest",
+        "lab02_extra.py:hailstone": "doctest",
+        "lab02_extra.py:count_cond": "doctest",
+        "lab02_extra.py:cycle": "doctest",
+        "lab02_extra.py:paths": "doctest"
+    },
+    "protocols": [
+        "restore",
+        "file_contents",
+        "analytics",
+        "unlock",
+        "grading",
+        "backup"
+    ]
+}

cs61a/lab/lab02/.ok_messages

@@ -0,0 +1,86 @@
+"""Lab 2: Higher Order Functions & Lambdas & Recursions"""
+
+def lambda_curry2(func):
+    """
+    Returns a Curried version of a two argument function func.
+    >>> from operator import add
+    >>> x = lambda_curry2(add)
+    >>> y = x(3)
+    >>> y(5)
+    8
+    """
+    "*** YOUR CODE HERE ***"
+    return lambda x: lambda y: func(x, y)
+
+def adder(f1, f2):
+    """
+    Return a function that takes in a single variable x, and returns
+    f1(x) + f2(x). You can assume the result of f1(x) and f2(x) can be
+    added together, and they both take in one argument.
+
+    >>> identity = lambda x: x       # returns inpuSettingst
+    >>> square = lambda x: x**2
+    >>> a1 = adder(identity, square) # x + x^2
+    >>> a1(4)
+    20
+    >>> a2 = adder(a1, identity)     # (x + x^2) + x
+    >>> a2(4)
+    24
+    >>> a2(5)
+    35
+    >>> a3 = adder(a1, a2)           # (x + x^2) + (x + x^2 + x)
+    >>> a3(4)
+    44
+    """
+    return lambda x: f1(x) + f2(x)
+
+def skip_mul(n):
+    """Return the product of n * (n - 2) * (n - 4) * ...
+
+    >>> skip_mul(5) # 5 * 3 * 1
+    15
+    >>> skip_mul(8) # 8 * 6 * 4 * 2  * 0
+    0
+    """
+    if n == 0:
+        return 0
+    elif n == 1:
+        return 1
+    else:
+        return n * skip_mul(n - 2)
+
+def count_up(n):
+    """Print out all numbers up to and including n in ascending order.
+
+    >>> count_up(5)
+    1
+    2
+    3
+    4
+    5
+    """
+    def counter(i):
+        if i <= n:
+            print(i)
+            counter(i+1)
+    counter(1)
+
+def gcd(a, b):
+    """Returns the greatest common divisor of a and b.
+    Should be implemented using recursion.
+
+    >>> gcd(34, 19)
+    1
+    >>> gcd(39, 91)
+    13
+    >>> gcd(20, 30)
+    10
+    >>> gcd(40, 40)
+    40
+    """
+    if a < b:
+        a, b = b, a # a is lager number and b is smaller number
+    if a % b == 0:
+        return b
+    else:
+        return gcd(b, a % b)

cs61a/lab/lab02/lab02.ok

@@ -0,0 +1,121 @@
+"""Optional program for lab02 """
+
+from lab02 import *
+
+# Extra Question
+
+def hailstone(n):
+	"""Print out the hailstone sequence starting at n, and return the
+	number of elements in the sequence.
+
+	>>> a = hailstone(10)
+	10
+	5
+	16
+	8
+	4
+	2
+	1
+	>>> a
+	7
+	"""
+	print(n)
+	if n == 1:
+		return 1
+	if n % 2 == 0:
+		return hailstone(n//2) + 1
+	else:
+		return hailstone(n*3+1) + 1
+
+def count_cond(condition):
+	"""
+	>>> count_factors = count_cond(lambda n, i: n % i == 0)
+	>>> count_factors(2) # 1, 2
+	2
+	>>> count_factors(4) # 1, 2, 4
+	3
+	>>> count_factors(12) # 1, 2, 3, 4, 6, 12
+	6
+
+	>>> is_prime = lambda n, i: count_factors(i) == 2
+	>>> count_primes = count_cond(is_prime)
+	>>> count_primes(2) # 2
+	1
+	>>> count_primes(3) # 2, 3
+	2
+	>>> count_primes(4) # 2, 3
+	2
+	>>> count_primes(5) # 2, 3, 5
+	3
+	>>> count_primes(20) # 2, 3, 5, 7, 11, 13, 17, 19
+	8
+	"""
+	def count(n):
+		i, count = 1, 0
+		while i <= n:
+			if condition(n, i):
+				count += 1
+			i += 1
+		return count
+	return count
+
+def cycle(f1, f2, f3):
+	""" Returns a function that is itself a higher order function
+	>>> def add1(x):
+	...     return x + 1
+	>>> def times2(x):
+	...     return x * 2
+	>>> def add3(x):
+	...     return x + 3
+	>>> my_cycle = cycle(add1, times2, add3)
+	>>> identity = my_cycle(0)
+	>>> identity(5)
+	5
+	>>> add_one_then_double = my_cycle(2)
+	>>> add_one_then_double(1)
+	4
+	>>> do_all_functions = my_cycle(3)
+	>>> do_all_functions(2)
+	9
+	>>> do_more_than_a_cycle = my_cycle(4)
+	>>> do_more_than_a_cycle(2)
+	10
+	>>> do_two_cycles = my_cycle(6)
+	>>> do_two_cycles(1)
+	19
+	"""
+	def g(n):
+		def h(x):
+			if n == 0:
+				return x
+			elif n == 1:
+				return f1(x)
+			elif n == 2:
+				return f2(f1(x))
+			elif n == 3:
+				return f3(f2(f1(x)))
+			else:
+				c = (n-1) % 3 + 1
+				out_most_function = g(c)
+				rest_result = g(n-c)(x)
+				return out_most_function(rest_result)
+		return h
+	return g
+
+def paths(m, n):
+	"""Return the number of paths from one corner of an
+	M by N grid to the opposite corner.
+
+	>>> paths(2, 2)
+	2
+	>>> paths(5, 7)
+	210
+	>>> paths(117, 1)
+	1
+	>>> paths(1, 157)
+	1
+	"""
+	if m == 1 or n == 1:
+		return 1
+	else:
+		return paths(m-1, n) + paths(m, n-1)

cs61a/lab/lab02/lab02.py

@@ -0,0 +1,12 @@
+"""
+This is a minimal contest submission file. You may also submit the full
+hog.py from Project 1 as your contest entry.
+
+Only this file will be submitted. Make sure to include any helper functions
+from `hog.py` that you'll need here! For example, if you have a function to
+calculate Free Bacon points, you should make sure it's added to this file
+as well.
+"""
+
+def final_strategy(score, opponent_score):
+    return 5

cs61a/lab/lab02/lab02_extra.py

@@ -0,0 +1,17 @@
+{
+  "name": "Project 1 Contest: Hog Strategy",
+  "endpoint": "cal/cs61a/sp16/proj1contest",
+  "src": [
+    "hog.py"
+  ],
+  "tests": {
+      "tests/import.py": "ok_test",
+      "tests/final.py": "ok_test"
+  },
+  "protocols": [
+      "file_contents",
+      "analytics",
+      "grading",
+      "backup"
+  ]
+}

cs61a/lab/lab02/ok

@@ -0,0 +1,25 @@
+test = {
+  'name': 'Time Check',
+  'points': 0,
+  'suites': [
+    {
+      'cases': [
+        {
+          'code': r"""
+          >>> for i in range(100):
+          ...     for j in range(100):
+          ...         assert -1 <= final_strategy(i, j) <= 10
+          """,
+          'hidden': False,
+          'locked': False
+        }
+      ],
+      'scored': True,
+      'setup': r"""
+      >>> from hog import final_strategy
+      """,
+      'teardown': '',
+      'type': 'doctest'
+    }
+  ]
+}