# 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 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 numberint 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 numbersvoid 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 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 codeint main(){    int n = 20;         // Function call    Highly_Totient(n);     return 0;}

## Java

 // Java program to find highly totient numbersimport java.util.*; class GFG { // Function to find euler totient numberstatic 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 numbersstatic 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 codepublic 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 numberdef 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 numbersdef 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 codeif __name__=='__main__':     n = 20;         # Function call    Highly_Totient(n);         # This code is contributed by rutvik_56

## C#

 // C# program to find highly totient numbersusing System;using System.Collections.Generic;     class GFG { // Function to find euler totient numberstatic 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 numbersstatic 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 mp = new Dictionary();    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 codepublic static void Main(String[] args){    int n = 20;         // Function call    Highly_Totient(n);}} // This code is contributed by Rajput-Ji

## Javascript



Output:

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

Time Complexity: O(N), as we are using a loop to traverse N times. [ As O(N) > O(sqrt(N)*logN), as we using nested loops for traversing sqrt(N)*logN times ]

Auxiliary Space: O(100000), as we are using extra space for the map.

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