array, binary search, bitmasking, dp, graph, hashing added

Author: Komal97

Array/reverse_pair.py

@@ -20,6 +20,12 @@ class Solution:
     def merge(self, s, e, mid, temp, nums):
 
         count = 0
+        j = mid+1
+        for i in range(s, mid+1):                   # count for each element
+            while j <= e and nums[i] > 2*nums[j]:   # find all elements in second half which is smaller
+                j += 1
+            count += (j-(mid+1))
+        
         i = s
         j = mid+1
         k = s
@@ -48,28 +54,22 @@ def merge(self, s, e, mid, temp, nums):
 
         for i in range(s, e+1):
             nums[i] = temp[i]
- 
+        
+        return count
 
     def mergesort(self, s, e, nums, temp):
 
         count = 0
         if s < e:
             mid = (s+e)//2
 
-            count = self.mergesort(s, mid, nums, temp) + self.mergesort(mid+1, e, nums, temp)
-            
-            j = mid+1
-            for i in range(s, mid+1):                               # count for each element
-                while j <= e and nums[i] > 2*nums[j]:               # find all elements in second half which is smaller
-                    j += 1
-                count += j-(mid+1)
-        
-            self.merge(s, e, mid, temp, nums)
+            count += self.mergesort(s, mid, nums, temp)
+            count += self.mergesort(mid+1, e, nums, temp) 
+            count += self.merge(s, e, mid, temp, nums)
             #nums[s: e + 1] = sorted(nums[s: e + 1])
-
         return count
 
-    def reversePairs(self, nums: List[int]) -> int:
+    def reversePairs(self, nums: List[int]):
 
         n = len(nums)
         temp = [0]*n

Array/subarray_with_k_diff_integers.py

@@ -0,0 +1,46 @@
+'''
+https://leetcode.com/problems/subarrays-with-k-different-integers/
+Given an array A of positive integers, call a (contiguous, not necessarily distinct) subarray of A good if the number of different integers in that subarray is exactly K.
+(For example, [1,2,3,1,2] has 3 different integers: 1, 2, and 3.)
+Return the number of good subarrays of A.
+
+Example 1:
+Input: A = [1,2,1,2,3], K = 2
+Output: 7
+Explanation: Subarrays formed with exactly 2 different integers: [1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2].
+
+Example 2:
+Input: A = [1,2,1,3,4], K = 3
+Output: 3
+Explanation: Subarrays formed with exactly 3 different integers: [1,2,1,3], [2,1,3], [1,3,4].
+'''
+
+class Solution:
+    def subarraysWithKDistinct(self, A: List[int], K: int):
+        
+        # cnt = count number of distict number
+        # prefix_count = numbers with same distinct number in which we shrink our window
+        m = collections.defaultdict(int)
+        cnt, prefix_count, res, left = 0, 0, 0, 0
+        
+        for right in range(len(A)):
+            m[A[right]] += 1
+            if m[A[right]] == 1:
+                cnt += 1
+            
+            if cnt > K:                 # start new window with new distinct elements thats why make prefix 0
+                m[A[left]] -= 1
+                left += 1
+                cnt -= 1
+                prefix_count = 0
+            
+            while m[A[left]] > 1:
+                m[A[left]] -= 1
+                left += 1
+                prefix_count += 1
+            
+            if cnt == K:
+                res += prefix_count + 1
+        
+        return res
+                

Binary Search/median_of_2_sorted_array.py

@@ -0,0 +1,53 @@
+'''
+https://leetcode.com/problems/median-of-two-sorted-arrays/
+Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.
+Follow up: The overall run time complexity should be O(log (m+n)).
+
+Example 1:
+Input: nums1 = [1,3], nums2 = [2]
+Output: 2.00000
+Explanation: merged array = [1,2,3] and median is 2.
+
+Example 2:
+Input: nums1 = [1,2], nums2 = [3,4]
+Output: 2.50000
+Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
+
+Example 3:
+Input: nums1 = [], nums2 = [1]
+Output: 1.00000
+
+'''
+
+class Solution:
+    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]):
+        
+        if len(nums1) > len(nums2):
+            return self.findMedianSortedArrays(nums2, nums1)
+        
+        lengthA = len(nums1)
+        lengthB = len(nums2)
+        
+        low = 0
+        high = lengthA
+        
+        while low <= high:
+            
+            partitionA = low + (high - low)//2
+            partitionB = ((lengthA + lengthB + 1)//2) - partitionA
+            
+            maxLeftA = nums1[partitionA-1] if partitionA != 0 else float('-inf')
+            minRightA = nums1[partitionA] if partitionA < lengthA else float('inf')
+            
+            maxLeftB = nums2[partitionB-1] if partitionB != 0 else float('-inf')
+            minRightB = nums2[partitionB] if partitionB < lengthB else float('inf')
+            
+            if maxLeftA <= minRightB and maxLeftB <= minRightA:
+                if (lengthA + lengthB) & 1:
+                    return max(maxLeftA, maxLeftB)
+                else:
+                    return (max(maxLeftA, maxLeftB) + min(minRightA, minRightB))/2
+            elif maxLeftA > minRightB:
+                high = partitionA - 1
+            else:
+                low = partitionA + 1

Bitmasking/divide_2_integers.py

@@ -0,0 +1,50 @@
+'''
+https://leetcode.com/problems/divide-two-integers/
+Given two integers dividend and divisor, divide two integers without using multiplication, division, and mod operator.
+Return the quotient after dividing dividend by divisor.
+The integer division should truncate toward zero, which means losing its fractional part. For example, truncate(8.345) = 8 and truncate(-2.7335) = -2.
+
+Note:
+Assume we are dealing with an environment that could only store integers within the 32-bit signed integer range: [−231,  231 − 1]. For this problem, assume that your function returns 231 − 1 when the division result overflows.
+ 
+Example 1:
+Input: dividend = 10, divisor = 3
+Output: 3
+Explanation: 10/3 = truncate(3.33333..) = 3.
+
+Example 2:
+Input: dividend = 7, divisor = -3
+Output: -2
+Explanation: 7/-3 = truncate(-2.33333..) = -2.
+
+Example 3:
+Input: dividend = 0, divisor = 1
+Output: 0
+'''
+
+# take a = 10, b = 3
+# step 1: 10 - (3) = 7
+# step 2: 7 - (3*2) = 1
+# step 3: 1 - (3*4) = ...
+# each time subtract double the number which we subtracted last time and add number of time in ans 
+class Solution:
+    def divide(self, A: int, B: int):
+        
+        if B == 1:
+            return A
+       
+        a = abs(A)
+        b = abs(B)
+        res = 0
+        while a - b >= 0:
+            x = 0
+            while (a - (b << x)) >= 0:      # 3*1, 3*2, 3*4.... where b = 3 and 2*(..) = x
+                a -= (b<<x)
+                res += (1 << x)
+                x += 1
+        
+        # check sign
+        ans = res if ((A >=0 ) == (B >=0)) else -res
+        
+        # check integer overflow
+        return ((2**31)-1) if ans < (-(2**31)) or ans > ((2**31) - 1) else ans

Dynamic Programming/generate_pallindrome_partitioning.py

@@ -0,0 +1,36 @@
+'''
+https://leetcode.com/problems/palindrome-partitioning/
+Given a string s, partition s such that every substring of the partition is a palindrome.
+Return all possible palindrome partitioning of s.
+Example:
+Input: "aab"
+Output:
+[
+  ["aa","b"],
+  ["a","a","b"]
+]
+'''
+
+# use recursion to find all substrings
+# store store result of pallindrome in dp
+# initialize dp false, if extreme (s[idx] == s[i]) are equal and between them string is also pallindrome(check from dp) 
+# then current string is also pallindrome
+class Solution:
+    def partition(self, s: str):
+       
+        def pallindromePartitioning(idx, output):
+            
+            if idx == n:
+                ans.append(output)
+                return
+
+            for i in range(idx, n):
+                # if extreme equal and either length is 2 or string between extreme is pallindrome
+                if (s[idx] == s[i]) and (i-idx <= 2  or dp[idx+1][i-1]== True):
+                    dp[idx][i] = True
+                    pallindromePartitioning(i+1, output + [s[idx:i+1]]) 
+                
+        n, ans = len(s), []
+        dp = [[False]*n for _ in range(n)]
+        pallindromePartitioning(0, [])
+        return ans

Graph/clone_graph.py

@@ -0,0 +1,111 @@
+'''
+https://leetcode.com/problems/clone-graph/
+Given a reference of a node in a connected undirected graph. Return a deep copy (clone) of the graph.
+Each node in the graph contains a val (int) and a list (List[Node]) of its neighbors.
+
+Test case format:
+For simplicity sake, each node's value is the same as the node's index (1-indexed). For example, the first node with val = 1, the second node with val = 2, and so on. The graph is represented in the test case using an adjacency list.
+Adjacency list is a collection of unordered lists used to represent a finite graph. Each list describes the set of neighbors of a node in the graph.
+
+Example 1:
+Input: adjList = [[2,4],[1,3],[2,4],[1,3]]
+Output: [[2,4],[1,3],[2,4],[1,3]]
+Explanation: There are 4 nodes in the graph.
+1st node (val = 1)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+
+Example 2:
+Input: adjList = [[]]
+Output: [[]]
+Explanation: Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors.
+
+Example 4:
+Input: adjList = [[2],[1]]
+Output: [[2],[1]]
+'''
+
+'''
+Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+'''
+
+# method - 1
+from collections import defaultdict, deque
+class Solution:
+    def cloneGraph(self, node: 'Node'):
+        
+        if node == None:
+            return None
+        
+        visited = defaultdict(bool)
+        copyvisited = defaultdict()
+        queue = deque()
+        
+        src = Node(node.val)
+        queue.append([node, src])
+        copyvisited[node.val] = src
+        
+        while len(queue) > 0:
+            
+            original, copy = queue.popleft()
+            visited[original] = True
+            
+            for nbr in original.neighbors:
+                # if node is not visited
+                if not visited[nbr]:                                
+                    # if node is already created by some other node then refer that node else create
+                    if nbr.val not in copyvisited:                  
+                        child = Node(nbr.val)
+                        copyvisited[nbr.val] = child
+                    else:
+                        child = copyvisited[nbr.val]
+
+                    copy.neighbors.append(child)
+                    child.neighbors.append(copy)
+                
+                    queue.append([nbr, child])
+        
+        return src
+    
+# method - 2
+from collections import deque
+class Solution:
+    def cloneGraph(self, node: 'Node'):
+        
+        if node == None:
+            return None
+        
+        # keep mapping of node: clone
+        clone = {}
+        queue = deque()
+        cloneroot = Node(node.val)
+        
+        clone = {node: cloneroot}
+        queue.append(node)
+        
+        while len(queue) > 0:
+            
+            n = queue.popleft()
+            
+            # process all neighbors of node 
+            for nbr in n.neighbors:
+                # if node is not created then create, add in map and queue
+                if nbr not in clone:
+                    child = Node(nbr.val)
+                    clone[nbr] = child
+                    queue.append(nbr)
+                # if already created then only refer and no need to append in queue as it is seen already and processed
+                # but needed to be connect by some other node
+                else:
+                    child = clone[nbr]
+                # always append the neighbors
+                clone[n].neighbors.append(child)
+        
+        return cloneroot
+        
+