Queries to count integers in a range [L, R] such that their digit sum is prime and divisible by K
Given Q queries and an integer K where each query consists of a range [L, R] and the task is to find the count of integers in the given range whose digit sum is prime and divisible by K.
Example:
Input: Q = { {1, 11},
{5, 15},
{2, 24} }
K = 2
Output:
2
1
3
Explanation:
Query 1: 2 and 11 are the only
numbers in the given range whose
digit sum is prime and divisible by K.
Query 2: 11 is the only number.
Query 3: 2, 11 and 20.
Input: Q = { {2, 17},
{3, 24} }
K = 3
Output:
2
3
Approach:
- First pre-compute all the primes till the maximum possible value of R among all the given ranges say maxVal using Sieve of Eratosthenes.
- Then mark all the integers from 1 to maxVal which are divisible by K and are prime.
- Take the prefix sum of the marked array.
- Answer the given queries by prefix[right] – prefix[left – 1].
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
const int maxSize = 1e5 + 1;
bool isPrime[maxSize];
int prefix[maxSize];
int digitSum( int num)
{
int s = 0;
while (num != 0) {
s = s + num % 10;
num = num / 10;
}
return s;
}
void sieveOfEratosthenes()
{
for ( int i = 2; i < maxSize; i++) {
isPrime[i] = true ;
}
for ( int i = 2; i * i <= maxSize; i++) {
if (isPrime[i]) {
for ( int j = i * i; j < maxSize; j += i) {
isPrime[j] = false ;
}
}
}
}
void precompute( int k)
{
sieveOfEratosthenes();
for ( int i = 1; i < maxSize; i++) {
int sum = digitSum(i);
if (isPrime[sum] == true && sum % k == 0) {
prefix[i]++;
}
}
for ( int i = 1; i < maxSize; i++) {
prefix[i] = prefix[i] + prefix[i - 1];
}
}
void performQueries( int k, int q,
vector<vector< int > >& query)
{
precompute(k);
vector< int > ans;
for ( int i = 0; i < q; i++) {
int l = query[i][0], r = query[i][1];
int cnt = prefix[r] - prefix[l - 1];
cout << cnt << endl;
}
}
int main()
{
vector<vector< int > > query = { { 1, 11 },
{ 5, 15 },
{ 2, 24 } };
int k = 2, q = query.size();
performQueries(k, q, query);
return 0;
}
|
Java
import java.io.*;
public class GFG
{
static final int maxSize = ( int )1e5 + 1 ;
static boolean isPrime[] = new boolean [maxSize];
static int prefix[] = new int [maxSize];
static int digitSum( int num)
{
int s = 0 ;
while (num != 0 )
{
s = s + num % 10 ;
num = num / 10 ;
}
return s;
}
static void sieveOfEratosthenes()
{
for ( int i = 2 ; i < maxSize; i++)
{
isPrime[i] = true ;
}
for ( int i = 2 ; i * i <= maxSize; i++)
{
if (isPrime[i])
{
for ( int j = i * i;
j < maxSize; j += i)
{
isPrime[j] = false ;
}
}
}
}
static void precompute( int k)
{
sieveOfEratosthenes();
for ( int i = 1 ; i < maxSize; i++)
{
int sum = digitSum(i);
if (isPrime[sum] == true &&
sum % k == 0 )
{
prefix[i]++;
}
}
for ( int i = 1 ; i < maxSize; i++)
{
prefix[i] = prefix[i] +
prefix[i - 1 ];
}
}
static void performQueries( int k, int q,
int query[][])
{
precompute(k);
for ( int i = 0 ; i < q; i++)
{
int l = query[i][ 0 ], r = query[i][ 1 ];
int cnt = prefix[r] - prefix[l - 1 ];
System.out.println(cnt);
}
}
public static void main (String[] args)
{
int query[][] = { { 1 , 11 },
{ 5 , 15 },
{ 2 , 24 } };
int k = 2 , q = query.length;
performQueries(k, q, query);
}
}
|
Python3
from math import sqrt
maxSize = 10 * * 5 + 1 ;
isPrime = [ 0 ] * maxSize;
prefix = [ 0 ] * maxSize;
def digitSum(num) :
s = 0 ;
while (num ! = 0 ) :
s = s + num % 10 ;
num = num / / 10 ;
return s;
def sieveOfEratosthenes() :
for i in range ( 2 , maxSize) :
isPrime[i] = True ;
for i in range ( 2 , int (sqrt(maxSize)) + 1 ) :
if (isPrime[i]) :
for j in range (i * i, maxSize, i) :
isPrime[j] = False ;
def precompute(k) :
sieveOfEratosthenes();
for i in range ( 1 , maxSize) :
sum = digitSum(i);
if (isPrime[ sum ] = = True and
sum % k = = 0 ) :
prefix[i] + = 1 ;
for i in range ( 1 , maxSize) :
prefix[i] = prefix[i] + prefix[i - 1 ];
def performQueries(k, q, query) :
precompute(k);
for i in range (q) :
l = query[i][ 0 ]; r = query[i][ 1 ];
cnt = prefix[r] - prefix[l - 1 ];
print (cnt);
if __name__ = = "__main__" :
query = [ [ 1 , 11 ],
[ 5 , 15 ],
[ 2 , 24 ] ];
k = 2 ; q = len (query);
performQueries(k, q, query);
|
C#
using System;
class GFG
{
static readonly int maxSize = ( int )1e5 + 1;
static Boolean []isPrime = new Boolean[maxSize];
static int []prefix = new int [maxSize];
static int digitSum( int num)
{
int s = 0;
while (num != 0)
{
s = s + num % 10;
num = num / 10;
}
return s;
}
static void sieveOfEratosthenes()
{
for ( int i = 2; i < maxSize; i++)
{
isPrime[i] = true ;
}
for ( int i = 2; i * i <= maxSize; i++)
{
if (isPrime[i])
{
for ( int j = i * i;
j < maxSize; j += i)
{
isPrime[j] = false ;
}
}
}
}
static void precompute( int k)
{
sieveOfEratosthenes();
for ( int i = 1; i < maxSize; i++)
{
int sum = digitSum(i);
if (isPrime[sum] == true &&
sum % k == 0)
{
prefix[i]++;
}
}
for ( int i = 1; i < maxSize; i++)
{
prefix[i] = prefix[i] +
prefix[i - 1];
}
}
static void performQueries( int k, int q,
int [,]query)
{
precompute(k);
for ( int i = 0; i < q; i++)
{
int l = query[i, 0], r = query[i, 1];
int cnt = prefix[r] - prefix[l - 1];
Console.WriteLine(cnt);
}
}
public static void Main (String[] args)
{
int [,]query = {{ 1, 11 },
{ 5, 15 },
{ 2, 24 }};
int k = 2, q = query.GetLength(0);
performQueries(k, q, query);
}
}
|
Javascript
<script>
var maxSize = parseInt(1e5 + 1);
var isPrime = Array.from({length: maxSize},
(_, i) => false );
var prefix = Array.from({length: maxSize},
(_, i) => 0);
function digitSum(num)
{
var s = 0;
while (num != 0)
{
s = s + num % 10;
num = parseInt(num / 10);
}
return s;
}
function sieveOfEratosthenes()
{
for (i = 2; i < maxSize; i++)
{
isPrime[i] = true ;
}
for (i = 2; i * i <= maxSize; i++)
{
if (isPrime[i])
{
for (j = i * i;
j < maxSize; j += i)
{
isPrime[j] = false ;
}
}
}
}
function precompute(k)
{
sieveOfEratosthenes();
for (i = 1; i < maxSize; i++)
{
var sum = digitSum(i);
if (isPrime[sum] == true &&
sum % k == 0)
{
prefix[i]++;
}
}
for (i = 1; i < maxSize; i++)
{
prefix[i] = prefix[i] +
prefix[i - 1];
}
}
function performQueries(k , q, query)
{
precompute(k);
for (i = 0; i < q; i++)
{
var l = query[i][0], r = query[i][1];
var cnt = prefix[r] - prefix[l - 1];
document.write(cnt+ "<br>" );
}
}
var query = [ [ 1, 11 ],
[ 5, 15 ],
[ 2, 24 ] ];
var k = 2, q = query.length;
performQueries(k, q, query);
</script>
|
The time complexity of this approach is O(N * log(N)). Here N is the maximum size of the array. We are running a sieve algorithm to generate all prime numbers up to N, and then performing the precomputation step to generate the count of prime numbers which are divisible by the given number k and have digit sum as prime numbers.
The space complexity of this approach is O(N) as we are using an array of size N to store the count of prime numbers which are divisible by the given number k and have digit sum as prime numbers.
Last Updated :
27 Jan, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...