# Smallest possible integer to be added to N-1 elements in array A such that elements of array B are present in A

• Last Updated : 15 Nov, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 – A or B – A.
• So either A or A 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++

 `// C++ program for the above approach``#include ``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 - A``    ``int` `X = B - A;` `    ``// Check if X value assumed is negative or 0``    ``if` `(X <= 0)` `        ``// Update the X value to B - A``        ``X = B - A;` `    ``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 - A;``                ``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);` `    ``findVal(A, B, N);` `    ``return` `0;``}`

## Java

 `// 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 s = ``new` `HashSet();` `    ``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 - A``    ``int` `X = B[``0``] - A[``1``];` `    ``// Check if X value assumed is negative or 0``    ``if` `(X <= ``0``)` `        ``// Update the X value to B - A``        ``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`

## Python3

 `# 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 - A``    ``X ``=` `B[``0``] ``-` `A[``1``]` `    ``# Check if X value assumed is negative or 0``    ``if` `(X <``=` `0``):` `        ``# Update the X value to B - A``        ``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#

 `// 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 - A``    ``int` `X = B - A;` `    ``// Check if X value assumed is negative or 0``    ``if` `(X <= 0)` `        ``// Update the X value to B - A``        ``X = B - A;` `    ``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 - A;``                ``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`

## Javascript

 ``

Output
`7`

Time Complexity: O(N log N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up