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⁵ 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;
}

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

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

Javascript

<script>
// javascript program to find highly totient numbers

    // Function to find euler totient number
    function phi(n) {
        var result = n; // Initialize result as n

        // Consider all prime factors of n and
        // subtract their multiples from result
        for (var 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
    function Highly_Totient(n)
    {

        // Count of Highly totient numbers
        // and value of count of phi of previous numbers
        var count = 0, p_count = -1;

        // Store all the values of phi(x) upto
        // 10^5 with frequencies
        var mp = new Map();

        for (i = 1; i < 100000; i++) {
            if (mp.has(phi(i))) {
                mp.set(phi(i), mp.get(phi(i)) + 1);
            } else {
                mp.set(phi(i), 1);
            }
        }

        var i = 1;
        while (count < n) {

            // If count is greater than count of
            // previous element
            if (mp.has(i) && mp.get(i) > p_count)
            {

                // Display the number
                document.write(i);

                if (count < n - 1)
                    document.write(", ");

                // Store the value of phi
                p_count = mp.get(i);
                count++;
            }
            i++;
        }
    }

    // Driver code
        var n = 20;

        // Function call
        Highly_Totient(n);

// This code is contributed by gauravrajput1
</script>

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.