Merge branch 'master' of https://github.com/smv1999/CompetitiveProgrammingQuestionBank

Author: smv1999

.github/ISSUE_TEMPLATE/---issue--feature.md

@@ -8,13 +8,10 @@ assignees: ''
 ---
 
 **Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+A clear and concise description of what the problem is. 
 
 **Describe the solution you'd like**
 A clear and concise description of what you want to happen.
 
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
 **Additional context**
 Add any other context or screenshots about the feature request here.

.gitignore

@@ -0,0 +1,15 @@
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+*.code-workspace
+
+# Local History for Visual Studio Code
+.history/
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide

DSA 450 GFG/BTtoBST.py

@@ -0,0 +1,155 @@
+# Link : https://practice.geeksforgeeks.org/problems/binary-tree-to-bst/1#
+
+'''
+# Tree Node
+class Node:
+    def __init__(self, val):
+        self.right = None
+        self.data = val
+        self.left = None
+'''
+class Solution:
+    
+    # The given root is the root of the Binary Tree
+    # Return the root of the generated BST
+    
+    def BTtoArray(self , root , array):
+        
+        if root is None:
+            return 
+        
+        self.BTtoArray(root.left , array)
+        
+        array.append(root.data)
+        
+        self.BTtoArray(root.right , array)
+        
+        
+    def countNodes(self,root):
+        
+        if root is None:
+            return 0
+        
+        return self.countNodes(root.left) + self.countNodes(root.right) + 1
+        
+    def ArraytoBST(self,array,root):
+        
+        if root is None:
+            return
+        
+        self.ArraytoBST(array , root.left)
+        
+        root.data = array[0]
+        array.pop(0)
+        
+        self.ArraytoBST(array , root.right)
+        
+        
+    def binaryTreeToBST(self, root):
+        # code here
+        
+        if root is None:
+            return
+        
+        # Find the number of nodes to create an array of that size
+        n = self.countNodes(root)
+        
+        arr = []*n
+        
+        # Store the inorder traversal of tree in an array
+        self.BTtoArray(root , arr)
+        
+        # Sort the array
+        arr.sort()
+        
+        # Tranfer the elements from root to the tree and return the BST
+        self.ArraytoBST(arr , root)
+        
+        
+        
+
+#{ 
+#  Driver Code Starts
+#Initial Template for Python 3
+
+from collections import deque
+# Tree Node
+class Node:
+    def __init__(self, val):
+        self.right = None
+        self.data = val
+        self.left = None
+
+# Function to Build Tree   
+def buildTree(s):
+    #Corner Case
+    if(len(s)==0 or s[0]=="N"):           
+        return None
+        
+    # Creating list of strings from input 
+    # string after spliting by space
+    ip=list(map(str,s.split()))
+    
+    # Create the root of the tree
+    root=Node(int(ip[0]))                     
+    size=0
+    q=deque()
+    
+    # Push the root to the queue
+    q.append(root)                            
+    size=size+1 
+    
+    # Starting from the second element
+    i=1                                       
+    while(size>0 and i<len(ip)):
+        # Get and remove the front of the queue
+        currNode=q[0]
+        q.popleft()
+        size=size-1
+        
+        # Get the current node's value from the string
+        currVal=ip[i]
+        
+        # If the left child is not null
+        if(currVal!="N"):
+            
+            # Create the left child for the current node
+            currNode.left=Node(int(currVal))
+            
+            # Push it to the queue
+            q.append(currNode.left)
+            size=size+1
+        # For the right child
+        i=i+1
+        if(i>=len(ip)):
+            break
+        currVal=ip[i]
+        
+        # If the right child is not null
+        if(currVal!="N"):
+            
+            # Create the right child for the current node
+            currNode.right=Node(int(currVal))
+            
+            # Push it to the queue
+            q.append(currNode.right)
+            size=size+1
+        i=i+1
+    return root
+
+def printInorder(root): 
+    if root is None: 
+        return
+    printInorder(root.left) 
+    print (root.data, end=' ')  
+    printInorder(root.right) 
+
+if __name__=="__main__":
+    t=int(input())
+    for _ in range(0,t):
+        s=input()
+        root=buildTree(s)
+        Solution().binaryTreeToBST(root)
+        printInorder(root)
+        print()
+# } Driver Code Ends

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/DeleteNodeinBST.py

@@ -0,0 +1,50 @@
+#https://leetcode.com/problems/delete-node-in-a-bst/submissions/
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+  
+    def findMinimum(self , root):
+      current = root
+      while(current.left):
+        current = current.left
+      return current
+      
+    def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
+      
+      if not root:
+        return root
+      
+      
+      elif(key < root.val):
+        root.left = self.deleteNode(root.left , key)
+        
+      elif(key > root.val):
+        root.right = self.deleteNode(root.right , key)
+        
+      else:
+        
+        #Leaf
+        if not root.left and not root.right:
+          root = None
+        
+        #1 child   
+        elif not root.left:
+          root = root.right
+          
+        elif not root.right :
+          root = root.left
+          
+        #2 child
+        else:
+          temp = self.findMinimum(root.right)
+          root.val = temp.val
+          root.right = self.deleteNode(root.right , temp.val)
+          
+      return root
+        
+