GeeksforGeeks App
Open App
Browser
Continue

# Count of elements having Euler’s Totient value one less than itself

Given an array arr[] of N integers, and a range L to R, the task is to find the total number of elements in the array from index L to R that satisfies the following condition:

where F(x) is Euler’s Totient Function.

Examples:

Input: arr[] = {2, 4, 5, 8}, L = 1, R = 3
Output:
Explanation:
Here in the given range, F(2) = 1 and (2 – 1) = 1. Similarly, F(5) = 4 and (5 – 1) = 4.
So the total count of indices which satisfy the condition is 2.
Input: arr[] = {9, 3, 4, 6, 8}, L = 3, R = 5
Output:
Explanation :
In the given range there is no element that satisfies the given condition.
So the total count is 0.

Naive Approach: The naive approach to solve this problem is to iterate over all the elements of the array and check if the Euler’s Totient value of the current element is one less than itself. If yes then increment the count.
Time Complexity: O(N * sqrt(N))
Auxiliary Space: O(1)
Efficient Approach:

Euler’s Totient function F(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 Greatest Common Divisor with n is 1.

1. If we observe, we can notice that the above given condition is only satisfied by the Prime numbers.
2. So, all we need to do is to compute the total numbers of prime numbers in the given range.
3. We will use Sieve of Eratosthenes to compute prime numbers efficiently.
4. Also, we will pre-compute the numbers of primes numbers in a count array.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `long` `long` `prime[1000001] = { 0 };` `// Seiev of Erotosthenes method to compute all primes``void` `seiveOfEratosthenes()``{``    ``for` `(``int` `i = 2; i < 1000001; i++)``        ``prime[i] = 1;` `    ``for` `(``int` `i = 2; i * i < 1000001; i++) {``        ``// If current number is marked prime then mark its``        ``// multiple as non-prime``        ``if` `(prime[i] == 1)``            ``for` `(``int` `j = i * i; j < 1000001; j += i)``                ``prime[j] = 0;``    ``}``}` `// Function to count the number``// of element satisfying the condition``void` `CountElements(``int` `arr[], ``int` `n, ``int` `L, ``int` `R)``{``    ``seiveOfEratosthenes();` `    ``long` `long` `countPrime[n + 1] = { 0 };` `    ``// Compute the number of primes in count prime array``    ``for` `(``int` `i = 1; i <= n; i++)``        ``countPrime[i] = countPrime[i - 1] + prime[arr[i - 1]];` `    ``// Print the number of elements satisfying the condition``    ``printf``(``"%lld"``, (countPrime[R] - countPrime[L - 1]));``    ``return``;``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 2, 4, 5, 8 };``    ``// Size of the array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(``int``);``    ``int` `L = 1, R = 3;``    ``// Function Call``    ``CountElements(arr, N, L, R);``    ``return` `0;``}` `// This code is contributed by Sania Kumari Gupta`

## C

 `// C program for the above approach``#include ``#include ` `long` `long` `prime[1000001];` `// Seiev of Erotosthenes method to compute all primes``void` `seiveOfEratosthenes()``{``    ``memset``(prime, 0, ``sizeof``(prime));``    ``for` `(``int` `i = 2; i < 1000001; i++)``        ``prime[i] = 1;` `    ``for` `(``int` `i = 2; i * i < 1000001; i++) {``        ``// If current number is marked prime then mark its``        ``// multiple as non-prime``        ``if` `(prime[i] == 1)``            ``for` `(``int` `j = i * i; j < 1000001; j += i)``                ``prime[j] = 0;``    ``}``}` `// Function to count the number``// of element satisfying the condition``void` `CountElements(``int` `arr[], ``int` `n, ``int` `L, ``int` `R)``{``    ``seiveOfEratosthenes();``    ``long` `long` `countPrime[n + 1];``    ``memset``(countPrime, 0, ``sizeof``(countPrime));` `    ``// Compute the number of primes in count prime array``    ``for` `(``int` `i = 1; i <= n; i++)``        ``countPrime[i]``            ``= countPrime[i - 1] + prime[arr[i - 1]];` `    ``// Print the number of elements satisfying the condition``    ``printf``(``"%lld"``, (countPrime[R] - countPrime[L - 1]));``    ``return``;``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 2, 4, 5, 8 };``    ``// Size of the array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(``int``);``    ``int` `L = 1, R = 3;``    ``// Function Call``    ``CountElements(arr, N, L, R);``    ``return` `0;``}` `// This code is contributed by Sania Kumari Gupta`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `static` `int` `prime[] = ``new` `int``[``1000001``];` `// Seiev of Erotosthenes method to``// compute all primes``static` `void` `seiveOfEratosthenes()``{``    ``for``(``int` `i = ``2``; i < ``1000001``; i++)``    ``{``       ``prime[i] = ``1``;``    ``}` `    ``for``(``int` `i = ``2``; i * i < ``1000001``; i++)``    ``{``       ` `       ``// If current number is``       ``// marked prime then mark``       ``// its multiple as non-prime``       ``if` `(prime[i] == ``1``)``       ``{``           ``for``(``int` `j = i * i;``                   ``j < ``1000001``; j += i)``           ``{``              ``prime[j] = ``0``;``           ``}``       ``}``    ``}``}` `// Function to count the number``// of element satisfying the condition``static` `void` `CountElements(``int` `arr[], ``int` `n,``                          ``int` `L, ``int` `R)``{``    ``seiveOfEratosthenes();` `    ``int` `countPrime[] = ``new` `int``[n + ``1``];` `    ``// Compute the number of primes``    ``// in count prime array``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``       ``countPrime[i] = countPrime[i - ``1``] +``                        ``prime[arr[i - ``1``]];``    ``}` `    ``// Print the number of elements``    ``// satisfying the condition``    ``System.out.print(countPrime[R] -``                     ``countPrime[L - ``1``] + ``"\n"``);` `    ``return``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given array``    ``int` `arr[] = { ``2``, ``4``, ``5``, ``8` `};` `    ``// Size of the array``    ``int` `N = arr.length;``    ``int` `L = ``1``, R = ``3``;` `    ``// Function Call``    ``CountElements(arr, N, L, R);``}``}` `// This code is contributed by amal kumar choubey`

## Python3

 `# Python3 program for the above approach``prime ``=` `[``0``] ``*` `(``1000001``)` `# Seiev of Erotosthenes method to``# compute all primes``def` `seiveOfEratosthenes():` `    ``for` `i ``in` `range``(``2``, ``1000001``):``        ``prime[i] ``=` `1``    ` `    ``i ``=` `2``    ``while``(i ``*` `i < ``1000001``):` `        ``# If current number is``        ``# marked prime then mark``        ``# its multiple as non-prime``        ``if` `(prime[i] ``=``=` `1``):``            ``for` `j ``in` `range``(i ``*` `i, ``1000001``, i):``                ``prime[j] ``=` `0``        ` `        ``i ``+``=` `1` `# Function to count the number``# of element satisfying the condition``def` `CountElements(arr, n, L, R):``    ` `    ``seiveOfEratosthenes()` `    ``countPrime ``=` `[``0``] ``*` `(n ``+` `1``)` `    ``# Compute the number of primes``    ``# in count prime array``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``countPrime[i] ``=` `(countPrime[i ``-` `1``] ``+``                          ``prime[arr[i ``-` `1``]])``    ` `    ``# Print the number of elements``    ``# satisfying the condition``    ``print``(countPrime[R] ``-``          ``countPrime[L ``-` `1``])` `    ``return` `# Driver Code` `# Given array``arr ``=` `[ ``2``, ``4``, ``5``, ``8` `]` `# Size of the array``N ``=` `len``(arr)``L ``=` `1``R ``=` `3` `# Function call``CountElements(arr, N, L, R)` `# This code is contributed by sanjoy_62`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG{` `static` `int` `[]prime = ``new` `int``[1000001];` `// Seiev of Erotosthenes method to``// compute all primes``static` `void` `seiveOfEratosthenes()``{``    ``for``(``int` `i = 2; i < 1000001; i++)``    ``{``        ``prime[i] = 1;``    ``}` `    ``for``(``int` `i = 2; i * i < 1000001; i++)``    ``{``        ` `        ``// If current number is``        ``// marked prime then mark``        ``// its multiple as non-prime``        ``if` `(prime[i] == 1)``        ``{``            ``for``(``int` `j = i * i;``                    ``j < 1000001; j += i)``            ``{``                ``prime[j] = 0;``            ``}``        ``}``    ``}``}` `// Function to count the number``// of element satisfying the condition``static` `void` `CountElements(``int` `[]arr, ``int` `n,``                          ``int` `L, ``int` `R)``{``    ``seiveOfEratosthenes();` `    ``int` `[]countPrime = ``new` `int``[n + 1];` `    ``// Compute the number of primes``    ``// in count prime array``    ``for``(``int` `i = 1; i <= n; i++)``    ``{``        ``countPrime[i] = countPrime[i - 1] +``                         ``prime[arr[i - 1]];``    ``}` `    ``// Print the number of elements``    ``// satisfying the condition``    ``Console.Write(countPrime[R] -``                  ``countPrime[L - 1] + ``"\n"``);` `    ``return``;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given array``    ``int` `[]arr = { 2, 4, 5, 8 };` `    ``// Size of the array``    ``int` `N = arr.Length;``    ``int` `L = 1, R = 3;` `    ``// Function Call``    ``CountElements(arr, N, L, R);``}``}` `// This code is contributed by sapnasingh4991`

## Javascript

 ``

Output:

`2`

Time Complexity: O(N * log(logN))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up