Euler's Totient for First n Natural Numbers

Euler's Totient function φ(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 GCD (Greatest Common Divisor) with n is 1.

Example:

Input: n = 5
Output:
Totient of 1 is 1
Totient of 2 is 1
Totient of 3 is 2
Totient of 4 is 2
Totient of 5 is 4
Explanation:
1 has 1 coprime number → φ(1) = 1
2 has 1 coprime number (1) → φ(2) = 1
3 has 2 coprime numbers (1,2) → φ(3) = 2
4 has 2 coprime numbers (1,3) → φ(4) = 2
5 has 4 coprime numbers (1,2,3,4) → φ(5) = 4

Input: n = 12
Output:
Totient of 1 is 1
Totient of 2 is 1
Totient of 3 is 2
Totient of 4 is 2
Totient of 5 is 4
Totient of 6 is 2
Totient of 7 is 6
Totient of 8 is 4
Totient of 9 is 6
Totient of 10 is 4
Totient of 11 is 10
Totient of 12 is 4
Explanation:
1 has 1 coprime number → φ(1) = 1 → {1}
2 has 1 coprime number → φ(2) = 1 → {1}
3 has 2 coprime numbers → φ(3) = 2 → {1,2}
4 has 2 coprime numbers → φ(4) = 2 → {1,3}
5 has 4 coprime numbers → φ(5) = 4 → {1,2,3,4}
6 has 2 coprime numbers → φ(6) = 2 → {1,5}
7 has 6 coprime numbers → φ(7) = 6 → {1,2,3,4,5,6}
8 has 4 coprime numbers → φ(8) = 4 → {1,3,5,7}
9 has 6 coprime numbers → φ(9) = 6 → {1,2,4,5,7,8}
10 has 4 coprime numbers → φ(10) = 4 → {1,3,7,9}
11 has 10 coprime numbers → φ(11) = 10 → {1,2,3,4,5,6,7,8,9,10}
12 has 4 coprime numbers → φ(12) = 4 → {1,5,7,11}

[Naive Approach] Iterative GCD Method - O(√n) time and O(1) space

A simple solution is to iterate through all numbers from 1 to n-1 and count numbers with gcd with n as 1. Below is the implementation of the simple method to compute Euler's Totient function for an input integer n.

#include <iostream>
using namespace std; 

// Function to return gcd of a and b
int gcd(int a, int b) { 
    if (a == 0) 
        return b; 
    return gcd(b % a, a); 
} 

// A simple method to evaluate Euler Totient Function 
int etf(int n) { 
    int res = 1; 
    for (int i = 2; i < n; i++) 
        if (gcd(i, n) == 1) 
            res++; 
    return res; 
} 

// Driver Code
int main() { 
    int n = 12; 
    cout << etf(n);
    return 0; 
}

class GfG {

    // Function to return gcd of a and b
    static int gcd(int a, int b) {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

    // Function to compute Euler's Totient Function
    static int etf(int n) {
        int res = 1;
        for (int i = 2; i < n; i++) {
            if (gcd(i, n) == 1)
                res++;
        }
        return res;
    }

// Driver Code
    public static void main(String[] args) {
        int n = 12;
        System.out.println(etf(n));
    }
}

# Function to return gcd of a and b
def gcd(a, b):
    if a == 0:
        return b
    return gcd(b % a, a)

# A simple method to evaluate Euler Totient Function


def etf(n):
    res = 1
    for i in range(2, n):
        if gcd(i, n) == 1:
            res += 1
    return res


# Driver Code
if __name__ == "__main__":
    n = 12
    print(etf(n))

using System;

class GfG {

    // Function to return gcd of a and b
    static int gcd(int a, int b)
    {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

    // A simple method to evaluate Euler Totient Function
    static int etf(int n)
    {
        int res = 1;
        for (int i = 2; i < n; i++) {
            if (gcd(i, n) == 1)
                res++;
        }
        return res;
    }

    // Driver Code
    static void Main()
    {
        int n = 12;
        Console.WriteLine(etf(n));
    }
}

// Function to return gcd of a and b
function gcd(a, b)
{
    if (a === 0)
        return b;
    return gcd(b % a, a);
}

// A simple method to evaluate Euler Totient Function
function etf(n)
{
    let res = 1;
    for (let i = 2; i < n; i++) {
        if (gcd(i, n) === 1)
            res++;
    }
    return res;
}

// Driver Code
let n = 12;
console.log(etf(n));

10

[Efficient Approach] Sieve of Eratosthenes - O(n log(log n)) time and O(n) space

An Efficient Solution is to use an idea similar to the Sieve of Eratosthenes to precompute all values. The method is based on below product formula.

\phi(n) = n \prod_{p \mid n} \left(1 - \frac{1}{p}\right)

Below is the complete algorithm: 

Step 1. Create an array phi[1..n] to store φ values of all numbers from 1 to n.

Step 2. Initialize all values such that phi[i] stores i. This initialization serves two purposes.

• To check if phi[i] is already evaluated or not. Note that the maximum possible phi value of a number i is i-1.

• To initialize phi[i] as i is multiple in the above product formula.

Step 3. Run a loop for p = 2 to n

• If phi[p] is p, means p is not evaluated yet and p is a prime number (similar to Sieve), otherwise phi[p] must have been updated in step 3.b

• Traverse through all multiples of p and update all multiples of p by multiplying with (1-1/p).

Step 4. Run a loop from i = 1 to n and print all Phi[i] values.

using namespace std;

vector<int> etf(int n)
{
    // Computes totient of all numbers from 1 to n
    vector<int> phi(n + 1);
    for (int i = 1; i <= n; i++)
        phi[i] = i;

    // Compute other Phi values
    for (int p = 2; p <= n; p++)
    {
        // If p is prime
        if (phi[p] == p)
        {
            phi[p] = p - 1;
            // Update multiples of p
            for (int i = 2 * p; i <= n; i += p)
            {
                phi[i] = (phi[i] / p) * (p - 1);
            }
        }
    }
    return phi;
}

// Driver code
int main()
{
    int n = 12;
    vector<int> phi = etf(n);

    for (int i = 1; i <= n; i++)
        cout << "Totient of " << i << " is " << phi[i] << endl;

    return 0;
}

class GFG {

    static int[] etf(int n)
    {
        // Computes totient of all numbers from 1 to n
        int phi[] = new int[n + 1];
        for (int i = 1; i <= n; i++)
            phi[i] = i;

        // Compute other Phi values
        for (int p = 2; p <= n; p++) {

            // If p is prime
            if (phi[p] == p) {
                phi[p] = p - 1;

                // Update multiples of p
                for (int i = 2 * p; i <= n; i += p) {
                    phi[i] = (phi[i] / p) * (p - 1);
                }
            }
        }
        return phi;
    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 12;
        int[] phi = etf(n);

        for (int i = 1; i <= n; i++)
            System.out.println("Totient of " + i + " is "
                               + phi[i]);
    }
}

def etf(n):
    # Computes totient of all numbers from 1 to n
    phi = [0] * (n + 1)

    for i in range(1, n + 1):
        phi[i] = i

    # Compute other Phi values
    for p in range(2, n + 1):
        # If p is prime
        if phi[p] == p:
            phi[p] = p - 1

            for i in range(2 * p, n + 1, p):
                phi[i] = (phi[i] // p) * (p - 1)

    return phi


# Driver code
n = 12
phi = etf(n)

for i in range(1, n + 1):
    print("Totient of", i, "is", phi[i])

using System;

class GFG
{
    // Computes totient of all numbers from 1 to n
    static int[] etf(int n)
    {
        int[] phi = new int[n + 1];

        for (int i = 1; i <= n; i++)
            phi[i] = i;

        // Compute other Phi values
        for (int p = 2; p <= n; p++)
        {
            // If p is prime
            if (phi[p] == p)
            {
                phi[p] = p - 1;

                // Update multiples of p
                for (int i = 2 * p; i <= n; i += p)
                {
                    phi[i] = (phi[i] / p) * (p - 1);
                }
            }
        }

        return phi;
    }

    // Driver code
    public static void Main()
    {
        int n = 12;
        int[] phi = etf(n);

        for (int i = 1; i <= n; i++)
            Console.WriteLine("Totient of " + i + " is " + phi[i]);
    }
}

function etf(n)
{
    // Computes totient of all numbers from 1 to n
    let phi = new Array(n + 1);
    for (let i = 1; i <= n; i++)

        phi[i] = i;

    // Compute other Phi values
    for (let p = 2; p <= n; p++) {

        // If p is prime
        if (phi[p] == p) {

            phi[p] = p - 1;

            // Update multiples of p
            for (let i = 2 * p; i <= n; i += p) {

                phi[i] = parseInt(phi[i] / p, 10) * (p - 1);
            }
        }
    }

    return phi;
}

// Driver code
let n = 12;
let phi = etf(n);

for (let i = 1; i <= n; i++)
    console.log("Totient of " + i + " is " + phi[i]);

<?php 
// Computes totient of all numbers from 1 to n
function etf($n) 
{ 
    $phi = array();

    for($i = 1; $i <= $n; $i++) 
        $phi[$i] = $i; 

    // Compute other Phi values 
    for($p = 2; $p <= $n; $p++) 
    { 
        // If p is prime 
        if ($phi[$p] == $p) 
        { 
            
            $phi[$p] = $p - 1; 

            // Update multiples of p 
            for($i = 2 * $p; $i <= $n; $i += $p) 
            { 
                $phi[$i] = ($phi[$i] / $p) * ($p - 1); 
            } 
        } 
    } 

    return $phi;
} 

// Driver Code 
$n = 12; 
$phi = etf($n);

for($i = 1; $i <= $n; $i++) 
    echo "Totient of ", $i, " is ", $phi[$i], "\n"; 

?> 

Totient of 1 is 1
Totient of 2 is 1
Totient of 3 is 2
Totient of 4 is 2
Totient of 5 is 4
Totient of 6 is 2
Totient of 7 is 6
Totient of 8 is 4
Totient of 9 is 6
Totient of 10 is 4
Totient of 11 is 10...

Time Complexity: O(n log(log n))
Auxiliary Space: O(n)

Prime Factorization - O(sqrt(n)*log(n)) time and O(1) space

The sieve-based solution is useful when we have a large number of queries for computing the totient function.

For numbers upto n, we can use Prime Factorization.

\phi(n) = \prod_{i=1}^{k} p_i^{\alpha_i - 1} (p_i - 1)

This approach computes φ(n) using prime factorization instead of iterating over all numbers.

For example, φ(12) = { (2^(2-1)) x (2-1) } x { (3^(1-1)) x (3-1) } =4

Note that φ(n) = n - 1 if n is prime.

using namespace std;

int etf(int n)
{
    int res = 1;
    for (int i = 2; i * i <= n; i++)
    {
        int c = 0;
        if (n % i == 0)
        {
            while (n % i == 0)
            {
                c++;
                n /= i;
            }
        }
        if (c > 0)
        {
            int power = (int)pow(i, c - 1);
            int sm = (int)pow(i, c - 1) * (i - 1);
            res *= sm;
        }
    }
    if (n > 1)
    {
        res *= (n - 1);
    }
    return res;
}

// driver code
int main()
{
    for (int i = 1; i < 13; i++)
    {
        cout << "Totient of " << i << " is: ";
        cout << etf(i) << endl;
    }
}

class GFG {

    static int etf(int n)
    {
        int res = 1;
        for (int i = 2; i * i <= n; i++) {
            int c = 0;
            if (n % i == 0) {
                while (n % i == 0) {
                    c++;
                    n /= i;
                }
            }
            if (c > 0) {
                int power = (int)Math.pow(i, c - 1);
                int sm = (int)Math.pow(i, c - 1) * (i - 1);
                res *= sm;
            }
        }
        if (n > 1) {
            res *= (n - 1);
        }
        return res;
    }

    // Driver code
    public static void main(String[] args)
    {
        for (int i = 1; i < 13; i++) {
            System.out.print("Totient of " + i
                             + " is ");
            System.out.println(etf(i));
        }
    }
}

import math


def etf(n):
    res = 1
    for i in range(2, n + 1):
        c = 0
        if n % i == 0:
            while (n % i == 0):
                c += 1
                n //= i
        if (c > 0):
            power = math.pow(i, c - 1)
            m = math.pow(i, c - 1) * (i - 1)
            res *= m
    if (n > 1):
        res *= (n - 1)
    return int(res)


# Driver code
for i in range(1, 13):
    print("Totient of ", i, " is ", end="")
    print(etf(i))

// C# program for the above approach
using System;

class GFG {

    static int etf(int n)
    {
        int res = 1;
        for (int i = 2; i * i <= n; i++) {
            int c = 0;
            if (n % i == 0) {
                while (n % i == 0) {
                    c++;
                    n /= i;
                }
            }
            if (c > 0) {
                int sm
                    = (int)Math.Pow(i, c - 1) * (i - 1);
                res *= sm;
            }
        }
        if (n > 1) {
            res *= (n - 1);
        }
        return res;
    }

    // Driver code
    public static void Main()
    {
        for (int i = 1; i < 13; i++) {
            Console.Write("Totient of " + i
                          + " is ");
            Console.WriteLine(etf(i));
        }
    }
}

function etf(n)
{
    let res = 1;
    for (let i = 2; i * i <= n; i++) {
        let c = 0;
        if (n % i == 0) {
            while (n % i == 0) {
                c++;
                n = parseInt(n / i);
            }
        }
        if (c > 0) {
            let power = Math.pow(i, c - 1);
            let sm = Math.pow(i, c - 1) * (i - 1);
            res *= sm;
        }
    }
    if (n > 1) {
        res *= (n - 1);
    }
    return res;
}

// driver code
for (let i = 1; i < 13; i++) {
    console.log("Totient of " + i + " is ", etf(i));
}

Totient of 1 is: 1
Totient of 2 is: 1
Totient of 3 is: 2
Totient of 4 is: 2
Totient of 5 is: 4
Totient of 6 is: 2
Totient of 7 is: 6
Totient of 8 is: 4
Totient of 9 is: 6
Totient of 10 is: 4
Totient o...