Done up to #5

Author: r1cc4rdo

problems/01/README.md

@@ -1,7 +1,8 @@
-##Problem 1
+## Problem 1
 
 Given a stack of N elements, interleave the first half of the stack
 with the second half reversed using one other queue.
+
 Example:
 
     >>> coding_problem_01([1, 2, 3, 4, 5])

problems/01/solution_01.py

@@ -15,11 +15,11 @@ def coding_problem_01(stack):
     Note: with itertools, you could instead islice(chain.from_iterable(izip(l, reversed(l))), len(l))
     """
     queue = deque([])  # stack S:[1,2,3,4,5], queue Q:[]
-    for cnt in range(len(stack) - 1):  # move stack into queue. S:[1], Q:[5,4,3,2]
+    for _ in range(len(stack) - 1):  # move stack into queue. S:[1], Q:[5,4,3,2]
         queue.append(stack.pop())
-    for cnt in range(len(queue) // 2):
+    for _ in range(len(queue) // 2):
         stack.append(queue.popleft())  # S:[1,5], Q:[4,3,2]
-        for cnt2 in range(len(queue) - 1):  # rotate last element to front, S:[1,5], Q:[2,4,3]
+        for __ in range(len(queue) - 1):  # rotate last element to front, S:[1,5], Q:[2,4,3]
             queue.append(queue.popleft())
         stack.append(queue.popleft())  # S:[1,5,2], Q:[4,3]
     if queue:

problems/02/README.md

@@ -1,8 +1,9 @@
-##Problem 2
+## Problem 2
 
 Given an array of integers, return a new array such that each element at index i of
 the new array is the product of all the numbers in the original array except the one at i.
 Solve it without using division and in O(n).
+
 Example:
 
     >>> coding_problem_02([1, 2, 3, 4, 5])

problems/02/problem_02.py

@@ -1,6 +1,3 @@
-from collections import deque
-
-
 def coding_problem_02(l):
     """
     Given an array of integers, return a new array such that each element at index i of

problems/02/solution_02.py

@@ -1,6 +1,3 @@
-from collections import deque
-
-
 def coding_problem_02(l):
     """
     Given an array of integers, return a new array such that each element at index i of
@@ -13,7 +10,7 @@ def coding_problem_02(l):
     """
     forward = [1] * len(l)
     backward = [1] * len(l)
-    for idx in xrange(1, len(l)):
+    for idx in range(1, len(l)):
 
         forward[idx] = forward[idx - 1] * l[idx - 1]
         backward[-idx - 1] = backward[-idx] * l[-idx]

problems/03/README.md

@@ -1,11 +1,14 @@
-##Problem 3
+## Problem 3
 
 Given the root to a binary tree, implement serialize(root), which serializes the tree
 into a string, and deserialize(s), which deserializes the string back into the tree.
+
 Example:
 
-    >>> s = '3 2 1 None None None 4 5 None None 6 None None'
-    >>> de_serialized = coding_problem_03(s)
-    >>> re_serialized = de_serialized.serialize_to_string()
-    >>> s == re_serialized
-    True
+    >>> serialize, deserialize = coding_problem_03()
+    >>> s = '>>> YOUR OWN TREE ENCODING HERE <<<'
+    >>> isinstance(s, str)
+    True
+
+    >>> s == serialize(deserialize(s))
+    True

problems/03/problem_03.py

@@ -1,16 +1,15 @@
-from collections import deque
-
-
-def coding_problem_03(s):
+def coding_problem_03():
     """
     Given the root to a binary tree, implement serialize(root), which serializes the tree
-    into a string, and deserialize(s), which deserializes the string back into the tree.
+    into a string, and deserialize(s), which de-serializes the string back into the tree.
     Example:
 
-    >>> s = '3 2 1 None None None 4 5 None None 6 None None'
-    >>> de_serialized = coding_problem_03(s)
-    >>> re_serialized = de_serialized.serialize_to_string()
-    >>> s == re_serialized
+    >>> serialize, deserialize = coding_problem_03()
+    >>> s = '>>> YOUR OWN TREE ENCODING HERE <<<'
+    >>> isinstance(s, str)
+    True
+
+    >>> s == serialize(deserialize(s))
     True
     """
     pass

problems/03/solution_03.py

@@ -1,49 +1,43 @@
-from collections import deque
+from typing import Iterable
 
 
-def coding_problem_03(s):
+def coding_problem_03():
     """
     Given the root to a binary tree, implement serialize(root), which serializes the tree
-    into a string, and deserialize(s), which deserializes the string back into the tree.
+    into a string, and deserialize(s), which de-serializes the string back into the tree.
     Example:
 
+    >>> serialize, deserialize = coding_problem_03()
     >>> s = '3 2 1 None None None 4 5 None None 6 None None'
-    >>> de_serialized = coding_problem_03(s)
-    >>> re_serialized = de_serialized.serialize_to_string()
-    >>> s == re_serialized
+    >>> tree = (3, (2, (1, None, None), None), (4, (5, None, None), (6, None, None)))
+    >>> isinstance(s, str)
     True
+
+    >>> deserialized = deserialize(s)
+    >>> tree == deserialized
+    True
+
+    >>> s == serialize(deserialized)
+    True
+
+    Notes: the implementation below tries to solve the problem as intended.
+    However, one could instead: serialize, deserialize = lambda tree: repr(tree), lambda s: eval(s)
     """
-    class BinaryNode(object):
-
-        def __init__(self, val, lc=None, rc=None):
-            self.val = val
-            self.lc = lc
-            self.rc = rc
-
-        def serialize(self, queue=None):
-            queue = [] if queue is None else queue
-            queue.append(self.val)
-            if self.val is not None:
-                self.lc.serialize(queue)
-                self.rc.serialize(queue)
-            return queue
-
-        @classmethod
-        def deserialize(cls, queue):
-            val, lc, rc = queue.pop(), None, None
-            if val is not None:
-                lc = cls.deserialize(queue)
-                rc = cls.deserialize(queue)
-            return BinaryNode(val, lc, rc)
-
-        def serialize_to_string(self):
-            return ' '.join(repr(element) for element in self.serialize())
-
-        @classmethod
-        def deserialize_from_string(cls, s):
-            return cls.deserialize([int(token) if token != 'None' else None for token in s.split(' ')][::-1])
-
-    return BinaryNode.deserialize_from_string(s)
+    def deserialize_array(array):
+        val = array.pop()
+        return None if val is None else (val, deserialize_array(array), deserialize_array(array))
+
+    def flatten(array):
+        return [y for x in array for y in flatten(x)] if isinstance(array, Iterable) else [array]
+
+    def serialize(array):
+        return ' '.join(repr(element) for element in flatten(array))
+
+    def deserialize(s):
+        values = [int(token) if token != 'None' else None for token in s.split()]
+        return deserialize_array(values[::-1])
+
+    return serialize, deserialize
 
 
 if __name__ == '__main__':

problems/04/README.md

@@ -1,35 +1,15 @@
-##Problem 4
+## Problem 4
 
 Given an array of integers, find the first missing positive integer in linear time and constant space.
 You can modify the input array in-place.
+
 Example:
 
     >>> coding_problem_04([3, 4, -1, 1])
     2
+    
     >>> coding_problem_04([1, 2, 0])
     3
+    
     >>> coding_problem_04([4, 1, 2, 2, 2, 1, 0])
     3
-
-Notes: the code below is a bucket sort variant, and therefore has linear time complexity equal to O(n).
-More in detail, all the for loops in the code are O(n). The while loop is also linear, because it loops
-only when element are not ordered and each iteration correctly positions one element of the array.
-
-This was my original implementation, which however is not constant space:
-
-bucket_sort = [True] + [False] * len(arr)  # skip 0 index
-for element in filter(lambda x: 0 < x < len(arr), arr):
-bucket_sort[element] = True
-return bucket_sort.index(False)
-
-The following one, also not constant space but possibly more understandable,
-has been contributed by NikhilCodes (https://github.com/NikhilCodes):
-
-arr = set(arr)  # O(n)
-max_val = max(arr)  # O(n)
-missing_val = max_val + 1
-for e in range(1, max_val + 1):  # O(n)
-if e not in arr:  # O(1)
-missing_val = e
-break
-return missing_val

problems/04/problem_04.py

@@ -1,6 +1,3 @@
-from collections import deque
-
-
 def coding_problem_04(array):
     """
     Given an array of integers, find the first missing positive integer in linear time and constant space.
@@ -13,29 +10,6 @@ def coding_problem_04(array):
     3
     >>> coding_problem_04([4, 1, 2, 2, 2, 1, 0])
     3
-
-    Notes: the code below is a bucket sort variant, and therefore has linear time complexity equal to O(n).
-    More in detail, all the for loops in the code are O(n). The while loop is also linear, because it loops
-    only when element are not ordered and each iteration correctly positions one element of the array.
-
-    This was my original implementation, which however is not constant space:
-
-        bucket_sort = [True] + [False] * len(arr)  # skip 0 index
-        for element in filter(lambda x: 0 < x < len(arr), arr):
-            bucket_sort[element] = True
-        return bucket_sort.index(False)
-
-    The following one, also not constant space but possibly more understandable,
-    has been contributed by NikhilCodes (https://github.com/NikhilCodes):
-
-        arr = set(arr)  # O(n)
-        max_val = max(arr)  # O(n)
-        missing_val = max_val + 1
-        for e in range(1, max_val + 1):  # O(n)
-            if e not in arr:  # O(1)
-                missing_val = e
-                break
-        return missing_val
     """
     pass