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

Author: ushmita4

.github/pull_request_template.md

@@ -19,7 +19,6 @@ Happy Contributing!
 
 - [ ] I've read the contribution guidelines.
 - [ ] I've checked the issue list before deciding what to submit.
-- [ ] I've edited the `README.md` and link to my code.
 
 ## Related Issues or Pull Requests
 

.vscode/settings.json

@@ -0,0 +1,41 @@
+/**************************************************************************
+Given an array arr[] and a number K where K is smaller than size of array, 
+the task is to find the Kth smallest element in the given array. 
+Given all Array elements are distinct.
+
+For Example: arr[] = {7, 8, 1, 4, 9, 3}
+             k = 3 ------> 3rd smallest element in the array
+        ANS: 4
+
+This can be solved using heap and priority queue.
+***************************************************************************/
+
+// SOLUTION (in C++):
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int main()
+{
+   int n, k;
+   cin >> n >> k;
+   cout << "Enter the array elements" << endl;
+   int arr[n];
+   priority_queue<int> maxh;
+   //A priority queue keeps the elements in the order of their priority, i.e.,
+   //elements having greater values will be at the top of the queue and elements having smaller values will be kept at the bottom of the queue.
+   //The element popped out of this queue is the element with the maximum value.
+
+   for (int i = 0; i < n; i++)
+   {
+      maxh.push(arr[i]);
+      if (maxh.size() > k)
+      {
+         maxh.pop();
+      }
+   }
+
+   cout << "The " << k << "th smallest element is " << maxh.top();
+   return 0;
+}

Arrays/Kth_smallest_element_in_an_array_using_heap.cpp

@@ -0,0 +1,117 @@
+/* 
+Given an integer array nums, return the maximum result of nums[i] XOR nums[j], 
+where 0 ≤ i ≤ j < n.
+*/
+
+#include<iostream>
+#include<vector>
+using namespace std;
+
+// Constructing a trie
+struct trie {
+        trie *zero,*one;
+};
+
+//Building the trie
+void insert(int num,trie *root) {
+   // Store the head
+   trie *ptr=root;
+      for(int i=31;i>=0;i--) {
+        // Find the i-th bit
+         int h = (num>>i & 1);
+           if(h==0) {
+               // If ptr->zero is NULL
+                if(ptr->zero==NULL) {
+                    ptr->zero=new trie();
+                }
+                // Update ptr to ptr->zero
+                ptr=ptr->zero;
+            }
+            else {
+                // If ptr->onr is NULL
+                if(ptr->one==NULL) {
+                    ptr->one=new trie();
+                }
+                // Update ptr to ptr->one
+                ptr=ptr->one;
+            }
+        }
+}
+
+//Finding the maximum XOR for each element   
+int comp(int num,trie *root) {
+        trie *ptr = root;
+        int sum=0;
+        for(int i=31;i>=0;i--) {
+            sum=sum<<1;
+            // Finding ith bit
+           int h = (num>>i & 1);
+           // Check if the bit is 0
+            if(h==0) {
+                // If right node exists
+                if(ptr->one) {
+                   sum++;
+                    ptr=ptr->one;
+                }
+                else ptr=ptr->zero;
+                
+            }
+            else {
+                // Check if left node exists
+                  if(ptr->zero) {
+                   sum++;
+                    ptr=ptr->zero;
+                }
+                else ptr=ptr->one;
+            }
+        }
+        return sum;
+}
+   
+int findMaximumXOR(vector<int>& nums) {
+        // head Node of Trie
+        trie *root = new trie(); 
+        // Insert each element in trie
+        for(int i=0;i<nums.size();i++) {
+            insert(nums[i],root);
+        }
+        // Stores the maximum XOR value
+        int maxm=0;
+        // Traverse the given array
+        for(int i=0;i<nums.size();i++) {
+            maxm=max(comp(nums[i],root),maxm);
+        }
+        return maxm;
+}
+
+//Main Function
+int main() {
+
+   vector<int>nums;
+   int sz; 
+   
+   cout<<"Enter the vector size\n";
+   cin>>sz; // size of the vector
+ 
+   cout<<"Enter the elements in the vector\n";
+   for(int i=0;i<sz;i++) {
+   	 int x; 
+	 cin>>x;
+	 nums.push_back(x);
+   }
+  
+   int answer = findMaximumXOR(nums);
+   cout<<"The Maximum XOR of two numbers in the array/vector is : "<<answer<<endl;   
+
+        return 0;
+}
+
+/* Sample Text Case 
+ Enter the vector size
+ 6
+ Enter the elements in the vector
+ 3 10 5 25 2 8
+ The Maximum XOR of two numbers in the array/vector is : 28
+
+ Time Complexity : O(n) , where n is the number of elements in the vector.
+*/

Arrays/Max_XOR_of_Two_Array.cpp

@@ -0,0 +1,61 @@
+/*
+Given an integer array A of N integers, find the pair of integers 
+in the array which have minimum XOR value. Report the minimum XOR value. 
+Explanation: According to the problem, we are given the size of the array 
+and the numbers present in it. So we have to find two such numbers that are 
+the elements of the array and their xor is the minimum in value in comparison 
+to all the possible pairs of the array.
+*/
+
+#include<bits/stdc++.h>
+using namespace std;
+
+void Min_xor(int*A,int n)
+{
+    //ele1 and ele2 will store the value of the elements that gives minimum xor value
+    int ele1,ele2;
+    //ans will store the minimum xor value
+    int ans=INT_MAX;
+    for(int i=0;i<n-1;i++)
+    {
+        //x will store xor value for each possible pair of elements of array
+        int x=A[i]^A[i+1];
+        if(x<ans)
+        {
+            ans=x;
+            ele1=A[i];
+            ele2=A[i+1];
+        } 
+    }
+    //printing the output
+    cout<<"The Minimum xor value is : "<<ans<<endl;
+    cout<<"The corresponding elements are : "<<ele1<<" and "<<ele2;
+}
+
+int main() {
+    //n will store the size of the array
+    int n;
+    cout<<"Enter the size of array : ";
+    cin>>n;
+    cout<<"Enter the array : ";
+    int A[n];
+    for(int i=0;i<n;i++)
+    cin>>A[i];
+    //sort() will sort the array in increasing order
+    sort(A,A+n);
+    //calling the function
+    Min_xor(A,n);
+    return 0;
+}
+
+/*
+INPUT:
+Enter the size of array : 4
+Enter the array : 0 2 5 7
+OUTPUT:
+The Minimum xor value is : 2
+The corresponding elements are : 0 and 2
+
+Time Complexity : O(nlogn)
+Space Complexity : O(1)
+*/

Arrays/Minimum_XOR_Value.cpp

@@ -0,0 +1,50 @@
+// Trapping Rain Water
+//Approach 1
+// O(n^2) O(1)
+
+//i/p: 3 0 1 2 5
+//o/p: 6
+
+//Brute force approach
+
+#include<bits/stdc++.h>
+using namespace std;
+int traprain(int arr[],int n)
+{ // To store the maximum water
+    // that can be stored
+    int res = 0;
+
+// i/p: 3 0 1 2 5
+//o/p: 6
+
+    // For every element of the array
+    for (int i = 1; i < n-1; i++) {
+
+        // Find the maximum element on its left from o th to i th value
+        int left = arr[i];
+        for (int j=0; j<i; j++)                 //o(n^2)
+           left = max(left, arr[j]);
+
+        // Find the maximum element on its right from j th th value to end
+        int right = arr[i];
+        for (int j=i+1; j<n; j++)
+           right = max(right, arr[j]);
+
+       // Update the maximum water
+       res = res + (min(left, right) - arr[i]); // 3 + 2 + 1
+    }
+
+    return res;
+}
+int main()
+{
+    int n;
+    cout<<"Enter the number of elements in the array\n";
+    cin>>n;
+    int arr[n];
+    cout<<"Enter the elements in  the array\n";
+    for(int i=0;i<n;i++)
+        cin>>arr[i];
+    cout<<"Total trapped water is "<<traprain(arr,n);
+    return 0;
+}

Arrays/trapping_rain_water_brute_force.cpp

@@ -0,0 +1,61 @@
+// Trapping Rain Water
+//Approach 2
+// O(n) O(2n)
+
+//i/p: 3 0 1 2 5
+//o/p: 6
+
+//Use 2 extra arrays
+
+#include<bits/stdc++.h>
+using namespace std;
+int getwater(int arr[],int n)
+{
+   int res=0;
+   int lmax[n],rmax[n];
+
+   	//left max
+   lmax[0]=arr[0];
+   for(int i=1;i<n;i++)
+        lmax[i]=max(arr[i],lmax[i-1]);
+
+			//starts from start to end
+			//1st element as it is other max will place in lmax
+			//Array is 5 0 6 2 3
+//					   |/\/\/\/\
+			 //lmax is 5 5 6 6 6
+
+	//right max
+   	rmax[n-1]=arr[n-1];
+   for(int i=n-2;i>=0;i--)
+    rmax[i]=max(arr[0],rmax[i+1]);
+
+	//starts from end to start
+	//last element as it is other max will place in rmax
+		//Array is 5 0 6 2 3
+//			       /\/\/\/\|
+   		 //rmax is 6 6 6 3 3
+
+   //here we get result
+   for(int i=1;i<n-1;i++)
+    res+=(min(lmax[i],rmax[i])-arr[i]);
+
+//    min(lmax,rmax)-arr[i]    min        arr[i]
+//		5 5 6 6 6			5 5 6 3 3 - 5 0 6 2 3 = 0+5+0+1+0=6
+//		6 6 6 3 3
+
+
+   return res;
+}
+int main()
+{
+	int n;
+    cout<<"Enter the number of elements in the array\n";
+    cin>>n;
+    int arr[n];
+    cout<<"Enter the elements in  the array\n";
+    for(int i=0;i<n;i++)
+        cin>>arr[i];
+    cout<<"Total trapped water is "<<getwater(arr,n);
+    return 0;
+}