🚀 04-Jul-2020

sureshmangs · sureshmangs · commit bd38a2cab1bc · 2020-07-04T09:25:23.000+05:30
diff --git a/array/floor_of_num_in_sorted_array_binary_search.cpp b/array/floor_of_num_in_sorted_array_binary_search.cpp
@@ -0,0 +1,77 @@
+/*
+Given a sorted array arr[] of size N without duplicates, and given a value x. Find the floor of x in given array. Floor of x is defined as the largest element K in arr[] such that K is smaller than or equal to x.
+
+Input:
+First line of input contains number of testcases T. For each testcase, first line of input contains number of elements in the array and element whose floor is to be searched. Last line of input contains array elements.
+
+Output:
+Output the index of floor of x if exists, else print -1.
+
+Constraints:
+1 ≤ T ≤ 100
+1 ≤ N ≤ 107
+1 ≤ arr[i] ≤ 1018
+0 ≤ X ≤ arr[n-1]
+
+Example:
+Input:
+3
+7 0
+1 2 8 10 11 12 19
+7 5
+1 2 8 10 11 12 19
+7 10
+1 2 8 10 11 12 19
+
+Output:
+-1
+1
+3
+
+Explanation:
+Testcase 1: No element less than 0 is found. So output is "-1".
+Testcase 2: Number less than 5 is 2, whose index is 1(0-based indexing).
+*/
+
+
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int getFloor(long long a[], int n, int x){
+    int l=0, h=n-1, mid, res=-1;
+    while(l<=h){
+        mid=l+(h-l)/2;
+        if(a[mid]==x){
+            return mid;
+            h=mid-1;
+        }
+       else  if(a[mid]<x){
+           res=mid;  // possible result
+           l=mid+1;
+       } else h=mid-1;
+    }
+    return res;
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n, x;
+        cin>>n>>x;
+        long long a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+        cout<<getFloor(a, n, x)<<endl;
+    }
+
+return 0;
+}
diff --git a/competitive programming/leetcode/2020-July-Challenge/Day-03-Prison Cells After N Days.cpp b/competitive programming/leetcode/2020-July-Challenge/Day-03-Prison Cells After N Days.cpp
@@ -0,0 +1,73 @@
+There are 8 prison cells in a row, and each cell is either occupied or vacant.
+
+Each day, whether the cell is occupied or vacant changes according to the following rules:
+
+If a cell has two adjacent neighbors that are both occupied or both vacant, then the cell becomes occupied.
+Otherwise, it becomes vacant.
+(Note that because the prison is a row, the first and the last cells in the row can't have two adjacent neighbors.)
+
+We describe the current state of the prison in the following way: cells[i] == 1 if the i-th cell is occupied, else cells[i] == 0.
+
+Given the initial state of the prison, return the state of the prison after N days (and N such changes described above.)
+
+
+
+Example 1:
+
+Input: cells = [0,1,0,1,1,0,0,1], N = 7
+Output: [0,0,1,1,0,0,0,0]
+Explanation:
+The following table summarizes the state of the prison on each day:
+Day 0: [0, 1, 0, 1, 1, 0, 0, 1]
+Day 1: [0, 1, 1, 0, 0, 0, 0, 0]
+Day 2: [0, 0, 0, 0, 1, 1, 1, 0]
+Day 3: [0, 1, 1, 0, 0, 1, 0, 0]
+Day 4: [0, 0, 0, 0, 0, 1, 0, 0]
+Day 5: [0, 1, 1, 1, 0, 1, 0, 0]
+Day 6: [0, 0, 1, 0, 1, 1, 0, 0]
+Day 7: [0, 0, 1, 1, 0, 0, 0, 0]
+
+Example 2:
+
+Input: cells = [1,0,0,1,0,0,1,0], N = 1000000000
+Output: [0,0,1,1,1,1,1,0]
+
+
+Note:
+
+cells.length == 8
+cells[i] is in {0, 1}
+1 <= N <= 10^9
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> prisonAfterNDays(vector<int>& cells, int N) {
+        int n=cells.size();
+        vector<int> res=cells;
+
+        bool first=true;
+        if(N>14) N=(N%14)+14;
+        while(N--){
+            for(int i=1;i<n-1;i++){
+                if(cells[i-1]==1 && cells[i+1]==1) res[i]=1;
+                else if(cells[i-1]==0 && cells[i+1]==0) res[i]=1;
+                else res[i]=0;
+            }
+            if(first){
+                res[0]=0;
+                res[n-1]=0;
+                first=false;
+            }
+            cells=res;
+        }
+
+        return res;
+    }
+};
diff --git a/competitive programming/leetcode/34. Find First and Last Position of Element in Sorted Array.cpp b/competitive programming/leetcode/34. Find First and Last Position of Element in Sorted Array.cpp
@@ -0,0 +1,70 @@
+Given an array of integers nums sorted in ascending order, find the starting and ending position of a given target value.
+
+Your algorithm's runtime complexity must be in the order of O(log n).
+
+If the target is not found in the array, return [-1, -1].
+
+Example 1:
+
+Input: nums = [5,7,7,8,8,10], target = 8
+Output: [3,4]
+Example 2:
+
+Input: nums = [5,7,7,8,8,10], target = 6
+Output: [-1,-1]
+
+
+Constraints:
+
+0 <= nums.length <= 10^5
+-10^9 <= nums[i] <= 10^9
+nums is a non decreasing array.
+-10^9 <= target <= 10^9
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int first(vector<int> &a, int n, int item){
+        int l=0, r=n-1, mid, res=-1;
+        while(l<=r){
+            mid=l+(r-l)/2;
+            if(a[mid]==item){
+                res=mid;    // can be a possible result
+                r=mid-1;
+            }
+            else if(a[mid]<item) l=mid+1;
+            else r=mid-1;
+        }
+        return res;
+    }
+
+    int last(vector<int> &a, int n, int item){
+        int l=0, r=n-1, mid, res=-1;
+        while(l<=r){
+            mid=l+(r-l)/2;
+            if(a[mid]==item){
+                res=mid;    // can be a possible result
+                l=mid+1;
+            }
+            else if(a[mid]<item) l=mid+1;
+            else r=mid-1;
+        }
+        return res;
+    }
+
+    vector<int> searchRange(vector<int>& a, int target) {
+        vector<int>res;
+        int n=a.size();
+        int f=first(a, n, target);
+        int l=last(a, n, target);
+        res.push_back(f);
+        res.push_back(l);
+        return res;
+    }
+};
diff --git a/competitive programming/leetcode/957. Prison Cells After N Days.cpp b/competitive programming/leetcode/957. Prison Cells After N Days.cpp
@@ -0,0 +1,73 @@
+There are 8 prison cells in a row, and each cell is either occupied or vacant.
+
+Each day, whether the cell is occupied or vacant changes according to the following rules:
+
+If a cell has two adjacent neighbors that are both occupied or both vacant, then the cell becomes occupied.
+Otherwise, it becomes vacant.
+(Note that because the prison is a row, the first and the last cells in the row can't have two adjacent neighbors.)
+
+We describe the current state of the prison in the following way: cells[i] == 1 if the i-th cell is occupied, else cells[i] == 0.
+
+Given the initial state of the prison, return the state of the prison after N days (and N such changes described above.)
+
+
+
+Example 1:
+
+Input: cells = [0,1,0,1,1,0,0,1], N = 7
+Output: [0,0,1,1,0,0,0,0]
+Explanation:
+The following table summarizes the state of the prison on each day:
+Day 0: [0, 1, 0, 1, 1, 0, 0, 1]
+Day 1: [0, 1, 1, 0, 0, 0, 0, 0]
+Day 2: [0, 0, 0, 0, 1, 1, 1, 0]
+Day 3: [0, 1, 1, 0, 0, 1, 0, 0]
+Day 4: [0, 0, 0, 0, 0, 1, 0, 0]
+Day 5: [0, 1, 1, 1, 0, 1, 0, 0]
+Day 6: [0, 0, 1, 0, 1, 1, 0, 0]
+Day 7: [0, 0, 1, 1, 0, 0, 0, 0]
+
+Example 2:
+
+Input: cells = [1,0,0,1,0,0,1,0], N = 1000000000
+Output: [0,0,1,1,1,1,1,0]
+
+
+Note:
+
+cells.length == 8
+cells[i] is in {0, 1}
+1 <= N <= 10^9
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> prisonAfterNDays(vector<int>& cells, int N) {
+        int n=cells.size();
+        vector<int> res=cells;
+
+        bool first=true;
+        if(N>14) N=(N%14)+14;
+        while(N--){
+            for(int i=1;i<n-1;i++){
+                if(cells[i-1]==1 && cells[i+1]==1) res[i]=1;
+                else if(cells[i-1]==0 && cells[i+1]==0) res[i]=1;
+                else res[i]=0;
+            }
+            if(first){
+                res[0]=0;
+                res[n-1]=0;
+                first=false;
+            }
+            cells=res;
+        }
+
+        return res;
+    }
+};
