Refactoring

Author: suyash248

Array/maxAndMinProductSubArray.py

@@ -31,4 +31,4 @@ def max_and_min_product_subarray(arr):
 if __name__ == "__main__":
     arr = [1, 0, -4, -2, 2, 3, -2]
     max_n_min = max_and_min_product_subarray(arr)
-    print "Product of max-product-sub-array is {} & product of min-product-sub-array is {}".format(*max_n_min)
+    print("Product of max-product-sub-array is {} & product of min-product-sub-array is {}".format(*max_n_min))

Array/maximizeProfit.py

@@ -68,9 +68,9 @@ def maximize_profit(prices):
     currency = "INR"
     prices = [2, 11, 10, 6, 9, 7, 16, 8, 3, 4, 14, 1, 10, 2]
     res = maximize_profit(prices)
-    print """Maximum profit is {max_profit}, 
+    print("""Maximum profit is {max_profit}, 
     Buy at price {currency} {buy_price} at index/time {buy_index}.
     Sell at price {currency} {sell_price} at index/time {sell_index}
     """.format(max_profit=res['max_profit'], currency=currency,
                        buy_price=res['buy']['price'], buy_index=res['buy']['index'],
-                       sell_price=res['sell']['price'], sell_index=res['sell']['index'])
+                       sell_price=res['sell']['price'], sell_index=res['sell']['index']))

Array/stockSpanProblem.py

@@ -24,5 +24,5 @@ def stock_span(prices):
 if __name__ == '__main__':
     prices = [10, 4, 5, 90, 120, 80]
     spans = stock_span(prices)
-    print "Prices:", prices
-    print "Spans:", spans
+    print("Prices:", prices)
+    print("Spans:", spans)

Heap/BinaryHeap/Heap.py

@@ -57,13 +57,13 @@ def is_empty(self):
         return self.heap_size <= 0
 
     def print_heap(self):
-        for idx in xrange(0, self.heap_size):
+        for idx in range(0, self.heap_size):
             l_idx = Heap.left(idx)
             r_idx = Heap.right(idx)
 
             curr_elt = self.get(idx)
             l_elt = self.get(l_idx)
             r_elt = self.get(r_idx)
 
-            print "{current} : left -> {left} | right -> {right}".format(current=curr_elt,
-                                                                         left=l_elt, right=r_elt)
+            print("{current} : left -> {left} | right -> {right}".format(current=curr_elt,
+                                                                         left=l_elt, right=r_elt))

Heap/BinaryHeap/maxHeap.py

@@ -1,5 +1,5 @@
 from Array import swap
-from Heap import Heap
+from Heap.BinaryHeap import Heap
 from copy import deepcopy
 
 class MaxHeap(Heap):
@@ -49,20 +49,20 @@ def build_heap(self, harr):
         :return:
         """
         if len(harr) > self.capacity:
-            print '''Can't build heap as the array contains {} elements, 
-                        which is more than specified capacity({}) of heap'''.format(len(harr), self.capacity)
+            print('''Can't build heap as the array contains {} elements, 
+                        which is more than specified capacity({}) of heap'''.format(len(harr), self.capacity))
 
         self.harr = harr
         self.heap_size = len(harr)
-        half = self.heap_size / 2
+        half = int(self.heap_size / 2)
 
-        for idx in xrange(half, -1, -1): # for idx=half; idx<=0; idx++
+        for idx in range(half, -1, -1): # for idx=half; idx<=0; idx++
             self.max_heapify(idx)
 
     # Time Complexity: O(log(n))
     def insert(self, elt):
         if self.is_full():
-            print "Heap is full, can't insert key"
+            print("Heap is full, can't insert key")
             return False
 
         # First insert the new key at the end.
@@ -83,14 +83,14 @@ def insert(self, elt):
     # Time Complexity: O(1)
     def get_max(self):
         if self.is_empty():
-            print "Heap is empty"
+            print("Heap is empty")
             return False
         return deepcopy(self.harr[0])
 
     # Time Complexity: O(log(n))
     def delete_max(self):
         if self.is_empty():
-            print "Heap is empty"
+            print("Heap is empty")
             return False
 
         root = self.harr[0]
@@ -113,13 +113,13 @@ def delete(self, idx):
     mh = MaxHeap(12)
     mh.build_heap(harr)
 
-    print "Array {} is converted to Max-Heap {}".format(harr_copy, harr)
+    print("Array {} is converted to Max-Heap {}".format(harr_copy, harr))
 
     elt = 1
     mh.insert(elt)
-    print "Inserted {}:".format(elt), harr
+    print("Inserted {}:".format(elt), harr)
 
     d_elt = mh.delete_max()
-    print "Deleted maximum element(root)=>{}:".format(d_elt), harr
+    print("Deleted maximum element(root)=>{}:".format(d_elt), harr)
 
     #mh.print_heap()

Heap/BinaryHeap/minHeap.py

@@ -1,5 +1,5 @@
 from Array import swap
-from Heap import Heap
+from Heap.BinaryHeap import Heap
 from copy import deepcopy
 
 class MinHeap(Heap):
@@ -10,7 +10,7 @@ def min_heapify(self, index):
         Algorithm: We move downwards(bottom) in the heap in each step until heap is in it's correct form.
 
         Min-Heapify (A, i):
-            left = 2*i // = means "assignment"
+            left = 2*i          # `=` means `assignment`
             right = 2*i + 1
             smallest = i
 
@@ -44,28 +44,28 @@ def min_heapify(self, index):
     def build_heap(self, harr):
         """
         Build-Min-Heap (A):
-            for i=floor(length[A]/2); i<=0; i--:
+            for i=floor(length[A]/2); i>=0; i--:
                 Min-Heapify(A, i)
         :param harr:
         :return:
         """
 
         if len(harr) > self.capacity:
-            print '''Can't build heap as the array contains {} elements, 
-                        which is more than specified capacity({}) of heap'''.format(len(harr), self.capacity)
+            print('''Can't build heap as the array contains {} elements, 
+                        which is more than specified capacity({}) of heap'''.format(len(harr), self.capacity))
 
         self.harr = harr
         self.heap_size = len(harr)
-        half = self.heap_size/2
+        half = int(self.heap_size/2)
 
-        for idx in xrange(half, -1, -1): # for idx=half; idx<=0; idx++
+        for idx in range(half, -1, -1): # for idx=half; idx>=0; idx--
             self.min_heapify(idx)
         return deepcopy(self.harr)
 
     # Time Complexity: O(log(n))
     def insert(self, elt):
         if self.is_full():
-            print "Heap is full, can't insert key"
+            print("Heap is full, can't insert key")
             return False
 
         # First insert the new key at the end.
@@ -86,14 +86,14 @@ def insert(self, elt):
     # Time Complexity: O(1)
     def get_min(self):
         if self.is_empty():
-            print "Heap is empty"
+            print ("Heap is empty")
             return False
         return deepcopy(self.harr[0])
 
     # Time Complexity: O(log(n))
     def delete_min(self):
         if self.is_empty():
-            print "Heap is empty"
+            print ("Heap is empty")
             return False
 
         root = self.harr[0]
@@ -116,13 +116,13 @@ def delete(self, idx):
     mh = MinHeap(12)
     mh.build_heap(harr)
 
-    print "Array {} is converted to Min-Heap {}".format(harr_copy, harr)
+    print("Array {} is converted to Min-Heap {}".format(harr_copy, harr))
 
     elt = 1
     mh.insert(elt)
-    print "Inserted {}:".format(elt), harr
+    print("Inserted {}:".format(elt), harr)
 
     d_elt = mh.delete_min()
-    print "Deleted minimum element(root)=>{}:".format(d_elt), harr
+    print("Deleted minimum element(root)=>{}:".format(d_elt), harr)
 
     #mh.print_heap()

Queues/PriorityQueue/pq.py

@@ -1,7 +1,6 @@
 from Heap.BinaryHeap.maxHeap import MaxHeap
 from copy import deepcopy
 
-
 class PriorityQueue(object):
     def __init__(self, pq_capacity=10):
         self._pq_capacity_ = pq_capacity
@@ -12,7 +11,7 @@ def __init__(self, pq_capacity=10):
     def insert(self, item, priority):
         res = False
         if self.is_full():
-            print "Priority queue is full, please delete older items in order to insert newer ones."
+            print("Priority queue is full, please delete older items in order to insert newer ones.")
             return res
         e = Entry(item, priority)
         res = self._pq_heap_.insert(e)
@@ -24,7 +23,7 @@ def insert(self, item, priority):
     def delete_item_with_highest_priority(self):
         res = False
         if self.is_empty():
-            print "Priority queue is empty"
+            print("Priority queue is empty")
             return res
         res = self._pq_heap_.delete_max()
         if isinstance(res, bool) and res == False:
@@ -36,7 +35,7 @@ def delete_item_with_highest_priority(self):
     # Time Complexity : O(1)
     def get_item_with_highest_priority(self):
         if self.is_empty():
-            print "Priority queue is empty"
+            print("Priority queue is empty")
             return False
         return self._pq_heap_.get_max()
 
@@ -104,9 +103,9 @@ def test():
         mh_test.insert(priority)
         pq.insert(item, priority)
 
-    print pq.pq_arr()
-    print mh_test.heap_arr()
-    print "Element with highest priority: ", pq.get_item_with_highest_priority()
+    print(pq.pq_arr())
+    print(mh_test.heap_arr())
+    print("Element with highest priority: ", pq.get_item_with_highest_priority())
 
 
 if __name__ == '__main__':
@@ -122,40 +121,40 @@ def test():
         5. Get the size and capacity of priority queue.
         6. Stop.
     """
-    print menu
+    print(menu)
     while True:
         try:
             choice = input("Please enter your choice - ")
         except:
-            print "Incorrect choice, please select from menu."
+            print("Incorrect choice, please select from menu.")
             continue
         try:
             if choice == 1:
-                item_priority = raw_input("Enter item & priority separated by a white-space - ")
+                item_priority = input("Enter item & priority separated by a white-space - ")
                 item_priority = item_priority.split(" ")
                 item = item_priority[0].strip()
                 priority = item_priority[1].strip()
                 res = pq.insert(item, priority)
-                print res
+                print(res)
                 continue
             if choice == 2:
-                print pq.pq_print()
+                print(pq.pq_print())
                 continue
             if choice == 3:
                 res = pq.get_item_with_highest_priority()
-                print res
+                print(res)
                 continue
             if choice == 4:
                 res = pq.delete_item_with_highest_priority()
-                print res
+                print(res)
                 continue
             if choice == 5:
-                print "Size : {} | Capacity: {}".format(pq.pq_size(), pq.pq_capacity())
+                print("Size : {} | Capacity: {}".format(pq.pq_size(), pq.pq_capacity()))
                 continue
             if choice == 6:
                 break
         except Exception as ex:
-            print "Error occurred while performing last operation(choice: {}):".format(choice)
-            print ex.message, ex.args
+            print("Error occurred while performing last operation(choice: {}):".format(choice))
+            print(ex.message, ex.args)
 
-        print menu
+        print(menu)

Tree/allPathsRootToLeaves.py

@@ -1,4 +1,5 @@
 from Tree.commons import insert, print_tree, is_leaf
+from copy import deepcopy
 
 def all_paths_root_to_leaves_v1(root):
     if root == None:
@@ -24,6 +25,17 @@ def all_paths_root_to_leaves_v2(root, path, path_len):
         all_paths_root_to_leaves_v2(root.left, path, path_len)
         all_paths_root_to_leaves_v2(root.right, path, path_len)
 
+def all_paths_root_to_leaves_v3(root, path = []):
+    if root is None: return
+    path.append(root.key)
+    if is_leaf(root):
+        for elt in path:
+            print(elt, end=',')
+        print('\n')
+    else:
+        all_paths_root_to_leaves_v3(root.left, deepcopy(path))
+        all_paths_root_to_leaves_v3(root.right, deepcopy(path))
+
 # Driver program to test above function
 if __name__ == "__main__":
     """ Let us create following BST
@@ -51,4 +63,7 @@ def all_paths_root_to_leaves_v2(root, path, path_len):
     all_paths_root_to_leaves_v1(root)
 
     print("\n-------- Using v2 ---------\n")
-    all_paths_root_to_leaves_v2(root, [None] * 20, 0)
+    all_paths_root_to_leaves_v2(root, [None] * 20, 0)
+
+    print("\n-------- Using v3 ---------\n")
+    all_paths_root_to_leaves_v3(root)

Tree/distanceFromRoot.py

@@ -32,14 +32,14 @@ def distance_from_root_v2(root, key, level=0):
         distance_v2 = level
         return level
 
-    left = distance_from_root_v2(root.left, key, level+1)
+    ld = distance_from_root_v2(root.left, key, level+1)
     # if key found in left-subtree, return it.
-    if left != -1:
-        return left
+    if ld != -1:
+        return ld
     # if key is not found in left-subtree, try searching for key in right-subtree
     else:
-        right = distance_from_root_v2(root.right, key, level+1)
-        return right
+        rd = distance_from_root_v2(root.right, key, level+1)
+        return rd
 
 
 def distance_from_root_v3(root, key, distance=0):