# 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:1Explanation:

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

The pair from 1 to 5 is (2, 4)

The pairs from 1 to 7 are (2, 4), (2, 6), (3, 6), (4, 6)

**Approach:** The idea is to use 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 is 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 them in the array.

**Example:**

arr[10] = 10 * (1-1/2) * (1-1/5) = 4

3.

4. 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.

5. 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 <bits/stdc++.h>` `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[1]=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` `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[0]);` ` ` `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[1] = 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[1]=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[1] = 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];` ` ` `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` |

## Javascript

`<script>` `// javascript program to find the count of pairs` `// from 1 to N such that their LCM` `// is not equal to their product` ` ` `var` `N = 100005;` ` ` `// To store Euler's Totient Function` ` ` `var` `phi = Array(N).fill(0);` ` ` `// To store prefix sum table` ` ` `var` `pref = Array(N).fill(0);` ` ` `// Compute Totients of all numbers` ` ` `// smaller than or equal to N` ` ` `function` `precompute() {` ` ` `// Make phi[1] = 0 since 1 cannot form any pair` ` ` `phi[1] = 0;` ` ` `// Initialise all remaining phi with i` ` ` `for` `(i = 2; i < N; i++)` ` ` `phi[i] = i;` ` ` `// Compute remaining phi` ` ` `for` `(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` `(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` ` ` `function` `prefix() {` ` ` `// Prefix Sum of all Euler's Totient Values` ` ` `for` `(i = 1; i < N; i++)` ` ` `pref[i] = pref[i - 1] + phi[i];` ` ` `}` ` ` `function` `find_pairs(n) {` ` ` `// Total number of pairs that can be formed` ` ` `var` `total = (n * (n - 1)) / 2;` ` ` `var` `ans = total - pref[n];` ` ` `document.write(` `"Number of pairs from 1 to "` `+ n + ` `" are "` `+ ans + ` `"<br/>"` `);` ` ` `}` ` ` `// Driver Code` ` ` ` ` `// Function call to compute all phi` ` ` `precompute();` ` ` `// Function call to store all prefix sum` ` ` `prefix();` ` ` `var` `q = [ 5, 7 ];` ` ` `var` `n = q.length;` ` ` `for` `(i = 0; i < n; i++) {` ` ` `find_pairs(q[i]);` ` ` `}` `// This code contributed by Rajput-Ji` `</script>` |

**Output:**

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

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****.**