recursion prep

Author: colevandersWands

3_documenting_and_testing/exercises/mystery_5.py

@@ -1,6 +1,4 @@
-def mystery_5(a, b=None):
-    if b is None:
-        b = []
+def mystery_5(a, b):
     while a:
         c = min(a)
         a.remove(c)

3_documenting_and_testing/exercises/tests/test_mystery_5.py

@@ -8,11 +8,4 @@ class TestMystery5(unittest.TestCase):
     def test_minimal_input(self):
         """"""
         self.assertEqual(mystery_5([], []), [])
-
-    def test_minimal_input_none(self):
-        """"""
-        self.assertEqual(mystery_5([], None), [])
-
-    def test_minimal_input_default_argument(self):
-        """"""
-        self.assertEqual(mystery_5([]), [])
+        

6_recursion/1_describe_recursion/README.md

@@ -22,8 +22,12 @@ You can also summarize a recursive strategy in a few lines like so:
 
 ```py
 """
-base case         ->  turn-around
-recursive case  ->  ƒ(break-down)  +  rest of solution
+behavior description
+
+base case :
+    argument description  ->  turn-around description
+recursive case:
+    argument description  ->  ƒ(break-down description) build-up description 
 """
 ```
 
@@ -40,8 +44,12 @@ connect your programming knowledge to computer science principles.
 ```py
 def _func_name_(__: __) -> __:
     """
-    base case         ->  return value
-    recursive case  ->  ƒ(break-down) + rest of solution
+    behavior description
+
+    base case :
+        argument description  ->  turn-around description
+    recursive case:
+        argument description  ->  ƒ(break-down description) build-up description
     """
     is_base_case = __ # must use argument(s)
     if is_base_case:
@@ -65,8 +73,12 @@ solution, the more it resembles the semi-formal description.
 
 def reverse_string(to_reverse: str) -> str:
   """
-  empty string    ->  empty string
-  non-empty str ->  ƒ(string without first char) + first char
+  Reverses the characters in a string.
+
+  base case :
+      empty string    ->  empty string
+  recursive case:
+      non-empty str ->  ƒ(string without first char) + first char
   """
   is_base_case = len(to_reverse) == 0 # must use argument(s)
   if is_base_case:
@@ -84,8 +96,12 @@ def reverse_string(to_reverse: str) -> str:
 
 def reverse_string(to_reverse: str) -> str:
   """
-  empty string    ->  empty string
-  non-empty str ->  ƒ(string without first char) + first char
+  Reverses the characters in a string.
+
+  base case :
+      empty string    ->  empty string
+  recursive case:
+      non-empty str ->  ƒ(string without first char) + first char
   """
   if len(to_reverse) == 0: # base case
       return '' # turn-around
@@ -101,8 +117,12 @@ def reverse_string(to_reverse: str) -> str:
 
 def reverse_string(to_reverse: str) -> str:
   """
-  empty string    ->  empty string
-  non-empty str ->  ƒ(string without first char) + first char
+  Reverses the characters in a string.
+
+  base case :
+      empty string    ->  empty string
+  recursive case:
+      non-empty str ->  ƒ(string without first char) + first char
   """
   if len(to_reverse) == 0: # base case
       return '' # turn-around
@@ -116,8 +136,12 @@ def reverse_string(to_reverse: str) -> str:
 
 def reverse_string(to_reverse: str) -> str:
   """
-  empty string    ->  empty string
-  non-empty str ->  ƒ(string without first char) + first char
+  Reverses the characters in a string.
+
+  base case :
+      empty string    ->  empty string
+  recursive case:
+      non-empty str ->  ƒ(string without first char) + first char
   """
   if len(to_reverse) == 0:
       return ''

6_recursion/1_describe_recursion/examples/1_linear_recursion.py

@@ -28,7 +28,7 @@ def reverse_list(to_reverse: list) -> list:
 
 # --- --- --- test cases --- --- ---
 
-assert reverse_list([]) == [], "Test 1"
-assert reverse_list([1, 2, 3]) == [3, 2, 1], "Test 2"
-assert reverse_list([1, 2, 1]) == [1, 2, 1], "Test 3"
-assert reverse_list(["", False, None, 0]) == [0, None, False, ""], "Test 4"
+print(reverse_list([]), "should be", [])
+print(reverse_list([1, 2, 3]), "should be", [3, 2, 1])
+print(reverse_list([1, 2, 1]), "should be", [1, 2, 1])
+print(reverse_list(["", False, None, 0]), "should be", [0, None, False, ""])

6_recursion/1_describe_recursion/examples/2_tree_recursion.py

@@ -37,12 +37,12 @@ def fibonacci(n: int) -> int:
 
 # --- --- --- test cases --- --- ---
 
-assert fibonacci(0) == 0, "0 -> 0"
-assert fibonacci(1) == 1, "1 -> 1"
-assert fibonacci(2) == 1, "2 -> 1"
-assert fibonacci(3) == 2, "3 -> 2"
-assert fibonacci(4) == 3, "4 -> 3"
-assert fibonacci(5) == 5, "5 -> 5"
-assert fibonacci(6) == 8, "6 -> 8"
-assert fibonacci(7) == 13, "7 -> 13"
-# assert fibonacci(33) == 3524578, '7 -> 3524578' # a slow line!
+print(fibonacci(0) , 'should be ', 0)
+print(fibonacci(1) , 'should be ', 1)
+print(fibonacci(2) , 'should be ', 1)
+print(fibonacci(3) , 'should be ', 2)
+print(fibonacci(4) , 'should be ', 3)
+print(fibonacci(5) , 'should be ', 5)
+print(fibonacci(6) , 'should be ', 8)
+print(fibonacci(7) , 'should be ', 13)
+# print(fibonacci(33) , 'should be ', 3524578)  # a slow line!

6_recursion/1_describe_recursion/exercises/fibonacci_memo.py

@@ -17,16 +17,22 @@ def fibonacci(n: int, memo: dict = {}) -> int:
     recursive case:
 
     """
-    if n == 0:
-        return 0
-
-    if n == 1:
-        return 1
-
-    if n in memo:
-        return memo[n]
-
-    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
+    if n == 0: #
+        return 0 #
+
+    if n == 1: #
+        return 1 #
+
+    if n in memo: #
+        return memo[n] #
+    
+    # 
+    left_recursion = fibonacci(n - 1, memo)
+    # 
+    right_recursion = fibonacci(n - 2, memo)
+    # 
+    memo[n] = left_recursion + right_recursion
+    
     return memo[n]
 
 

6_recursion/1_describe_recursion/exercises/merge_sort.py

@@ -17,9 +17,9 @@ def merge_sort(numbers: list) -> list:
         return numbers  #
 
     mid = len(numbers) // 2
-    #                                    |
+    # 
     left_half = merge_sort(numbers[:mid])
-    #                                      |
+    # 
     right_half = merge_sort(numbers[mid:])
 
     return merge(left_half, right_half)

6_recursion/1_describe_recursion/exercises/reverse_list.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+""" Use test cases, the docstring, and labels to describe this solution. """
+
+
+def reverse_list(to_reverse: list) -> list:
+    """
+
+
+    base case:
+
+    recursive case:
+
+    """
+    if len(to_reverse) == 0: #
+        return [] #
+
+    #
+    return reverse_list(to_reverse[1:]) + [to_reverse[0]]
+
+
+# --- call the traced function ---
+
+print(reverse_list([]), 'should be', [])
+print(reverse_list([1, 2, 3]), 'should be', [3, 2, 1])
+print(reverse_list([1, 2, 1]), 'should be', [1, 2, 1])
+print(reverse_list(["", False, None, 0]), 'should be', [0, None, False, ""])

6_recursion/1_describe_recursion/exercises/sum_digits_to_threshold.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+""" Visualizing count_items
+
+To visualize implementation, 
+- use your VSCode debugger
+- copy-paste the code into PythonTutor
+
+To visualize strategy:
+- run the script and read the recursion trace
+- comment @trace_recursion and debug the function
+or copy the function into one of these sites:
+- https://www.recursionvisualizer.com
+- (https://recursion.vercel.app
+- https://recursion-visualizer.vercel.app
+- https://visualgo.net/en/recursion
+
+"""
+
+import sys
+import os
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+
+from trace_recursion import trace_recursion
+
+
+@trace_recursion
+def count_items(to_count: list) -> int:
+    """
+    
+    """
+    if len(to_count) == 0:
+        return 0
+
+    break_down = to_count[1:]
+    recursion = count_items(break_down)
+    build_up = recursion + 1
+
+    return  build_up
+
+
+# --- call the traced function ---
+
+print(count_items([]), 'should be', 0)
+print(count_items([1, 2, 3]), 'should be', 3)
+print(count_items([1, 2, 1]), 'should be', 3)
+print(count_items(["", False, None, 0]), 'should be', 4)
+print(count_items(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']), 'should be', 8)