Merge pull request thepranaygupta#328 from krishna6431/main

fixes thepranaygupta#317

Author: 8-bit-souvik

02. Algorithms/06. Number Theory/Sieve Of Eratosthenes/Nth_Natural_No.cpp renamed to 02. Algorithms/06. Number Theory/Nth_Natural_Number/Nth_Natural_Number.cpp

@@ -1,11 +1,9 @@
-
 //Problem Statement
 //Given a positive integer N. You have to find Nth natural number after removing all the numbers containing digit 9.
 
 
 /*
 Example 1:
-
 Input:
 N = 8
 Output:
@@ -14,7 +12,6 @@ After removing natural numbers which contains
 digit 9, first 8 numbers are 1,2,3,4,5,6,7,8
 and 8th number is 8.
 Example 2:
-
 Input:
 N = 9
 Output:
@@ -24,42 +21,27 @@ After removing natural numbers which contains
 digit 9, first 9 numbers are 1,2,3,4,5,6,7,8,10
 and 9th number is 10.
  
-
 Your Task:
 You don't need to read input or print anything. Complete the function findNth() which accepts an integer N as input parameter and return the Nth number after removing all the numbers containing digit 9.
-
-
 Expected Time Complexity: O(logN)
 Expected Auxiliary Space: O(1)
-
-
 Constraints:
 1 ≤ N ≤ 10^12
-
 */
 
 /*
 Naive Approach: The simplest approach to solve the above problem is to iterate up to N and keep excluding all numbers less than N containing the digit 9. Finally, print the Nth natural number obtained.
-
-
-
-
 Time Complexity: O(N)
 Auxiliary Space: O(1)
 */
 
 /*
 Efficient Approach: The above approach can be optimized based on the following observations: 
-
-
 It is known that, digits of base 2 numbers varies from 0 to 1. Similarly, digits of base 10 numbers varies from 0 to 9.
 Therefore, the digits of base 9 numbers will vary from 0 to 8.
 It can be observed that Nth number in base 9 is equal to Nth number after skipping numbers containing digit 9.
 So the task is reduced to find the base 9 equivalent of the number N.
-
 Follow the steps below to solve the problem:
-
-
 Initialize two variables, say res = 0 and p = 1, to store the number in base 9 and to store the position of a digit.
 Iterate while N is greater than 0 and perform the following operations:
 Update res as res = res + p*(N%9).

02. Algorithms/06. Number Theory/Return_Two_Prime_Number/Return_Two_Prime_No.cpp

@@ -0,0 +1,87 @@
+//Problem Statement
+//Given an even number N (greater than 2), return two prime numbers whose sum will be equal to given number. There are several combinations possible. Print only the pair whose minimum value is the smallest among all the minimum values of pairs.
+
+
+/*
+Example 1:
+
+Input: N = 74
+Output: 3 71
+Explaination: There are several possibilities 
+like 37 37. But the minimum value of this pair 
+is 3 which is smallest among all possible 
+minimum values of all the pairs.
+Example 2:
+
+Input: 4
+Output: 2 2
+Explaination: This is the only possible 
+prtitioning of 4.
+ 
+our Task:
+You do not need to read input or print anything. Your task is to complete the function primeDivision() which takes N as input parameter and returns the partition satisfying the condition.
+
+Expected Time Complexity: O(N*log(logN))
+Expected Auxiliary Space: O(N)
+
+Constraints:
+1 ≤ N ≤ 104 
+*/
+
+//Implementation
+
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution{
+public:
+ vector<int> primeDivision(int n){
+ vector<int>ans;
+ vector<int>prime_no;
+ bool prime[n+1]={0};
+ int i,j;
+ for(i=2;i*i<=n;i++){
+ if(prime[i]==0){
+ for(j=i*i;j<=n;j+=i){
+ prime[j]=1;
+ }
+ }
+ }
+ for(i=2;i<=n;i++){
+ if(prime[i]==0){
+ prime_no.push_back(i);
+ }
+ }
+ for(i=0;i<prime_no.size();i++){
+ int temp=prime_no[i];
+ for(j=prime_no.size();j>=i;j--){
+ if(n-temp==prime_no[j]){
+ ans.push_back(temp);
+ ans.push_back(prime_no[j]);
+ break;
+ }
+ }
+ 
+ }
+ return ans;
+ 
+ }
+ 
+ 
+};
+
+int main(){
+ int t;
+ cin>>t;
+ while(t--){
+ int N;
+ cin>>N;
+ 
+ Solution ob;
+ vector<int> ans = ob.primeDivision(N);
+ cout<<ans[0]<<" "<<ans[1]<<"\n";
+ }
+ return 0;
+}
+
+//Code is Contributed By krishna_6431

Love Babbar DSA Sheet Solutions/Searching & Sorting/Merge_Without_Extra_Space/Merge_Without_Extra_space.cpp

@@ -0,0 +1,165 @@
+//Problem Statement
+//Given two sorted arrays arr1[] and arr2[] of sizes n and m in non-decreasing order. Merge them in sorted order without using any extra space. Modify arr1 so that it contains the first N elements and modify arr2 so that it contains the last M elements.
+
+
+/*
+Example 1:
+
+Input: 
+n = 4, arr1[] = [1 3 5 7] 
+m = 5, arr2[] = [0 2 6 8 9]
+Output: 
+arr1[] = [0 1 2 3]
+arr2[] = [5 6 7 8 9]
+Explanation:
+After merging the two 
+non-decreasing arrays, we get, 
+0 1 2 3 5 6 7 8 9.
+Example 2:
+
+Input: 
+n = 2, arr1[] = [10, 12] 
+m = 3, arr2[] = [5 18 20]
+Output: 
+arr1[] = [5 10]
+arr2[] = [12 18 20]
+Explanation:
+After merging two sorted arrays 
+we get 5 10 12 18 20.
+
+
+Your Task:
+You don't need to read input or print anything. You only need to complete the function merge() that takes arr1, arr2, n and m as input parameters and modifies them in-place so that they look like the sorted merged array when concatenated.
+ 
+
+Expected Time Complexity: O((n+m) log(n+m))
+Expected Auxilliary Space: O(1)
+ 
+
+Constraints:
+1 <= n, m <= 5*104
+0 <= arr1i, arr2i <= 107
+*/
+
+/*
+1. Method 1
+
+
+
+
+Algorithm: 
+
+
+1) Iterate through every element of ar2[] starting from last 
+
+ element. Do following for every element ar2[i]
+
+ a) Store last element of ar1[i]: last = ar1[i]
+
+ b) Loop from last element of ar1[] while element ar1[j] is 
+
+ greater than ar2[i].
+
+ ar1[j+1] = ar1[j] // Move element one position ahead
+
+ j--
+
+ c) If any element of ar1[] was moved or (j != m-1)
+
+ ar1[j+1] = ar2[i] 
+
+ ar2[i] = last
+
+In above loop, elements in ar1[] and ar2[] are always kept sorted.
+
+
+*/
+
+/*
+Method 2:
+
+
+
+
+The solution can be further optimized by observing that while traversing the two sorted arrays parallelly, if we encounter the jth second array element is smaller than ith first array element, then jth element is to be included and replace some kth element in the first array. This observation helps us with the following algorithm
+
+
+
+
+Algorithm
+
+
+1) Initialize i,j,k as 0,0,n-1 where n is size of arr1 
+
+2) Iterate through every element of arr1 and arr2 using two pointers i and j respectively
+
+ if arr1[i] is less than arr2[j]
+
+ increment i
+
+ else
+
+ swap the arr2[j] and arr1[k]
+
+ increment j and decrement k
+
+
+
+3) Sort both arr1 and arr2 
+*/
+/*
+Method 3:
+
+
+
+
+Algorithm:
+
+
+1) Initialize i with 0
+
+2) Iterate while loop until last element of array 1 is greater than first element of array 2
+
+ if arr1[i] greater than first element of arr2
+
+ swap arr1[i] with arr2[0]
+
+ sort arr2
+
+ incrementing i 
+ */
+
+//Implementation
+#include<bits/stdc++.h>
+using namespace std;
+class Solution{
+public:
+ long long findNth(long long N)
+ {
+ long long ans=0;
+ long long temp = 1;
+ long long n = N;
+ while(n>0){
+ ans += (temp*(n%9));
+ n=n/9;
+ temp = temp*10;
+ }
+ return ans;
+ }
+};
+
+int main()
+{
+int t;
+cin>>t;
+while(t--)
+{
+long long n , ans;
+cin>>n;
+Solution obj;
+ans = obj.findNth(n);
+cout<<ans<<endl;
+}
+}
+
+//code is contributed by krishna_6431