Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Sum of numbers in a range [L, R] whose count of divisors is prime

  • Difficulty Level : Medium
  • Last Updated : 21 Apr, 2021

Given Q queries where each query consists of an integer range [L, R], the task is to find the sum of the integers from the given range whose count of divisors is prime.
Examples: 
 

Input: Q[][] = {{2, 4}} 
Output: 

All the numbers in the range have only 2 divisors 
which is prime. 
(2 + 3 + 4) = 9.
Input: Q[][] = {{15, 17}, {2, 12}} 
Output: 
33 
41 
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

 

Approach: Find all the prime numbers and the count of divisors for each element up to a limit N using Sieve of Eratosthenes. Now create a prefix sum array sum[] where sum[i] will store the sum of elements from the range [0, i] whose count of divisors is prime using the Sieve array created earlier. Now every query can be answered in O(1) as sum[r] – sum[l – 1].
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
 
// prime[i] stores 1 if i is prime
int prime[N];
 
// divi[i] stores the count of
// divisors of i
int divi[N];
 
// sum[i] will store the sum of all
// the integers from 0 to i whose
// count of divisors is prime
int sum[N];
 
// Function for Sieve of Eratosthenes
void SieveOfEratosthenes()
{
    // Create a boolean array "prime[0..n]" and initialize
    // all entries it as true. A value in prime[i] will
    // finally be 0 if i is Not a prime, else true.
    for (int i = 0; i < N; i++)
        prime[i] = 1;
 
    // 0 and 1 is not prime
    prime[0] = prime[1] = 0;
 
    for (int p = 2; p * p < N; p++) {
 
        // If prime[p] is not changed, then it is a prime
        if (prime[p] == 1) {
 
            // Update all multiples of p greater than or
            // equal to the square of it
            // numbers which are multiple of p and are
            // less than p^2 are already been marked.
            for (int i = p * p; i < N; i += p)
                prime[i] = 0;
        }
    }
}
 
// Function to count the divisors
void DivisorCount()
{
 
    // For each number i we will go to each of
    // the multiple of i and update the count
    // of divisor of its multiple j as i is one
    // of the factor of j
    for (int i = 1; i < N; i++) {
        for (int j = i; j < N; j += i) {
            divi[j]++;
        }
    }
}
 
// Function for pre-computation
void pre()
{
    for (int i = 1; i < N; i++) {
 
        // If count of divisors of i is prime
        if (prime[divi[i]] == 1) {
            sum[i] = i;
        }
    }
 
    // taking prefix sum
    for (int i = 1; i < N; i++)
        sum[i] += sum[i - 1];
}
 
// Driver code
int main()
{
 
    int l = 5, r = 8;
 
    // Find all the prime numbers till N
    SieveOfEratosthenes();
 
    // Update the count of divisors
    // of all the numbers till N
    DivisorCount();
 
    // Precomputation for the prefix sum array
    pre();
 
    // Perform query
    cout << sum[r] - sum[l - 1];
 
    return 0;
}

Java




//Java implementation of above approach
import java.util.*;
class GFG
{
     
static int N = 100000;
 
// prime[i] stores 1 if i is prime
static int prime[] = new int[N];
 
// divi[i] stores the count of
// divisors of i
static int divi[] = new int[N];
 
// sum[i] will store the sum of all
// the integers from 0 to i whose
// count of divisors is prime
static int sum[] = new int[N];
 
// Function for Sieve of Eratosthenes
static void SieveOfEratosthenes()
{
    // Create a boolean array "prime[0..n]" and
    // initialize all entries it as true.
    // A value in prime[i] will finally be 0
    // if i is Not a prime, else true.
    for (int i = 0; i < N; i++)
        prime[i] = 1;
 
    // 0 and 1 is not prime
    prime[0] = prime[1] = 0;
 
    for (int p = 2; p * p < N; p++)
    {
 
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p] == 1)
        {
 
            // Update all multiples of p greater than or
            // equal to the square of it
            // numbers which are multiple of p and are
            // less than p^2 are already been marked.
            for (int i = p * p; i < N; i += p)
                prime[i] = 0;
        }
    }
}
 
// Function to count the divisors
static void DivisorCount()
{
 
    // For each number i we will go to each of
    // the multiple of i and update the count
    // of divisor of its multiple j as i is one
    // of the factor of j
    for (int i = 1; i < N; i++)
    {
        for (int j = i; j < N; j += i)
        {
            divi[j]++;
        }
    }
}
 
// Function for pre-computation
static void pre()
{
    for (int i = 1; i < N; i++)
    {
 
        // If count of divisors of i is prime
        if (prime[divi[i]] == 1)
        {
            sum[i] = i;
        }
    }
 
    // taking prefix sum
    for (int i = 1; i < N; i++)
        sum[i] += sum[i - 1];
}
 
// Driver code
public static void main(String args[])
{
    int l = 5, r = 8;
 
    // Find all the prime numbers till N
    SieveOfEratosthenes();
 
    // Update the count of divisors
    // of all the numbers till N
    DivisorCount();
 
    // Precomputation for the prefix sum array
    pre();
 
    // Perform query
    System.out.println( sum[r] - sum[l - 1]);
}
}
 
// This code is contributed by Arnab Kundu

Python3




# Python3 implementation of the approach
from math import sqrt
 
N = 100000;
 
# Create a boolean array "prime[0..n]" and
# initialize all entries it as true.
# A value in prime[i] will finally be 0 if
# i is Not a prime, else true.
# prime[i] stores 1 if i is prime
prime = [1] * N;
 
# divi[i] stores the count of
# divisors of i
divi = [0] * N;
 
# sum[i] will store the sum of all
# the integers from 0 to i whose
# count of divisors is prime
sum = [0] * N;
 
# Function for Sieve of Eratosthenes
def SieveOfEratosthenes() :
 
    for i in range(N) :
        prime[i] = 1;
 
    # 0 and 1 is not prime
    prime[0] = prime[1] = 0;
 
    for p in range(2, int(sqrt(N)) + 1) :
 
        # If prime[p] is not changed,
        # then it is a prime
        if (prime[p] == 1) :
 
            # Update all multiples of p greater than or
            # equal to the square of it
            # numbers which are multiple of p and are
            # less than p^2 are already been marked.
            for i in range(p * p, N, p) :
                prime[i] = 0;
 
# Function to count the divisors
def DivisorCount() :
 
    # For each number i we will go to each of
    # the multiple of i and update the count
    # of divisor of its multiple j as i is one
    # of the factor of j
    for i in range(1, N) :
        for j in range(i, N , i) :
            divi[j] += 1;
 
# Function for pre-computation
def pre() :
 
    for i in range(1, N) :
 
        # If count of divisors of i is prime
        if (prime[divi[i]] == 1) :
            sum[i] = i;
 
    # taking prefix sum
    for i in range(1, N) :
        sum[i] += sum[i - 1];
 
# Driver code
if __name__ == "__main__" :
 
    l = 5; r = 8;
 
    # Find all the prime numbers till N
    SieveOfEratosthenes();
 
    # Update the count of divisors
    # of all the numbers till N
    DivisorCount();
 
    # Precomputation for the prefix sum array
    pre();
 
    # Perform query
    print(sum[r] - sum[l - 1]);
 
# This code is contributed by AnkitRai01

C#




// C# implementation of the approach
using System;
using System.Collections.Generic;
     
class GFG
{
static int N = 100000;
 
// prime[i] stores 1 if i is prime
static int []prime = new int[N];
 
// divi[i] stores the count of
// divisors of i
static int []divi = new int[N];
 
// sum[i] will store the sum of all
// the integers from 0 to i whose
// count of divisors is prime
static int []sum = new int[N];
 
// Function for Sieve of Eratosthenes
static void SieveOfEratosthenes()
{
    // Create a boolean array "prime[0..n]"
    // and initialize all entries it as true.
    // A value in prime[i] will finally be 0
    // if i is Not a prime, else true.
    for (int i = 0; i < N; i++)
        prime[i] = 1;
 
    // 0 and 1 is not prime
    prime[0] = prime[1] = 0;
 
    for (int p = 2; p * p < N; p++)
    {
 
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p] == 1)
        {
 
            // Update all multiples of p greater than
            // or equal to the square of it
            // numbers which are multiple of p and are
            // less than p^2 are already been marked.
            for (int i = p * p; i < N; i += p)
                prime[i] = 0;
        }
    }
}
 
// Function to count the divisors
static void DivisorCount()
{
 
    // For each number i we will go to each of
    // the multiple of i and update the count
    // of divisor of its multiple j as i is one
    // of the factor of j
    for (int i = 1; i < N; i++)
    {
        for (int j = i; j < N; j += i)
        {
            divi[j]++;
        }
    }
}
 
// Function for pre-computation
static void pre()
{
    for (int i = 1; i < N; i++)
    {
 
        // If count of divisors of i is prime
        if (prime[divi[i]] == 1)
        {
            sum[i] = i;
        }
    }
 
    // taking prefix sum
    for (int i = 1; i < N; i++)
        sum[i] += sum[i - 1];
}
 
// Driver code
public static void Main(String []args)
{
    int l = 5, r = 8;
 
    // Find all the prime numbers till N
    SieveOfEratosthenes();
 
    // Update the count of divisors
    // of all the numbers till N
    DivisorCount();
 
    // Precomputation for the prefix sum array
    pre();
 
    // Perform query
    Console.WriteLine( sum[r] - sum[l - 1]);
}
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
// Javascript implementation of above approach  
var N = 100000;
 
// prime[i] stores 1 if i is prime
var prime = Array.from({length: N}, (_, i) => 0);
 
// divi[i] stores the count of
// divisors of i
var divi = Array.from({length: N}, (_, i) => 0);
 
// sum[i] will store the sum of all
// the integers from 0 to i whose
// count of divisors is prime
var sum = Array.from({length: N}, (_, i) => 0);
 
// Function for Sieve of Eratosthenes
function SieveOfEratosthenes()
{
    // Create a boolean array "prime[0..n]" and
    // initialize all entries it as true.
    // A value in prime[i] will finally be 0
    // if i is Not a prime, else true.
    for (i = 0; i < N; i++)
        prime[i] = 1;
 
    // 0 and 1 is not prime
    prime[0] = prime[1] = 0;
 
    for (p = 2; p * p < N; p++)
    {
 
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p] == 1)
        {
 
            // Update all multiples of p greater than or
            // equal to the square of it
            // numbers which are multiple of p and are
            // less than p^2 are already been marked.
            for (i = p * p; i < N; i += p)
                prime[i] = 0;
        }
    }
}
 
// Function to count the divisors
function DivisorCount()
{
 
    // For each number i we will go to each of
    // the multiple of i and update the count
    // of divisor of its multiple j as i is one
    // of the factor of j
    for (i = 1; i < N; i++)
    {
        for (j = i; j < N; j += i)
        {
            divi[j]++;
        }
    }
}
 
// Function for pre-computation
function pre()
{
    for (i = 1; i < N; i++)
    {
 
        // If count of divisors of i is prime
        if (prime[divi[i]] == 1)
        {
            sum[i] = i;
        }
    }
 
    // taking prefix sum
    for (i = 1; i < N; i++)
        sum[i] += sum[i - 1];
}
 
// Driver code
 
var l = 5, r = 8;
 
// Find all the prime numbers till N
SieveOfEratosthenes();
 
// Update the count of divisors
// of all the numbers till N
DivisorCount();
 
// Precomputation for the prefix sum array
pre();
 
// Perform query
document.write( sum[r] - sum[l - 1]);
 
 
// This code is contributed by Amit Katiyar
 
</script>
Output: 
12

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!