🚀 20-Aug-2020

Author: sureshmangs

algorithms/sorting/quick_select.cpp

@@ -0,0 +1,54 @@
+/*
+Input: arr[] = {7, 10, 4, 3, 20, 15}
+           k = 3
+Output: 7
+
+Input: arr[] = {7, 10, 4, 3, 20, 15}
+           k = 4
+Output: 10
+*/
+
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int partion(int a[], int low, int high){
+    int pivot=a[high];
+    int pIndex=low;
+    for(int i=low; i< high; i++){
+        if(a[i] <= pivot){
+            swap(a[i], a[pIndex]);
+            pIndex++;
+        }
+    }
+    swap(a[pIndex], a[high]);
+    return pIndex;
+}
+
+int kthSmallest(int a[], int low, int high, int k){
+    // If k is smaller than number of elements in array
+    if(k > 0 && k <= high - low + 1){
+        int pIndex = partion(a, low, high);
+        if(pIndex-low == k-1) return a[pIndex];
+        else if(pIndex-low > k-1) kthSmallest(a, low, pIndex-1, k);
+        else kthSmallest(a, pIndex+1, high, k-pIndex+low-1);
+    }
+    // If k is more than number of elements in array
+    else return INT_MAX;
+}
+
+int main(){
+    int n;
+    cin>>n;
+    int a[n];
+    for(int i=0;i<n;i++) cin>>a[i];
+    int k;
+    cin>>k;
+
+    cout<<kthSmallest(a, 0, n-1, k);   // <array , low, high>
+}

algorithms/sorting/quick_sort.cpp

@@ -0,0 +1,51 @@
+/*
+Example 1:
+
+Input: N = 5, arr[] = { 4, 1, 3, 9, 7}
+Output: 1 3 4 7 9
+Example 2:
+
+Input: N = 10,
+arr[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}
+Output: 1 2 3 4 5 6 7 8 9 10
+*/
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int partion(int a[], int low, int high){
+    int pivot=a[high];
+    int pIndex=low;
+    for(int i=low; i< high; i++){
+        if(a[i] <= pivot){
+            swap(a[i], a[pIndex]);
+            pIndex++;
+        }
+    }
+    swap(a[pIndex], a[high]);
+    return pIndex;
+}
+
+void quickSort(int a[], int low, int high){
+    if(low < high){
+        int pIndex = partion(a, low, high);
+        quickSort(a, low, pIndex-1);
+        quickSort(a, pIndex, high);
+    }
+}
+
+int main(){
+    int n;
+    cin>>n;
+    int a[n];
+    for(int i=0;i<n;i++) cin>>a[i];
+
+    quickSort(a, 0, n-1);   // <array , low, high>
+
+    for(int i=0;i<n;i++) cout<<a[i]<<" ";
+}

array/trapping_rain_water.cpp

@@ -38,3 +38,31 @@ int main(){
 
 return 0;
 }
+
+
+
+
+
+
+//  TC O(N) SC: O(1)
+/*
+int trap(vector<int>& height) {
+        int trapped=0;
+        int n=height.size();
+        int l=0, r=n-1;
+        int maxLeft=0, maxRight=0;
+
+        while(l<r){
+            if(height[l]>height[r]){
+                if(height[r]>maxRight) maxRight=height[r];
+                else trapped+=maxRight-height[r];
+                r--;
+            } else {
+                if(height[l]>maxLeft) maxLeft=height[l];
+                else trapped+=maxLeft-height[l];
+                l++;
+            }
+        }
+      return trapped;
+     }
+*/

competitive programming/leetcode/29. Divide Two Integers.cpp

@@ -39,3 +39,42 @@ class Solution {
         return dividend/divisor;
     }
 };
+
+
+
+
+
+class Solution {
+public:
+    int divide(int dividend, int divisor) {
+        long long n=dividend, m=divisor;
+        if(n <= INT_MIN && m == -1) return INT_MAX;
+
+        int sign = (n < 0) ^ (m < 0) ? -1: 1;
+
+        n=abs(n);
+        m=abs(m);
+
+        long long q=0, temp=0;
+
+        for(int i=31; i>=0; i--){
+            if(temp + (m << i) <= n){
+                temp += m << i;
+                q += 1 << i;     // q |= 1 << i;
+            }
+        }
+        return sign * q;
+    }
+};
+
+
+/*
+dividend = quotient * divisor + remainder
+dividend -  quotient * divisor  >= 0
+So here we find highest value of quotient
+We start with highest value of i  ie:  (divisor * 2^31) .... (divisor * 2^30)..................(divisor * 2^0)
+here (m << i) is equivalent to m * 2^i
+we keep adding (1 << i) or in other words 2^i to quotient
+*/
+
+

competitive programming/leetcode/42. Trapping Rain Water.cpp

@@ -40,3 +40,37 @@ class Solution {
         return waterTrap;
     }
 };
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int trap(vector<int>& height) {
+        int trapped=0;
+        int n=height.size();
+        int l=0, r=n-1;
+        int maxLeft=0, maxRight=0;
+
+        while(l<r){
+            if(height[l]>height[r]){
+                if(height[r]>maxRight) maxRight=height[r];
+                else trapped+=maxRight-height[r];
+                r--;
+            } else {
+                if(height[l]>maxLeft) maxLeft=height[l];
+                else trapped+=maxLeft-height[l];
+                l++;
+            }
+        }
+      return trapped;
+     }
+};