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 :
// 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 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 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# 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 |
<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.