Given two arrays A[] of length N and B[] of length N-1, the task is to find the smallest positive integer X that is added to every element of A[] except one element, so that all the elements of array B[] are present in array A[]. Assume that finding X is always possible.
Examples:
Input: A[] = {1, 4, 3, 8}, B[] = {15, 8, 11}
Output: 7
Explanation: Adding 7 to every elements of the array A except 3 will give all the elements of array B
Input: A[] = {4, 8}, B[] = {10}
Output: 2
Explanation: Adding 2 to 8 gives 10.
Approach: The idea is to use the greedy approach.
- Sort the arrays A[] and B[]
- On observation, it can be seen that, the value of the X can be either B[0] – A[0] or B[0] – A[1].
- So either A[0] or A[1] is not taken into account and X is added to the rest of the elements.
- Check if both values are valid or not by traversing the array and if both X values are found to be valid then choose the minimum one and print it.
Below is the implementation for the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the smallest positive integer // X such that X is added to every element of A // except one element to give array B void findVal( int A[], int B[], int N)
{ // Stores the unique elements of array A
unordered_set< int > s;
for ( int i = 0; i < N; i++) {
// Insert A[i] into the set s
s.insert(A[i]);
}
// Sort array A[]
sort(A, A + N);
// Sort array B[]
sort(B, B + N - 1);
// Assume X value as B[0] - A[1]
int X = B[0] - A[1];
// Check if X value assumed is negative or 0
if (X <= 0)
// Update the X value to B[0] - A[0]
X = B[0] - A[0];
else {
for ( int i = 0; i < N - 1; i++) {
// If assumed value is wrong
if (s.count(B[i] - X) == 0) {
// Update X value
X = B[0] - A[0];
break ;
}
}
}
cout << X << endl;
} // Driver Code int main()
{ int A[] = { 1, 4, 3, 8 };
int B[] = { 15, 8, 11 };
int N = sizeof (A) / sizeof (A[0]);
findVal(A, B, N);
return 0;
} |
// Java implementation for the above approach import java.util.*;
public class GFG
{ // Function to find the smallest positive integer // X such that X is added to every element of A // except one element to give array B static void findVal( int []A, int []B, int N)
{ // Stores the unique elements of array A
HashSet<Integer> s = new HashSet<Integer>();
for ( int i = 0 ; i < N; i++) {
// Insert A[i] into the set s
s.add(A[i]);
}
// Sort array A[]
Arrays.sort(A);
// Sort array B[]
Arrays.sort(B);
// Assume X value as B[0] - A[1]
int X = B[ 0 ] - A[ 1 ];
// Check if X value assumed is negative or 0
if (X <= 0 )
// Update the X value to B[0] - A[0]
X = B[ 0 ] - A[ 0 ];
else {
for ( int i = 0 ; i < N - 1 ; i++) {
// If assumed value is wrong
if (s.contains(B[i] - X) == false ) {
// Update X value
X = B[ 0 ] - A[ 0 ];
break ;
}
}
}
System.out.println(X);
} // Driver Code public static void main(String args[])
{ int []A = { 1 , 4 , 3 , 8 };
int []B = { 15 , 8 , 11 };
int N = A.length;
findVal(A, B, N);
} } // This code is contributed by Samim Hossain Mondal |
# Python 3 program for the above approach # Function to find the smallest positive integer # X such that X is added to every element of A # except one element to give array B def findVal(A, B, N):
# Stores the unique elements of array A
s = set ()
for i in range (N):
# Insert A[i] into the set s
s.add(A[i])
# Sort array A[]
A.sort()
# Sort array B[]
B.sort()
# Assume X value as B[0] - A[1]
X = B[ 0 ] - A[ 1 ]
# Check if X value assumed is negative or 0
if (X < = 0 ):
# Update the X value to B[0] - A[0]
X = B[ 0 ] - A[ 0 ]
else :
for i in range (N - 1 ):
# If assumed value is wrong
if (B[i] - X not in s):
# Update X value
X = B[ 0 ] - A[ 0 ]
break
print (X)
# Driver Code if __name__ = = '__main__' :
A = [ 1 , 4 , 3 , 8 ]
B = [ 15 , 8 , 11 ]
N = len (A)
findVal(A, B, N)
# This code is contributed by SURENDRA_GANGWAR.
|
// C# implementation for the above approach using System;
using System.Collections.Generic;
class GFG
{ // Function to find the smallest positive integer // X such that X is added to every element of A // except one element to give array B static void findVal( int []A, int []B, int N)
{ // Stores the unique elements of array A
HashSet< int > s = new HashSet< int >();
for ( int i = 0; i < N; i++) {
// Insert A[i] into the set s
s.Add(A[i]);
}
// Sort array A[]
Array.Sort(A);
// Sort array B[]
Array.Sort(B);
// Assume X value as B[0] - A[1]
int X = B[0] - A[1];
// Check if X value assumed is negative or 0
if (X <= 0)
// Update the X value to B[0] - A[0]
X = B[0] - A[0];
else {
for ( int i = 0; i < N - 1; i++) {
// If assumed value is wrong
if (s.Contains(B[i] - X) == false ) {
// Update X value
X = B[0] - A[0];
break ;
}
}
}
Console.Write(X);
} // Driver Code public static void Main()
{ int []A = { 1, 4, 3, 8 };
int []B = { 15, 8, 11 };
int N = A.Length;
findVal(A, B, N);
} } // This code is contributed by Samim Hossain Mondal |
<script> // JavaScript Program to implement
// the above approach
// Function to find the smallest positive integer
// X such that X is added to every element of A
// except one element to give array B
function findVal(A, B, N)
{
// Stores the unique elements of array A
let s = new Set();
for (let i = 0; i < N; i++)
{
// Insert A[i] into the set s
s.add(A[i]);
}
// Sort array A[]
A.sort( function (a, b) { return a - b });
// Sort array B[]
B.sort( function (a, b) { return a - b })
// Assume X value as B[0] - A[1]
let X = B[0] - A[1];
// Check if X value assumed is negative or 0
if (X <= 0)
// Update the X value to B[0] - A[0]
X = B[0] - A[0];
else {
for (let i = 0; i < N - 1; i++) {
// If assumed value is wrong
if (s.has(B[i] - X) == false ) {
// Update X value
X = B[0] - A[0];
break ;
}
}
}
document.write(X);
}
// Driver Code
let A = [1, 4, 3, 8];
let B = [15, 8, 11];
let N = A.length;
findVal(A, B, N);
// This code is contributed by Potta Lokesh
</script>
|
7
Time Complexity: O(N log N)
Auxiliary Space: O(N)