# Count integers up to N that are equal to at least 2nd power of any integer exceeding 1

• Last Updated : 25 May, 2021

Given a positive integer N, the task is to count the number of integers from the range [1, N], that can be represented as ab, where a and b are integers greater than 1.

Examples:

Input: N = 6
Output: 1
Explanation:
Only such integer from the range [1, 6] is 4 (= 22).
Therefore, the required count is 1.

Input: N = 10
Output: 3

Approach: The given problem can be solved by counting all the possible pairs of elements (a, b) such that ab is at most N. Follow the steps below to solve the problem:

• Initialize a HashSet to store all possible values of ab which is at most N.
• Iterate over the range [2, √N], and for each value of a, insert all possible values of ab having value at most N, where b lies over the range [1, N].
• After completing the above steps, print the size of the HashSet as the resultant count of integers.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count the integers``// up to N that can be represented``// as a ^ b, where a &b > 1``void` `printNumberOfPairs(``int` `N)``{``    ` `    ``// Initialize a HashSet``    ``unordered_set<``int``> st;` `    ``// Iterating over the range``    ``// [2, sqrt(N)]``    ``for``(``int` `i = 2; i * i <= N; i++)``    ``{``        ``int` `x = i;` `        ``// Generate all possible``        ``// power of x``        ``while` `(x <= N)``        ``{``            ` `            ``// Multiply x by i``            ``x *= i;` `            ``// If the generated number``            ``// lies in the range [1, N]``            ``// then insert it in HashSet``            ``if` `(x <= N)``            ``{``                ``st.insert(x);``            ``}``        ``}``    ``}` `    ``// Print the total count``    ``cout << st.size();``}` `// Driver code``int` `main()``{``    ``int` `N = 10000;``    ``printNumberOfPairs(N);` `    ``return` `0;``}` `// This code is contributed by Kingash`

## Java

 `// Java program for the above approach` `import` `java.util.HashSet;` `public` `class` `GFG {` `    ``// Function to count the integers``    ``// up to N that can be represented``    ``// as a ^ b, where a &b > 1``    ``static` `void` `printNumberOfPairs(``int` `N)``    ``{``        ``// Initialize a HashSet``        ``HashSet st``            ``= ``new` `HashSet();` `        ``// Iterating over the range``        ``// [2, sqrt(N)]``        ``for` `(``int` `i = ``2``; i * i <= N; i++) {` `            ``int` `x = i;` `            ``// Generate all possible``            ``// power of x``            ``while` `(x <= N) {` `                ``// Multiply x by i``                ``x *= i;` `                ``// If the generated number``                ``// lies in the range [1, N]``                ``// then insert it in HashSet``                ``if` `(x <= N) {``                    ``st.add(x);``                ``}``            ``}``        ``}` `        ``// Print the total count``        ``System.out.println(st.size());``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `N = ``10000``;``        ``printNumberOfPairs(N);``    ``}``}`

## Python3

 `# Python 3 program for the above approach``from` `math ``import` `sqrt` `# Function to count the integers``# up to N that can be represented``# as a ^ b, where a &b > 1``def` `printNumberOfPairs(N):``  ` `    ``# Initialize a HashSet``    ``st ``=` `set``()` `    ``# Iterating over the range``    ``# [2, sqrt(N)]``    ``for` `i ``in` `range``(``2``, ``int``(sqrt(N)) ``+` `1``, ``1``):``        ``x ``=` `i``        ` `        ``# Generate all possible``        ``# power of x``        ``while``(x <``=` `N):``          ` `            ``# Multiply x by i``            ``x ``*``=` `i``            ` `            ``# If the generated number``            ``# lies in the range [1, N]``            ``# then insert it in HashSet``            ``if` `(x <``=` `N):``                ``st.add(x)` `    ``# Print the total count``    ``print``(``len``(st))` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``N ``=` `10000``    ``printNumberOfPairs(N)``    ` `    ``# This code is contributed by ipg2016107.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to count the integers``// up to N that can be represented``// as a ^ b, where a &b > 1``static` `void` `printNumberOfPairs(``int` `N)``{``    ` `    ``// Initialize a HashSet``    ``HashSet<``int``> st = ``new` `HashSet<``int``>();` `    ``// Iterating over the range``    ``// [2, sqrt(N)]``    ``for``(``int` `i = 2; i * i <= N; i++)``    ``{``        ``int` `x = i;` `        ``// Generate all possible``        ``// power of x``        ``while` `(x <= N)``        ``{``            ` `            ``// Multiply x by i``            ``x *= i;` `            ``// If the generated number``            ``// lies in the range [1, N]``            ``// then insert it in HashSet``            ``if` `(x <= N)``            ``{``                ``st.Add(x);``            ``}``        ``}``    ``}` `    ``// Print the total count``    ``Console.WriteLine(st.Count);``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``int` `N = 10000;``    ``printNumberOfPairs(N);``}``}` `// This code is contributed by ukasp`

## Javascript

 ``

Output:

`124`

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

My Personal Notes arrow_drop_up