欧拉Totient值比自身小1的元素数

给定N个整数的数组arr [] ，范围为L到R ，任务是查找满足以下条件的从索引L到R的数组中的元素总数：

$F(arr[i]) = arr[i] - 1$
 

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

 

例子：

Input: arr[] = {2, 4, 5, 8}, L = 1, R = 3 
Output: 2 
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: 0 
Explanation : 
In the given range there is no element that satisfies the given condition. 
So the total count is 0.

幼稚的方法：解决此问题的幼稚的方法是遍历数组的所有元素，并检查当前元素的欧拉Totient值是否比其自身小1。如果是，则增加计数。
时间复杂度： O(N * sqrt(N))
辅助空间： O(1)
高效方法：

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. 如果我们观察到，我们可以注意到上述给定条件仅由质数满足。
2. 因此，我们要做的就是计算给定范围内素数的总数。
3. 我们将使用Eratosthenes筛子有效地计算素数。
4. 同样，我们将预先计算计数数组中素数的数量。

下面是上述方法的实现。

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
    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[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

 
// JavaScript program for the above approach
 
let prime = new Uint8Array(1000001);
 
// Seiev of Erotosthenes method to
// compute all primes
function seiveOfEratosthenes()
{
 
    for (let i = 2; i < 1000001;
        i++) {
        prime[i] = 1;
    }
 
    for (let i = 2; i * i < 1000001;
        i++) {
 
        // If current number is
        // marked prime then mark
        // its multiple as non-prime
        if (prime[i] == 1) {
            for (let j = i * i;
                j < 1000001; j += i) {
                prime[j] = 0;
            }
        }
    }
}
 
// Function to count the number
// of element satisfying the condition
function CountElements(arr, n, L, R)
{
    seiveOfEratosthenes();
 
    countPrime = new Uint8Array(n + 1);
 
    // Compute the number of primes
    // in count prime array
    for (let i = 1; i <= n; i++) {
        countPrime[i] = countPrime[i - 1]
                        + prime[arr[i - 1]];
    }
 
    // Print the number of elements
    // satisfying the condition
    document.write((countPrime[R]
                - countPrime[L - 1])
        + "<br>");
 
    return;
}
 
// Driver Code
 
    // Given array
    let arr = [ 2, 4, 5, 8 ];
 
    // Size of the array
    let N = arr.length;
    let L = 1, R = 3;
 
    // Function Call
    CountElements(arr, N, L, R);
 
 
// This code is contributed by Surbhi Tyagi.
 

输出：

2

时间复杂度： O(N * log(logN))
辅助空间： O(N)