# Count numbers up to N that can be expressed as powers of Prime Numbers

• Last Updated : 26 May, 2022

Given an integer N, the task is to count numbers from the range [1, N] which are the power of prime numbers.

Examples:

Input: N = 6
Output: 3
Explanation:
Numbers from the range [1, 6] that can be expressed as powers of prime numbers are:
2 = 21
3 = 31
4 = 22
5 = 51

Input: N = 9
Output: 7
Explanation:
Numbers from the range [1, 9] that can be expressed as powers of prime numbers are:
2 = 21
3 = 31
4 = 22
5 = 51
7 = 71
8 = 23
9 = 32

Approach: The problem can be solved using Sieve of Eratosthenes.

1. Initialize an array prime[] of length N+1 using Sieve of Eratosthenes, in which prime[i] = 1 means i is a prime number and prime[i] = 0 means i is not a prime number.
2. Push all the prime numbers into a vector, say v.
3. Initialize a variable, say ans,  to store the count of the powers of primes.
4. For each prime, say p in vector v, perform the following operations:
• Initialize a variable, say temp, equal to p.
• Check if the temp is less than N. If found to be true, then perform the following operations:
• Increase ans by 1.
• Update temp = temp * p, the next power of p.
5. Return the final count as ans.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to count the number` `// of powers of prime numbers upto N` `int` `countPowerOfPrimes(``int` `N)` `{`   `    ``// Sieve array` `    ``int` `prime[N + 1];`   `    ``// Sieve of Eratosthenes`   `    ``// Initialize all numbers as prime` `    ``for` `(``int` `i = 0; i <= N; i++)` `        ``prime[i] = 1;`   `    ``// Mark 0 and 1 as non prime` `    ``prime = 0;` `    ``prime = 0;`   `    ``for` `(``int` `i = 2; i * i <= N; i++) {` `        ``// If a prime number is found` `        ``if` `(prime[i] == 1) {` `            ``// Mark all multiples` `            ``// of i as non-prime` `            ``for` `(``int` `j = i * i;` `                 ``j <= N; j += i) {` `                ``prime[j] = 0;` `            ``}` `        ``}` `    ``}`   `    ``// Stores all prime` `    ``// numbers upto N` `    ``vector<``int``> v;`   `    ``// Push all the primes into v` `    ``for` `(``int` `i = 2; i <= N; i++) {` `        ``if` `(prime[i] == 1) {` `            ``v.push_back(i);` `        ``}` `    ``}`   `    ``// Stores the count of` `    ``// powers of primes up to N` `    ``int` `ans = 0;`   `    ``// Iterator over every` `    ``// prime number up to N` `    ``for` `(``auto` `p : v) {` `        ``// Store p in temp` `        ``int` `temp = p;`   `        ``// Iterate until temp exceeds n` `        ``while` `(temp <= N) {` `            ``// Increment ans by 1` `            ``ans = ans + 1;`   `            ``// Update temp to` `            ``// next power of p` `            ``temp = temp * p;` `        ``}` `    ``}`   `    ``// Return ans as the final answer` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given Input` `    ``int` `n = 9;`   `    ``// Function call to count` `    ``// the number of power of` `    ``// primes in the range [1, N]` `    ``cout << countPowerOfPrimes(n);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `class` `GFG{` `    `  `// Function to count the number` `// of powers of prime numbers upto N` `static` `int` `countPowerOfPrimes(``int` `N)` `{` `    `  `    ``// Sieve array` `    ``int` `prime[] = ``new` `int``[N + ``1``];`   `    ``// Sieve of Eratosthenes`   `    ``// Initialize all numbers as prime` `    ``for``(``int` `i = ``0``; i <= N; i++)` `        ``prime[i] = ``1``;`   `    ``// Mark 0 and 1 as non prime` `    ``prime[``0``] = ``0``;` `    ``prime[``1``] = ``0``;`   `    ``for``(``int` `i = ``2``; i * i <= N; i++)` `    ``{` `        `  `        ``// If a prime number is found` `        ``if` `(prime[i] == ``1``)` `        ``{` `            `  `            ``// Mark all multiples` `            ``// of i as non-prime` `            ``for``(``int` `j = i * i; ` `                    ``j < N + ``1``; ` `                    ``j += i)` `            ``{` `                ``prime[j] = ``0``;` `            ``}` `        ``}` `    ``}` `    `  `    ``// Stores all prime` `    ``// numbers upto N` `    ``int` `v[] = ``new` `int``[N + ``1``];` `    ``int` `j = ``0``;`   `    ``// Push all the primes into v` `    ``for``(``int` `i = ``2``; i < N + ``1``; i++)` `    ``{` `        ``if` `(prime[i] == ``1``)` `        ``{` `            ``v[j] = i;` `            ``j += ``1``;` `        ``}` `    ``}` `    `  `    ``// Stores the count of` `    ``// powers of primes up to N` `    ``int` `ans = ``0``;`   `    ``// Iterator over every` `    ``// prime number up to N` `    ``for``(``int` `k = ``0``; k < j; k++)` `    ``{` `        `  `        ``// Store v[k] in temp` `        ``int` `temp = v[k];`   `        ``// Iterate until temp exceeds n` `        ``while` `(temp <= N) ` `        ``{` `            `  `            ``// Increment ans by 1` `            ``ans = ans + ``1``;`   `            ``// Update temp to` `            ``// next power of v[k]` `            ``temp = temp * v[k];` `        ``}` `    ``}`   `    ``// Return ans as the final answer` `    ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args) ` `{` `    ``int` `n = ``9``;` `    `  `    ``// Function call to count` `    ``// the number of power of` `    ``// primes in the range [1, N]` `    ``System.out.println(countPowerOfPrimes(n));` `}` `}`   `// This code is contributed by AnkThon`

## Python3

 `# Python3 program for the above approach`   `# Function to count the number` `# of powers of prime numbers upto N` `def` `countPowerOfPrimes(N):`   `    ``# Sieve array` `    ``prime ``=` `[``1``] ``*` `(N ``+` `1``)`   `    ``# Mark 0 and 1 as non prime` `    ``prime[``0``] ``=` `0` `    ``prime[``1``] ``=` `0`   `    ``for` `i ``in` `range``(``2``, N ``+` `1``):` `        ``if` `i ``*` `i > N:` `            ``break` `        `  `        ``# If a prime number is found` `        ``if` `(prime[i] ``=``=` `1``):` `            `  `            ``# Mark all multiples` `            ``# of i as non-prime` `            ``for` `j ``in` `range``(i ``*` `i, N ``+` `1``, i):` `                ``prime[j] ``=` `0`   `    ``# Stores all prime` `    ``# numbers upto N` `    ``v ``=` `[]`   `    ``# Push all the primes into v` `    ``for` `i ``in` `range``(``2``, N ``+` `1``):` `        ``if` `(prime[i] ``=``=` `1``):` `            ``v.append(i)`   `    ``# Stores the count of` `    ``# powers of primes up to N` `    ``ans ``=` `0`   `    ``# Iterator over every` `    ``# prime number up to N` `    ``for` `p ``in` `v:` `        `  `        ``# Store p in temp` `        ``temp ``=` `p`   `        ``# Iterate until temp exceeds n` `        ``while` `(temp <``=` `N):` `            `  `            ``# Increment ans by 1` `            ``ans ``=` `ans ``+` `1`   `            ``# Update temp to` `            ``# next power of p` `            ``temp ``=` `temp ``*` `p`   `    ``# Return ans as the final answer` `    ``return` `ans`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given Input` `    ``n ``=` `9`   `    ``# Function call to count` `    ``# the number of power of` `    ``# primes in the range [1, N]` `    ``print` `(countPowerOfPrimes(n))`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Function to count the number` `// of powers of prime numbers upto N` `static` `int` `countPowerOfPrimes(``int` `N)` `{` `    `  `    ``// Sieve array` `    ``int``[] prime = ``new` `int``[N + 1];` `    ``int` `j;`   `    ``// Sieve of Eratosthenes`   `    ``// Initialize all numbers as prime` `    ``for``(``int` `i = 0; i <= N; i++)` `        ``prime[i] = 1;`   `    ``// Mark 0 and 1 as non prime` `    ``prime = 0;` `    ``prime = 0;`   `    ``for``(``int` `i = 2; i * i <= N; i++)` `    ``{` `        `  `        ``// If a prime number is found` `        ``if` `(prime[i] == 1)` `        ``{` `            `  `            ``// Mark all multiples` `            ``// of i as non-prime` `            ``for``(j = i * i; ` `                ``j < N + 1; ` `                ``j += i)` `            ``{` `                ``prime[j] = 0;` `            ``}` `        ``}` `    ``}` `    `  `    ``// Stores all prime` `    ``// numbers upto N` `    ``int``[] v = ``new` `int``[N + 1];` `    ``j = 0;`   `    ``// Push all the primes into v` `    ``for``(``int` `i = 2; i < N + 1; i++)` `    ``{` `        ``if` `(prime[i] == 1)` `        ``{` `            ``v[j] = i;` `            ``j += 1;` `        ``}` `    ``}` `    `  `    ``// Stores the count of` `    ``// powers of primes up to N` `    ``int` `ans = 0;`   `    ``// Iterator over every` `    ``// prime number up to N` `    ``for``(``int` `k = 0; k < j; k++)` `    ``{` `        `  `        ``// Store v[k] in temp` `        ``int` `temp = v[k];`   `        ``// Iterate until temp exceeds n` `        ``while` `(temp <= N) ` `        ``{` `            `  `            ``// Increment ans by 1` `            ``ans = ans + 1;`   `            ``// Update temp to` `            ``// next power of v[k]` `            ``temp = temp * v[k];` `        ``}` `    ``}`   `    ``// Return ans as the final answer` `    ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `Main(``string``[] args)` `{` `    ``int` `n = 9;` `    `  `    ``// Function call to count` `    ``// the number of power of` `    ``// primes in the range [1, N]` `    ``Console.Write(countPowerOfPrimes(n));` `}` `}`   `// This code is contributed by sanjoy_62`

## Javascript

 ``

Output:

`7`

Time Complexity: O(N log (log N))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :