fix bugs, add descriptions, and add tests (keon#486)

* fix: test_heap, tree/traversal/__init__

* fix a error in longest_non_repeat.py

* fix bugs, add notes, and add tests

Author: JKLiang9714

algorithms/arrays/longest_non_repeat.py

@@ -16,6 +16,8 @@ def longest_non_repeat_v1(string):
     Find the length of the longest substring
     without repeating characters.
     """
+    if string is None:
+        return 0
     dict = {}
     max_length = 0
     j = 0
@@ -52,18 +54,19 @@ def get_longest_non_repeat_v1(string):
     Return max_len and the substring as a tuple
     """
     if string is None:
-        return 0
+        return 0, ''
     sub_string = ''
-    temp = []
-    max_len = 0
-    for i in string:
-        if i in temp:
-            temp = []
-        temp.append(i)
-        if len(temp) > max_len:
-            max_len = len(temp)
-            sub_string = ''.join(temp)
-    return max_len, sub_string
+    dict = {}
+    max_length = 0
+    j = 0
+    for i in range(len(string)):
+        if string[i] in dict:
+            j = max(dict[string[i]], j)
+        dict[string[i]] = i + 1
+        if i - j + 1 > max_length:
+            max_length = i - j + 1
+            sub_string = string[j: i + 1]
+    return max_length, sub_string
 
 def get_longest_non_repeat_v2(string):
     """
@@ -73,7 +76,7 @@ def get_longest_non_repeat_v2(string):
     Return max_len and the substring as a tuple
     """
     if string is None:
-        return 0
+        return 0, ''
     sub_string = ''
     start, max_len = 0, 0
     used_char = {}

algorithms/backtrack/anagram.py

@@ -1,3 +1,12 @@
+"""
+Given two strings, determine if they are equal after reordering.
+
+Examples:
+"apple", "pleap"  -> True
+"apple", "cherry" -> False
+"""
+
+
 def anagram(s1, s2):
     c1 = [0] * 26
     c2 = [0] * 26

algorithms/backtrack/generate_abbreviations.py

@@ -1,7 +1,7 @@
 """
 given input word, return the list of abbreviations.
 ex)
-word => [1ord, w1rd, wo1d, w2d, 3d, w3 ... etc]
+word => ['word', 'wor1', 'wo1d', 'wo2', 'w1rd', 'w1r1', 'w2d', 'w3', '1ord', '1or1', '1o1d', '1o2', '2rd', '2r1', '3d', '4']
 """
 
 

algorithms/backtrack/letter_combination.py

@@ -2,6 +2,16 @@
 Given a digit string, return all possible letter
 combinations that the number could represent.
 
+A mapping of digit to letters (just like on the telephone buttons) is given below:
+2: "abc"
+3: "def"
+4: "ghi"
+5: "jkl"
+6: "mno"
+7: "pqrs"
+8: "tuv"
+9: "wxyz"
+
 Input:Digit string "23"
 Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
 """

tests/test_array.py

@@ -3,7 +3,7 @@
     flatten_iter, flatten,
     garage,
     josephus,
-    longest_non_repeat_v1, longest_non_repeat_v2,
+    longest_non_repeat_v1, longest_non_repeat_v2, get_longest_non_repeat_v1, get_longest_non_repeat_v2,
     Interval, merge_intervals,
     missing_ranges,
     move_zeros,
@@ -169,6 +169,40 @@ def test_longest_non_repeat_v2(self):
 
         string = "asjrgapa"
         self.assertEqual(longest_non_repeat_v2(string), 6)
+    
+    def test_get_longest_non_repeat_v1(self):
+        
+        string = "abcabcbb"
+        self.assertEqual(get_longest_non_repeat_v1(string), (3, 'abc'))
+
+        string = "bbbbb"
+        self.assertEqual(get_longest_non_repeat_v1(string), (1, 'b'))
+
+        string = "pwwkew"
+        self.assertEqual(get_longest_non_repeat_v1(string), (3, 'wke'))
+
+        string = "dvdf"
+        self.assertEqual(get_longest_non_repeat_v1(string), (3, 'vdf'))
+
+        string = "asjrgapa"
+        self.assertEqual(get_longest_non_repeat_v1(string), (6, 'sjrgap'))
+
+    def test_get_longest_non_repeat_v2(self):
+        
+        string = "abcabcbb"
+        self.assertEqual(get_longest_non_repeat_v2(string), (3, 'abc'))
+
+        string = "bbbbb"
+        self.assertEqual(get_longest_non_repeat_v2(string), (1, 'b'))
+
+        string = "pwwkew"
+        self.assertEqual(get_longest_non_repeat_v2(string), (3, 'wke'))
+
+        string = "dvdf"
+        self.assertEqual(get_longest_non_repeat_v2(string), (3, 'vdf'))
+
+        string = "asjrgapa"
+        self.assertEqual(get_longest_non_repeat_v2(string), (6, 'sjrgap'))
 
 
 class TestMaxOnesIndex(unittest.TestCase):
@@ -314,7 +348,7 @@ def test_three_sum(self):
                             {(-4, 1, 3), (-2, -1, 3), (-1, -1, 2)})
 
 
-class TestSuite(unittest.TestCase):
+class TestTwoSum(unittest.TestCase):
 
     def test_two_sum(self):
 

tests/test_backtrack.py

@@ -6,12 +6,17 @@
     array_sum_combinations,
     unique_array_sum_combinations,
     combination_sum,
+    get_factors,
+    recursive_get_factors,
     find_words,
+    generate_abbreviations,
+    generate_parenthesis_v1,
+    generate_parenthesis_v2,
+    letter_combinations,
     pattern_match,
 )
 
 import unittest
-from algorithms.backtrack.generate_parenthesis import *
 
 
 class TestAddOperator(unittest.TestCase):
@@ -110,6 +115,53 @@ def test_combination_sum(self):
         self.assertEqual(combination_sum(candidates2, target2), answer2)
 
 
+class TestFactorCombinations(unittest.TestCase):
+
+    def test_get_factors(self):
+        target1 = 32
+        answer1 = [
+            [2, 16],
+            [2, 2, 8],
+            [2, 2, 2, 4],
+            [2, 2, 2, 2, 2],
+            [2, 4, 4],
+            [4, 8]
+        ]
+        self.assertEqual(sorted(get_factors(target1)), sorted(answer1))
+        
+        target2 = 12
+        answer2 = [
+            [2, 6],
+            [2, 2, 3],
+            [3, 4]
+        ]
+        self.assertEqual(sorted(get_factors(target2)), sorted(answer2))
+        self.assertEqual(sorted(get_factors(1)), [])
+        self.assertEqual(sorted(get_factors(37)), [])
+    
+    def test_recursive_get_factors(self):
+        target1 = 32
+        answer1 = [
+            [2, 16],
+            [2, 2, 8],
+            [2, 2, 2, 4],
+            [2, 2, 2, 2, 2],
+            [2, 4, 4],
+            [4, 8]
+        ]
+        self.assertEqual(sorted(recursive_get_factors(target1)), sorted(answer1))
+        
+        target2 = 12
+        answer2 = [
+            [2, 6],
+            [2, 2, 3],
+            [3, 4]
+        ]
+        self.assertEqual(sorted(recursive_get_factors(target2)), sorted(answer2))
+        self.assertEqual(sorted(recursive_get_factors(1)), [])
+        self.assertEqual(sorted(recursive_get_factors(37)), [])
+
+
 class TestFindWords(unittest.TestCase):
 
     def test_normal(self):
@@ -158,6 +210,21 @@ def test_repeat(self):
         self.assertTrue(len(find_words(board, words)) == 5)
 
 
+class TestGenerateAbbreviations(unittest.TestCase):
+    def test_generate_abbreviations(self):
+        word1 = "word"
+        answer1 = ['word', 'wor1', 'wo1d', 'wo2', 'w1rd', 'w1r1', 'w2d', 'w3',
+            '1ord', '1or1', '1o1d', '1o2', '2rd', '2r1', '3d', '4']
+        self.assertEqual(sorted(generate_abbreviations(word1)), sorted(answer1))
+
+        word2 = "hello"
+        answer2 = ['hello', 'hell1', 'hel1o', 'hel2', 'he1lo', 'he1l1', 'he2o',
+            'he3', 'h1llo', 'h1ll1', 'h1l1o', 'h1l2', 'h2lo', 'h2l1', 'h3o', 'h4',
+            '1ello', '1ell1', '1el1o', '1el2', '1e1lo', '1e1l1', '1e2o', '1e3',
+            '2llo', '2ll1', '2l1o', '2l2', '3lo', '3l1', '4o', '5']
+        self.assertEqual(sorted(generate_abbreviations(word2)), sorted(answer2))
+
+
 class TestPatternMatch(unittest.TestCase):
 
     def test_pattern_match(self):
@@ -172,6 +239,7 @@ def test_pattern_match(self):
         self.assertTrue(pattern_match(pattern2, string2))
         self.assertFalse(pattern_match(pattern3, string3))
 
+
 class TestGenerateParenthesis(unittest.TestCase):
 
     def test_generate_parenthesis(self):
@@ -180,7 +248,19 @@ def test_generate_parenthesis(self):
         self.assertEqual(generate_parenthesis_v2(2), ['(())', '()()'])
         self.assertEqual(generate_parenthesis_v2(3), ['((()))', '(()())', '(())()', '()(())', '()()()'])
 
+
+class TestLetterCombinations(unittest.TestCase):
+
+    def test_letter_combinations(self):
+        digit1 = "23"
+        answer1 = ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]
+        self.assertEqual(sorted(letter_combinations(digit1)), sorted(answer1))
+
+        digit2 = "34"
+        answer2 = ['dg', 'dh', 'di', 'eg', 'eh', 'ei', 'fg', 'fh', 'fi']
+        self.assertEqual(sorted(letter_combinations(digit2)), sorted(answer2))
+
+
 if __name__ == '__main__':
 
     unittest.main()
-