🚀 16-Aug-2020

Author: sureshmangs

competitive programming/leetcode/1550. Three Consecutive Odds.cpp

@@ -0,0 +1,39 @@
+Given an integer array arr, return true if there are three consecutive odd numbers in the array. Otherwise, return false.
+
+
+Example 1:
+
+Input: arr = [2,6,4,1]
+Output: false
+Explanation: There are no three consecutive odds.
+Example 2:
+
+Input: arr = [1,2,34,3,4,5,7,23,12]
+Output: true
+Explanation: [5,7,23] are three consecutive odds.
+
+
+Constraints:
+
+1 <= arr.length <= 1000
+1 <= arr[i] <= 1000
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    bool threeConsecutiveOdds(vector<int>& arr) {
+        int n=arr.size();
+        if(n<=2) return false;
+        for(int i=0;i<n-2;i++){
+            if(arr[i]%2!=0 && arr[i+1]%2!=0 && arr[i+2]%2!=0)
+                return true;
+        }
+        return false;
+    }
+};

competitive programming/leetcode/1551. Minimum Operations to Make Array Equal.cpp

@@ -0,0 +1,51 @@
+You have an array arr of length n where arr[i] = (2 * i) + 1 for all valid values of i (i.e. 0 <= i < n).
+
+In one operation, you can select two indices x and y where 0 <= x, y < n and subtract 1 from arr[x] and add 1 to arr[y] (i.e. perform arr[x] -=1 and arr[y] += 1). The goal is to make all the elements of the array equal. It is guaranteed that all the elements of the array can be made equal using some operations.
+
+Given an integer n, the length of the array. Return the minimum number of operations needed to make all the elements of arr equal.
+
+
+
+Example 1:
+
+Input: n = 3
+Output: 2
+Explanation: arr = [1, 3, 5]
+First operation choose x = 2 and y = 0, this leads arr to be [2, 3, 4]
+In the second operation choose x = 2 and y = 0 again, thus arr = [3, 3, 3].
+Example 2:
+
+Input: n = 6
+Output: 9
+
+
+Constraints:
+
+1 <= n <= 10^4
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int minOperations(int n) {
+        int res=0;
+        int first = 1;
+        int last = 2 * (n-1) + 1;
+        int i=0;
+        while(i<n/2){
+            res+=(last-first)/2;
+            last-=2;
+            first+=2;
+            i++;
+        }
+        return res;
+    }
+};

competitive programming/leetcode/2020-August-Challenge/Day-15-Non-overlapping Intervals.cpp

@@ -0,0 +1,71 @@
+Given a collection of intervals, find the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.
+
+
+
+Example 1:
+
+Input: [[1,2],[2,3],[3,4],[1,3]]
+Output: 1
+Explanation: [1,3] can be removed and the rest of intervals are non-overlapping.
+Example 2:
+
+Input: [[1,2],[1,2],[1,2]]
+Output: 2
+Explanation: You need to remove two [1,2] to make the rest of intervals non-overlapping.
+Example 3:
+
+Input: [[1,2],[2,3]]
+Output: 0
+Explanation: You don't need to remove any of the intervals since they're already non-overlapping.
+
+
+Note:
+
+You may assume the interval's end point is always bigger than its start point.
+Intervals like [1,2] and [2,3] have borders "touching" but they don't overlap each other.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    static bool comp(vector<int> a, vector<int> b){
+        return a[1] < b[1];
+    }
+
+    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
+        int res=0;
+        int n=intervals.size();
+        if(n==0) return 0;
+
+        sort(intervals.begin(), intervals.end(), comp);
+
+
+        pair<int, int> cur;
+        cur.first=intervals[0][0];
+        cur.second=intervals[0][1];
+
+        for(int i=1;i<n;i++){
+            if(cur.second>intervals[i][0]){
+                res++;
+            } else {
+                cur.first=intervals[i][0];
+                cur.second=intervals[i][1];
+            }
+        }
+        return res;
+    }
+};

competitive programming/leetcode/435. Non-overlapping Intervals.cpp

@@ -0,0 +1,71 @@
+Given a collection of intervals, find the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.
+
+
+
+Example 1:
+
+Input: [[1,2],[2,3],[3,4],[1,3]]
+Output: 1
+Explanation: [1,3] can be removed and the rest of intervals are non-overlapping.
+Example 2:
+
+Input: [[1,2],[1,2],[1,2]]
+Output: 2
+Explanation: You need to remove two [1,2] to make the rest of intervals non-overlapping.
+Example 3:
+
+Input: [[1,2],[2,3]]
+Output: 0
+Explanation: You don't need to remove any of the intervals since they're already non-overlapping.
+
+
+Note:
+
+You may assume the interval's end point is always bigger than its start point.
+Intervals like [1,2] and [2,3] have borders "touching" but they don't overlap each other.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    static bool comp(vector<int> a, vector<int> b){
+        return a[1] < b[1];
+    }
+
+    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
+        int res=0;
+        int n=intervals.size();
+        if(n==0) return 0;
+
+        sort(intervals.begin(), intervals.end(), comp);
+
+
+        pair<int, int> cur;
+        cur.first=intervals[0][0];
+        cur.second=intervals[0][1];
+
+        for(int i=1;i<n;i++){
+            if(cur.second>intervals[i][0]){
+                res++;
+            } else {
+                cur.first=intervals[i][0];
+                cur.second=intervals[i][1];
+            }
+        }
+        return res;
+    }
+};