Count divisors of array multiplication
Last Updated :
19 Sep, 2023
Given an array with N elements, the task is to find the count of factors of a number X, which is the product of all array elements.
Examples:
Input : 5 5
Output : 3
5 * 5 = 25, the factors of 25 are 1, 5, 25
whose count is 3
Input : 3 5 7
Output : 8
3 * 5 * 7 = 105, the factors of 105 are 1,
3, 5, 7, 15, 21, 35, 105 whose count is 8
Method 1 (Simple but causes overflow):
- Multiply all the elements of the array.
- Count divisors in the number obtained after multiplication.
Implementation:
C++
// A simple C++ program to count divisors
// in array multiplication.
#include <iostream>
using namespace std;
// To count number of factors in a number
int counDivisors(int X)
{
// Initialize count with 0
int count = 0;
// Increment count for every factor
// of the given number X.
for (int i = 1; i <= X; ++i) {
if (X % i == 0) {
count++;
}
}
// Return number of factors
return count;
}
// Returns number of divisors in array
// multiplication
int countDivisorsMult(int arr[], int n)
{
// Multiplying all elements of
// the given array.
int mul = 1;
for (int i = 0; i < n; ++i)
mul *= arr[i];
// Calling function which count number of factors
// of the number
return counDivisors(mul);
}
// Driver code
int main()
{
int arr[] = { 2, 4, 6 };
int n = sizeof(arr) / sizeof(arr[0]);
cout << countDivisorsMult(arr, n) << endl;
return 0;
}
// A simple Java program to count divisors
// in array multiplication.
class GFG
{
// To count number of factors in a number
static int counDivisors(int X)
{
// Initialize count with 0
int count = 0;
// Increment count for every factor
// of the given number X.
for (int i = 1; i <= X; ++i)
{
if (X % i == 0) {
count++;
}
}
// Return number of factors
return count;
}
// Returns number of divisors in array
// multiplication
static int countDivisorsMult(int arr[], int n)
{
// Multiplying all elements of
// the given array.
int mul = 1;
for (int i = 0; i < n; ++i)
mul *= arr[i];
// Calling function which count
// number of factors of the number
return counDivisors(mul);
}
// Driver code
public static void main (String[] args)
{
int arr[] = { 2, 4, 6 };
int n = arr.length;
System.out.println(countDivisorsMult(arr, n));
}
}
// This code is contributed by Anant Agarwal.
# A simple Python program
# to count divisors
# in array multiplication.
# To count number of
# factors in a number
def counDivisors(X):
# Initialize count with 0
count = 0
# Increment count for
# every factor
# of the given number X.
for i in range(1, X + 1):
if (X % i == 0):
count += 1
# Return number of factors
return count
# Returns number of
# divisors in array
# multiplication
def countDivisorsMult(arr, n):
# Multiplying all elements of
# the given array.
mul = 1
for i in range(n):
mul *= arr[i]
# Calling function which
# count number of factors
# of the number
return counDivisors(mul)
# Driver code
arr = [ 2, 4, 6 ]
n =len(arr)
print(countDivisorsMult(arr, n))
# This code is contributed
# by Anant Agarwal.
// C# program to count divisors
// in array multiplication.
using System;
class GFG {
// To count number of factors
// in a number
static int counDivisors(int X)
{
// Initialize count with 0
int count = 0;
// Increment count for every
// factor of the given
// number X.
for (int i = 1; i <= X; ++i)
{
if (X % i == 0) {
count++;
}
}
// Return number of factors
return count;
}
// Returns number of divisors in
// array multiplication
static int countDivisorsMult(
int []arr, int n)
{
// Multiplying all elements
// of the given array.
int mul = 1;
for (int i = 0; i < n; ++i)
mul *= arr[i];
// Calling function which
// count number of factors
// of the number
return counDivisors(mul);
}
// Driver code
public static void Main ()
{
int []arr = { 2, 4, 6 };
int n = arr.Length;
Console.Write(
countDivisorsMult(arr, n));
}
}
// This code is contributed by
// nitin mittal.
<?php
// A simple PHP program to count divisors
// in array multiplication.
// To count number of factors in a number
function counDivisors($X)
{
// Initialize count with 0
$count = 0;
// Increment count for every factor
// of the given number X.
for ($i = 1; $i <= $X; ++$i) {
if ($X % $i == 0) {
$count++;
}
}
// Return number of factors
return $count;
}
// Returns number of divisors in array
// multiplication
function countDivisorsMult($arr, $n)
{
// Multiplying all elements of
// the given array.
$mul = 1;
for ($i = 0; $i < $n; ++$i)
$mul *= $arr[$i];
// Calling function which count
// number of factors of the number
return counDivisors($mul);
}
// Driver code
$arr = array(2, 4, 6);
$n = sizeof($arr);
echo countDivisorsMult($arr, $n);
// This code is contributed by nitin mittal
?>
<script>
// Javascript program to count divisors
// in array multiplication.
// To count number of factors in a number
function counDivisors(X)
{
// Initialize count with 0
let count = 0;
// Increment count for every factor
// of the given number X.
for (let i = 1; i <= X; ++i)
{
if (X % i == 0) {
count++;
}
}
// Return number of factors
return count;
}
// Returns number of divisors in array
// multiplication
function countDivisorsMult(arr, n)
{
// Multiplying all elements of
// the given array.
let mul = 1;
for (let i = 0; i < n; ++i)
mul *= arr[i];
// Calling function which count
// number of factors of the number
return counDivisors(mul);
}
// driver function
let arr = [ 2, 4, 6 ];
let n = arr.length;
document.write(countDivisorsMult(arr, n));
// This code is contributed by code_hunt.
</script>
Time Complexity: O(m), m is the multiplication of all elements of array
Auxiliary Space: O(1)
Method 2 (Avoids overflow):
- Find a maximum element in the array
- Find prime numbers smaller than the maximum element
- Find the number of overall occurrences of each prime factor in the whole array by traversing all array elements and finding their prime factors. We use hashing to count occurrences.
- Let the counts of occurrences of prime factors be a1, a2, ...aK, if we have K distinct prime factors, then the answer will be: (a1+1)(a2+1)(...)*(aK+1).
Implementation:
C++
// C++ program to count divisors in array multiplication.
#include <bits/stdc++.h>
using namespace std;
void SieveOfEratosthenes(int largest, vector<int> &prime)
{
// Create a boolean array "isPrime[0..n]" and initialize
// all entries it as true. A value in isPrime[i] will
// finally be false if i is Not a isPrime, else true.
bool isPrime[largest+1];
memset(isPrime, true, sizeof(isPrime));
for (int p = 2; p * p <= largest; p++)
{
// If isPrime[p] is not changed, then it is a isPrime
if (isPrime[p] == true)
{
// Update all multiples of p
for (int i = p * 2; i <= largest; i += p)
isPrime[i] = false;
}
}
// Print all isPrime numbers
for (int p = 2; p <= largest; p++)
if (isPrime[p])
prime.push_back(p);
}
// Returns number of divisors in array
// multiplication
int countDivisorsMult(int arr[], int n)
{
// Find all prime numbers smaller than
// the largest element.
int largest = *max_element(arr, arr+n);
vector<int> prime;
SieveOfEratosthenes(largest, prime);
// Find counts of occurrences of each prime
// factor
unordered_map<int, int> mp;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < prime.size(); j++)
{
while(arr[i] > 1 && arr[i]%prime[j] == 0)
{
arr[i] /= prime[j];
mp[prime[j]]++;
}
}
if (arr[i] != 1)
mp[arr[i]]++;
}
// Compute count of all divisors using counts
// prime factors.
long long int res = 1;
for (auto it : mp)
res *= (it.second + 1L);
return res;
}
// Driver code
int main()
{
int arr[] = { 2, 4, 6 };
int n = sizeof(arr) / sizeof(arr[0]);
cout << countDivisorsMult(arr, n) << endl;
return 0;
}
// Java program to count divisors in array multiplication.
import java.io.*;
import java.util.*;
class GFG
{
static void SieveOfEratosthenes(int largest, ArrayList<Integer> prime)
{
// Create a boolean array "isPrime[0..n]" and initialize
// all entries it as true. A value in isPrime[i] will
// finally be false if i is Not a isPrime, else true.
boolean[] isPrime = new boolean[largest + 1];
Arrays.fill(isPrime, true);
for (int p = 2; p * p <= largest; p++)
{
// If isPrime[p] is not changed, then it is a isPrime
if (isPrime[p] == true)
{
// Update all multiples of p
for (int i = p * 2; i <= largest; i += p)
isPrime[i] = false;
}
}
// Print all isPrime numbers
for (int p = 2; p <= largest; p++)
if (isPrime[p])
prime.add(p);
}
// Returns number of divisors in array
// multiplication
static long countDivisorsMult(int[] arr, int n)
{
// Find all prime numbers smaller than
// the largest element.
int largest = 0;
for(int a : arr )
{
largest=Math.max(largest, a);
}
ArrayList<Integer> prime = new ArrayList<Integer>();
SieveOfEratosthenes(largest, prime);
// Find counts of occurrences of each prime
// factor
Map<Integer,Integer> mp = new HashMap<>();
for (int i = 0; i < n; i++)
{
for (int j = 0; j < prime.size(); j++)
{
while(arr[i] > 1 && arr[i]%prime.get(j) == 0)
{
arr[i] /= prime.get(j);
if(mp.containsKey(prime.get(j)))
{
mp.put(prime.get(j), mp.get(prime.get(j)) + 1);
}
else
{
mp.put(prime.get(j), 1);
}
}
}
if (arr[i] != 1)
{
if(mp.containsKey(arr[i]))
{
mp.put(arr[i], mp.get(arr[i]) + 1);
}
else
{
mp.put(arr[i], 1);
}
}
}
// Compute count of all divisors using counts
// prime factors.
long res = 1;
for (int it : mp.keySet())
res *= (mp.get(it) + 1L);
return res;
}
// Driver code
public static void main (String[] args) {
int arr[] = { 2, 4, 6 };
int n = arr.length;
System.out.println(countDivisorsMult(arr, n));
}
}
// This code is contributed by avanitrachhadiya2155
# Python 3 program to count divisors in array multiplication.
from collections import defaultdict
def SieveOfEratosthenes(largest, prime):
# Create a boolean array "isPrime[0..n]" and initialize
# all entries it as true. A value in isPrime[i] will
# finally be false if i is Not a isPrime, else true.
isPrime = [True] * (largest + 1)
p = 2
while p * p <= largest:
# If isPrime[p] is not changed, then it is a isPrime
if (isPrime[p] == True):
# Update all multiples of p
for i in range(p * 2, largest + 1, p):
isPrime[i] = False
p += 1
# Print all isPrime numbers
for p in range(2, largest + 1):
if (isPrime[p]):
prime.append(p)
# Returns number of divisors in array
# multiplication
def countDivisorsMult(arr, n):
# Find all prime numbers smaller than
# the largest element.
largest = max(arr)
prime = []
SieveOfEratosthenes(largest, prime)
# Find counts of occurrences of each prime
# factor
mp = defaultdict(int)
for i in range(n):
for j in range(len(prime)):
while(arr[i] > 1 and arr[i] % prime[j] == 0):
arr[i] //= prime[j]
mp[prime[j]] += 1
if (arr[i] != 1):
mp[arr[i]] += 1
# Compute count of all divisors using counts
# prime factors.
res = 1
for it in mp.values():
res *= (it + 1)
return res
# Driver code
if __name__ == "__main__":
arr = [2, 4, 6]
n = len(arr)
print(countDivisorsMult(arr, n))
# This code is contributed by chitranayal.
// C# program to count divisors in array multiplication.
using System;
using System.Collections.Generic;
class GFG{
static void SieveOfEratosthenes(int largest,
List<int> prime)
{
// Create a boolean array "isPrime[0..n]" and initialize
// all entries it as true. A value in isPrime[i] will
// finally be false if i is Not a isPrime, else true.
bool[] isPrime = new bool[largest + 1];
Array.Fill(isPrime, true);
for(int p = 2; p * p <= largest; p++)
{
// If isPrime[p] is not changed, then it is a isPrime
if (isPrime[p] == true)
{
// Update all multiples of p
for (int i = p * 2; i <= largest; i += p)
isPrime[i] = false;
}
}
// Print all isPrime numbers
for(int p = 2; p <= largest; p++)
if (isPrime[p])
prime.Add(p);
}
// Returns number of divisors in array
// multiplication
static long countDivisorsMult(int[] arr, int n)
{
// Find all prime numbers smaller than
// the largest element.
int largest = 0;
foreach(int a in arr )
{
largest = Math.Max(largest, a);
}
List<int> prime = new List<int>();
SieveOfEratosthenes(largest, prime);
// Find counts of occurrences of each prime
// factor
Dictionary<int,
int> mp = new Dictionary<int,
int>();
for(int i = 0; i < n; i++)
{
for(int j = 0; j < prime.Count; j++)
{
while(arr[i] > 1 && arr[i] % prime[j] == 0)
{
arr[i] /= prime[j];
if (mp.ContainsKey(prime[j]))
{
mp[prime[j]]++;
}
else
{
mp.Add(prime[j], 1);
}
}
}
if (arr[i] != 1)
{
if(mp.ContainsKey(arr[i]))
{
mp[arr[i]]++;
}
else
{
mp.Add(arr[i], 1);
}
}
}
// Compute count of all divisors using counts
// prime factors.
long res = 1;
foreach(KeyValuePair<int, int> it in mp)
res *= (it.Value + 1L);
return res;
}
// Driver code
static public void Main()
{
int[] arr = { 2, 4, 6 };
int n = arr.Length;
Console.WriteLine(countDivisorsMult(arr, n));
}
}
// This code is contributed by rag2127
<script>
// javascript program to count divisors in array multiplication.
function SieveOfEratosthenes(largest, prime)
{
// Create a boolean array "isPrime[0..n]" and initialize
// all entries it as true. A value in isPrime[i] will
// finally be false if i is Not a isPrime, else true.
var isPrime = Array(largest+1).fill(true);
var p,i;
for (p = 2; p * p <= largest; p++)
{
// If isPrime[p] is not changed, then it is a isPrime
if (isPrime[p] == true)
{
// Update all multiples of p
for(i = p * 2; i <= largest; i += p)
isPrime[i] = false;
}
}
// Print all isPrime numbers
for (p = 2; p <= largest; p++)
if (isPrime[p])
prime.push(p);
}
// Returns number of divisors in array
// multiplication
function countDivisorsMult(arr, n)
{
// Find all prime numbers smaller than
// the largest element.
var largest = Math.max.apply(null,arr);
var prime = [];
SieveOfEratosthenes(largest, prime);
// Find counts of occurrences of each prime
// factor
var j;
var mp = new Map();
for (i = 0; i < n; i++)
{
for (j = 0; j < prime.length; j++)
{
while(arr[i] > 1 && arr[i]%prime[j] == 0)
{
arr[i] /= prime[j];
if(mp.has(prime[j]))
mp.set(prime[j],mp.get(prime[j])+1);
else
mp.set(prime[j],1);
}
}
if (arr[i] != 1){
if(mp.has(arr[i]))
mp.set(arr[i],mp.get(arr[i])+1);
else
mp.set(arr[i],1);
}
}
// Compute count of all divisors using counts
// prime factors.
var res = 1;
for (const [key, value] of mp.entries()) {
res *= (value + 1);
}
return res;
}
// Driver code
var arr = [2, 4, 6];
var n = arr.length;
document.write(countDivisorsMult(arr, n));
</script>
Time Complexity: O(n2)
Auxiliary Space: O(n)
Similar Reads
DSA Tutorial - Learn Data Structures and Algorithms DSA (Data Structures and Algorithms) is the study of organizing data efficiently using data structures like arrays, stacks, and trees, paired with step-by-step procedures (or algorithms) to solve problems effectively. Data structures manage how data is stored and accessed, while algorithms focus on
7 min read
Quick Sort QuickSort is a sorting algorithm based on the Divide and Conquer that picks an element as a pivot and partitions the given array around the picked pivot by placing the pivot in its correct position in the sorted array. It works on the principle of divide and conquer, breaking down the problem into s
12 min read
Merge Sort - Data Structure and Algorithms Tutorials Merge sort is a popular sorting algorithm known for its efficiency and stability. It follows the divide-and-conquer approach. It works by recursively dividing the input array into two halves, recursively sorting the two halves and finally merging them back together to obtain the sorted array. Merge
14 min read
Data Structures Tutorial Data structures are the fundamental building blocks of computer programming. They define how data is organized, stored, and manipulated within a program. Understanding data structures is very important for developing efficient and effective algorithms. What is Data Structure?A data structure is a st
2 min read
Bubble Sort Algorithm Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large data sets as its average and worst-case time complexity are quite high.We sort the array using multiple passes. After the fir
8 min read
Breadth First Search or BFS for a Graph Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Binary Search Algorithm - Iterative and Recursive Implementation Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). Binary Search AlgorithmConditions to apply Binary Searc
15 min read
Insertion Sort Algorithm Insertion sort is a simple sorting algorithm that works by iteratively inserting each element of an unsorted list into its correct position in a sorted portion of the list. It is like sorting playing cards in your hands. You split the cards into two groups: the sorted cards and the unsorted cards. T
9 min read
Array Data Structure Guide In this article, we introduce array, implementation in different popular languages, its basic operations and commonly seen problems / interview questions. An array stores items (in case of C/C++ and Java Primitive Arrays) or their references (in case of Python, JS, Java Non-Primitive) at contiguous
4 min read
Sorting Algorithms A Sorting Algorithm is used to rearrange a given array or list of elements in an order. For example, a given array [10, 20, 5, 2] becomes [2, 5, 10, 20] after sorting in increasing order and becomes [20, 10, 5, 2] after sorting in decreasing order. There exist different sorting algorithms for differ
3 min read