Up to #15

r1cc4rdo · r1cc4rdo · commit 500f63e8d45d · 2019-12-02T00:39:54.000-08:00
diff --git a/previous/README.md b/previous/README.md
@@ -0,0 +1,9 @@
+# Daily coding problem
+
+These are my solutions to https://dailycodingproblem.com, a great resource to practice coding interviews.
+
+I have copied problem definitions and examples verbatim from the one I received, but they might occasionally differ
+from yours when questions have been updated to improve clarity or provide additional tests.
+Notes added after examples are comments of mine.
+
+Pull requests warmly welcomed if you spot issues with any of my solutions!
diff --git a/previous/run_tests.py b/previous/run_tests.py
diff --git a/problems/06/README.md b/problems/06/README.md
@@ -1,17 +1,14 @@
-##Problem 6
+## Problem 6
 
 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_06()
-    >>> for cnt in xrange(0, 4):
-    ...     l.add(cnt)
-    >>> l.get(2) == 2
+    >>> xll = coding_problem_06()
+    >>> for cnt in range(0, 4):
+    ...     xll.add(cnt)
+    >>> xll.get(2) == 2
     True
-
-Note: python does not have actual pointers (id() exists but it is not an actual pointer in all implementations).
-For this reason, we use a python list to simulate memory. Indexes are the addresses in memory. This has the
-unfortunate consequence that the travel logic needs to reside in the List class rather than the Node one.
diff --git a/problems/06/problem_06.py b/problems/06/problem_06.py
@@ -6,15 +6,11 @@ def coding_problem_06():
     and a get(index) which returns the node at index.
     Example:
 
-    >>> l = coding_problem_06()
-    >>> for cnt in xrange(0, 4):
-    ...     l.add(cnt)
-    >>> l.get(2) == 2
+    >>> xll = coding_problem_06()
+    >>> for cnt in range(0, 4):
+    ...     xll.add(cnt)
+    >>> xll.get(2) == 2
     True
-
-    Note: python does not have actual pointers (id() exists but it is not an actual pointer in all implementations).
-    For this reason, we use a python list to simulate memory. Indexes are the addresses in memory. This has the
-    unfortunate consequence that the travel logic needs to reside in the List class rather than the Node one.
     """
     pass
 
diff --git a/problems/06/solution_06.py b/problems/06/solution_06.py
@@ -7,14 +7,13 @@ def coding_problem_06():
     Example:
 
     >>> l = coding_problem_06()
-    >>> for cnt in xrange(0, 4):
+    >>> for cnt in range(0, 4):
     ...     l.add(cnt)
     >>> l.get(2) == 2
     True
 
     Note: python does not have actual pointers (id() exists but it is not an actual pointer in all implementations).
-    For this reason, we use a python list to simulate memory. Indexes are the addresses in memory. This has the
-    unfortunate consequence that the travel logic needs to reside in the List class rather than the Node one.
+    For this reason, we use a python list to simulate memory. Indexes are the addresses in memory.
     """
     class XORLinkedListNode(object):
 
@@ -51,7 +50,7 @@ def add(self, val):
 
         def get(self, index):
             current_index, previous_index, current_node = self.head()
-            for cnt in xrange(index + 1):
+            for cnt in range(index + 1):
                 previous_index, current_index = current_index, current_node.next_node(previous_index)
                 current_node = self.memory[current_index]
             return current_node.val
diff --git a/problems/07/README.md b/problems/07/README.md
@@ -1,9 +1,11 @@
-##Problem 7
+## Problem 7
 
 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_07('111')  # possible interpretations: 'aaa', 'ka', 'ak'
     3
+    
     >>> coding_problem_07('2626')  # 'zz', 'zbf', 'bfz', 'bfbf'
-    4
+    4
diff --git a/problems/08/README.md b/problems/08/README.md
@@ -1,9 +1,9 @@
-##Problem 8
+## Problem 8
 
 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_08(btree)[0]
-    6
+    >>> coding_problem_08(btree)
+    6
diff --git a/problems/08/problem_08.py b/problems/08/problem_08.py
@@ -5,7 +5,7 @@ def coding_problem_08(btree):
     Example:
 
     >>> btree = (0, (0, (0, None, None), (0, (0, None, None), (0, None, None))), (1, None, None))
-    >>> coding_problem_08(btree)[0]
+    >>> coding_problem_08(btree)
     6
     """
     pass
diff --git a/problems/08/solution_08.py b/problems/08/solution_08.py
@@ -1,23 +1,27 @@
-def coding_problem_08(btree):
+def coding_problem_08(bt):
     """
     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_08(btree)[0]
+    >>> coding_problem_08(btree)
     6
     """
-    val, ln, rn = btree
-    if ln is None and rn is None:  # leaf case
-        return 1, True, val
+    def unival_count(btree):
 
-    lcount, is_uni_l, lval = coding_problem_08(ln)
-    rcount, is_uni_r, rval = coding_problem_08(rn)
+        val, ln, rn = btree
+        if ln is None and rn is None:  # leaf case
+            return 1, True, val
 
-    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
+        lcount, is_uni_l, lval = unival_count(ln)
+        rcount, is_uni_r, rval = unival_count(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
+
+    return unival_count(bt)[0]
 
 
 if __name__ == '__main__':
diff --git a/problems/09/README.md b/problems/09/README.md
@@ -1,17 +1,21 @@
-##Problem 9
+## Problem 9
 
 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_09([2, 4, 6, 8])
     12
+    
     >>> coding_problem_09([5, 1, 1, 5])
     10
+
     >>> coding_problem_09([1, 2, 3, 4, 5, 6])
     12
+
     >>> coding_problem_09([-8, 4, -3, 2, 3, 4])
     10
+
     >>> coding_problem_09([2, 4, 6, 2, 5])
-    13
+    13
diff --git a/problems/10/README.md b/problems/10/README.md
@@ -1,9 +1,3 @@
-##Problem 10
+## Problem 10
 
 Implement a job scheduler which takes in a function f and an integer n, and calls f after n milliseconds.
-Example:
-
-    >>> coding_problem_10()
-    Before
-Hello from thread
-After
diff --git a/problems/10/problem_10.py b/problems/10/problem_10.py
@@ -1,11 +1,5 @@
 def coding_problem_10():
     """
     Implement a job scheduler which takes in a function f and an integer n, and calls f after n milliseconds.
-    Example:
-
-    >>> coding_problem_10()
-    Before
-    Hello from thread
-    After
     """
-    pass
+    pass
diff --git a/problems/10/solution_10.py b/problems/10/solution_10.py
@@ -16,14 +16,14 @@ def delayed_execution(f, ms):
         return f()
 
     def hello(name):
-        print 'Hello {}'.format(name)
+        print(f'Hello {name}')
 
     job = Thread(target=delayed_execution, args=(lambda: hello('from thread'), 0.01))
     job.start()
 
-    print 'Before'
+    print('Before')
     time.sleep(0.02)
-    print 'After'
+    print('After')
 
 
 if __name__ == '__main__':
diff --git a/problems/11/README.md b/problems/11/README.md
@@ -1,14 +1,13 @@
-##Problem 11
+## Problem 11
 
 Implement an autocomplete system. That is, given a query string s and a dictionary of all possible query strings,
-return all strings in the dictionary that have s as a prefix. Hint: Try pre-processing the dictionary into a more
+return all strings in the dictionary that have s as a prefix.
+
+**Hint**: Try pre-processing the dictionary into a more
 efficient data structure to speed up queries.
+
 Example:
 
     >>> words = ['able', 'abode', 'about', 'above', 'abuse', 'syzygy']
     >>> coding_problem_11(words, 'abo')
     ['abode', 'about', 'above']
-
-Note: I have been thinking of lots of potential data structures, like hierarchical dictionaries, or hashing.
-Unless otherwise specified, I think space/computation trade-off is not worth doing more than I do below.
-The necessity of using more sophisticated solutions depends on the problem to be solved, overkill here.
diff --git a/problems/11/problem_11.py b/problems/11/problem_11.py
@@ -1,7 +1,3 @@
-from bisect import bisect_left as bisect
-import random
-
-
 def coding_problem_11(strings, prefix):
     """
     Implement an autocomplete system. That is, given a query string s and a dictionary of all possible query strings,
@@ -12,10 +8,6 @@ def coding_problem_11(strings, prefix):
     >>> words = ['able', 'abode', 'about', 'above', 'abuse', 'syzygy']
     >>> coding_problem_11(words, 'abo')
     ['abode', 'about', 'above']
-
-    Note: I have been thinking of lots of potential data structures, like hierarchical dictionaries, or hashing.
-    Unless otherwise specified, I think space/computation trade-off is not worth doing more than I do below.
-    The necessity of using more sophisticated solutions depends on the problem to be solved, overkill here.
     """
     pass
 
diff --git a/problems/11/solution_11.py b/problems/11/solution_11.py
@@ -1,5 +1,4 @@
 from bisect import bisect_left as bisect
-import random
 
 
 def coding_problem_11(strings, prefix):
@@ -13,9 +12,9 @@ def coding_problem_11(strings, prefix):
     >>> coding_problem_11(words, 'abo')
     ['abode', 'about', 'above']
 
-    Note: I have been thinking of lots of potential data structures, like hierarchical dictionaries, or hashing.
-    Unless otherwise specified, I think space/computation trade-off is not worth doing more than I do below.
-    The necessity of using more sophisticated solutions depends on the problem to be solved, overkill here.
+    Note: the complexity of the code below is already logarithmic. Faster speed are possible with hierarchical
+    dictionaries or hashing scheme, if we are willing to pay a space complexity trade-off. Using more sophisticated
+    approaches must be justified over actual requirements, overkill here.
     """
     dictionary = [s.lower() for s in sorted(strings)]
     next_prefix = prefix + 'a' if prefix[-1] == 'z' else prefix[:-1] + chr(ord(prefix[-1]) + 1)
diff --git a/problems/12/README.md b/problems/12/README.md
@@ -1,18 +1,20 @@
-##Problem 12
+## Problem 12
 
 There exists a staircase with N steps, and you can climb up either 1 or 2 steps at a time. Given N, write a
 function that returns the number of unique ways you can climb the staircase. The order of the steps matters.
+
 For example, if N is 4, then there are 5 unique ways:
 
-1, 1, 1, 1
-2, 1, 1
-1, 2, 1
-1, 1, 2
-2, 2
+    1, 1, 1, 1
+    2, 1, 1
+    1, 2, 1
+    1, 1, 2
+    2, 2
 
 What if, instead of being able to climb 1 or 2 steps at a time, you could climb any number from a set of positive
 integers X? For example, if X = {1, 3, 5}, you could climb 1, 3, or 5 steps at a time.
+
 Example:
 
-    >>> coding_problem_12(4, [1, 2])
+    >>> coding_problem_12(budget=4, choices=[1, 2])
     5
diff --git a/problems/12/problem_12.py b/problems/12/problem_12.py
@@ -1,7 +1,3 @@
-from bisect import bisect_left as bisect
-import random
-
-
 def coding_problem_12(budget, choices):
     """
     There exists a staircase with N steps, and you can climb up either 1 or 2 steps at a time. Given N, write a
@@ -18,7 +14,7 @@ def coding_problem_12(budget, choices):
     integers X? For example, if X = {1, 3, 5}, you could climb 1, 3, or 5 steps at a time.
     Example:
 
-    >>> coding_problem_12(4, [1, 2])
+    >>> coding_problem_12(budget=4, choices=[1, 2])
     5
     """
     pass
diff --git a/problems/12/solution_12.py b/problems/12/solution_12.py
@@ -1,7 +1,3 @@
-from bisect import bisect_left as bisect
-import random
-
-
 def coding_problem_12(budget, choices):
     """
     There exists a staircase with N steps, and you can climb up either 1 or 2 steps at a time. Given N, write a
diff --git a/problems/13/README.md b/problems/13/README.md
@@ -1,10 +1,12 @@
-##Problem 13
+## Problem 13
 
 Given an integer k and a string s, find the length of the longest substring that contains at most k distinct
 characters.
+
 Example:
 
     >>> coding_problem_13('abcba', 2)  # longest substring with at most 2 distinct characters is 'bcb'
     3
+    
     >>> coding_problem_13('edabccccdccba', 3)  # 'bccccdccb'
-    9
+    9
diff --git a/problems/13/problem_13.py b/problems/13/problem_13.py
@@ -1,7 +1,3 @@
-from bisect import bisect_left as bisect
-import random
-
-
 def coding_problem_13(s, k):
     """
     Given an integer k and a string s, find the length of the longest substring that contains at most k distinct
diff --git a/problems/13/solution_13.py b/problems/13/solution_13.py
@@ -1,7 +1,3 @@
-from bisect import bisect_left as bisect
-import random
-
-
 def coding_problem_13(s, k):
     """
     Given an integer k and a string s, find the length of the longest substring that contains at most k distinct
diff --git a/problems/14/README.md b/problems/14/README.md
@@ -1,6 +1,7 @@
-##Problem 14
+## Problem 14
+
+The area of a circle is defined as πr². Estimate π to 3 decimal places using a Monte Carlo method.
 
-The area of a circle is defined as $\pi r^2$. Estimate $\pi$ to 3 decimal places using a Monte Carlo method.
 Example:
 
     >>> import math
@@ -9,7 +10,3 @@ Example:
     >>> pi_approx = coding_problem_14()
     >>> abs(math.pi - pi_approx) < 1e-2
     True
-
-Note: the unit test above is not testing for 3 decimal places, but only 2. Getting to 3 significant digits would
-require too much time each time, since convergence is exponentially slow. Also priming the random number generator
-to avoid random failure for unlucky distributions of samples.
diff --git a/problems/14/problem_14.py b/problems/14/problem_14.py
diff --git a/problems/14/solution_14.py b/problems/14/solution_14.py
diff --git a/problems/15/README.md b/problems/15/README.md
diff --git a/problems/15/problem_15.py b/problems/15/problem_15.py
diff --git a/problems/15/solution_15.py b/problems/15/solution_15.py
diff --git a/problems/run_tests.py b/problems/run_tests.py
diff --git a/tools/split.py b/tools/split.py

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ def coding_problem_08(btree):`
`5`	`5`	`Example:`
`6`	`6`
`7`	`7`	`>>> btree = (0, (0, (0, None, None), (0, (0, None, None), (0, None, None))), (1, None, None))`
`8`		`- >>> coding_problem_08(btree)[0]`
	`8`	`+ >>> coding_problem_08(btree)`
`9`	`9`	`6`
`10`	`10`	`"""`
`11`	`11`	`pass`
Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,21 @@`
`1`		`-##Problem 9`
	`1`	`+## Problem 9`
`2`	`2`
`3`	`3`	`Given a list of integers, write a function that returns the largest sum of non-adjacent numbers.`
`4`	`4`	`The "largest sum of non-adjacent numbers" is the sum of any subset of non-contiguous elements.`
`5`		`-Solution courtesy of Kye Jiang (https://github.com/Jedshady).`
	`5`	`+`
`6`	`6`	`Examples:`
`7`	`7`
`8`	`8`	`>>> coding_problem_09([2, 4, 6, 8])`
`9`	`9`	`12`
	`10`	`+`
`10`	`11`	`>>> coding_problem_09([5, 1, 1, 5])`
`11`	`12`	`10`
	`13`	`+`
`12`	`14`	`>>> coding_problem_09([1, 2, 3, 4, 5, 6])`
`13`	`15`	`12`
	`16`	`+`
`14`	`17`	`>>> coding_problem_09([-8, 4, -3, 2, 3, 4])`
`15`	`18`	`10`
	`19`	`+`
`16`	`20`	`>>> coding_problem_09([2, 4, 6, 2, 5])`
`17`		`- 13`
	`21`	`+ 13`