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: 4 
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: 3 
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 10⁶ 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 10⁶ 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 <bits/stdc++.h>
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

<script>
// Javascript implementation for the above approach

let maxN = 1000000;

// Create an array for storing primes
let arr = Array.from({length: 1000001}, (_, i) => 0);
// Create a prefix array that will
// contain whether sum is prime or not
let prefix = Array.from({length: 1000001}, (_, i) => 0);

// Function to find primes in the range
// and check whether the sum of digits
// of a prime number is prime or not
function findPrimes()
{
    // Initialise Prime array arr[]
    for (let 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 (let 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 (let j = i * i;
                     j <= maxN; j += i)
            {

                //'0' represents not prime
                arr[j] = 0;
            }
        }
    }

    // Initialise a sum variable as 0
    let sum = 0;
    prefix[0] = 0;

    for (let i = 1; i <= maxN; i++)
    {

        // Check if the number is prime
        if (arr[i] == 1)
        {

            // A temporary variable to
            // store the number
            let temp = i;
            sum = 0;

            // Loop to calculate the
            // sum of digits
            while (temp > 0)
            {
                let x = temp % 10;
                sum += x;
                temp = Math.floor(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 (let i = 1; i <= maxN; i++)
    {
        prefix[i] += prefix[i - 1];
    }
}

// Function to count the prime numbers
// in the range [L, R]
function countNumbersInRange(l, r)
{
    // Function Call to find primes
    findPrimes();
    let result = prefix[r] - prefix[l - 1];

    // Print the result
    document.write(result + "\n");
}

    // Driver Code

     // Input range
    let l, r;
    l = 5;
    r = 20;

    // Function Call
    countNumbersInRange(l, r);

</script>

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 <iostream>
#include <cmath>

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)