Related Articles
Count of distinct sums that can be obtained by adding prime numbers from given arrays
• Difficulty Level : Easy
• Last Updated : 29 Nov, 2019

Given two arrays arr1[] and arr2[]. The task is to count the distinct sums that can be obtained while choosing a prime element from arr1[] and another prime element from arr2[].

Examples:

Input: arr1[] = {2, 3}, arr2[] = {2, 2, 4, 7}
Output: 4
All possible prime pairs are (2, 2), (2, 2), (2, 7), (3, 2), (3, 2)
and (3, 7) with sums 4, 4, 9, 5, 5 and 10 respectively.

Input: arr1[] = {3, 1, 4, 2, 5}, arr2[] = {8, 7, 10, 6, 5}
Output: 5

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Use Sieve of Eratosthenes to check whether a number is prime or not then for every prime pair, store it’s sum in a set in order to avoid duplicates. The size of the final set will be the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``#define MAX 1000000``using` `namespace` `std;`` ` `bool` `prime[MAX];``void` `sieve()``{``    ``memset``(prime, ``true``, ``sizeof``(prime));``    ``prime = prime = ``false``;``    ``for` `(``int` `p = 2; p * p <= MAX; p++) {``        ``if` `(prime[p] == ``true``) {``            ``for` `(``int` `i = p * p; i <= MAX; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}`` ` `// Function to return the distinct sums``// that can be obtained by adding prime``// numbers from the given arrays``int` `distinctSum(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n)``{``    ``sieve();`` ` `    ``// Set to store distinct sums``    ``set<``int``, greater<``int``> > sumSet;`` ` `    ``for` `(``int` `i = 0; i < m; i++)``        ``for` `(``int` `j = 0; j < n; j++)``            ``if` `(prime[arr1[i]] && prime[arr2[j]])``                ``sumSet.insert(arr1[i] + arr2[j]);`` ` `    ``return` `sumSet.size();``}`` ` `// Driver code``int` `main()``{``    ``int` `arr1[] = { 2, 3 };``    ``int` `arr2[] = { 2, 2, 4, 7 };``    ``int` `m = ``sizeof``(arr1) / ``sizeof``(arr1);``    ``int` `n = ``sizeof``(arr2) / ``sizeof``(arr2);``    ``cout << distinctSum(arr1, arr2, m, n);`` ` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;`` ` `class` `GFG``{``static` `int` `MAX = ``1000000``;`` ` `static` `boolean` `[]prime = ``new` `boolean``[MAX + ``1``];``static` `void` `sieve()``{``    ``Arrays.fill(prime, ``true``);``    ``prime[``0``] = prime[``1``] = ``false``;``    ``for` `(``int` `p = ``2``; p * p <= MAX; p++)``    ``{``        ``if` `(prime[p] == ``true``) ``        ``{``            ``for` `(``int` `i = p * p; ``                     ``i <= MAX; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}`` ` `// Function to return the distinct sums``// that can be obtained by adding prime``// numbers from the given arrays``static` `int` `distinctSum(``int` `arr1[],``                       ``int` `arr2[], ``                       ``int` `m, ``int` `n)``{``    ``sieve();`` ` `    ``// Set to store distinct sums``    ``Set sumSet = ``new` `HashSet();`` ` `    ``for` `(``int` `i = ``0``; i < m; i++)``        ``for` `(``int` `j = ``0``; j < n; j++)``            ``if` `(prime[arr1[i]] && prime[arr2[j]])``                ``sumSet.add(arr1[i] + arr2[j]);`` ` `    ``return` `sumSet.size();``}`` ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr1[] = { ``2``, ``3` `};``    ``int` `arr2[] = { ``2``, ``2``, ``4``, ``7` `};``    ``int` `m = arr1.length;``    ``int` `n = arr2.length;``    ``System.out.println(distinctSum(arr1, arr2, m, n));``}``}`` ` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation of the approach``MAX` `=` `1000000`` ` `prime ``=` `[``True` `for` `i ``in` `range``(``MAX` `+` `1``)]`` ` `def` `sieve():`` ` `    ``prime[``0``], prime[``1``] ``=` `False``, ``False`` ` `    ``for` `p ``in` `range``(``2``, ``MAX` `+` `1``):``        ``if` `p ``*` `p > ``MAX``:``            ``break``        ``if` `(prime[p] ``=``=` `True``):``            ``for` `i ``in` `range``(``2` `*` `p, ``MAX` `+` `1``, p):``                ``prime[i] ``=` `False`` ` `# Function to return the distinct sums``# that can be obtained by adding prime``# numbers from the given arrays``def` `distinctSum(arr1, arr2, m, n):``    ``sieve()`` ` `    ``# Set to store distinct sums``    ``sumSet ``=` `dict``()`` ` `    ``for` `i ``in` `range``(m):``        ``for` `j ``in` `range``(n):``            ``if` `(prime[arr1[i]] ``and` `                ``prime[arr2[j]]):``                ``sumSet[arr1[i] ``+` `arr2[j]] ``=` `1`` ` `    ``return` `len``(sumSet)`` ` `# Driver code``arr1 ``=` `[``2``, ``3` `]``arr2 ``=` `[``2``, ``2``, ``4``, ``7` `]``m ``=` `len``(arr1)``n ``=` `len``(arr2)``print``(distinctSum(arr1, arr2, m, n))`` ` `# This code is contributed by mohit kumar`

## C#

 `// C# implementation of the approach ``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG``{``static` `int` `MAX = 1000000;`` ` `static` `bool` `[]prime = ``new` `bool``[MAX + 1];``static` `void` `sieve()``{``    ``for` `(``int` `i = 0; i < MAX + 1; i++)``        ``prime[i] = ``true``;``    ``prime = prime = ``false``;``    ``for` `(``int` `p = 2; p * p <= MAX; p++)``    ``{``        ``if` `(prime[p] == ``true``) ``        ``{``            ``for` `(``int` `i = p * p; ``                     ``i <= MAX; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}`` ` `// Function to return the distinct sums``// that can be obtained by adding prime``// numbers from the given arrays``static` `int` `distinctSum(``int` `[]arr1,``                       ``int` `[]arr2, ``                       ``int` `m, ``int` `n)``{``    ``sieve();`` ` `    ``// Set to store distinct sums``    ``HashSet<``int``> sumSet = ``new` `HashSet<``int``>();`` ` `    ``for` `(``int` `i = 0; i < m; i++)``        ``for` `(``int` `j = 0; j < n; j++)``            ``if` `(prime[arr1[i]] && prime[arr2[j]])``                ``sumSet.Add(arr1[i] + arr2[j]);`` ` `    ``return` `sumSet.Count;``}`` ` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr1 = { 2, 3 };``    ``int` `[]arr2 = { 2, 2, 4, 7 };``    ``int` `m = arr1.Length;``    ``int` `n = arr2.Length;``    ``Console.WriteLine(distinctSum(arr1, arr2, m, n));``}``}`` ` `// This code is contributed by Rajput-Ji`
Output:
```4
```

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.

My Personal Notes arrow_drop_up