# Construct longest possible sequence of unique elements with given LCM

• Last Updated : 11 Jun, 2021

Given a positive integer N, the task is to construct the longest sorted sequence of unique elements whose LCM of the is equal to N.

Examples:

Input: N = 12
Output: 1 2 3 4 6 12
Explanation:
LCM of {1, 2, 3, 4, 6, 12 } is N( = 12).
Therefore, the longest possible sequence is {1, 2, 3, 4, 6, 12 }.

Input: N = 9
Output: 1 3 9
Explanation:
LCM of { 1, 2, 9 } is N( = 9).
Therefore, the longest possible sequence is {1, 3, 9 }.

Approach: The problem can be solved based on the following observation:

If an array element is not a factor of N then the LCM of the array elements never be N. Therefore, the array elements must be the factor of N.

Follow the below steps to solve this problem:

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to construct an array of``// unique elements whose LCM is N``void` `constructArrayWithGivenLCM(``int` `N)``{``    ``// Stores array elements``    ``// whose LCM is N``    ``vector<``int``> newArr;` `    ``// Iterate over the range``    ``// [1, sqrt(N)]``    ``for` `(``int` `i = 1; i * i <= N;``         ``i++) {` `        ``// If N is divisible``        ``// by i``        ``if` `(N % i == 0) {` `            ``// Insert i into newArr[]``            ``newArr.push_back(i);` `            ``// If N is not perfect square``            ``if` `(N / i != i) {``                ``newArr.push_back(N / i);``            ``}``        ``}``    ``}` `    ``// Sort the array newArr[]``    ``sort(newArr.begin(), newArr.end());` `    ``// Print array elements``    ``for` `(``auto` `i : newArr) {` `        ``cout << i << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given N``    ``int` `N = 12;` `    ``// Function Call``    ``constructArrayWithGivenLCM(N);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.Arrays;` `class` `GFG{` `// Function to construct an array of``// unique elements whose LCM is N``static` `void` `constructArrayWithGivenLCM(``int` `N)``{``    ` `    ``// Stores array elements``    ``// whose LCM is N``    ``int` `newArr[] = ``new` `int``[N];` `    ``int` `j = ``0``;``    ` `    ``// Iterate over the range``    ``// [1, sqrt(N)]``    ``for``(``int` `i = ``1``; i * i <= N; i++)``    ``{``        ` `        ``// If N is divisible``        ``// by i``        ``if` `(N % i == ``0``)``        ``{``            ` `            ``// Insert i into newArr[]``            ``newArr[j] = i;``            ``j++;` `            ``// If N is not perfect square``            ``if` `(N / i != i)``            ``{``                ``newArr[j] = N / i;``                ``j++;``            ``}``        ``}``    ``}` `    ``// Sort the array newArr[]``    ``Arrays.sort(newArr);` `    ``// Print array elements``    ``for``(``int` `i = j; i < N; i++) ``    ``{``        ``System.out.print(newArr[i] + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ` `    ``// Given N``    ``int` `N = ``12``;``    ` `    ``// Function Call``    ``constructArrayWithGivenLCM(N);``}``}` `// This code is contributed by AnkThon`

## Python3

 `# Python3 program to implement``# the above approach``from` `math ``import` `sqrt,ceil,floor` `# Function to construct an array of``# unique elements whose LCM is N``def` `constructArrayWithGivenLCM(N):``  ` `    ``# Stores array elements``    ``# whose LCM is N``    ``newArr ``=` `[]` `    ``# Iterate over the range``    ``# [1, sqrt(N)]``    ``for` `i ``in` `range``(``1``, ceil(sqrt(N ``+` `1``))):` `        ``# If N is divisible``        ``# by i``        ``if` `(N ``%` `i ``=``=` `0``):` `            ``# Insert i into newArr[]``            ``newArr.append(i)` `            ``# If N is not perfect square``            ``if` `(N ``/``/` `i !``=` `i):``                ``newArr.append(N ``/``/` `i)` `    ``# Sort the array newArr[]``    ``newArr ``=` `sorted``(newArr)` `    ``# Print array elements``    ``for` `i ``in` `newArr:``        ``print``(i, end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `  ``# Given N``    ``N ``=` `12` `    ``# Function Call``    ``constructArrayWithGivenLCM(N)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement``// the above approach``using` `System;``class` `GFG{` `  ``// Function to construct an array of``  ``// unique elements whose LCM is N``  ``static` `void` `constructArrayWithGivenLCM(``int` `N)``  ``{` `    ``// Stores array elements``    ``// whose LCM is N``    ``int` `[]newArr = ``new` `int``[N];` `    ``int` `j = 0;` `    ``// Iterate over the range``    ``// [1, sqrt(N)]``    ``for``(``int` `i = 1; i * i <= N; i++)``    ``{` `      ``// If N is divisible``      ``// by i``      ``if` `(N % i == 0)``      ``{` `        ``// Insert i into newArr[]``        ``newArr[j] = i;``        ``j++;` `        ``// If N is not perfect square``        ``if` `(N / i != i)``        ``{``          ``newArr[j] = N / i;``          ``j++;``        ``}``      ``}``    ``}` `    ``// Sort the array newArr[]``    ``Array.Sort(newArr);` `    ``// Print array elements``    ``for``(``int` `i = j; i < N; i++) ``    ``{``      ``Console.Write(newArr[i] + ``" "``);``    ``}``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{` `    ``// Given N``    ``int` `N = 12;` `    ``// Function Call``    ``constructArrayWithGivenLCM(N);``  ``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``
Output:
`1 2 3 4 6 12`

Time Complexity: O(√ N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up