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)
{
TruncatablePrimes task = new TruncatablePrimes();
// Test A
// n = 30
/*
2 : 2
3 : 3
5 : 5
7 : 7
13 : 13 3
17 : 17 7
23 : 23 3
----------
*/
task.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
*/
task.leftTruncatablePrime(1000);
}
}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()
{
TruncatablePrimes *task = new TruncatablePrimes();
// Test A
// n = 30
/*
2 : 2
3 : 3
5 : 5
7 : 7
13 : 13 3
17 : 17 7
23 : 23 3
----------
*/
task->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
*/
task->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// 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)
{
TruncatablePrimes task = new TruncatablePrimes();
// Test A
// n = 30
/*
2 : 2
3 : 3
5 : 5
7 : 7
13 : 13 3
17 : 17 7
23 : 23 3
----------
*/
task.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
*/
task.leftTruncatablePrime(1000);
}
}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 7package 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
----------
*/
task.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
*/
task.leftTruncatablePrime(1000)
}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()
{
$task = new TruncatablePrimes();
// Test A
// n = 30
/*
2 : 2
3 : 3
5 : 5
7 : 7
13 : 13 3
17 : 17 7
23 : 23 3
----------
*/
$task->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
*/
$task->leftTruncatablePrime(1000);
}
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()
{
var task = new TruncatablePrimes();
// Test A
// n = 30
/*
2 : 2
3 : 3
5 : 5
7 : 7
13 : 13 3
17 : 17 7
23 : 23 3
----------
*/
task.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
*/
task.leftTruncatablePrime(1000);
}
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() :
task = TruncatablePrimes()
# Test A
# n = 30
# 2 : 2
# 3 : 3
# 5 : 5
# 7 : 7
# 13 : 13 3
# 17 : 17 7
# 23 : 23 3
# ----------
task.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
task.leftTruncatablePrime(1000)
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()
task = TruncatablePrimes.new()
# Test A
# n = 30
# 2 : 2
# 3 : 3
# 5 : 5
# 7 : 7
# 13 : 13 3
# 17 : 17 7
# 23 : 23 3
# ----------
task.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
task.leftTruncatablePrime(1000)
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
----------
*/
task.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
*/
task.leftTruncatablePrime(1000);
}
}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()
{
let task: TruncatablePrimes = TruncatablePrimes();
// Test A
// n = 30
/*
2 : 2
3 : 3
5 : 5
7 : 7
13 : 13 3
17 : 17 7
23 : 23 3
----------
*/
task.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
*/
task.leftTruncatablePrime(1000);
}
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
{
val task: TruncatablePrimes = TruncatablePrimes();
// Test A
// n = 30
/*
2 : 2
3 : 3
5 : 5
7 : 7
13 : 13 3
17 : 17 7
23 : 23 3
----------
*/
task.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
*/
task.leftTruncatablePrime(1000);
}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
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.
New Comment