# Count pairs in an array whose product is composite number

Given an array, arr[] of size N, the task is to count all the pairs of the given array whose product is a composite number.

Examples:

Input: arr[] = {1, 4, 7}
Output: 2
Explanation:
Pairs whose product is a composite number are:(4, 7), (1, 4).
Therefore, the required output is 2.

Input: arr[] = {1, 2, 8, 10}
Output: 5

Naive approach: The idea is to traverse the array and generate all the possible pairs of the given array. For each pair, check if the product of its elements is a composite number or not. If found to be true, then increment the count by 1. Follow the steps below to solve the problem:

• Initialize a variable, say res to store the count of pairs whose product is a composite number.
• Traverse the array and generate all possible pairs of the given array.
• For each pair, check if their product is composite or not. If found to be true, then increment the value of res by 1.
• Finally, print the value of res.

Below is the implementation of the above approach

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to check if a` `// number is prime or not` `bool` `isComposite(``int` `N)` `{` `    ``// Check if N is multiple` `    ``// of i or not.` `    ``for` `(``int` `i = 2; i * i <= N;` `         ``i++) {`   `        ``// If N is multiple of i.` `        ``if` `(N % i == 0) {` `            ``return` `true``;` `        ``}` `    ``}`   `    ``return` `false``;` `}`   `// Function to get the count` `// of pairs whose product` `// is a composite number.` `int` `compositePair(``int` `arr[], ``int` `N)` `{` `    ``// Stores the count of pairs` `    ``// whose product is` `    ``// a composite number` `    ``int` `res = 0;`   `    ``// Generate all possible pairs` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``for` `(``int` `j = i + 1; j < N;` `             ``j++) {`   `            ``// Stores the product of` `            ``// element of current pair` `            ``int` `prod = arr[i] * arr[j];`   `            ``// If prod is a` `            ``// composite number` `            ``if` `(isComposite(prod)) {` `                ``res++;` `            ``}` `        ``}` `    ``}` `    ``return` `res;` `}`   `// Driver Code` `int` `main()` `{`   `    ``int` `arr[] = { 1, 1, 2, 2, 8 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << compositePair(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java Program to implement` `// the above approach` `import` `java.io.*;` `class` `GFG{` `    `  `// Function to check if a` `// number is prime or not` `static` `boolean` `isComposite(``int` `N)` `{` `  ``// Check if N is multiple` `  ``// of i or not.` `  ``for` `(``int` `i = ``2``; i * i <= N; i++) ` `  ``{` `    ``// If N is multiple of i.` `    ``if` `(N % i == ``0``) ` `    ``{` `      ``return` `true``;` `    ``}` `  ``}` `  ``return` `false``;` `}` ` `  `// Function to get the count` `// of pairs whose product` `// is a composite number.` `static` `int` `compositePair(``int` `arr[], ` `                         ``int` `N)` `{` `  ``// Stores the count of pairs` `  ``// whose product is` `  ``// a composite number` `  ``int` `res = ``0``;`   `  ``// Generate all possible pairs` `  ``for` `(``int` `i = ``0``; i < N; i++) ` `  ``{` `    ``for` `(``int` `j = i + ``1``; j < N; j++) ` `    ``{` `      ``// Stores the product of` `      ``// element of current pair` `      ``int` `prod = arr[i] * arr[j];`   `      ``// If prod is a` `      ``// composite number` `      ``if` `(isComposite(prod)) ` `      ``{` `        ``res++;` `      ``}` `    ``}` `  ``}` `  ``return` `res;` `}` ` `  `// Driver Code` `public` `static` `void` `main (String[] args)` `{` `  ``int` `arr[] = {``1``, ``1``, ``2``, ``2``, ``8``};` `  ``int` `N = arr.length;` `  ``System.out.println(compositePair(arr, N));` `}` `}`   `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to check if a` `# number is prime or not` `def` `isComposite(N):` `    `  `    ``# Check if N is multiple` `    ``# of i or not.` `    ``for` `i ``in` `range``(``2``, N ``+` `1``):` `        ``if` `i ``*` `i > N:` `            ``break`   `        ``# If N is multiple of i.` `        ``if` `(N ``%` `i ``=``=` `0``):` `            ``return` `True`   `    ``return` `False` `    `  `# Function to get the count` `# of pairs whose product` `# is a composite number.` `def` `compositePair(arr, N):` `    `  `    ``# Stores the count of pairs` `    ``# whose product is` `    ``# a composite number` `    ``res ``=` `0`   `    ``# Generate all possible pairs` `    ``for` `i ``in` `range``(N):` `        ``for` `j ``in` `range``(i ``+` `1``, N):`   `            ``# Stores the product of` `            ``# element of current pair` `            ``prod ``=` `arr[i] ``*` `arr[j]`   `            ``# If prod is a` `            ``# composite number` `            ``if` `(isComposite(prod)):` `                ``res ``+``=` `1` `                `  `    ``return` `res`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``arr ``=` `[ ``1``, ``1``, ``2``, ``2``, ``8` `]` `    ``N ``=` `len``(arr)` `    `  `    ``print``(compositePair(arr, N))`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# Program to implement` `// the above approach` `using` `System;` `class` `GFG{` `    `  `// Function to check if a` `// number is prime or not` `static` `bool` `isComposite(``int` `N)` `{` `  ``// Check if N is multiple` `  ``// of i or not.` `  ``for` `(``int` `i = 2; i * i <= N; i++) ` `  ``{` `    ``// If N is multiple of i.` `    ``if` `(N % i == 0) ` `    ``{` `      ``return` `true``;` `    ``}` `  ``}` `  ``return` `false``;` `}` ` `  `// Function to get the count` `// of pairs whose product` `// is a composite number.` `static` `int` `compositePair(``int` `[]arr, ` `                         ``int` `N)` `{` `  ``// Stores the count of pairs` `  ``// whose product is` `  ``// a composite number` `  ``int` `res = 0;`   `  ``// Generate all possible pairs` `  ``for` `(``int` `i = 0; i < N; i++) ` `  ``{` `    ``for` `(``int` `j = i + 1; j < N; j++) ` `    ``{` `      ``// Stores the product of` `      ``// element of current pair` `      ``int` `prod = arr[i] * arr[j];`   `      ``// If prod is a` `      ``// composite number` `      ``if` `(isComposite(prod)) ` `      ``{` `        ``res++;` `      ``}` `    ``}` `  ``}` `  ``return` `res;` `}` ` `  `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``int` `[]arr = {1, 1, 2, 2, 8};` `  ``int` `N = arr.Length;` `  ``Console.WriteLine(compositePair(arr, N));` `}` `}`   `// This code is contributed by shikhasingrajput`

Output

`5`

Time Complexity: O(N2 √X), where X is the maximum possible product of a pair in the given array.
Auxiliary Space: O(1)

Efficient Approach: TO optimize the above approach, the idea is to use the fact that all the prime numbers and 1s are not composite numbers. Follow the steps below to solve the problem:

• Initialize two variables cntPrime and cntOne to store the count of 1s and prime numbers in the given array respectively.
• Initialize a variable, say res to store the count of pairs whose product is a composite number.
• Total pairs whose product is not a composite number is:

cntNonComp = cntPrime × cntOne + cntOne × (cntOne – 1) / 2.

• Therefore, the total count of pairs whose product is a composite number is:

res = N × (N – 1) / 2 – cntNonComp.

• Finally, print the value of res.

Below is the implementation of the above approach

## C++

 `// C++ program to implement` `// the above approach` `#include ` `using` `namespace` `std;` `#define X 1000000`   `// Function to get all` `// the prime numbers in` `// the range[1, X]` `vector<``bool``> getPrimeNum()` `{` `    ``// Stores the boolean value` `    ``// to check if a number is` `    ``// prime or not` `    ``vector<``bool``> isPrime(X, ``true``);`   `    ``isPrime = ``false``;` `    ``isPrime = ``false``;`   `    ``// Mark all non prime` `    ``// numbers as false` `    ``for` `(``int` `i = 2; i * i <= X;` `         ``i++) {`   `        ``// If i is prime number` `        ``if` `(isPrime[i] == ``true``) {` `            ``for` `(``int` `j = i * i;` `                 ``j < X; j += i) {`   `                ``// Mark j as` `                ``// a composite number` `                ``isPrime[j] = ``false``;` `            ``}` `        ``}` `    ``}` `    ``return` `isPrime;` `}`   `// Function to get the count of pairs` `// whose product is a composite number` `int` `cntPairs(``int` `arr[], ``int` `N)` `{` `    ``// Stores the boolean value` `    ``// to check if a number is` `    ``// prime or not` `    ``vector<``bool``> isPrime` `        ``= getPrimeNum();`   `    ``// Stores the count of 1s` `    ``int` `cntOne = 0;`   `    ``// Stores the count` `    ``// of prime numbers` `    ``int` `cntPrime = 0;`   `    ``// Traverse the given array.` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``if` `(arr[i] == 1) {` `            ``cntOne += 1;` `        ``}` `        ``else` `if` `(isPrime[i]) {` `            ``cntPrime += 1;` `        ``}` `    ``}`   `    ``// Stores count of pairs whose` `    ``// product is not a composite number` `    ``int` `cntNonComp = 0;` `    ``cntNonComp = cntPrime * cntOne` `                 ``+ cntOne * (cntOne - 1) / 2;`   `    ``// Stores the count of pairs` `    ``// whose product is composite number` `    ``int` `res = 0;` `    ``res = N * (N - 1) / 2 - cntNonComp;`   `    ``return` `res;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 2, 8 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << cntPairs(arr, N);` `}`

## Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;`   `class` `GFG{` `    `  `public` `static` `int` `X = ``1000000``;`   `// Function to get all` `// the prime numbers in` `// the range[1, X]` `public` `static` `boolean``[] getPrimeNum()` `{` `    `  `    ``// Stores the boolean value` `    ``// to check if a number is` `    ``// prime or not` `    ``boolean` `isPrime[] = ``new` `boolean``[X];` `    ``Arrays.fill(isPrime, ``true``); ` ` `  `    ``isPrime[``0``] = ``false``;` `    ``isPrime[``1``] = ``false``;` ` `  `    ``// Mark all non prime` `    ``// numbers as false` `    ``for``(``int` `i = ``2``; i * i <= X; i++)` `    ``{` `        `  `        ``// If i is prime number` `        ``if` `(isPrime[i] == ``true``) ` `        ``{` `            ``for``(``int` `j = i * i; j < X; j += i)` `            ``{` `                `  `                ``// Mark j as a composite ` `                ``// number` `                ``isPrime[j] = ``false``;` `            ``}` `        ``}` `    ``}` `    ``return` `isPrime;` `}` ` `  `// Function to get the count of pairs` `// whose product is a composite number` `public` `static` `int` `cntPairs(``int` `arr[], ``int` `N)` `{` `    `  `    ``// Stores the boolean value` `    ``// to check if a number is` `    ``// prime or not` `    ``boolean` `isPrime[] = getPrimeNum();` ` `  `    ``// Stores the count of 1s` `    ``int` `cntOne = ``0``;` ` `  `    ``// Stores the count` `    ``// of prime numbers` `    ``int` `cntPrime = ``0``;` ` `  `    ``// Traverse the given array.` `    ``for``(``int` `i = ``0``; i < N; i++)` `    ``{` `        ``if` `(arr[i] == ``1``)` `        ``{` `            ``cntOne += ``1``;` `        ``}` `        ``else` `if` `(isPrime[i]) ` `        ``{` `            ``cntPrime += ``1``;` `        ``}` `    ``}` ` `  `    ``// Stores count of pairs whose` `    ``// product is not a composite number` `    ``int` `cntNonComp = ``0``;` `    ``cntNonComp = cntPrime * cntOne + ` `                   ``cntOne * (cntOne - ``1``) / ``2``;` ` `  `    ``// Stores the count of pairs` `    ``// whose product is composite number` `    ``int` `res = ``0``;` `    ``res = N * (N - ``1``) / ``2` `- cntNonComp;` ` `  `    ``return` `res;` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `    ``int` `arr[] = { ``1``, ``1``, ``2``, ``2``, ``8` `};` `    ``int` `N = arr.length;` `    `  `    ``System.out.println(cntPairs(arr, N));` `}` `}`   `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program to implement` `# the above approach` `X ``=` `1000000`   `# Function to get all` `# the prime numbers in` `# the range[1, X]` `def` `getPrimeNum():`   `    ``# Stores the boolean value` `    ``# to check if a number is` `    ``# prime or not` `    ``isPrime ``=` `[``True``] ``*` `(X)`   `    ``isPrime[``0``] ``=` `False` `    ``isPrime[``1``] ``=` `False`   `    ``# Mark all non prime` `    ``# numbers as false` `    ``i ``=` `2` `    ``while` `i ``*` `i <``=` `X:`   `        ``# If i is prime number` `        ``if` `(isPrime[i] ``=``=` `True``):` `            ``for` `j ``in` `range``(i ``*` `i, ` `                           ``X, i):`   `                ``# Mark j as` `                ``# a composite number` `                ``isPrime[j] ``=` `False`   `        ``i ``+``=` `1`   `    ``return` `isPrime`   `# Function to get the count ` `# of pairs whose product ` `# is a composite number` `def` `cntPairs(arr, N):`   `    ``# Stores the boolean value` `    ``# to check if a number is` `    ``# prime or not` `    ``isPrime ``=` `getPrimeNum()`   `    ``# Stores the count of 1s` `    ``cntOne ``=` `0`   `    ``# Stores the count` `    ``# of prime numbers` `    ``cntPrime ``=` `0`   `    ``# Traverse the given array.` `    ``for` `i ``in` `range``(N):` `        ``if` `(arr[i] ``=``=` `1``):` `            ``cntOne ``+``=` `1` `        ``elif` `(isPrime[i]):` `            ``cntPrime ``+``=` `1`   `    ``# Stores count of pairs whose` `    ``# product is not a composite number` `    ``cntNonComp ``=` `0` `    ``cntNonComp ``=` `(cntPrime ``*` `cntOne ``+` `                  ``cntOne ``*` `(cntOne ``-` `1``) ``/``/` `2``)`   `    ``# Stores the count of pairs` `    ``# whose product is composite number` `    ``res ``=` `0` `    ``res ``=` `(N ``*` `(N ``-` `1``) ``/``/` `2` `-` `           ``cntNonComp)`   `    ``return` `res`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``1``, ``1``, ``2``, ``2``, ``8``]` `    ``N ``=` `len``(arr)` `    ``print``(cntPairs(arr, N))`   `# This code is contributed by Chitranayal`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `class` `GFG{` `    `  `public` `static` `int` `X = 1000000;`   `// Function to get all` `// the prime numbers in` `// the range[1, X]` `public` `static` `bool``[] getPrimeNum()` `{` `  ``// Stores the bool value` `  ``// to check if a number is` `  ``// prime or not` `  ``bool` `[]isPrime = ``new` `bool``[X];` `  `  `  ``for``(``int` `i = 0; i < X; i++)` `    ``isPrime[i] = ``true``;`   `  ``isPrime = ``false``;` `  ``isPrime = ``false``;`   `  ``// Mark all non prime` `  ``// numbers as false` `  ``for``(``int` `i = 2; ` `          ``i * i <= X; i++)` `  ``{` `    ``// If i is prime number` `    ``if` `(isPrime[i] == ``true``) ` `    ``{` `      ``for``(``int` `j = i * i; ` `              ``j < X; j += i)` `      ``{` `        ``// Mark j as a composite ` `        ``// number` `        ``isPrime[j] = ``false``;` `      ``}` `    ``}` `  ``}` `  ``return` `isPrime;` `}` ` `  `// Function to get the count of pairs` `// whose product is a composite number` `public` `static` `int` `cntPairs(``int` `[]arr, ` `                           ``int` `N)` `{    ` `  ``// Stores the bool value` `  ``// to check if a number is` `  ``// prime or not` `  ``bool` `[]isPrime = getPrimeNum();`   `  ``// Stores the count of 1s` `  ``int` `cntOne = 0;`   `  ``// Stores the count` `  ``// of prime numbers` `  ``int` `cntPrime = 0;`   `  ``// Traverse the given array.` `  ``for``(``int` `i = 0; i < N; i++)` `  ``{` `    ``if` `(arr[i] == 1)` `    ``{` `      ``cntOne += 1;` `    ``}` `    ``else` `if` `(isPrime[i]) ` `    ``{` `      ``cntPrime += 1;` `    ``}` `  ``}`   `  ``// Stores count of pairs ` `  ``// whose product is not ` `  ``// a composite number` `  ``int` `cntNonComp = 0;` `  ``cntNonComp = cntPrime * cntOne + ` `               ``cntOne * (cntOne - 1) / 2;`   `  ``// Stores the count of pairs` `  ``// whose product is composite number` `  ``int` `res = 0;` `  ``res = N * (N - 1) / 2 - cntNonComp;`   `  ``return` `res;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args) ` `{` `  ``int` `[]arr = {1, 1, 2, 2, 8};` `  ``int` `N = arr.Length;` `  ``Console.WriteLine(cntPairs(arr, N));` `}` `}`   `// This code is contributed by gauravrajput1`

Output

`5`

Time Complexity: O(N + X × log(log(X))), Where X stores the maximum possible product of a pair in the given array.
Auxiliary Space: O(X)

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 Active and well versed member of Competitive Programming

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.