# Count of pairs upto N such whose LCM is not equal to their product for Q queries

Given a number N, the task is to find the number of pairs (a, b) in the range [1, N] such that their LCM is not equal to their product, i.e. LCM(a, b) != (a*b) and (b > a). There can be multiple queries to answer.

Examples:

Input: Q[] = {5}
Output: 1
Explanation:
The pair from 1 to 5 is (2, 4)

Input: Q[] = {5, 7}
Output: 1, 4
Explanation:
The pair from 1 to 5 is (2, 4)
The pairs from 1 to 7 are (2, 4), (2, 6), (3, 6), (4, 6)

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

Approach: The idea is to use the Euler’s Totient Function.

1. Find the total number of pairs that can be formed using numbers from 1 to N. The number of pairs formed are equal to ( N * (N – 1) ) / 2.
2. For each integer i ≤ N, using Euler's Totient Function find all such pairs which are co-prime with i and store it in array.
Example:

```arr = 10 * (1-1/2) * (1-1/5)
= 4
```
3. Now build the prefix sum table which stores the sum of all phi(i) for all i between 1 to N. Using this, we can answer each query in O(1) time.
4. Finally the answer for any i ≤ N is given by the difference between the total number of pairs formed and pref[i].

Below is the implementation of the given approach:

## C++

 `// C++ program to find the count of pairs ` `// from 1 to N such that their LCM ` `// is not equal to their product ` `#include ` `using` `namespace` `std; ` ` `  `#define N 100005 ` ` `  `// To store Euler's Totient Function ` `int` `phi[N]; ` ` `  `// To store prefix sum table ` `int` `pref[N]; ` ` `  `// Compute Totients of all numbers ` `// smaller than or equal to N ` `void` `precompute() ` `{ ` `    ``// Make phi=0 since 1 cannot form any pair ` `    ``phi = 0; ` ` `  `    ``// Initialise all remaining phi[] with i ` `    ``for` `(``int` `i = 2; i < N; i++) ` `        ``phi[i] = i; ` ` `  `    ``// Compute remaining phi ` `    ``for` `(``int` `p = 2; p < N; p++) { ` ` `  `        ``// If phi[p] is not computed already, ` `        ``// then number p is prime ` `        ``if` `(phi[p] == p) { ` ` `  `            ``// phi of prime number is p-1 ` `            ``phi[p] = p - 1; ` ` `  `            ``// Update phi of all multiples of p ` `            ``for` `(``int` `i = 2 * p; i < N; i += p) { ` ` `  `                ``// Add the contribution of p ` `                ``// to its multiple i by multiplying ` `                ``// it with (1 - 1/p) ` `                ``phi[i] = (phi[i] / p) * (p - 1); ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Function to store prefix sum table ` `void` `prefix() ` `{ ` `    ``// Prefix Sum of all Euler's Totient Values ` `    ``for` `(``int` `i = 1; i < N; i++) ` `        ``pref[i] = pref[i - 1] + phi[i]; ` `} ` ` `  `void` `find_pairs(``int` `n) ` `{ ` ` `  `    ``// Total number of pairs that can be formed ` `    ``int` `total = (n * (n - 1)) / 2; ` ` `  `    ``int` `ans = total - pref[n]; ` ` `  `    ``cout << ``"Number of pairs from 1 to "` `         ``<< n << ``" are "` `<< ans << endl; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` ` `  `    ``// Function call to compute all phi ` `    ``precompute(); ` ` `  `    ``// Function call to store all prefix sum ` `    ``prefix(); ` ` `  `    ``int` `q[] = { 5, 7 }; ` `    ``int` `n = ``sizeof``(q) / ``sizeof``(q); ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``find_pairs(q[i]); ` `    ``} ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find the count of pairs ` `// from 1 to N such that their LCM ` `// is not equal to their product ` ` `  `class` `GFG{ ` ` `  `static` `final` `int` `N = ``100005``; ` ` `  `// To store Euler's Totient Function ` `static` `int` `[]phi = ``new` `int``[N]; ` ` `  `// To store prefix sum table ` `static` `int` `[]pref = ``new` `int``[N]; ` ` `  `// Compute Totients of all numbers ` `// smaller than or equal to N ` `static` `void` `precompute() ` `{ ` `    ``// Make phi = 0 since 1 cannot form any pair ` `    ``phi[``1``] = ``0``; ` ` `  `    ``// Initialise all remaining phi[] with i ` `    ``for` `(``int` `i = ``2``; i < N; i++) ` `        ``phi[i] = i; ` ` `  `    ``// Compute remaining phi ` `    ``for` `(``int` `p = ``2``; p < N; p++) { ` ` `  `        ``// If phi[p] is not computed already, ` `        ``// then number p is prime ` `        ``if` `(phi[p] == p) { ` ` `  `            ``// phi of prime number is p-1 ` `            ``phi[p] = p - ``1``; ` ` `  `            ``// Update phi of all multiples of p ` `            ``for` `(``int` `i = ``2` `* p; i < N; i += p) { ` ` `  `                ``// Add the contribution of p ` `                ``// to its multiple i by multiplying ` `                ``// it with (1 - 1/p) ` `                ``phi[i] = (phi[i] / p) * (p - ``1``); ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Function to store prefix sum table ` `static` `void` `prefix() ` `{ ` `    ``// Prefix Sum of all Euler's Totient Values ` `    ``for` `(``int` `i = ``1``; i < N; i++) ` `        ``pref[i] = pref[i - ``1``] + phi[i]; ` `} ` ` `  `static` `void` `find_pairs(``int` `n) ` `{ ` ` `  `    ``// Total number of pairs that can be formed ` `    ``int` `total = (n * (n - ``1``)) / ``2``; ` ` `  `    ``int` `ans = total - pref[n]; ` ` `  `    ``System.out.print(``"Number of pairs from 1 to "` `        ``+ n + ``" are "` `+ ans +``"\n"``); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` ` `  `    ``// Function call to compute all phi ` `    ``precompute(); ` ` `  `    ``// Function call to store all prefix sum ` `    ``prefix(); ` ` `  `    ``int` `q[] = { ``5``, ``7` `}; ` `    ``int` `n = q.length; ` ` `  `    ``for` `(``int` `i = ``0``; i < n; i++) { ` `        ``find_pairs(q[i]); ` `    ``} ` ` `  `} ` `} ` ` `  `// This code contributed by Rajput-Ji `

## Python3

 `# Python 3 program to find the count of pairs ` `# from 1 to N such that their LCM ` `# is not equal to their product ` ` `  `N ``=` `100005` ` `  `# To store Euler's Totient Function ` `phi ``=` `[``0` `for` `i ``in` `range``(N)] ` ` `  `# To store prefix sum table ` `pref ``=` `[``0` `for` `i ``in` `range``(N)] ` ` `  `# Compute Totients of all numbers ` `# smaller than or equal to N ` `def` `precompute(): ` ` `  `    ``# Make phi=0 since 1 cannot form any pair ` `    ``phi[``1``] ``=` `0` ` `  `    ``# Initialise all remaining phi[] with i ` `    ``for` `i ``in` `range``(``2``, N, ``1``): ` `        ``phi[i] ``=` `i ` ` `  `    ``# Compute remaining phi ` `    ``for` `p ``in` `range``(``2``,N): ` `        ``# If phi[p] is not computed already, ` `        ``# then number p is prime ` `        ``if` `(phi[p] ``=``=` `p): ` `            ``# phi of prime number is p-1 ` `            ``phi[p] ``=` `p ``-` `1` ` `  `            ``# Update phi of all multiples of p ` `            ``for` `i ``in` `range``(``2``*``p, N, p): ` ` `  `                ``# Add the contribution of p ` `                ``# to its multiple i by multiplying ` `                ``# it with (1 - 1/p) ` `                ``phi[i] ``=` `(phi[i] ``/``/` `p) ``*` `(p ``-` `1``) ` ` `  `# Function to store prefix sum table ` `def` `prefix(): ` ` `  `    ``# Prefix Sum of all Euler's Totient Values ` `    ``for` `i ``in` `range``(``1``, N, ``1``): ` `        ``pref[i] ``=` `pref[i ``-` `1``] ``+` `phi[i] ` ` `  `def` `find_pairs(n): ` `    ``# Total number of pairs that can be formed ` `    ``total ``=` `(n ``*` `(n ``-` `1``)) ``/``/` `2` ` `  `    ``ans ``=` `total ``-` `pref[n] ` ` `  `    ``print``(``"Number of pairs from 1 to"``,n,``"are"``,ans) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``# Function call to compute all phi ` `    ``precompute() ` ` `  `    ``# Function call to store all prefix sum ` `    ``prefix() ` ` `  `    ``q ``=`  `[``5``, ``7``] ` `    ``n ``=` `len``(q) ` ` `  `    ``for` `i ``in` `range``(n): ` `        ``find_pairs(q[i]) ` `         `  `# This code is contributed by Surendra_Gangwar `

## C#

 `// C# program to find the count of pairs ` `// from 1 to N such that their LCM ` `// is not equal to their product ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `static` `readonly` `int` `N = 100005; ` ` `  `// To store Euler's Totient Function ` `static` `int` `[]phi = ``new` `int``[N]; ` ` `  `// To store prefix sum table ` `static` `int` `[]pref = ``new` `int``[N]; ` ` `  `// Compute Totients of all numbers ` `// smaller than or equal to N ` `static` `void` `precompute() ` `{ ` ` `  `    ``// Make phi = 0 since 1 ` `    ``// cannot form any pair ` `    ``phi = 0; ` ` `  `    ``// Initialise all remaining  ` `    ``// phi[] with i ` `    ``for``(``int` `i = 2; i < N; i++) ` `       ``phi[i] = i; ` ` `  `    ``// Compute remaining phi ` `    ``for``(``int` `p = 2; p < N; p++) ` `    ``{ ` `        `  `       ``// If phi[p] is not computed already, ` `       ``// then number p is prime ` `       ``if` `(phi[p] == p) ` `       ``{ ` `            `  `           ``// phi of prime number is p-1 ` `           ``phi[p] = p - 1; ` `            `  `           ``// Update phi of all multiples of p ` `           ``for``(``int` `i = 2 * p; i < N; i += p) ` `           ``{ ` `               `  `              ``// Add the contribution of p ` `              ``// to its multiple i by multiplying ` `              ``// it with (1 - 1/p) ` `              ``phi[i] = (phi[i] / p) * (p - 1); ` `           ``} ` `       ``} ` `    ``} ` `} ` ` `  `// Function to store prefix sum table ` `static` `void` `prefix() ` `{ ` `     `  `    ``// Prefix Sum of all  ` `    ``// Euler's Totient Values ` `    ``for``(``int` `i = 1; i < N; i++) ` `       ``pref[i] = pref[i - 1] + phi[i]; ` `} ` ` `  `static` `void` `find_pairs(``int` `n) ` `{ ` ` `  `    ``// Total number of pairs  ` `    ``// that can be formed ` `    ``int` `total = (n * (n - 1)) / 2; ` `    ``int` `ans = total - pref[n]; ` ` `  `    ``Console.Write(``"Number of pairs from 1 to "` `+  ` `                      ``n + ``" are "` `+ ans + ``"\n"``); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` ` `  `    ``// Function call to compute all phi ` `    ``precompute(); ` ` `  `    ``// Function call to store ` `    ``// all prefix sum ` `    ``prefix(); ` ` `  `    ``int` `[]q = {5, 7}; ` `    ``int` `n = q.Length; ` ` `  `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `       ``find_pairs(q[i]); ` `    ``} ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```Number of pairs from 1 to 5 are 1
Number of pairs from 1 to 7 are 4
```

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.