reorganize arrays

Author: keon

algorithms/arrays/__init__.py

@@ -0,0 +1,13 @@
+from .delete_nth import *
+from .flatten import *
+from .garage import *
+from .josephus import *
+from .longest_non_repeat import *
+from .merge_intervals import *
+from .missing_ranges import *
+from .move_zeros import *
+from .plus_one import *
+from .rotate import *
+from .summarize_ranges import *
+from .three_sum import *
+from .two_sum import *

arrays/delete_nth.py renamed to algorithms/arrays/delete_nth.py

@@ -26,6 +26,6 @@ def flatten_iter(iterable):
     """
     for element in iterable:
         if isinstance(element, Iterable):
-            yield from flatten(element)
+            yield from flatten_iter(element)
         else:
             yield element

arrays/flatten.py renamed to algorithms/arrays/flatten.py

@@ -10,7 +10,7 @@
 """
 
 
-def longest_non_repeat(string):
+def longest_non_repeat_v1(string):
     """
     Finds the length of the longest substring
     without repeating characters.
@@ -27,7 +27,7 @@ def longest_non_repeat(string):
     return max_len
 
 
-def longest_non_repeat_two(string):
+def longest_non_repeat_v2(string):
     """
     Finds the length of the longest substring
     without repeating characters.

arrays/garage.py renamed to algorithms/arrays/garage.py

@@ -64,7 +64,7 @@ def print_intervals(intervals):
         print("".join(res))
 
 
-def merge_v2(intervals):
+def merge_intervals(intervals):
     """ Merges intervals in the form of list. """
     if intervals is None:
         return None

arrays/josephus_problem.py renamed to algorithms/arrays/josephus.py

@@ -7,7 +7,7 @@
 """
 
 
-def plus_one(digits):
+def plus_one_v1(digits):
     """
     :type digits: List[int]
     :rtype: List[int]

arrays/longest_non_repeat.py renamed to algorithms/arrays/longest_non_repeat.py

@@ -6,7 +6,7 @@
 """
 
 
-def summary_ranges(array):
+def summarize_ranges(array):
     """
     :type array: List[int]
     :rtype: List[]

arrays/merge_intervals.py renamed to algorithms/arrays/merge_intervals.py

@@ -1,16 +1,16 @@
-from arrays.delete_nth import delete_nth, delete_nth_naive
-from arrays.flatten import flatten, flatten_iter
-from arrays.garage import garage
-from arrays.josephus_problem import josephus
-from arrays.longest_non_repeat import longest_non_repeat, longest_non_repeat_two
-from arrays.merge_intervals import Interval, merge_v2
-from arrays.missing_ranges import missing_ranges
-from arrays.move_zeros_to_end import move_zeros
-from arrays.plus_one import plus_one, plus_one_v2, plus_one_v3
-from arrays.rotate_array import rotate_v1, rotate_v2, rotate_v3
-from arrays.summary_ranges import summary_ranges
-from arrays.three_sum import three_sum
-from arrays.two_sum import two_sum
+from algorithms.arrays import delete_nth, delete_nth_naive
+from algorithms.arrays import flatten, flatten_iter
+from algorithms.arrays import garage
+from algorithms.arrays import josephus
+from algorithms.arrays import longest_non_repeat_v1, longest_non_repeat_v2
+from algorithms.arrays import Interval, merge_intervals
+from algorithms.arrays import missing_ranges
+from algorithms.arrays import move_zeros
+from algorithms.arrays import plus_one_v1, plus_one_v2, plus_one_v3
+from algorithms.arrays import rotate_v1, rotate_v2, rotate_v3
+from algorithms.arrays import summarize_ranges
+from algorithms.arrays import three_sum
+from algorithms.arrays import two_sum
 
 import unittest
 
@@ -37,15 +37,19 @@ class TestDeleteNth(unittest.TestCase):
 
     def test_delete_nth_naive(self):
 
-        self.assertListEqual(delete_nth_naive([20, 37, 20, 21, 37, 21, 21], n=1),
+        self.assertListEqual(delete_nth_naive(
+                             [20, 37, 20, 21, 37, 21, 21], n=1),
                              [20, 37, 21])
-        self.assertListEqual(delete_nth_naive([1, 1, 3, 3, 7, 2, 2, 2, 2], n=3),
+        self.assertListEqual(delete_nth_naive(
+                             [1, 1, 3, 3, 7, 2, 2, 2, 2], n=3),
                              [1, 1, 3, 3, 7, 2, 2, 2])
-        self.assertListEqual(delete_nth_naive([1, 2, 3, 1, 1, 2, 1, 2, 3, 3, 2, 4, 5, 3, 1], n=3),
+        self.assertListEqual(delete_nth_naive(
+                             [1, 2, 3, 1, 1, 2, 1, 2, 3, 3, 2, 4, 5, 3, 1], n=3),
                              [1, 2, 3, 1, 1, 2, 2, 3, 3, 4, 5])
         self.assertListEqual(delete_nth_naive([], n=5),
                              [])
-        self.assertListEqual(delete_nth_naive([1, 2, 3, 1, 1, 2, 1, 2, 3, 3, 2, 4, 5, 3, 1], n=0),
+        self.assertListEqual(delete_nth_naive(
+                             [1, 2, 3, 1, 1, 2, 1, 2, 3, 3, 2, 4, 5, 3, 1], n=0),
                              [])
 
     def test_delete_nth(self):
@@ -117,32 +121,35 @@ def test_garage(self):
         steps, seq = garage(initial, final)
 
         self.assertEqual(steps, 4)
-        self.assertListEqual(seq, [[0, 2, 3, 1, 4], [2, 0, 3, 1, 4], [2, 3, 0, 1, 4], [0, 3, 2, 1, 4]])
+        self.assertListEqual(seq, [[0, 2, 3, 1, 4],
+                                   [2, 0, 3, 1, 4],
+                                   [2, 3, 0, 1, 4],
+                                   [0, 3, 2, 1, 4]])
 
 
 class TestLongestNonRepeat(unittest.TestCase):
 
-    def test_longest_non_repeat(self):
+    def test_longest_non_repeat_v1(self):
 
         string = "abcabcbb"
-        self.assertEqual(longest_non_repeat(string), 3)
+        self.assertEqual(longest_non_repeat_v1(string), 3)
 
         string = "bbbbb"
-        self.assertEqual(longest_non_repeat(string), 1)
+        self.assertEqual(longest_non_repeat_v1(string), 1)
 
         string = "pwwkew"
-        self.assertEqual(longest_non_repeat(string), 3)
+        self.assertEqual(longest_non_repeat_v1(string), 3)
 
-    def test_longest_non_repeat_two(self):
+    def test_longest_non_repeat_v2(self):
 
         string = "abcabcbb"
-        self.assertEqual(longest_non_repeat_two(string), 3)
+        self.assertEqual(longest_non_repeat_v2(string), 3)
 
         string = "bbbbb"
-        self.assertEqual(longest_non_repeat_two(string), 1)
+        self.assertEqual(longest_non_repeat_v2(string), 1)
 
         string = "pwwkew"
-        self.assertEqual(longest_non_repeat_two(string), 3)
+        self.assertEqual(longest_non_repeat_v2(string), 3)
 
 
 class TestMergeInterval(unittest.TestCase):
@@ -156,9 +163,9 @@ def test_merge(self):
             [Interval(1, 6), Interval(8, 10), Interval(15, 18)]
         )
 
-    def test_merge_v2(self):
+    def test_merge_intervals(self):
         interval_list = [[1, 3], [2, 6], [8, 10], [15, 18]]
-        merged_intervals = merge_v2(interval_list)
+        merged_intervals = merge_intervals(interval_list)
         self.assertEqual(
             merged_intervals,
             [[1, 6], [8, 10], [15, 18]]
@@ -172,7 +179,8 @@ def test_missing_ranges(self):
         arr = [3, 5, 10, 11, 12, 15, 19]
 
         self.assertListEqual(missing_ranges(arr, 0, 20),
-                             [(0, 2), (4, 4), (6, 9), (13, 14), (16, 18), (20, 20)])
+                             [(0, 2), (4, 4), (6, 9),
+                              (13, 14), (16, 18), (20, 20)])
 
         self.assertListEqual(missing_ranges(arr, 6, 100),
                              [(6, 9), (13, 14), (16, 18), (20, 100)])
@@ -191,64 +199,79 @@ def test_move_zeros(self):
 
 class TestPlusOne(unittest.TestCase):
 
-    def test_plus_one(self):
+    def test_plus_one_v1(self):
 
-        self.assertListEqual(plus_one([0]), [1])
-        self.assertListEqual(plus_one([9]), [1, 0])
-        self.assertListEqual(plus_one([1, 0, 9]), [1, 1, 0])
-        self.assertListEqual(plus_one([9, 9, 8, 0, 0, 9]), [9, 9, 8, 0, 1, 0])
-        self.assertListEqual(plus_one([9, 9, 9, 9]), [1, 0, 0, 0, 0])
+        self.assertListEqual(plus_one_v1([0]), [1])
+        self.assertListEqual(plus_one_v1([9]), [1, 0])
+        self.assertListEqual(plus_one_v1([1, 0, 9]), [1, 1, 0])
+        self.assertListEqual(plus_one_v1([9, 9, 8, 0, 0, 9]),
+                             [9, 9, 8, 0, 1, 0])
+        self.assertListEqual(plus_one_v1([9, 9, 9, 9]),
+                             [1, 0, 0, 0, 0])
 
     def test_plus_one_v2(self):
 
         self.assertListEqual(plus_one_v2([0]), [1])
         self.assertListEqual(plus_one_v2([9]), [1, 0])
         self.assertListEqual(plus_one_v2([1, 0, 9]), [1, 1, 0])
-        self.assertListEqual(plus_one_v2([9, 9, 8, 0, 0, 9]), [9, 9, 8, 0, 1, 0])
-        self.assertListEqual(plus_one_v2([9, 9, 9, 9]), [1, 0, 0, 0, 0])
+        self.assertListEqual(plus_one_v2([9, 9, 8, 0, 0, 9]),
+                             [9, 9, 8, 0, 1, 0])
+        self.assertListEqual(plus_one_v2([9, 9, 9, 9]),
+                             [1, 0, 0, 0, 0])
 
     def test_plus_one_v3(self):
 
         self.assertListEqual(plus_one_v3([0]), [1])
         self.assertListEqual(plus_one_v3([9]), [1, 0])
         self.assertListEqual(plus_one_v3([1, 0, 9]), [1, 1, 0])
-        self.assertListEqual(plus_one_v3([9, 9, 8, 0, 0, 9]), [9, 9, 8, 0, 1, 0])
-        self.assertListEqual(plus_one_v3([9, 9, 9, 9]), [1, 0, 0, 0, 0])
+        self.assertListEqual(plus_one_v3([9, 9, 8, 0, 0, 9]),
+                             [9, 9, 8, 0, 1, 0])
+        self.assertListEqual(plus_one_v3([9, 9, 9, 9]),
+                             [1, 0, 0, 0, 0])
 
 
 class TestRotateArray(unittest.TestCase):
 
     def test_rotate_v1(self):
 
-        self.assertListEqual(rotate_v1([1, 2, 3, 4, 5, 6, 7], k=3), [5, 6, 7, 1, 2, 3, 4])
-        self.assertListEqual(rotate_v1([1, 2, 3, 4, 5, 6, 7], k=1), [7, 1, 2, 3, 4, 5, 6])
-        self.assertListEqual(rotate_v1([1, 2, 3, 4, 5, 6, 7], k=7), [1, 2, 3, 4, 5, 6, 7])
+        self.assertListEqual(rotate_v1([1, 2, 3, 4, 5, 6, 7], k=3),
+                                       [5, 6, 7, 1, 2, 3, 4])
+        self.assertListEqual(rotate_v1([1, 2, 3, 4, 5, 6, 7], k=1),
+                                       [7, 1, 2, 3, 4, 5, 6])
+        self.assertListEqual(rotate_v1([1, 2, 3, 4, 5, 6, 7], k=7),
+                                       [1, 2, 3, 4, 5, 6, 7])
         self.assertListEqual(rotate_v1([1, 2], k=111), [2, 1])
 
     def test_rotate_v2(self):
 
-        self.assertListEqual(rotate_v2([1, 2, 3, 4, 5, 6, 7], k=3), [5, 6, 7, 1, 2, 3, 4])
-        self.assertListEqual(rotate_v2([1, 2, 3, 4, 5, 6, 7], k=1), [7, 1, 2, 3, 4, 5, 6])
-        self.assertListEqual(rotate_v2([1, 2, 3, 4, 5, 6, 7], k=7), [1, 2, 3, 4, 5, 6, 7])
+        self.assertListEqual(rotate_v2([1, 2, 3, 4, 5, 6, 7], k=3),
+                                       [5, 6, 7, 1, 2, 3, 4])
+        self.assertListEqual(rotate_v2([1, 2, 3, 4, 5, 6, 7], k=1),
+                                       [7, 1, 2, 3, 4, 5, 6])
+        self.assertListEqual(rotate_v2([1, 2, 3, 4, 5, 6, 7], k=7),
+                                       [1, 2, 3, 4, 5, 6, 7])
         self.assertListEqual(rotate_v2([1, 2], k=111), [2, 1])
 
     def test_rotate_v3(self):
 
-        self.assertListEqual(rotate_v3([1, 2, 3, 4, 5, 6, 7], k=3), [5, 6, 7, 1, 2, 3, 4])
-        self.assertListEqual(rotate_v3([1, 2, 3, 4, 5, 6, 7], k=1), [7, 1, 2, 3, 4, 5, 6])
-        self.assertListEqual(rotate_v3([1, 2, 3, 4, 5, 6, 7], k=7), [1, 2, 3, 4, 5, 6, 7])
+        self.assertListEqual(rotate_v3([1, 2, 3, 4, 5, 6, 7], k=3),
+                                       [5, 6, 7, 1, 2, 3, 4])
+        self.assertListEqual(rotate_v3([1, 2, 3, 4, 5, 6, 7], k=1),
+                                       [7, 1, 2, 3, 4, 5, 6])
+        self.assertListEqual(rotate_v3([1, 2, 3, 4, 5, 6, 7], k=7),
+                                       [1, 2, 3, 4, 5, 6, 7])
         self.assertListEqual(rotate_v3([1, 2], k=111), [2, 1])
 
 
 class TestSummaryRanges(unittest.TestCase):
 
-    def test_summary_ranges(self):
+    def test_summarize_ranges(self):
 
-        self.assertListEqual(summary_ranges([0, 1, 2, 4, 5, 7]),
+        self.assertListEqual(summarize_ranges([0, 1, 2, 4, 5, 7]),
                              [(0, 2), (4, 5), (7, 7)])
-        self.assertListEqual(summary_ranges([-5, -4, -3, 1, 2, 4, 5, 6]),
+        self.assertListEqual(summarize_ranges([-5, -4, -3, 1, 2, 4, 5, 6]),
                              [(-5, -3), (1, 2), (4, 6)])
-        self.assertListEqual(summary_ranges([-2, -1, 0, 1, 2]),
+        self.assertListEqual(summarize_ranges([-2, -1, 0, 1, 2]),
                              [(-2, 2)])