Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Number of N length sequences whose product is M

  • Difficulty Level : Expert
  • Last Updated : 08 Jun, 2021

Given two integers N and M, the task is to find the count of possible sequences a1, a2, … of length N such that the product of all the elements of the sequence is M.
Examples: 
 

Input: N = 2, M = 6 
Output:
Possible sequences are {1, 6}, {2, 3}, {3, 2} and {6, 1}
Input: N = 3, M = 24 
Output: 30 
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

 



Approach: 
 

  • Consider the prime factorisation of M as p1k1p2k2 …pzkz.
  • For each prime factor, its exponent has to be distributed among N different groups because on multiplying those N terms, the exponents of the prime factors will add. This can be done using the formula explained here.
  • For each prime factor, the number of ways of distributing its exponents in N sequences would be equal to 
    N + Ki -1CN-1 for every 1 ≤ i ≤ z.
  • Using Fundamental Principle of Multiplication, multiply the results of all the prime factors to get the answer.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the
// value of ncr effectively
int ncr(int n, int r)
{
 
    // Initializing the result
    int res = 1;
 
    for (int i = 1; i <= r; i += 1) {
 
        // Multiply and divide simultaneously
        // to avoid overflow
        res *= (n - r + i);
        res /= i;
    }
 
    // Return the answer
    return res;
}
 
// Function to return the number of sequences
// of length N such that their product is M
int NoofSequences(int N, int M)
{
 
    // Hashmap to store the prime factors of M
    unordered_map<int, int> prime;
 
    // Calculate the prime factors of M
    for (int i = 2; i <= sqrt(M); i += 1) {
 
        // If i divides M it means it is a factor
        // Divide M by i till it could be
        // divided to store the exponent
        while (M % i == 0) {
 
            // Increase the exponent count
            prime[i] += 1;
            M /= i;
        }
    }
 
    // If the number is a prime number
    // greater than sqrt(M)
    if (M > 1) {
        prime[M] += 1;
    }
 
    // Initializing the ans
    int ans = 1;
 
    // Multiply the answer for every prime factor
    for (auto it : prime) {
 
        // it.second represents the
        // exponent of every prime factor
        ans *= (ncr(N + it.second - 1, N - 1));
    }
 
    // Return the result
    return ans;
}
 
// Driver code
int main()
{
    int N = 2, M = 6;
 
    cout << NoofSequences(N, M);
 
    return 0;
}

Java




// Java implementation of the above approach
import java.util.HashMap;
 
class geeks
{
 
    // Function to calculate the
    // value of ncr effectively
    public static int nCr(int n, int r)
    {
 
        // Initializing the result
        int res = 1;
        for (int i = 1; i <= r; i++)
        {
 
            // Multiply and divide simultaneously
            // to avoid overflow
            res *= (n - r + i);
            res /= i;
        }
 
        // Return the answer
        return res;
    }
 
    // Function to return the number of sequences
    // of length N such that their product is M
    public static int NoofSequences(int N, int M)
    {
         
        // Hashmap to store the prime factors of M
        HashMap<Integer, Integer> prime = new HashMap<>();
 
        // Calculate the prime factors of M
        for (int i = 2; i <= Math.sqrt(M); i++)
        {
 
            // If i divides M it means it is a factor
            // Divide M by i till it could be
            // divided to store the exponent
            while (M % i == 0)
            {
 
                // Increase the exponent count
                if (prime.get(i) == null)
                    prime.put(i, 1);
                else
                {
                    int x = prime.get(i);
                    prime.put(i, ++x);
                }
                M /= i;
            }
        }
 
        // If the number is a prime number
        // greater than sqrt(M)
        if (M > 1)
        {
            if (prime.get(M) != null)
            {
                int x = prime.get(M);
                prime.put(M, ++x);
            }
            else
                prime.put(M, 1);
        }
 
        // Initializing the ans
        int ans = 1;
 
        // Multiply the answer for every prime factor
        for (HashMap.Entry<Integer, Integer> entry : prime.entrySet())
        {
 
            // entry.getValue() represents the
            // exponent of every prime factor
            ans *= (nCr(N + entry.getValue() - 1, N - 1));
        }
 
        // Return the result
        return ans;
    }
     
    // Driver code
    public static void main(String[] args)
    {
        int N = 2, M = 6;
        System.out.println(NoofSequences(N, M));
    }
}
 
// This code is contributed by
// sanjeev2552

Python3




# Python3 implementation of the above approach
 
# Function to calculate the
# value of ncr effectively
def ncr(n, r):
 
 
    # Initializing the result
    res = 1
 
    for i in range(1,r+1):
 
        # Multiply and divide simultaneously
        # to avoid overflow
        res *= (n - r + i)
        res //= i
 
    # Return the answer
    return res
 
# Function to return the number of sequences
# of length N such that their product is M
def NoofSequences(N, M):
 
    # Hashmap to store the prime factors of M
    prime={}
 
    # Calculate the prime factors of M
    for i in range(2,int(M**(.5))+1):
 
        # If i divides M it means it is a factor
        # Divide M by i till it could be
        # divided to store the exponent
        while (M % i == 0):
 
            # Increase the exponent count
            prime[i]= prime.get(i,0)+1
            M //= i
 
 
    # If the number is a prime number
    # greater than sqrt(M)
    if (M > 1):
        prime[M] =prime.get(M,0) + 1
 
    # Initializing the ans
    ans = 1
 
    # Multiply the answer for every prime factor
    for it in prime:
 
        # it.second represents the
        # exponent of every prime factor
        ans *= (ncr(N + prime[it] - 1, N - 1))
 
    # Return the result
    return ans
 
# Driver code
 
N = 2
M = 6
 
print(NoofSequences(N, M))
 
# This code is contributed by mohit kumar 29

C#




// C# implementation of the approach
using System;
using System.Collections.Generic;
     
public class geeks
{
  
    // Function to calculate the
    // value of ncr effectively
    public static int nCr(int n, int r)
    {
  
        // Initializing the result
        int res = 1;
        for (int i = 1; i <= r; i++)
        {
  
            // Multiply and divide simultaneously
            // to avoid overflow
            res *= (n - r + i);
            res /= i;
        }
  
        // Return the answer
        return res;
    }
  
    // Function to return the number of sequences
    // of length N such that their product is M
    public static int NoofSequences(int N, int M)
    {
          
        // Hashmap to store the prime factors of M
        Dictionary<int,int>prime = new Dictionary<int,int>();
  
        // Calculate the prime factors of M
        for (int i = 2; i <= Math.Sqrt(M); i++)
        {
  
            // If i divides M it means it is a factor
            // Divide M by i till it could be
            // divided to store the exponent
            while (M % i == 0)
            {
  
                // Increase the exponent count
                if (!prime.ContainsKey(i))
                    prime.Add(i, 1);
                else
                {
                    int x = prime[i];
                    prime.Remove(i);
                    prime.Add(i, ++x);
                }
                M /= i;
            }
        }
  
        // If the number is a prime number
        // greater than sqrt(M)
        if (M > 1)
        {
            if (prime.ContainsKey(M))
            {
                int x = prime[M];
                prime.Remove(M);
                prime.Add(M, ++x);
            }
            else
                prime.Add(M, 1);
        }
  
        // Initializing the ans
        int ans = 1;
  
        // Multiply the answer for every prime factor
        foreach(KeyValuePair<int, int> entry in prime)
        {
  
            // entry.getValue() represents the
            // exponent of every prime factor
            ans *= (nCr(N + entry.Value - 1, N - 1));
        }
  
        // Return the result
        return ans;
    }
      
    // Driver code
    public static void Main(String[] args)
    {
        int N = 2, M = 6;
        Console.WriteLine(NoofSequences(N, M));
    }
}
 
// This code is contributed by Princi Singh

Javascript




<script>
// Javascript implementation of the above approach
 
    // Function to calculate the
    // value of ncr effectively
    function nCr(n,r)
    {
        // Initializing the result
        let res = 1;
        for (let i = 1; i <= r; i++)
        {
   
            // Multiply and divide simultaneously
            // to avoid overflow
            res *= (n - r + i);
            res =Math.floor(res/ i);
        }
   
        // Return the answer
        return res;
    }
     
    // Function to return the number of sequences
    // of length N such that their product is M
    function NoofSequences(N,M)
    {
        // Hashmap to store the prime factors of M
        let prime = new Map();
   
        // Calculate the prime factors of M
        for (let i = 2; i <= Math.sqrt(M); i++)
        {
   
            // If i divides M it means it is a factor
            // Divide M by i till it could be
            // divided to store the exponent
            while (M % i == 0)
            {
   
                // Increase the exponent count
                if (prime.get(i) == null)
                    prime.set(i, 1);
                else
                {
                    let x = prime.get(i);
                    prime.set(i, ++x);
                }
                M = Math.floor(M/i);
            }
        }
   
        // If the number is a prime number
        // greater than sqrt(M)
        if (M > 1)
        {
            if (prime.get(M) != null)
            {
                let x = prime.get(M);
                prime.set(M, ++x);
            }
            else
                prime.set(M, 1);
        }
   
        // Initializing the ans
        let ans = 1;
   
        // Multiply the answer for every prime factor
        for (let [key, value] of prime.entries())
        {
   
            // entry.getValue() represents the
            // exponent of every prime factor
            ans *= (nCr(N + value - 1, N - 1));
        }
   
        // Return the result
        return ans;
    }
     
    // Driver code
    let N = 2, M = 6;
    document.write(NoofSequences(N, M));
 
// This code is contributed by patel2127
</script>
Output: 
4

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!