Skip to content
Related Articles

Related Articles

Find all numbers between range L to R such that sum of digit and sum of square of digit is prime
  • Last Updated : 18 Sep, 2019

Given a range L and R count all numbers between L to R such that sum of digit of each number and sum of square of digit of each number is Prime.

Note: 10 <= [L, R] <= 108

Examples:

Input: L = 10, R = 20
Output: 4
Such types of numbers are: 11 12 14 16

Input: L = 100, R = 130
Output: 9



Such types of numbers are : 101 102 104 106 110 111 113 119 120

Naive Approach:
Just get the sum of digit of each number and sum of the square of digit of each number and to check whether they both are prime or not.

Efficient Approach:

    In this approach, there is an observation that can do the optimization:

  • Now if look closely into range the number is 108 ie., and largest number less than this will be 99999999 and maximum number can be formed is 8 * ( 9 * 9 ) = 648 (as the sum of digit square is 92 + 92 + … 8times) so we need only primes upto 648 only which can be done using Sieve of Eratosthenes.
  • Now iterate for each number in the range and check whether it satisfies above condition or not.

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Sieve of prime numbers
void primesieve(vector<bool>& prime)
{
    // Sieve to store whether a
    // number is prime or not in
    // O(nlog(log(n)))
    prime[1] = false;
  
    for (int p = 2; p * p <= 650; p++) {
        if (prime[p] == true) {
            for (int i = p * 2; i <= 650; i += p)
                prime[i] = false;
        }
    }
}
  
// Function to return sum of digit
// and sum of square of digit
pair<int, int> sum_sqsum(int n)
{
  
    int sum = 0;
    int sqsum = 0;
    int x;
  
    // Until number is not
    // zero
    while (n) {
        x = n % 10;
        sum += x;
        sqsum += x * x;
        n /= 10;
    }
  
    return (make_pair(sum, sqsum));
}
  
// Function to return the count
// of number form L to R
// whose sum of digits and
// sum of square of digits
// are prime
int countnumber(int L, int R)
{
  
    vector<bool> prime(651, true);
  
    primesieve(prime);
  
    int cnt = 0;
  
    // Iterate for each value
    // in the range of L to R
    for (int i = L; i <= R; i++) {
  
        // digit.first stores sum of digits
        // digit.second stores sum of
        // square of digit
        pair<int, int> digit = sum_sqsum(i);
  
        // If sum of digits and sum of
        // square of digit both are
        // prime then increment the count
        if (prime[digit.first]
            && prime[digit.second]) {
            cnt += 1;
        }
    }
  
    return cnt;
}
  
// Driver Code
int main()
{
  
    int L = 10;
    int R = 20;
  
    cout << countnumber(L, R);
}
Java



// Java implementation of the approach
import java.util.*;
  
class GFG 
{
static class pair
{ 
    int first, second; 
    public pair(int first, int second) 
    { 
        this.first = first; 
        this.second = second; 
    } 
}
  
// Sieve of prime numbers
static void primesieve(boolean []prime)
{
    // Sieve to store whether a
    // number is prime or not in
    // O(nlog(log(n)))
    prime[1] = false;
  
    for (int p = 2; p * p <= 650; p++)
    {
        if (prime[p] == true)
        {
            for (int i = p * 2; i <= 650; i += p)
                prime[i] = false;
        }
    }
}
  
// Function to return sum of digit
// and sum of square of digit
static pair sum_sqsum(int n)
{
    int sum = 0;
    int sqsum = 0;
    int x;
  
    // Until number is not
    // zero
    while (n > 0)
    {
        x = n % 10;
        sum += x;
        sqsum += x * x;
        n /= 10;
    }
    return (new pair(sum, sqsum));
}
  
// Function to return the count
// of number form L to R
// whose sum of digits and
// sum of square of digits
// are prime
static int countnumber(int L, int R)
{
    boolean []prime = new boolean[651];
  
    Arrays.fill(prime, true);
    primesieve(prime);
  
    int cnt = 0;
  
    // Iterate for each value
    // in the range of L to R
    for (int i = L; i <= R; i++) 
    {
  
        // digit.first stores sum of digits
        // digit.second stores sum of
        // square of digit
        pair digit = sum_sqsum(i);
  
        // If sum of digits and sum of
        // square of digit both are
        // prime then increment the count
        if (prime[digit.first] && 
            prime[digit.second]) 
        {
            cnt += 1;
        }
    }
    return cnt;
}
  
// Driver Code
public static void main(String[] args) 
{
    int L = 10;
    int R = 20;
  
    System.out.println(countnumber(L, R));
}
} 
  
// This code is contributed by PrinciRaj1992
Python3



# Python3 implementation of the approach 
from math import sqrt
  
# Sieve of prime numbers 
def primesieve(prime) :
  
    # Sieve to store whether a 
    # number is prime or not in 
    # O(nlog(log(n))) 
    prime[1] = False; 
  
    for p in range(2, int(sqrt(650)) + 1) :
        if (prime[p] == True) :
            for i in range(p * 2, 651, p) : 
                prime[i] = False; 
  
# Function to return sum of digit 
# and sum of square of digit 
def sum_sqsum(n) :
  
    sum = 0; 
    sqsum = 0; 
  
    # Until number is not 
    # zero 
    while (n) :
        x = n % 10; 
        sum += x; 
        sqsum += x * x; 
        n //= 10; 
  
    return (sum, sqsum); 
  
# Function to return the count 
# of number form L to R 
# whose sum of digits and 
# sum of square of digits 
# are prime 
def countnumber(L, R): 
  
    prime = [True] * 651; 
  
    primesieve(prime); 
  
    cnt = 0; 
  
    # Iterate for each value 
    # in the range of L to R 
    for i in range(L, R + 1) :
          
        # digit.first stores sum of digits 
        # digit.second stores sum of 
        # square of digit 
        digit = sum_sqsum(i); 
  
        # If sum of digits and sum of 
        # square of digit both are 
        # prime then increment the count 
        if (prime[digit[0]] and prime[digit[1]]) :
            cnt += 1; 
  
    return cnt; 
  
# Driver Code 
if __name__ == "__main__" : 
  
    L = 10; 
    R = 20; 
  
    print(countnumber(L, R)); 
  
# This code is contributed by AnkitRai01
C#



// C# implementation of the approach
using System;
      
class GFG 
{
public class pair
{ 
    public int first, second; 
    public pair(int first, int second) 
    { 
        this.first = first; 
        this.second = second; 
    } 
}
  
// Sieve of prime numbers
static void primesieve(bool []prime)
{
    // Sieve to store whether a
    // number is prime or not in
    // O(nlog(log(n)))
    prime[1] = false;
  
    for (int p = 2; p * p <= 650; p++)
    {
        if (prime[p] == true)
        {
            for (int i = p * 2;
                     i <= 650; i += p)
                prime[i] = false;
        }
    }
}
  
// Function to return sum of digit
// and sum of square of digit
static pair sum_sqsum(int n)
{
    int sum = 0;
    int sqsum = 0;
    int x;
  
    // Until number is not
    // zero
    while (n > 0)
    {
        x = n % 10;
        sum += x;
        sqsum += x * x;
        n /= 10;
    }
    return (new pair(sum, sqsum));
}
  
// Function to return the count
// of number form L to R
// whose sum of digits and
// sum of square of digits
// are prime
static int countnumber(int L, int R)
{
    bool []prime = new bool[651];
    for (int i = 0; i < 651; i++) 
        prime[i] = true;
    primesieve(prime);
  
    int cnt = 0;
  
    // Iterate for each value
    // in the range of L to R
    for (int i = L; i <= R; i++) 
    {
  
        // digit.first stores sum of digits
        // digit.second stores sum of
        // square of digit
        pair digit = sum_sqsum(i);
  
        // If sum of digits and sum of
        // square of digit both are
        // prime then increment the count
        if (prime[digit.first] && 
            prime[digit.second]) 
        {
            cnt += 1;
        }
    }
    return cnt;
}
  
// Driver Code
public static void Main(String[] args) 
{
    int L = 10;
    int R = 20;
  
    Console.WriteLine(countnumber(L, R));
}
}
  
// This code is contributed by 29AjayKumar
Output:
4

Note:
    If there are multiple queries asked to find out numbers between range from L and R there will be 2 approaches:
  1. Store all number which satisfies above condition in another array and use binary search to find out how many elements in array such that it less than R , say cnt1 , and how many elements in array such that it less than L , say cnt2 . Return cnt1 – cnt2
    Time Complexity: O(log(N)) per query.
  2. We can use prefix array or DP approach such that it already stores how many no. are good of above type from index 0 to i, and return total count by giving DP[R] – DP[L-1]
    Time Complexity: O(1) per query.
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.
My Personal Notes
arrow_drop_up
Previous
Find two co-prime integers such that the first divides A and the second divides B
Next

Minimum given operations required to convert a given binary string to all 1's
Recommended Articles
Page :
Count numbers in a given range having prime and non-prime digits at prime and non-prime positions respectively
15, Jan 21
Print numbers such that no two consecutive numbers are co-prime and every three consecutive numbers are co-prime
22, Jan 19
Count all prime numbers in a given range whose sum of digits is also prime
30, Jun 20
Absolute Difference between the Sum of Non-Prime numbers and Prime numbers of an Array
02, Nov 18
Queries to count integers in a range [L, R] such that their digit sum is prime and divisible by K
20, Nov 19
Absolute difference between the Product of Non-Prime numbers and Prime numbers of an Array
03, Nov 18
Absolute difference between the XOR of Non-Prime numbers and Prime numbers of an Array
23, Sep 19
Find the highest occurring digit in prime numbers in a range
24, Dec 16
Sum of all prime divisors of all the numbers in range L-R
14, Aug 18
Count numbers in a given range whose count of prime factors is a Prime Number
28, Oct 20
Count prime numbers that can be expressed as sum of consecutive prime numbers
10, Sep 20
Count prime numbers up to N that can be represented as a sum of two prime numbers
14, Apr 21
Permutation of first N positive integers such that prime numbers are at prime indices | Set 2
29, Apr 20
Permutation of first N positive integers such that prime numbers are at prime indices
08, Apr 20
Numbers in range [L, R] such that the count of their divisors is both even and prime
29, Oct 18
Count of Numbers in Range where first digit is equal to last digit of the number
26, Dec 18
Count Numbers in Range with difference between Sum of digits at even and odd positions as Prime
22, Feb 19
C/C++ Program to find Prime Numbers between given range
08, Jul 20
Sum of all the prime numbers in a given range
28, Oct 18
Print all numbers whose set of prime factors is a subset of the set of the prime factors of X
22, Apr 19
Queries for the difference between the count of composite and prime numbers in a given range
28, May 19
Count pairs from a given range whose sum is a Prime Number in that range
11, Nov 20
Count distinct prime triplets up to N such that sum of two primes is equal to the third prime
09, Feb 21
Count occurrences of a prime number in the prime factorization of every element from the given range
11, Sep 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Chandan_Agrawal
@Chandan_Agrawal
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox