# 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 ``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 = prime = 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 = prime = 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

 ``
Output:
`12`

My Personal Notes arrow_drop_up