Queries to count Palindrome Numbers from a range whose sum of digits is a Prime Number

Last Updated : 09 Jun, 2021

Given an array Q[][] consisting of N queries of the form {L, R}, the task for each query is to find the count of the numbers in the range [L, R] that are palindrome and the sum of their digits is a prime number.

Examples:

Input: Q[][] = {{5, 9}, {5, 22}}
Output:
2
3
Explanation:
Query 1: All palindrome numbers from the range [5, 9] having sum of their digits equal to a prime number are {5, 7}. Therefore, the count of elements is 2.
Query 2: All palindrome numbers from the range [5, 20] having sum of their digits equal to a prime number are {5, 7, 11}. Therefore, the count of elements is 2.

Input: Q[] = {{1, 101}, {13, 15}}
Output:
6
0

Naive Approach: The simplest approach to solve the given problem is to iterate over the range [L, R] for each query and print the count of those numbers that are palindrome, and the sum of their digits is a prime number.

Time Complexity: O(N*(R – L))
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by using the Inclusion-Exclusion principle and the concepts of prefix sum. Follow the steps below to solve the given problem:

Initialize an array arr[] to store the count of numbers up to each index i that are palindrome and the sum of their digits is a prime number at every i^th index.
Iterate over the range [1, 10⁵], and for each element X, if the number X is palindromic and the sum of the digits is prime then update arr[i] to 1. Otherwise, set arr[i] = 0.
Find the prefix sum array of the array arr[].
Now, Traverse the array Q[] and for each query {L, R}, print the total count of the numbers in the range [L, R] that are palindrome and the sum of their digits is a prime number as (arr[R] – arr[L – 1]).

Below is the implementation of the above approach:

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
int arr[100005];
 
// Function to check if the number N
// is palindrome or not
bool isPalindrome(int N)
{
    // Store the value of N
    int temp = N;
 
    // Store the reverse of number N
    int res = 0;
 
    // Reverse temp and store in res
    while (temp != 0) {
        int rem = temp % 10;
        res = res * 10 + rem;
        temp /= 10;
    }
 
    // If N is the same as res, then
    // return true
    if (res == N) {
        return true;
    }
    else {
        return false;
    }
}
 
// Function to find the sum of the
// digits of the number N
int sumOfDigits(int N)
{
    // Stores the sum of the digits
    int sum = 0;
 
    while (N != 0) {
        // Add the last digit of the
        // number N to the sum
        sum += N % 10;
 
        // Remove the last digit
        // from N
        N /= 10;
    }
 
    // Return the resultant sum
    return sum;
}
 
// Function to check if N is prime or not
bool isPrime(int n)
{
    // If i is 1 or 0, then return false
    if (n <= 1) {
        return false;
    }
 
    // Check if i is divisible by any
    // number in the range [2, n/2]
    for (int i = 2; i <= n / 2; ++i) {
        // If n is divisible by i
        if (n % i == 0)
            return false;
    }
 
    return true;
}
 
// Function to precompute all the numbers
// till 10^5 that are palindromic and
// whose sum of digits is prime numbers
void precompute()
{
    // Iterate over the range 1 to 10 ^ 5
    for (int i = 1; i <= 100000; i++) {
 
        // If i is a palindrome number
        if (isPalindrome(i)) {
 
            // Stores the sum of
            // the digits in i
            int sum = sumOfDigits(i);
 
            // If the sum of digits
            // in i is a prime number
            if (isPrime(sum))
                arr[i] = 1;
            else
                arr[i] = 0;
        }
        else
            arr[i] = 0;
    }
 
    // Find the prefix sum of arr[]
    for (int i = 1; i <= 100000; i++) {
        arr[i] = arr[i] + arr[i - 1];
    }
}
 
// Function to count all the numbers in
// the given ranges that are palindromic
// and the sum of digits is prime numbers
void countNumbers(int Q[][2], int N)
{
 
    // Function Call to precompute
    // all the numbers till 10^5
    precompute();
 
    // Traverse the given queries Q[]
    for (int i = 0; i < N; i++) {
 
        // Print the result for
        // each query
        cout << (arr[Q[i][1]]
                 - arr[Q[i][0] - 1]);
        cout << endl;
    }
}
 
// Driver Code
int main()
{
    int Q[][2] = { { 5, 9 }, { 1, 101 } };
    int N = sizeof(Q) / sizeof(Q[0]);
 
    // Function Call
    countNumbers(Q, N);
}

Java

// Java program for the above approach
class GFG{
     
static int[] arr = new int[100005];
 
// Function to check if the number N
// is palindrome or not
static boolean isPalindrome(int N)
{
    int temp = N;
 
    // Store the reverse of number N
    int res = 0;
 
    // Reverse temp and store in res
    while (temp != 0) 
    {
        int rem = temp % 10;
        res = res * 10 + rem;
        temp /= 10;
    }
 
    // If N is the same as res, then
    // return true
    if (res == N)
    {
        return true;
    }
    else
    {
        return false;
    }
}
 
// Function to find the sum of the
// digits of the number N
static int sumOfDigits(int N)
{
     
    // Stores the sum of the digits
    int sum = 0;
 
    while (N != 0)
    {
         
        // Add the last digit of the
        // number N to the sum
        sum += N % 10;
 
        // Remove the last digit
        // from N
        N /= 10;
    }
 
    // Return the resultant sum
    return sum;
}
 
// Function to check if N is prime or not
static boolean isPrime(int n)
{
    // If i is 1 or 0, then return false
    if (n <= 1) 
    {
        return false;
    }
 
    // Check if i is divisible by any
    // number in the range [2, n/2]
    for(int i = 2; i <= n / 2; ++i) 
    {
         
        // If n is divisible by i
        if (n % i == 0)
            return false;
    }
    return true;
}
 
// Function to precompute all the numbers
// till 10^5 that are palindromic and
// whose sum of digits is prime numbers
static void precompute()
{
     
    // Iterate over the range 1 to 10 ^ 5
    for(int i = 1; i <= 100000; i++) 
    {
 
        // If i is a palindrome number
        if (isPalindrome(i)) 
        {
 
            // Stores the sum of
            // the digits in i
            int sum = sumOfDigits(i);
 
            // If the sum of digits
            // in i is a prime number
            if (isPrime(sum))
                arr[i] = 1;
            else
                arr[i] = 0;
        }
        else
            arr[i] = 0;
    }
 
    // Find the prefix sum of arr[]
    for(int i = 1; i <= 100000; i++) 
    {
        arr[i] = arr[i] + arr[i - 1];
    }
}
 
// Function to count all the numbers in
// the given ranges that are palindromic
// and the sum of digits is prime numbers
static void countNumbers(int[][] Q, int N)
{
 
    // Function Call to precompute
    // all the numbers till 10^5
    precompute();
 
    // Traverse the given queries Q[]
    for(int i = 0; i < N; i++) 
    {
         
        // Print the result for
        // each query
        System.out.println((arr[Q[i][1]] - 
                            arr[Q[i][0] - 1]));
    }
}
 
// Driver Code
public static void main(String[] args) 
{
    int[][] Q = { { 5, 9 }, { 1, 101 } };
    int N = Q.length;
 
    // Function Call
    countNumbers(Q, N);
}
}
 
// This code is contributed by user_qa7r

Python3

# Python 3 program for the above approach
arr = [0 for i in range(100005)]
 
# Function to check if the number N
# is palindrome or not
def isPalindrome(N):
   
    # Store the value of N
    temp = N
 
    # Store the reverse of number N
    res = 0
 
    # Reverse temp and store in res
    while (temp != 0):
        rem = temp % 10
        res = res * 10 + rem
        temp //= 10
 
    # If N is the same as res, then
    # return true
    if (res == N):
        return True
    else:
        return False
 
# Function to find the sum of the
# digits of the number N
def sumOfDigits(N):
   
    # Stores the sum of the digits
    sum = 0
 
    while (N != 0):
       
        # Add the last digit of the
        # number N to the sum
        sum += N % 10
 
        # Remove the last digit
        # from N
        N //= 10
 
    # Return the resultant sum
    return sum
 
# Function to check if N is prime or not
def isPrime(n):
   
    # If i is 1 or 0, then return false
    if (n <= 1):
        return False
 
    # Check if i is divisible by any
    # number in the range [2, n/2]
    for i in range(2, (n//2) + 1, 1):
       
        # If n is divisible by i
        if (n % i == 0):
            return False
 
    return True
 
# Function to precompute all the numbers
# till 10^5 that are palindromic and
# whose sum of digits is prime numbers
def precompute():
   
    # Iterate over the range 1 to 10 ^ 5
    for i in range(1, 100001, 1):
       
        # If i is a palindrome number
        if (isPalindrome(i)):
           
            # Stores the sum of
            # the digits in i
            sum = sumOfDigits(i)
 
            # If the sum of digits
            # in i is a prime number
            if (isPrime(sum)):
                arr[i] = 1
            else:
                arr[i] = 0
        else:
            arr[i] = 0
 
    # Find the prefix sum of arr[]
    for i in range(1,100001,1):
        arr[i] = arr[i] + arr[i - 1]
 
# Function to count all the numbers in
# the given ranges that are palindromic
# and the sum of digits is prime numbers
def countNumbers(Q, N):
   
    # Function Call to precompute
    # all the numbers till 10^5
    precompute()
 
    # Traverse the given queries Q[]
    for i in range(N):
       
        # Print the result for
        # each query
        print(arr[Q[i][1]] - arr[Q[i][0] - 1])
 
# Driver Code
if __name__ == '__main__':
    Q = [[5, 9], [1, 101]]
    N = len(Q)
 
    # Function Call
    countNumbers(Q, N)
 
    # This code is contributed by bgangwar59.

C#

// C# program for the above approach
using System;
 
class GFG{
 
static int[] arr = new int[100005];
 
// Function to check if the number N
// is palindrome or not
static bool isPalindrome(int N)
{
    int temp = N;
 
    // Store the reverse of number N
    int res = 0;
 
    // Reverse temp and store in res
    while (temp != 0) 
    {
        int rem = temp % 10;
        res = res * 10 + rem;
        temp /= 10;
    }
 
    // If N is the same as res, then
    // return true
    if (res == N)
    {
        return true;
    }
    else
    {
        return false;
    }
}
 
// Function to find the sum of the
// digits of the number N
static int sumOfDigits(int N)
{
 
    // Stores the sum of the digits
    int sum = 0;
 
    while (N != 0)
    {
         
        // Add the last digit of the
        // number N to the sum
        sum += N % 10;
 
        // Remove the last digit
        // from N
        N /= 10;
    }
 
    // Return the resultant sum
    return sum;
}
 
// Function to check if N is prime or not
static bool isPrime(int n)
{
    // If i is 1 or 0, then return false
    if (n <= 1) 
    {
        return false;
    }
 
    // Check if i is divisible by any
    // number in the range [2, n/2]
    for(int i = 2; i <= n / 2; ++i) 
    {
         
        // If n is divisible by i
        if (n % i == 0)
            return false;
    }
    return true;
}
 
// Function to precompute all the numbers
// till 10^5 that are palindromic and
// whose sum of digits is prime numbers
static void precompute()
{
     
    // Iterate over the range 1 to 10 ^ 5
    for(int i = 1; i <= 100000; i++) 
    {
         
        // If i is a palindrome number
        if (isPalindrome(i)) 
        {
             
            // Stores the sum of
            // the digits in i
            int sum = sumOfDigits(i);
 
            // If the sum of digits
            // in i is a prime number
            if (isPrime(sum))
                arr[i] = 1;
            else
                arr[i] = 0;
        }
        else
            arr[i] = 0;
    }
 
    // Find the prefix sum of arr[]
    for(int i = 1; i <= 100000; i++)
    {
        arr[i] = arr[i] + arr[i - 1];
    }
}
 
// Function to count all the numbers in
// the given ranges that are palindromic
// and the sum of digits is prime numbers
static void countNumbers(int[, ] Q, int N)
{
 
    // Function Call to precompute
    // all the numbers till 10^5
    precompute();
 
    // Traverse the given queries Q[]
    for(int i = 0; i < N; i++)
    {
         
        // Print the result for
        // each query
        Console.WriteLine((arr[Q[i, 1]] - 
                           arr[Q[i, 0] - 1]));
    }
}
 
// Driver Code
static public void Main()
{
    int[,] Q = { { 5, 9 }, { 1, 101 } };
    int N = Q.GetLength(0);
   
    // Function Call
    countNumbers(Q, N);
}
}
 
// This code is contributed by Dharanendra L V.

Javascript

<script>
// JavaScript program for the above approach
 
let arr = [];
for(let m = 0; m < 100005; m++)
{
    arr[m] = 0;
}
  
// Function to check if the number N
// is palindrome or not
function isPalindrome(N)
{
    let temp = N;
  
    // Store the reverse of number N
    let res = 0;
  
    // Reverse temp and store in res
    while (temp != 0)
    {
        let rem = temp % 10;
        res = res * 10 + rem;
        temp = Math.floor( temp / 10);
    }
  
    // If N is the same as res, then
    // return true
    if (res == N)
    {
        return true;
    }
    else
    {
        return false;
    }
}
  
// Function to find the sum of the
// digits of the number N
function sumOfDigits(N)
{
      
    // Stores the sum of the digits
    let sum = 0;
  
    while (N != 0)
    {
          
        // Add the last digit of the
        // number N to the sum
        sum += N % 10;
  
        // Remove the last digit
        // from N
        N = Math.floor( N / 10);
    }
  
    // Return the resultant sum
    return sum;
}
  
// Function to check if N is prime or not
function isPrime(n)
{
    // If i is 1 or 0, then return false
    if (n <= 1)
    {
        return false;
    }
  
    // Check if i is divisible by any
    // number in the range [2, n/2]
    for(let i = 2; i <= Math.floor(n / 2); ++i)
    {
          
        // If n is divisible by i
        if (n % i == 0)
            return false;
    }
    return true;
}
  
// Function to precompute all the numbers
// till 10^5 that are palindromic and
// whose sum of digits is prime numbers
function precompute()
{
      
    // Iterate over the range 1 to 10 ^ 5
    for(let i = 1; i <= 100000; i++)
    {
  
        // If i is a palindrome number
        if (isPalindrome(i))
        {
  
            // Stores the sum of
            // the digits in i
            let sum = sumOfDigits(i);
  
            // If the sum of digits
            // in i is a prime number
            if (isPrime(sum))
                arr[i] = 1;
            else
                arr[i] = 0;
        }
        else
            arr[i] = 0;
    }
  
    // Find the prefix sum of arr[]
    for(let i = 1; i <= 100000; i++)
    {
        arr[i] = arr[i] + arr[i - 1];
    }
}
  
// Function to count all the numbers in
// the given ranges that are palindromic
// and the sum of digits is prime numbers
function countNumbers( Q, N)
{
  
    // Function Call to precompute
    // all the numbers till 10^5
    precompute();
  
    // Traverse the given queries Q[]
    for(let i = 0; i < N; i++)
    {
          
        // Print the result for
        // each query
        document.write((arr[Q[i][1]] -
                            arr[Q[i][0] - 1]) + "<br/>");
    }
}
 
// Driver Code
 
    let Q = [[ 5, 9 ], [ 1, 101 ]];
    let N = Q.length;
  
    // Function Call
    countNumbers(Q, N);
     
</script>

Output:

2
6

Time Complexity: O(N*log N)
Auxiliary Space: O(M), where M is the maximum element among each query.

Check if it is possible to reach any point on the circumference of a given circle from origin

patelajeet

Improve

Article Tags :

Practice Tags :

Queries to count Palindrome Numbers from a range whose sum of digits is a Prime Number

C++

Java

Python3

C#

Javascript

Similar Reads

Thank You!

What kind of Experience do you want to share?