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

**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++ implementation of the approach ` `#include <bits/stdc++.h> ` `#define MAX 1000000 ` `using` `namespace` `std; `
` ` `bool` `prime[MAX]; `
`void` `sieve() `
`{ ` ` ` `memset` `(prime, ` `true` `, ` `sizeof` `(prime)); `
` ` `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 ` `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[0]); `
` ` `int` `n = ` `sizeof` `(arr2) / ` `sizeof` `(arr2[0]); `
` ` `cout << distinctSum(arr1, arr2, m, n); `
` ` ` ` `return` `0; `
`} ` |

*chevron_right*

*filter_none*

`# 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 ` |

*chevron_right*

*filter_none*

**Output:**

4

## Recommended Posts:

- Count of pairs between two arrays such that the sums are distinct
- Total distinct pairs from two arrays such that second number can be obtained by inverting bits of first
- Print the nearest prime number formed by adding prime numbers to N
- Numbers less than N which are product of exactly two distinct prime numbers
- Exactly n distinct prime factor numbers from a to b
- Find two distinct prime numbers with given product
- Check whether count of distinct characters in a string is Prime or not
- Number of distinct prime factors of first n natural numbers
- Sort an array according to the increasing count of distinct Prime Factors
- Count distinct pairs from two arrays having same sum of digits
- Count pairs formed by distinct element sub-arrays
- Total distinct pairs of ugly numbers from two arrays
- Count subsets having distinct even numbers
- Count of numbers below N whose sum of prime divisors is K
- Find count of Almost Prime numbers from 1 to N

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.