# Product of all the Composite Numbers in an array

Given an array of integers. The task is to calculate the product of all the composite numbers in an array.

Note: 1 is neither prime nor composite.

Examples:

```Input: arr[] = {2, 3, 4, 5, 6, 7}
Output: 24
Composite numbers are 4 and 6.
So, product = 24

Input: arr[] = {11, 13, 17, 20, 19}
Output: 20```

Naive Approach: A simple solution is to traverse the array and do a primality test on every element. If the element is not prime nor 1, multiply it to the running product.
Time Complexity: O(Nsqrt(N))

Efficient Approach: Using Sieve of Eratosthenes generate a boolean vector upto the size of the maximum element from the array which can be used to check whether a number is prime or not. Also add 0 and 1 as a prime so that they donâ€™t get counted as composite numbers. Now traverse the array and find the product of those elements which are composite using the generated boolean vector.

Implementation:

## C++

 `// C++ program to find the product``// of all the composite numbers``// in an array``#include ``using` `namespace` `std;` `// Function that returns the``// the product of all composite numbers``int` `compositeProduct(``int` `arr[], ``int` `n)``{``    ``// Find maximum value in the array``    ``int` `max_val = *max_element(arr, arr + n);` `    ``// Use sieve to find all prime numbers``    ``// less than or equal to max_val``    ``// Create a boolean array "prime[0..n]". A``    ``// value in prime[i] will finally be false``    ``// if i is Not a prime, else true.``    ``vector<``bool``> prime(max_val + 1, ``true``);` `    ``// Set 0 and 1 as primes as``    ``// they don't need to be``    ``// counted as composite numbers``    ``prime[0] = ``true``;``    ``prime[1] = ``true``;``    ``for` `(``int` `p = 2; p * p <= max_val; p++) {` `        ``// If prime[p] is not changed, then``        ``// it is a prime``        ``if` `(prime[p] == ``true``) {` `            ``// Update all multiples of p``            ``for` `(``int` `i = p * 2; i <= max_val; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}` `    ``// Find the product of all``    ``// composite numbers in the arr[]``    ``int` `product = 1;``    ``for` `(``int` `i = 0; i < n; i++)``        ``if` `(!prime[arr[i]]) {``            ``product *= arr[i];``        ``}` `    ``return` `product;``}` `// Driver code``int` `main()``{` `    ``int` `arr[] = { 2, 3, 4, 5, 6, 7 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << compositeProduct(arr, n);` `    ``return` `0;``}`

## Java

 `// Java program to find the product``// of all the composite numbers``// in an array``import` `java.util.*;` `class` `GFG {` `    ``// Function that returns the``    ``// the product of all composite numbers``    ``static` `int` `compositeProduct(``int` `arr[], ``int` `n)``    ``{``        ``// Find maximum value in the array``        ``int` `max_val = Arrays.stream(arr).max().getAsInt();` `        ``// Use sieve to find all prime numbers``        ``// less than or equal to max_val``        ``// Create a boolean array "prime[0..n]". A``        ``// value in prime[i] will finally be false``        ``// if i is Not a prime, else true.``        ``boolean``[] prime = ``new` `boolean``[max_val + ``1``];``        ``Arrays.fill(prime, ``true``);` `        ``// Set 0 and 1 as primes as``        ``// they don't need to be``        ``// counted as composite numbers``        ``prime[``0``] = ``true``;``        ``prime[``1``] = ``true``;``        ``for` `(``int` `p = ``2``; p * p <= max_val; p++) {` `            ``// If prime[p] is not changed, then``            ``// it is a prime``            ``if` `(prime[p] == ``true``) {` `                ``// Update all multiples of p``                ``for` `(``int` `i = p * ``2``; i <= max_val; i += p) {``                    ``prime[i] = ``false``;``                ``}``            ``}``        ``}` `        ``// Find the product of all``        ``// composite numbers in the arr[]``        ``int` `product = ``1``;``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(!prime[arr[i]]) {``                ``product *= arr[i];``            ``}``        ``}` `        ``return` `product;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``2``, ``3``, ``4``, ``5``, ``6``, ``7` `};``        ``int` `n = arr.length;` `        ``System.out.println(compositeProduct(arr, n));``    ``}``}` `// This code has been contributed by 29AjayKumar`

## Python3

 `'''``Python3 program to find product of``all the composite numbers in given array'''``import` `math as mt``'''``function to find the product of all composite``numbers in the given array``'''``def` `compositeProduct(arr, n):``    ` `     ` `    ``# find the maximum value in the array``    ``max_val ``=` `max``(arr)``    ``'''``    ``USE SIEVE TO FIND ALL PRIME NUMBERS LESS``    ``THAN OR EQUAL TO max_val``    ``Create a boolean array "prime[0..n]". A``    ``value in prime[i] will finally be false``    ``if i is Not a prime, else true.``    ``'''``    ``prime ``=``[``True` `for` `i ``in` `range``(max_val ``+` `1``)]``    ` `    ``'''``    ``Set 0 and 1 as primes as``    ``they don't need to be``    ``counted as composite numbers``    ``'''``    ``prime[``0``]``=` `True``    ``prime[``1``]``=` `True``    ` `    ``for` `p ``in` `range``(``2``, mt.ceil(mt.sqrt(max_val))):``        ``# Remaining part of SIEVE``        ``'''``        ``if prime[p] is not changed, than it is prime``        ``'''``        ``if` `prime[p]:``            ``# update all multiples of p``            ``for` `i ``in` `range``(p ``*` `2``, max_val ``+` `1``, p):``                ``prime[i]``=` `False``    ` `    ``# find the product of all composite numbers in the arr[]``    ``product ``=` `1``    ` `    ``for` `i ``in` `range``(n):``        ``if` `prime[arr[i]]``=``=` `False``:``            ``product``*``=` `arr[i]``    ` `    ``return` `product` `# Driver code` `arr ``=``[``2``, ``3``, ``4``, ``5``, ``6``, ``7``]` `n ``=` `len``(arr)` `print``(compositeProduct(arr, n))` `# contributed by Mohit kumar 29``       `

## C#

 `// C# program to find the product``// of all the composite numbers``// in an array``using` `System;``using` `System.Linq;``public` `class` `GFG {` `    ``// Function that returns the``    ``// the product of all composite numbers``    ``static` `int` `compositeProduct(``int``[] arr, ``int` `n)``    ``{``        ``// Find maximum value in the array``        ``int` `max_val = arr.Max();` `        ``// Use sieve to find all prime numbers``        ``// less than or equal to max_val``        ``// Create a boolean array "prime[0..n]". A``        ``// value in prime[i] will finally be false``        ``// if i is Not a prime, else true.``        ``bool``[] prime = ``new` `bool``[max_val + 1];``        ``for` `(``int` `i = 0; i < max_val + 1; i++)``            ``prime[i] = ``true``;` `        ``// Set 0 and 1 as primes as``        ``// they don't need to be``        ``// counted as composite numbers``        ``prime[0] = ``true``;``        ``prime[1] = ``true``;``        ``for` `(``int` `p = 2; p * p <= max_val; p++) {` `            ``// If prime[p] is not changed, then``            ``// it is a prime``            ``if` `(prime[p] == ``true``) {` `                ``// Update all multiples of p``                ``for` `(``int` `i = p * 2; i <= max_val; i += p) {``                    ``prime[i] = ``false``;``                ``}``            ``}``        ``}` `        ``// Find the product of all``        ``// composite numbers in the arr[]``        ``int` `product = 1;``        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `(!prime[arr[i]]) {``                ``product *= arr[i];``            ``}``        ``}` `        ``return` `product;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 2, 3, 4, 5, 6, 7 };``        ``int` `n = arr.Length;` `        ``Console.WriteLine(compositeProduct(arr, n));``    ``}``}``/* This code contributed by PrinciRaj1992 */`

## PHP

 ``

## Javascript

 ``

Output
`24`

Complexity Analysis:

• Time Complexity: O(n + max_val2)
• Auxiliary Space: O(max_val)

Previous
Next