Merge branch 'smv1999:master' into issue#439

Author: sidparashar2001

Arrays/Median_of_two_Sorted_arrays_of_different_size.cpp

@@ -0,0 +1,81 @@
+/* Given two sorted arrays, arr1[] and arr2[], the task is to find the 
+median of these sorted arrays different size. */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* Function to find Median of two Sorted array of different size */
+int solve()
+{
+    /* Input n1 = size of array 1
+       Input n2 = size of array 2 */
+    int n1,n2;
+    cout<<"Accept size of 1st Array : ";
+    cin >> n1 ;
+    cout<<"Accept size of 2nd Array : ";
+    cin>>n2;
+
+    int arr1[n1],arr2[n2];
+
+    /* Input values in array 1 */
+    cout<<"Accept the values of 1st Array : ";
+    for (int i = 0; i < n1; ++i)
+    {
+        cin >> arr1[i];
+    }
+
+    /* Input values in array 2 */
+    cout<<"Accept the values of 2nd Array : ";
+    for (int i = 0; i < n2; ++i)
+    {
+        cin >> arr2[i];
+    }
+
+    /* Create a vector */
+    vector<int> v;
+
+    /* Push array 1 element in vector */
+    for (int i = 0; i < n1; ++i)
+    {
+        v.push_back(arr1[i]);
+    }
+
+    /* Push array 2 element in vector */
+    for (int i = 0; i < n2; ++i)
+    {
+        v.push_back(arr2[i]);
+    }
+
+    /* Sort the given vector */
+    sort(v.begin(), v.end());
+    
+    /* Find medina using this formula */
+    int mid = v[v.size()/2];
+    
+    /* Return Calculated median */
+    return mid;
+}
+
+int main()
+{
+    int Median = solve();
+
+    cout << "Median is : " << Median <<endl;
+    return 0;
+}
+
+/*
+Test cases :
+    
+    Input :
+      Accept size of 1st Array : 1
+      Accept size of 2nd Array : 4
+      Accept the values of 1st Array : 900
+      Accept the values of 2nd Array : 5 8 10 20
+
+    Output :
+      Median is : 10
+    
+    Time complexity: O(nlogn)
+    Space Complexity: O(n)
+*/

Arrays/PeakElement.java

@@ -0,0 +1,31 @@
+import java.io.*;
+public class PeakElement {
+     // TC : O(logn)
+     // SC : O(1)
+  public static void main(String args[])throws IOException
+  {
+      InputStreamReader read=new InputStreamReader(System.in);
+      BufferedReader in=new BufferedReader(read);
+      int n,i;
+      System.out.println("Enter the size of the array");
+      n=Integer.parseInt(in.readLine());
+      int nums[]=new int[n];
+      System.out.println("Enter the elements of the array");
+      for(i=0;i<n;i++)
+      {
+          nums[i]=Integer.parseInt(in.readLine());
+      }
+    int low = 0;
+    int high = n-1;
+
+    while(low< high){
+      int mid = low + (high-low)/2;
+      if(nums[mid]<nums[mid+1]){
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+}
+System.out.println("The Peak Element is = "+nums[low]);
+  }
+}

Arrays/containerWithMostWater.cpp

@@ -0,0 +1,57 @@
+/* 
+Given n non-negative integers a1, a2, ..., an , where each represents a point at coordinate (i, ai). n 
+vertical lines are drawn such that the two endpoints of the line i is at (i, ai) and (i, 0). 
+Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.
+
+Notice that you may not slant the container.
+
+
+Input: height = [1,8,6,2,5,4,8,3,7]
+Output: 49
+Explanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. 
+In this case, the max area of water the container can contain is 49.
+
+Constraints:
+ n == height.length
+ 2 <= n <= 105
+ 0 <= height[i] <= 104
+  
+*/
+
+/*
+Time Complexity: O(N), where N is the size of the array
+Space Complexity: O(1), Constant Space
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+int maxArea(vector<int> &height)
+{
+    int n = height.size(); 
+    int i = 0; // one pointer to the start of the array
+    int j = n - 1; // one poninter to the end of the array
+    int mx = min(height[i], height[j]) * (j - i); // contains the max value of maximum water that can be stored
+    while (i < j) 
+    {
+        if (height[i] < height[j]) // Checking condition if height pointed by i is less than that pointed by j if yes => incrementing i and updating value of mx
+        {
+            i++;
+            mx = max(mx, (min(height[i], height[j]) * (j - i)));
+        }
+        else // otherwise =>  decrementing j and updating value of mx
+        {
+            j--;
+            mx = max(mx, (min(height[i], height[j]) * (j - i)));
+        }
+    }
+    return mx;
+}
+
+int main() // driver function
+{
+    vector<int> heights = {1,8,6,2,5,4,8,3,7};
+    int ans = maxArea(heights);
+    cout<<ans;
+    return 0;
+}

Arrays/searchInRotatedSortedArray.cpp

@@ -0,0 +1,86 @@
+/*
+There is an integer array nums sorted in ascending order (with distinct values).
+
+Prior to being passed to your function, nums is rotated at an unknown pivot index k (0 <= k < nums.length) such that 
+the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). 
+For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2].
+
+Given the array nums after the rotation and an integer target, return the index of target if it is in nums, or -1 
+if it is not in nums.
+
+You must write an algorithm with O(log n) runtime complexity.
+
+Input: nums = [4,5,6,7,0,1,2], target = 0
+Output: 4
+
+Constraints:
+ 1 <= nums.length <= 5000
+ -104 <= nums[i] <= 104
+ All values of nums are unique.
+ nums is guaranteed to be rotated at some pivot.
+ -104 <= target <= 104
+
+*/
+
+/*
+Time Complexity: O(log(N)), where N is the size of the array
+Space Complexity: O(1), Constant Space
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+int binarySearch(vector<int> arr, int l, int r, int x) // Function to perform Binary Search
+{
+    while(l<=r)
+    {
+        int m=(l+r)/2;
+        if(arr[m]==x)
+        return m;
+        else if(arr[m]<x)
+        l=m+1;
+        else
+        r=m-1;
+    }
+    return -1;
+}
+int search(const vector<int> &A, int B) 
+{
+    int l=0; // lower bound
+    int n=A.size();
+    int u=n-1; // upper bound
+    int index=-1; // to know the index upto which array is sorted i.e left,right of this will be sorted array
+    while(l<=u)
+    {
+        int m=(l+u)/2;
+        int prev=(m-1+n)%n;
+        int next=(m+1)%n;
+        if(A[l]<=A[u]) // If array is already sorted return lower bound
+        {
+            index=l;
+            break;
+        }
+        if(A[m]<=A[prev]&&A[m]<=A[next]) // if value at middle is less than or equal to value at previous and value at middle is also less than or equal to value at next => we have found our match
+        {
+            index=m;
+            break;
+        }
+        else if(A[l]<=A[m]) // if value at lower bound is less than value at middle then shift lower bound
+        l=next;
+        else// if above condition is  not true shift upper bound
+        u=prev;
+    }
+    int i1=binarySearch(A,0,index-1,B); // performing binary search in either halves of the sorted array
+    if(i1!=-1)
+    return i1;
+    i1=binarySearch(A,index,n-1,B);
+    return i1;
+}
+
+int main() // driver function
+{
+    vector<int> array = {4,5,6,7,0,1,2};
+    int ans = search(array,0);
+    cout << ans;
+    return 0;
+}

Arrays/sum_of_all_subarrays.cpp

@@ -0,0 +1,37 @@
+/* Q. Given an integer array ‘arr[]’ of size n, find sum of all sub-arrays of given array. 
+   Input : a[] = {1, 2, 3}
+   Output: 20
+
+   Explanation: We have to generate all the subarrays using two for loops and then compute their sum.
+   subarrays     -->  {1} {12} {123} {2} {23} {3}
+   subarrays sum -->  1 + 3 + 6 + 2 + 5 + 3 --> 20
+
+   Time Complexity: O(n^2)
+*/
+
+#include <iostream>
+using namespace std;
+int main()
+{
+    int n, sum=0, result = 0;
+    cin>>n;
+    int a[n];
+    for( int i=0; i<n; i++)
+    {
+        cin>>a[i];
+    }
+    
+    for( int i=0; i<n; i++)
+    {
+        sum = 0;
+        for( int j=i; j<n; j++)
+        {
+            sum = sum + a[j];
+            result = result + sum;
+        }
+    }
+
+    cout<<"Sum of all Subarrays : "<<result;
+
+    return 0;
+}