# Count all prime numbers in a given range whose sum of digits is also prime

Given two integers L and R, the task is to find the count of total numbers of prime numbers in the range [L, R] whose sum of the digits is also a prime number.

Examples:

Input: L = 1, R = 10
Output:
Explanation:
Prime numbers in the range L = 1 to R = 10 are {2, 3, 5, 7}.
Their sum of digits is {2, 3, 5, 7}.
Since all the numbers are prime, hence the answer to the query is 4.
Input: L = 5, R = 20
Output:
Explanation:
Prime numbers in the range L = 5 to R = 20 are {5, 7, 11, 13, 17, 19}.1
Their sum of digits is {5, 7, 2, 4, 8, 10}.
Only {5, 7, 2} are prime, hence the answer to the query is 3.

Naive Approach: The naive approach is to iterate for each number in the range [L, R] and check if the number is prime or not. If the number is prime, find the sum of its digits and again check whether the sum is prime or not. If the sum is prime, then increment the counter for the current element in the range [L, R].
Time Complexity: O((R – L)*log(log P)) where P is the prime number in the range [L, R].

Space Complexity: O(N)

Efficient Approach:

1. Store all the prime numbers ranging from 1 to 106 in an array using Sieve of Eratosthenes.
2. Create another array that will store whether the sum of the digits of all the numbers ranging from 1 to 106 which are prime.
3. Now, compute a prefix array to store counts till every value before the limit.
4. Once we have a prefix array, the value of prefix[R] – prefix[L-1] gives the count of elements in the given range that are prime and whose sum is also prime.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `int` `maxN = 1000000;`   `// Create an array for storing primes` `int` `arr[1000001];`   `// Create a prefix array that will` `// contain whether sum is prime or not` `int` `prefix[1000001];`   `// Function to find primes in the range` `// and check whether the sum of digits` `// of a prime number is prime or not` `void` `findPrimes()` `{` `    ``// Initialise Prime array arr[]` `    ``for` `(``int` `i = 1; i <= maxN; i++)` `        ``arr[i] = 1;`   `    ``// Since 0 and 1 are not prime` `    ``// numbers we mark them as '0'` `    ``arr[0] = 0, arr[1] = 0;`   `    ``// Using Sieve Of Eratosthenes` `    ``for` `(``int` `i = 2; i * i <= maxN; i++) {`   `        ``// if the number is prime` `        ``if` `(arr[i] == 1) {`   `            ``// Mark all the multiples` `            ``// of i starting from square` `            ``// of i with '0' ie. composite` `            ``for` `(``int` `j = i * i;` `                 ``j <= maxN; j += i) {`   `                ``//'0' represents not prime` `                ``arr[j] = 0;` `            ``}` `        ``}` `    ``}`   `    ``// Initialise a sum variable as 0` `    ``int` `sum = 0;` `    ``prefix[0] = 0;`   `    ``for` `(``int` `i = 1; i <= maxN; i++) {`   `        ``// Check if the number is prime` `        ``if` `(arr[i] == 1) {`   `            ``// A temporary variable to` `            ``// store the number` `            ``int` `temp = i;` `            ``sum = 0;`   `            ``// Loop to calculate the` `            ``// sum of digits` `            ``while` `(temp > 0) {` `                ``int` `x = temp % 10;` `                ``sum += x;` `                ``temp = temp / 10;`   `                ``// Check if the sum of prime` `                ``// number is prime` `                ``if` `(arr[sum] == 1) {`   `                    ``// if prime mark 1` `                    ``prefix[i] = 1;` `                ``}`   `                ``else` `{`   `                    ``// If not prime mark 0` `                    ``prefix[i] = 0;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// computing prefix array` `    ``for` `(``int` `i = 1; i <= maxN; i++) {` `        ``prefix[i]` `            ``+= prefix[i - 1];` `    ``}` `}`   `// Function to count the prime numbers` `// in the range [L, R]` `void` `countNumbersInRange(``int` `l, ``int` `r)` `{` `    ``// Function Call to find primes` `    ``findPrimes();` `    ``int` `result = prefix[r]` `                 ``- prefix[l - 1];`   `    ``// Print the result` `    ``cout << result << endl;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Input range` `    ``int` `l, r;` `    ``l = 5, r = 20;`   `    ``// Function Call` `    ``countNumbersInRange(l, r);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `class` `GFG{`   `static` `int` `maxN = ``1000000``;`   `// Create an array for storing primes` `static` `int` `[]arr = ``new` `int``[``1000001``];`   `// Create a prefix array that will` `// contain whether sum is prime or not` `static` `int` `[]prefix = ``new` `int``[``1000001``];`   `// Function to find primes in the range` `// and check whether the sum of digits` `// of a prime number is prime or not` `static` `void` `findPrimes()` `{` `    ``// Initialise Prime array arr[]` `    ``for` `(``int` `i = ``1``; i <= maxN; i++)` `        ``arr[i] = ``1``;`   `    ``// Since 0 and 1 are not prime` `    ``// numbers we mark them as '0'` `    ``arr[``0``] = ``0``;` `    ``arr[``1``] = ``0``;`   `    ``// Using Sieve Of Eratosthenes` `    ``for` `(``int` `i = ``2``; i * i <= maxN; i++)` `    ``{`   `        ``// if the number is prime` `        ``if` `(arr[i] == ``1``)` `        ``{`   `            ``// Mark all the multiples` `            ``// of i starting from square` `            ``// of i with '0' ie. composite` `            ``for` `(``int` `j = i * i;` `                     ``j <= maxN; j += i) ` `            ``{`   `                ``//'0' represents not prime` `                ``arr[j] = ``0``;` `            ``}` `        ``}` `    ``}`   `    ``// Initialise a sum variable as 0` `    ``int` `sum = ``0``;` `    ``prefix[``0``] = ``0``;`   `    ``for` `(``int` `i = ``1``; i <= maxN; i++) ` `    ``{`   `        ``// Check if the number is prime` `        ``if` `(arr[i] == ``1``)` `        ``{`   `            ``// A temporary variable to` `            ``// store the number` `            ``int` `temp = i;` `            ``sum = ``0``;`   `            ``// Loop to calculate the` `            ``// sum of digits` `            ``while` `(temp > ``0``)` `            ``{` `                ``int` `x = temp % ``10``;` `                ``sum += x;` `                ``temp = temp / ``10``;`   `                ``// Check if the sum of prime` `                ``// number is prime` `                ``if` `(arr[sum] == ``1``) ` `                ``{`   `                    ``// if prime mark 1` `                    ``prefix[i] = ``1``;` `                ``}`   `                ``else` `                ``{`   `                    ``// If not prime mark 0` `                    ``prefix[i] = ``0``;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// computing prefix array` `    ``for` `(``int` `i = ``1``; i <= maxN; i++)` `    ``{` `        ``prefix[i] += prefix[i - ``1``];` `    ``}` `}`   `// Function to count the prime numbers` `// in the range [L, R]` `static` `void` `countNumbersInRange(``int` `l, ``int` `r)` `{` `    ``// Function Call to find primes` `    ``findPrimes();` `    ``int` `result = prefix[r] - prefix[l - ``1``];`   `    ``// Print the result` `    ``System.out.print(result + ``"\n"``);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``// Input range` `    ``int` `l, r;` `    ``l = ``5``;` `    ``r = ``20``;`   `    ``// Function Call` `    ``countNumbersInRange(l, r);` `}` `}`   `// This code is contributed by sapnasingh4991`

## Python3

 `# Python3 program for the above approach` `maxN ``=` `1000000`   `# Create an array for storing primes` `arr ``=` `[``0``] ``*` `(``1000001``)`   `# Create a prefix array that will` `# contain whether sum is prime or not` `prefix ``=` `[``0``] ``*` `(``1000001``)`   `# Function to find primes in the range` `# and check whether the sum of digits` `# of a prime number is prime or not` `def` `findPrimes():`   `    ``# Initialise Prime array arr[]` `    ``for` `i ``in` `range``(``1``, maxN ``+` `1``):` `        ``arr[i] ``=` `1`   `    ``# Since 0 and 1 are not prime` `    ``# numbers we mark them as '0'` `    ``arr[``0``] ``=` `0` `    ``arr[``1``] ``=` `0`   `    ``# Using Sieve Of Eratosthenes` `    ``i ``=` `2` `    ``while` `i ``*` `i <``=` `maxN:`   `        ``# If the number is prime` `        ``if` `(arr[i] ``=``=` `1``):`   `            ``# Mark all the multiples` `            ``# of i starting from square` `            ``# of i with '0' ie. composite` `            ``for` `j ``in` `range``(i ``*` `i, maxN, i):`   `                ``# '0' represents not prime` `                ``arr[j] ``=` `0`   `        ``i ``+``=` `1`   `    ``# Initialise a sum variable as 0` `    ``sum` `=` `0` `    ``prefix[``0``] ``=` `0`   `    ``for` `i ``in` `range``(``1``, maxN ``+` `1``):`   `        ``# Check if the number is prime` `        ``if` `(arr[i] ``=``=` `1``):`   `            ``# A temporary variable to` `            ``# store the number` `            ``temp ``=` `i` `            ``sum` `=` `0`   `            ``# Loop to calculate the` `            ``# sum of digits` `            ``while` `(temp > ``0``):` `                ``x ``=` `temp ``%` `10` `                ``sum` `+``=` `x` `                ``temp ``=` `temp ``/``/` `10`   `                ``# Check if the sum of prime` `                ``# number is prime` `                ``if` `(arr[``sum``] ``=``=` `1``):`   `                    ``# If prime mark 1` `                    ``prefix[i] ``=` `1`   `                ``else``:` `                    `  `                    ``# If not prime mark 0` `                    ``prefix[i] ``=` `0`   `    ``# Computing prefix array` `    ``for` `i ``in` `range``(``1``, maxN ``+` `1``):` `        ``prefix[i] ``+``=` `prefix[i ``-` `1``]`   `# Function to count the prime numbers` `# in the range [L, R]` `def` `countNumbersInRange(l, r):`   `    ``# Function call to find primes` `    ``findPrimes()` `    ``result ``=` `(prefix[r] ``-` `prefix[l ``-` `1``])`   `    ``# Print the result` `    ``print``(result)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``# Input range` `    ``l ``=` `5` `    ``r ``=` `20`   `    ``# Function call` `    ``countNumbersInRange(l, r)`   `# This code is contributed by chitranayal`

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG{`   `static` `int` `maxN = 1000000;`   `// Create an array for storing primes` `static` `int` `[]arr = ``new` `int``[1000001];`   `// Create a prefix array that will` `// contain whether sum is prime or not` `static` `int` `[]prefix = ``new` `int``[1000001];`   `// Function to find primes in the range` `// and check whether the sum of digits` `// of a prime number is prime or not` `static` `void` `findPrimes()` `{` `    ``// Initialise Prime array arr[]` `    ``for` `(``int` `i = 1; i <= maxN; i++)` `        ``arr[i] = 1;`   `    ``// Since 0 and 1 are not prime` `    ``// numbers we mark them as '0'` `    ``arr[0] = 0;` `    ``arr[1] = 0;`   `    ``// Using Sieve Of Eratosthenes` `    ``for` `(``int` `i = 2; i * i <= maxN; i++)` `    ``{`   `        ``// if the number is prime` `        ``if` `(arr[i] == 1)` `        ``{`   `            ``// Mark all the multiples` `            ``// of i starting from square` `            ``// of i with '0' ie. composite` `            ``for` `(``int` `j = i * i;` `                     ``j <= maxN; j += i) ` `            ``{`   `                ``//'0' represents not prime` `                ``arr[j] = 0;` `            ``}` `        ``}` `    ``}`   `    ``// Initialise a sum variable as 0` `    ``int` `sum = 0;` `    ``prefix[0] = 0;`   `    ``for` `(``int` `i = 1; i <= maxN; i++) ` `    ``{`   `        ``// Check if the number is prime` `        ``if` `(arr[i] == 1)` `        ``{`   `            ``// A temporary variable to` `            ``// store the number` `            ``int` `temp = i;` `            ``sum = 0;`   `            ``// Loop to calculate the` `            ``// sum of digits` `            ``while` `(temp > 0)` `            ``{` `                ``int` `x = temp % 10;` `                ``sum += x;` `                ``temp = temp / 10;`   `                ``// Check if the sum of prime` `                ``// number is prime` `                ``if` `(arr[sum] == 1) ` `                ``{`   `                    ``// if prime mark 1` `                    ``prefix[i] = 1;` `                ``}`   `                ``else` `                ``{`   `                    ``// If not prime mark 0` `                    ``prefix[i] = 0;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// computing prefix array` `    ``for` `(``int` `i = 1; i <= maxN; i++)` `    ``{` `        ``prefix[i] += prefix[i - 1];` `    ``}` `}`   `// Function to count the prime numbers` `// in the range [L, R]` `static` `void` `countNumbersInRange(``int` `l, ``int` `r)` `{` `    ``// Function Call to find primes` `    ``findPrimes();` `    ``int` `result = prefix[r] - prefix[l - 1];`   `    ``// Print the result` `    ``Console.Write(result + ``"\n"``);` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``// Input range` `    ``int` `l, r;` `    ``l = 5;` `    ``r = 20;`   `    ``// Function Call` `    ``countNumbersInRange(l, r);` `}` `}`   `// This code is contributed by Code_Mech`

## Javascript

 ``

Output

```3

```

Time Complexity: O(N*(log(log)N))
Auxiliary Space: O(N)

## Approach: Brute force approach

Steps:

1. Define a function is_prime(num) to check if a number is prime or not.
2. Define a function sum_of_digits(num) to find the sum of digits of a number.
3. Iterate through the range [L, R], and for each number in the range, check if it is prime and if the sum of its digits is prime.
4. If both conditions are satisfied, increment the count.
5. Return the count as the result.

## C++

 `#include ` `#include `   `using` `namespace` `std;`   `bool` `is_prime(``int` `num) {` `    ``if` `(num <= 1) {` `        ``return` `false``;` `    ``}` `    ``for` `(``int` `i = 2; i <= ``sqrt``(num); i++) {` `        ``if` `(num % i == 0) {` `            ``return` `false``;` `        ``}` `    ``}` `    ``return` `true``;` `}`   `int` `sum_of_digits(``int` `num) {` `    ``int` `s = 0;` `    ``while` `(num > 0) {` `        ``s += num % 10;` `        ``num /= 10;` `    ``}` `    ``return` `s;` `}`   `int` `count_primes_with_prime_sum_of_digits(``int` `L, ``int` `R) {` `    ``int` `count = 0;` `    ``for` `(``int` `num = L; num <= R; num++) {` `        ``if` `(is_prime(num) && is_prime(sum_of_digits(num))) {` `            ``count++;` `        ``}` `    ``}` `    ``return` `count;` `}`   `int` `main() {` `    ``int` `L = 1;` `    ``int` `R = 10;` `    ``int` `result = count_primes_with_prime_sum_of_digits(L, R);` `    ``cout << result << endl; ``// Output: 4` `    ``return` `0;` `}`

## Java

 `public` `class` `Main {` `    ``public` `static` `boolean` `isPrime(``int` `num) {` `        ``if` `(num <= ``1``) {` `            ``return` `false``;` `        ``}` `        ``for` `(``int` `i = ``2``; i <= Math.sqrt(num); i++) {` `            ``if` `(num % i == ``0``) {` `                ``return` `false``;` `            ``}` `        ``}` `        ``return` `true``;` `    ``}`   `    ``public` `static` `int` `sumOfDigits(``int` `num) {` `        ``int` `s = ``0``;` `        ``while` `(num > ``0``) {` `            ``s += num % ``10``;` `            ``num /= ``10``;` `        ``}` `        ``return` `s;` `    ``}`   `    ``public` `static` `int` `countPrimesWithPrimeSumOfDigits(``int` `L, ``int` `R) {` `        ``int` `count = ``0``;` `        ``for` `(``int` `num = L; num <= R; num++) {` `            ``if` `(isPrime(num) && isPrime(sumOfDigits(num))) {` `                ``count++;` `            ``}` `        ``}` `        ``return` `count;` `    ``}`   `    ``// Example Usage` `    ``public` `static` `void` `main(String[] args) {` `        ``int` `L = ``1``;` `        ``int` `R = ``10``;` `        ``int` `result = countPrimesWithPrimeSumOfDigits(L, R);` `        ``System.out.println(result); ``// Output: 4` `    ``}` `}`

## Python3

 `def` `is_prime(num):` `    ``if` `num <``=` `1``:` `        ``return` `False` `    ``for` `i ``in` `range``(``2``, ``int``(num``*``*``0.5``)``+``1``):` `        ``if` `num ``%` `i ``=``=` `0``:` `            ``return` `False` `    ``return` `True`   `def` `sum_of_digits(num):` `    ``s ``=` `0` `    ``while` `num > ``0``:` `        ``s ``+``=` `num ``%` `10` `        ``num ``/``/``=` `10` `    ``return` `s`   `def` `count_primes_with_prime_sum_of_digits(L, R):` `    ``count ``=` `0` `    ``for` `num ``in` `range``(L, R``+``1``):` `        ``if` `is_prime(num) ``and` `is_prime(sum_of_digits(num)):` `            ``count ``+``=` `1` `    ``return` `count`   `# Example usage:` `L ``=` `1` `R ``=` `10` `result ``=` `count_primes_with_prime_sum_of_digits(L, R)` `print``(result) ``# Output: 4`

## C#

 `using` `System;`   `class` `Program` `{` `    ``// Function to check if a number is prime` `    ``static` `bool` `IsPrime(``int` `num)` `    ``{` `        ``if` `(num <= 1)` `        ``{` `            ``return` `false``;` `        ``}` `        ``for` `(``int` `i = 2; i <= Math.Sqrt(num); i++)` `        ``{` `            ``if` `(num % i == 0)` `            ``{` `                ``return` `false``;` `            ``}` `        ``}` `        ``return` `true``;` `    ``}`   `    ``// Function to calculate the sum of digits of a number` `    ``static` `int` `SumOfDigits(``int` `num)` `    ``{` `        ``int` `s = 0;` `        ``while` `(num > 0)` `        ``{` `            ``s += num % 10;` `            ``num /= 10;` `        ``}` `        ``return` `s;` `    ``}`   `    ``// Function to count prime numbers with a prime sum of digits in a given range` `    ``static` `int` `CountPrimesWithPrimeSumOfDigits(``int` `L, ``int` `R)` `    ``{` `        ``int` `count = 0;` `        ``for` `(``int` `num = L; num <= R; num++)` `        ``{` `            ``if` `(IsPrime(num) && IsPrime(SumOfDigits(num)))` `            ``{` `                ``count++;` `            ``}` `        ``}` `        ``return` `count;` `    ``}`   `    ``static` `void` `Main()` `    ``{` `        ``int` `L = 1;` `        ``int` `R = 10;` `        ``int` `result = CountPrimesWithPrimeSumOfDigits(L, R);` `        ``Console.WriteLine(result); ``// Output: 4` `    ``}` `}`

## Javascript

 `function` `isPrime(num) {` `    ``if` `(num <= 1) {` `        ``return` `false``;` `    ``}` `    ``for` `(let i = 2; i <= Math.sqrt(num); i++) {` `        ``if` `(num % i === 0) {` `            ``return` `false``;` `        ``}` `    ``}` `    ``return` `true``;` `}`   `function` `sumOfDigits(num) {` `    ``let sum = 0;` `    ``while` `(num > 0) {` `        ``sum += num % 10;` `        ``num = Math.floor(num / 10);` `    ``}` `    ``return` `sum;` `}`   `function` `countPrimesWithPrimeSumOfDigits(L, R) {` `    ``let count = 0;` `    ``for` `(let num = L; num <= R; num++) {` `        ``if` `(isPrime(num) && isPrime(sumOfDigits(num))) {` `            ``count++;` `        ``}` `    ``}` `    ``return` `count;` `}`   `// Example usage:` `let L = 1;` `let R = 10;` `let result = countPrimesWithPrimeSumOfDigits(L, R);` `console.log(result); ``// Output: 4`   `// This code is Contributed by - Dwaipayan Bandyopadhyay`

Output

```4

```

Time complexity: O((R-L)*sqrt(R))
Auxiliary space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next