Competitive programming

Competitive_Programming/C++/Array/Merge-two-arrays.md

@@ -0,0 +1,106 @@
+# Merge two arrays by satisfying given constraints
+Given two sorted arrays X[] and Y[] of size m and n each where m >= n and X[] has exactly n vacant cells, merge elements of Y[] in their correct position in array X[], i.e., merge (X, Y) by keeping the sorted order.
+
+For example,
+
+## Input:
+
+X[] = { 0, 2, 0, 3, 0, 5, 6, 0, 0 }
+Y[] = { 1, 8, 9, 10, 15 }
+
+The vacant cells in X[] is represented by 0
+
+## Output:
+
+X[] = { 1, 2, 3, 5, 6, 8, 9, 10, 15 }
+
+## Approach:
+The idea is simple – move non-empty elements of X[] at the beginning of X[] and then merge X[] with Y[] starting from the end. The merge process is similar to the merge routine of the merge sort algorithm.
+
+## Code:
+``` Cpp
+#include<bits/stdc++.h
+
+// Function to merge `X[0… m]` and `Y[0… n]` into `X[0… m+n+1]`
+void merge(int X[], int Y[], int m, int n)
+{
+    // size of `X[]` is `k+1`
+    int k = m + n + 1;
+
+    // run if X[] or Y[] has elements left
+    while (m >= 0 && n >= 0)
+    {
+        // put the next greater element in the next free position in `X[]` from the end
+        if (X[m] > Y[n]) {
+            X[k--] = X[m--];
+        }
+        else {
+            X[k--] = Y[n--];
+        }
+    }
+
+    // copy the remaining elements of `Y[]` (if any) to `X[]`
+    while (n >= 0) {
+        X[k--] = Y[n--];
+    }
+
+    // fill `Y[]` with all zeroes
+    for (int i = 0; i < n; i++) {
+        Y[i] = 0;
+    }
+}
+
+// The function moves non-empty elements in `X[]` in the
+// beginning and then merge them with `Y[]`
+void rearrange(int X[], int Y[], int m, int n)
+{
+    // return if `X` is empty
+    if (m == 0) {
+        return;
+    }
+
+    // moves non-empty elements of `X[]` at the beginning
+    int k = 0;
+    for (int i = 0; i < m; i++)
+    {
+        if (X[i] != 0) {
+            X[k++] = X[i];
+        }
+    }
+
+    // merge `X[0 … k-1]` and `Y[0 … n-1]` into `X[0 … m-1]`
+    merge(X, Y, k - 1, n - 1);
+}
+
+int main()
+{
+    // vacant cells in `X[]` is represented by 0
+    int X[] = { 0, 2, 0, 3, 0, 5, 6, 0, 0 };
+    int Y[] = { 1, 8, 9, 10, 15 };
+
+    int m = sizeof(X) / sizeof(X[0]);
+    int n = sizeof(Y) / sizeof(Y[0]);
+
+    /* Validate input before calling `rearrange()`
+        1. Both arrays `X[]` and `Y[]` should be sorted (ignore 0's in `X[]`)
+        2. Size of array `X[]` >= size of array `Y[]` (i.e., `m >= n`)
+        3. Total number of vacant cells in array `X[]` = size of array `Y[]` */
+
+    // merge `Y[]` into `X[]`
+    rearrange(X, Y, m, n);
+
+    // print merged array
+    for (int i = 0; i < m; i++) {
+        printf("%d ", X[i]);
+    }
+
+    return 0;
+}
+```
+
+## Output:
+
+1 2 3 5 6 8 9 10 15
+
+## Time Complexity
+Time complexity of the above solution is O(m + n) and runs in constant space. Here, m and n are the size of the first and second array, respectively.

Competitive_Programming/C++/Greedy/CarSell_Problem/CarSell.md

@@ -0,0 +1,58 @@
+# Car Sell Problem
+
+## Problem Definition
+
+MAXIMUM PROFIT:
+
+A man owns N cars (numbered from 1 to N). He wishes to sell all cars over N days by selling exactly one car per day. For each valid i, the initial price of the i-th car is Pi. Due to depreciation, the price of each car decreases by 1 unit per day until it is sold. Note that the price of a car cannot drop below 0 no matter how many days have passed, i.e. when the price of a car reaches 0 on some day then it remains 0 in all subsequent days. Find the maximum profit he can make if he sells his cars in an optimal way in order to maximise his profit. The output can be very large so compute it to modulo of 1000000007(10^9+7).
+
+
+## EXPLANATION
+We use the greedy approach for solving this problem. 
+As we already know the price of any given car can never become negative. So, we will start by selling the car with the maximum price and then proceed to the car with a lower price.
+We store the prices in ascending or descending order and then add prices accordingly until we get negative value for price of any car after depreciation on anyday.
+
+
+## Example
+
+### Input
+```
+5
+2 4 5 6 3
+```
+### Output
+```
+12
+```
+### CODE 💻
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+int main()
+{
+	long long int n,k,i;
+	cin>>n;
+	k=0;
+        //create a vector to store price of cars
+	vector <long long int> v(n);
+        //storing prices of cars in v
+	for(i=0;i<n;i++)
+	{
+	    cin>>v[i];
+	}
+        //we sort this vector using sort() function
+	sort(v.begin(),v.end());
+	//calculation of price of cars after depreciation and then adding their sum in k
+	for(i=n-1;i>=0;i--)
+	{
+    	if(v[i]-n+1+i>0)k+=v[i]-n+1+i;
+        else break;
+	}
+	k=k%1000000007;
+	//printing maximum possible profit
+	cout<<k<<endl;
+	return 0;
+}
+```
+
+## Time Complexity: N(Log N)

Competitive_Programming/C++/Heap/FindingKthLargestElement/FindingKthLargestElement.md

@@ -0,0 +1,99 @@
+# Kth Largest Element
+
+
+Find the kth largest element means that the output will be the kth largest element in the whole array.
+<br>
+
+eg : 8 3 5 9 1 2 5 6
+
+<br>
+
+if k = 2
+<br>
+output: 8 
+
+explanation: 
+
+ the second largest in the array is 8 ,
+ sorted array: 1 2 3 5 5 6 8 9
+
+similarily, 
+ array[]= 8 3 5 9 1 2 5 6
+ if k=5
+
+ output: 3
+
+
+The Brute Force method to find the kth largest element is to first sort and then find the k-1 index element. This will take O(n log n) time. 
+
+```c++
+//c++
+    #include <bits/stdc++.h>
+    using namespace std;
+
+    int main ()
+    {
+      vector < int >v = { 6, 5, 2, 7, 1, 8, 4, 9, 10, 11 };
+      int k = 3;
+      sort (v.begin (), v.end ());
+      cout << "Kth largest element " << v[n - k];
+      return 0;
+    }
+```
+>OUTPUT:
+>
+>Kth largest element 9
+>
+
+>
+>*Time Complexity*
+>
+>*O(n log n)*
+where n is the size of the array/vector and sorting takes O(n log n).
+Optimized way to solve this is to use min-heap, and this will take O(n log K) time.
+
+- *The property of the min-heap structure is that the minimum element remains at the top*
+
+ - so since, we have to find only the kth largest element so after maintaining the heap of k size
+
+  - we can just pop the next top element after we have maintain the k size heap, as the top will always be smaller than the elements below it.
+
+- since we iterate to each element in the array , so it takes O(n) time and for heap function it takes O(log k) , 
+so the total complexity becomes O(n log k).
+
+
+The answer will be at the top of the min heap.
+
+```c++
+//c++
+    #include <bits/stdc++.h>
+    using namespace std;
+
+    int findKthLargest(vector<int>nums, int k) {
+    priority_queue<int, vector<int>, greater<int>> minh;
+    for (auto i = nums.begin(); i != nums.end(); i++){
+     minh.push(*i);
+     if(minh.size()>k){
+            minh.pop();
+        }
+    }
+    return minh.top();
+    }
+    int main(){
+    vector<int> v={6,5,2,7,1,8,4,9,10,11};
+    int k=3;
+    int ele;
+    ele=findKthLargest(v,k);
+    cout<<"Kth largest element "<<ele;
+    return 0;
+    }
+```
+>OUTPUT:
+>
+>Kth largest element 9
+>
+
+>
+>*Time Complexity*
+>
+>*O(n log k)*