Skip to content
Related Articles

Related Articles

Improve Article

Sum of product of all integers upto N with their count of divisors

  • Last Updated : 04 Aug, 2021
Geek Week

Given a positive integer N, the task is to find the sum of the product of all the integers in the range [1, N] with their count of divisors. 

Examples:

Input: N = 3
Output: 11
Explanation:
Number of positive divisors of 1 is 1( i.e. 1 itself). Therefore, f(1) = 1.
Number of positive divisors of 2 is 2( i.e. 1, 2). Therefore, f(2) = 2.
Number of positive divisors of 3 is 2( i.e. 1, 3). Therefore, f(3) = 2.
So the answer is 1*f(1) + 2*f(2) + 3*f(3) = 1*1 + 2*2 + 3*2 = 11.

Input: N = 4
Output: 23
Explanation:
Here f(1) = 1, f(2) = 2, f(3) = 2 and f(4) = 3. So, the answer is 1*1 + 2*2 + 3*2 + 4*3 = 23.

Naive Approach: The naive approach is to traverse from 1 to N and find the sum of all the numbers with their count of divisors.



Time Complexity: O(N*sqrt(N))
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to consider the total contribution each number makes to the answer. Below are the steps: 

  1. For any number X in the range [1, N], X contributes K to the sum for each K from 1 to N such that K is a multiple of X.
  2. Observe that the list of these K is of form i, 2i, 3i, …, Fi where F is the number of multiples of i between 1 and N.
  3. Hence, to find the sum of these numbers generated above is given by 
     

i*(1+2+3 + … F) = i*(F*(F+1))/2. 
 

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the sum of the
// product of all the integers and
// their positive divisors up to N
long long sumOfFactors(int N)
{
    long long ans = 0;
 
    // Iterate for every number
    // between 1 and N
    for (int i = 1; i <= N; i++) {
 
        // Find the first multiple
        // of i between 1 and N
        long long first = i;
 
        // Find the last multiple
        // of i between 1 and N
        long long last = (N / i) * i;
 
        // Find the total count of
        // multiple of in [1, N]
        long long factors
            = (last - first) / i + 1;
 
        // Compute the contribution of i
        // using the formula
        long long totalContribution
            = (((factors) * (factors + 1)) / 2) * i;
 
        // Add the contribution
        // of i to the answer
        ans += totalContribution;
    }
 
    // Return the result
    return ans;
}
 
// Driver code
int main()
{
    // Given N
    int N = 3;
 
    // function call
    cout << sumOfFactors(N);
}
Java



// Java program for the above approach
class GFG{
   
// Function to find the sum of the
// product of all the integers and
// their positive divisors up to N
static int sumOfFactors(int N)
{
    int ans = 0;
  
    // Iterate for every number
    // between 1 and N
    for (int i = 1; i <= N; i++)
    {
  
        // Find the first multiple
        // of i between 1 and N
        int first = i;
  
        // Find the last multiple
        // of i between 1 and N
        int last = (N / i) * i;
  
        // Find the total count of
        // multiple of in [1, N]
        int factors = (last - first) / i + 1;
  
        // Compute the contribution of i
        // using the formula
        int totalContribution = (((factors) *
                                  (factors + 1)) / 2) * i;
  
        // Add the contribution
        // of i to the answer
        ans += totalContribution;
    }
  
    // Return the result
    return ans;
}
  
// Driver code
public static void main(String[] args)
{
    // Given N
    int N = 3;
  
    // function call
    System.out.println(sumOfFactors(N));
}
}
 
// This code is contributed by Ritik Bansal
Python3



# Python3 implementation of
# the above approach
 
# Function to find the sum of the
# product of all the integers and
# their positive divisors up to N
def sumOfFactors(N):
 
    ans = 0
 
    # Iterate for every number
    # between 1 and N
    for i in range(1, N + 1):
 
        # Find the first multiple
        # of i between 1 and N
        first = i
 
        # Find the last multiple
        # of i between 1 and N
        last = (N // i) * i
 
        # Find the total count of
        # multiple of in [1, N]
        factors = (last - first) // i + 1
 
        # Compute the contribution of i
        # using the formula
        totalContribution = (((factors *
                              (factors + 1)) // 2) * i)
 
        # Add the contribution
        # of i to the answer
        ans += totalContribution
 
    # Return the result
    return ans
 
# Driver Code
 
# Given N
N = 3
 
# Function call
print(sumOfFactors(N))
 
# This code is contributed by Shivam Singh
C#



// C# program for the above approach
using System;
class GFG{
   
// Function to find the sum of the
// product of all the integers and
// their positive divisors up to N
static int sumOfFactors(int N)
{
    int ans = 0;
  
    // Iterate for every number
    // between 1 and N
    for (int i = 1; i <= N; i++)
    {
  
        // Find the first multiple
        // of i between 1 and N
        int first = i;
  
        // Find the last multiple
        // of i between 1 and N
        int last = (N / i) * i;
  
        // Find the total count of
        // multiple of in [1, N]
        int factors = (last - first) / i + 1;
  
        // Compute the contribution of i
        // using the formula
        int totalContribution = (((factors) *
                                  (factors + 1)) / 2) * i;
  
        // Add the contribution
        // of i to the answer
        ans += totalContribution;
    }
  
    // Return the result
    return ans;
}
  
// Driver code
public static void Main(String[] args)
{
    // Given N
    int N = 3;
  
    // function call
    Console.WriteLine(sumOfFactors(N));
}
}
 
// This code is contributed by gauravrajput1
Javascript



<script>
// javascript program for the above approach   
// Function to find the sum of the
    // product of all the integers and
    // their positive divisors up to N
    function sumOfFactors(N)
    {
        var ans = 0;
 
        // Iterate for every number
        // between 1 and N
        for (i = 1; i <= N; i++)
        {
 
            // Find the first multiple
            // of i between 1 and N
            var first = i;
 
            // Find the last multiple
            // of i between 1 and N
            var last = parseInt(N / i) * i;
 
            // Find the total count of
            // multiple of in [1, N]
            var factors = parseInt((last - first) / i )+ 1;
 
            // Compute the contribution of i
            // using the formula
            var totalContribution = parseInt(((factors) * (factors + 1)) / 2) * i;
 
            // Add the contribution
            // of i to the answer
            ans += totalContribution;
        }
 
        // Return the result
        return ans;
    }
 
    // Driver code
     
        // Given N
        var N = 3;
 
        // function call
        document.write(sumOfFactors(N));
 
// This code is contributed by todaysgaurav.
</script>
Output: 
11
 
Time Complexity: O(N)
Auxiliary Space: O(1)
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.



My Personal Notes
arrow_drop_up
Previous
Reduce a given Binary Array to a single element by removal of Triplets
Next

Minimize count of array elements to be removed to maximize difference between any pair up to K
Recommended Articles
Page :
Check if count of even divisors of N is equal to count of odd divisors
29, May 20
Check if a number has an odd count of odd divisors and even count of even divisors
20, Aug 20
Minimum value exceeding X whose count of divisors has different parity with count of divisors of X
18, Nov 20
Find sum of divisors of all the divisors of a natural number
21, Jan 17
Count permutations of all integers upto N that can form an acyclic graph based on given conditions
13, Oct 20
Find sum of inverse of the divisors when sum of divisors and the number is given
28, Jun 19
Sum of integers upto N with given unit digit
17, Dec 18
Sum of integers upto N with given unit digit (Set 2)
19, Dec 18
Count of pairs upto N such whose LCM is not equal to their product for Q queries
24, Apr 20
Sum of product of all subsets formed by only divisors of N
08, May 20
Sum of product of proper divisors of all Numbers lying in range [L, R]
26, Mar 20
Count of all values of N in [L, R] such that count of primes upto N is also prime
03, Jul 20
Divisors of n-square that are not divisors of n
11, Nov 17
Maximum possible prime divisors that can exist in numbers having exactly N divisors
07, May 20
Minimise N such that sum of count of all factors upto N is greater than or equal to X
28, Jun 20
Count number of integers less than or equal to N which has exactly 9 divisors
31, Oct 18
Count of integers up to N which are non divisors and non coprime with N
27, Jul 20
Count integers from a given range with no odd divisors
08, Feb 21
Count of divisors of product of an Array in range L to R for Q queries
17, Apr 20
Count set bits in Bitwise XOR of all adjacent elements upto N
11, Nov 20
Count numbers < = N whose difference with the count of primes upto them is > = K
19, Dec 18
Count all pairs of divisors of a number N whose sum is coprime with N
17, Jun 20
Sum of GCD of all numbers upto N with N itself
26, May 20
Maximize count of equal numbers in Array of numbers upto N by replacing pairs with their sum
28, Aug 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
aqibmahboob1999
@aqibmahboob1999
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox