Binary-search

Author: prajwal714

Leetcode/Binary Searching/find-k-closest-elements.cpp

@@ -0,0 +1,62 @@
+class Solution {
+public:
+    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
+        
+        int pos=-1;
+        int left=0, right=arr.size()-1;
+        int n=arr.size();
+        
+        if(x<arr[0])
+            return vector<int>(arr.begin(),arr.begin()+k);
+        else if(x>arr[n-1])
+            return vector<int>(arr.begin()+(n-k),arr.end());
+        
+        
+        while(left<=right)
+        {
+            int mid=left+(right-left)/2;
+            
+            if(arr[mid]<=x)
+            {
+                pos=mid;
+                left=mid+1;
+                
+            }
+            else
+                right=mid-1;
+        }
+        
+        vector<int> res;
+        
+        
+       
+        left=pos; right=pos+1;
+        while(k--)
+        {
+            int left_diff=INT_MAX, right_diff=INT_MAX;
+            
+            if(left>=0)
+                left_diff=abs(x-arr[left]);
+            
+            if(right<arr.size())
+                right_diff=abs(x-arr[right]);
+            
+            
+            if(left_diff<=right_diff)
+            {
+                res.push_back(arr[left]);
+                left--;
+            }
+            else
+                res.push_back(arr[right++]);
+            
+           
+        }
+        sort(res.begin(),res.end());
+        return res;
+        
+        
+        
+        
+    }
+};

Leetcode/Binary Searching/find-smallest-element-greater-than-target.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    char nextGreatestLetter(vector<char>& letters, char target) {
+        
+        int n=letters.size();
+        if(target>=letters[n-1] || target<letters[0])
+            return letters[0];
+        
+       int left=0,right=n-1;
+        int pos=-1;
+        while(left<=right)
+        {
+            int mid=left+(right-left)/2;
+            
+            if(letters[mid]>target)
+            {
+                pos=mid;
+                right=mid-1;
+            }
+            else
+                left=mid+1;
+        }
+        
+        return letters[pos];
+    }
+};

Leetcode/Binary Searching/is-perfect-square.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    bool isPerfectSquare(int num) {
+        
+        if(num==1)
+            return true;
+        
+        
+        
+        int low=1,high=num/2;
+        
+        while(low<=high)
+        {
+            int mid=low+(high-low)/2;
+            
+            if(mid==num/mid && num%mid==0)
+                return true;
+            else if(mid<num/mid)
+                low=mid+1;
+            else
+                high=mid-1;
+        }
+        
+        return false;
+    }
+};

Leetcode/Math/my-pow.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    double myPow(double x, int n) {
+        
+        if(x==1)
+            return 1;
+        
+        if(n==0)
+            return 1;
+        if(n<0)
+        {
+            if(n==INT_MIN) //this is to handle the case t avoid overflow of INT_MIN on -ve to +ve
+                n+=2;
+            
+            n=-n;
+            x=1/x;
+            return myPow(x,n);
+        }
+        
+        if(n%2==0)
+            return myPow(x*x, n/2);
+        else
+            return x*myPow(x*x, n/2);
+    }
+};