# Find the all left truncatable primes in n natural numbers

Here given code implementation process.

``````// C program for
// Find the all left truncatable primes in n natural numbers
#include <stdio.h>

// Find all prime numbers which have smaller and equal to given number n
void sieveOfEratosthenes(int prime[], int n)
{
// Loop controlling variables
int i;
int j;
// Initial two numbers are not prime (0 and 1)
prime[0] = 0;
prime[1] = 0;
// Set the initial (2 to n element is prime)
for (i = 2; i <= n; ++i)
{
prime[i] = 1;
}
// Initial 0 and 1 are not prime
// We start to 2
for (i = 2; i *i <= n; ++i)
{
if (prime[i] == 1)
{
//When i is prime number
//Modify the prime status of all next multiplier of location i
for (j = i *i; j <= n; j += i)
{
prime[j] = 0;
}
}
}
}
void leftTruncatablePrime(int n)
{
if (n <= 1)
{
return;
}
int prime[n + 1];
sieveOfEratosthenes(prime, n);
printf("\n Given n : %d", n);
printf("\n");
for (int i = 2; i <= n; ++i)
{
if (prime[i] == 1)
{
int temp = i;
int count = 1;
int zero = 0;
// Count number of digits
while (zero == 0 && temp > 9)
{
if (temp % 10 == 0)
{
zero++;
}
temp = temp / 10;
count = count *10;
}
int k = count;
temp = i;
while (zero == 0 && temp > 0 && prime[temp] == 1)
{
// Remove last digit
temp = temp - ((temp / count) *count);
count = count / 10;
}
if (temp == 0)
{
printf("\n %d : ", i);
count = k;
temp = i;
while (temp > 0 && prime[temp] == 1)
{
printf(" %d ", temp);
// Remove last digit
temp = temp - ((temp / count) *count);
count = count / 10;
}
}
}
}
}
int main(int argc, char
const *argv[])
{
// Test A
// n = 30
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
----------
*/
leftTruncatablePrime(30);
// Test B
// n = 1000
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7
----------------
[Remove left digit]
Example prime = 823
823
23
3
----------------------
All is prime so 823
left truncatable prime
*/
leftTruncatablePrime(1000);
return 0;
}``````

#### Output

`````` Given n : 30

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
Given n : 1000

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7``````
``````/*
Java Program for
Find the all left truncatable primes in n natural numbers
*/
public class TruncatablePrimes
{
// Find all prime numbers which have smaller and equal
// to given number n
public void sieveOfEratosthenes(boolean[] prime, int n)
{
// Initial two numbers are not prime (0 and 1)
prime[0] = false;
prime[1] = false;
// Set the initial (2 to n element is prime)
for (int i = 2; i <= n; ++i)
{
prime[i] = true;
}
// Initial 0 and 1 are not prime
// We start to 2
for (int i = 2; i * i <= n; ++i)
{
if (prime[i] == true)
{
// When i is prime number
// Modify the prime status of all next
// multiplier of location i
for (int j = i * i; j <= n; j += i)
{
prime[j] = false;
}
}
}
}
public void leftTruncatablePrime(int n)
{
if (n <= 1)
{
return;
}
boolean[] prime = new boolean[n + 1];
sieveOfEratosthenes(prime, n);
System.out.print("\n Given n : " + n);
System.out.print("\n");
for (int i = 2; i <= n; ++i)
{
if (prime[i] == true)
{
int temp = i;
int count = 1;
int zero = 0;
// Count number of digits
while (zero == 0 && temp > 9)
{
if (temp % 10 == 0)
{
zero++;
}
temp = temp / 10;
count = count * 10;
}
int k = count;
temp = i;
while (zero == 0 && temp > 0 && prime[temp] == true)
{
// Remove last digit
temp = temp - ((temp / count) * count);
count = count / 10;
}
if (temp == 0)
{
System.out.print("\n " + i + " : ");
count = k;
temp = i;
while (temp > 0 && prime[temp] == true)
{
System.out.print(" " + temp);
// Remove last digit
temp = temp - ((temp / count) * count);
count = count / 10;
}
}
}
}
}
public static void main(String[] args)
{
// Test A
// n = 30
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
----------
*/
// Test B
// n = 1000
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7
----------------
[Remove left digit]
Example prime = 823
823
23
3
----------------------
All is prime so 823
left truncatable prime
*/
}
}``````

#### Output

`````` Given n : 30

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
Given n : 1000

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
37 :  37 7
43 :  43 3
47 :  47 7
53 :  53 3
67 :  67 7
73 :  73 3
83 :  83 3
97 :  97 7
113 :  113 13 3
137 :  137 37 7
167 :  167 67 7
173 :  173 73 3
197 :  197 97 7
223 :  223 23 3
283 :  283 83 3
313 :  313 13 3
317 :  317 17 7
337 :  337 37 7
347 :  347 47 7
353 :  353 53 3
367 :  367 67 7
373 :  373 73 3
383 :  383 83 3
397 :  397 97 7
443 :  443 43 3
467 :  467 67 7
523 :  523 23 3
547 :  547 47 7
613 :  613 13 3
617 :  617 17 7
643 :  643 43 3
647 :  647 47 7
653 :  653 53 3
673 :  673 73 3
683 :  683 83 3
743 :  743 43 3
773 :  773 73 3
797 :  797 97 7
823 :  823 23 3
853 :  853 53 3
883 :  883 83 3
937 :  937 37 7
947 :  947 47 7
953 :  953 53 3
967 :  967 67 7
983 :  983 83 3
997 :  997 97 7``````
``````// Include header file
#include <iostream>

using namespace std;
/*
C++ Program for
Find the all left truncatable primes in n natural numbers
*/
class TruncatablePrimes
{
public:
// Find all prime numbers which have smaller and equal
// to given number n
void sieveOfEratosthenes(bool prime[], int n)
{
// Initial two numbers are not prime (0 and 1)
prime[0] = false;
prime[1] = false;
// Set the initial (2 to n element is prime)
for (int i = 2; i <= n; ++i)
{
prime[i] = true;
}
// Initial 0 and 1 are not prime
// We start to 2
for (int i = 2; i *i <= n; ++i)
{
if (prime[i] == true)
{
// When i is prime number
// Modify the prime status of all next
// multiplier of location i
for (int j = i *i; j <= n; j += i)
{
prime[j] = false;
}
}
}
}
void leftTruncatablePrime(int n)
{
if (n <= 1)
{
return;
}
bool prime[n + 1];
this->sieveOfEratosthenes(prime, n);
cout << "\n Given n : " << n;
cout << "\n";
for (int i = 2; i <= n; ++i)
{
if (prime[i] == true)
{
int temp = i;
int count = 1;
int zero = 0;
// Count number of digits
while (zero == 0 && temp > 9)
{
if (temp % 10 == 0)
{
zero++;
}
temp = temp / 10;
count = count *10;
}
int k = count;
temp = i;
while (zero == 0 && temp > 0 && prime[temp] == true)
{
// Remove last digit
temp = temp - ((temp / count) *count);
count = count / 10;
}
if (temp == 0)
{
cout << "\n " << i << " : ";
count = k;
temp = i;
while (temp > 0 && prime[temp] == true)
{
cout << " " << temp;
// Remove last digit
temp = temp - ((temp / count) *count);
count = count / 10;
}
}
}
}
}
};
int main()
{
// Test A
// n = 30
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
----------
*/
// Test B
// n = 1000
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7
----------------
[Remove left digit]
Example prime = 823
823
23
3
----------------------
All is prime so 823
left truncatable prime
*/
return 0;
}``````

#### Output

`````` Given n : 30

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
Given n : 1000

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
37 :  37 7
43 :  43 3
47 :  47 7
53 :  53 3
67 :  67 7
73 :  73 3
83 :  83 3
97 :  97 7
113 :  113 13 3
137 :  137 37 7
167 :  167 67 7
173 :  173 73 3
197 :  197 97 7
223 :  223 23 3
283 :  283 83 3
313 :  313 13 3
317 :  317 17 7
337 :  337 37 7
347 :  347 47 7
353 :  353 53 3
367 :  367 67 7
373 :  373 73 3
383 :  383 83 3
397 :  397 97 7
443 :  443 43 3
467 :  467 67 7
523 :  523 23 3
547 :  547 47 7
613 :  613 13 3
617 :  617 17 7
643 :  643 43 3
647 :  647 47 7
653 :  653 53 3
673 :  673 73 3
683 :  683 83 3
743 :  743 43 3
773 :  773 73 3
797 :  797 97 7
823 :  823 23 3
853 :  853 53 3
883 :  883 83 3
937 :  937 37 7
947 :  947 47 7
953 :  953 53 3
967 :  967 67 7
983 :  983 83 3
997 :  997 97 7``````
``````// Include namespace system
using System;
/*
Csharp Program for
Find the all left truncatable primes in n natural numbers
*/
public class TruncatablePrimes
{
// Find all prime numbers which have smaller and equal
// to given number n
public void sieveOfEratosthenes(Boolean[] prime, int n)
{
// Initial two numbers are not prime (0 and 1)
prime[0] = false;
prime[1] = false;
// Set the initial (2 to n element is prime)
for (int i = 2; i <= n; ++i)
{
prime[i] = true;
}
// Initial 0 and 1 are not prime
// We start to 2
for (int i = 2; i * i <= n; ++i)
{
if (prime[i] == true)
{
// When i is prime number
// Modify the prime status of all next
// multiplier of location i
for (int j = i * i; j <= n; j += i)
{
prime[j] = false;
}
}
}
}
public void leftTruncatablePrime(int n)
{
if (n <= 1)
{
return;
}
Boolean[] prime = new Boolean[n + 1];
this.sieveOfEratosthenes(prime, n);
Console.Write("\n Given n : " + n);
Console.Write("\n");
for (int i = 2; i <= n; ++i)
{
if (prime[i] == true)
{
int temp = i;
int count = 1;
int zero = 0;
// Count number of digits
while (zero == 0 && temp > 9)
{
if (temp % 10 == 0)
{
zero++;
}
temp = temp / 10;
count = count * 10;
}
int k = count;
temp = i;
while (zero == 0 && temp > 0 && prime[temp] == true)
{
// Remove last digit
temp = temp - ((temp / count) * count);
count = count / 10;
}
if (temp == 0)
{
Console.Write("\n " + i + " : ");
count = k;
temp = i;
while (temp > 0 && prime[temp] == true)
{
Console.Write(" " + temp);
// Remove last digit
temp = temp - ((temp / count) * count);
count = count / 10;
}
}
}
}
}
public static void Main(String[] args)
{
// Test A
// n = 30
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
----------
*/
// Test B
// n = 1000
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7
----------------
[Remove left digit]
Example prime = 823
823
23
3
----------------------
All is prime so 823
left truncatable prime
*/
}
}``````

#### Output

`````` Given n : 30

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
Given n : 1000

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
37 :  37 7
43 :  43 3
47 :  47 7
53 :  53 3
67 :  67 7
73 :  73 3
83 :  83 3
97 :  97 7
113 :  113 13 3
137 :  137 37 7
167 :  167 67 7
173 :  173 73 3
197 :  197 97 7
223 :  223 23 3
283 :  283 83 3
313 :  313 13 3
317 :  317 17 7
337 :  337 37 7
347 :  347 47 7
353 :  353 53 3
367 :  367 67 7
373 :  373 73 3
383 :  383 83 3
397 :  397 97 7
443 :  443 43 3
467 :  467 67 7
523 :  523 23 3
547 :  547 47 7
613 :  613 13 3
617 :  617 17 7
643 :  643 43 3
647 :  647 47 7
653 :  653 53 3
673 :  673 73 3
683 :  683 83 3
743 :  743 43 3
773 :  773 73 3
797 :  797 97 7
823 :  823 23 3
853 :  853 53 3
883 :  883 83 3
937 :  937 37 7
947 :  947 47 7
953 :  953 53 3
967 :  967 67 7
983 :  983 83 3
997 :  997 97 7``````
``````package main
import "fmt"
/*
Go Program for
Find the all left truncatable primes in n natural numbers
*/
type TruncatablePrimes struct {}
func getTruncatablePrimes() * TruncatablePrimes {
var me *TruncatablePrimes = &TruncatablePrimes {}
return me
}
// Find all prime numbers which have smaller and equal
// to given number n
func(this TruncatablePrimes) sieveOfEratosthenes(prime[] bool, n int) {
// Initial two numbers are not prime (0 and 1)
prime[0] = false
prime[1] = false
// Set the initial (2 to n element is prime)
for i := 2 ; i <= n ; i++ {
prime[i] = true
}
// Initial 0 and 1 are not prime
// We start to 2
for i := 2 ; i * i <= n ; i++ {
if prime[i] == true {
// When i is prime number
// Modify the prime status of all next
// multiplier of location i
for j := i * i ; j <= n ; j += i {
prime[j] = false
}
}
}
}
func(this TruncatablePrimes) leftTruncatablePrime(n int) {
if n <= 1 {
return
}
var prime = make([] bool, n + 1)
this.sieveOfEratosthenes(prime, n)
fmt.Print("\n Given n : ", n)
fmt.Print("\n")
for i := 2 ; i <= n ; i++ {
if prime[i] == true {
var temp int = i
var count int = 1
var zero int = 0
// Count number of digits
for (zero == 0 && temp > 9) {
if temp % 10 == 0 {
zero++
}
temp = temp / 10
count = count * 10
}
var k int = count
temp = i
for (zero == 0 && temp > 0 && prime[temp] == true) {
// Remove last digit
temp = temp - ((temp / count) * count)
count = count / 10
}
if temp == 0 {
fmt.Print("\n ", i, " : ")
count = k
temp = i
for (temp > 0 && prime[temp] == true) {
fmt.Print(" ", temp)
// Remove last digit
temp = temp - ((temp / count) * count)
count = count / 10
}
}
}
}
}
func main() {
var task * TruncatablePrimes = getTruncatablePrimes()
// Test A
// n = 30
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
----------
*/
// Test B
// n = 1000
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7
----------------
[Remove left digit]
Example prime = 823
823
23
3
----------------------
All is prime so 823
left truncatable prime
*/
}``````

#### Output

`````` Given n : 30

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
Given n : 1000

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
37 :  37 7
43 :  43 3
47 :  47 7
53 :  53 3
67 :  67 7
73 :  73 3
83 :  83 3
97 :  97 7
113 :  113 13 3
137 :  137 37 7
167 :  167 67 7
173 :  173 73 3
197 :  197 97 7
223 :  223 23 3
283 :  283 83 3
313 :  313 13 3
317 :  317 17 7
337 :  337 37 7
347 :  347 47 7
353 :  353 53 3
367 :  367 67 7
373 :  373 73 3
383 :  383 83 3
397 :  397 97 7
443 :  443 43 3
467 :  467 67 7
523 :  523 23 3
547 :  547 47 7
613 :  613 13 3
617 :  617 17 7
643 :  643 43 3
647 :  647 47 7
653 :  653 53 3
673 :  673 73 3
683 :  683 83 3
743 :  743 43 3
773 :  773 73 3
797 :  797 97 7
823 :  823 23 3
853 :  853 53 3
883 :  883 83 3
937 :  937 37 7
947 :  947 47 7
953 :  953 53 3
967 :  967 67 7
983 :  983 83 3
997 :  997 97 7``````
``````<?php
/*
Php Program for
Find the all left truncatable primes in n natural numbers
*/
class TruncatablePrimes
{
// Find all prime numbers which have smaller and equal
// to given number n
public	function sieveOfEratosthenes(&\$prime, \$n)
{
// Initial two numbers are not prime (0 and 1)
\$prime[0] = false;
\$prime[1] = false;
// Initial 0 and 1 are not prime
// We start to 2
for (\$i = 2; \$i * \$i <= \$n; ++\$i)
{
if (\$prime[\$i] == true)
{
// When i is prime number
// Modify the prime status of all next
// multiplier of location i
for (\$j = \$i * \$i; \$j <= \$n; \$j += \$i)
{
\$prime[\$j] = false;
}
}
}
}
public	function leftTruncatablePrime(\$n)
{
if (\$n <= 1)
{
return;
}
\$prime = array_fill(0, \$n + 1, true);
\$this->sieveOfEratosthenes(\$prime, \$n);
echo("\n Given n : ".\$n);
echo("\n");
for (\$i = 2; \$i <= \$n; ++\$i)
{
if (\$prime[\$i] == true)
{
\$temp = \$i;
\$count = 1;
\$zero = 0;
// Count number of digits
while (\$zero == 0 && \$temp > 9)
{
if (\$temp % 10 == 0)
{
\$zero++;
}
\$temp = (int)(\$temp / 10);
\$count = \$count * 10;
}
\$k = \$count;
\$temp = \$i;
while (\$zero == 0 && \$temp > 0 && \$prime[\$temp] == true)
{
// Remove last digit
\$temp = \$temp - (((int)(\$temp / \$count)) * \$count);
\$count = (int)(\$count / 10);
}
if (\$temp == 0)
{
echo("\n ".\$i.
" : ");
\$count = \$k;
\$temp = \$i;
while (\$temp > 0 && \$prime[\$temp] == true)
{
echo(" ".\$temp);
// Remove last digit
\$temp = \$temp - (((int)(\$temp / \$count)) * \$count);
\$count = (int)(\$count / 10);
}
}
}
}
}
}

function main()
{
// Test A
// n = 30
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
----------
*/
// Test B
// n = 1000
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7
----------------
[Remove left digit]
Example prime = 823
823
23
3
----------------------
All is prime so 823
left truncatable prime
*/
}
main();``````

#### Output

`````` Given n : 30

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
Given n : 1000

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
37 :  37 7
43 :  43 3
47 :  47 7
53 :  53 3
67 :  67 7
73 :  73 3
83 :  83 3
97 :  97 7
113 :  113 13 3
137 :  137 37 7
167 :  167 67 7
173 :  173 73 3
197 :  197 97 7
223 :  223 23 3
283 :  283 83 3
313 :  313 13 3
317 :  317 17 7
337 :  337 37 7
347 :  347 47 7
353 :  353 53 3
367 :  367 67 7
373 :  373 73 3
383 :  383 83 3
397 :  397 97 7
443 :  443 43 3
467 :  467 67 7
523 :  523 23 3
547 :  547 47 7
613 :  613 13 3
617 :  617 17 7
643 :  643 43 3
647 :  647 47 7
653 :  653 53 3
673 :  673 73 3
683 :  683 83 3
743 :  743 43 3
773 :  773 73 3
797 :  797 97 7
823 :  823 23 3
853 :  853 53 3
883 :  883 83 3
937 :  937 37 7
947 :  947 47 7
953 :  953 53 3
967 :  967 67 7
983 :  983 83 3
997 :  997 97 7``````
``````/*
Node JS Program for
Find the all left truncatable primes in n natural numbers
*/
class TruncatablePrimes
{
// Find all prime numbers which have smaller and equal
// to given number n
sieveOfEratosthenes(prime, n)
{
// Initial two numbers are not prime (0 and 1)
prime[0] = false;
prime[1] = false;
// Initial 0 and 1 are not prime
// We start to 2
for (var i = 2; i * i <= n; ++i)
{
if (prime[i] == true)
{
// When i is prime number
// Modify the prime status of all next
// multiplier of location i
for (var j = i * i; j <= n; j += i)
{
prime[j] = false;
}
}
}
}
leftTruncatablePrime(n)
{
if (n <= 1)
{
return;
}
var prime = Array(n + 1).fill(true);
this.sieveOfEratosthenes(prime, n);
process.stdout.write("\n Given n : " + n);
process.stdout.write("\n");
for (var i = 2; i <= n; ++i)
{
if (prime[i] == true)
{
var temp = i;
var count = 1;
var zero = 0;
// Count number of digits
while (zero == 0 && temp > 9)
{
if (temp % 10 == 0)
{
zero++;
}
temp = parseInt(temp / 10);
count = count * 10;
}
var k = count;
temp = i;
while (zero == 0 && temp > 0 && prime[temp] == true)
{
// Remove last digit
temp = temp - ((parseInt(temp / count)) * count);
count = parseInt(count / 10);
}
if (temp == 0)
{
process.stdout.write("\n " + i + " : ");
count = k;
temp = i;
while (temp > 0 && prime[temp] == true)
{
process.stdout.write(" " + temp);
// Remove last digit
temp = temp - ((parseInt(temp / count)) * count);
count = parseInt(count / 10);
}
}
}
}
}
}

function main()
{
// Test A
// n = 30
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
----------
*/
// Test B
// n = 1000
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7
----------------
[Remove left digit]
Example prime = 823
823
23
3
----------------------
All is prime so 823
left truncatable prime
*/
}
main();``````

#### Output

`````` Given n : 30

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
Given n : 1000

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
37 :  37 7
43 :  43 3
47 :  47 7
53 :  53 3
67 :  67 7
73 :  73 3
83 :  83 3
97 :  97 7
113 :  113 13 3
137 :  137 37 7
167 :  167 67 7
173 :  173 73 3
197 :  197 97 7
223 :  223 23 3
283 :  283 83 3
313 :  313 13 3
317 :  317 17 7
337 :  337 37 7
347 :  347 47 7
353 :  353 53 3
367 :  367 67 7
373 :  373 73 3
383 :  383 83 3
397 :  397 97 7
443 :  443 43 3
467 :  467 67 7
523 :  523 23 3
547 :  547 47 7
613 :  613 13 3
617 :  617 17 7
643 :  643 43 3
647 :  647 47 7
653 :  653 53 3
673 :  673 73 3
683 :  683 83 3
743 :  743 43 3
773 :  773 73 3
797 :  797 97 7
823 :  823 23 3
853 :  853 53 3
883 :  883 83 3
937 :  937 37 7
947 :  947 47 7
953 :  953 53 3
967 :  967 67 7
983 :  983 83 3
997 :  997 97 7``````
``````#   Python 3 Program for
#   Find the all left truncatable primes in n natural numbers
class TruncatablePrimes :
#  Find all prime numbers which have smaller and equal
#  to given number n
def sieveOfEratosthenes(self, prime, n) :
#  Initial two numbers are not prime (0 and 1)
prime[0] = False
prime[1] = False
i = 2
#  Initial 0 and 1 are not prime
#  We start to 2
while (i * i <= n) :
if (prime[i] == True) :
j = i * i
#  When i is prime number
#  Modify the prime status of all next
#  multiplier of location i
while (j <= n) :
prime[j] = False
j += i

i += 1

def leftTruncatablePrime(self, n) :
if (n <= 1) :
return

prime = [True] * (n + 1)
self.sieveOfEratosthenes(prime, n)
print("\n Given n : ", n, end = "")
print(end = "\n")
i = 2
while (i <= n) :
if (prime[i] == True) :
temp = i
count = 1
zero = 0
#  Count number of digits
while (zero == 0 and temp > 9) :
if (temp % 10 == 0) :
zero += 1

temp = int(temp / 10)
count = count * 10

k = count
temp = i
while (zero == 0 and temp > 0 and prime[temp] == True) :
#  Remove last digit
temp = temp - ((int(temp / count)) * count)
count = int(count / 10)

if (temp == 0) :
print("\n ", i ," : ", end = "")
count = k
temp = i
while (temp > 0 and prime[temp] == True) :
print(" ", temp, end = "")
#  Remove last digit
temp = temp - ((int(temp / count)) * count)
count = int(count / 10)

i += 1

def main() :
#  Test A
#  n = 30
#    2 :  2
#    3 :  3
#    5 :  5
#    7 :  7
#    13 :  13  3
#    17 :  17  7
#    23 :  23  3
# ----------
#  Test B
#  n = 1000
#    2 :  2
#    3 :  3
#    5 :  5
#    7 :  7
#    13 :  13  3
#    17 :  17  7
#    23 :  23  3
#    37 :  37  7
#    43 :  43  3
#    47 :  47  7
#    53 :  53  3
#    67 :  67  7
#    73 :  73  3
#    83 :  83  3
#    97 :  97  7
#    113 :  113  13  3
#    137 :  137  37  7
#    167 :  167  67  7
#    173 :  173  73  3
#    197 :  197  97  7
#    223 :  223  23  3
#    283 :  283  83  3
#    313 :  313  13  3
#    317 :  317  17  7
#    337 :  337  37  7
#    347 :  347  47  7
#    353 :  353  53  3
#    367 :  367  67  7
#    373 :  373  73  3
#    383 :  383  83  3
#    397 :  397  97  7
#    443 :  443  43  3
#    467 :  467  67  7
#    523 :  523  23  3
#    547 :  547  47  7
#    613 :  613  13  3
#    617 :  617  17  7
#    643 :  643  43  3
#    647 :  647  47  7
#    653 :  653  53  3
#    673 :  673  73  3
#    683 :  683  83  3
#    743 :  743  43  3
#    773 :  773  73  3
#    797 :  797  97  7
#    823 :  823  23  3
#    853 :  853  53  3
#    883 :  883  83  3
#    937 :  937  37  7
#    947 :  947  47  7
#    953 :  953  53  3
#    967 :  967  67  7
#    983 :  983  83  3
#    997 :  997  97  7
#    ----------------
#    [Remove left digit]
#    Example prime = 823
#    823
#    23
#    3
#    ----------------------
#    All is prime so 823
#    left truncatable prime

if __name__ == "__main__": main()``````

#### Output

`````` Given n :  30

2  :   2
3  :   3
5  :   5
7  :   7
13  :   13  3
17  :   17  7
23  :   23  3
Given n :  1000

2  :   2
3  :   3
5  :   5
7  :   7
13  :   13  3
17  :   17  7
23  :   23  3
37  :   37  7
43  :   43  3
47  :   47  7
53  :   53  3
67  :   67  7
73  :   73  3
83  :   83  3
97  :   97  7
113  :   113  13  3
137  :   137  37  7
167  :   167  67  7
173  :   173  73  3
197  :   197  97  7
223  :   223  23  3
283  :   283  83  3
313  :   313  13  3
317  :   317  17  7
337  :   337  37  7
347  :   347  47  7
353  :   353  53  3
367  :   367  67  7
373  :   373  73  3
383  :   383  83  3
397  :   397  97  7
443  :   443  43  3
467  :   467  67  7
523  :   523  23  3
547  :   547  47  7
613  :   613  13  3
617  :   617  17  7
643  :   643  43  3
647  :   647  47  7
653  :   653  53  3
673  :   673  73  3
683  :   683  83  3
743  :   743  43  3
773  :   773  73  3
797  :   797  97  7
823  :   823  23  3
853  :   853  53  3
883  :   883  83  3
937  :   937  37  7
947  :   947  47  7
953  :   953  53  3
967  :   967  67  7
983  :   983  83  3
997  :   997  97  7``````
``````#  Ruby Program for
#  Find the all left truncatable primes in n natural numbers
class TruncatablePrimes
#  Find all prime numbers which have smaller and equal
#  to given number n
def sieveOfEratosthenes(prime, n)
#  Initial two numbers are not prime (0 and 1)
prime[0] = false
prime[1] = false
i = 2
#  Initial 0 and 1 are not prime
#  We start to 2
while (i * i <= n)
if (prime[i] == true)
j = i * i
#  When i is prime number
#  Modify the prime status of all next
#  multiplier of location i
while (j <= n)
prime[j] = false
j += i
end

end

i += 1
end

end

def leftTruncatablePrime(n)
if (n <= 1)
return
end

prime = Array.new(n + 1) {true}
self.sieveOfEratosthenes(prime, n)
print("\n Given n : ", n)
print("\n")
i = 2
while (i <= n)
if (prime[i] == true)
temp = i
count = 1
zero = 0
#  Count number of digits
while (zero == 0 && temp > 9)
if (temp % 10 == 0)
zero += 1
end

temp = temp / 10
count = count * 10
end

k = count
temp = i
while (zero == 0 && temp > 0 && prime[temp] == true)
#  Remove last digit
temp = temp - ((temp / count) * count)
count = count / 10
end

if (temp == 0)
print("\n ", i ," : ")
count = k
temp = i
while (temp > 0 && prime[temp] == true)
print(" ", temp)
#  Remove last digit
temp = temp - ((temp / count) * count)
count = count / 10
end

end

end

i += 1
end

end

end

def main()
#  Test A
#  n = 30
#    2 :  2
#    3 :  3
#    5 :  5
#    7 :  7
#    13 :  13  3
#    17 :  17  7
#    23 :  23  3
# ----------
#  Test B
#  n = 1000
#    2 :  2
#    3 :  3
#    5 :  5
#    7 :  7
#    13 :  13  3
#    17 :  17  7
#    23 :  23  3
#    37 :  37  7
#    43 :  43  3
#    47 :  47  7
#    53 :  53  3
#    67 :  67  7
#    73 :  73  3
#    83 :  83  3
#    97 :  97  7
#    113 :  113  13  3
#    137 :  137  37  7
#    167 :  167  67  7
#    173 :  173  73  3
#    197 :  197  97  7
#    223 :  223  23  3
#    283 :  283  83  3
#    313 :  313  13  3
#    317 :  317  17  7
#    337 :  337  37  7
#    347 :  347  47  7
#    353 :  353  53  3
#    367 :  367  67  7
#    373 :  373  73  3
#    383 :  383  83  3
#    397 :  397  97  7
#    443 :  443  43  3
#    467 :  467  67  7
#    523 :  523  23  3
#    547 :  547  47  7
#    613 :  613  13  3
#    617 :  617  17  7
#    643 :  643  43  3
#    647 :  647  47  7
#    653 :  653  53  3
#    673 :  673  73  3
#    683 :  683  83  3
#    743 :  743  43  3
#    773 :  773  73  3
#    797 :  797  97  7
#    823 :  823  23  3
#    853 :  853  53  3
#    883 :  883  83  3
#    937 :  937  37  7
#    947 :  947  47  7
#    953 :  953  53  3
#    967 :  967  67  7
#    983 :  983  83  3
#    997 :  997  97  7
#    ----------------
#    [Remove left digit]
#    Example prime = 823
#    823
#    23
#    3
#    ----------------------
#    All is prime so 823
#    left truncatable prime
end

main()``````

#### Output

`````` Given n : 30

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
Given n : 1000

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
37 :  37 7
43 :  43 3
47 :  47 7
53 :  53 3
67 :  67 7
73 :  73 3
83 :  83 3
97 :  97 7
113 :  113 13 3
137 :  137 37 7
167 :  167 67 7
173 :  173 73 3
197 :  197 97 7
223 :  223 23 3
283 :  283 83 3
313 :  313 13 3
317 :  317 17 7
337 :  337 37 7
347 :  347 47 7
353 :  353 53 3
367 :  367 67 7
373 :  373 73 3
383 :  383 83 3
397 :  397 97 7
443 :  443 43 3
467 :  467 67 7
523 :  523 23 3
547 :  547 47 7
613 :  613 13 3
617 :  617 17 7
643 :  643 43 3
647 :  647 47 7
653 :  653 53 3
673 :  673 73 3
683 :  683 83 3
743 :  743 43 3
773 :  773 73 3
797 :  797 97 7
823 :  823 23 3
853 :  853 53 3
883 :  883 83 3
937 :  937 37 7
947 :  947 47 7
953 :  953 53 3
967 :  967 67 7
983 :  983 83 3
997 :  997 97 7``````
``````/*
Scala Program for
Find the all left truncatable primes in n natural numbers
*/
class TruncatablePrimes()
{
// Find all prime numbers which have smaller and equal
// to given number n
def sieveOfEratosthenes(prime: Array[Boolean], n: Int): Unit = {
// Initial two numbers are not prime (0 and 1)
prime(0) = false;
prime(1) = false;
var i: Int = 2;
// Initial 0 and 1 are not prime
// We start to 2
while (i * i <= n)
{
if (prime(i) == true)
{
var j: Int = i * i;
// When i is prime number
// Modify the prime status of all next
// multiplier of location i
while (j <= n)
{
prime(j) = false;
j += i;
}
}
i += 1;
}
}
def leftTruncatablePrime(n: Int): Unit = {
if (n <= 1)
{
return;
}
var prime: Array[Boolean] = Array.fill[Boolean](n + 1)(true);
sieveOfEratosthenes(prime, n);
print("\n Given n : " + n);
print("\n");
var i: Int = 2;
while (i <= n)
{
if (prime(i) == true)
{
var temp: Int = i;
var count: Int = 1;
var zero: Int = 0;
// Count number of digits
while (zero == 0 && temp > 9)
{
if (temp % 10 == 0)
{
zero += 1;
}
temp = temp / 10;
count = count * 10;
}
var k: Int = count;
temp = i;
while (zero == 0 && temp > 0 && prime(temp) == true)
{
// Remove last digit
temp = temp - ((temp / count) * count);
count = count / 10;
}
if (temp == 0)
{
print("\n " + i + " : ");
count = k;
temp = i;
while (temp > 0 && prime(temp) == true)
{
print(" " + temp);
// Remove last digit
temp = temp - ((temp / count) * count);
count = count / 10;
}
}
}
i += 1;
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: TruncatablePrimes = new TruncatablePrimes();
// Test A
// n = 30
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
----------
*/
// Test B
// n = 1000
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7
----------------
[Remove left digit]
Example prime = 823
823
23
3
----------------------
All is prime so 823
left truncatable prime
*/
}
}``````

#### Output

`````` Given n : 30

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
Given n : 1000

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
37 :  37 7
43 :  43 3
47 :  47 7
53 :  53 3
67 :  67 7
73 :  73 3
83 :  83 3
97 :  97 7
113 :  113 13 3
137 :  137 37 7
167 :  167 67 7
173 :  173 73 3
197 :  197 97 7
223 :  223 23 3
283 :  283 83 3
313 :  313 13 3
317 :  317 17 7
337 :  337 37 7
347 :  347 47 7
353 :  353 53 3
367 :  367 67 7
373 :  373 73 3
383 :  383 83 3
397 :  397 97 7
443 :  443 43 3
467 :  467 67 7
523 :  523 23 3
547 :  547 47 7
613 :  613 13 3
617 :  617 17 7
643 :  643 43 3
647 :  647 47 7
653 :  653 53 3
673 :  673 73 3
683 :  683 83 3
743 :  743 43 3
773 :  773 73 3
797 :  797 97 7
823 :  823 23 3
853 :  853 53 3
883 :  883 83 3
937 :  937 37 7
947 :  947 47 7
953 :  953 53 3
967 :  967 67 7
983 :  983 83 3
997 :  997 97 7``````
``````/*
Swift 4 Program for
Find the all left truncatable primes in n natural numbers
*/
class TruncatablePrimes
{
// Find all prime numbers which have smaller and equal
// to given number n
func sieveOfEratosthenes(_ prime: inout[Bool], _ n: Int)
{
// Initial two numbers are not prime (0 and 1)
prime[0] = false;
prime[1] = false;
var i: Int = 2;
// Initial 0 and 1 are not prime
// We start to 2
while (i * i <= n)
{
if (prime[i] == true)
{
var j: Int = i * i;
// When i is prime number
// Modify the prime status of all next
// multiplier of location i
while (j <= n)
{
prime[j] = false;
j += i;
}
}
i += 1;
}
}
func leftTruncatablePrime(_ n: Int)
{
if (n <= 1)
{
return;
}
var prime: [Bool] = Array(repeating: true, count: n + 1);
self.sieveOfEratosthenes(&prime, n);
print("\n Given n : ", n, terminator: "");
print(terminator: "\n");
var i: Int = 2;
while (i <= n)
{
if (prime[i] == true)
{
var temp: Int = i;
var count: Int = 1;
var zero: Int = 0;
// Count number of digits
while (zero == 0 && temp > 9)
{
if (temp % 10 == 0)
{
zero += 1;
}
temp = temp / 10;
count = count * 10;
}
let k: Int = count;
temp = i;
while (zero == 0 && temp > 0 && prime[temp] == true)
{
// Remove last digit
temp = temp - ((temp / count) * count);
count = count / 10;
}
if (temp == 0)
{
print("\n ", i ," : ", terminator: "");
count = k;
temp = i;
while (temp > 0 && prime[temp] == true)
{
print(" ", temp, terminator: "");
// Remove last digit
temp = temp - ((temp / count) * count);
count = count / 10;
}
}
}
i += 1;
}
}
}
func main()
{
// Test A
// n = 30
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
----------
*/
// Test B
// n = 1000
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7
----------------
[Remove left digit]
Example prime = 823
823
23
3
----------------------
All is prime so 823
left truncatable prime
*/
}
main();``````

#### Output

`````` Given n :  30

2  :   2
3  :   3
5  :   5
7  :   7
13  :   13  3
17  :   17  7
23  :   23  3
Given n :  1000

2  :   2
3  :   3
5  :   5
7  :   7
13  :   13  3
17  :   17  7
23  :   23  3
37  :   37  7
43  :   43  3
47  :   47  7
53  :   53  3
67  :   67  7
73  :   73  3
83  :   83  3
97  :   97  7
113  :   113  13  3
137  :   137  37  7
167  :   167  67  7
173  :   173  73  3
197  :   197  97  7
223  :   223  23  3
283  :   283  83  3
313  :   313  13  3
317  :   317  17  7
337  :   337  37  7
347  :   347  47  7
353  :   353  53  3
367  :   367  67  7
373  :   373  73  3
383  :   383  83  3
397  :   397  97  7
443  :   443  43  3
467  :   467  67  7
523  :   523  23  3
547  :   547  47  7
613  :   613  13  3
617  :   617  17  7
643  :   643  43  3
647  :   647  47  7
653  :   653  53  3
673  :   673  73  3
683  :   683  83  3
743  :   743  43  3
773  :   773  73  3
797  :   797  97  7
823  :   823  23  3
853  :   853  53  3
883  :   883  83  3
937  :   937  37  7
947  :   947  47  7
953  :   953  53  3
967  :   967  67  7
983  :   983  83  3
997  :   997  97  7``````
``````/*
Kotlin Program for
Find the all left truncatable primes in n natural numbers
*/
class TruncatablePrimes
{
// Find all prime numbers which have smaller and equal
// to given number n
fun sieveOfEratosthenes(prime: Array < Boolean > , n: Int): Unit
{
// Initial two numbers are not prime (0 and 1)
prime[0] = false;
prime[1] = false;
var i: Int = 2;
// Initial 0 and 1 are not prime
// We start to 2
while (i * i <= n)
{
if (prime[i] == true)
{
var j: Int = i * i;
// When i is prime number
// Modify the prime status of all next
// multiplier of location i
while (j <= n)
{
prime[j] = false;
j += i;
}
}
i += 1;
}
}
fun leftTruncatablePrime(n: Int): Unit
{
if (n <= 1)
{
return;
}
var prime: Array < Boolean > = Array(n + 1)
{
true
};
this.sieveOfEratosthenes(prime, n);
print("\n Given n : " + n);
print("\n");
var i: Int = 2;
while (i <= n)
{
if (prime[i] == true)
{
var temp: Int = i;
var count: Int = 1;
var zero: Int = 0;
// Count number of digits
while (zero == 0 && temp > 9)
{
if (temp % 10 == 0)
{
zero += 1;
}
temp = temp / 10;
count = count * 10;
}
val k: Int = count;
temp = i;
while (zero == 0 && temp > 0 && prime[temp] == true)
{
// Remove last digit
temp = temp - ((temp / count) * count);
count = count / 10;
}
if (temp == 0)
{
print("\n " + i + " : ");
count = k;
temp = i;
while (temp > 0 && prime[temp] == true)
{
print(" " + temp);
// Remove last digit
temp = temp - ((temp / count) * count);
count = count / 10;
}
}
}
i += 1;
}
}
}
fun main(args: Array < String > ): Unit
{
// Test A
// n = 30
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
----------
*/
// Test B
// n = 1000
/*
2 :  2
3 :  3
5 :  5
7 :  7
13 :  13  3
17 :  17  7
23 :  23  3
37 :  37  7
43 :  43  3
47 :  47  7
53 :  53  3
67 :  67  7
73 :  73  3
83 :  83  3
97 :  97  7
113 :  113  13  3
137 :  137  37  7
167 :  167  67  7
173 :  173  73  3
197 :  197  97  7
223 :  223  23  3
283 :  283  83  3
313 :  313  13  3
317 :  317  17  7
337 :  337  37  7
347 :  347  47  7
353 :  353  53  3
367 :  367  67  7
373 :  373  73  3
383 :  383  83  3
397 :  397  97  7
443 :  443  43  3
467 :  467  67  7
523 :  523  23  3
547 :  547  47  7
613 :  613  13  3
617 :  617  17  7
643 :  643  43  3
647 :  647  47  7
653 :  653  53  3
673 :  673  73  3
683 :  683  83  3
743 :  743  43  3
773 :  773  73  3
797 :  797  97  7
823 :  823  23  3
853 :  853  53  3
883 :  883  83  3
937 :  937  37  7
947 :  947  47  7
953 :  953  53  3
967 :  967  67  7
983 :  983  83  3
997 :  997  97  7
----------------
[Remove left digit]
Example prime = 823
823
23
3
----------------------
All is prime so 823
left truncatable prime
*/
}``````

#### Output

`````` Given n : 30

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
Given n : 1000

2 :  2
3 :  3
5 :  5
7 :  7
13 :  13 3
17 :  17 7
23 :  23 3
37 :  37 7
43 :  43 3
47 :  47 7
53 :  53 3
67 :  67 7
73 :  73 3
83 :  83 3
97 :  97 7
113 :  113 13 3
137 :  137 37 7
167 :  167 67 7
173 :  173 73 3
197 :  197 97 7
223 :  223 23 3
283 :  283 83 3
313 :  313 13 3
317 :  317 17 7
337 :  337 37 7
347 :  347 47 7
353 :  353 53 3
367 :  367 67 7
373 :  373 73 3
383 :  383 83 3
397 :  397 97 7
443 :  443 43 3
467 :  467 67 7
523 :  523 23 3
547 :  547 47 7
613 :  613 13 3
617 :  617 17 7
643 :  643 43 3
647 :  647 47 7
653 :  653 53 3
673 :  673 73 3
683 :  683 83 3
743 :  743 43 3
773 :  773 73 3
797 :  797 97 7
823 :  823 23 3
853 :  853 53 3
883 :  883 83 3
937 :  937 37 7
947 :  947 47 7
953 :  953 53 3
967 :  967 67 7
983 :  983 83 3
997 :  997 97 7``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.