# Largest subset with sum of every pair as prime

Given an array A[], find a subset of maximum size in which sum of every pair of elements is a prime number. Print its length and the subset. Consider many queries for different arrays and maximum value of an element as 100000.

Examples :

```Input : A[] = {2, 1, 2}
Output : 2
1 2
Explanation :
Here, we can only form subsets with size 1 and 2.
maximum sized subset = {1, 2}, 1 + 2 = 3, which
is prime number.
So, Answer = 2 (size), {1, 2} (subset)

Input : A[] = {2, 1, 1}
Output : 3
1 1 2
Explanation :
Maximum subset = {2, 1, 2}, since 1 + 2 = 3,
1 + 1 = 2, both are prime numbers.
Answer = 3 (size), {2, 1, 1} (subset).```

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

Let’s make some observations and then move to problem. Sum of two numbers is even if and only both the numbers are either odd or even. An even number cannot be a prime number except 2. Now, if we take three numbers a, b and c, two of them should be either odd or even(Pigeonhole theorem). So, our solution exists only in two cases – (Let the subset be B)

• Case I : When B contains only two integers(>1) whose sum is a prime number.
• Case II : When B contains some number of ones(1s) and another number X, where X + 1 should be a prime(Only possible when X is an even number).

First count the number of ones in the array using a for loop.

1. If the count of 1s is greater than 0, then traverse the whole the array and check if [A[i] + 1] is a prime number and (A[i] != 1), if found any, print the size of subarray as (count of 1s) +1 and all the ones(1s) and the found A[i]. Exit the program.
2. If the above step fails (i.e, A[i] not found), print all the ones(1s). Exit the program.
3. If above step fails (i.e, count of 1s = 0), Check every pair of elements in the array for their sum to be a prime. Print 2 and the pair of integers.
4. Else Print -1.

Below is implementation of above approach :

## C++

 `// CPP program to find a subset in which sum of  ` `// every pair in it is a prime ` `#include ` `using` `namespace` `std; ` ` `  `#define MAX 100001 ` ` `  `bool` `isPrime[MAX] = { 0 }; ` ` `  `int` `sieve() ` `{ ` `    ``for` `(``int` `p = 2; p * p < MAX; p++)  ` `    ``{ ` `        ``// If isPrime[p] is not changed, then it ` `        ``// is a prime ` `        ``if` `(isPrime[p] == 0)  ` `        ``{ ` `            ``// Update all multiples of p ` `            ``for` `(``int` `i = p * 2; i < MAX; i += p) ` `                ``isPrime[i] = 1; ` `        ``} ` `    ``} ` `} ` ` `  `int` `findSubset(``int` `a[], ``int` `n) ` `{ ` `    ``int` `cnt1 = 0; ` ` `  `    ``// Counting no.of ones in the array ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `        ``if` `(a[i] == 1) ` `            ``cnt1++; ` ` `  `    ``// Case-I: count of ones(1s) > 0 and  ` `    ``// an integer > 1 is present in the array ` `    ``if` `(cnt1 > 0)  ` `    ``{ ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{ ` `            ``// Find a[i], where a[i] + 1 is prime. ` `            ``if` `((a[i] != 1) and (isPrime[a[i] + 1] == 0))  ` `            ``{ ` `                ``cout << cnt1 + 1 << endl; ` ` `  `                ``// Print all the ones(1s). ` `                ``for` `(``int` `j = 0; j < cnt1; j++)  ` `         `  `                ``cout << 1 << ``" "``; ` `                ``cout << a[i] << endl; ``// print a[i]. ` `                ``return` `0; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Case-II: array contains only ones(1s) ` `    ``if` `(cnt1 >= 2)  ` `    ``{ ` `        ``cout << cnt1 << endl; ` ` `  `        ``// Print all ones(1s). ` `        ``for` `(``int` `i = 0; i < cnt1; i++)  ` `            ``cout << 1 << ``" "``; ` ` `  `        ``cout << endl; ` `        ``return` `0; ` `    ``} ` ` `  `    ``// Case-III: array does not contain 1s ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``for` `(``int` `j = i + 1; j < n; j++)  ` `        ``{ ` `            ``// Find a pair of integers whose sum is prime ` `            ``if` `(isPrime[a[i] + a[j]] == 0)  ` `            ``{ ` `                ``cout << 2 << endl; ` `                ``cout << a[i] << ``" "` `<< a[j] << endl; ` `                ``return` `0; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Array contains only a single element. ` `    ``cout << -1 << endl; ` `} ` ` `  `// Driver function ` `int` `main() ` `{ ` `    ``sieve(); ` `    ``int` `A[] = { 2, 1, 1 }; ` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A); ` `    ``findSubset(A, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find a  ` `// subset in which sum of  ` `// every pair in it is a prime ` `import` `java.io.*; ` ` `  `class` `GFG ` `{ ` `    ``static` `int` `MAX = ``100001``; ` `     `  `    ``static` `int` `[]isPrime = ``new` `int``[MAX]; ` `     `  `    ``static` `int` `sieve() ` `    ``{ ` `        ``for` `(``int` `p = ``2``;  ` `                 ``p * p < MAX; p++)  ` `        ``{ ` `            ``// If isPrime[p] is  ` `            ``// not changed, then ` `            ``// it is a prime ` `            ``if` `(isPrime[p] == ``0``)  ` `            ``{ ` `                ``// Update all ` `                ``// multiples of p ` `                ``for` `(``int` `i = p * ``2``;  ` `                         ``i < MAX; i += p) ` `                    ``isPrime[i] = ``1``; ` `            ``} ` `        ``} ` `        ``return` `-``1``; ` `    ``}      ` `    ``static` `int` `findSubset(``int` `[]a, ``int` `n) ` `    ``{ ` `        ``int` `cnt1 = ``0``; ` `     `  `        ``// Counting no. of  ` `        ``// ones in the array ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `            ``if` `(a[i] == ``1``) ` `                ``cnt1++; ` `     `  `        ``// Case-I: count of  ` `        ``// ones(1s) > 0 and  ` `        ``// an integer > 1 is  ` `        ``// present in the array ` `        ``if` `(cnt1 > ``0``)  ` `        ``{ ` `            ``for` `(``int` `i = ``0``; i < n; i++)  ` `            ``{ ` `                ``// Find a[i], where ` `                ``// a[i] + 1 is prime. ` `                ``if` `((a[i] != ``1``) &&  ` `                    ``(isPrime[a[i] + ``1``] == ``0``))  ` `                ``{ ` `                    ``System.out.println(cnt1 + ``1``); ` `     `  `                    ``// Print all  ` `                    ``// the ones(1s). ` `                    ``for` `(``int` `j = ``0``; ` `                             ``j < cnt1; j++)  ` `             `  `                    ``System.out.print(``1` `+ ``" "``); ` `                    ``System.out.println(a[i]); ``// print a[i]. ` `                    ``return` `0``; ` `                ``} ` `            ``} ` `        ``} ` `     `  `        ``// Case-II: array contains ` `        ``// only ones(1s) ` `        ``if` `(cnt1 >= ``2``)  ` `        ``{ ` `            ``System.out.println(cnt1); ` `     `  `            ``// Print all ones(1s). ` `            ``for` `(``int` `i = ``0``;  ` `                     ``i < cnt1; i++)  ` `                ``System.out.print(``1` `+ ``" "``); ` `     `  `            ``System.out.println(); ` `            ``return` `0``; ` `        ``} ` `     `  `        ``// Case-III: array does ` `        ``// not contain 1s ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``for` `(``int` `j = i + ``1``;  ` `                     ``j < n; j++)  ` `            ``{ ` `                ``// Find a pair of integers ` `                ``// whose sum is prime ` `                ``if` `(isPrime[a[i] + a[j]] == ``0``)  ` `                ``{ ` `                    ``System.out.println(``2``); ` `                    ``System.out.println(a[i] + ` `                                 ``" "` `+ a[j]); ` `                    ``return` `0``; ` `                ``} ` `            ``} ` `        ``} ` `     `  `        ``// Array contains only  ` `        ``// a single element. ` `        ``System.out.println(-``1``); ` `        ``return` `-``1``; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``sieve(); ` `        ``int` `[]A = ``new` `int``[]{ ``2``, ``1``, ``1` `}; ` `        ``int` `n = A.length; ` `        ``findSubset(A, n); ` `    ``} ` `} ` ` `  `// This code is contributed by  ` `// Manish Shaw(manishshaw1) `

## Python3

 `# Python3 program to find a subset in which  ` `# sum of every pair in it is a prime ` `import` `math as mt ` ` `  `MAX` `=` `100001` ` `  `isPrime ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` ` `  `def` `sieve(): ` ` `  `    ``for` `p ``in` `range``(``2``, mt.ceil(mt.sqrt(``MAX``))):  ` `         `  `        ``# If isPrime[p] is not changed,  ` `        ``# then it is a prime ` `        ``if` `(isPrime[p] ``=``=` `0``) : ` `             `  `            ``# Update all multiples of p ` `            ``for` `i ``in` `range``(``2` `*` `p, ``MAX``, p): ` `                ``isPrime[i] ``=` `1` ` `  `def` `findSubset(a, n): ` ` `  `    ``cnt1 ``=` `0` ` `  `    ``# Counting no.of ones in the array ` `    ``for` `i ``in` `range``(n):  ` `        ``if` `(a[i] ``=``=` `1``): ` `            ``cnt1``+``=``1` ` `  `    ``# Case-I: count of ones(1s) > 0 and  ` `    ``# an integer > 1 is present in the array ` `    ``if` `(cnt1 > ``0``): ` ` `  `        ``for` `i ``in` `range``(n): ` ` `  `            ``# Find a[i], where a[i] + 1 is prime. ` `            ``if` `((a[i] !``=` `1``) ``and` `                ``(isPrime[a[i] ``+` `1``] ``=``=` `0``)): ` ` `  `                ``print``(cnt1 ``+` `1``) ` ` `  `                ``# Print all the ones(1s). ` `                ``for` `j ``in` `range``(cnt1): ` `                    ``print``(``"1"``, end ``=` `" "``) ` ` `  `                ``print``(a[i]) ` `                ``return` `0` ` `  `    ``# Case-II: array contains only ones(1s) ` `    ``if` `(cnt1 >``=` `2``): ` ` `  `        ``print``(cnt1) ` ` `  `        ``# Print all ones(1s). ` `        ``for` `i ``in` `range``(cnt1): ` `            ``print``(``"1"``, end ``=` `" "``) ` ` `  `        ``print``(``"\n"``) ` `        ``return` `0` `     `  `    ``# Case-III: array does not contain 1s ` `    ``for` `i ``in` `range``(n): ` `        ``for` `j ``in` `range``(i ``+` `1``, n): ` `             `  `            ``# Find a pair of integers whose  ` `            ``# sum is prime ` `            ``if` `(isPrime[a[i] ``+` `a[j]] ``=``=` `0``): ` `                ``print``(``2``) ` `                ``print``(a[i], ``" "``, a[j]) ` ` `  `    ``# Array contains only a single element. ` `    ``print``(``-``1``) ` ` `  `# Driver Code ` `sieve() ` `A ``=``[ ``2``, ``1``, ``1``] ` `n ``=``len``(A) ` `findSubset(A, n) ` ` `  `# This code is contributed  ` `# by Mohit kumar 29 `

## C#

 `// C# program to find a subset  ` `// in which sum of every pair  ` `// in it is a prime ` `using` `System; ` ` `  `class` `GFG ` `{ ` `    ``static` `int` `MAX = 100001; ` `     `  `    ``static` `int` `[]isPrime = ``new` `int``[MAX]; ` `     `  `    ``static` `int` `sieve() ` `    ``{ ` `        ``for` `(``int` `p = 2;  ` `                 ``p * p < MAX; p++)  ` `        ``{ ` `            ``// If isPrime[p] is  ` `            ``// not changed, then ` `            ``// it is a prime ` `            ``if` `(isPrime[p] == 0)  ` `            ``{ ` `                ``// Update all ` `                ``// multiples of p ` `                ``for` `(``int` `i = p * 2;  ` `                         ``i < MAX; i += p) ` `                    ``isPrime[i] = 1; ` `            ``} ` `        ``} ` `        ``return` `-1; ` `    ``}      ` `    ``static` `int` `findSubset(``int` `[]a, ``int` `n) ` `    ``{ ` `        ``int` `cnt1 = 0; ` `     `  `        ``// Counting no. of  ` `        ``// ones in the array ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `            ``if` `(a[i] == 1) ` `                ``cnt1++; ` `     `  `        ``// Case-I: count of  ` `        ``// ones(1s) > 0 and  ` `        ``// an integer > 1 is  ` `        ``// present in the array ` `        ``if` `(cnt1 > 0)  ` `        ``{ ` `            ``for` `(``int` `i = 0; i < n; i++)  ` `            ``{ ` `                ``// Find a[i], where ` `                ``// a[i] + 1 is prime. ` `                ``if` `((a[i] != 1) &&  ` `                    ``(isPrime[a[i] + 1] == 0))  ` `                ``{ ` `                    ``Console.WriteLine(cnt1 + 1); ` `     `  `                    ``// Print all the ones(1s). ` `                    ``for` `(``int` `j = 0; j < cnt1; j++)  ` `             `  `                    ``Console.Write(1 + ``" "``); ` `                    ``Console.WriteLine(a[i]); ``// print a[i]. ` `                    ``return` `0; ` `                ``} ` `            ``} ` `        ``} ` `     `  `        ``// Case-II: array contains ` `        ``// only ones(1s) ` `        ``if` `(cnt1 >= 2)  ` `        ``{ ` `            ``Console.WriteLine(cnt1); ` `     `  `            ``// Print all ones(1s). ` `            ``for` `(``int` `i = 0; i < cnt1; i++)  ` `                ``Console.Write(1 + ``" "``); ` `     `  `            ``Console.WriteLine(); ` `            ``return` `0; ` `        ``} ` `     `  `        ``// Case-III: array does ` `        ``// not contain 1s ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{ ` `            ``for` `(``int` `j = i + 1; j < n; j++)  ` `            ``{ ` `                ``// Find a pair of integers ` `                ``// whose sum is prime ` `                ``if` `(isPrime[a[i] + a[j]] == 0)  ` `                ``{ ` `                    ``Console.WriteLine(2); ` `                    ``Console.WriteLine(a[i] + ``" "` `+ a[j]); ` `                    ``return` `0; ` `                ``} ` `            ``} ` `        ``} ` `     `  `        ``// Array contains only  ` `        ``// a single element. ` `        ``Console.WriteLine(-1); ` `        ``return` `-1; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``static` `void` `Main() ` `    ``{ ` `        ``sieve(); ` `        ``int` `[]A = ``new` `int``[]{ 2, 1, 1 }; ` `        ``int` `n = A.Length; ` `        ``findSubset(A, n); ` `    ``} ` `} ` ` `  `// This code is contributed by  ` `// Manish Shaw(manishshaw1) `

## PHP

 ` 0 and  ` `    ``// an integer > 1 is  ` `    ``// present in the array ` `    ``if` `(``\$cnt1` `> 0)  ` `    ``{ ` `        ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)  ` `        ``{ ` `            ``// Find a[i], where  ` `            ``// a[i] + 1 is prime. ` `            ``if` `((``\$a``[``\$i``] != 1) ``and`  `                ``(``\$isPrime``[``\$a``[``\$i``] + 1] == 0))  ` `            ``{ ` `                ``echo` `((``\$cnt1` `+ 1) . ``"\n"``); ` ` `  `                ``// Pr\$all the ones(1s). ` `                ``for` `(``\$j` `= 0; ` `                     ``\$j` `< ``\$cnt1``; ``\$j``++)  ` `                ``{ ` `                    ``echo` `(``"1 "``); ` `                ``} ` `                ``echo` `(``\$a``[``\$i``] . ``"\n"``); ` `                ``return` `0; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Case-II: array contains  ` `    ``// only ones(1s) ` `    ``if` `(``\$cnt1` `>= 2)  ` `    ``{ ` `        ``echo` `(cnt1 . ``"\n"``); ` ` `  `        ``// Pr\$all ones(1s). ` `        ``for` `(``\$i` `= 0;  ` `             ``\$i` `< ``\$cnt1``; ``\$i``++)  ` `            ``echo` `(``"1 "``); ` ` `  `        ``echo` `(``"\n"``); ` `        ``return` `0; ` `    ``}  ` `     `  `    ``// Case-III: array does  ` `    ``// not contain 1s ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)  ` `    ``{ ` `        ``for` `(``\$j` `= ``\$i` `+ 1; ` `             ``\$j` `< ``\$n``; ``\$j``++)  ` `        ``{ ` `            ``// Find a pair of integers ` `            ``// whose sum is prime ` `            ``if` `(``\$isPrime``[``\$a``[``\$i``] +  ` `                ``\$a``[``\$j``]] == 0)  ` `            ``{ ` `                ``echo` `(2 . ``"\n"``); ` `                ``echo` `(``\$a``[``\$i``] . ``" "` `.  ` `                      ``\$a``[``\$j``] . ``"\n"``); ` `                ``return` `0; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Array contains only ` `    ``// a single element. ` `    ``echo` `(-1 . ``"\n"``); ` `} ` ` `  `// Driver Code ` `sieve(); ` `\$A` `= ``array``(2, 1, 1); ` `\$n` `= ``count``(``\$A``); ` `findSubset(``\$A``, ``\$n``); ` ` `  `// This code is contributed by  ` `// Manish Shaw(manishshaw1) ` `?> `

Output :

```3
1 1 2```

Time Complexity : O(n2)

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.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.