# Find Nth smallest number having exactly 4 divisors

• Last Updated : 21 Jul, 2021

Given a positive integer N, the task is to find the Nth smallest number in the sequence which is having exactly 4 divisors.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

Input: 4
Output: 14
Explanation: The numbers in the sequence that has 4 divisors are 6, 8, 10, 14, …, the fourth number in the sequence is 14.

Input: 24
Output: 94

Approach: This problem can be solved by observing that the number i having a prime factorization of p1a1 * p2a2 * p3a3…pkak, then the number of divisors of i is (a1+1)(a2+1)…(ak+1). So for i to have exactly 4 divisors, it should be equal to the product of two distinct primes or some prime number raised to the power 3. Follow the steps below to solve the problem:

• Initialize arrays divs[] and vis[] to store the number of divisors of any number and to check if given number is considered or not respectively.
• Initialize a variable cnt as 0 to store number of elements having exactly 4 divisors.
• Now, use the sieve of Eratosthenes algorithm.
• Iterate while cnt is less than n, using a variable i start from 2:
• If i is prime:
• Iterate in the range [2*i, 1000000] using the variable j with increment of i:
• If the number j is already considered, then continue.
• Update vis[j] as true and initialize variables currNum as j and count as 0.
• Divide the currNum by i while currNum % i is equal to 0, increment div[j] and count by 1.
• If currNum is equal to 1, count is equal to 3 and divs[j] is equal to 3, then increment cnt by 1.
• Otherwise, if currNum is not equal to 1, count is equal to 1, divs[j] is equal to 1 and divs[currNum] is equal to 0, then increment cnt by 1.
• If cnt is equal to N, then print j and return.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the nth number which``// has exactly 4 divisors``int` `nthNumber(``int` `n)``{` `    ``// The divs[] array to store number of``    ``// divisors of every element``    ``int` `divs;` `    ``// The vis[] array to check if given number``    ``// is considered or not``    ``bool` `vis;` `    ``// The cnt stores number of elements having``    ``// exactly 4 divisors``    ``int` `cnt = 0;` `    ``// Iterate while cnt less than n``    ``for` `(``int` `i = 2; cnt < n; i++) {` `        ``// If i is a prime``        ``if` `(divs[i] == 0) {` `            ``// Iterate in the range [2*i, 1000000] with``            ``// increment of i``            ``for` `(``int` `j = 2 * i; j < 1000000; j += i) {` `                ``// If the number j is already considered``                ``if` `(vis[j]) {``                    ``continue``;``                ``}` `                ``vis[j] = 1;` `                ``int` `currNum = j;``                ``int` `count = 0;` `                ``// Dividing currNum by i until currNum % i is``                ``// equal to 0``                ``while` `(currNum % i == 0) {``                    ``divs[j]++;``                    ``currNum = currNum / i;``                    ``count++;``                ``}` `                ``// Case a single prime in its factorization``                ``if` `(currNum == 1 && count == 3 && divs[j] == 3) {``                    ``cnt++;``                ``}` `                ``else` `if` `(currNum != 1``                         ``&& divs[currNum] == 0``                         ``&& count == 1``                         ``&& divs[j] == 1) {``                    ``// Case of two distinct primes which``                    ``// divides j exactly once each``                    ``cnt++;``                ``}` `                ``if` `(cnt == n) {``                    ``return` `j;``                ``}``            ``}``        ``}``    ``}` `    ``return` `-1;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `N = 24;` `    ``// Function Call``    ``cout << nthNumber(N) << endl;``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG {` `    ``// Function to find the nth number which``    ``// has exactly 4 divisors``    ``static` `int` `nthNumber(``int` `n)``    ``{` `        ``// The divs[] array to store number of``        ``// divisors of every element``        ``int` `divs[] = ``new` `int``[``1000000``];` `        ``// The vis[] array to check if given number``        ``// is considered or not``        ``boolean` `vis[] = ``new` `boolean``[``1000000``];` `        ``// The cnt stores number of elements having``        ``// exactly 4 divisors``        ``int` `cnt = ``0``;` `        ``// Iterate while cnt less than n``        ``for` `(``int` `i = ``2``; cnt < n; i++) {` `            ``// If i is a prime``            ``if` `(divs[i] == ``0``) {` `                ``// Iterate in the range [2*i, 1000000] with``                ``// increment of i``                ``for` `(``int` `j = ``2` `* i; j < ``1000000``; j += i) {` `                    ``// If the number j is already considered``                    ``if` `(vis[j]) {``                        ``continue``;``                    ``}` `                    ``vis[j] = ``true``;` `                    ``int` `currNum = j;``                    ``int` `count = ``0``;` `                    ``// Dividing currNum by i until currNum %``                    ``// i is equal to 0``                    ``while` `(currNum % i == ``0``) {``                        ``divs[j]++;``                        ``currNum = currNum / i;``                        ``count++;``                    ``}` `                    ``// Case a single prime in its``                    ``// factorization``                    ``if` `(currNum == ``1` `&& count == ``3``                        ``&& divs[j] == ``3``) {``                        ``cnt++;``                    ``}` `                    ``else` `if` `(currNum != ``1``                             ``&& divs[currNum] == ``0``                             ``&& count == ``1``                             ``&& divs[j] == ``1``) {``                        ``// Case of two distinct primes which``                        ``// divides j exactly once each``                        ``cnt++;``                    ``}` `                    ``if` `(cnt == n) {``                        ``return` `j;``                    ``}``                ``}``            ``}``        ``}` `        ``return` `-``1``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given Input``        ``int` `N = ``24``;` `        ``// Function Call``        ``System.out.println(nthNumber(N));``    ``}``}` `// This code is contributed by Potta Lokesh`

## Python3

 `# Python program for the above approach` `# Function to find the nth number which``# has exactly 4 divisors``def` `nthNumber(n):` `    ``# The divs[] array to store number of``    ``# divisors of every element``    ``divs ``=` `[``0` `for` `i ``in` `range``(``1000000``)];` `    ``# The vis[] array to check if given number``    ``# is considered or not``    ``vis ``=` `[``0` `for` `i ``in` `range``(``1000000``)];` `    ``# The cnt stores number of elements having``    ``# exactly 4 divisors``    ``cnt ``=` `0``;` `    ``# Iterate while cnt less than n``    ``for` `i ``in` `range``(``2``, n):` `        ``# If i is a prime``        ``if` `(divs[i] ``=``=` `0``):` `            ``# Iterate in the range [2*i, 1000000] with``            ``# increment of i``            ``for` `j ``in` `range``(``2` `*` `i, ``1000000``):` `                ``# If the number j is already considered``                ``if` `(vis[j]):``                    ``continue``;` `                ``vis[j] ``=` `1``;` `                ``currNum ``=` `j;``                ``count ``=` `0``;` `                ``# Dividing currNum by i until currNum % i is``                ``# equal to 0``                ``while` `(currNum ``%` `i ``=``=` `0``):``                    ``divs[j] ``+``=` `1``;``                    ``currNum ``=` `currNum ``/``/` `i;``                    ``count ``+``=` `1``;``    ` `                ``# Case a single prime in its factorization``                ``if` `(currNum ``=``=` `1` `and` `count ``=``=` `3` `and` `divs[j] ``=``=` `3``):``                    ``cnt ``+``=` `1``                ``elif` `(currNum !``=` `1``                    ``and` `divs[currNum] ``=``=` `0``                    ``and` `count ``=``=` `1``                    ``and` `divs[j] ``=``=` `1``):``                ` `                    ``# Case of two distinct primes which``                    ``# divides j exactly once each``                    ``cnt ``+``=` `1` `                ``if` `(cnt ``=``=` `n):``                    ``return` `j;` `    ``return` `-``1``;` `# Driver Code` `# Given Input``N ``=` `24``;` `# Function Call``print``(nthNumber(N));` `# This code is contributed by gfgking.`

## C#

 `// C# program for the above approach``using` `System;` `// Function to find minimum number of``// elements required to obtain sum K``class` `GFG{` `// Function to find the nth number which``// has exactly 4 divisors``static` `int` `nthNumber(``int` `n)``{``    ` `    ``// The divs[] array to store number of``    ``// divisors of every element``    ``int``[] divs = ``new` `int``;` `    ``// The vis[] array to check if given number``    ``// is considered or not``    ``int``[] vis  = ``new` `int``;` `    ``// The cnt stores number of elements having``    ``// exactly 4 divisors``    ``int` `cnt = 0;` `    ``// Iterate while cnt less than n``    ``for``(``int` `i = 2; cnt < n; i++)``    ``{``        ` `        ``// If i is a prime``        ``if` `(divs[i] == 0)``        ``{``            ` `            ``// Iterate in the range [2*i, 1000000] with``            ``// increment of i``            ``for``(``int` `j = 2 * i; j < 1000000; j += i)``            ``{``                ` `                ``// If the number j is already considered``                ``if` `(vis[j] != 0)``                ``{``                    ``continue``;``                ``}` `                ``vis[j] = 1;` `                ``int` `currNum = j;``                ``int` `count = 0;` `                ``// Dividing currNum by i until currNum % i is``                ``// equal to 0``                ``while` `(currNum % i == 0)``                ``{``                    ``divs[j]++;``                    ``currNum = currNum / i;``                    ``count++;``                ``}` `                ``// Case a single prime in its factorization``                ``if` `(currNum == 1 && count == 3 && divs[j] == 3)``                ``{``                    ``cnt++;``                ``}` `                ``else` `if` `(currNum != 1 && divs[currNum] == 0 &&``                           ``count == 1 && divs[j] == 1)``                ``{``                    ` `                    ``// Case of two distinct primes which``                    ``// divides j exactly once each``                    ``cnt++;``                ``}` `                ``if` `(cnt == n)``                ``{``                    ``return` `j;``                ``}``            ``}``        ``}``    ``}``    ``return` `-1;``}` `// Driver Code``static` `public` `void` `Main ()``{``    ` `    ``// Given Input``    ``int` `N = 24;` `    ``// Function Call``    ``Console.Write(nthNumber(N));``}``}` `// This code is contributed by sanjoy_62`

## Javascript

 ``
Output
`94`

Time Complexity: O(Nlog(log(N))), where N is 1000000.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up