clean up backtrack and move tests to test_backtest (keon#306)

* clean up backtrack and add tests

* fix typos in backtrack

Author: keon

algorithms/backtrack/__init__.py

@@ -0,0 +1,15 @@
+from .add_operators import *
+from .anagram import *
+from .array_sum_combinations import *
+from .combination_sum import *
+from .factor_combinations import *
+from .find_words import *
+from .generate_abbreviations import *
+from .generate_parenthesis import *
+from .letter_combination import *
+from .palindrome_partitioning import *
+from .pattern_match import *
+from .permute_unique import *
+from .permute import *
+from .subsets_unique import *
+from .subsets import *

algorithms/backtrack/add_operators.py

@@ -0,0 +1,45 @@
+"""
+Given a string that contains only digits 0-9 and a target value,
+return all possibilities to add binary operators (not unary) +, -, or *
+between the digits so they prevuate to the target value.
+
+Examples:
+"123", 6 -> ["1+2+3", "1*2*3"]
+"232", 8 -> ["2*3+2", "2+3*2"]
+"105", 5 -> ["1*0+5","10-5"]
+"00", 0 -> ["0+0", "0-0", "0*0"]
+"3456237490", 9191 -> []
+"""
+
+
+def add_operators(num, target):
+    """
+    :type num: str
+    :type target: int
+    :rtype: List[str]
+    """
+
+    def dfs(res, path, num, target, pos, prev, multed):
+        if pos == len(num):
+            if target == prev:
+                res.append(path)
+            return
+        for i in range(pos, len(num)):
+            if i != pos and num[pos] == '0':  # all digits have to be used
+                break
+            cur = int(num[pos:i+1])
+            if pos == 0:
+                dfs(res, path + str(cur), num, target, i+1, cur, cur)
+            else:
+                dfs(res, path + "+" + str(cur), num, target,
+                    i+1, prev + cur, cur)
+                dfs(res, path + "-" + str(cur), num, target,
+                    i+1, prev - cur, -cur)
+                dfs(res, path + "*" + str(cur), num, target,
+                    i+1, prev - multed + multed * cur, multed * cur)
+
+    res = []
+    if not num:
+        return res
+    dfs(res, "", num, target, 0, 0, 0)
+    return res

algorithms/backtrack/anagram.py

@@ -1,31 +1,3 @@
-import unittest
-
-def all_perms_iter(elements):
-    """
-        iterator: returns a perumation by each call. 
-    """
-    if len(elements) <=1:
-        yield elements
-    else:
-        for perm in all_perms_iter(elements[1:]):
-            for i in range(len(elements)):
-                yield perm[:i] + elements[0:1] + perm[i:]
-
-
-def all_perms(elements):
-    """
-        returns a list with the permuations.
-    """
-    if len(elements) <=1:
-        return elements
-    else:
-        tmp = []
-        for perm in all_perms(elements[1:]):
-            for i in range(len(elements)):
-                tmp.append(perm[:i] + elements[0:1] + perm[i:])
-        return tmp
-
-
 def anagram(s1, s2):
     c1 = [0] * 26
     c2 = [0] * 26
@@ -39,24 +11,3 @@ def anagram(s1, s2):
         c2[pos] = c2[pos] + 1
 
     return c1 == c2
-
-
-class TestSuite (unittest.TestCase):
-
-    def test_all_perms(self):
-        perms = ['abc', 'bac', 'bca', 'acb', 'cab', 'cba']
-        self.assertEqual(perms, all_perms("abc"))
-
-    def test_all_perms_iter(self):
-        it = all_perms_iter("abc")
-        perms = ['abc', 'bac', 'bca', 'acb', 'cab', 'cba']
-        for i in range(len(perms)):
-            self.assertEqual(perms[i], next(it))
-
-    def test_angram(self):
-        self.assertTrue(anagram('apple', 'pleap'))
-        self.assertFalse(anagram("apple", "cherry"))
-
-
-if __name__ == "__main__":
-    unittest.main()

algorithms/backtrack/array_sum_combinations.py

@@ -5,7 +5,7 @@
 /*
 A = [1, 2, 3, 3]
 B = [2, 3, 3, 4]
-C = [1, 2, 2, 2]
+C = [2, 3, 3, 4]
 target = 7
 */
 
@@ -16,79 +16,69 @@
 import itertools
 from functools import partial
 
-A = [1, 2, 3, 3]
-B = [2, 3, 3, 4]
-C = [1, 2, 2, 2]
-target = 7
-
-
-def construct_candidates(constructed_sofar):
-    global A, B, C
-    array = A
-    if 1 == len(constructed_sofar):
-        array = B
-    elif 2 == len(constructed_sofar):
-        array = C
-    return array
-
-
-def over(constructed_sofar):
-    global target
-    sum = 0
-    to_stop, reached_target = False, False
-    for elem in constructed_sofar:
-        sum += elem
-    if sum >= target or len(constructed_sofar) >= 3:
-        to_stop = True
-        if sum == target and 3 == len(constructed_sofar):
-            reached_target = True
-
-    return to_stop, reached_target
-
-
-def backtrack(constructed_sofar):
-    to_stop, reached_target = over(constructed_sofar)
-    if to_stop:
-        if reached_target:
-            print(constructed_sofar)
-        return
-    candidates = construct_candidates(constructed_sofar)
-    for candidate in candidates:
-        constructed_sofar.append(candidate)
-        backtrack(constructed_sofar[:])
-        constructed_sofar.pop()
-
-
-backtrack([])
-
-
-# Complexity: O(n(m+p))
-
-# 1. Sort all the arrays - a,b,c. - This will improve average time complexity.
-# 2. If c[i] < Sum, then look for Sum - c[i] in array a and b. When pair found,
-#    insert c[i], a[j] & b[k] into the result list. This can be done in O(n).
-# 3. Keep on doing the above procedure while going through complete c array.
-
-
-A = [1, 2, 3, 3]
-B = [2, 3, 3, 4]
-C = [1, 2, 2, 2]
-S = 7
-
-
-def check_sum(n, *nums):
-    if sum(x for x in nums) == n:
-        return (True, nums)
-    else:
-        return (False, nums)
-
-
-pro = itertools.product(A, B, C)
-func = partial(check_sum, S)
-sums = list(itertools.starmap(func, pro))
 
-res = set()
-for s in sums:
-    if s[0] is True and s[1] not in res:
-        res.add(s[1])
-print(res)
+def array_sum_combinations(A, B, C, target):
+
+    def over(constructed_sofar):
+        sum = 0
+        to_stop, reached_target = False, False
+        for elem in constructed_sofar:
+            sum += elem
+        if sum >= target or len(constructed_sofar) >= 3:
+            to_stop = True
+            if sum == target and 3 == len(constructed_sofar):
+                reached_target = True
+        return to_stop, reached_target
+
+    def construct_candidates(constructed_sofar):
+        array = A
+        if 1 == len(constructed_sofar):
+            array = B
+        elif 2 == len(constructed_sofar):
+            array = C
+        return array
+
+    def backtrack(constructed_sofar=[], res=[]):
+        to_stop, reached_target = over(constructed_sofar)
+        if to_stop:
+            if reached_target:
+                res.append(constructed_sofar)
+            return
+        candidates = construct_candidates(constructed_sofar)
+
+        for candidate in candidates:
+            constructed_sofar.append(candidate)
+            backtrack(constructed_sofar[:], res)
+            constructed_sofar.pop()
+
+    res = []
+    backtrack([], res)
+    return res
+
+
+def unique_array_sum_combinations(A, B, C, target):
+    """
+    1. Sort all the arrays - a,b,c. - This improves average time complexity.
+    2. If c[i] < Sum, then look for Sum - c[i] in array a and b.
+       When pair found, insert c[i], a[j] & b[k] into the result list.
+       This can be done in O(n).
+    3. Keep on doing the above procedure while going through complete c array.
+
+    Complexity: O(n(m+p))
+    """
+    def check_sum(n, *nums):
+        if sum(x for x in nums) == n:
+            return (True, nums)
+        else:
+            return (False, nums)
+
+    pro = itertools.product(A, B, C)
+    func = partial(check_sum, target)
+    sums = list(itertools.starmap(func, pro))
+
+    res = set()
+    for s in sums:
+        if s[0] is True and s[1] not in res:
+            res.add(s[1])
+
+    return list(res)

algorithms/backtrack/combination_sum.py

@@ -16,18 +16,18 @@
 """
 
 
-def combination_sum(self, candidates, target):
+def combination_sum(candidates, target):
+
+    def dfs(nums, target, index, path, res):
+        if target < 0:
+            return  # backtracking
+        if target == 0:
+            res.append(path)
+            return
+        for i in range(index, len(nums)):
+            dfs(nums, target-nums[i], i, path+[nums[i]], res)
+
     res = []
     candidates.sort()
-    self.dfs(candidates, target, 0, [], res)
+    dfs(candidates, target, 0, [], res)
     return res
-
-
-def dfs(self, nums, target, index, path, res):
-    if target < 0:
-        return  # backtracking
-    if target == 0:
-        res.append(path)
-        return
-    for i in range(index, len(nums)):
-        self.dfs(nums, target-nums[i], i, path+[nums[i]], res)

algorithms/backtrack/expression_add_operators.py

@@ -3,7 +3,8 @@
 
 8 = 2 x 2 x 2;
   = 2 x 4.
-Write a function that takes an integer n and return all possible combinations of its factors.
+Write a function that takes an integer n
+and return all possible combinations of its factors.
 
 Note:
 You may assume that n is always positive.
@@ -49,7 +50,7 @@ def get_factors(n):
 
 
 # Recursive:
-def get_factors_recur(n):
+def recursive_get_factors(n):
 
     def factor(n, i, combi, combis):
         while i * i <= n: