Dan sample

README.md

@@ -58,44 +58,46 @@ buffer.get()   # should return ['d', 'e', 'f']
 
 #### Task 2. Runtime Optimization
 
-***!Important!*** If you are running this using PowerShell by clicking on the green play button, you will get an error that `names1.txt` is not found.  To resolve this, run it, get the error, then `cd` into the `names` directory in the `python` terminal that opens in VSCode.
+**_!Important!_** If you are running this using PowerShell by clicking on the green play button, you will get an error that `names1.txt` is not found. To resolve this, run it, get the error, then `cd` into the `names` directory in the `python` terminal that opens in VSCode.
 
 Navigate into the `names` directory. Here you will find two text files containing 10,000 names each, along with a program `names.py` that compares the two files and prints out duplicate name entries. Try running the code with `python3 names.py`. Be patient because it might take a while: approximately six seconds on my laptop. What is the runtime complexity of this code?
 
 Six seconds is an eternity so you've been tasked with speeding up the code. Can you get the runtime to under a second? Under one hundredth of a second?
 
-*You may not use the built in Python list, set, or dictionary in your solution for this problem.  However, you can and should use the provided `duplicates` list to return your solution.*
+_You may not use the built in Python list, set, or dictionary in your solution for this problem. However, you can and should use the provided `duplicates` list to return your solution._
 
 (Hint: You might try importing a data structure you built during the week)
 
-
 #### Task 3. Reverse a Linked List
 
-Inside of the `reverse` directory, you'll find a basic implementation of a Singly Linked List. _Without_ making it a Doubly Linked List (adding a tail attribute), complete the `reverse_list()` function within `reverse/reverse.py` reverse the contents of the list using recursion, *not a loop.*
+Inside of the `reverse` directory, you'll find a basic implementation of a Singly Linked List. _Without_ making it a Doubly Linked List (adding a tail attribute), complete the `reverse_list()` function within `reverse/reverse.py` reverse the contents of the list using recursion, _not a loop._
 
 For example,
+
 ```
 1->2->3->None
 ```
+
 would become...
+
 ```
 3->2->1->None
 ```
 
-While credit will be given for a functional solution, only optimal solutions will earn a ***3*** on this task.
-
-#### Stretch 
+While credit will be given for a functional solution, only optimal solutions will earn a **_3_** on this task.
 
-* Say your code from `names.py` is to run on an embedded computer with very limited RAM. Because of this, memory is extremely constrained and you are only allowed to store names in arrays (i.e. Python lists). How would you go about optimizing the code under these conditions? Try it out and compare your solution to the original runtime. (If this solution is less efficient than your original solution, include both and label the strech solution with a comment)
+#### Stretch
 
+- Say your code from `names.py` is to run on an embedded computer with very limited RAM. Because of this, memory is extremely constrained and you are only allowed to store names in arrays (i.e. Python lists). How would you go about optimizing the code under these conditions? Try it out and compare your solution to the original runtime. (If this solution is less efficient than your original solution, include both and label the strech solution with a comment)
 
 ### Rubric
-| OBJECTIVE | TASK | 1 - DOES NOT MEET Expectations | 2 - MEETS Expectations | 3 - EXCEEDS Expectations | SCORE |
-| ---------- | ----- | ------- | ------- | ------- | -- |
-| _Student should be able to construct a queue and stack and justify the decision to use a linked list instead of an array._ | Task 1. Implement a Ring Buffer Data Structure | Solution in `ring_buffer.py` DOES NOT run OR it runs but has multiple logical errors, failing 2 or more tests | Solution in `ring_buffer.py` runs, but may have one or two logical errors; passes at least 5/6 tests (Note that each function in the test file that begins with `test` is a test) | Solution in `ring_buffer.py` has no syntax or logical errors and passes all tests (Note that each function in the test file that begins with `test` is a test)| |
-| _Student should be able to construct a binary search tree class that can perform basic operations with O(log n) runtime._ | Task 2. Runtime Optimization | Student does NOT correctly identify the runtime of the starter code in `name.py` and is not able to optimize it to run in under 6 seconds | Student does not identify the runtime of the starter code in `name.py`, but optimizes it to run in under 6 seconds, with a solution of O(n log n) or better | Student does BOTH correctly identify the runtime of the starter code in `name.py` and optimizes it to run in under 6 seconds, with a solution of 0(n log n) or better |  |
-| _Student should be able to construct a linked list and compare the runtime of operations to an array to make the optimal choice between them._ | Task 3. Reverse the contents of a Singly Linked List using Recursion| Student's solution in `reverse.py` is failing one or more tests | Student's solution in `reverse.py` is able to correctly print out the contents of the Linked List in reverse order, passing all tests, BUT, the runtime of their solution is not optimal (requires looping through the list more than once) | Student's solution in `reverse.py` is able to correctly print out the contents of the Linked List in reverse order, passing all tests AND it has a runtime of O(n) or better |  |
 
+| OBJECTIVE                                                                                                                                      | TASK                                                                 | 1 - DOES NOT MEET Expectations                                                                                                            | 2 - MEETS Expectations                                                                                                                                                                                                                      | 3 - EXCEEDS Expectations                                                                                                                                                     | SCORE |
+| ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| _Student should be able to construct a queue and stack and justify the decision to use a linked list instead of an array._                     | Task 1. Implement a Ring Buffer Data Structure                       | Solution in `ring_buffer.py` DOES NOT run OR it runs but has multiple logical errors, failing 2 or more tests                             | Solution in `ring_buffer.py` runs, but may have one or two logical errors; passes at least 5/6 tests (Note that each function in the test file that begins with `test` is a test)                                                           | Solution in `ring_buffer.py` has no syntax or logical errors and passes all tests (Note that each function in the test file that begins with `test` is a test)               |       |
+| _Student should be able to construct a binary search tree class that can perform basic operations with O(log n) runtime._                      | Task 2. Runtime Optimization                                         | Student does NOT correctly identify the runtime of the starter code in `name.py` and is not able to optimize it to run in under 6 seconds | Student does not identify the runtime of the starter code in `name.py`, but optimizes it to run in under 6 seconds, with a solution of O(n log n) or better                                                                                 | Student does BOTH correctly identify the runtime of the starter code in `name.py` and optimizes it to run in under 6 seconds, with a solution of 0(n log n) or better        |       |
+| _Student should be able to construct a linked list and compare the runtime of operations to an array to make the optimal choice between them._ | Task 3. Reverse the contents of a Singly Linked List using Recursion | Student's solution in `reverse.py` is failing one or more tests                                                                           | Student's solution in `reverse.py` is able to correctly print out the contents of the Linked List in reverse order, passing all tests, BUT, the runtime of their solution is not optimal (requires looping through the list more than once) | Student's solution in `reverse.py` is able to correctly print out the contents of the Linked List in reverse order, passing all tests AND it has a runtime of O(n) or better |       |
 
 #### Passing the Sprint
+
 Score ranges for a 1, 2, and 3 are shown in the rubric above. For a student to have _passed_ a sprint challenge, they need to earn an **average of at least 2** for all items on the rubric.

names/names.py

@@ -1,4 +1,5 @@
 import time
+from collections import Counter
 
 start_time = time.time()
 
@@ -12,11 +13,71 @@
 
 duplicates = []  # Return the list of duplicates in this data structure
 
-# Replace the nested for loops below with your improvements
-for name_1 in names_1:
-    for name_2 in names_2:
-        if name_1 == name_2:
-            duplicates.append(name_1)
+# # Replace the nested for loops below with your improvements
+# for name_1 in names_1:
+#     for name_2 in names_2:
+#         if name_1 == name_2:
+#             duplicates.append(name_1)
+
+# copy/pasted BSTNode from past project
+class BSTNode:
+    def __init__(self, value="Default Value"):
+        self.value = value
+        self.left = None
+        self.right = None
+
+    # Insert the given value into the tree
+    def insert(self, value):
+        # create node to insert into tree
+        new_node = BSTNode(value)
+
+        # check to see if there are existing children
+        if self.value:
+            if value >= self.value:
+                if self.right is None:
+                    self.right = new_node
+                else:
+                    self.right.insert(value)
+            else:
+                if self.left is None:
+                    self.left = new_node
+                else:
+                    self.left.insert(value)
+        else:
+            self.value = value  
+
+
+    # Return True if the tree contains the value
+    # False if it does not
+    def contains(self, target):
+        # check to see if the BST is empty
+        if self.value:
+            # check to see if the target == the self.value
+            if target == self.value:
+                return True
+            # check to see if target is larger or smaller then the self.value
+            if target > self.value:
+                if not self.right:
+                    return False
+                return self.right.contains(target)
+            else:
+                if not self.left:
+                    return False
+                return self.left.contains(target)                    
+        # if there is no value then just return False
+        else:
+            return False
+
+# Create new BST node
+
+BST = BSTNode()    
+
+counter1 = Counter(names_1)
+counter2 = Counter(names_2)
+
+for key in counter1:
+    if key in counter2:
+        duplicates.append(key)
 
 end_time = time.time()
 print (f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n")

reverse/reverse.py

@@ -39,4 +39,15 @@ def contains(self, value):
         return False
 
     def reverse_list(self, node, prev):
-        pass
+        if not node:
+            return "There is nothing to reverse."
+        # create a variable that is the next_node
+        next = node.get_next()
+        # reverse the direction
+        node.set_next(prev)
+        # if it is not None (the tail) use recursion to continue reversing the list
+        if next is not None:
+            self.reverse_list(next, node)
+        # if its the tail, make it the head
+        else:
+            self.head = node

ring_buffer/ring_buffer.py

@@ -1,9 +1,35 @@
 class RingBuffer:
     def __init__(self, capacity):
-        pass
+        # Set the max capacity
+        self.capacity = capacity
+        # create a list and grow list to capacity
+        self.data = [None]*capacity
+        # To track current item
+        self.current = 0
 
     def append(self, item):
-        pass
+        # check current against capacity 
+        if self.current < self.capacity:
+            # remove the oldest element using the current index
+            self.data.pop(self.current)
+            # insert the new item at the current index
+            self.data.insert(self.current, item)
+            # add 1 to the current index
+            self.current += 1
+
+            # check if current is equal to capacity
+            if self.current == self.capacity:
+                # reset current to 0
+                self.current = 0
 
     def get(self):
-        pass
+        # define a list to store the not NONE values
+        get_list = []
+        # loop over the self.data list 
+        for n in self.data:
+            # if the item in the list doesn't equal None
+            if n != None:
+                # append it to the list
+                get_list.append(n)
+        # return the list
+        return get_list