# Find the sum of all Truncatable primes below N

• Last Updated : 15 Jun, 2022

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 ``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

 ``

## Javascript

 ``

Output:

`40`

Time Complexity: O(n*log(log(n))), time used for running sieve function
Auxiliary Space: O(N), extra space of size n used to create an array prime

My Personal Notes arrow_drop_up