Mathematics, Data Structures

Author: sahmed09

Data Structures/Queues/QueueUsingTwoStacks.py

@@ -0,0 +1,38 @@
+# queue = []
+#
+# for i in range(int(input())):
+#     query = list(map(int, input().split()))
+#     if query[0] == 1:
+#         queue.append(query[1])
+#     elif query[0] == 2:
+#         if len(queue) != 0:
+#             queue.pop(0)
+#     else:
+#         print(queue[0])
+
+# Using two stacks:
+stack_in, stack_out = [], []
+
+for i in range(int(input())):
+    curr_inst = list(map(int, input().split(" ")))
+
+    if curr_inst[0] == 1:
+        stack_in.append(curr_inst[1])
+
+    elif curr_inst[0] == 2:
+        # If stack_out is not empty then pop from it
+        if stack_out:
+            stack_out.pop()
+            continue
+        else:
+            # Move everything to the out stack:
+            while stack_in:
+                stack_out.append(stack_in.pop())
+            stack_out.pop()
+            continue
+
+    else:
+        if not stack_out:
+            while stack_in:
+                stack_out.append(stack_in.pop())
+        print(stack_out[-1])

Data Structures/Stacks/BalancedBrackets.py

@@ -0,0 +1,35 @@
+def isBalanced(s):
+    bracket_dict = {')': '(', ']': '[', '}': '{'}
+    stack = []
+    for x in s:
+        if x in bracket_dict and stack and bracket_dict.get(x) == stack[-1]:
+            # bracket_dict.get(x) similar to bracket_dict[x] -> both return the value for key
+            stack.pop()
+        else:
+            stack.append(x)
+
+    return "NO" if stack else "YES"
+
+
+# def isBalanced(s):
+#     n = -1
+#     while len(s) != n:
+#         n = len(s)
+#         s = s.replace("()", "")
+#         s = s.replace("[]", "")
+#         s = s.replace("{}", "")
+#
+#     if len(s) == 0:
+#         return "YES"
+#     else:
+#         return "NO"
+
+
+if __name__ == '__main__':
+    t = int(input())
+
+    for t_itr in range(t):
+        s = input()
+
+        result = isBalanced(s)
+        print(result)

Data Structures/Stacks/EqualStacks.py

@@ -0,0 +1,51 @@
+# def equalStacks(h1, h2, h3):
+#     sum1, sum2, sum3 = map(sum, (h1, h2, h3))
+#     while h1 and h2 and h3:
+#         minimum = min(sum1, sum2, sum3)
+#         while sum1 > minimum:
+#             sum1 -= h1.pop(0)
+#         while sum2 > minimum:
+#             sum2 -= h2.pop(0)
+#         while sum3 > minimum:
+#             sum3 -= h3.pop(0)
+#         if sum1 == sum2 == sum3:
+#             return sum1
+#     return 0
+
+
+def equalStacks(h1, h2, h3):
+    h1 = h1[::-1]
+    h2 = h2[::-1]
+    h3 = h3[::-1]
+
+    sum_h1 = sum(h1)
+    sum_h2 = sum(h2)
+    sum_h3 = sum(h3)
+
+    while not sum_h1 == sum_h2 == sum_h3:
+        if sum_h1 > sum_h2 or sum_h1 > sum_h3:
+            t = h1.pop()
+            sum_h1 -= t
+        if sum_h2 > sum_h1 or sum_h2 > sum_h3:
+            t = h2.pop()
+            sum_h2 -= t
+        if sum_h3 > sum_h1 or sum_h3 > sum_h2:
+            t = h3.pop()
+            sum_h3 -= t
+
+    return sum_h1
+
+
+if __name__ == '__main__':
+    first_multiple_input = input().rstrip().split()
+
+    n1 = int(first_multiple_input[0])
+    n2 = int(first_multiple_input[1])
+    n3 = int(first_multiple_input[2])
+
+    h1 = list(map(int, input().rstrip().split()))
+    h2 = list(map(int, input().rstrip().split()))
+    h3 = list(map(int, input().rstrip().split()))
+
+    result = equalStacks(h1, h2, h3)
+    print(result)

Data Structures/Stacks/GameOfTwoStacks.py

@@ -0,0 +1,72 @@
+def twoStacks(x, a, b):
+    a.reverse()
+    b.reverse()
+    stack = []
+    total, score = 0, 0
+
+    while a:
+        item = a.pop()
+        if (total + item) <= x:
+            total += item
+            score += 1
+            stack.append(item)
+        else:
+            break
+
+    max_score = score
+
+    while b:
+        # print("b ", b)
+        item = b.pop()
+        # print("item ", item)
+        total += item
+        score += 1
+        while total > x and stack:
+            total -= stack.pop()
+            # print("total ", total)
+            score -= 1
+            # print("score ", score)
+        if total <= x and score > max_score:
+            max_score = score
+            # print("max ", max_score)
+
+    return max_score
+
+
+# def twoStacks(x, a, b):
+#     total, count, i, j = 0, 0, 0, 0
+#
+#     while i < len(a) and total + a[i] <= x:  # considering only first stack and calculating count
+#         total += a[i]
+#         i += 1
+#
+#     count = i
+#
+#     while j < m and i >= 0:  # now adding one element of second stack at a time and subtracting the top element of
+#         # first stack and calculating the count
+#         total += b[j]
+#         j += 1
+#         while total > x and i > 0:
+#             i -= 1
+#             total -= a[i]
+#         if total <= x and i + j > count:
+#             count = i + j
+#
+#     return count
+
+
+if __name__ == '__main__':
+    g = int(input())
+
+    for g_itr in range(g):
+        nmx = input().split()
+
+        n = int(nmx[0])
+        m = int(nmx[1])
+        x = int(nmx[2])
+
+        a = list(map(int, input().rstrip().split()))
+        b = list(map(int, input().rstrip().split()))
+
+        result = twoStacks(x, a, b)
+        print(result)

Data Structures/Stacks/MaximumElement.py

@@ -0,0 +1,34 @@
+# Using two lists:
+items = []
+maximum = []
+
+for i in range(int(input())):
+    nums = list(map(int, input().split()))
+    if nums[0] == 1:
+        if len(items) == 0:
+            items.append(nums[1])
+            maximum.append(nums[1])
+        else:
+            if nums[1] > maximum[-1]:
+                maximum.append(nums[1])
+            else:
+                maximum.append(maximum[-1])
+            items.append(nums[1])
+    elif nums[0] == 2:
+        if len(items) != 0:
+            items.pop()
+            maximum.pop()
+    else:
+        print(maximum[-1])
+
+# Using single list:
+# items = [0]
+#
+# for i in range(int(input())):
+#     nums = list(map(int, input().split()))
+#     if nums[0] == 1:
+#         items.append(max(nums[1], items[-1]))
+#     elif nums[0] == 2:
+#         items.pop()
+#     else:
+#         print(items[-1])

Data Structures/Stacks/SimpleTextEditor.py

@@ -0,0 +1,23 @@
+test = int(input())
+
+my_string = ""
+stack = []
+
+for _ in range(test):
+    operation = input().strip().split(" ")
+
+    if operation[0] == "1":
+        stack.append(my_string)
+        my_string = my_string + operation[1]
+    elif operation[0] == "2":
+        stack.append(my_string)
+        del_pos = int(operation[1])
+        my_pos = len(my_string) - del_pos
+        my_string = my_string[0:my_pos]
+    elif operation[0] == "3":
+        print_pos = int(operation[1]) - 1
+        print(my_string[print_pos])
+    else:
+        my_string = stack.pop()
+        # print(stack)
+        # print(my_string)

Data Structures/Trees/Tree_HeightOfABinaryTree.py

@@ -0,0 +1,88 @@
+class Node:
+    def __init__(self, info):
+        self.info = info
+        self.left = None
+        self.right = None
+        self.level = None
+
+    def __str__(self):
+        return str(self.info)
+
+
+class BinarySearchTree:
+    def __init__(self):
+        self.root = None
+
+    def create(self, val):
+        if self.root is None:
+            self.root = Node(val)
+        else:
+            current = self.root
+
+            while True:
+                if val < current.info:
+                    if current.left:
+                        current = current.left
+                    else:
+                        current.left = Node(val)
+                        break
+                elif val > current.info:
+                    if current.right:
+                        current = current.right
+                    else:
+                        current.right = Node(val)
+                        break
+                else:
+                    break
+
+
+# Enter your code here. Read input from STDIN. Print output to STDOUT
+'''
+class Node:
+      def __init__(self,info): 
+          self.info = info  
+          self.left = None  
+          self.right = None 
+
+
+       // this is a node of the tree , which contains info as data, left , right
+'''
+
+
+def height(root):
+    left_height = 0
+    right_height = 0
+    if root.left:
+        left_height = 1 + height(root.left)
+
+    if root.right:
+        right_height = 1 + height(root.right)
+
+    if root is None:
+        return -1
+    return max(left_height, right_height)
+
+
+# def height(root):
+#     if root is None:
+#         return -1
+#     return max(1 + height(root.left), 1 + height(root.right))
+
+
+# From Editorial:
+# def height(root):
+#     if root is None:
+#         return -1
+#     else:
+#         return 1 + max(height(root.left), height(root.right))
+
+
+tree = BinarySearchTree()
+t = int(input())
+
+arr = list(map(int, input().split()))
+
+for i in range(t):
+    tree.create(arr[i])
+
+print(height(tree.root))