*New

Author: Tuhin-thinks

Arrays/longest_common_prefix.py

@@ -0,0 +1,29 @@
+class Solution:
+    def longestCommonPrefix(self, arr, n):
+        common_prefix = min(arr)
+        filtered = list(filter(lambda x: len(x) >= len(common_prefix), arr))
+        ans = ""
+        for idx in range(len(common_prefix)):
+            for el in filtered:
+                if el[idx] == common_prefix[idx]:
+                    continue
+                else:
+                    return ans or "-1"
+
+            ans += common_prefix[idx]
+        return ans or "-1"
+
+
+# {
+# Driver Code Starts
+# Initial Template for Python 3
+
+if __name__ == '__main__':
+    t = int(input())
+    for _ in range(t):
+        n = int(input())
+        arr = [x for x in input().strip().split(" ")]
+
+        ob = Solution()
+        print(ob.longestCommonPrefix(arr, n))
+# } Driver Code Ends

Arrays/servers_that_communicate.py

@@ -0,0 +1,53 @@
+# Problem source: https://leetcode.com/problems/count-servers-that-communicate/
+# Servers that communicate
+
+from typing import List
+
+
+class Solution:
+
+    def countServers(self, grid: List[List[int]]) -> int:
+        rows = len(grid)
+        cols = len(grid[0])
+        discovered = set()
+
+        for i in range(rows):
+            has_server = 0
+            temp_discovery = None
+            for j in range(cols):
+                el = grid[i][j]
+                if el:
+                    if has_server:
+                        discovered.add((i, j))
+                        if temp_discovery:
+                            discovered.add(temp_discovery)
+                            temp_discovery = None
+                    else:
+                        temp_discovery = (i, j)
+                    has_server = 1
+                    found_servers = self.discover_cols(i + 1, j, grid, discovered, rows, cols)
+                    if found_servers and temp_discovery:
+                        discovered.add(temp_discovery)
+                        temp_discovery = None
+
+        return len(discovered)
+
+    def discover_cols(self, row, col, grid, discovered, rows, cols):
+        found_servers = 0
+        for c in range(row, rows):
+            el = grid[c][col]
+            if el == 1:
+                discovered.add((c, col))
+                found_servers = 1
+
+        return found_servers
+
+
+if __name__ == '__main__':
+    ob = Solution()
+    rows, cols = input().split(" ")
+    _grid = []
+    for row in range(int(rows)):
+        line = input()
+        _grid.append([int(x) for x in line.split(" ")])
+    print(ob.countServers(_grid))

Arrays/sort_on_kth_attribute.py

@@ -0,0 +1,27 @@
+# Problem source: https://www.hackerrank.com/challenges/python-sort-sort/problem
+
+import math
+import os
+import random
+import re
+import sys
+
+if __name__ == '__main__':
+    nm = input().split()
+
+    n = int(nm[0])
+
+    m = int(nm[1])
+
+    arr = []
+
+    for _ in range(n):
+        arr.append(list(map(int, input().rstrip().split())))
+
+    k = int(input())
+
+    sorted_list = list(sorted(arr, key=lambda x: x[k]))
+    for row in sorted_list:
+        for c in row:
+            print(c, end=" ")
+        print()

DynamicProgramming/snake_ladder.py

@@ -0,0 +1,66 @@
+# Problem source: https://practice.geeksforgeeks.org/problems/snake-and-ladder-problem4816/1
+# input:
+#  The input is represented by two things, the first is ‘N’ which
+#  is a number of cells in the given board, second is an array ‘move[0…N-1]’ of size N.
+#  An entry move[i] is -1 if there is no snake and no ladder from i,
+#  otherwise move[i] contains index of destination cell for the snake or the ladder at i.
+
+# output: Minimum number of dice throws required to reach the destination cell from the source or the 1st cell.
+
+class QueueEntry:
+    def __init__(self):
+        self.v = 0
+        self.dist = 0
+
+
+class Solution:
+    def minThrow(self, N, arr):
+        q = []
+        qe = QueueEntry()
+        visited = [False] * N+1
+        q.append(qe)
+
+        mat = [-1] * 30
+        for i in range(0, 2*N, 2):
+            mat[arr[i]] = arr[i+1]
+
+        while q:
+            qe = q.pop(0)
+            v = qe.v
+            if v == 30:
+                break
+
+            for j in range(v+1, 7):
+                if j > 30:
+                    break
+                if visited[j] == 0:
+                    a = QueueEntry()
+                    a.dist = qe.dist + 1
+
+                    if mat[j] != -1:
+                        a.v = mat[j]
+                    else:
+                        a.v = j
+
+                    q.append(a)
+
+        return qe.dist
+
+
+# code here
+
+
+# {
+# Driver Code Starts
+# Initial Template for Python3
+
+if __name__ == '__main__':
+    t = int(input())
+    for _ in range(t):
+        N = int(input())
+        arr = input().split()
+        for i in range(2 * N):
+            arr[i] = int(arr[i])
+
+        ob = Solution()
+        print(ob.minThrow(N, arr))

Tree/BaseTree.py

@@ -0,0 +1,107 @@
+
+class Node:
+    def __init__(self, data=None):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+class Tree:
+    def __init__(self):
+        self.root = None
+
+    def insert_node(self, data):
+
+        x = self.root
+        y = None
+
+        # iterative approach
+        while x is not None:
+            y = x
+            if data < x.data:
+                x = x.left
+            else:
+                x = x.right
+
+        if y is None:
+            y = Node(data)
+        elif data < y.data:
+            y.left = Node(data)
+        else:
+            y.right = Node(data)
+
+        return y
+
+    def inorder_traversal(self, node: Node):
+        if node is None:
+            return
+
+        if node.left is not None:
+            self.inorder_traversal(node.left)
+
+        print(node.data, end=" ")
+
+        if node.right is not None:
+            self.inorder_traversal(node.right)
+
+    def preorder_traversal(self, node: Node):
+        if node is None:
+            return
+
+        print(node.data, end=" ")
+
+        if node.left is not None:
+            self.preorder_traversal(node.left)
+
+        if node.right is not None:
+            self.preorder_traversal(node.right)
+
+    def postorder_traversal(self, node: Node):
+        if node is None:
+            return
+
+        if node.left is not None:
+            self.postorder_traversal(node.left)
+
+        if node.right is not None:
+            self.postorder_traversal(node.right)
+
+        print(node.data, end=" ")
+
+    def level_order_traversal(self):
+        if self.root is None:
+            return
+
+        queue = [self.root]
+
+        while len(queue) > 0:
+            node = queue.pop(0)
+            print(node.data, end=" ")
+
+            if node.left is not None:
+                queue.append(node.left)
+
+            if node.right is not None:
+                queue.append(node.right)
+
+
+if __name__ == '__main__':
+    tree = Tree()
+    _root = tree.root = tree.insert_node(1)
+    _root.left = Node(2)
+    _root.right = Node(3)
+    _root.left.left = Node(4)
+    _root.left.right = Node(5)
+    # tree.insert_node(2)
+    # tree.insert_node(3)
+    # tree.insert_node(4)
+    # tree.insert_node(5)
+
+    print("InOrder Traversal")
+    tree.inorder_traversal(_root)
+
+    print("\nLevel Order Traversal")
+    tree.level_order_traversal()
+
+    print("\nPreOrder Traversal")
+    tree.preorder_traversal(tree.root)