# Count number of pairs (i, j) up to N that can be made equal on multiplying with a pair from the range [1, N / 2]

• Difficulty Level : Hard
• Last Updated : 20 Jul, 2022

Given a positive even integer N, the task is to find the number of pairs (i, j) from the range [1, N] such that the product of i and L1 is the same as the product of j and L2 where i < j and L1 and L2 any number from the range [1, N/2].

Examples:

Input: N = 4
Output: 2
Explanation:
The possible pairs satisfying the given criteria are:

1. (1, 2): As 1 < 2, and 1*2 = 2*1 where L1 = 2 and L2 = 1.
2. (2, 4): As 2 < 4 and 2*2 = 4*1 where L1 = 2 and L2 = 1.

Therefore, the total count is 2.

Input: N = 6
Output: 7

Naive Approach: The given problem can be solved based on the following observations:

Let i * L1 = j * L2 = lcm(i, j) — (1)
⇒ L1 = lcm(i, j)/ i
= j/gcd(i, j)

Similarly, L2 = i/gcd(i, j)

Now, for the condition to be satisfied, L1 and L2 must be in the range [1, N/2].

Therefore, the idea is to generate all possible pairs (i, j) over the range [1,  N] and if there exist any pair (i, j) such that the value of i/gcd(i, j) and j/gcd(i, j) is less than N/2, then increment the count of pairs by 1. After checking for all the pairs, print the value of the count as the result.

Time Complexity: O(N2*log N)
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized by using Euler’s Totient function. There exist the following 2 cases for any pair (i, j):

• Case 1: If the pair (i, j) lies in the range [1, N/2], then all the possible pairs formed will satisfy the given condition. Therefore, the total count of pairs is given by (z*(z – 1))/2, where z = N/2.
• Case 2: If all possible pairs (i, j) lies in the range [N/2 + 1, N] having gcd(i, j) is greater than 1 satisfy the given conditions.

Follow the steps below to count the total number of this type of pairs:

• Compute Φ for all numbers smaller than or equal to N by using Euler’s Totient function for all numbers smaller than or equal to N.
• For a number j, the total number of possible pairs (i, j) can be calculated as (j – Φ(j) – 1).
• For each number in the range [N/2 + 1, N], count the total number pairs using the above formula.
• After completing the above steps, print the sum of values obtained in the above two steps as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to compute totient of all``// numbers smaller than or equal to N``void` `computeTotient(``int` `N, ``int` `phi[])``{``    ``// Iterate over the range [2, N]``    ``for` `(``int` `p = 2; p <= N; p++) {` `        ``// If phi[p] is not computed``        ``// already, then p is prime``        ``if` `(phi[p] == p) {` `            ``// Phi of a prime number``            ``// p is (p - 1)``            ``phi[p] = p - 1;` `            ``// Update phi values of``            ``// all multiples of p``            ``for` `(``int` `i = 2 * p; i <= N;``                 ``i += p) {` `                ``// Add contribution of p``                ``// to its multiple i by``                ``// multiplying with (1 - 1/p)``                ``phi[i] = (phi[i] / p) * (p - 1);``            ``}``        ``}``    ``}``}` `// Function to count the pairs (i, j)``// from the range [1, N], satisfying``// the given condition``void` `countPairs(``int` `N)``{``    ``// Stores the counts of first and``    ``// second type of pairs respectively``    ``int` `cnt_type1 = 0, cnt_type2 = 0;` `    ``// Count of first type of pairs``    ``int` `half_N = N / 2;``    ``cnt_type1 = (half_N * (half_N - 1)) / 2;` `    ``// Stores the  phi or totient values``    ``int` `phi[N + 1];` `    ``for` `(``int` `i = 1; i <= N; i++) {``        ``phi[i] = i;``    ``}` `    ``// Calculate the Phi values``    ``computeTotient(N, phi);` `    ``// Iterate over the range``    ``// [N/2 + 1, N]``    ``for` `(``int` `i = (N / 2) + 1;``         ``i <= N; i++)` `        ``// Update the value of``        ``// cnt_type2``        ``cnt_type2 += (i - phi[i] - 1);` `    ``// Print the total count``    ``cout << cnt_type1 + cnt_type2;``}` `// Driver Code``int` `main()``{``    ``int` `N = 6;``    ``countPairs(N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to compute totient of all``// numbers smaller than or equal to N``static` `void` `computeTotient(``int` `N, ``int` `phi[])``{``    ` `    ``// Iterate over the range [2, N]``    ``for``(``int` `p = ``2``; p <= N; p++)``    ``{``        ` `        ``// If phi[p] is not computed``        ``// already, then p is prime``        ``if` `(phi[p] == p)``        ``{``            ` `            ``// Phi of a prime number``            ``// p is (p - 1)``            ``phi[p] = p - ``1``;` `            ``// Update phi values of``            ``// all multiples of p``            ``for``(``int` `i = ``2` `* p; i <= N; i += p)``            ``{``                ` `                ``// Add contribution of p``                ``// to its multiple i by``                ``// multiplying with (1 - 1/p)``                ``phi[i] = (phi[i] / p) * (p - ``1``);``            ``}``        ``}``    ``}``}` `// Function to count the pairs (i, j)``// from the range [1, N], satisfying``// the given condition``static` `void` `countPairs(``int` `N)``{``    ` `    ``// Stores the counts of first and``    ``// second type of pairs respectively``    ``int` `cnt_type1 = ``0``, cnt_type2 = ``0``;` `    ``// Count of first type of pairs``    ``int` `half_N = N / ``2``;``    ``cnt_type1 = (half_N * (half_N - ``1``)) / ``2``;` `    ``// Stores the  phi or totient values``    ``int` `[]phi = ``new` `int``[N + ``1``];` `    ``for``(``int` `i = ``1``; i <= N; i++)``    ``{``        ``phi[i] = i;``    ``}` `    ``// Calculate the Phi values``    ``computeTotient(N, phi);` `    ``// Iterate over the range``    ``// [N/2 + 1, N]``    ``for``(``int` `i = (N / ``2``) + ``1``;``            ``i <= N; i++)` `        ``// Update the value of``        ``// cnt_type2``        ``cnt_type2 += (i - phi[i] - ``1``);` `    ``// Print the total count``    ``System.out.print(cnt_type1 + cnt_type2);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``6``;``    ` `    ``countPairs(N);``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the above approach` `# Function to compute totient of all``# numbers smaller than or equal to N``def` `computeTotient(N, phi):` `    ``# Iterate over the range [2, N]``    ``for` `p ``in` `range``(``2``, N ``+` `1``):` `        ``# If phi[p] is not computed``        ``# already then p is prime``        ``if` `phi[p] ``=``=` `p:` `            ``# Phi of a prime number``            ``# p is (p - 1)``            ``phi[p] ``=` `p ``-` `1` `            ``# Update phi values of``            ``# all multiples of p``            ``for` `i ``in` `range``(``2` `*` `p, N ``+` `1``, p):` `                ``# Add contribution of p``                ``# to its multiple i by``                ``# multiplying with (1 - 1/p)``                ``phi[i] ``=` `(phi[i] ``/``/` `p) ``*` `(p ``-` `1``)` `# Function to count the pairs (i, j)``# from the range [1, N], satisfying``# the given condition``def` `countPairs(N):` `    ``# Stores the counts of first and``    ``# second type of pairs respectively``    ``cnt_type1 ``=` `0``    ``cnt_type2 ``=` `0` `    ``# Count of first type of pairs``    ``half_N ``=` `N ``/``/` `2``    ``cnt_type1 ``=` `(half_N ``*` `(half_N ``-` `1``)) ``/``/` `2` `    ``# Count of second type of pairs` `    ``# Stores the  phi or totient values``    ``phi ``=` `[``0` `for` `i ``in` `range``(N ``+` `1``)]` `    ``for` `i ``in` `range``(``1``, N ``+` `1``):``        ``phi[i] ``=` `i` `    ``# Calculate the Phi values``    ``computeTotient(N, phi)` `    ``# Iterate over the range``    ``# [N/2 + 1, N]``    ``for` `i ``in` `range``((N ``/``/` `2``) ``+` `1``, N ``+` `1``):` `        ``# Update the value of``        ``# cnt_type2``        ``cnt_type2 ``+``=` `(i ``-` `phi[i] ``-` `1``)` `    ``# Print the total count``    ``print``(cnt_type1 ``+` `cnt_type2)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `6``    ``countPairs(N)` `    ``# This code is contributed by kundudinesh007.`

## C#

 `// C# program for the above approach` `using` `System;``class` `GFG {``    ``// Function to compute totient of all``    ``// numbers smaller than or equal to N``    ``static` `void` `computeTotient(``int` `N, ``int``[] phi)``    ``{``        ``// Iterate over the range [2, N]``        ``for` `(``int` `p = 2; p <= N; p++) {` `            ``// If phi[p] is not computed``            ``// already, then p is prime``            ``if` `(phi[p] == p) {` `                ``// Phi of a prime number``                ``// p is (p - 1)``                ``phi[p] = p - 1;` `                ``// Update phi values of``                ``// all multiples of p``                ``for` `(``int` `i = 2 * p; i <= N; i += p) {` `                    ``// Add contribution of p``                    ``// to its multiple i by``                    ``// multiplying with (1 - 1/p)``                    ``phi[i] = (phi[i] / p) * (p - 1);``                ``}``            ``}``        ``}``    ``}` `    ``// Function to count the pairs (i, j)``    ``// from the range [1, N], satisfying``    ``// the given condition``    ``static` `void` `countPairs(``int` `N)``    ``{``        ``// Stores the counts of first and``        ``// second type of pairs respectively``        ``int` `cnt_type1 = 0, cnt_type2 = 0;` `        ``// Count of first type of pairs``        ``int` `half_N = N / 2;``        ``cnt_type1 = (half_N * (half_N - 1)) / 2;` `        ``// Stores the  phi or totient values``        ``int``[] phi = ``new` `int``[N + 1];` `        ``for` `(``int` `i = 1; i <= N; i++) {``            ``phi[i] = i;``        ``}` `        ``// Calculate the Phi values``        ``computeTotient(N, phi);` `        ``// Iterate over the range``        ``// [N/2 + 1, N]``        ``for` `(``int` `i = (N / 2) + 1; i <= N; i++)` `            ``// Update the value of``            ``// cnt_type2``            ``cnt_type2 += (i - phi[i] - 1);` `        ``// Print the total count``        ``Console.Write(cnt_type1 + cnt_type2);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `N = 6;``        ``countPairs(N);``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``

Output:

`7`

Time Complexity: O(N*log(log(N)))
Auxiliary Space: O(N), since N extra space has been taken.

My Personal Notes arrow_drop_up