proper parenthetics with tests, stack, linked list

README.md

@@ -1,5 +1,7 @@
 # code-katas
-CodeWars Assignments for Snow Day.
+Collection of Code Kata problems and tests.  Most are from codewars.com and have links to the original problem and 
+examples of other solutions 
+
 
 Convert a String to an Array (8 kyu)
 - Module:string_to_array.py
@@ -130,3 +132,18 @@ def multiples(s1, s2, s3):
     return [a for a in xrange(1, s3) if not(a % s1 or a % s2)]
 ```
 
+Sum of the first nth terms of a series (7 kyu)
+- Module: series_sum.py
+- Tests: test_series_sum.py
+- Link: http://www.codewars.com/kata/sum-of-the-first-nth-term-of-series/train/python
+- Interesting Solution: Making the numerator a float() was smart.
+```python
+def series_sum(n):
+    """Solution by MMMAAANNN"""
+    return '{:.2f}'.format(sum(1.0/(3 * i + 1) for i in range(n)))
+```
+
+
+Proper Parenthetics
+- Module: proper_parenthetics.py
+- Tests: test_proper_parenthetics.py

src/linked_list.py

@@ -0,0 +1,83 @@
+"""Implementation of Linked_List data type."""
+
+
+class LinkedList(object):
+    """Class representation of linked list."""
+
+    def __init__(self, iterable=None):
+        """Instantiate linked list."""
+        self.head_node = None
+        self.length = 0
+        try:
+            for item in iterable:
+                self.push(item)
+        except TypeError:
+            if iterable:
+                return "Please only enter iterable values"
+
+    def push(self, contents):
+        """Add node to this linked list."""
+        self.head_node = Node(contents, self.head_node)
+        self.length += 1
+
+    def pop(self):
+        """Remove and return the current head node."""
+        if not self.head_node:
+            return "Linked list is already empty"
+        old_head_node = self.head_node
+        self.head_node = self.head_node.next_node
+        self.length -= 1
+        return old_head_node.contents
+
+    def size(self):
+        """Return the current size of this linked list."""
+        return self.length
+
+    def search(self, search_value):
+        """Return the node with the searched contents if found."""
+        if self.length:
+            if search_value == self.head_node.contents:
+                return self.head_node
+            current_node = self.head_node
+            while current_node.contents != search_value:
+                if current_node.next_node is None:
+                    return None
+                current_node = current_node.next_node
+            return current_node
+        else:
+            return None
+
+    def remove(self, remove_node):
+        """Remove a node from linked list."""
+        if remove_node == self.head_node:
+            self.head_node = self.head_node.next_node
+            self.length -= 1
+            return None
+        elif remove_node is None:
+            raise ValueError("Provided value not in list.")
+        current_node = self.head_node
+        while current_node.next_node != remove_node:
+            current_node = current_node.next_node
+        current_node.next_node = current_node.next_node.next_node
+        self.length -= 1
+
+    def display(self):
+        """Return the tuple of all values in linked list."""
+        if self.length == 0:
+            return None
+        else:
+            new_list = [self.head_node.contents]
+            current_node = self.head_node
+            while current_node.next_node is not None:
+                current_node = current_node.next_node
+                new_list.append(current_node.contents)
+            return tuple(new_list)
+
+
+class Node(object):
+    """Class representation of linked list node."""
+
+    def __init__(self, contents, next_node):
+        """Instantiate linked list node."""
+        self.contents = contents
+        self.next_node = next_node

src/proper_parenthetics.py

@@ -0,0 +1,19 @@
+"""Ensure the same number of opening and closing parenthetics in a string."""
+
+from stack import Stack
+
+
+def proper_parenthetics(input_string):
+    """Ensure the balance of opening and closing parenthtics."""
+    parenthetics_stack = Stack()
+    for i in input_string:
+        if i == '(':
+            parenthetics_stack.push(i)
+        if i == ')':
+            if parenthetics_stack.head_node is None:
+                return -1
+            else:
+                parenthetics_stack.pop()
+    if parenthetics_stack.head_node is None:
+        return 0
+    return 1

src/stack.py

@@ -0,0 +1,24 @@
+"""Implementation of Stack data type."""
+
+from linked_list import LinkedList
+
+
+class Stack(object):
+    """Class representation of a stack."""
+
+    def __init__(self, iterable=None):
+        """Instantiate stack."""
+        self.linked_list = LinkedList(iterable)
+        self.length = self.linked_list.length
+        self.head_node = self.linked_list.head_node
+
+    def push(self, contents):
+        """Add node to this stack."""
+        self.linked_list.push(contents)
+        self.head_node = self.linked_list.head_node
+
+    def pop(self):
+        """Remove and return the current head node."""
+        old_head_node_value = self.linked_list.pop()
+        self.head_node = self.linked_list.head_node
+        return old_head_node_value

src/test_proper_parenthetics.py

@@ -0,0 +1,21 @@
+"""Tests for proper_parenthetics."""
+import pytest
+
+
+ASSERTIONS = [
+    ['(', 1],
+    ['(This is (a string)', 1],
+    ['()', 0],
+    ['some (strings) and (others)', 0],
+    ['((Nestes)ones)', 0],
+    [')', -1],
+    ['(bloop))', -1],
+    [')its backwards(', -1]
+]
+
+
+@pytest.mark.parametrize("input, result", ASSERTIONS)
+def test_proper_parenthetics(input, result):
+    """Test proper_parenthetics for proper output in test cases."""
+    from proper_parenthetics import proper_parenthetics
+    assert proper_parenthetics(input) == result