# Count of non co-prime pairs from the range [1, arr[i]] for every array element

• Difficulty Level : Hard
• Last Updated : 10 Nov, 2021

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 4
Explanation:

1. All non-co-prime pairs from the range [1, 3] are (2, 2) and (3, 3).
2. All non-co-prime pairs from the range [1, 4] are (2, 2), (2, 4), (3, 3) and (4, 4).

Input: N = 3, arr[] = {5, 10, 20}
Output: 5 23 82

Naive Approach: The simplest approach to solve the problem is to iterate over every ith array element and then, generate every possible pair from the range [1, arr[i]], and for every pair, check whether it is non-co-prime, i.e. gcd of the pair is greater than 1 or not.

Follow the steps below to solve this problem:

• Iterate over the range [0, N – 1] using a variable, say i, and perform the following steps:
• Initialize variables lastEle as arr[i] and count as 0 to store the last value of the current range and number of co-prime pairs respectively.
• Iterate over every pair from the range [1, arr[i]] using variables x and y and do the following:
• If GCD(x, y) is greater than 1, then the increment count by 1.
• Finally, print the count as the answer.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach#include using namespace std; // Recursive function to// return gcd of two numbersint gcd(int a, int b){    if (b == 0)        return a;     return gcd(b, a % b);} // Function to count the number of// non co-prime pairs for each queryvoid countPairs(int* arr, int N){     // Traverse the array arr[]    for (int i = 0; i < N; i++) {         // Stores the count of        // non co-prime pairs        int count = 0;         // Iterate over the range [1, x]        for (int x = 1; x <= arr[i]; x++) {             // Iterate over the range [x, y]            for (int y = x; y <= arr[i]; y++) {                 // If gcd of current pair                // is greater than 1                if (gcd(x, y) > 1)                    count++;            }        }        cout << count << " ";    }} // Driver Codeint main(){    // Given Input    int arr[] = { 5, 10, 20 };    int N = 3;     // Function Call    countPairs(arr, N);     return 0;}

## Java

 // Java program for the above approachimport java.util.*; class GFG{ // Recursive function to// return gcd of two numbersstatic int gcd(int a, int b){    if (b == 0)        return a;     return gcd(b, a % b);} // Function to count the number of// non co-prime pairs for each querystatic void countPairs(int[] arr, int N){         // Traverse the array arr[]    for(int i = 0; i < N; i++)    {                 // Stores the count of        // non co-prime pairs        int count = 0;         // Iterate over the range [1, x]        for(int x = 1; x <= arr[i]; x++)        {                         // Iterate over the range [x, y]            for(int y = x; y <= arr[i]; y++)            {                                 // If gcd of current pair                // is greater than 1                if (gcd(x, y) > 1)                    count++;            }        }        System.out.print(count + " ");    }} // Driver Codepublic static void main(String[] args){         // Given Input    int arr[] = { 5, 10, 20 };    int N = 3;     // Function Call    countPairs(arr, N);}} // This code is contributed by subhammahato348

## Python3

 # Python3 program for the above approach # Recursive program to# return gcd of two numbersdef gcd(a, b):         if b == 0:        return a             return gcd(b, a % b) # Function to count the number of# non co-prime pairs for each querydef countPairs(arr, N):         # Traverse the array arr[]    for i in range(0, N):               # Stores the count of        # non co-prime pairs        count = 0                 # Iterate over the range [1,x]        for x in range(1, arr[i] + 1):                         # Iterate over the range [x,y]            for y in range(x, arr[i] + 1):                               # If gcd of current pair                # is greater than 1                if gcd(x, y) > 1:                    count += 1                             print(count, end = " ") # Driver codeif __name__ == '__main__':       # Given Input    arr = [ 5, 10, 20 ]    N = len(arr)     # Function Call    countPairs(arr, N) # This code is contributed by MuskanKalra1

## C#

 // C# program for the above approachusing System; class GFG{ // Recursive function to// return gcd of two numbersstatic int gcd(int a, int b){    if (b == 0)        return a;     return gcd(b, a % b);} // Function to count the number of// non co-prime pairs for each querystatic void countPairs(int[] arr, int N){         // Traverse the array arr[]    for(int i = 0; i < N; i++)    {                 // Stores the count of        // non co-prime pairs        int count = 0;         // Iterate over the range [1, x]        for(int x = 1; x <= arr[i]; x++)        {                         // Iterate over the range [x, y]            for(int y = x; y <= arr[i]; y++)            {                                 // If gcd of current pair                // is greater than 1                if (gcd(x, y) > 1)                    count++;            }        }        Console.Write(count + " ");    }} // Driver Codepublic static void Main(String[] args){         // Given Input    int []arr = { 5, 10, 20 };    int N = 3;     // Function Call    countPairs(arr, N);}} // This code is contributed by shivanisinghss2110

## Javascript



Output

5 23 82

Time Complexity: O(N*M2*log(M)), where M is the maximum element of the array.
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by using Euler’s totient function, and prefix sum array. Follow the steps below to solve the problem:

• Initialize two arrays, say phi[] and ans[] as 0, where the ith element of the array represents the count of integers that is coprime to i and the count of non-coprime pairs formed from the range [1, arr[i]].
• Iterate over the range [1, MAX] using a variable, say i, and assign i to phi[i].
• Iterate over the range [2, MAX] using a variable, say i,  and perform the following steps:
• If phi[i] = i, then iterate over the range [i, MAX] using a variable and perform the following steps:
• Decrement phi[j] / i from phi[j] and then increment j by i.
• Iterate over the range [1, MAX] using a variable, say i,  and perform the following steps:
• Update ans[i] to ans[i – 1] + (i – phi[i]).
• Finally, after completing the above steps, print the array ans[].

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach#include using namespace std;const int MAX = 1005; // Auxiliary function to pre-compute// the answer for each arrayvoid preCalculate(vector& phi,                  vector& ans){    phi[0] = 0;    phi[1] = 1;     // Iterate over the range [1, MAX]    for (int i = 2; i <= MAX; i++)        phi[i] = i;     // Iterate over the range [1, MAX]    for (int i = 2; i <= MAX; i++) {         // If the number is prime        if (phi[i] == i) {             for (int j = i; j <= MAX; j += i)                 // Subtract the number of                // pairs which has i as one                // of their factors                phi[j] -= (phi[j] / i);        }    }     // Iterate over the range [1, MAX]    for (int i = 1; i <= MAX; i++)        ans[i] = ans[i - 1] + (i - phi[i]);} // Function to count the number of// non co-prime pairs for each queryvoid countPairs(int* arr, int N){    // The i-th element stores    // the count of element that    // are co-prime with i    vector phi(1e5, 0);     // Stores the resulting array    vector ans(1e5, 0);     // Function Call    preCalculate(phi, ans);     // Traverse the array arr[]    for (int i = 0; i < N; ++i) {        cout << ans[arr[i]] << " ";    }} // Driver Codeint main(){    // Given Input    int arr[] = { 5, 10, 20 };    int N = 3;     // Function Call    countPairs(arr, N);}

## Java

 // Java program for the above approachimport java.util.*;class GFG {     static int MAX = 1005; // Auxiliary function to pre-compute// the answer for each arraystatic void preCalculate(int[] phi,                  int[] ans){    phi[0] = 0;    phi[1] = 1;     // Iterate over the range [1, MAX]    for (int i = 2; i <= MAX; i++)        phi[i] = i;     // Iterate over the range [1, MAX]    for (int i = 2; i <= MAX; i++) {         // If the number is prime        if (phi[i] == i) {             for (int j = i; j <= MAX; j += i)                 // Subtract the number of                // pairs which has i as one                // of their factors                phi[j] -= (phi[j] / i);        }    }     // Iterate over the range [1, MAX]    for (int i = 1; i <= MAX; i++)        ans[i] = ans[i - 1] + (i - phi[i]);} // Function to count the number of// non co-prime pairs for each querystatic void countPairs(int[] arr, int N){    // The i-th element stores    // the count of element that    // are co-prime with i    int[] phi = new int[100000];    Arrays.fill(phi, 0);     // Stores the resulting array    int[] ans = new int[100000];    Arrays.fill(ans, 0);         // Function Call    preCalculate(phi, ans);     // Traverse the array arr[]    for (int i = 0; i < N; ++i) {        System.out.print(ans[arr[i]] + " ");    }}    // Driver Codepublic static void main(String[] args){     // Given Input    int arr[] = { 5, 10, 20 };    int N = 3;     // Function Call    countPairs(arr, N);}} // This code is contributed by code_hunt.

## Python3

 MAX = 1005; def preCalculate(phi,ans):    phi[0] = 0    phi[1] = 1         # Iterate over the range [1, MAX]    for i in range(2, MAX+1):        phi[i] = i         # Iterate over the range [1, MAX]    for i in range(2, MAX+1):        if (phi[i] == i):            for j in range(i, MAX+1, i):                                 # Subtract the number of                # pairs which has i as one                # of their factors                phi[j] -= (phi[j] // i);                     # Iterate over the range [1, MAX]    for i in range(1, MAX+1):        ans[i] = ans[i - 1] + (i - phi[i]); # Function to count the number of# non co-prime pairs for each querydef countPairs(arr, N):     # The i-th element stores    # the count of element that    # are co-prime with i    phi = [0 for i in range(100001)]     # Stores the resulting array    ans = [0 for i in range(100001)]     # Function Call    preCalculate(phi, ans);     # Traverse the array arr[]    for i in range(N):        print(ans[arr[i]],end=' '); # Given Inputarr= [5, 10, 20]N = 3; # Function CallcountPairs(arr, N); # This code is contributed by rutvik_56.

## C#

 // C# program for the above approachusing System;class GFG{ static int MAX = 1005; // Auxiliary function to pre-compute// the answer for each arraystatic void preCalculate(int[] phi,                  int[] ans){    phi[0] = 0;    phi[1] = 1;     // Iterate over the range [1, MAX]    for (int i = 2; i <= MAX; i++)        phi[i] = i;     // Iterate over the range [1, MAX]    for (int i = 2; i <= MAX; i++) {         // If the number is prime        if (phi[i] == i) {             for (int j = i; j <= MAX; j += i)                 // Subtract the number of                // pairs which has i as one                // of their factors                phi[j] -= (phi[j] / i);        }    }     // Iterate over the range [1, MAX]    for (int i = 1; i <= MAX; i++)        ans[i] = ans[i - 1] + (i - phi[i]);} // Function to count the number of// non co-prime pairs for each querystatic void countPairs(int[] arr, int N){    // The i-th element stores    // the count of element that    // are co-prime with i    int[] phi = new int[100000];    Array.Clear(phi, 0, 100000);     // Stores the resulting array    int[] ans = new int[100000];    Array.Clear(ans, 0, 100000);     // Function Call    preCalculate(phi, ans);     // Traverse the array arr[]    for (int i = 0; i < N; ++i) {        Console.Write(ans[arr[i]] + " ");    }} // Driver Codepublic static void Main(){    // Given Input    int[] arr = { 5, 10, 20 };    int N = 3;     // Function Call    countPairs(arr, N);}} // This code is contributed by sanjoy_62.

## Javascript



Output

5 23 82

Time Complexity: O(N+ M*log(N)), where M is the maximum element of the array.
Auxiliary Space: O(M+N)

My Personal Notes arrow_drop_up