Revert "Renamed files and added 5 problems (#370)" (#398)

This reverts commit d838d01.

Author: Adarsh-jaiss

.DS_Store

@@ -1,4 +1,3 @@
-// https://leetcode.com/problems/binary-tree-level-order-traversal/
 class Solution {
 public:
     vector<vector<int>> levelOrder(TreeNode* root) {

CPP/.DS_Store

@@ -1,95 +1,95 @@
-// Bitonic array is an array having strictly increasing order upto an element and then having strictly
-// decreasing order. It is also called Mountain array.
+    // Bitonic array is an array having strictly increasing order upto an element and then having strictly
+    // decreasing order. It is also called Mountain array.
 
-// Program to find element in a bitonic array
-// T.C.: O(log n)
-// S.C.: O(1)
-#include <iostream>
-#include <vector>
-using namespace std;
+    // Program to find element in a bitonic array
+    // T.C.: O(log n)
+    // S.C.: O(1)
+    #include <iostream>
+    #include <vector>
+    using namespace std;
 
-int findPeakIndex (vector<int> vect, int size) { // find index of peak element
-    int lo = 0, hi = size-1;
-    int mid = lo + (hi - lo)/2;
+    int findPeakIndex (vector<int> vect, int size) { // find index of peak element
+        int lo = 0, hi = size-1;
+        int mid = lo + (hi - lo)/2;
 
-    while (lo < hi) {
-        if (mid == size-1 || vect[mid] > vect[mid+1]) {
-            hi = mid;
+        while (lo < hi) {
+            if (mid == size-1 || vect[mid] > vect[mid+1]) {
+                hi = mid;
+            }
+            else if (mid == 0 || vect[mid] > vect[mid-1]) {
+                lo = mid+1;
+            }
+            mid = lo + (hi - lo)/2;
         }
-        else if (mid == 0 || vect[mid] > vect[mid-1]) {
-            lo = mid+1;
-        }
-        mid = lo + (hi - lo)/2;
+        return lo;
     }
-    return lo;
-}
 
-int leftPart (vector<int> vect, int target, int hi) { // search element in left part
-    int lo = 0;
-    int mid = lo + (hi - lo)/2;
-    while (lo <= hi) {
-        if (vect[mid] == target) {
-            return mid;
-        }
-        else if (vect[mid] > target) {
-            hi = mid - 1;
+    int leftPart (vector<int> vect, int target, int hi) { // search element in left part
+        int lo = 0;
+        int mid = lo + (hi - lo)/2;
+        while (lo <= hi) {
+            if (vect[mid] == target) {
+                return mid;
+            }
+            else if (vect[mid] > target) {
+                hi = mid - 1;
+            }
+            else {
+                lo = mid + 1;
+            }
+            mid = lo + (hi - lo)/2;
         }
-        else {
-            lo = mid + 1;
-        }
-        mid = lo + (hi - lo)/2;
+        return -1;
     }
-    return -1;
-}
 
-int rightPart (vector<int> vect, int target, int lo) { // search element in right part
-    int hi = vect.size()-1;
-    int mid = lo + (hi - lo)/2;
-    while (lo <= hi) {
-        if (vect[mid] == target) {
-            return mid;
-        }
-        else if (vect[mid] < target) {
-            hi = mid - 1;
+    int rightPart (vector<int> vect, int target, int lo) { // search element in right part
+        int hi = vect.size()-1;
+        int mid = lo + (hi - lo)/2;
+        while (lo <= hi) {
+            if (vect[mid] == target) {
+                return mid;
+            }
+            else if (vect[mid] < target) {
+                hi = mid - 1;
+            }
+            else {
+                lo = mid + 1;
+            }
+            mid = lo + (hi - lo)/2;
         }
-        else {
-            lo = mid + 1;
-        }
-        mid = lo + (hi - lo)/2;
+        return -1;
     }
-    return -1;
-}
 
-int findElement(vector<int> vect, int size, int target) {
-    // DRIVER CODE
-    // find peak of array
-    int peak = findPeakIndex (vect, size);
-    // compare peak element with target
-    if (target > vect[peak]) {return -1;}
-    else if (target == vect[peak]) {return peak;}
-    // find element in increasing/decreasing sequence
-    else {
-        int leftIndex = leftPart(vect, target, peak);
-        if (leftIndex != -1) {
-            return leftIndex;
-        }
+    int findElement(vector<int> vect, int size, int target) {
+        // DRIVER CODE
+        // find peak of array
+        int peak = findPeakIndex (vect, size);
+        // compare peak element with target
+        if (target > vect[peak]) {return -1;}
+        else if (target == vect[peak]) {return peak;}
+        // find element in increasing/decreasing sequence
         else {
-            return rightPart(vect, target, peak);
+            int leftIndex = leftPart(vect, target, peak);
+            if (leftIndex != -1) {
+                return leftIndex;
+            }
+            else {
+                return rightPart(vect, target, peak);
+            }
         }
+        return 0;
     }
-    return 0;
-}
 
-int main () {
-    vector<int> numvect;
-    int num, target;
-    cin>>num;
-    cin>>target;
-    for (int i = 0; i < num; i++) {
-        int temp;
-        cin>>temp;
-        numvect.push_back(temp);
+    int main () {
+        vector<int> numvect;
+        int num, target;
+        cin>>num;
+        cin>>target;
+        for (int i = 0; i < num; i++) {
+            int temp;
+            cin>>temp;
+            numvect.push_back(temp);
+        }
+        cout<<findElement(numvect, num, target);
+        return 0;
     }
-    cout<<findElement(numvect, num, target);
-    return 0;
-}

CPP/Problems/.DS_Store

@@ -1,4 +1,3 @@
-// https://leetcode.com/problems/container-with-most-water/
 class Solution {
 public:
     int maxArea(vector<int>& height) {

CPP/Problems/Leetcode-102-Binary-Tree-Level-Order-Traversal.cpp renamed to CPP/Problems/BinaryTreeLevelOrderTraversal.cpp

@@ -1,4 +1,6 @@
+// Question Link
 // https://leetcode.com/problems/delete-and-earn/
+// ----------------------------------------------
 class Solution {
 public:
     int deleteAndEarn(vector<int>& nums) {

CPP/Problems/BitonicArray.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    vector<int> searchRange(vector<int>& nums, int target) {
+        vector<int>ans;
+     auto low=lower_bound(nums.begin(),nums.end(),target);
+        auto upp=upper_bound(nums.begin(),nums.end(),target);
+        if(low==nums.end()|| *low!=target )
+        {
+            ans.push_back(-1);
+              ans.push_back(-1);
+        }
+        else
+        {
+            int start=low-nums.begin();
+            int end=upp-nums.begin()-1;
+            ans.push_back(start);
+             ans.push_back(end);
+        }
+        return ans;
+    }
+};

CPP/Problems/Leetcode-11-Container-With-Most-Water.cpp renamed to CPP/Problems/Container With Most Water.cpp

@@ -1,22 +1,36 @@
-// https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/
 class Solution {
 public:
     vector<int> searchRange(vector<int>& nums, int target) {
-        vector<int>ans;
-     auto low=lower_bound(nums.begin(),nums.end(),target);
-        auto upp=upper_bound(nums.begin(),nums.end(),target);
-        if(low==nums.end()|| *low!=target )
-        {
-            ans.push_back(-1);
-              ans.push_back(-1);
+        int n=nums.size();
+        int l=0,r=n-1;
+        int p1=-1,p2=-1;
+        while(l<=r){
+            int mid=l+(r-l)/2;
+            if(nums[mid]==target){
+                p1=mid;
+                r=mid-1;
+            }
+            else if(nums[mid]>target){
+                r=mid-1;
+            }
+            else
+                l=mid+1;
         }
-        else
-        {
-            int start=low-nums.begin();
-            int end=upp-nums.begin()-1;
-            ans.push_back(start);
-             ans.push_back(end);
+        l=0,r=n-1;
+        while(l<=r){
+            int mid=l+(r-l)/2;
+            if(nums[mid]>=target+1){
+                r=mid-1;
+            }
+            else{
+                
+                l=mid+1;
+            }
+                
         }
-        return ans;
+        p2=l;
+        if(p1!=-1)
+        return {p1,p2-1};
+        return {-1,-1};
     }
 };

CPP/Problems/Leetcode-740-Delete-And-Earn.cpp renamed to CPP/Problems/Delete_and_Earn.cpp

@@ -1,4 +1,3 @@
-// https://leetcode.com/problems/longest-continuous-increasing-subsequence/
 class Solution {
 public:
     int findLengthOfLCIS(vector<int>& nums) {