# Smallest integer which has n factors or more

Given n, find the smallest integer which has n factors or more. It may be assumed that the result is less than 1000001.

Examples:

```Input : n = 3
Output : 4
Explanation: 4 has factors 1, 2 and 4.

Input : n = 2
Output : 2
Explanation: 2 has one factor 1 and 2.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

There are many methods to calculate the number of factors, but the efficient one can be found here

Simple Approach: A simple approach will be to run a loop to find out the factors of a number. One for finding out the factors of a number in O(x) is to run a loop from 1 to x and see all numbers that divide x.
Time Complexity: O(x) for every number x that we try until we find answer or reach limit.

Efficient Approach:We can find out factors in sqrt(x)for every iteration.
Time Complexity: O(sqrt(x)) for every number x that we try until we find answer or reach limit.

Best Approach will be to traverse for every number and calculate the number of factors. Then check if the count is equal to or more then n then we get our desired smallest integer with n or more factors.

Below is the implementation of the above approach:

## C++

 `// c++ program to print the smallest ` `// integer with n factors or more ` `#include ` `using` `namespace` `std; ` ` `  `const` `int` `MAX = 1000001; ` ` `  `// array to store prime factors ` `int` `factor[MAX] = { 0 }; ` ` `  `// function to generate all prime factors ` `// of numbers from 1 to 10^6 ` `void` `generatePrimeFactors() ` `{ ` `    ``factor = 1; ` ` `  `    ``// Initializes all the positions ` `    ``// with their value. ` `    ``for` `(``int` `i = 2; i < MAX; i++) ` `        ``factor[i] = i; ` ` `  `    ``// Initializes all multiples of 2 with 2 ` `    ``for` `(``int` `i = 4; i < MAX; i += 2) ` `        ``factor[i] = 2; ` ` `  `    ``// A modified version of Sieve of ` `    ``// Eratosthenes to store the smallest ` `    ``// prime factor that divides every number. ` `    ``for` `(``int` `i = 3; i * i < MAX; i++) { ` ` `  `        ``// check if it has no prime factor. ` `        ``if` `(factor[i] == i) { ` ` `  `            ``// Initializes of j starting from i*i ` `            ``for` `(``int` `j = i * i; j < MAX; j += i) { ` ` `  `                ``// if it has no prime factor ` `                ``// before, then stores the ` `                ``// smallest prime divisor ` `                ``if` `(factor[j] == j) ` `                    ``factor[j] = i; ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// function to calculate number of factors ` `int` `calculateNoOFactors(``int` `n) ` `{ ` `    ``if` `(n == 1) ` `        ``return` `1; ` ` `  `    ``int` `ans = 1; ` ` `  `    ``// stores the smallest prime number ` `    ``// that divides n ` `    ``int` `dup = factor[n]; ` ` `  `    ``// stores the count of number of times ` `    ``// a prime number divides n. ` `    ``int` `c = 1; ` ` `  `    ``// reduces to the next number after prime ` `    ``// factorization of n ` `    ``int` `j = n / factor[n]; ` ` `  `    ``// false when prime factorization is done ` `    ``while` `(j != 1) { ` ` `  `        ``// if the same prime number is dividing n, ` `        ``// then we increase the count ` `        ``if` `(factor[j] == dup) ` `            ``c += 1; ` ` `  `        ``/* if its a new prime factor that is ` `           ``factorizing n, then we again set c=1  ` `           ``and change dup to the new prime factor, ` `           ``and apply the formula explained above. */` `        ``else` `{ ` `            ``dup = factor[j]; ` `            ``ans = ans * (c + 1); ` `            ``c = 1; ` `        ``} ` ` `  `        ``// prime factorizes a number ` `        ``j = j / factor[j]; ` `    ``} ` ` `  `    ``// for the last prime factor ` `    ``ans = ans * (c + 1); ` ` `  `    ``return` `ans; ` `} ` ` `  `// function to find the smallest integer ` `// with n factors or more. ` `int` `smallest(``int` `n) ` `{ ` `    ``for` `(``int` `i = 1;; i++) ` ` `  `        ``// check if no of factors is more ` `        ``// than n or not ` `        ``if` `(calculateNoOFactors(i) >= n) ` `            ``return` `i; ` `} ` ` `  `// Driver program to test above function ` `int` `main() ` `{ ` `    ``// generate prime factors of number ` `    ``// upto 10^6 ` `    ``generatePrimeFactors(); ` ` `  `    ``int` `n = 4; ` `    ``cout << smallest(n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to print the smallest ` `// integer with n factors or more ` `import` `java.util.*; ` `import` `java.lang.*; ` ` `  `public` `class` `GfG{ ` `    ``private` `static` `final` `int` `MAX = ``1000001``; ` ` `  `    ``// array to store prime factors ` `    ``private` `static` `final` `int``[] factor = ``new` `int` `[MAX]; ` ` `  `    ``// function to generate all prime factors ` `    ``// of numbers from 1 to 10^6 ` `    ``public` `static` `void` `generatePrimeFactors() ` `    ``{ ` `        ``factor[``1``] = ``1``; ` ` `  `        ``// Initializes all the positions ` `        ``// with their value. ` `        ``for` `(``int` `i = ``2``; i < MAX; i++) ` `            ``factor[i] = i; ` ` `  `        ``// Initializes all multiples of 2 with 2 ` `        ``for` `(``int` `i = ``4``; i < MAX; i += ``2``) ` `            ``factor[i] = ``2``; ` ` `  `        ``// A modified version of Sieve of ` `        ``// Eratosthenes to store the smallest ` `        ``// prime factor that divides every number. ` `        ``for` `(``int` `i = ``3``; i * i < MAX; i++) { ` ` `  `            ``// check if it has no prime factor. ` `            ``if` `(factor[i] == i) { ` ` `  `                ``// Initializes of j starting from i*i ` `                ``for` `(``int` `j = i * i; j < MAX; j += i) { ` ` `  `                    ``// if it has no prime factor ` `                    ``// before, then stores the ` `                    ``// smallest prime divisor ` `                    ``if` `(factor[j] == j) ` `                        ``factor[j] = i; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// function to calculate number of factors ` `    ``public` `static` `int` `calculateNoOFactors(``int` `n) ` `    ``{ ` `        ``if` `(n == ``1``) ` `            ``return` `1``; ` ` `  `        ``int` `ans = ``1``; ` ` `  `        ``// stores the smallest prime number ` `        ``// that divides n ` `        ``int` `dup = factor[n]; ` ` `  `        ``// stores the count of number of times ` `        ``// a prime number divides n. ` `        ``int` `c = ``1``; ` ` `  `        ``// reduces to the next number after prime ` `        ``// factorization of n ` `        ``int` `j = n / factor[n]; ` ` `  `        ``// false when prime factorization is done ` `        ``while` `(j != ``1``) { ` ` `  `            ``// if the same prime number is dividing n, ` `            ``// then we increase the count ` `            ``if` `(factor[j] == dup) ` `                ``c += ``1``; ` ` `  `            ``/* if its a new prime factor that is ` `            ``factorizing n, then we again set c=1  ` `            ``and change dup to the new prime factor, ` `            ``and apply the formula explained above. */` `            ``else` `{ ` `                ``dup = factor[j]; ` `                ``ans = ans * (c + ``1``); ` `                ``c = ``1``; ` `            ``} ` ` `  `            ``// prime factorizes a number ` `            ``j = j / factor[j]; ` `        ``} ` ` `  `        ``// for the last prime factor ` `        ``ans = ans * (c + ``1``); ` ` `  `        ``return` `ans;  ` `    ``} ` ` `  `    ``// function to find the smallest integer ` `    ``// with n factors or more. ` `    ``public` `static` `int` `smallest(``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = ``1``;; i++) ` ` `  `            ``// check if no of factors is more ` `            ``// than n or not ` `            ``if` `(calculateNoOFactors(i) >= n) ` `                ``return` `i; ` `    ``} ` `     `  `    ``// driver function ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``// generate prime factors of number ` `        ``// upto 10^6 ` `        ``generatePrimeFactors(); ` ` `  `        ``int` `n = ``4``; ` `        ``System.out.println(smallest(n)); ` `    ``} ` `} ` ` `  `/* This code is contributed by Sagar Shukla */`

## Python3

 `# Python3 program to print the  ` `# smallest integer with n ` `# factors or more ` `MAX` `=` `100001``; ` ` `  `# array to store ` `# prime factors ` `factor ``=` `[``0``] ``*` `MAX``; ` ` `  `# function to generate all  ` `# prime factors of numbers ` `# from 1 to 10^6 ` `def` `generatePrimeFactors(): ` `     `  `    ``factor[``1``] ``=` `1``; ` ` `  `    ``# Initializes all the  ` `    ``# positions with their value. ` `    ``for` `i ``in` `range``(``2``, ``MAX``): ` `        ``factor[i] ``=` `i; ` ` `  `    ``# Initializes all ` `    ``# multiples of 2 with 2 ` `    ``i ``=` `4` `    ``while``(i < ``MAX``): ` `        ``factor[i] ``=` `2``; ` `        ``i ``+``=` `2``; ` ` `  `    ``# A modified version of  ` `    ``# Sieve of Eratosthenes  ` `    ``# to store the smallest ` `    ``# prime factor that  ` `    ``# divides every number. ` `    ``i ``=` `3``;  ` `    ``while``(i ``*` `i < ``MAX``): ` ` `  `        ``# check if it has ` `        ``# no prime factor. ` `        ``if` `(factor[i] ``=``=` `i): ` ` `  `            ``# Initializes of j  ` `            ``# starting from i*i ` `            ``j ``=` `i ``*` `i; ` `            ``while``(j < ``MAX``):  ` ` `  `                ``# if it has no prime factor ` `                ``# before, then stores the ` `                ``# smallest prime divisor ` `                ``if` `(factor[j] ``=``=` `j): ` `                    ``factor[j] ``=` `i; ` `                ``j ``+``=` `i; ` `        ``i ``+``=` `1``; ` ` `  `# function to calculate  ` `# number of factors ` `def` `calculateNoOFactors(n): ` `    ``if` `(n ``=``=` `1``): ` `        ``return` `1``; ` ` `  `    ``ans ``=` `1``; ` ` `  `    ``# stores the smallest prime  ` `    ``# number that divides n ` `    ``dup ``=` `factor[n]; ` ` `  `    ``# stores the count of  ` `    ``# number of times a  ` `    ``# prime number divides n. ` `    ``c ``=` `1``; ` ` `  `    ``# reduces to the next ` `    ``# number after prime ` `    ``# factorization of n ` `    ``j ``=` `int``(n ``/` `factor[n]); ` ` `  `    ``# false when prime  ` `    ``# factorization is done ` `    ``while` `(j !``=` `1``): ` ` `  `        ``# if the same prime number  ` `        ``# is dividing n, then we  ` `        ``# increase the count ` `        ``if` `(factor[j] ``=``=` `dup): ` `            ``c ``+``=` `1``; ` ` `  `        ``# if its a new prime factor  ` `        ``# that is factorizing n, then  ` `        ``# we again set c=1 and change  ` `        ``# dup to the new prime factor, ` `        ``# and apply the formula  ` `        ``# explained above.  ` `        ``else``: ` `            ``dup ``=` `factor[j]; ` `            ``ans ``=` `ans ``*` `(c ``+` `1``); ` `            ``c ``=` `1``; ` ` `  `        ``# prime factorizes a number ` `        ``j ``=` `int``(j ``/` `factor[j]); ` ` `  `    ``# for the last prime factor ` `    ``ans ``=` `ans ``*` `(c ``+` `1``); ` ` `  `    ``return` `ans; ` ` `  `# function to find the  ` `# smallest integer with ` `# n factors or more. ` `def` `smallest(n): ` `    ``i ``=` `1``; ` `    ``while``(``True``): ` `         `  `        ``# check if no of  ` `        ``# factors is more ` `        ``# than n or not ` `        ``if` `(calculateNoOFactors(i) >``=` `n): ` `            ``return` `i; ` `        ``i ``+``=` `1``; ` ` `  `# Driver Code ` ` `  `# generate prime factors  ` `# of number upto 10^6 ` `generatePrimeFactors(); ` ` `  `n ``=` `4``; ` `print``(smallest(n)); ` ` `  `# This code is contributed by mits `

## C#

 `// C# program to print the smallest ` `// integer with n factors or more ` `using` `System; ` ` `  `class` `GfG { ` `    ``private` `static` `int` `MAX = 1000001; ` ` `  `    ``// array to store prime factors ` `    ``private` `static` `int` `[]factor = ``new` `int` `[MAX]; ` ` `  `    ``// function to generate all prime  ` `    ``// factorsof numbers from 1 to 10^6 ` `    ``public` `static` `void` `generatePrimeFactors() ` `    ``{ ` `        ``factor = 1; ` ` `  `        ``// Initializes all the positions ` `        ``// with their value. ` `        ``for` `(``int` `i = 2; i < MAX; i++) ` `            ``factor[i] = i; ` ` `  `        ``// Initializes all multiples of 2 with 2 ` `        ``for` `(``int` `i = 4; i < MAX; i += 2) ` `            ``factor[i] = 2; ` ` `  `        ``// A modified version of Sieve of ` `        ``// Eratosthenes to store the smallest ` `        ``// prime factor that divides every number. ` `        ``for` `(``int` `i = 3; i * i < MAX; i++) { ` ` `  `            ``// check if it has no prime factor. ` `            ``if` `(factor[i] == i) { ` ` `  `                ``// Initializes of j starting from i*i ` `                ``for` `(``int` `j = i * i; j < MAX; j += i) ` `                ``{ ` ` `  `                    ``// if it has no prime factor ` `                    ``// before, then stores the ` `                    ``// smallest prime divisor ` `                    ``if` `(factor[j] == j) ` `                        ``factor[j] = i; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// function to calculate number of factors ` `    ``public` `static` `int` `calculateNoOFactors(``int` `n) ` `    ``{ ` `        ``if` `(n == 1) ` `            ``return` `1; ` ` `  `        ``int` `ans = 1; ` ` `  `        ``// stores the smallest prime number ` `        ``// that divides n ` `        ``int` `dup = factor[n]; ` ` `  `        ``// stores the count of number of times ` `        ``// a prime number divides n. ` `        ``int` `c = 1; ` ` `  `        ``// reduces to the next number after prime ` `        ``// factorization of n ` `        ``int` `j = n / factor[n]; ` ` `  `        ``// false when prime factorization is done ` `        ``while` `(j != 1) { ` ` `  `            ``// if the same prime number is dividing n, ` `            ``// then we increase the count ` `            ``if` `(factor[j] == dup) ` `                ``c += 1; ` ` `  `            ``// if its a new prime factor that is ` `            ``// factorizing n, then we again set c=1  ` `            ``// and change dup to the new prime factor, ` `            ``// and apply the formula explained above. ` `            ``else` `{ ` `                ``dup = factor[j]; ` `                ``ans = ans * (c + 1); ` `                ``c = 1; ` `            ``} ` ` `  `            ``// prime factorizes a number ` `            ``j = j / factor[j]; ` `        ``} ` ` `  `        ``// for the last prime factor ` `        ``ans = ans * (c + 1); ` ` `  `        ``return` `ans;  ` `    ``} ` ` `  `    ``// function to find the smallest integer ` `    ``// with n factors or more. ` `    ``public` `static` `int` `smallest(``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = 1; ; i++) ` ` `  `            ``// check if no of factors is more ` `            ``// than n or not ` `            ``if` `(calculateNoOFactors(i) >= n) ` `                ``return` `i; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `         `  `        ``// generate prime factors of  ` `        ``// number upto 10^6 ` `        ``generatePrimeFactors(); ` ` `  `        ``int` `n = 4; ` `        ``Console.Write(smallest(n)); ` `    ``} ` `} ` ` `  `// This code is contributed by Nitin Mittal. `

## PHP

 `= ``\$n``) ` `            ``return` `\$i``; ` `} ` ` `  `// Driver Code ` ` `  `// generate prime factors  ` `// of number upto 10^6 ` `generatePrimeFactors(); ` ` `  `\$n` `= 4; ` `echo` `smallest(``\$n``); ` ` `  `// This code is contributed by mits ` `?> `

Output:

```6
```

Time Complexity: O(log(max(number))) for every computing number we check before getting the answer.

My Personal Notes arrow_drop_up Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : nitin mittal, Mithun Kumar

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.