Given an array **arr[]** of size **N**, the task is to find the count of distinct prime factors of each element of the given array.

**Examples:**

Input:arr[] = {6, 9, 12}Output:2 1 2Explanation:

- 6 =
2×3. Therefore, count = 2- 9 =
3× 3. Therefore, count = 1- 12 =
2× 2 ×3. Therefore, count = 2The count of distinct prime factors of each array element are

2, 1, 2respectively.

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

**Naive Approach:** The simplest approach to solve the problem is to find the prime factors of each array element. Then, find the distinct prime numbers among them and print that count for each array element. **Time Complexity:** O(N^{2})**Auxiliary Space:** O(1)

**Efficient Approach:** The above approach can be optimized by precomputing the distinct factors of all the numbers using their Smallest Prime Factors. Follow the steps below to solve the problem

- Initialize a vector, say
**v**, to store the distinct prime factors. - Store the Smallest Prime Factor
**(SPF)**up to**10**using a Sieve of Eratosthenes.^{5} - Calculate the distinct prime factors of all the numbers by dividing the numbers recursively with their smallest prime factor till it reduces to
**1**and store distinct prime factors of**X**, in**v[X]**. - Traverse the array
**arr[]**and for each array element, print the count as**v[arr[i]].size()**.

Below is the implementation of the above approach :

## C++14

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `#define MAX 100001` `// Stores smallest prime` `// factor for every number` `int` `spf[MAX];` `// Stores distinct prime factors` `vector<` `int` `> v[MAX];` `// Function to find the smallest` `// prime factor of every number` `void` `sieve()` `{` ` ` `// Mark the smallest prime factor` ` ` `// of every number to itself` ` ` `for` `(` `int` `i = 1; i < MAX; i++)` ` ` `spf[i] = i;` ` ` `// Seperately mark all the` ` ` `// smallest prime factor of` ` ` `// every even number to be 2` ` ` `for` `(` `int` `i = 4; i < MAX; i = i + 2)` ` ` `spf[i] = 2;` ` ` `for` `(` `int` `i = 3; i * i < MAX; i++)` ` ` `// If i is prime` ` ` `if` `(spf[i] == i) {` ` ` `// Mark spf for all numbers` ` ` `// divisible by i` ` ` `for` `(` `int` `j = i * i; j < MAX;` ` ` `j = j + i) {` ` ` `// Mark spf[j] if it is` ` ` `// not previously marked` ` ` `if` `(spf[j] == j)` ` ` `spf[j] = i;` ` ` `}` ` ` `}` `}` `// Function to find the distinct` `// prime factors` `void` `DistPrime()` `{` ` ` `for` `(` `int` `i = 1; i < MAX; i++) {` ` ` `int` `idx = 1;` ` ` `int` `x = i;` ` ` `// Push all distinct of x` ` ` `// prime factor in v[x]` ` ` `if` `(x != 1)` ` ` `v[i].push_back(spf[x]);` ` ` `x = x / spf[x];` ` ` `while` `(x != 1) {` ` ` `if` `(v[i][idx - 1]` ` ` `!= spf[x]) {` ` ` `// Pushback into v[i]` ` ` `v[i].push_back(spf[x]);` ` ` `// Increment the idx` ` ` `idx += 1;` ` ` `}` ` ` `// Update x = (x / spf[x])` ` ` `x = x / spf[x];` ` ` `}` ` ` `}` `}` `// Function to get the distinct` `// factor count of arr[]` `void` `getFactorCount(` `int` `arr[],` ` ` `int` `N)` `{` ` ` `// Precompute the smallest` ` ` `// Prime Factors` ` ` `sieve();` ` ` `// For distinct prime factors` ` ` `// Fill the v[] vector` ` ` `DistPrime();` ` ` `// Count of Distinct Prime` ` ` `// Factors of each array element` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `cout << (` `int` `)v[arr[i]].size()` ` ` `<< ` `" "` `;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 6, 9, 12 };` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `getFactorCount(arr, N);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;` `class` `GFG` `{` ` ` `static` `int` `MAX = ` `100001` `;` ` ` `// Stores smallest prime` ` ` `// factor for every number` ` ` `static` `int` `spf[];` ` ` `// Stores distinct prime factors` ` ` `static` `ArrayList<Integer> v[];` ` ` `// Function to find the smallest` ` ` `// prime factor of every number` ` ` `static` `void` `sieve()` ` ` `{` ` ` `// Mark the smallest prime factor` ` ` `// of every number to itself` ` ` `for` `(` `int` `i = ` `1` `; i < MAX; i++)` ` ` `spf[i] = i;` ` ` `// Seperately mark all the` ` ` `// smallest prime factor of` ` ` `// every even number to be 2` ` ` `for` `(` `int` `i = ` `4` `; i < MAX; i = i + ` `2` `)` ` ` `spf[i] = ` `2` `;` ` ` `for` `(` `int` `i = ` `3` `; i * i < MAX; i++)` ` ` `// If i is prime` ` ` `if` `(spf[i] == i) {` ` ` `// Mark spf for all numbers` ` ` `// divisible by i` ` ` `for` `(` `int` `j = i * i; j < MAX; j = j + i) {` ` ` `// Mark spf[j] if it is` ` ` `// not previously marked` ` ` `if` `(spf[j] == j)` ` ` `spf[j] = i;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Function to find the distinct` ` ` `// prime factors` ` ` `static` `void` `DistPrime()` ` ` `{` ` ` `for` `(` `int` `i = ` `1` `; i < MAX; i++) {` ` ` `int` `idx = ` `1` `;` ` ` `int` `x = i;` ` ` `// Push all distinct of x` ` ` `// prime factor in v[x]` ` ` `if` `(x != ` `1` `)` ` ` `v[i].add(spf[x]);` ` ` `x = x / spf[x];` ` ` `while` `(x != ` `1` `) {` ` ` `if` `(v[i].get(idx - ` `1` `) != spf[x]) {` ` ` `// Pushback into v[i]` ` ` `v[i].add(spf[x]);` ` ` `// Increment the idx` ` ` `idx += ` `1` `;` ` ` `}` ` ` `// Update x = (x / spf[x])` ` ` `x = x / spf[x];` ` ` `}` ` ` `}` ` ` `}` ` ` `// Function to get the distinct` ` ` `// factor count of arr[]` ` ` `static` `void` `getFactorCount(` `int` `arr[], ` `int` `N)` ` ` `{` ` ` `// initialization` ` ` `spf = ` `new` `int` `[MAX];` ` ` `v = ` `new` `ArrayList[MAX];` ` ` `for` `(` `int` `i = ` `0` `; i < MAX; i++)` ` ` `v[i] = ` `new` `ArrayList<>();` ` ` `// Precompute the smallest` ` ` `// Prime Factors` ` ` `sieve();` ` ` `// For distinct prime factors` ` ` `// Fill the v[] vector` ` ` `DistPrime();` ` ` `// Count of Distinct Prime` ` ` `// Factors of each array element` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) {` ` ` `System.out.print((` `int` `)v[arr[i]].size() + ` `" "` `);` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `arr[] = { ` `6` `, ` `9` `, ` `12` `};` ` ` `int` `N = arr.length;` ` ` `getFactorCount(arr, N);` ` ` `}` `}` `// This code is contributed by Kingash.` |

**Output:**

2 1 2

**Time Complexity:** O(N * log N)**Auxiliary Space:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**