# Generate a sequence with product N such that for every pair of indices (i, j) and i < j, arr[j] is divisible by arr[i]

• Difficulty Level : Medium
• Last Updated : 09 Aug, 2021

Given a positive integer N, the task is to generate a sequence say arr[] of maximum length having all elements at least 2 such that the product of all the numbers in the sequence is N and for any pair of indices (i, j) and i < j, arr[j] is divisible by arr[i].

Examples:

Input: N = 360
Output: Maximum size = 3, final array = {2, 2, 90}
Explanation:
Consider the array arr[] be the resultant array, then the following operations can be performed:

1. Add 2 to the array arr[]. Now, N = 360/2 = 180 and arr[] = {2}.
2. Add 2 to the array arr[]. Now, N = 180/2 = 90 and arr[] = {2, 2}.
3. Add 90 to the array arr[]. Now, arr[] = {2, 2, 90}.

After the above operations, the maximum size of the array is 3 and the resultant array is {2, 2, 90}.

Input: N = 810
Output: Maximum size = 4, final array = {3, 3, 3, 30}

Approach: The given problem can be solved by using the concept of prime factorization, the idea is to find the prime number having the maximum frequency of occurrence as N that can be represented as the product of prime numbers as:

N = (a1p1)*(a2p1)*(a3p1)*(a4p1)(……)*(anpn)

Follow the steps below to solve the problem:

• Initialize a Map, say M that stores all the prime numbers as a key and their powers as values. For example, for the value 23, the map M stores as M = 3.
• Choose the prime factor which has the maximum power factor and store that power in a variable, say ans, and store that prime number in a variable say P.
• If the value of ans is smaller than 2, then the resultant array will be of size 1 and the array element will be equal to N.
• Otherwise, print the value of ans as the maximum length, and to print the final sequence, print the value of P (ans – 1) number of times, and then print (N/2ans) at the end.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to calculate the prime` `// factors of N with their count` `vector > primeFactor(` `    ``int` `N)` `{` `    ``// Initialize a vector, say v` `    ``vector > v;`   `    ``// Initialize the count` `    ``int` `count = 0;`   `    ``// Count the number of divisors` `    ``while` `(!(N % 2)) {`   `        ``// Divide the value of N by 2` `        ``N >>= 1;` `        ``count++;` `    ``}`   `    ``// For factor 2 divides it` `    ``if` `(count)` `        ``v.push_back({ 2, count });`   `    ``// Find all prime factors` `    ``for` `(``int` `i = 3;` `         ``i <= ``sqrt``(N); i += 2) {`   `        ``// Count their frequency` `        ``count = 0;` `        ``while` `(N % i == 0) {` `            ``count++;` `            ``N = N / i;` `        ``}`   `        ``// Push it to the vector` `        ``if` `(count) {` `            ``v.push_back({ i, count });` `        ``}` `    ``}`   `    ``// Push N if it is not 1` `    ``if` `(N > 2)` `        ``v.push_back({ N, 1 });`   `    ``return` `v;` `}`   `// Function to print the array that` `// have the maximum size` `void` `printAnswer(``int` `n)` `{` `    ``// Stores the all prime factor` `    ``// and their powers` `    ``vector > v` `        ``= primeFactor(n);`   `    ``int` `maxi_size = 0, prime_factor = 0;`   `    ``// Traverse the vector and find` `    ``// the maximum power of prime` `    ``// factor` `    ``for` `(``int` `i = 0; i < v.size(); i++) {`   `        ``if` `(maxi_size < v[i].second) {` `            ``maxi_size = v[i].second;` `            ``prime_factor = v[i].first;` `        ``}` `    ``}`   `    ``// If max size is less than 2` `    ``if` `(maxi_size < 2) {` `        ``cout << 1 << ``' '` `<< n;` `    ``}`   `    ``// Otherwise` `    ``else` `{`   `        ``int` `product = 1;`   `        ``// Print the maximum size` `        ``// of sequence` `        ``cout << maxi_size << endl;`   `        ``// Print the final sequence` `        ``for` `(``int` `i = 0;` `             ``i < maxi_size - 1; i++) {`   `            ``// Print the prime factor` `            ``cout << prime_factor << ``" "``;` `            ``product *= prime_factor;` `        ``}`   `        ``// Print the last value of` `        ``// the sequence` `        ``cout << (n / product);` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 360;` `    ``printAnswer(N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{` `    ``static` `class` `pair` `    ``{ ` `        ``int` `first, second; ` `        ``public` `pair(``int` `first, ``int` `second)  ` `        ``{ ` `            ``this``.first = first; ` `            ``this``.second = second; ` `        ``}    ` `    ``} ` `// Function to calculate the prime` `// factors of N with their count` `static` `Vector primeFactor(` `    ``int` `N)` `{` `  `  `    ``// Initialize a vector, say v` `    ``Vector v = ``new` `Vector<>();`   `    ``// Initialize the count` `    ``int` `count = ``0``;`   `    ``// Count the number of divisors` `    ``while` `((N % ``2``)==``0``) {`   `        ``// Divide the value of N by 2` `        ``N >>= ``1``;` `        ``count++;` `    ``}`   `    ``// For factor 2 divides it` `    ``if` `(count!=``0``)` `        ``v.add(``new` `pair( ``2``, count ));`   `    ``// Find all prime factors` `    ``for` `(``int` `i = ``3``;` `         ``i <= Math.sqrt(N); i += ``2``) {`   `        ``// Count their frequency` `        ``count = ``0``;` `        ``while` `(N % i == ``0``) {` `            ``count++;` `            ``N = N / i;` `        ``}`   `        ``// Push it to the vector` `        ``if` `(count!=``0``) {` `            ``v.add(``new` `pair( i, count ));` `        ``}` `    ``}`   `    ``// Push N if it is not 1` `    ``if` `(N > ``2``)` `        ``v.add(``new` `pair( N, ``1` `));`   `    ``return` `v;` `}`   `// Function to print the array that` `// have the maximum size` `static` `void` `printAnswer(``int` `n)` `{` `    ``// Stores the all prime factor` `    ``// and their powers` `    ``Vector v` `        ``= primeFactor(n);`   `    ``int` `maxi_size = ``0``, prime_factor = ``0``;`   `    ``// Traverse the vector and find` `    ``// the maximum power of prime` `    ``// factor` `    ``for` `(``int` `i = ``0``; i < v.size(); i++) {`   `        ``if` `(maxi_size < v.get(i).second) {` `            ``maxi_size = v.get(i).second;` `            ``prime_factor = v.get(i).first;` `        ``}` `    ``}`   `    ``// If max size is less than 2` `    ``if` `(maxi_size < ``2``) {` `        ``System.out.print(``1` `<< ``' '``);` `    ``}`   `    ``// Otherwise` `    ``else` `{`   `        ``int` `product = ``1``;`   `        ``// Print the maximum size` `        ``// of sequence` `        ``System.out.print(maxi_size +``"\n"``);`   `        ``// Print the final sequence` `        ``for` `(``int` `i = ``0``;` `             ``i < maxi_size - ``1``; i++) {`   `            ``// Print the prime factor` `            ``System.out.print(prime_factor+ ``" "``);` `            ``product *= prime_factor;` `        ``}`   `        ``// Print the last value of` `        ``// the sequence` `        ``System.out.print((n / product));` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``360``;` `    ``printAnswer(N);`   `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach` `from` `math ``import` `sqrt`   `# Function to calculate the prime` `# factors of N with their count` `def` `primeFactor(N):` `    `  `    ``# Initialize a vector, say v` `    ``v ``=` `[]`   `    ``# Initialize the count` `    ``count ``=` `0`   `    ``# Count the number of divisors` `    ``while` `((N ``%` `2``) ``=``=` `0``):` `        `  `        ``# Divide the value of N by 2` `        ``N >>``=` `1` `        ``count ``+``=` `1`   `    ``# For factor 2 divides it` `    ``if` `(count):` `        ``v.append([``2``, count])`   `    ``# Find all prime factors` `    ``for` `i ``in` `range``(``3``, ``int``(sqrt(N)) ``+` `1``, ``2``):` `        `  `        ``# Count their frequency` `        ``count ``=` `0` `        ``while` `(N ``%` `i ``=``=` `0``):` `            ``count ``+``=` `1` `            ``N ``=` `N ``/` `i`   `        ``# Push it to the vector` `        ``if` `(count):` `            ``v.append([i, count])`   `    ``# Push N if it is not 1` `    ``if` `(N > ``2``):` `        ``v.append([N, ``1``])`   `    ``return` `v`   `# Function to print the array that` `# have the maximum size` `def` `printAnswer(n):` `    `  `    ``# Stores the all prime factor` `    ``# and their powers` `    ``v ``=` `primeFactor(n)`   `    ``maxi_size ``=` `0` `    ``prime_factor ``=` `0`   `    ``# Traverse the vector and find` `    ``# the maximum power of prime` `    ``# factor` `    ``for` `i ``in` `range``(``len``(v)):` `        ``if` `(maxi_size < v[i][``1``]):` `            ``maxi_size ``=` `v[i][``1``]` `            ``prime_factor ``=` `v[i][``0``]`   `    ``# If max size is less than 2` `    ``if` `(maxi_size < ``2``):` `        ``print``(``1``, n)`   `    ``# Otherwise` `    ``else``:` `        ``product ``=` `1`   `        ``# Print the maximum size` `        ``# of sequence` `        ``print``(maxi_size)`   `        ``# Print the final sequence` `        ``for` `i ``in` `range``(maxi_size ``-` `1``):` `            `  `            ``# Print the prime factor` `            ``print``(prime_factor, end ``=` `" "``)` `            ``product ``*``=` `prime_factor`   `        ``# Print the last value of` `        ``# the sequence` `        ``print``(n ``/``/` `product)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``N ``=` `360` `    `  `    ``printAnswer(N)` `    `  `# This code is contributed by SURENDRA_GANGWAR`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG{` `    ``class` `pair` `    ``{ ` `        ``public` `int` `first;` `        ``public` `int` `second; ` `        ``public` `pair(``int` `first, ``int` `second)  ` `        ``{ ` `            ``this``.first = first; ` `            ``this``.second = second; ` `        ``}    ` `    ``} ` `  `  `// Function to calculate the prime` `// factors of N with their count` `static` `List primeFactor(` `    ``int` `N)` `{` `  `  `    ``// Initialize a vector, say v` `    ``List v = ``new` `List();`   `    ``// Initialize the count` `    ``int` `count = 0;`   `    ``// Count the number of divisors` `    ``while` `((N % 2)==0) {`   `        ``// Divide the value of N by 2` `        ``N >>= 1;` `        ``count++;` `    ``}`   `    ``// For factor 2 divides it` `    ``if` `(count!=0)` `        ``v.Add(``new` `pair( 2, count ));`   `    ``// Find all prime factors` `    ``for` `(``int` `i = 3;` `         ``i <= Math.Sqrt(N); i += 2) {`   `        ``// Count their frequency` `        ``count = 0;` `        ``while` `(N % i == 0) {` `            ``count++;` `            ``N = N / i;` `        ``}`   `        ``// Push it to the vector` `        ``if` `(count!=0) {` `            ``v.Add(``new` `pair( i, count ));` `        ``}` `    ``}`   `    ``// Push N if it is not 1` `    ``if` `(N > 2)` `        ``v.Add(``new` `pair( N, 1 ));`   `    ``return` `v;` `}`   `// Function to print the array that` `// have the maximum size` `static` `void` `printAnswer(``int` `n)` `{` `  `  `    ``// Stores the all prime factor` `    ``// and their powers` `    ``List v` `        ``= primeFactor(n);`   `    ``int` `maxi_size = 0, prime_factor = 0;`   `    ``// Traverse the vector and find` `    ``// the maximum power of prime` `    ``// factor` `    ``for` `(``int` `i = 0; i < v.Count; i++) {`   `        ``if` `(maxi_size < v[i].second) {` `            ``maxi_size = v[i].second;` `            ``prime_factor = v[i].first;` `        ``}` `    ``}`   `    ``// If max size is less than 2` `    ``if` `(maxi_size < 2) {` `        ``Console.Write(1 << ``' '``);` `    ``}`   `    ``// Otherwise` `    ``else` `{`   `        ``int` `product = 1;`   `        ``// Print the maximum size` `        ``// of sequence` `        ``Console.Write(maxi_size +``"\n"``);`   `        ``// Print the readonly sequence` `        ``for` `(``int` `i = 0;` `             ``i < maxi_size - 1; i++) {`   `            ``// Print the prime factor` `            ``Console.Write(prime_factor+ ``" "``);` `            ``product *= prime_factor;` `        ``}`   `        ``// Print the last value of` `        ``// the sequence` `        ``Console.Write((n / product));` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `N = 360;` `    ``printAnswer(N);`   `}` `}`   `// This code is contributed by 29AjayKumar `

## Javascript

 ``

Output:

```3
2 2 90```

Time Complexity: O(N3/2)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :