# Count of numbers between L and R that are coprime with P

• Last Updated : 13 Dec, 2022

Find the count of numbers between L and R and are coprime with P.

Note: Two numbers X and Y are coprime with each other if their GCD is 1.

Examples:

Input: L = 1, R = 10, P = 16
Output: 5
Explanation: The numbers coprime with P are 1, 3, 5, 7, 9

Input: L = 10, R = 20, P = 15
Output: 6

Approach: The problem can be solved by using simple mathematical concept

Traverse from i = L to R and check if the GCD between i and P is 1 or not.

Follow the below steps to solve the problem:

• Initialize count = 0.
• Traverse in the range and check if the number is coprime with P.
• For checking coprime, check if the GCD of two numbers is 1 or not, if yes then it is else not.
• If yes add 1 to the count.
• After traversing the range, return the count.

Below is the implementation of the above approach:

## C++

```// C++ code to implement the approach

#include <bits/stdc++.h>
using namespace std;

// Function to check if two numbers are coprime
bool isCoprime(int a, int b)
{
return __gcd(a, b) == 1;
}

// Function to count the numbers which
// is coprime to P and in the range [L, R]
int solve(int L, int R, int P)
{
// Initialize count
int Cnt = 0;

// Traverse in the range
for (int i = L; i <= R; i++) {
Cnt += P % 2 == 0 && i % 2 == 0 ? 0
: isCoprime(i, P);
}

// Return count
return Cnt;
}

// Driver Code
int main()
{
// Testcase1
int L = 1, R = 10, P = 16;
cout << solve(L, R, P) << endl;

// Testcase2
L = 5, R = 50, P = 35;
cout << solve(L, R, P) << endl;

return 0;
}```

## Java

```// Java code to implement the approach

import java.io.*;

class GFG {

// Function to calculate GCD
static int gcd(int a, int b)
{
if (b == 0) {
return a;
}
else {
return gcd(b, Math.abs(a - b));
}
}

// Function to check if two numbers are coprime
static boolean isCoprime(int a, int b)
{
return gcd(a, b) == 1;
}

// Function to count the numbers which
// is coprime to P and in the range [L, R]
static int solve(int L, int R, int P)
{
// Initialize count
int Cnt = 0;

// Traverse in the range
for (int i = L; i <= R; i++) {
Cnt += (P % 2 == 0 && i % 2 == 0
? 0
: (isCoprime(i, P) ? 1 : 0));
}

// Return count
return Cnt;
}

public static void main(String[] args)
{
// Testcase1
int L = 1, R = 10, P = 16;
System.out.println(solve(L, R, P));

// Testcase2
L = 5;
R = 50;
P = 35;
System.out.println(solve(L, R, P));
}
}

// This code is contributed by lokesh.```

## Python3

```#Python code to implement the approach
import math

# Function to check if two numbers are coprime
def isCoprime(a,b):
return math.gcd(a,b)==1

# Function to count the numbers which
# is coprime to P and in the range [L, R]
def solve(L,R,P):
# Initialize count
Cnt=0

# Traverse in the range
for i in range(L,R+1):
Cnt=Cnt+ (0 if ((P%2==0) and (i%2==0)) else (1 if isCoprime(i,P) else 0))

# Return count
return Cnt

# Driver Code

# Testcase1
L,R,P=1,10,16
print(solve(L,R,P))

# Testcase2
L,R,P=5,50,35
print(solve(L,R,P))

# This code is contributed by Pushpesh Raj.```

## C#

```// C# code to implement the approach

using System;

public class GFG {

// Function to calculate GCD
static int gcd(int a, int b)
{
if (b == 0) {
return a;
}
else {
return gcd(b, Math.Abs(a - b));
}
}

// Function to check if two numbers are coprime
static bool isCoprime(int a, int b)
{
return gcd(a, b) == 1;
}

// Function to count the numbers which
// is coprime to P and in the range [L, R]
static int solve(int L, int R, int P)
{
// Initialize count
int Cnt = 0;

// Traverse in the range
for (int i = L; i <= R; i++) {
Cnt += (P % 2 == 0 && i % 2 == 0
? 0
: (isCoprime(i, P) ? 1 : 0));
}

// Return count
return Cnt;
}

static public void Main()
{

// Testcase1
int L = 1, R = 10, P = 16;
Console.WriteLine(solve(L, R, P));

// Testcase2
L = 5;
R = 50;
P = 35;
Console.WriteLine(solve(L, R, P));
}
}

// This code is contributed by lokesh.```

## Javascript

```// JS code to implement the approach

// Function to calculate GCD
function gcd(a,b)
{
if (b == 0) {
return a;
}
else {
return gcd(b, Math.abs(a - b));
}
}

// Function to check if two numbers are coprime
function isCoprime(a,b)
{
return (gcd(a, b) == 1);
}

// Function to count the numbers which
// is coprime to P and in the range [L, R]
function solve(L,R,P)
{
// Initialize count
let Cnt = 0;

// Traverse in the range
for (let i = L; i <= R; i++) {
Cnt += P % 2 == 0 && i % 2 == 0 ? 0 : isCoprime(i, P);
}

// Return count
return Cnt;
}

// Driver Code

// Testcase1
let L = 1, R = 10, P = 16;
console.log(solve(L, R, P));

// Testcase2
let a = 5, b = 50, c = 35;
console.log(solve(a,b,c));

// This code is contributed by ksam24000```
Output

```5
30```

Time Complexity: O((R – L) * logN)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up