copy all exercies to solutions, clearn exercises

Author: Kimfucious

exercises/anagrams.py

@@ -10,34 +10,4 @@
 
 
 def anagrams(stringA, stringB):
-    """
-    Using regular expression sub() to remove non characters from string with
-    helper function. sorted() returns a list, but no need to join
-    """
-    import re
-
-    def clean_string(string):
-        return sorted(re.sub(r"[^\w]", "", string).lower())
-    return clean_string(stringA) == clean_string(stringB)
-
-
-# def anagrams(stringA, stringB):
-#     """
-#     Using sorted() directly on the strings w/o helper function
-#     """
-#     import re
-#     return sorted(re.sub(r"[^\w]", "", stringA).lower()) == sorted(re.sub(r"[^\w]", "", stringB).lower())
-
-
-# def anagrams(stringA, stringB):
-#     """
-#     Using dict comprehension to built character maps with sorted() on the
-#     dictionaries
-#     """
-#     import re
-#     char_map_one = {char: stringA.count(
-#         char) for char in re.sub(r"[^\w]", "", stringA).lower()}
-#     char_map_two = {char: stringB.count(
-#         char) for char in re.sub(r"[^\w]", "", stringB).lower()}
-
-#     return sorted(char_map_one) == sorted(char_map_two)
+    pass

exercises/bst.py

@@ -11,28 +11,4 @@
 
 
 class Node:
-    def __init__(self, data):
-        self.data = data
-        self.left = None
-        self.right = None
-
-    def contains(self, data):
-        if self.data == data:
-            return self
-        if self.left and data < self.data:
-            return self.left.contains(data)
-        elif self.right and data > self.data:
-            return self.right.contains(data)
-        else:
-            return None
-
-    def insert(self, data):
-        if self.left and data < self.data:
-            self.left.insert(data)
-        elif data < self.data:
-            self.left = Node(data)
-
-        if self.right and data > self.data:
-            self.right.insert(data)
-        elif data > self.data:
-            self.right = Node(data)
+    pass

exercises/capitalize.py

@@ -8,28 +8,4 @@
 
 
 def capitalize(string):
-    """
-    Using the Python str.title() method
-    """
-    return string.title()
-
-# def capitalize(string):
-#     """
-#     Using a loop on the string
-#     """
-#     result = string[0].upper()
-#     for index in range(1, len(string)):
-#         if string[index-1] == " ":
-#             result += string[index].upper()
-#         else:
-#             result += string[index]
-#     return result
-
-# def capitalize(string):
-#     """
-#     Using a loop on a list split from the string
-#     """
-#     words = []
-#     for word in string.split(" "):
-#         words.append(word[0].upper() + word[1:])
-#     return " ".join(words)
+    pass

exercises/chunk.py

@@ -10,35 +10,4 @@
 
 
 def chunk(l, size):
-    """
-    Using while until the list is empty Emptying out the list using del 
-    """
-    chunked = []
-    while len(l) > 0:
-        chunked.append(l[0:size])
-        del l[0:size]
-    return chunked
-
-# def chunk(l, size):
-#     """
-#     Using while with an index counter
-#     """
-#     chunked = []
-#     index = 0
-#     while index < len(l):
-#         chunked.append(l[index:index+size])
-#         index += size
-#     return chunked
-
-# def chunk(l, size):
-#     """
-#     Using interation DOES NOT WORK!
-#     """
-#     chunked = []
-#     for element in l:
-#         last = chunked[len(chunked) - 1]
-#         if not last or len(last) == size:
-#             chunked.append([element])
-#         else:
-#             last.append(element)
-#     return chunked
+    pass

exercises/circular.py

@@ -13,12 +13,4 @@
 
 
 def circular(l):
-    slow = l.get_at(0)
-    fast = l.get_at(0)
-
-    while fast.next and fast.next.next:
-        slow = slow.next
-        fast = fast.next.next
-        if slow == fast:
-            return True
-    return False
+    pass

exercises/fib.py

@@ -11,49 +11,4 @@
 
 
 def fib(n):
-    """
-    Using recursion
-    """
-    if n <= 1:
-        return n
-    return fib(n-1) + fib(n-2)
-
-# There are issues with these solutions as the instructions have the Fib series
-# starting at zero and Stephen's tests assert that it starts at 1
-
-# def fib(n):
-#     result = [0, 1]
-
-#     if n == 1:
-#         return 0
-
-#     for index in range(2, n+1):
-#         a = result[index - 1]
-#         b = result[index - 2]
-#         result.append(a + b)
-
-#     return result[-1]
-
-
-# def fib(n):
-#     """
-#     Using a while loop and a counter
-#     """
-#     if n == 1:
-#         return 0
-#     if n > 0 and n < 3:
-#         return 1
-#     a = 1
-#     b = 1
-#     c = 2
-#     counter = 3
-#     while counter <= n:
-#         if counter == n:
-#             return c
-#         a = b
-#         b = c
-#         c = a + b
-#         counter += 1
-
-
-print(fib(3))
+    pass

exercises/fib_memoize.py

@@ -10,20 +10,5 @@
 # function, so I named it george.
 
 
-def memoize(fn):
-    cache = {}
-
-    def george(*args):
-        if args in cache:
-            return cache[args]
-        else:
-            cache[args] = fn(*args)
-            return cache[args]
-    return george
-
-
-@memoize
 def fib(n):
-    if n < 2:
-        return n
-    return fib(n-1) + fib(n-2)
+    pass

exercises/fizzbuzz.py

@@ -12,12 +12,4 @@
 
 
 def fizzbuzz(n):
-    for num in range(1, n+1):
-        if num % 15 == 0:
-            print("fizzbuzz")
-        elif num % 5 == 0:
-            print("buzz")
-        elif num % 3 == 0:
-            print("fizz")
-        else:
-            print(num)
+    pass

exercises/fromlast.py

@@ -12,9 +12,4 @@
 
 
 def from_last(l, n):
-    slow = l.get_at(0)
-    fast = l.get_at(n)
-    while fast.next:
-        slow = slow.next
-        fast = fast.next
-    return slow
+    pass

exercises/levelwidth.py

@@ -12,14 +12,4 @@
 
 
 def level_width(root):
-    widths = [0]
-    l = [root, "end"]
-    while len(l) > 1:
-        node = l.pop(0)
-        if node == "end":
-            l.append("end")
-            widths.append(0)
-        else:
-            l = l + node.children
-            widths[-1] += 1
-    return widths
+    pass

exercises/linkedlist.py

@@ -4,107 +4,8 @@
 
 
 class Node:
-    def __init__(self, data, next=None):
-        self.data = data
-        self.next = next
+    pass
 
 
 class LinkedList:
-    def __init__(self, head=None):
-        self.head = head
-
-    def __iter__(self):
-        node = self.head
-        while node:
-            yield node
-            node = node.next
-
-    def clear(self):
-        self.head = None
-
-    def for_each(self, fn):
-        if not self.head:
-            return
-        node = self.head
-        while node:
-            fn(node)
-            node = node.next
-
-    def get_at(self, index):
-        counter = 0
-        node = self.head
-        while node:
-            if counter == index:
-                return node
-            counter += 1
-            node = node.next
-        return None
-
-    def get_first(self):
-        return self.head
-
-    def get_last(self):
-        if not self.head:
-            return None
-        node = self.head
-        while node:
-            if not node.next:
-                return node
-            node = node.next
-
-    def insert_first(self, data):
-        self.head = Node(data, self.head)
-
-    def insert_at(self, data, index):
-        if not self.head:
-            self.head = Node(data)
-            return
-        if index == 0:
-            self.head = Node(data, self.head)
-            return
-        prev = self.get_at(index - 1) or self.get_last()
-        prev.next = Node(data, prev.next)
-
-    def insert_last(self, data):
-        last = self.get_last()
-        if last:
-            last.next = Node(data)
-        else:
-            self.head = Node(data)
-
-    def remove_at(self, index):
-        if not self.head:
-            return None
-        if index == 0:
-            self.head = self.head.next
-            return
-        prev = self.get_at(index - 1)
-        if not prev or not prev.next:
-            return
-        prev.next = prev.next.next
-
-    def remove_first(self):
-        if not self.head:
-            return
-        self.head = self.head.next
-
-    def remove_last(self):
-        if not self.head:
-            return None
-        if not self.head.next:
-            self.head = None
-            return
-        prev = self.head
-        node = self.head.next
-        while node.next:
-            prev = node
-            node = node.next
-        prev.next = None
-
-    def size(self):
-        counter = 0
-        node = self.head
-        while node:
-            counter += 1
-            node = node.next
-        return counter
+    pass