Related Articles

Related Articles

Count array elements whose product of digits is a Composite Number
  • Last Updated : 25 Nov, 2020

Given an array arr[] consisting of N non-negative integers, the task is to count the number of array elements whose product of digits is a composite number.

Examples:

Input: arr[] = {13, 55, 7, 13, 11, 71, 233, 144, 89}
Output: 4
Explanation: The array elements having product of digits equal to a composite number are 55 (5 * 5 = 25), 233 (2 * 3 * 3 = 18), 144 (1 * 4 * 4 = 16), 89 ( = 8 * 9 = 72)

Input: arr[] = {34, 13, 55, 11, 8, 3, 55, 23}
Output:
Explanation: The array elements having product of digits equal to a composite number are 34 ( = 3 * 4 = 12), 55 ( 5 * 5 = 25), 23 ( = 2 * 3 = 6)

Approach: Follow the steps below to solve the problem:



Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
 
#include <bits/stdc++.h>
#include <set>
using namespace std;
 
#define N 100005
 
// Function to generate prime numbers
// using Sieve of Eratosthenes
void SieveOfEratosthenes(bool prime[],
                         int p_size)
{
    // Set 0 and 1 as non-prime
    prime[0] = false;
    prime[1] = false;
 
    for (int p = 2; p * p <= p_size; p++) {
        // If p is a prime
        if (prime[p]) {
 
            // Set all multiples of p as non-prime
            for (int i = p * 2; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
 
// Function to calculate the product
// of digits of the given number
long long int digitProduct(int number)
{
    // Stores the product of digits
    long long int res = 1;
    while (number > 0) {
 
        // Extract digits and
        // add to the sum
        res *= (number % 10);
        number /= 10;
    }
 
    // Return the product
    // of its digits
    return res;
}
 
// Function to print number of distinct
// values with digit product as composite
void DistinctCompositeDigitProduct(int arr[],
                                   int n)
{
    // Initialize set
    set<int> output;
 
    // Initialize boolean array
    bool prime[N + 1];
    memset(prime, true, sizeof(prime));
 
    // Pre-compute primes
    SieveOfEratosthenes(prime, N);
 
    // Traverse array
    for (int i = 0; i < n; i++) {
 
        // Stores the product of digits
        // of the current array element
        long long int ans
            = digitProduct(arr[i]);
 
        // If Product of digits is
        // less than or equal to 1
        if (ans <= 1) {
            continue;
        }
 
        // If Product of digits is
        // not a prime
        if (!prime[ans]) {
            output.insert(ans);
        }
    }
 
    // Print the answer
    cout << output.size() << endl;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[]
        = { 13, 55, 7, 13, 11,
            71, 233, 233, 144, 89 };
 
    // Given size
    int n = sizeof(arr)
            / sizeof(arr[0]);
 
    // Function call
    DistinctCompositeDigitProduct(arr, n);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.io.*;
import java.util.*;
   
class GFG{
   
static int N = 100005;
  
// Function to generate prime numbers
// using Sieve of Eratosthenes
static void SieveOfEratosthenes(boolean prime[],
                                int p_size)
{
     
    // Set 0 and 1 as non-prime
    prime[0] = false;
    prime[1] = false;
  
    for(int p = 2; p * p <= p_size; p++)
    {
         
        // If p is a prime
        if (prime[p])
        {
             
            // Set all multiples of p as non-prime
            for(int i = p * 2; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
  
// Function to calculate the product
// of digits of the given number
static int digitProduct(int number)
{
     
    // Stores the product of digits
    int res = 1;
    while (number > 0)
    {
         
        // Extract digits and
        // add to the sum
        res *= (number % 10);
        number /= 10;
    }
  
    // Return the product
    // of its digits
    return res;
}
  
// Function to print number of distinct
// values with digit product as composite
static void DistinctCompositeDigitProduct(int arr[],
                                          int n)
{
     
    // Initialize set
    TreeSet<Integer> output = new TreeSet<Integer>();
 
    // Initialize boolean array
    boolean prime[] = new boolean[N + 1];
    Arrays.fill(prime, true);
  
    // Pre-compute primes
    SieveOfEratosthenes(prime, N);
  
    // Traverse array
    for(int i = 0; i < n; i++)
    {
         
        // Stores the product of digits
        // of the current array element
        int ans = digitProduct(arr[i]);
  
        // If Product of digits is
        // less than or equal to 1
        if (ans <= 1)
        {
            continue;
        }
  
        // If Product of digits is
        // not a prime
        if (!prime[ans])
        {
            output.add(ans);
        }
    }
  
    // Print the answer
    System.out.print(output.size());
}
   
// Driver Code
public static void main(String[] args)
{
     
    // Given array
    int arr[] = { 13, 55, 7, 13, 11,
                  71, 233, 233, 144, 89 };
  
    // Given size
    int n = arr.length;
  
    // Function call
    DistinctCompositeDigitProduct(arr, n);
}
}
 
// This code is contributed by susmitakundugoaldanga

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
    
static int N = 100005;
   
// Function to generate prime numbers
// using Sieve of Eratosthenes
static void SieveOfEratosthenes(bool[] prime,
                                int p_size)
{
   
    // Set 0 and 1 as non-prime
    prime[0] = false;
    prime[1] = false;
   
    for(int p = 2; p * p <= p_size; p++)
    {
       
        // If p is a prime
        if (prime[p])
        {
              
            // Set all multiples of p as non-prime
            for(int i = p * 2; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
   
// Function to calculate the product
// of digits of the given number
static int digitProduct(int number)
{
      
    // Stores the product of digits
    int res = 1;
    while (number > 0)
    {
          
        // Extract digits and
        // add to the sum
        res *= (number % 10);
        number /= 10;
    }
   
    // Return the product
    // of its digits
    return res;
}
   
// Function to print number of distinct
// values with digit product as composite
static void DistinctCompositeDigitProduct(int[] arr,
                                          int n)
{
      
    // Initialize set
    SortedSet<int> output = new SortedSet<int>();
  
    // Initialize boolean array
    bool[] prime = new bool[N + 1];
    for(int i = 0; i < N + 1; i++)
    {
        prime[i] = true;
    }
     
    // Pre-compute primes
    SieveOfEratosthenes(prime, N);
   
    // Traverse array
    for(int i = 0; i < n; i++)
    {
          
        // Stores the product of digits
        // of the current array element
        int ans = digitProduct(arr[i]);
   
        // If Product of digits is
        // less than or equal to 1
        if (ans <= 1)
        {
            continue;
        }
   
        // If Product of digits is
        // not a prime
        if (!prime[ans])
        {
            output.Add(ans);
        }
    }
   
    // Print the answer
    Console.WriteLine(output.Count);
}
 
   
// Driver Code
public static void Main()
{
    // Given array
    int[] arr = { 13, 55, 7, 13, 11,
                  71, 233, 233, 144, 89 };
   
    // Given size
    int n = arr.Length;
   
    // Function call
    DistinctCompositeDigitProduct(arr, n);
}
}
 
// This code is contributed by sanjoy_62

chevron_right


Output: 

4

 

Time Complexity: O(N + MlogM), where N is the size of the given array and M is the maximum array element.
Auxiliary Space: O(1)

 

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
Recommended Articles
Page :