Merge branch 'smv1999:master' into manny

Author: MannyP31

2D Arrays/Set Matrix Zero.cpp

@@ -0,0 +1,55 @@
+/*______________________________________________________________________PROBLEM___________________________________________________________*/
+
+/*Given an m x n matrix. If an element is 0, set its entire row and column to 0. Do it in-place.
+   Follow up:
+
+A straight forward solution using O(mn) space is probably a bad idea.
+A simple improvement uses O(m + n) space, but still not the best solution.
+Could you devise a constant space solution?
+
+ EXAMPLE 1:
+ Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]
+ Output: [[1,0,1],[0,0,0],[1,0,1]]
+ 
+ EXAMPLE 2:
+ Input: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
+ Output: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
+ 
+ 
+ 
+ Constraints:
+
+m == matrix.length
+n == matrix[0].length
+1 <= m, n <= 200
+-231 <= matrix[i][j] <= 231 - 1
+*/
+ 
+
+class Solution {
+public:
+    void setZeroes(vector<vector<int>>& m) {
+        set<int>row,col;
+        
+      for(int i=0;i<m.size();i++){
+          for(int j=0;j<m[0].size();j++){
+              if(m[i][j]==0){
+                  row.insert(i);
+                  col.insert(j);
+              }
+          }
+      }
+    
+    
+        for(auto it=row.begin();it!=row.end();it++){
+            for(int j=0;j<m[0].size();j++){
+                m[*it][j]=0;
+            }
+            
+        }
+        for(auto it=col.begin();it!=col.end();it++){
+            for(int j=0;j<m.size();j++){
+                m[j][*it]=0;
+            }
+        }
+    }

DSA 450 GFG/BuyandSell.py

@@ -0,0 +1,12 @@
+# Link to the problem : https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+
+class Solution:
+    def maxProfit(self, prices):
+        min_so_far = prices[0]
+        max_profit = 0
+        n = len(prices)
+        for i in prices :
+          min_so_far = min(min_so_far , i)
+          profit = i - min_so_far
+          max_profit = max(max_profit , profit)
+        return max_profit

DSA 450 GFG/CountAndSay.py

@@ -0,0 +1,36 @@
+# Problem : https://leetcode.com/problems/count-and-say/
+
+# Input: n = 4
+# Output: "1211"
+# Explanation:
+# countAndSay(1) = "1"
+# countAndSay(2) = say "1" = one 1 = "11"
+# countAndSay(3) = say "11" = two 1's = "21"
+# countAndSay(4) = say "21" = one 2 + one 1 = "12" + "11" = "1211"
+
+# Initialize counter = 1 to store the count of every element 
+# Initialize o/p string as ret = ""
+# If the previous element in the string is equal to the current element in the string , increament the counter
+# else Concatenate the count and the previous element of the string in ret
+
+# Return ret
+
+class Solution:
+    def countAndSay(self, n):
+        if (n == 1):
+            return ("1")
+        
+        s = self.countAndSay(n-1)
+        
+        ret = ""
+        cnt = 1
+        i = 1
+        while i < len(s) + 1:
+            if i < len(s) and s[i] == s[i-1]:
+                cnt += 1
+            else:
+                ret += str(cnt) + str(s[i-1])
+                cnt = 1
+            i += 1
+            
+        return (ret)

DSA 450 GFG/PrintAnagrams.py

@@ -0,0 +1,51 @@
+
+# Problem : https://practice.geeksforgeeks.org/problems/print-anagrams-together/1
+
+
+# Input:
+# N = 5
+# words[] = {act,god,cat,dog,tac}
+# Output: 
+# god dog
+# act cat tac
+# Explanation:
+# There are 2 groups of
+# anagrams "god", "dog" make group 1.
+# "act", "cat", "tac" make group 2.
+
+from collections import defaultdict
+
+def Anagrams(words,n):
+    '''
+    words: list of word
+    n:      no of words
+    return : list of group of anagram {list will be sorted in driver code (not word in grp)}
+    '''
+    
+    #code here
+    anagrams = defaultdict(list)
+    
+    for word in words:
+        anagrams["".join(sorted(word))].append(word)
+  
+    return anagrams.values()
+    
+
+#  Driver Code 
+
+if __name__ =='__main__':
+    t= int(input())
+    for tcs in range(t):
+        n= int(input())
+        words=input().split()
+        
+        ans=Anagrams(words,n)
+        
+        for grp in sorted(ans):
+            for word in grp:
+                print(word,end=' ')
+            print()
+
+
+
+# Used default dict from collections module . It does not raise key value error

DSA 450 GFG/TrapRainWater.py

@@ -0,0 +1,48 @@
+# Problem : https://practice.geeksforgeeks.org/problems/trapping-rain-water-1587115621/1
+
+class Solution:
+    def trappingWater(self, arr,n):
+        #Code here
+        left = [0]*n
+        right = [0]*n
+
+        left[0] = arr[0]
+        right[n-1] = arr[n-1]
+        trap_sum = 0
+        
+        for i in range (1 , n):
+            left[i] = max(left[i-1] , arr[i])
+        for i in range(n-2 , -1 , -1):
+            right[i] = max(arr[i] , right[i+1])
+        for i in range (0 , n):
+            trap_sum += min(left[i] , right[i]) - arr[i]
+                
+        return trap_sum
+#{ 
+#  Driver Code Starts
+#Initial Template for Python 3
+
+import math
+
+
+
+def main():
+        T=int(input())
+        while(T>0):
+            
+            n=int(input())
+            
+            arr=[int(x) for x in input().strip().split()]
+            obj = Solution()
+            print(obj.trappingWater(arr,n))
+            
+            
+            T-=1
+
+
+if __name__ == "__main__":
+    main()
+
+
+
+# } Driver Code Ends

DSA 450 GFG/chocolate_distribution.py

@@ -0,0 +1,42 @@
+# Problem : https://practice.geeksforgeeks.org/problems/chocolate-distribution-problem3825/1#
+
+#Given an array A[ ] of positive integers of size N, where each value represents the number of chocolates in a packet. Each packet can have a variable number of chocolates. There are M students, the task is to distribute chocolate packets among M students such that :
+#1. Each student gets exactly one packet.
+#2. The difference between maximum number of chocolates given to a student and minimum number of chocolates given to a student is minimum.
+
+
+class Solution:
+
+    def findMinDiff(self, A,N,M):
+
+        # code here
+        if(N == 0 or M == 0):
+            return 0
+        elif (N < M):
+            return -1
+        else:
+            A.sort()
+            min_diff = A[N-1] - A[0]
+            for i in range(0 , N - M + 1):
+                min_diff = min(min_diff , A[i+M-1] - A[i])
+            return min_diff
+        
+        
+#{ 
+#  Driver Code Starts
+#Initial Template for Python 3
+
+if __name__ == '__main__':
+
+    t = int(input())
+
+    for _ in range(t):
+        N = int(input())
+        A = [int(x) for x in input().split()]
+        M = int(input())
+
+
+        solObj = Solution()
+
+        print(solObj.findMinDiff(A,N,M))
+# } Driver Code Ends

DSA 450 GFG/max_and_min_of_array.py

@@ -0,0 +1,44 @@
+# Maximum and minimum of an array using minimum number of comparisons - Python
+
+def getMinMax(arr):
+	
+	n = len(arr)
+	
+	# If array has even number of elements then initialize the first two elements as minimum and maximum
+	if(n % 2 == 0):
+		maximum = max(arr[0], arr[1])
+		minimum = min(arr[0], arr[1])
+		
+		# set the starting index for loop
+		i = 2
+		
+	# If array has odd number of elements then initialize the first element as minimum and maximum
+	else:
+		maximum = minimum = arr[0]
+		
+		# set the starting index for loop
+		i = 1
+		
+	# In the while loop, pick elements in pair and compare the pair with max and min so far
+	while(i < n - 1):
+		if arr[i] < arr[i + 1]:
+			maximum = max(maximum, arr[i + 1])
+			minimum = min(minimum, arr[i])
+		else:
+			maximum = max(maximum, arr[i])
+			minimum = min(minimum, arr[i + 1])
+			
+		# Increment the index by 2 as two elements are processed in loop
+		i += 2
+	
+	return (maximum, minimum)
+	
+# Driver Code
+if __name__ =='__main__':
+	
+	arr = [9, 1, 45, 2, 330, 3]
+	maximum, minimum = getMinMax(arr)
+	print("Minimum element is", minimum)
+	print("Maximum element is", maximum)
+	
+

DSA 450 GFG/merge_intervals.py

@@ -0,0 +1,30 @@
+
+# Link for the problem : https://leetcode.com/problems/merge-intervals/
+
+# Input: intervals = [[1,3],[2,6],[8,10],[15,18]]
+# Output: [[1,6],[8,10],[15,18]]
+# Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].
+
+# Create a list merged to store the merged intervals
+# Condition for merging  : If the first index of current interval is less than last index of previous interval 
+# If condition satisfies , replace the last index of previous interval with the maximum between current and previous interval's last index
+# If not , then simply append the interval in the merged list 
+
+
+
+class Solution:
+    def merge(self, intervals):
+      
+        intervals.sort(key = lambda x : x[0])
+        merged = [] 
+        
+        for interval in intervals :
+          
+          if not merged or merged[-1][1] < interval[0] :
+            merged.append(interval)
+          else :
+            merged[-1][1] = max(merged[-1][1] , interval[1])
+            
+        return merged
+    
+    

DSA 450 GFG/move_all_neg_numbers.py

@@ -0,0 +1,17 @@
+
+
+def rearrange (arr , n ):
+    j = 0 
+    for i in range(0 , n)  :
+        if(arr[i] < 0):
+            temp = arr[i]
+            arr[i] = arr[j]
+            arr[j] = temp 
+            j = j + 1
+    print(arr)
+    
+#Driver code 
+sequence = [1 , 3, - 6 , 9 , -3 , -1]
+length = len(sequence)
+print(sequence.sort)
+rearrange(sequence , length)

DSA 450 GFG/reverse_an_array.py

@@ -0,0 +1,22 @@
+#  Write a program to reverse an array
+# Given an array (or string), the task is to reverse the array/string.
+# Examples : 
+ 
+# Input  : arr[] = [1, 2, 3]
+# Output : arr[] = [3, 2, 1]
+# Input :  arr[] = [4, 5, 1, 2]
+# Output : arr[] = [2, 1, 5, 4]
+
+
+
+
+# Reverse of an array can be implented in Python using the List slicing 
+
+def reverseList(a):
+      print( a[::-1])
+
+# Driver Code
+arr = [4,5,1,2]
+print(arr)
+print("Reverse : ")
+reverseList(arr)