# 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 ``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 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 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

 ``
Output:
`4`

My Personal Notes arrow_drop_up