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]
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, 2): As 1 < 2, and 1*2 = 2*1 where L1 = 2 and L2 = 1.
- (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 <bits/stdc++.h> 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 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 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# 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. <script> // Javascript program implementation // of the approach // Function to compute totient of all // numbers smaller than or equal to N function computeTotient(N, phi) { // Iterate over the range [2, N] for(let 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(let 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 function countPairs(N) { // Stores the counts of first and // second type of pairs respectively let cnt_type1 = 0, cnt_type2 = 0; // Count of first type of pairs let half_N = N / 2; cnt_type1 = (half_N * (half_N - 1)) / 2; // Stores the phi or totient values let phi = Array.from({length: N+1}, (_, i) => 0); for(let i = 1; i <= N; i++) { phi[i] = i; } // Calculate the Phi values computeTotient(N, phi); // Iterate over the range // [N/2 + 1, N] for(let i = (N / 2) + 1; i <= N; i++) // Update the value of // cnt_type2 cnt_type2 += (i - phi[i] - 1); // Print the total count document.write(cnt_type1 + cnt_type2); } // Driver Code let N = 6; countPairs(N); // This code is contributed by souravghosh0416. </script> Time Complexity: O(N*log(log(N)))
Auxiliary Space: O(N), since N extra space has been taken.
Similar Reads
Euler Totient for Competitive Programming What is Euler Totient function(ETF)?Euler Totient Function or Phi-function for 'n', gives the count of integers in range '1' to 'n' that are co-prime to 'n'. It is denoted by \phi(n) .For example the below table shows the ETF value of first 15 positive integers: 3 Important Properties of Euler Totie
8 min read
Euler's Totient Function Given an integer n, find the value of Euler's Totient Function, denoted as Φ(n). The function Φ(n) represents the count of positive integers less than or equal to n that are relatively prime to n. Euler's Totient function Φ(n) for an input n is the count of numbers in {1, 2, 3, ..., n-1} that are re
10 min read
Count of non co-prime pairs from the range [1, arr[i]] for every array element Given an array arr[] consisting of N integers, the task for every ith element of the array is to find the number of non co-prime pairs from the range [1, arr[i]]. Examples: Input: N = 2, arr[] = {3, 4}Output: 2 4Explanation: All non-co-prime pairs from the range [1, 3] are (2, 2) and (3, 3).All non-
13 min read
Generate an array having sum of Euler Totient Function of all elements equal to N Given a positive integer N, the task is to generate an array such that the sum of the Euler Totient Function of each element is equal to N. Examples: Input: N = 6Output: 1 6 2 3 Input: N = 12Output: 1 12 2 6 3 4 Approach: The given problem can be solved based on the divisor sum property of the Euler
5 min read
Count all possible values of K less than Y such that GCD(X, Y) = GCD(X+K, Y) Given two integers X and Y, the task is to find the number of integers, K, such that gcd(X, Y) is equal to gcd(X+K, Y), where 0 < K <Y. Examples: Input: X = 3, Y = 15Output: 4Explanation: All possible values of K are {0, 3, 6, 9} for which GCD(X, Y) = GCD(X + K, Y). Input: X = 2, Y = 12Output:
8 min read
Count of integers up to N which are non divisors and non coprime with N Given an integer N, the task is to find the count of all possible integers less than N satisfying the following properties: The number is not coprime with N i.e their GCD is greater than 1.The number is not a divisor of N. Examples: Input: N = 10 Output: 3 Explanation: All possible integers which ar
5 min read
Find the number of primitive roots modulo prime Given a prime p . The task is to count all the primitive roots of p .A primitive root is an integer x (1 <= x < p) such that none of the integers x - 1, x2 - 1, ...., xp - 2 - 1 are divisible by p but xp - 1 - 1 is divisible by p . Examples: Input: P = 3 Output: 1 The only primitive root modul
5 min read
Compute power of power k times % m Given x, k and m. Compute (xxxx...k)%m, x is in power k times. Given x is always prime and m is greater than x. Examples: Input : 2 3 3 Output : 1 Explanation : ((2 ^ 2) ^ 2) % 3 = (4 ^ 2) % 3 = 1 Input : 3 2 3 Output : 0 Explanation : (3^3)%3 = 0 A naive approach is to compute the power of x k time
15+ min read
Primitive root of a prime number n modulo n Given a prime number n, the task is to find its primitive root under modulo n. The primitive root of a prime number n is an integer r between[1, n-1] such that the values of r^x(mod n) where x is in the range[0, n-2] are different. Return -1 if n is a non-prime number. Examples: Input : 7 Output : S
15 min read
Euler's Totient function for all numbers smaller than or equal to n Euler's Totient function ?(n) for an input n is the count of numbers in {1, 2, 3, ..., n} that are relatively prime to n, i.e., the numbers whose GCD (Greatest Common Divisor) with n is 1. For example, ?(4) = 2, ?(3) = 2 and ?(5) = 4. There are 2 numbers smaller or equal to 4 that are relatively pri
13 min read