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 \phi(n) .
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. \phi(p)=p-1
2. For n^k where n is a prime number and k is some positive integer:
   1. \phi(p^k)=p^k (1-1/p)
3. If a and b are relatively prime
   1. \phi(ab)=\phi(a)*\phi(b)

click here for proof

Deducing equation to calcuate ETF for 'n' using above properties:

\phi(n) = \phi_{}(p_{1}^{a_{1}} * p_{2}^{a_{2}} * p_{3}^{a_{3}} ... p_{k}^{a_{k}}) {prime factorizing n}

\phi(n) = (p_{1}^{a_{1}}*(1-1/p_{1}) * p_{2}^{a_{2}}*(1-1/p_{2}) ... p_{k}^{a_{k}}*(1-1/p_{k}) )

\phi(n) = (p_{1}^{a_{1}} * p_{2}^{a_{2}}...*p_{k}^{a_{k}} * (1-1/p_{1})*(1-1/p_{2}) ... *(1-1/p_{k}) )

\phi(n) = n * (1-1/p_{1})*(1-1/p_{2}) ... *(1-1/p_{k})

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

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;
}

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);
    }
}

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;
}

// 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}`);

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:

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
}

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;
}

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;
}

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;
}

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 {a^{b}}^{c}

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 a^{φ(n)} ≡ 1 (mod n) . 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 \phi(n) and then determine the count of coprime pairs.

Eulter Totient Function as DP-state:

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

Practice Problems On Euler Totient:

Medium:

Hard: