# Count all the numbers less than 10^6 whose minimum prime factor is N

• Difficulty Level : Expert
• Last Updated : 19 Nov, 2021

Given a number N which is prime. The task is to find all the numbers less than or equal to 10^6 whose minimum prime factor is N.
Examples:

```Input: N = 2
Output: 500000

Input: N = 3
Output: 166667```

Approach: Use sieve of Eratosthenes to find the solution to the problem. Store all the prime numbers less than 10^6 . Form another sieve that will store the count of all the numbers whose minimum prime factor is the index of the sieve. Then display the count of the prime number N (i.e. sieve_count[n]+1), where n is the prime number.
Below is the implementation of above approach:

## C++

 `// C++ implementation of above approach``#include ``using` `namespace` `std;``#define MAX 1000000` `// the sieve of prime number and``// count of minimum prime factor``int` `sieve_Prime[MAX + 4] = { 0 },``                      ``sieve_count[MAX + 4] = { 0 };` `// form the prime sieve``void` `form_sieve()``{``    ``// 1 is not a prime number``    ``sieve_Prime = 1;` `    ``// form the sieve``    ``for` `(``int` `i = 2; i <= MAX; i++) {` `        ``// if i is prime``        ``if` `(sieve_Prime[i] == 0) {``            ``for` `(``int` `j = i * 2; j <= MAX; j += i) {` `                ``// if i is the least prime factor``                ``if` `(sieve_Prime[j] == 0) {` `                    ``// mark the number j as non prime``                    ``sieve_Prime[j] = 1;` `                    ``// count the numbers whose least prime factor is i``                    ``sieve_count[i]++;``                ``}``            ``}``        ``}``    ``}``}` `// Driver code``int` `main()``{``    ``// form the sieve``    ``form_sieve();` `    ``int` `n = 2;` `    ``// display``    ``cout << ``"Count = "` `<< (sieve_count[n] + 1) << endl;` `    ``n = 3;` `    ``// display``    ``cout << ``"Count = "` `<< (sieve_count[n] + 1) << endl;` `    ``return` `0;``}`

## Java

 `// Java implementation of above approach``import` `java.io.*;` `class` `GFG {``    ` `static` `int` `MAX = ``1000000``;` `// the sieve of prime number and``// count of minimum prime factor``static` `int` `sieve_Prime[] = ``new` `int``[MAX + ``4``];``static` `int` `sieve_count[] =  ``new` `int``[MAX + ``4``];` `// form the prime sieve``static` `void` `form_sieve()``{``    ``// 1 is not a prime number``    ``sieve_Prime[``1``] = ``1``;` `    ``// form the sieve``    ``for` `(``int` `i = ``2``; i <= MAX; i++) {` `        ``// if i is prime``        ``if` `(sieve_Prime[i] == ``0``) {``            ``for` `(``int` `j = i * ``2``; j <= MAX; j += i) {` `                ``// if i is the least prime factor``                ``if` `(sieve_Prime[j] == ``0``) {` `                    ``// mark the number j as non prime``                    ``sieve_Prime[j] = ``1``;` `                    ``// count the numbers whose least prime factor is i``                    ``sieve_count[i]++;``                ``}``            ``}``        ``}``    ``}``}` `// Driver code` `    ``public` `static` `void` `main (String[] args) {``        ``// form the sieve``    ``form_sieve();` `    ``int` `n = ``2``;` `    ``// display``    ``System.out.println( ``"Count = "` `+ (sieve_count[n] + ``1``));` `    ``n = ``3``;` `    ``// display``    ``System.out.println (``"Count = "`  `+(sieve_count[n] + ``1``));``    ``}``}``// This code was contributed``// by inder_mca`

## Python3

 `# Python3 implementation of``# above approach` `MAX` `=` `1000000` `# the sieve of prime number and``# count of minimum prime factor``sieve_Prime ``=` `[``0` `for` `i ``in` `range``(``MAX` `+` `4``)]``sieve_count ``=` `[``0` `for` `i ``in` `range``(``MAX` `+` `4``)]` `# form the prime sieve``def` `form_sieve():``    ` `    ``# 1 is not a prime number``    ``sieve_Prime[``1``] ``=` `1` `    ``# form the sieve``    ``for` `i ``in` `range``(``2``, ``MAX` `+` `1``):` `        ``# if i is prime``        ``if` `sieve_Prime[i] ``=``=` `0``:``            ``for` `j ``in` `range``(i ``*` `2``, ``MAX` `+` `1``, i):` `                ``# if i is the least prime factor``                ``if` `sieve_Prime[j] ``=``=` `0``:` `                    ``# mark the number j``                    ``# as non prime``                    ``sieve_Prime[j] ``=` `1` `                    ``# count the numbers whose``                    ``# least prime factor is i``                    ``sieve_count[i] ``+``=` `1` `# Driver code` `# form the sieve``form_sieve()` `n ``=` `2` `# display``print``(``"Count ="``, sieve_count[n] ``+` `1``)` `n ``=` `3` `# display``print``(``"Count ="``, sieve_count[n] ``+` `1``)` `# This code was contributed``# by VishalBachchas`

## C#

 `// C# implementation of above approach``using` `System;` `class` `GFG {``    ` `static` `int` `MAX = 1000000;` `// the sieve of prime number and``// count of minimum prime factor``static` `int` `[]sieve_Prime = ``new` `int``[MAX + 4];``static` `int` `[]sieve_count = ``new` `int``[MAX + 4];` `// form the prime sieve``static` `void` `form_sieve()``{``    ``// 1 is not a prime number``    ``sieve_Prime = 1;` `    ``// form the sieve``    ``for` `(``int` `i = 2; i <= MAX; i++) {` `        ``// if i is prime``        ``if` `(sieve_Prime[i] == 0) {``            ``for` `(``int` `j = i * 2; j <= MAX; j += i) {` `                ``// if i is the least prime factor``                ``if` `(sieve_Prime[j] == 0) {` `                    ``// mark the number j as non prime``                    ``sieve_Prime[j] = 1;` `                    ``// count the numbers whose least prime factor is i``                    ``sieve_count[i]++;``                ``}``            ``}``        ``}``    ``}``}` `// Driver code` `    ``public` `static` `void` `Main () {``        ``// form the sieve``    ``form_sieve();` `    ``int` `n = 2;` `    ``// display``    ``Console.WriteLine( ``"Count = "` `+ (sieve_count[n] + 1));` `    ``n = 3;` `    ``// display``    ``Console.WriteLine (``"Count = "` `+(sieve_count[n] + 1));``    ``}``}``// This code was contributed``// by shs`

## PHP

 ``

## Javascript

 ``

Output

```Count = 500000
Count = 166667```

Time Complexity: O(N*log(log(N))), where N=106.

Auxiliary Space: O(106)

My Personal Notes arrow_drop_up