Truncatable primes: Difference between revisions
→{{header|PureBasic}}: Added PureBasic |
|||
Line 42: | Line 42: | ||
>./ step&digits^:5 seed NB. right truncatable |
>./ step&digits^:5 seed NB. right truncatable |
||
739399</lang> |
739399</lang> |
||
=={{header|PureBasic}}== |
|||
<lang PureBasic>#MaxLim = 999999 |
|||
Procedure is_Prime(n) |
|||
If n<=1 : ProcedureReturn #False |
|||
ElseIf n<4 : ProcedureReturn #True |
|||
ElseIf n%2=0: ProcedureReturn #False |
|||
ElseIf n<9 : ProcedureReturn #True |
|||
ElseIf n%3=0: ProcedureReturn #False |
|||
Else |
|||
Protected r=Round(Sqr(n),#PB_Round_Down) |
|||
Protected f=5 |
|||
While f<=r |
|||
If n%f=0 Or n%(f+2)=0 |
|||
ProcedureReturn #False |
|||
EndIf |
|||
f+6 |
|||
Wend |
|||
EndIf |
|||
ProcedureReturn #True |
|||
EndProcedure |
|||
Procedure TruncateLeft(n) |
|||
Protected s.s=Str(n), l=Len(s)-1 |
|||
If Not FindString(s,"0",1) |
|||
While l>0 |
|||
s=Right(s,l) |
|||
If Not is_Prime(Val(s)) |
|||
ProcedureReturn #False |
|||
EndIf |
|||
l-1 |
|||
Wend |
|||
ProcedureReturn #True |
|||
EndIf |
|||
EndProcedure |
|||
Procedure TruncateRight(a) |
|||
Repeat |
|||
a/10 |
|||
If Not a |
|||
Break |
|||
ElseIf Not is_Prime(a) Or a%10=0 |
|||
ProcedureReturn #False |
|||
EndIf |
|||
ForEver |
|||
ProcedureReturn #True |
|||
EndProcedure |
|||
i=#MaxLim |
|||
Repeat |
|||
If is_Prime(i) |
|||
If Not truncateleft And TruncateLeft(i) |
|||
truncateleft=i |
|||
EndIf |
|||
If Not truncateright And TruncateRight(i) |
|||
truncateright=i |
|||
EndIf |
|||
EndIf |
|||
If truncateleft And truncateright |
|||
Break |
|||
Else |
|||
i-2 |
|||
EndIf |
|||
Until i<=0 |
|||
x.s="Largest TruncateLeft= "+Str(truncateleft) |
|||
y.s="Largest TruncateRight= "+Str(truncateright) |
|||
MessageRequester("Truncatable primes",x+#CRLF$+y)</lang> |
|||
== {{header|Python}} == |
== {{header|Python}} == |
Revision as of 16:02, 9 September 2010
You are encouraged to solve this task according to the task description, using any language you may know.
A truncatable prime is prime number that when you successively remove digits from one end of the prime, you are left with a new prime number; for example, the number 997 is called a left-truncatable prime as the numbers 997, 97, and 7 are all prime. The number 7393 is a right-truncatable prime as the numbers 7393, 739, 73, and 7 formed by removing digits from its right are also prime. No zeroes are allowed in truncatable primes.
The task is to find the largest left-truncatable and right-truncatable primes less than one million.
C.f: Sieve of Eratosthenes; Truncatable Prime from Mathworld.
Haskell
Using
from HackageDB
<lang haskell>import Data.Numbers.Primes(primes, isPrime) import Data.List import Control.Arrow
primes1e6 = reverse. filter (all (/='0'). show) $ takeWhile(<=1000000) primes
rightT, leftT :: Int -> Bool rightT = all isPrime. takeWhile(>0). drop 1. iterate (`div`10) leftT x = all isPrime. takeWhile(<x).map (x`mod`) $ iterate (*10) 10
main = do
let (ltp, rtp) = (head. filter leftT &&& head. filter rightT) primes1e6 putStrLn $ "Left truncatable " ++ show ltp putStrLn $ "Right truncatable " ++ show rtp</lang>
Output: <lang haskell>*Main> main Left truncatable 998443 Right truncatable 739399</lang>
J
Truncatable primes may be constructed by starting with a set of one digit prime numbers and then repeatedly adding a non-zero digit (using the cartesian product of digit sequences) and, at each step, selecting the prime numbers which result.
In other words, given:
<lang j>selPrime=: #~ 1&p: seed=: selPrime digits=: 1+i.9 step=: selPrime@,@:(,&.":/&>)@{@;</lang>
The largest truncatable primes less than a million can be obtained by adding five digits to the prime seeds, then finding the largest value from the result:
<lang j> >./ digits&step^:5 seed NB. left truncatable 998443
>./ step&digits^:5 seed NB. right truncatable
739399</lang>
PureBasic
<lang PureBasic>#MaxLim = 999999
Procedure is_Prime(n)
If n<=1 : ProcedureReturn #False ElseIf n<4 : ProcedureReturn #True ElseIf n%2=0: ProcedureReturn #False ElseIf n<9 : ProcedureReturn #True ElseIf n%3=0: ProcedureReturn #False Else Protected r=Round(Sqr(n),#PB_Round_Down) Protected f=5 While f<=r If n%f=0 Or n%(f+2)=0 ProcedureReturn #False EndIf f+6 Wend EndIf ProcedureReturn #True
EndProcedure
Procedure TruncateLeft(n)
Protected s.s=Str(n), l=Len(s)-1 If Not FindString(s,"0",1) While l>0 s=Right(s,l) If Not is_Prime(Val(s)) ProcedureReturn #False EndIf l-1 Wend ProcedureReturn #True EndIf
EndProcedure
Procedure TruncateRight(a)
Repeat a/10 If Not a Break ElseIf Not is_Prime(a) Or a%10=0 ProcedureReturn #False EndIf ForEver ProcedureReturn #True
EndProcedure
i=#MaxLim Repeat
If is_Prime(i) If Not truncateleft And TruncateLeft(i) truncateleft=i EndIf If Not truncateright And TruncateRight(i) truncateright=i EndIf EndIf If truncateleft And truncateright Break Else i-2 EndIf
Until i<=0
x.s="Largest TruncateLeft= "+Str(truncateleft) y.s="Largest TruncateRight= "+Str(truncateright)
MessageRequester("Truncatable primes",x+#CRLF$+y)</lang>
Python
<lang python>maxprime = 1000000
def primes(n):
multiples = set() prime = [] for i in range(2, n+1): if i not in multiples: prime.append(i) multiples.update(set(range(i*i, n+1, i))) return prime
def truncatableprime(n):
'Return a longest left and right truncatable primes below n' primelist = [str(x) for x in primes(n)[::-1]] primeset = set(primelist) for n in primelist: # n = 'abc'; [n[i:] for i in range(len(n))] -> ['abc', 'bc', 'c'] alltruncs = set(n[i:] for i in range(len(n))) if alltruncs.issubset(primeset): truncateleft = int(n) break for n in primelist: # n = 'abc'; [n[:i+1] for i in range(len(n))] -> ['a', 'ab', 'abc'] alltruncs = set([n[:i+1] for i in range(len(n))]) if alltruncs.issubset(primeset): truncateright = int(n) break return truncateleft, truncateright
print(truncatableprime(maxprime))</lang>
Sample Output
(998443, 739399)
Tcl
<lang tcl>package require Tcl 8.5
- Optimized version of the Sieve-of-Eratosthenes task solution
proc sieve n {
set primes [list] if {$n < 2} {return $primes} set nums [dict create] for {set i 2} {$i <= $n} {incr i} { dict set nums $i "" } set next 2 set limit [expr {sqrt($n)}] while {$next <= $limit} { for {set i $next} {$i <= $n} {incr i $next} {dict unset nums $i} lappend primes $next
dict for {next -} $nums break
} return [concat $primes [dict keys $nums]]
}
proc isLeftTruncatable n {
global isPrime while {[string length $n] > 0} {
if {![info exist isPrime($n)]} { return false } set n [string range $n 1 end]
} return true
} proc isRightTruncatable n {
global isPrime while {[string length $n] > 0} {
if {![info exist isPrime($n)]} { return false } set n [string range $n 0 end-1]
} return true
}
- Demo code
set limit 1000000 puts "calculating primes up to $limit" set primes [sieve $limit] puts "search space contains [llength $primes] members" foreach p $primes {
set isPrime($p) "yes"
} set primes [lreverse $primes]
puts "searching for largest left-truncatable prime" foreach p $primes {
if {[isLeftTruncatable $p]} {
puts FOUND:$p break
}
}
puts "searching for largest right-truncatable prime" foreach p $primes {
if {[isRightTruncatable $p]} {
puts FOUND:$p break
}
}</lang> Output:
calculating primes up to 1000000 search space contains 78498 members searching for largest left-truncatable prime FOUND:998443 searching for largest right-truncatable prime FOUND:739399