Minimise N such that sum of count of all factors upto N is greater than or equal to X

31 May, 2021
Given a number X, the task is to find the minimum number N such that the sum of the count of all factors from 1 to N is greater than equal to X.Examples:
Input: X = 10 Output: 5 Explanation: Total factors of 1 = 1 (1) Total factors of 2 = 2 (1, 2) Total factors of 3 = 2 (1, 3) Total factors of 4 = 3 (1, 2, 4) Total factors of 5 = 2 (1, 5) Total count = 1 + 2 + 2 + 3 + 2 = 10 which is is greater than or equal to X i.e., 10Input: X = 19 Output: 8 Explanation: Total factors of 1 = 1 (1) Total factors of 2 = 2 (1, 2) Total factors of 3 = 2 (1, 3) Total factors of 4 = 3 (1, 2, 4) Total factors of 5 = 2 (1, 5) Total factors of 6 = 2 (1, 2, 3, 6) Total factors of 7 = 2 (1, 7) Total factors of 8 = 2 (1, 2, 4, 8) Total count = 1 + 2 + 2 + 3 + 2 + 4 + 2 + 4 = 20 which is greater than or equal to X i.e., 19  
Naive Approach: The naive approach is to run a loop starting from 1 until the total count of factor is greater than equal to X.Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ program for the above approach #include <bits/stdc++.h>using namespace std; #define MAX 1000050#define lli long int // Function to count total factors of Nlli CountFactors(lli N){    lli cnt = 0;    for (lli i = 1;         i * i <= N; i++) {         if (N % i == 0)            cnt += ((N / i == i) ? 1 : 2);    }     // Return the count    return cnt;} // Function to search lowest N// such that the given condition// is satisfiedlli minN(lli X){    lli i = 1;    lli total = 0;     while (1) {         // Add the count of total factor        // of i to variable total        total = total + CountFactors(i);         // If total count is greater than        // equal to N, then return i        if (total >= X)            return i;        i++;    }} // Driver Codeint main(){    // Given sum    lli X = 10;     // Function Call    cout << minN(X) << endl;     return 0;}
// Java program for the above approachclass GFG{ static final int MAX = 1000050; // Function to count total factors of Nstatic int CountFactors(int N){    int cnt = 0;    for(int i = 1; i * i <= N; i++)    {       if (N % i == 0)           cnt += ((N / i == i) ? 1 : 2);    }     // Return the count    return cnt;} // Function to search lowest N// such that the given condition// is satisfiedstatic int minN(int X){    int i = 1;    int total = 0;     while (true)    {                 // Add the count of total factor        // of i to variable total        total = total + CountFactors(i);         // If total count is greater than        // equal to N, then return i        if (total >= X)            return i;        i++;    }} // Driver Codepublic static void main(String[] args){         // Given sum    int X = 10;     // Function Call    System.out.print(minN(X) + "\n");}} // This code is contributed by PrinciRaj1992
# Python3 program for# the above approachMAX = 1000050 # Function to count# total factors of Ndef CountFactors(N):     cnt = 0    i = 1    while i * i <= N:         if (N % i == 0):            if (N // i == i):                cnt +=  1            else:                cnt +=  2        i += 1       # Return the count    return cnt # Function to search lowest N# such that the given condition# is satisfieddef minN(X):     i = 1    total = 0     while (1):         # Add the count of total factor        # of i to variable total        total = total + CountFactors(i)         # If total count is greater than        # equal to N, then return i        if (total >= X):            return i        i += 1 # Driver Codeif __name__ == "__main__":     # Given sum    X = 10     # Function Call    print( minN(X)) # This code is contributed by Chitranayal
// C# program for the above approachusing System; class GFG{  //static readonly int MAX = 1000050;  // Function to count total factors of Nstatic int CountFactors(int N){    int cnt = 0;    for(int i = 1; i * i <= N; i++)    {       if (N % i == 0)           cnt += ((N / i == i) ? 1 : 2);    }      // Return the count    return cnt;}  // Function to search lowest N// such that the given condition// is satisfiedstatic int minN(int X){    int i = 1;    int total = 0;      while (true)    {                  // Add the count of total factor        // of i to variable total        total = total + CountFactors(i);          // If total count is greater than        // equal to N, then return i        if (total >= X)            return i;        i++;    }}  // Driver Codepublic static void Main(String[] args){          // Given sum    int X = 10;      // Function Call    Console.Write(minN(X) + "\n");}} // This code is contributed by PrinciRaj1992
<script> // javascript program for the above approachstatic final var MAX = 1000050; // Function to count total factors of Nfunction CountFactors(N){    var cnt = 0;    for(i = 1; i * i <= N; i++)    {       if (N % i == 0)           cnt += ((N / i == i) ? 1 : 2);    }     // Return the count    return cnt;} // Function to search lowest N// such that the given condition// is satisfiedfunction minN(X){    var i = 1;    var total = 0;     while (true)    {                 // Add the count of total factor        // of i to variable total        total = total + CountFactors(i);         // If total count is greater than        // equal to N, then return i        if (total >= X)            return i;        i++;    }} // Driver Code//Given sumvar X = 10; // Function Calldocument.write(minN(X) + "\n"); // This code is contributed by 29AjayKumar</script>
5
 
Time Complexity: O(N*sqrt(N)) Auxiliary Space: O(1)Efficient Approach: The above approach can be optimized by doing some precomputation. Below are the steps:  
Calculate and store the smallest prime factor of each number (SPF) using the approach discussed in this article.Find the count of factors of N efficiently, using Sieve of Eratosthenes and the above calculated smallest prime factor.Create a prefix sum array to store the sum of the count of factors from 1 to MAX.To find the lowest N such that the above condition satisfied, instead of linear search in prefix array perform a binary search on the prefix sum array (as the prefix sum array will be in increasing order), so that time complexity will be optimal for multiple queries also.
Calculate and store the smallest prime factor of each number (SPF) using the approach discussed in this article.
Find the count of factors of N efficiently, using Sieve of Eratosthenes and the above calculated smallest prime factor.
Create a prefix sum array to store the sum of the count of factors from 1 to MAX.
To find the lowest N such that the above condition satisfied, instead of linear search in prefix array perform a binary search on the prefix sum array (as the prefix sum array will be in increasing order), so that time complexity will be optimal for multiple queries also.
Below is the implementation of the above approach:  
C++
Java
Python3
C#
Javascript
// C++ program for the above approach #include <bits/stdc++.h>using namespace std; #define MAX 1000050#define lli long int // Array to store smallest// prime factors of each no.lli spf[MAX + 1]; // Function to calculate smallest// prime factor of N.void calculate_SPF(){    for (lli i = 0; i <= MAX; i++)        spf[i] = i;     for (lli i = 4; i <= MAX; i += 2)        spf[i] = 2;     for (lli i = 3;         i * i <= MAX; i++) {         if (spf[i] == i) {            for (int j = i * i;                 j <= MAX; j += i)                 // marking spf[j] if                // it is not previously                // marked                if (spf[j] == j)                    spf[j] = i;        }    }} // Array to store the count of// factor for Nlli tfactor[MAX + 1]; // Prefix array which contains// the count of factors from 1 to Nlli pre[MAX + 1]; // Function to count total factors// from 1 to Nvoid CountTotalfactors(){    tfactor[1] = pre[1] = 1;     for (lli i = 2; i <= MAX; i++) {         lli mspf = spf[i];        lli prim = mspf;        lli temp = i;        lli cnt = 0;         while (temp % mspf == 0) {            temp /= mspf;            cnt += 1;            prim = prim * mspf;        }         // Store total factors of i        tfactor[i] = (cnt + 1)                     * tfactor[temp];         // Stores total factors        // from 1 to i        pre[i] = pre[i - 1]                 + tfactor[i];    }} // Function to search lowest X// such that the given condition// is satisfiedlli BinarySearch(lli X){    lli start = 1;    lli end = MAX - 1;     while (start < end) {         // Find mid        lli mid = (start + end) / 2;         if (pre[mid] == X)            return mid;         // Search in the right half        else if (pre[mid] < X)            start = mid + 1;         // Search in the left half        else            end = mid;    }     // Return the position after    // Binary Search    return start;} // Function to find the required sumvoid findSumOfCount(int X){     // Precompute smallest prime    // factor of each value    calculate_SPF();     // Calculate count of total    // factors from 1 to N    CountTotalfactors();     // Binary search to find minimum N    cout << BinarySearch(X)         << endl;} // Driver Codeint main(){    // Given Sum    int X = 10;     // Function Call    findSumOfCount(X);     return 0;}
// Java program for the above approachimport java.util.*; class GFG{ static final int MAX = 1000050; // Array to store smallest// prime factors of each no.static int []spf = new int[MAX + 1]; // Function to calculate smallest// prime factor of N.static void calculate_SPF(){    for(int i = 0; i <= MAX; i++)       spf[i] = i;     for(int i = 4; i <= MAX; i += 2)       spf[i] = 2;     for(int i = 3; i * i <= MAX; i++)    {       if (spf[i] == i)       {           for(int j = i * i;                   j <= MAX; j += i)                          // marking spf[j] if              // it is not previously              // marked              if (spf[j] == j)                  spf[j] = i;       }    }} // Array to store the count of// factor for Nstatic int []tfactor = new int[MAX + 1]; // Prefix array which contains// the count of factors from 1 to Nstatic int []pre = new int[MAX + 1]; // Function to count total factors// from 1 to Nstatic void CountTotalfactors(){    tfactor[1] = pre[1] = 1;     for(int i = 2; i <= MAX; i++)    {       int mspf = spf[i];       int prim = mspf;       int temp = i;       int cnt = 0;               while (temp % mspf == 0)       {           temp /= mspf;           cnt += 1;           prim = prim * mspf;       }               // Store total factors of i       tfactor[i] = (cnt + 1) * tfactor[temp];               // Stores total factors       // from 1 to i       pre[i] = pre[i - 1] + tfactor[i];    }} // Function to search lowest X// such that the given condition// is satisfiedstatic int BinarySearch(int X){    int start = 1;    int end = MAX - 1;     while (start < end)    {                 // Find mid        int mid = (start + end) / 2;         if (pre[mid] == X)            return mid;         // Search in the right half        else if (pre[mid] < X)            start = mid + 1;         // Search in the left half        else            end = mid;    }     // Return the position after    // Binary Search    return start;} // Function to find the required sumstatic void findSumOfCount(int X){     // Precompute smallest prime    // factor of each value    calculate_SPF();     // Calculate count of total    // factors from 1 to N    CountTotalfactors();     // Binary search to find minimum N    System.out.print(BinarySearch(X) + "\n");} // Driver Codepublic static void main(String[] args){         // Given Sum    int X = 10;     // Function Call    findSumOfCount(X);}} // This code is contributed by PrinciRaj1992
# Python3 program for the# above approachMAX = 1000050  # Array to store smallest# prime factors of each no.spf = [0 for i in range(MAX + 1)]  # Function to calculate smallest# prime factor of N.def calculate_SPF():         for i in range(MAX + 1):        spf[i] = i;         for i in range(4, MAX + 1, 2):        spf[i] = 2;         i = 3          while(i * i <= MAX):           if (spf[i] == i)                       j = i * i                         while(j <= MAX):                  # Marking spf[j] if                # it is not previously                # marked                if (spf[j] == j):                    spf[j] = i;                                 j += i        i += 1                # Array to store the# count of factor for Ntfactor = [0 for i in range(MAX + 1)]  # Prefix array which contains# the count of factors from 1 to Npre = [0 for i in range(MAX + 1)]  # Function to count# total factors from 1 to Ndef CountTotalfactors():     tfactor[1] = pre[1] = 1;         for i in range(2, MAX + 1):        mspf = spf[i];        prim = mspf;        temp = i;        cnt = 0;          while (temp % mspf == 0):            temp //= mspf;            cnt += 1;            prim = prim * mspf;          # Store total factors of i        tfactor[i] = (cnt + 1) *                      tfactor[temp];          # Stores total factors        # from 1 to i        pre[i] = pre[i - 1] +                 tfactor[i];    # Function to search lowest X# such that the given condition# is satisfieddef BinarySearch(X):     start = 1;    end = MAX - 1;      while (start < end):          # Find mid        mid = (start + end) // 2;          if (pre[mid] == X):            return mid;          # Search in the right half        elif (pre[mid] < X):            start = mid + 1;          # Search in the left half        else:            end = mid;         # Return the position after    # Binary Search    return start; # Function to find the# required sumdef findSumOfCount(X):      # Precompute smallest prime    # factor of each value    calculate_SPF();      # Calculate count of total    # factors from 1 to N    CountTotalfactors();      # Binary search to find    # minimum N    print(BinarySearch(X))     # Driver codeif __name__ == "__main__":         # Given Sum    X = 10;      # Function Call    findSumOfCount(X);         # This code is contributed by rutvik_56
// C# program for the above approachusing System;class GFG{ const int MAX = 1000050; // Array to store smallest// prime factors of each no.static int []spf = new int[MAX + 1]; // Function to calculate smallest// prime factor of N.static void calculate_SPF(){    for(int i = 0; i <= MAX; i++)    spf[i] = i;     for(int i = 4; i <= MAX; i += 2)    spf[i] = 2;     for(int i = 3; i * i <= MAX; i++)    {        if (spf[i] == i)        {            for(int j = i * i;                    j <= MAX; j += i)                                 // marking spf[j] if                // it is not previously                // marked                if (spf[j] == j)                    spf[j] = i;        }    }} // Array to store the count of// factor for Nstatic int []tfactor = new int[MAX + 1]; // Prefix array which contains// the count of factors from 1 to Nstatic int []pre = new int[MAX + 1]; // Function to count total factors// from 1 to Nstatic void CountTotalfactors(){    tfactor[1] = pre[1] = 1;     for(int i = 2; i <= MAX; i++)    {        int mspf = spf[i];        int prim = mspf;        int temp = i;        int cnt = 0;                     while (temp % mspf == 0)        {            temp /= mspf;            cnt += 1;            prim = prim * mspf;        }                     // Store total factors of i        tfactor[i] = (cnt + 1) * tfactor[temp];                     // Stores total factors        // from 1 to i        pre[i] = pre[i - 1] + tfactor[i];    }} // Function to search lowest X// such that the given condition// is satisfiedstatic int BinarySearch(int X){    int start = 1;    int end = MAX - 1;     while (start < end)    {                 // Find mid        int mid = (start + end) / 2;         if (pre[mid] == X)            return mid;         // Search in the right half        else if (pre[mid] < X)            start = mid + 1;         // Search in the left half        else            end = mid;    }     // Return the position after    // Binary Search    return start;} // Function to find the required sumstatic void findSumOfCount(int X){     // Precompute smallest prime    // factor of each value    calculate_SPF();     // Calculate count of total    // factors from 1 to N    CountTotalfactors();     // Binary search to find minimum N    Console.Write(BinarySearch(X) + "\n");} // Driver Codepublic static void Main(){         // Given Sum    int X = 10;     // Function Call    findSumOfCount(X);}} // This code is contributed by Code_Mech
<script> // JavaScript program for the above approach var MAX = 1000050; // Array to store smallest// prime factors of each no.var spf = Array(MAX+1); // Function to calculate smallest// prime factor of N.function calculate_SPF(){    for (var i = 0; i <= MAX; i++)        spf[i] = i;     for (var i = 4; i <= MAX; i += 2)        spf[i] = 2;     for (var i = 3;         i * i <= MAX; i++) {         if (spf[i] == i) {            for (var j = i * i;                 j <= MAX; j += i)                 // marking spf[j] if                // it is not previously                // marked                if (spf[j] == j)                    spf[j] = i;        }    }} // Array to store the count of// factor for Nvar tfactor = Array(MAX+1); // Prefix array which contains// the count of factors from 1 to Nvar pre = Array(MAX+1); // Function to count total factors// from 1 to Nfunction CountTotalfactors(){    tfactor[1] = pre[1] = 1;     for (var i = 2; i <= MAX; i++) {         var mspf = spf[i];        var prim = mspf;        var temp = i;        var cnt = 0;         while (temp % mspf == 0) {            temp = parseInt(temp/mspf);            cnt += 1;            prim = prim * mspf;        }         // Store total factors of i        tfactor[i] = (cnt + 1)                     * tfactor[temp];         // Stores total factors        // from 1 to i        pre[i] = pre[i - 1]                 + tfactor[i];    }} // Function to search lowest X// such that the given condition// is satisfiedfunction BinarySearch(X){    var start = 1;    var end = MAX - 1;     while (start < end) {         // Find mid        var mid = parseInt((start + end) / 2);         if (pre[mid] == X)            return mid;         // Search in the right half        else if (pre[mid] < X)            start = mid + 1;         // Search in the left half        else            end = mid;    }     // Return the position after    // Binary Search    return start;} // Function to find the required sumfunction findSumOfCount( X){     // Precompute smallest prime    // factor of each value    calculate_SPF();     // Calculate count of total    // factors from 1 to N    CountTotalfactors();     // Binary search to find minimum N    document.write( BinarySearch(X) + "<br>");} // Driver Code // Given Sumvar X = 10; // Function CallfindSumOfCount(X); </script>
5
 
Time Complexity: O(MAX*log(MAX)) Auxiliary Space: O(MAX)Note: If there are Q queries, then the time complexity of finding N for all the Q queries will be O(Q*log(MAX)).
princiraj1992
Code_Mech
nidhi_biet
ukasp
rutvik_56
29AjayKumar
itsok
Binary Search
factor
prefix-sum
Prime Number
prime-factor
sieve
Arrays
Competitive Programming
Mathematical
prefix-sum
Arrays
Mathematical
Prime Number
sieve
Binary Search
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
Search, insert and delete in an unsorted array
Window Sliding Technique
Longest Consecutive Subsequence
Chocolate Distribution Problem
Competitive Programming - A Complete Guide
Practice for cracking any coding interview
Arrow operator -> in C/C++ with Examples
Modulo 10^9+7 (1000000007)
Fast I/O for Competitive Programming