Data-structures

Author: geekbuti

Diff for: data-structures/2d-array.py

@@ -0,0 +1,24 @@
+#!/bin/python3
+
+import sys
+
+
+arr = []
+for arr_i in range(6):
+    arr_t = [int(arr_temp) for arr_temp in input().strip().split(' ')]
+    arr.append(arr_t)
+
+    
+best = 0
+for ind_i in range(6-2):
+    for ind_j in range(6-2):
+        temp = 0
+        temp += arr[ind_i][ind_j] + arr[ind_i][ind_j+1] + arr[ind_i][ind_j+2]
+        temp += arr[ind_i+1][ind_j+1]
+        temp += arr[ind_i+2][ind_j] + arr[ind_i+2][ind_j+1] + arr[ind_i+2][ind_j+2]
+        if ind_i == 0 and ind_j == 0:
+            best = temp
+        else:
+            best = max(best, temp)
+    
+print(best)

Diff for: data-structures/and-xor-or.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+    
+def solution(arr):
+    res = 0
+    stack = []
+    
+    for el in arr:
+        while stack:
+            res = max(res, el^stack[-1])
+            
+            if el < stack[-1]:
+                stack.pop()
+            else:
+                break
+        stack.append(el)
+            
+    return res
+            
+if __name__ == "__main__":
+    n = int(input().strip())
+    arr = [int(x) for x in input().strip().split()]
+    print(solution(arr))

Diff for: data-structures/array-left-rotation.py

@@ -0,0 +1,20 @@
+#!/bin/python3
+
+import sys
+
+def leftRotation(a, d):
+    out = list(a)
+    a_len = len(a)
+    for ind, el in enumerate(a):
+        out[(ind + a_len - d) % a_len] = el
+
+    return out
+        
+if __name__ == "__main__":
+    n, d = input().strip().split(' ')
+    n, d = [int(n), int(d)]
+    a = list(map(int, input().strip().split(' ')))
+    result = leftRotation(a, d)
+    print (" ".join(map(str, result)))
+
+

Diff for: data-structures/arrays-ds.py

@@ -0,0 +1,9 @@
+#!/bin/python3
+
+import sys
+
+
+n = int(input().strip())
+arr = [int(arr_temp) for arr_temp in input().strip().split(' ')]
+
+print(" ".join(map(str, arr[::-1])))

Diff for: data-structures/balanced-brackets.py

@@ -0,0 +1,41 @@
+#!/bin/python3
+
+import sys
+
+def isBalanced(s):
+    stack = []
+ 
+    for letter in s:
+        if letter == '{':
+            stack.append(1)
+        elif letter == '[':
+            stack.append(2)
+        elif letter == '(':
+            stack.append(3)
+        elif letter == '}':
+            if len(stack) == 0:
+                return False
+            if stack.pop() != 1:
+                return False
+        elif letter == ']':
+            if len(stack) == 0:
+                return False
+            if stack.pop() != 2:
+                return False
+        elif letter == ')':
+            if len(stack) == 0:
+                return False
+            if stack.pop() != 3:
+                return False
+ 
+    return len(stack) == 0
+
+if __name__ == "__main__":
+    t = int(input().strip())
+    for a0 in range(t):
+        s = input().strip()
+        result = isBalanced(s)
+        if result is True:
+            print('YES')
+        else:
+            print('NO')

Diff for: data-structures/binary-search-tree-insertion.py

@@ -0,0 +1,28 @@
+"""
+Node is defined as
+self.left (the left child of the node)
+self.right (the right child of the node)
+self.data (the value of the node)"""
+
+def insert(root, val):
+    if root is None:
+        root = Node(data=val)
+        return root
+    
+    current = root
+    while True:
+        if current.data > val:
+            if current.left is not None:
+                current = current.left
+            else:
+                current.left = Node(data=val)
+                break
+        else:
+            if current.right is not None:
+                current = current.right
+            else:
+                current.right = Node(data=val)
+                break
+    
+    return root
+    

Diff for: data-structures/binary-search-tree-lowest-common-ancestor.py

@@ -0,0 +1,20 @@
+"""
+Node is defined as
+self.left (the left child of the node)
+self.right (the right child of the node)
+self.data (the value of the node)
+"""
+
+def lca(root , v1 , v2):
+    vals = sorted([v1, v2])
+    v1, v2 = vals[0], vals[1]
+    node = root
+    while True:
+        if v1 < v2 < node.data:
+            node = node.left
+        if v1 > v2 > node.data:
+            node = node.right
+        if v1 <= node.data <= v2:
+            break
+    return node
+        

Diff for: data-structures/castle-on-the-grid.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+
+import sys
+from collections import deque
+
+def is_safe(grid, x, y, distances):
+    return x >= 0 and x < len(grid) and y >= 0 and y < len(grid) and distances[x][y] == -1 and grid[x][y] != 'X' 
+
+def get_safe_moves(grid, node, distances):
+    directions = [(-1, 0), (0, 1), (1, 0), (0, -1)]
+    variants = []
+    
+    for di in directions:
+        nunode = (node[0] + di[0], node[1] + di[1])
+        while is_safe(grid, nunode[0], nunode[1], distances):
+            variants.append(nunode)
+            nunode = (nunode[0] + di[0], nunode[1] + di[1])
+            
+    return variants
+            
+
+def minimumMoves(grid, startX, startY, goalX, goalY):
+    next_to_visit = deque()
+    node = (startX, startY)
+    next_to_visit.appendleft(node)
+    distances = [[-1]*len(grid) for _ in range(len(grid))]
+    distances[startX][startY] = 0
+    
+    while next_to_visit:
+        node = next_to_visit.pop()
+        #print("point = ({}, {})".format(node[0], node[1]))
+        #for row in distances:
+        #    print(row)
+        #print()
+        height = distances[node[0]][node[1]]
+       
+        variants = get_safe_moves(grid, node, distances)
+        
+        for var in variants:
+            if var == (goalX, goalY):
+                return height + 1
+            distances[var[0]][var[1]] = height + 1
+            next_to_visit.appendleft(var)
+                
+    return -1
+    
+
+if __name__ == "__main__":
+    n = int(input().strip())
+    grid = []
+    for _ in range(n):
+        layer = list(input().strip())
+        grid.append(layer)
+    startX, startY, goalX, goalY = [int(i) for i in input().strip().split()]
+    result = minimumMoves(grid, startX, startY, goalX, goalY)
+    print(result)

Diff for: data-structures/compare-two-linked-lists.py

@@ -0,0 +1,43 @@
+"""
+ Merge two linked list
+ head could be None as well for empty list
+ Node is defined as
+ 
+ class Node(object):
+ 
+   def __init__(self, data=None, next_node=None):
+       self.data = data
+       self.next = next_node
+
+ return back the head of the linked list in the below method.
+"""
+
+def CompareLists(headA, headB):
+    if headA is None and headB is None:
+        return 0
+    else:
+        nodeA = headA
+        nodeB = headB
+        while nodeA and nodeB:
+            if nodeA.data != nodeB.data:
+                return 0
+            nodeA = nodeA.next
+            nodeB = nodeB.next
+        
+        if nodeA is None and nodeB is None:
+            return 1
+        else:
+            return 0
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  

Diff for: data-structures/components-in-graph.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+
+import sys
+
+class disjoint_set:
+    class Node:
+        def __init__(self, data = 0):
+            self.data = data
+            self.parent = self
+            self.rank = 0
+
+    def __init__(self):
+        self.items = dict()
+
+    def make_set(self, data):
+        if not data in self.items:
+            self.items[data] = self.Node(data)
+        return self.items
+
+    def find_set(self, data):
+        if data in self.items:
+            node = self.items[data]
+        else:
+            return False
+
+        if node.parent == node:
+            return node
+        node.parent = self.find_set(node.parent.data)
+
+        return node.parent
+
+    def union(self, rep1, rep2):
+        node1 = self.find_set(rep1)
+        node2 = self.find_set(rep2)
+
+        #print("union: node1 = {} node2 = {}".format(node1.data, node2.data))
+
+        if node1 and node2 and node1 != node2:
+            if node1.rank >= node2.rank:
+                if node1.rank == node2.rank:
+                    node1.rank += 1
+                node2.parent = node1
+            else:
+                node1.parent = node2
+
+        return True
+
+if __name__ == "__main__":
+    n = int(input().strip())
+    output = [0] * (n+1)
+    
+    dset = disjoint_set()
+    
+    for _ in range(n):
+        rep1, rep2 = [int(x) for x in input().strip().split()]
+        
+        dset.make_set(rep1)
+        dset.make_set(rep2)
+        
+        dset.union(rep1, rep2)
+        
+    for el in dset.items.keys():
+        output[dset.find_set(el).data] += 1
+        
+    dset_max = max(output)
+    dset_min = min(filter(lambda x: x > 0, output))
+    
+    print("{} {}".format(dset_min, dset_max))
+        

Diff for: data-structures/contacts.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+
+class Trie:
+    def __init__(self):
+        self.count = 1
+        self.children = {}
+        
+    def add(self, name):
+        node = self
+        for let in name:
+            if let in node.children.keys():
+                node.children[let].count += 1
+                node = node.children[let]
+            else:
+                node.children[let] = Trie()
+                node = node.children[let]
+    
+    def find(self, name):
+        node = self
+        for let in name:
+            if let in node.children.keys():
+                res = node.children[let].count
+                node = node.children[let]
+            else:
+                res = 0
+                break
+                
+        return res
+    
+    def print(self):
+        print("count = {} keys = {}".format(self.count, self.children.keys()))
+        for key in self.children.keys():
+            self.children[key].print()
+            
+if __name__ == "__main__":
+    t = int(input().strip())
+    trie = Trie()
+    
+    for _ in range(t):
+        args = input().strip().split()
+        
+        if args[0] == 'add':
+            trie.add(args[1])
+        elif args[0] == 'find':
+            print(trie.find(args[1]))
+