Euler's Totient Function

Last Updated : 21 Jun, 2025

Given an integer n, find the value of Euler's Totient Function, denoted as Φ(n). The function Φ(n) represents the count of positive integers less than or equal to n that are relatively prime to n.

Euler's Totient function Φ(n) for an input n is the count of numbers in {1, 2, 3, ..., n-1} that are relatively prime to n, i.e., the numbers whose GCD (Greatest Common Divisor) with n is 1.
If n is a positive integer and its prime factorization is; n = p_1^{e_1} \cdot p_2^{e_2} \cdot \ldots \cdot p_k^{e_k}
Where p_1, p_2, \ldots, p_k are distinct prime factors of n, then:
\phi(n) = n \cdot \left(1 - \frac{1}{p_1}\right) \cdot \left(1 - \frac{1}{p_2}\right) \cdot \ldots \cdot \left(1 - \frac{1}{p_k}\right).

Examples:

Input: n = 11
Output: 10
Explanation: From 1 to 11, 1,2,3,4,5,6,7,8,9,10 are relatively prime to 11.
Input: n = 16
Output: 8
Explanation: From 1 to 16, 1,3,5,7,9,11,13,15 are relatively prime to 16.

Table of Content

[Naive Approach] Iterative GCD Method

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.

C++

#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 result = 1;      for (int i = 2; i < n; i++)          if (gcd(i, n) == 1)              result++;      return result;  }   // Driver Code int main() {      int n = 11;      cout << etf(n);     return 0;  }

Java

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 result = 1;         for (int i = 2; i < n; i++) {             if (gcd(i, n) == 1)                 result++;         }         return result;     }  // Driver Code     public static void main(String[] args) {         int n = 11;         System.out.println(etf(n));     } }

Python

# 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):     result = 1     for i in range(2, n):         if gcd(i, n) == 1:             result += 1     return result  # Driver Code     if __name__ == "__main__":     n = 11     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 result = 1;         for (int i = 2; i < n; i++){             if (gcd(i, n) == 1)                 result++;         }         return result;     }  // Driver Code     static void Main(){         int n = 11;         Console.WriteLine(etf(n));     } }

JavaScript

// 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 result = 1;     for (let i = 2; i < n; i++) {         if (gcd(i, n) === 1)             result++;     }     return result; }  // Driver Code let n = 11; console.log(etf(n));

Output

Time Complexity: O(n log n)
Auxiliary Space: O(log min(a,b)) where a,b are the parameters of gcd function.

[Expected Approach] Euler’s Product Formula

The idea is based on Euler's product formula which states that the value of totient functions is below the product overall prime factors p of n.

Euler's-Product-Formula

1) Initialize result as n
2) Consider every number 'p' (where 'p' varies from 2 to Φ(n)).
If p divides n, then do following
a) Subtract all multiples of p from 1 to n [all multiples of p
will have gcd more than 1 (at least p) with n]
b) Update n by repeatedly dividing it by p.
3) If the reduced n is more than 1, then remove all multiples
of n from result.

C++

#include <iostream>  using namespace std;  int etf(int n){          int result = n;      // Consider all prime factors of n      // and subtract their multiples      // from result     for (int p = 2; p * p <= n; ++p)     {         // Check if p is a prime factor.         if (n % p == 0)         {             // If yes, then update n and result             while (n % p == 0)                 n /= p;              result -= result / p;         }     }      // If n has a prime factor greater than sqrt(n)     // (There can be at-most one such prime factor)     if (n > 1)         result -= result / n;      return result; }  // Driver Code int main() {     int n = 11;     cout << etf(n);     return 0; }

Java

class GfG {      static int etf(int n) {                  int result = n;          // Consider all prime factors of n          // and subtract their multiples          // from result         for (int p = 2; p * p <= n; ++p) {                         if (n % p == 0) {                 while (n % p == 0)                     n /= p;                  result -= result / p;             }         }          // If n has a prime factor greater than sqrt(n)         // (There can be at-most one such prime factor)         if (n > 1)             result -= result / n;          return result;     }  // Driver Code     public static void main(String[] args) {         int n = 11;         System.out.println(etf(n));     } }

Python

def etf(n):          result = n      # Consider all prime factors of n      # and subtract their multiples      # from result     p = 2     while p * p <= n:                  if n % p == 0:             while n % p == 0:                 n //= p              result -= result // p         p += 1      # If n has a prime factor greater than sqrt(n)     # (There can be at-most one such prime factor)     if n > 1:         result -= result // n      return result  # Driver Code   if __name__ == "__main__":     n = 11     print(etf(n))

using System;  class GfG {     static int etf(int n) {                  int result = n;          // Consider all prime factors of n          // and subtract their multiples          // from result         for (int p = 2; p * p <= n; ++p) {                          // Check if p is a prime factor.             if (n % p == 0) {                                  // If yes, then update n and result                 while (n % p == 0)                     n /= p;                  result -= result / p;             }         }          // If n has a prime factor greater than sqrt(n)         // (There can be at-most one such prime factor)         if (n > 1)             result -= result / n;          return result;     }  // Driver Code     static void Main()     {         int n = 11;         Console.WriteLine(etf(n));     } }

JavaScript

function etf(n) {          let result = n;      // Consider all prime factors of n      // and subtract their multiples      // from result     for (let p = 2; p * p <= n; ++p) {         if (n % p === 0) {                         while (n % p === 0)                 n = Math.floor(n / p);              result -= Math.floor(result / p);         }     }      // If n has a prime factor greater than sqrt(n)     // (There can be at-most one such prime factor)     if (n > 1)         result -= Math.floor(result / n);      return result; }  // Driver Code const n = 11; console.log(etf(n));

Output

Time Complexity: O(√n)
Auxiliary Space: O(1)

Some Interesting Properties of Euler's Totient Function

1) For a prime number p, \phi(p) = p - 1

Proof :

\phi(p) = p - 1 , where p is any prime number
We know that gcd(p, k) = 1 where k is any random number and k \neq p
\\Total number from 1 to p = p
Number for which gcd(p, k) = 1 is 1, i.e the number p itself, so subtracting 1 from p \phi(p) = p - 1

Examples :

\phi(5) = 5 - 1 = 4\\\phi(13) = 13 - 1 = 12\\\phi(29) = 29 - 1 = 28.

2) For two prime numbers a and b \phi(a \cdot b) = \phi(a) \cdot \phi(b) = (a - 1) \cdot (b - 1) , used in RSA Algorithm

Proof :

Let a and b be distinct primes.
Then:
ϕ(a)=a−1, ϕ(b)=b−1
Total numbers from 1 to ab: ab
Multiples of a: b numbers
Multiples of b: a numbers
Common multiple (i.e., double-counted): only ab
So, numbers not coprime to ab:
a+b−1
Then,
ϕ(ab) = ab − (a + b − 1) = ab − a − b + 1 = (a−1)(b−1)
Hence,
ϕ(ab) = ϕ(a)* ϕ(b)

Examples :

ϕ(5⋅7) = ϕ(5)⋅ϕ(7) = (5−1) (7−1) = 4⋅6 = 24
ϕ(3⋅5) = ϕ(3)⋅ϕ(5) = (3−1) (5−1) = 2⋅4 = 8
ϕ(3⋅7) = ϕ(3)⋅ϕ(7) = (3−1) (7−1) = 2⋅6 = 12

3) For a prime number p and integer k ≥ 1:

ϕ(p^k) = p^k−p^k−1

Proof :

\phi(p^k) = p ^ k - p ^{k - 1} , where p is a prime number\\Total numbers from 1 to p ^ k = p ^ k Total multiples of p = \frac {p ^ k} {p} = p ^ {k - 1}
Removing these multiples as with them gcd \neq 1\\

Examples :

p = 2, k = 5, p ^ k = 32
Multiples of 2 (as with them gcd \neq 1) = 32 / 2 = 16\\\phi(p ^ k) = p ^ k - p ^ {k - 1}.

4) Special Case : gcd(a, b) = 1

\phi(a \cdot b) = \phi(a) \cdot \phi(b) \cdot \frac {1} {\phi(1)} = \phi(a) \cdot \phi(b).

Examples :

Special Case:

gcd(a, b) = 1, \phi(a \cdot b) = \phi(a) \cdot \phi(b)\phi(2 \cdot 9) = \phi(2) \cdot \phi(9) = 1 \cdot 6 = 6\\\phi(8 \cdot 9) = \phi(8) \cdot \phi(9) = 4 \cdot 6 = 24\\\phi(5 \cdot 6) = \phi(5) \cdot \phi(6) = 4 \cdot 2 = 8

Normal Case:

gcd(a, b) \neq 1, \phi(a \cdot b) = \phi(a) \cdot \phi(b) \cdot \frac {gcd(a, b)} {\phi(gcd(a, b))}\\\phi(4 \cdot 6) = \phi(4) \cdot \phi(6) \cdot \frac {gcd(4, 6)} {\phi(gcd(4, 6))}= 2 \cdot 2 \cdot \frac{2}{1}= 2 \cdot 2 \cdot 2 = 8\\\phi(4 \cdot 8) = \phi(4) \cdot \phi(8) \cdot \frac {gcd(4, 8)} {\phi(gcd(4, 8))} = 2 \cdot 4 \cdot \frac{4}{2} = 2 \cdot 4 \cdot 2 = 16\\\phi(6 \cdot 8) = \phi(6) \cdot \phi(8) \cdot \frac {gcd(6, 8)} {\phi(gcd(6, 8))} = 2 \cdot 4 \cdot \frac{2}{1} = 2 \cdot 4 \cdot 2 = 16.

5) Sum of values of totient functions of all divisors of n is equal to n.

gausss

Example :

n = 6 , factors = {1, 2, 3, 6}
n = \phi(1) + \phi(2) + \phi(3) + \phi(6) = 1 + 1 + 2 + 2 = 6

6) The most famous and important feature is expressed in Euler's theorem :

The theorem states that if n and a are coprime
(or relatively prime) positive integers, then

a^Φ(n) Φ 1 (mod n)

The RSA cryptosystem is based on this theorem:
In the particular case when m is prime say p, Euler's theorem turns into the so-called Fermat's little theorem :

a^p-1 Φ 1 (mod p)

kartik

Improve

Article Tags :

Practice Tags :

Euler's Totient Function

[Naive Approach] Iterative GCD Method

[Expected Approach] Euler’s Product Formula

Some Interesting Properties of Euler's Totient Function

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem