Adding Linked List task

Author: Elissa

Data_Structures_Answers.md

@@ -8,7 +8,7 @@ In this week's Sprint you implemented some classic and fundamental data structur
 
 This is an individual assessment. All work must be your own. Your Challenge score is a measure of your ability to work independently using the material covered throughout this sprint. You need to demonstrate proficiency in the concepts and objectives that were introduced and that you practiced in the preceding days.
 
-You are not allowed to collaborate during the Sprint Challenge. However, you are encouraged to follow the twenty-minute rule and seek support from your PM and Instructor in your cohort help channel on Slack. Your submitted work reflects your proficiency in the concepts and topics that were covered this week.
+You are not allowed to collaborate during the Sprint Challenge. However, you are encouraged to follow the twenty-minute rule and seek support from your TL and Instructor in your cohort help channel on Slack. Your submitted work reflects your proficiency in the concepts and topics that were covered this week.
 
 You have three hours to complete this Sprint Challenge. Plan your time accordingly.
 
@@ -22,7 +22,7 @@ This Sprint Challenge is split into three parts:
 
 1. Implement a data structure called a ring buffer (more details below)
 2. Optimizing some inefficient code
-3. Analyzing time and space complexities from parts 1 and 2
+3. Reversing the contents of a singly linked list
 
 ### Minimum Viable Product
 
@@ -68,37 +68,24 @@ Six seconds is an eternity so you've been tasked with speeding up the code. Can
 
 (Hint: You might try importing a data structure you built during the week)
 
-#### Task 3. Analyze Some Runtimes
 
-Open up the `Data_Structures_Answers.md` file. This is where you'll jot down your answers for the runtimes of the functions/data structures you just implemented. Also include the runtime and space complexities of the original code and your optimized solution from `names.py`.
+#### 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. 
+
+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 Problems
 
 1. 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
-
-#### Ring Buffer
-
-- Ring buffer implementation passes the tests: 10 points total
-
-#### Names
-
-- Optimize with an O(n log n) runtime solution: 8 points total
-- Optimize with an O(n) runtime solution: 10 points total
-
-#### Complexity
-
-- One point each: 8 points total
-
-#### Stretch
-
-- `names.py` is optimized with sub-quadratic runtime complexity and tightly constrained linear space complexity: 4 points
-
-
-#### Grading
-
-* *3*: 28+
-* *2*: 20-27
-* *1*: 0-19

README.md

@@ -0,0 +1,47 @@
+class Node:
+  def __init__(self, value=None, next_node=None):
+    # the value at this linked list node
+    self.value = value
+    # reference to the next node in the list
+    self.next_node = next_node
+
+  def get_value(self):
+    return self.value
+
+  def get_next(self):
+    return self.next_node
+
+  def set_next(self, new_next):
+    # set this node's next_node reference to the passed in node
+    self.next_node = new_next
+
+class LinkedList:
+  def __init__(self):
+    # reference to the head of the list
+    self.head = None
+
+  def add_to_head(self, value):
+    node = Node(value)
+    if self.head is not None:
+      node.set_next(self.head)
+    
+    self.head = node
+
+  def contains(self, value):
+    if not self.head:
+      return False
+    # get a reference to the node we're currently at; update this as we traverse the list
+    current = self.head
+    # check to see if we're at a valid node 
+    while current:
+      # return True if the current value we're looking at matches our target value
+      if current.get_value() == value:
+        return True
+      # update our current node to the current node's next node
+      current = current.get_next()
+    # if we've gotten here, then the target node isn't in our list
+    return False
+
+  def reverse_list(self):
+    # TO BE COMPLETED
+    pass

reverse/reverse.py

@@ -0,0 +1,47 @@
+import unittest
+from reverse import LinkedList
+
+class LinkedListTests(unittest.TestCase):
+  def setUp(self):
+    self.list = LinkedList()
+
+  def test_add_to_head(self):
+    self.list.add_to_head(1)
+    self.assertEqual(self.list.head.value, 1)
+    self.list.add_to_head(2)
+    self.assertEqual(self.list.head.value, 2)
+
+  def test_contains(self):
+    self.list.add_to_head(1)
+    self.list.add_to_head(2)
+    self.list.add_to_head(10)
+    self.assertTrue(self.list.contains(2))
+    self.assertTrue(self.list.contains(10))
+    self.assertFalse(self.list.contains(1000))
+
+  def test_empty_reverse(self):
+    self.list.reverse_list()
+    self.assertEqual(self.list.head, None)
+    
+  def test_single_reverse(self):
+    self.list.add_to_head(1)
+    self.list.reverse_list()
+    self.assertEqual(self.list.head.value, 1)
+
+  def test_longer_reverse(self):
+    self.list.add_to_head(1)
+    self.list.add_to_head(2)
+    self.list.add_to_head(3)
+    self.list.add_to_head(4)
+    self.list.add_to_head(5)
+    self.assertEqual(self.list.head.value, 5)
+    self.list.reverse_list()
+    self.assertEqual(self.list.head.value, 1)
+    self.assertEqual(self.list.head.get_next().value, 2)
+    self.assertEqual(self.list.head.get_next().get_next().value, 3)
+    
+
+ 
+
+if __name__ == '__main__':
+  unittest.main()