🚀 03-Jul-2020

Author: sureshmangs

array/count_of_element_binary_search.cpp

@@ -0,0 +1,86 @@
+/*
+Given a sorted array A of size N and a number X, you need to find the number of occurrences of X in A.
+
+Input:
+The first line of input contains an integer T denoting the number of test cases. T testcases follow. Each testcase contains two lines of input: The first line contains N and X(element whose occurrence needs to be counted). The second line contains the elements of the array separated by spaces.
+
+Output:
+For each testcase, print the count of the occurrences of X in the array, if count is zero then print -1.
+
+Constraints:
+1 ≤ T ≤ 100
+1 ≤ N ≤ 105
+1 ≤ A[i] ≤ 103
+1 <= X <= 103
+
+Example:
+Input:
+2
+7 2
+1 1 2 2 2 2 3
+7 4
+1 1 2 2 2 2 3
+Output:
+4
+-1
+
+Explanation:
+Testcase 1: 2 occurs 4 times in 1 1 2 2 2 2 3
+Testcase 2: 4 is not present in 1 1 2 2 2 2 3
+*/
+
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int first(int a[], int n, int x){
+    int l=0, r=n-1, mid, res=-1;
+    while(l<=r){
+        mid=l+(r-l)/2;
+        if(a[mid]==x){
+            res=mid;
+            r=mid-1;
+        } else if(a[mid]<x) l=mid+1;
+        else r=mid-1;
+    }
+    return res;
+}
+
+int last(int a[], int n, int x){
+    int l=0, r=n-1, mid, res=-1;
+    while(l<=r){
+        mid=l+(r-l)/2;
+        if(a[mid]==x){
+            res=mid;
+           l=mid+1;
+        } else if(a[mid]<x) l=mid+1;
+        else r=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;
+        int a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+        int f=first(a, n, x);
+        int l=last(a, n, x);
+        if(f>=0)
+            cout<<l-f+1<<endl;
+        else cout<<"-1"<<endl;
+    }
+
+return 0;
+}

array/num_of_rotation_in_sorted_array_binary_search.cpp

@@ -0,0 +1,28 @@
+/*
+Given a sorted array A of size N. The array is rotated 'K' times. Find the value of 'K'.
+
+Input:
+The first line contains an integer T, depicting total number of test cases. T testcases follow. Each testcase contains two lines of input. The first line contains an integer N depicting the size of array. The next line contains elements of the array separated by spaces.
+
+Output:
+For each testcase, print the value of K.
+
+Constraints:
+1 <= T <= 100
+1 <= N <=107
+0 <= Ai <= 1018
+
+Example:
+Input
+2
+5
+5 1 2 3 4
+5
+1 2 3 4 5
+Output
+1
+0
+
+Explanation:
+Testcase1: 5 1 2 3 4. The original sorted array is 1 2 3 4 5. We can see that the array was rotated 1 times to the right.
+*/

competitive programming/leetcode/107. Binary Tree Level Order Traversal II.cpp

@@ -0,0 +1,59 @@
+Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).
+
+For example:
+Given binary tree [3,9,20,null,null,15,7],
+    3
+   / \
+  9  20
+    /  \
+   15   7
+return its bottom-up level order traversal as:
+[
+  [15,7],
+  [9,20],
+  [3]
+]
+
+
+
+
+
+
+
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+
+    vector<vector<int>> levelOrderBottom(TreeNode* root) {
+        vector<vector<int> > res;
+        if(!root) return res;
+        queue<TreeNode*> q;
+        int size;
+        q.push(root);
+        while(!q.empty()){
+            size=q.size();
+            vector<int> tmp;
+            while(size--){
+                TreeNode* curr=q.front();
+                q.pop();
+                if(curr->left) q.push(curr->left);
+                if(curr->right) q.push(curr->right);
+                tmp.push_back(curr->val);
+            }
+            res.push_back(tmp);
+        }
+        reverse(res.begin(), res.end());
+        return res;
+    }
+};

competitive programming/leetcode/2020-July-Challenge/Day-02-Binary Tree Level Order Traversal II.cpp

@@ -0,0 +1,59 @@
+Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).
+
+For example:
+Given binary tree [3,9,20,null,null,15,7],
+    3
+   / \
+  9  20
+    /  \
+   15   7
+return its bottom-up level order traversal as:
+[
+  [15,7],
+  [9,20],
+  [3]
+]
+
+
+
+
+
+
+
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+
+    vector<vector<int>> levelOrderBottom(TreeNode* root) {
+        vector<vector<int> > res;
+        if(!root) return res;
+        queue<TreeNode*> q;
+        int size;
+        q.push(root);
+        while(!q.empty()){
+            size=q.size();
+            vector<int> tmp;
+            while(size--){
+                TreeNode* curr=q.front();
+                q.pop();
+                if(curr->left) q.push(curr->left);
+                if(curr->right) q.push(curr->right);
+                tmp.push_back(curr->val);
+            }
+            res.push_back(tmp);
+        }
+        reverse(res.begin(), res.end());
+        return res;
+    }
+};

competitive programming/leetcode/33. Search in Rotated Sorted Array.cpp

@@ -0,0 +1,71 @@
+Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+
+(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).
+
+You are given a target value to search. If found in the array return its index, otherwise return -1.
+
+You may assume no duplicate exists in the array.
+
+Your algorithm's runtime complexity must be in the order of O(log n).
+
+Example 1:
+
+Input: nums = [4,5,6,7,0,1,2], target = 0
+Output: 4
+Example 2:
+
+Input: nums = [4,5,6,7,0,1,2], target = 3
+Output: -1
+
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    int pivot(vector<int>&nums){
+        int l=0, r=nums.size()-1, mid, n=nums.size();
+            while(l<=r){
+                mid=l+(r-l)/2;
+                int prev=(mid-1+n)%n;
+                int next=(mid+1)%n;
+                if(nums[mid]<nums[prev] && nums[mid]<nums[next])
+                     return mid;
+                else if(nums[mid]<nums[r]) r=mid-1;
+                else l=mid+1;
+            }
+            return -1;
+    }
+
+    int bSearch(vector<int> &nums, int l, int r, int target){
+        int mid;
+        while(l<=r){
+            mid=l+(r-l)/2;
+            if(nums[mid]==target) return mid;
+            else if(nums[mid]<target) l=mid+1;
+            else r=mid-1;
+        }
+        return -1;
+    }
+
+
+    int search(vector<int>& nums, int target) {
+        int n=nums.size();
+        if(n<=0) return -1;
+       if(n==1){
+           if(nums[0]==target) return 0;
+           else return -1;
+       }
+
+        int piv=pivot(nums);
+        int left=bSearch(nums,0, piv-1, target);
+        int right=bSearch(nums,piv, n-1, target);
+        if(left>=0) return left;
+        else if(right>=0) return right;
+        else return -1;
+    }
+};