Check if each element of an Array is the Sum of any two elements of another Array

Given two arrays A[] and B[] consisting of N integers, the task is to check if each element of array B[] can be formed by adding any two elements of array A[]. If it is possible, then print “Yes”. Otherwise, print “No”.

Examples:

Input: A[] = {3, 5, 1, 4, 2}, B[] = {3, 4, 5, 6, 7} 
Output: Yes 
Explanation:
B[0] = 3 = (1 + 2) = A[2] + A[4], 
B[1] = 4 = (1 + 3) = A[2] + A[0], 
B[2] = 5 = (3 + 2) = A[0] + A[4], 
B[3] = 6 = (2 + 4) = A[4] + A[3], 
B[4] = 7 = (3 + 4) = A[0] + A[3]

Input: A[] = {1, 2, 3, 4, 5}, B[] = {1, 2, 3, 4, 5} 
Output: No 

Approach:
Follow the steps below to solve the problem: 

• Store each element of B[] in a Set.
• For each pair of indices (i, j) of the array A[], check if A[i] + A[j] is present in the set. If found to be true, remove A[i] + A[j] from the set.
• If the set becomes empty, then print “Yes”. Otherwise, print “No”.

Below is the implementation of the above approach: 

C++

// C++ program to implement
// the above approach
#include
using namespace std;

// Function to check if each element
// of B[] can be formed by adding two
// elements of array A[]
string checkPossible(int A[], int B[], int n)
{
    // Store each element of B[]
    unordered_set values;

    for (int i = 0; i < n; i++) {
        values.insert(B[i]);
    }

    // Traverse all possible pairs of array
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {

            // If A[i] + A[j] is present in
            // the set
            if (values.find(A[i] + A[j])
                != values.end()) {

                // Remove A[i] + A[j] from the set
                values.erase(A[i] + A[j]);

                if (values.empty())
                    break;
            }
        }
    }

    // If set is empty
    if (values.size() == 0)
        return "Yes";

    // Otherwise
    else
        return "No";
}

// Driver Code
int main()
{
    int N = 5;

    int A[] = { 3, 5, 1, 4, 2 };
    int B[] = { 3, 4, 5, 6, 7 };

    cout << checkPossible(A, B, N);
}

Java

// Java program to implement
// the above approach
import java.io.*;
import java.util.*;

class GFG{

// Function to check if each element
// of B[] can be formed by adding two
// elements of array A[]
static String checkPossible(int A[], int B[],
                            int n)
{

    // Store each element of B[]
    Set values = new HashSet();

    for(int i = 0; i < n; i++)
    {
        values.add(B[i]);
    }

    // Traverse all possible pairs of array
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {

            // If A[i] + A[j] is present in
            // the set
            if (values.contains(A[i] + A[j]))
            {

                // Remove A[i] + A[j] from the set
                values.remove(A[i] + A[j]);

                if (values.size() == 0)
                    break;
            }
        }
    }

    // If set is empty
    if (values.size() == 0)
        return "Yes";

    // Otherwise
    else
        return "No";
}

// Driver Code
public static void main(String args[])
{
    int N = 5;
    int A[] = { 3, 5, 1, 4, 2 };
    int B[] = { 3, 4, 5, 6, 7 };

    System.out.print(checkPossible(A, B, N));
}
}

// This code is contributed by offbeat

Python3

# Python3 program to implement
# the above approach

# Function to check if each element
# of B[] can be formed by adding two
# elements of array A[]
def checkPossible(A, B, n):

    # Store each element of B[]
    values = set([])

    for i in range (n):
        values.add(B[i])

    # Traverse all possible
    # pairs of array
    for i in range (n):
        for j in range (n):

            # If A[i] + A[j] is present in
            # the set
            if ((A[i] + A[j]) in values):

                # Remove A[i] + A[j] from the set
                values.remove(A[i] + A[j])

                if (len(values) == 0):
                    break

    # If set is empty
    if (len(values) == 0):
        return "Yes"

    # Otherwise
    else:
        return "No"

# Driver Code
if __name__ == "__main__":

  N = 5

  A = [3, 5, 1, 4, 2]
  B = [3, 4, 5, 6, 7]

  print (checkPossible(A, B, N))

# This code is contributed by Chitranayal

C#

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG{

// Function to check if each element
// of []B can be formed by adding two
// elements of array []A
static String checkPossible(int []A, int []B,
                            int n)
{

  // Store each element of []B
  HashSet values = new HashSet();

  for(int i = 0; i < n; i++)
  {
    values.Add(B[i]);
  }

  // Traverse all possible pairs of array
  for(int i = 0; i < n; i++)
  {
    for(int j = 0; j < n; j++)
    {
      // If A[i] + A[j] is present in
      // the set
      if (values.Contains(A[i] + A[j]))
      {
        // Remove A[i] + A[j] from the set
        values.Remove(A[i] + A[j]);

        if (values.Count == 0)
          break;
      }
    }
  }

  // If set is empty
  if (values.Count == 0)
    return "Yes";

  // Otherwise
  else
    return "No";
}

// Driver Code
public static void Main(String []args)
{
  int N = 5;
  int []A = {3, 5, 1, 4, 2};
  int []B = {3, 4, 5, 6, 7};

  Console.Write(checkPossible(A, B, N));
}
}

// This code is contributed by Amit Katiyar

Javascript

<script>

// Javascript program to implement
// the above approach

// Function to check if each element
// of B[] can be formed by adding two
// elements of array A[]
function checkPossible(A, B, n)
{

    // Store each element of B[]
    var values = new Set();

    for(var i = 0; i < n; i++)
    {
        values.add(B[i]);
    }

    // Traverse all possible pairs of array
    for(var i = 0; i < n; i++)
    {
        for(var j = 0; j < n; j++)
        {

            // If A[i] + A[j] is present in
            // the set
            if (values.has(A[i] + A[j]))
            {

                // Remove A[i] + A[j] from the set
                values.delete(A[i] + A[j]);

                if (values.size == 0)
                    break;
            }
        }
    }

    // If set is empty
    if (values.size == 0)
        return "Yes";

    // Otherwise
    else
        return "No";
}

// Driver Code
var N = 5;
var A = [ 3, 5, 1, 4, 2 ];
var B = [ 3, 4, 5, 6, 7 ];

document.write(checkPossible(A, B, N));

// This code is contributed by itsok

</script>

Output:

Yes

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