Euler Totient for Competitive Programming

What is Euler Totient function(ETF)?

Euler Totient Function or Phi-function for ‘n’, gives the count of integers in range ‘1′ to ‘n’ that are co-prime to ‘n’. It is denoted by .
For example the below table shows the ETF value of first 15 positive integers:

3 Important Properties of Euler Totient Funtion:

1. If p is prime number:
   1. 
2. For where n is a prime number and k is some positive integer:
   1. 
3. If a and b are relatively prime
   1. 

click here for proof

Deducing equation to calcuate ETF for ‘n’ using above properties:

{prime factorizing n}

Euler Totient Funtion in O(\sqrt{n} ) using prime factorization:

C++

int ETF(int n) {
    int phi_n = n;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            while (n % i == 0)
                n /= i;
            phi_n -= phi_n / i;
        }
    }
    if (n > 1)
        phi_n -= phi_n / n;
    return result;
}

Java

public class EulerTotientFunction {
    // Function to calculate Euler's Totient Function (ETF) for an integer n
    public static int ETF(int n) {
        int phi_n = n; // Initialize phi_n with the value of n

        // Iterate through potential prime factors up to the square root of n
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                // Found a prime factor i
                while (n % i == 0) {
                    n /= i; // Reduce n by removing all factors of i
                }
                phi_n -= phi_n / i; // Update phi_n using the formula
            }
        }

        // If n is still greater than 1, it is a prime number
        if (n > 1) {
            phi_n -= phi_n / n; // Update phi_n for the remaining prime factor
        }

        return phi_n; // Return the Euler's Totient Function value for n
    }

    public static void main(String[] args) {
        int n = 10; // Replace with the desired value of n

        // Calculate Euler's Totient Function for n
        int result = ETF(n);

        // Print the result
        System.out.println("Euler's Totient Function value for " + n + " is: " + result);
    }
}

C#

int ETF(int n) {
    int phi_n = n;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            while (n % i == 0)
                n /= i;
            phi_n -= phi_n / i;
        }
    }
    if (n > 1)
        phi_n -= phi_n / n;
    return phi_n;
}

Javascript

// Function to calculate Euler's Totient Function
function ETF(n) {
    let phi_n = n;

    for (let i = 2; i * i <= n; i++) {
        if (n % i === 0) {
            while (n % i === 0)
                n /= i;
            phi_n -= phi_n / i;
        }
    }

    if (n > 1)
        phi_n -= phi_n / n;

    return phi_n;
}

// Example usage
let n = 12;
let result = ETF(n);
console.log(`Euler's Totient Function for n = ${n}: ${result}`);

Python3

def ETF(n):
    phi_n = n
    i = 2
    while i * i <= n:
        if n % i == 0:
            while n % i == 0:
                n //= i
            phi_n -= phi_n // i
        i += 1
    if n > 1:
        phi_n -= phi_n // n
    return phi_n

How to store Euler Totient Function for each integer 1 to n Optimally:

The above code shows that we can calculate the ETF value for ‘n’ in O(\sqrt{n} ), If we want to calculate ETF value for each integer from 1 to n then it will take us O(n\sqrt{n}) .

Can we optimize this time complexity? YES we can, using precomputation similar to Sieve of Eratosthenes we can reduce the time complexity to O(n*log(log n)) as shown in below code:

C++

vector<int> ETF_1_to_n(int n) {
    vector<int> phi(n + 1);
    for (int i = 0; i <= n; i++)
        phi[i] = i;

    for (int i = 2; i <= n; i++) {
        if (phi[i] == i) {
            for (int j = i; j <= n; j += i)
                phi[j] -= phi[j] / i;
        }
    }
  return phi
}

Java

List<Integer> ETF_1_to_n(int n)
{
    List<Integer> phi = new ArrayList<>(n + 1);
    for (int i = 0; i <= n; i++) {
        phi.add(i);
    }

    for (int i = 2; i <= n; i++) {
        if (phi.get(i) == i) {
            for (int j = i; j <= n; j += i) {
                phi.set(j, phi.get(j) - phi.get(j) / i);
            }
        }
    }

    return phi;
}

C#

List<int> ETF_1_to_n(int n) {
    List<int> phi = new List<int>(n + 1);
    for (int i = 0; i <= n; i++)
        phi.Add(i);
    for (int i = 2; i <= n; i++) {
        if (phi[i] == i) {
            for (int j = i; j <= n; j += i)
                phi[j] -= phi[j] / i;
        }
    }
    return phi;
}

Javascript

function ETF_1_to_n(n) {
    const phi = new Array(n + 1).fill(0);
    for (let i = 0; i <= n; i++) {
        phi[i] = i;
    }
    for (let i = 2; i <= n; i++) {
        if (phi[i] === i) {
            for (let j = i; j <= n; j += i) {
                phi[j] -= Math.floor(phi[j] / i);
            }
        }
    }
    return phi;
}

Python3

def ETF_1_to_n(n):
    # Initialize a list phi containing numbers from 0 to n
    phi = list(range(n + 1))
    
    # Calculate Euler's Totient Function for each number from 2 to n
    for i in range(2, n + 1):
        # If phi[i] is equal to i, indicating i is prime
        if phi[i] == i:
            # Update phi for multiples of i using Euler's Totient formula
            for j in range(i, n + 1, i):
                phi[j] -= phi[j] // i  # phi[j] -= phi[j] / i, reducing by phi[j]
                                       # divided by i (floor division)
    
    return phi  # Return the list containing Euler's Totient values from 1 to n

Key hints to identify a problem uses the knowledge of Euler Totient Function:

ETF is considered to be an advance topic for competitive programming which requires a good understanding of mathematics and its problem difficulty ranges from medium to hard. For a problem we can try to think towards ETF in the following scenarios:

• GCD and LCM based problems
• Use of Chinese Remainder Theorem
• Use of Fermat’s Little Theorem
• Problem requires calcuation of Large Exponentiations such as

Note: It is not necessary that all the above type of problems can be solved using Euler Totient Function, we can try to think in ETF’s direction if above jargons are used in the problem statement.

Use-Case of Euler Totient Function in Competitive Programming:

Calculating Large Exponential Value % mod:

Euler’s Totient Theorem states that if a and n are coprime (gcd(a, n) = 1), then . This theorem is used to find the remainder of a number raised to a large power modulo n efficiently. Competitive programming problems often require solving such congruence relations.

Calculating Co-Prime Pairs:

You may encounter problems that require counting the number of pairs (a, b) such that 1 ≤ a, b ≤ n and gcd(a, b) = 1. The Euler Totient function can be used here to calculate and then determine the count of coprime pairs.

Eulter Totient Function as DP-state:

In dynamic programming (DP) problems, you might use as a state in your DP table when solving combinatorial or counting problems involving modular arithmetic.

Practice Problems On Euler Totient:

Medium:

Euler Totient
Count of non-co-prime pairs from the range [1, arr[i]] for every array element
Generate an array having sum of Euler Totient Function of all elements equal to N
Count all possible values of K less than Y such that GCD(X, Y) = GCD(X+K, Y)
Count of integers up to N which are non divisors and non coprime with N
Find the number of primitive roots modulo prime
Compute power of power k times % m
Primitive root of a prime number n modulo n
Euler’s Totient function for all numbers smaller than or equal to n
Count numbers up to N whose GCD with N is less than that number
Count integers in a range which are divisible by their euler totient value

Hard:

Sum of GCD of all numbers upto N with N itself
Find (1^n + 2^n + 3^n + 4^n) mod 5 | Set 2
Queries to count the number of unordered co-prime pairs from 1 to N
Minimum insertions to make a Co-prime array
Optimized Euler Totient Function for Multiple Evaluations
Number Theory | Generators of finite cyclic group under addition
Sum of Euler Totient Functions obtained for each divisor of N
Count number of pairs (i, j) up to N that can be made equal on multiplying with a pair from the range [1, N / 2]
Count of numbers up to N having at least one prime factor common with N
Probability of Euler’s Totient Function in a range [L, R] to be divisible by M
Count of Distinct strings possible by inserting K characters in the original string
Count of elements having Euler’s Totient value one less than itself
Count of pairs upto N such whose LCM is not equal to their product for Q queries
Count of numbers upto M with GCD equals to K when paired with M
Highly Totient Number