Skip to content
Related Articles

Related Articles

Improve Article

Find the sum of all Truncatable primes below N

  • Last Updated : 03 Jun, 2021
Geek Week

Given an integer N, the task is to find the sum of all Truncatable primes below N. Truncatable prime is a number which is left-truncatable prime (if the leading (“left”) digit is successively removed, then all resulting numbers are prime) as well as right-truncatable prime (if the last (“right”) digit is successively removed, then all the resulting numbers are prime). 

For example, 3797 is left-truncatable prime because 797, 97 and 7 are primes. And, 3797 is also right-truncatable prime as 379, 37, and 3 are primes. Hence 3797 is a truncatable prime.

Examples:  

Input: N = 25 
Output: 40 
2, 3, 5, 7 and 23 are the only truncatable primes below 25. 
2 + 3 + 5 + 7 + 23 = 40

Input: N = 40 
Output: 77 
 



Approach: An efficient approach is to find all the prime numbers using Sieve of Eratosthenes and for every number below N check whether it is Truncatable prime or not. If yes then add is to the running sum. 

Below is the implementation of the above approach: 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
#define N 1000005
 
// To check if a number is prime or not
bool prime[N];
 
// Sieve of Eratosthenes
// function to find all prime numbers
void sieve()
{
    memset(prime, true, sizeof prime);
    prime[1] = false;
    prime[0] = false;
 
    for (int i = 2; i < N; i++)
        if (prime[i])
            for (int j = i * 2; j < N; j += i)
                prime[j] = false;
}
 
// Function to return the sum of
// all truncatable primes below n
int sumTruncatablePrimes(int n)
{
    // To store the required sum
    int sum = 0;
 
    // Check every number below n
    for (int i = 2; i < n; i++) {
 
        int num = i;
        bool flag = true;
 
        // Check from right to left
        while (num) {
 
            // If number is not prime at any stage
            if (!prime[num]) {
                flag = false;
                break;
            }
            num /= 10;
        }
 
        num = i;
        int power = 10;
 
        // Check from left to right
        while (num / power) {
 
            // If number is not prime at any stage
            if (!prime[num % power]) {
                flag = false;
                break;
            }
            power *= 10;
        }
 
        // If flag is still true
        if (flag)
            sum += i;
    }
 
    // Return the required sum
    return sum;
}
 
// Driver code
int main()
{
    int n = 25;
    sieve();
    cout << sumTruncatablePrimes(n);
 
    return 0;
}

Java




// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
    static final int N = 1000005;
 
    // To check if a number is prime or not
    static boolean prime[] = new boolean[N];
 
    // Sieve of Eratosthenes
    // function to find all prime numbers
    static void sieve()
    {
        Arrays.fill(prime, true);
        prime[1] = false;
        prime[0] = false;
 
        for (int i = 2; i < N; i++)
        {
            if (prime[i])
            {
                for (int j = i * 2; j < N; j += i)
                {
                    prime[j] = false;
                }
            }
        }
    }
 
    // Function to return the sum of
    // all truncatable primes below n
    static int sumTruncatablePrimes(int n)
    {
        // To store the required sum
        int sum = 0;
 
        // Check every number below n
        for (int i = 2; i < n; i++)
        {
 
            int num = i;
            boolean flag = true;
 
            // Check from right to left
            while (num > 0)
            {
 
                // If number is not prime at any stage
                if (!prime[num])
                {
                    flag = false;
                    break;
                }
                num /= 10;
            }
 
            num = i;
            int power = 10;
 
            // Check from left to right
            while (num / power > 0)
            {
 
                // If number is not prime at any stage
                if (!prime[num % power])
                {
                    flag = false;
                    break;
                }
                power *= 10;
            }
 
            // If flag is still true
            if (flag)
            {
                sum += i;
            }
        }
 
        // Return the required sum
        return sum;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int n = 25;
        sieve();
        System.out.println(sumTruncatablePrimes(n));
    }
}
 
// This code contributed by Rajput-Ji

Python3




# Python3 implementation of the
# above approach
N = 1000005
 
# To check if a number is prime or not
prime = [True for i in range(N)]
 
# Sieve of Eratosthenes
# function to find all prime numbers
def sieve():
    prime[1] = False
    prime[0] = False
 
    for i in range(2, N):
        if (prime[i]==True):
            for j in range(i * 2, N, i):
                prime[j] = False
 
# Function to return the sum of
# all truncatable primes below n
def sumTruncatablePrimes(n):
 
    # To store the required sum
    sum = 0
 
    # Check every number below n
    for i in range(2, n):
 
        num = i
        flag = True
 
        # Check from right to left
        while (num):
 
            # If number is not prime at any stage
            if (prime[num] == False):
                flag = False
                break
 
            num //= 10
 
        num = i
        power = 10
 
        # Check from left to right
        while (num // power):
 
            # If number is not prime at any stage
            if (prime[num % power] == False):
                flag = False
                break
 
            power *= 10
 
        # If flag is still true
        if (flag==True):
            sum += i
 
    # Return the required sum
    return sum
 
# Driver code
n = 25
sieve()
print(sumTruncatablePrimes(n))
 
# This code is contributed by mohit kumar

C#




// C# implementation of the above approach.
using System;
using System.Collections.Generic;
 
class GFG
{
 
    static int N = 1000005;
 
    // To check if a number is prime or not
    static Boolean []prime = new Boolean[N];
 
    // Sieve of Eratosthenes
    // function to find all prime numbers
    static void sieve()
    {
        Array.Fill(prime, true);
        prime[1] = false;
        prime[0] = false;
 
        for (int i = 2; i < N; i++)
        {
            if (prime[i])
            {
                for (int j = i * 2; j < N; j += i)
                {
                    prime[j] = false;
                }
            }
        }
    }
 
    // Function to return the sum of
    // all truncatable primes below n
    static int sumTruncatablePrimes(int n)
    {
        // To store the required sum
        int sum = 0;
 
        // Check every number below n
        for (int i = 2; i < n; i++)
        {
 
            int num = i;
            Boolean flag = true;
 
            // Check from right to left
            while (num > 0)
            {
 
                // If number is not prime at any stage
                if (!prime[num])
                {
                    flag = false;
                    break;
                }
                num /= 10;
            }
 
            num = i;
            int power = 10;
 
            // Check from left to right
            while (num / power > 0)
            {
 
                // If number is not prime at any stage
                if (!prime[num % power])
                {
                    flag = false;
                    break;
                }
                power *= 10;
            }
 
            // If flag is still true
            if (flag)
            {
                sum += i;
            }
        }
 
        // Return the required sum
        return sum;
    }
 
    // Driver code
    public static void Main(String []args)
    {
        int n = 25;
        sieve();
        Console.WriteLine(sumTruncatablePrimes(n));
    }
 
}
 
// This code has been contributed by Arnab Kundu

PHP




<?php
// PHP implementation of the approach
$N = 10005;
 
// To check if a number is prime or not
$prime = array_fill(0, $N, true);
 
// Sieve of Eratosthenes
// function to find all prime numbers
function sieve()
{
    global $prime, $N;
    $prime[1] = false;
    $prime[0] = false;
 
    for ($i = 2; $i < $N; $i++)
        if ($prime[$i])
            for ($j = $i * 2; $j < $N; $j += $i)
                $prime[$j] = false;
}
 
// Function to return the sum of
// all truncatable primes below n
function sumTruncatablePrimes($n)
{
    global $prime, $N;
     
    // To store the required sum
    $sum = 0;
 
    // Check every number below n
    for ($i = 2; $i < $n; $i++)
    {
        $num = $i;
        $flag = true;
 
        // Check from right to left
        while ($num)
        {
 
            // If number is not prime at any stage
            if (!$prime[$num])
            {
                $flag = false;
                break;
            }
            $num = (int)($num / 10);
        }
 
        $num = $i;
        $power = 10;
 
        // Check from left to right
        while ((int)($num / $power))
        {
 
            // If number is not prime at any stage
            if (!$prime[$num % $power])
            {
                $flag = false;
                break;
            }
            $power *= 10;
        }
 
        // If flag is still true
        if ($flag)
            $sum += $i;
    }
 
    // Return the required sum
    return $sum;
}
 
// Driver code
$n = 25;
sieve();
echo sumTruncatablePrimes($n);
 
// This code is contributed by mits
?>

Javascript




<script>
 
// Javascript implementation of the approach
let N = 1000005;
 
// To check if a number is prime or not
let prime = new Array(N);
     
// Sieve of Eratosthenes
// function to find all prime numbers
function sieve()
{
    for(let i = 0; i < prime.length; i++)
    {
        prime[i] = true;
    }
    prime[1] = false;
    prime[0] = false;
 
    for(let i = 2; i < N; i++)
    {
        if (prime[i])
        {
            for(let j = i * 2; j < N; j += i)
            {
                prime[j] = false;
            }
        }
    }
}
 
// Function to return the sum of
// all truncatable primes below n
function sumTruncatablePrimes(n)
{
     
    // To store the required sum
    let sum = 0;
 
    // Check every number below n
    for(let i = 2; i < n; i++)
    {
        let num = i;
        let flag = true;
 
        // Check from right to left
        while (num > 0)
        {
             
            // If number is not prime at any stage
            if (!prime[num])
            {
                flag = false;
                break;
            }
            num = Math.floor(num / 10);
        }
 
        num = i;
        let power = 10;
 
        // Check from left to right
        while (num / power > 0)
        {
 
            // If number is not prime at any stage
            if (!prime[num % power])
            {
                flag = false;
                break;
            }
            power *= 10;
        }
 
        // If flag is still true
        if (flag)
        {
            sum += i;
        }
    }
 
    // Return the required sum
    return sum;
}
 
// Driver code
let n = 25;
sieve();
 
document.write(sumTruncatablePrimes(n));
 
// This code is contributed by unknown2108
 
</script>
Output: 
40

 

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 :