Related Articles

# Highly Totient Number

• Last Updated : 03 Feb, 2021

A highly totient number k is an integer that has more solutions to the equation φ(x) = k, where φ is Euler’s totient function
The sequence :

1, 2, 4, 8, 12, 24, 48, 72, 144, 240, 432, 480, 576, 720, 1152, 1440, 2880, 4320, 5760, 8640

Explanation :

• 1 has 2 solutions
• 2 has 3 solutions
• 4 has 4 solutions
• 8 has 5 solutions
• 12 has 6 solutions
• 24 has 10 solutions

For a given N, the task is to print first N highly totient numbers.
Examples:

Input : N = 10
Output : 1, 2, 4, 8, 12, 24, 48, 72, 144, 240
Input : N = 20
Output : 1, 2, 4, 8, 12, 24, 48, 72, 144, 240, 432, 480, 576, 720, 1152, 1440, 2880, 4320, 5760, 8640

Approach:
An efficient approach is to store all the values of φ(x) up to 105 in a map along with their frequencies and then run a loop from 1 until the count of Highly totient number is less than N. For each i we will check if the frequency of i is greater than the previous element, if yes then print the number and increase the count else increment the number .
Below is the implementation of the above approach :

## C++

 `// CPP program to find highly totient numbers``#include ``using` `namespace` `std;` `// Function to find euler totient number``int` `phi(``int` `n)``{``    ``int` `result = n; ``// Initialize result as 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;``}` `// Function to find first n highly totient numbers``void` `Highly_Totient(``int` `n)``{``    ``// Count of Highly totient numbers``    ``// and value of count of phi of previous numbers``    ``int` `count = 0, p_count = -1, i = 1;` `    ``// Store all the values of phi(x) upto``    ``// 10^5 with frequencies``    ``map<``int``, ``int``> mp;` `    ``for` `(``int` `i = 1; i < 100000; i++)``        ``mp[phi(i)]++;` `    ``while` `(count < n) {``        ` `        ``// If count is greater than count of``        ``// previous element``        ``if` `(mp[i] > p_count)``        ``{``            ``// Display the number``            ``cout << i;``            ` `            ``if``(count < n-1)``                ``cout << ``", "``;` `            ``// Store the value of phi``            ``p_count = mp[i];``            ``count++;``        ``}``        ``i++;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `n = 20;``    ` `    ``// Function call``    ``Highly_Totient(n);` `    ``return` `0;``}`

## Java

 `// Java program to find highly totient numbers``import` `java.util.*;` `class` `GFG``{` `// Function to find euler totient number``static` `int` `phi(``int` `n)``{``    ``int` `result = n; ``// Initialize result as 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;``}` `// Function to find first n highly totient numbers``static` `void` `Highly_Totient(``int` `n)``{``    ``// Count of Highly totient numbers``    ``// and value of count of phi of previous numbers``    ``int` `count = ``0``, p_count = -``1``;` `    ``// Store all the values of phi(x) upto``    ``// 10^5 with frequencies``    ``HashMap mp = ``new` `HashMap();` `    ``for` `(``int` `i = ``1``; i < ``100000``; i++)``    ``{``        ``if``(mp.containsKey(phi(i)))``        ``{``            ``mp.put(phi(i), mp.get(phi(i)) + ``1``);``        ``}``        ``else``        ``{``            ``mp.put(phi(i), ``1``);``        ``}``    ``}``    ` `    ``int` `i = ``1``;``    ``while` `(count < n)``    ``{``        ` `        ``// If count is greater than count of``        ``// previous element``        ``if` `(mp.containsKey(i)&&mp.get(i) > p_count)``        ``{``            ``// Display the number``            ``System.out.print(i);``            ` `            ``if``(count < n - ``1``)``                ``System.out.print(``", "``);` `            ``// Store the value of phi``            ``p_count = mp.get(i);``            ``count++;``        ``}``        ``i++;``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `n = ``20``;``    ` `    ``// Function call``    ``Highly_Totient(n);``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to find highly totient numbers` `# Function to find euler totient number``def` `phi(n):` `    ``result ``=` `n; ``# Initialize result as n` `    ``# Consider all prime factors of n and``    ``# subtract their multiples from result``    ``p ``=` `2` `    ``while``(p``*``p <``=` `n):` `        ``# 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);``        ``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;`  `# Function to find first n highly totient numbers``def` `Highly_Totient(n):` `    ``# Count of Highly totient numbers``    ``# and value of count of phi of previous numbers``    ``count ``=` `0``    ``p_count ``=` `-``1` `    ``# Store all the values of phi(x) upto``    ``# 10^5 with frequencies``    ``mp ``=` `dict``()``    ``i ``=` `1` `    ``while` `i < ``100000``:` `        ``tmp ``=` `phi(i)` `        ``if` `tmp ``not` `in` `mp:``            ``mp[tmp] ``=` `0``        ``mp[tmp] ``+``=` `1``;``        ``i ``+``=` `1``    ``i ``=` `1` `    ``while` `(count < n):``        ` `        ``# If count is greater than count of``        ``# previous element``        ``if` `((i ``in` `mp) ``and`  `mp[i] > p_count):` `            ``# Display the number``            ``print``(i, end ``=` `'');``            ` `            ``if``(count < n ``-` `1``):``                ``print``(``", "``, end ``=` `'');` `            ``# Store the value of phi``            ``p_count ``=` `mp[i];``            ``count ``+``=` `1``        ``i ``+``=` `1``    ` `# Driver code``if` `__name__``=``=``'__main__'``:` `    ``n ``=` `20``;``    ` `    ``# Function call``    ``Highly_Totient(n);``    ` `    ``# This code is contributed by rutvik_56`

## C#

 `// C# program to find highly totient numbers``using` `System;``using` `System.Collections.Generic;``    ` `class` `GFG``{` `// Function to find euler totient number``static` `int` `phi(``int` `n)``{``    ``int` `result = n; ``// Initialize result as 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;``}` `// Function to find first n highly totient numbers``static` `void` `Highly_Totient(``int` `n)``{``    ``// Count of Highly totient numbers``    ``// and value of count of phi of``    ``// previous numbers``    ``int` `count = 0, p_count = -1, i;` `    ``// Store all the values of phi(x) upto``    ``// 10^5 with frequencies``    ``Dictionary<``int``,``               ``int``> mp = ``new` `Dictionary<``int``,``                                        ``int``>();``    ``for` `(i = 1; i < 100000; i++)``    ``{``        ``if``(mp.ContainsKey(phi(i)))``        ``{``            ``mp[phi(i)] = mp[phi(i)] + 1;``        ``}``        ``else``        ``{``            ``mp.Add(phi(i), 1);``        ``}``    ``}``    ` `    ``i = 1;``    ``while` `(count < n)``    ``{``        ` `        ``// If count is greater than count of``        ``// previous element``        ``if` `(mp.ContainsKey(i)&&mp[i] > p_count)``        ``{``            ``// Display the number``            ``Console.Write(i);``            ` `            ``if``(count < n - 1)``                ``Console.Write(``", "``);` `            ``// Store the value of phi``            ``p_count = mp[i];``            ``count++;``        ``}``        ``i++;``    ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `n = 20;``    ` `    ``// Function call``    ``Highly_Totient(n);``}``}` `// This code is contributed by Rajput-Ji`

Output:

1, 2, 4, 8, 12, 24, 48, 72, 144, 240, 432, 480, 576, 720, 1152, 1440, 2880, 4320, 5760, 8640

This method cannot be used to find more than 1000 Highly totient number.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up