# Highly Totient Number

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 **10 ^{5}** 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 <bits/stdc++.h> ` `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; ` `} ` |

*chevron_right*

*filter_none*

## 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<Integer, ` ` ` `Integer> mp = ` `new` `HashMap<Integer, ` ` ` `Integer>(); ` ` ` ` ` `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 ` |

*chevron_right*

*filter_none*

**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.

## Recommended Posts:

- Euler's Totient Function
- Euler's Totient function for all numbers smaller than or equal to n
- Optimized Euler Totient Function for Multiple Evaluations
- Count integers in a range which are divisible by their euler totient value
- Count number of trailing zeros in Binary representation of a number using Bitset
- Find minimum number to be divided to make a number a perfect square
- Count number of triplets with product equal to given number with duplicates allowed
- Find the number of positive integers less than or equal to N that have an odd number of digits
- Given number of matches played, find number of teams in tournament
- Number of possible permutations when absolute difference between number of elements to the right and left are given
- Number of ways to split a binary number such that every part is divisible by 2
- Number of times the largest perfect square number can be subtracted from N
- Count the number of operations required to reduce the given number
- Find the number of integers x in range (1,N) for which x and x+1 have same number of divisors
- Find the number of jumps to reach X in the number line from zero

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.