Split problems into separate files

Author: r1cc4rdo

daily_coding_problem_01_05.py renamed to previous/daily_coding_problem_01_05.py

@@ -1,15 +1,15 @@
 from collections import deque
 
 
-def coding_problem_1(stack):
+def coding_problem_01(stack):
     """
     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_1([1, 2, 3, 4, 5])
+    >>> coding_problem_01([1, 2, 3, 4, 5])
     [1, 5, 2, 4, 3]
-    >>> coding_problem_1([1, 2, 3, 4, 5, 6])
+    >>> coding_problem_01([1, 2, 3, 4, 5, 6])
     [1, 6, 2, 5, 3, 4]
 
     Note: with Python lists, you could instead islice(chain.from_iterable(izip(l, reversed(l))), len(l))
@@ -27,14 +27,14 @@ def coding_problem_1(stack):
     return stack
 
 
-def coding_problem_2(l):
+def coding_problem_02(l):
     """
     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_2([1, 2, 3, 4, 5])
+    >>> coding_problem_02([1, 2, 3, 4, 5])
     [120, 60, 40, 30, 24]
     """
     forward = [1] * len(l)
@@ -47,14 +47,14 @@ def coding_problem_2(l):
     return [f * b for f, b in zip(forward, backward)]
 
 
-def coding_problem_3(s):
+def coding_problem_03(s):
     """
     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_3(s)
+    >>> de_serialized = coding_problem_03(s)
     >>> re_serialized = de_serialized.serialize_to_string()
     >>> s == re_serialized
     True
@@ -92,17 +92,17 @@ def deserialize_from_string(cls, s):
     return BinaryNode.deserialize_from_string(s)
 
 
-def coding_problem_4(array):
+def coding_problem_04(array):
     """
     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_4([3, 4, -1, 1])
+    >>> coding_problem_04([3, 4, -1, 1])
     2
-    >>> coding_problem_4([1, 2, 0])
+    >>> coding_problem_04([1, 2, 0])
     3
-    >>> coding_problem_4([4, 1, 2, 2, 2, 1, 0])
+    >>> 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).
@@ -147,13 +147,13 @@ def coding_problem_4(array):
     return len(array)  # if here, the sought integer is past the array end
 
 
-def coding_problem_5():
+def coding_problem_05():
     """
     cons(a, b) constructs a pair, and car(pair) and cdr(pair) returns the first and last element of that pair.
     Given this implementation of cons below, implement car and cdr.
     Examples: car(cons(3, 4)) == 3, cdr(cons(3, 4)) == 4
 
-    >>> coding_problem_5()
+    >>> coding_problem_05()
     True
     """
     def cons(a, b):

daily_coding_problem_06_10.py renamed to previous/daily_coding_problem_06_10.py

@@ -1,12 +1,12 @@
-def coding_problem_6():
+def coding_problem_06():
     """
     An XOR linked list is a more memory efficient doubly linked list.
     Instead of each node holding next and prev fields, it holds a field named both, which is a XOR of the next node
     and the previous node. Implement a XOR linked list; it has an add(element) which adds the element to the end,
     and a get(index) which returns the node at index.
     Example:
 
-    >>> l = coding_problem_6()
+    >>> l = coding_problem_06()
     >>> for cnt in xrange(0, 4):
     ...     l.add(cnt)
     >>> l.get(2) == 2
@@ -59,63 +59,63 @@ def get(self, index):
     return XORLinkedList()
 
 
-def coding_problem_7(s):
+def coding_problem_07(s):
     """
     Given the mapping a = 1, b = 2, ... z = 26, and an encoded message, count the number of ways it can be decoded.
     Examples:
 
-    >>> coding_problem_7('111')  # possible interpretations: 'aaa', 'ka', 'ak'
+    >>> coding_problem_07('111')  # possible interpretations: 'aaa', 'ka', 'ak'
     3
-    >>> coding_problem_7('2626')  # 'zz', 'zbf', 'bfz', 'bfbf'
+    >>> coding_problem_07('2626')  # 'zz', 'zbf', 'bfz', 'bfbf'
     4
     """
     symbols = map(str, range(1, 27))
     if not s:
         return 1
 
     matches = filter(lambda symbol: s.startswith(symbol), symbols)
-    encodings = [coding_problem_7(s[len(m):]) for m in matches]
+    encodings = [coding_problem_07(s[len(m):]) for m in matches]
     return sum(encodings)
 
 
-def coding_problem_8(btree):
+def coding_problem_08(btree):
     """
     A unival tree (which stands for "universal value") is a tree where all nodes have the same value.
     Given the root to a binary tree, count the number of unival subtrees.
     Example:
 
     >>> btree = (0, (0, (0, None, None), (0, (0, None, None), (0, None, None))), (1, None, None))
-    >>> coding_problem_8(btree)[0]
+    >>> coding_problem_08(btree)[0]
     6
     """
     val, ln, rn = btree
     if ln is None and rn is None:  # leaf case
         return 1, True, val
 
-    lcount, is_uni_l, lval = coding_problem_8(ln)
-    rcount, is_uni_r, rval = coding_problem_8(rn)
+    lcount, is_uni_l, lval = coding_problem_08(ln)
+    rcount, is_uni_r, rval = coding_problem_08(rn)
 
     is_unival = is_uni_l and is_uni_r and val == lval and val == rval
     count = lcount + rcount + is_unival
     return count, is_unival, val
 
 
-def coding_problem_9(numbers):
+def coding_problem_09(numbers):
     """
     Given a list of integers, write a function that returns the largest sum of non-adjacent numbers.
     The "largest sum of non-adjacent numbers" is the sum of any subset of non-contiguous elements.
     Solution courtesy of Kye Jiang (https://github.com/Jedshady).
     Examples:
 
-    >>> coding_problem_9([2, 4, 6, 8])
+    >>> coding_problem_09([2, 4, 6, 8])
     12
-    >>> coding_problem_9([5, 1, 1, 5])
+    >>> coding_problem_09([5, 1, 1, 5])
     10
-    >>> coding_problem_9([1, 2, 3, 4, 5, 6])
+    >>> coding_problem_09([1, 2, 3, 4, 5, 6])
     12
-    >>> coding_problem_9([-8, 4, -3, 2, 3, 4])
+    >>> coding_problem_09([-8, 4, -3, 2, 3, 4])
     10
-    >>> coding_problem_9([2, 4, 6, 2, 5])
+    >>> coding_problem_09([2, 4, 6, 2, 5])
     13
     """
     if not numbers:
@@ -124,8 +124,8 @@ def coding_problem_9(numbers):
     if len(numbers) <= 2:
         return max(numbers)
 
-    with_last = coding_problem_9(numbers[:-2]) + numbers[-1]  # sum include last number
-    without_last = coding_problem_9(numbers[:-1])  # sum without last number
+    with_last = coding_problem_09(numbers[:-2]) + numbers[-1]  # sum include last number
+    without_last = coding_problem_09(numbers[:-1])  # sum without last number
     return max(with_last, without_last)
 
 

daily_coding_problem_11_15.py renamed to previous/daily_coding_problem_11_15.py

@@ -0,0 +1,15 @@
+##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])
+    [1, 5, 2, 4, 3]
+    
+    >>> coding_problem_01([1, 2, 3, 4, 5, 6])
+    [1, 6, 2, 5, 3, 4]
+
+Note: with the **itertools** module, you could instead:
+
+    islice(chain.from_iterable(izip(l, reversed(l))), len(l))

daily_coding_problem_16_20.py renamed to previous/daily_coding_problem_16_20.py

@@ -0,0 +1,20 @@
+def coding_problem_01(stack):
+    """
+    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])
+    [1, 5, 2, 4, 3]
+    >>> coding_problem_01([1, 2, 3, 4, 5, 6])
+    [1, 6, 2, 5, 3, 4]
+
+    Note: with itertools, you could instead islice(chain.from_iterable(izip(l, reversed(l))), len(l))
+    """
+    pass
+
+
+if __name__ == '__main__':
+
+    import doctest
+    doctest.testmod(verbose=True)

daily_coding_problem_21_25.py renamed to previous/daily_coding_problem_21_25.py

@@ -0,0 +1,33 @@
+from collections import deque
+
+
+def coding_problem_01(stack):
+    """
+    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])
+    [1, 5, 2, 4, 3]
+    >>> coding_problem_01([1, 2, 3, 4, 5, 6])
+    [1, 6, 2, 5, 3, 4]
+
+    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]
+        queue.append(stack.pop())
+    for cnt 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]
+            queue.append(queue.popleft())
+        stack.append(queue.popleft())  # S:[1,5,2], Q:[4,3]
+    if queue:
+        stack.append(queue.popleft())
+    return stack
+
+
+if __name__ == '__main__':
+
+    import doctest
+    doctest.testmod(verbose=True)

daily_coding_problem_26_30.py renamed to previous/daily_coding_problem_26_30.py

@@ -0,0 +1,9 @@
+##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])
+    [120, 60, 40, 30, 24]

daily_coding_problem_31_35.py renamed to previous/daily_coding_problem_31_35.py

@@ -0,0 +1,20 @@
+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
+    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])
+    [120, 60, 40, 30, 24]
+    """
+    pass
+
+
+if __name__ == '__main__':
+
+    import doctest
+    doctest.testmod(verbose=True)

daily_coding_problem_36_40.py renamed to previous/daily_coding_problem_36_40.py

@@ -0,0 +1,27 @@
+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
+    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])
+    [120, 60, 40, 30, 24]
+    """
+    forward = [1] * len(l)
+    backward = [1] * len(l)
+    for idx in xrange(1, len(l)):
+
+        forward[idx] = forward[idx - 1] * l[idx - 1]
+        backward[-idx - 1] = backward[-idx] * l[-idx]
+
+    return [f * b for f, b in zip(forward, backward)]
+
+
+if __name__ == '__main__':
+
+    import doctest
+    doctest.testmod(verbose=True)

daily_coding_problem_41_45.py renamed to previous/daily_coding_problem_41_45.py

@@ -0,0 +1,11 @@
+##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

daily_coding_problem_46_50.py renamed to previous/daily_coding_problem_46_50.py

@@ -0,0 +1,22 @@
+from collections import deque
+
+
+def coding_problem_03(s):
+    """
+    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
+    """
+    pass
+
+
+if __name__ == '__main__':
+
+    import doctest
+    doctest.testmod(verbose=True)