Skip to content
Related Articles

Related Articles

Improve Article

Find all numbers between range L to R such that sum of digit and sum of square of digit is prime

  • Last Updated : 21 May, 2021

Given the range L and R, count all numbers between L to R such that sum of digits of each number and sum of square of digits of each number is Prime.
Note: 10 <= [L, R] <= 108

Examples:  

Input: L = 10, R = 20 
Output:
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 the digits of each number and the sum of the square of digits of each number and check whether they are both prime or not.
 



Efficient Approach:  

  • Now, if you look closely into the range, the number is 108 ie., and the largest number less than this will be 99999999, and the maximum number, can be formed is 8 * ( 9 * 9 ) = 648 (as the sum of squares of digits is 92 + 92 + … 8times,) so, we need only primes up to 648 only which can be done using Sieve of Eratosthenes.
  • Now iterate for each number in the range and check whether it satisfies the above conditions 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

Javascript




<script>
// Javascript implementation of the approach
 
// Sieve of prime numbers
function primesieve(prime) {
 
    // Sieve to store whether a
    // number is prime or not in
    // O(nlog(log(n)))
    prime[1] = false;
 
    for (let p = 2; p < Math.floor(Math.sqrt(650)) + 1; p++) {
        if (prime[p] == true) {
            for (let i = p * 2; i < 651; i += p) {
                prime[i] = false;
            }
        }
    }
}
   
// Function to return sum of digit
// and sum of square of digit
function sum_sqsum(n) {
 
    let sum = 0;
    let sqsum = 0;
    let x;
    // Until number is not
    // zero
    while (n) {
        x = n % 10;
        sum += x;
        sqsum += x * x;
        n = Math.floor(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
function countnumber(L, R) {
 
    let prime = new Array(651).fill(true);
 
    primesieve(prime);
 
    let cnt = 0;
 
    // Iterate for each value
    // in the range of L to R
    for (let i = L; i <= R; i++) {
 
        // digit.first stores sum of digits
        // digit.second stores sum of
        // square of digit
        let 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]] && prime[digit[1]]) {
            cnt += 1;
        }
    }
    return cnt;
}
 
// Driver Code
 
 
let L = 10;
let R = 20;
 
document.write(countnumber(L, R));
 
// This code is contributed by _saurabh_jaiswal
 
</script>
Output: 
4

 

Note:  

  1. Store all numbers which satisfy the above conditions in another array and use binary search to find out how many elements in the array such that it is less than R , say cnt1 , and how many elements in the array such that it less than L , say cnt2 . Return cnt1 – cnt2 
    Time Complexity: O(log(N)) per query.
  2. We can use a prefix array or DP approach such that it already stores how many no. are good of the above type, from index 0 to i, and return the 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.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :