# 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 = 3 = (1 + 2) = A + A,
B = 4 = (1 + 3) = A + A,
B = 5 = (3 + 2) = A + A,
B = 6 = (2 + 4) = A + A,
B = 7 = (3 + 4) = A + A
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 `

Output:

```Yes

```

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

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.