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

• Last Updated : 21 Apr, 2021

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: Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 = { 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``    ``cout << countPrime[R]``                ``- countPrime[L - 1]``         ``<< endl;` `    ``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;``}`

## 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``;` `// 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