The number 3797 has an interesting property. Being prime itself, it is possible to continuously remove digits from left to right, and remain prime at each stage: 3797, 797, 97, and 7. Similarly we can work from right to left: 3797, 379, 37, and 3.

Find the sum of the only eleven primes that are both truncatable from left to right and right to left.

NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes.



In [1]:

    
let compositesInRange fromNum toNum =
    [|2 .. toNum/fromNum|]
    |> Array.map (fun x -> fromNum * x)

let primesTo n =
    // start off assuming every number from 2 .. n is prime
    let isPrime = Array.append [| false; false |] (Array.init (1+n) (fun _ -> true))       
    
    // simple sieve of eratosthenes - update "primeness" of
    // each number in the isPrime array
    for x in 2 .. int(sqrt(double(n))) do 
        if isPrime.[x] then             
            compositesInRange x n
            |> Array.map (fun i -> isPrime.[i] <- false)
            |> ignore
                
    // now return numbers which are "true" in isPrime array
    let primesList =
        [|2..n|]
        |> Array.filter (fun x -> isPrime.[x])
        
    (primesList, isPrime)



In [8]:

    
let primesList, isPrime = primesTo 1000000

let leftTruncate n =
    n.ToString().Substring(1)
    |> int

let rightTruncate n = 
    let n_str = n.ToString()
    
    n_str
    new System.String(n_array.[0..(n_array.Length-2)])
    |> int

let rec isTruncatablePrimeBase truncate n =
    if n > 10 then isPrime.[n] && (isTruncatablePrimeBase truncate (truncate n))
    else isPrime.[n]

let isTruncatablePrime n =
    (isTruncatablePrimeBase leftTruncate n) && (isTruncatablePrimeBase rightTruncate n) 

primesList
|> Array.filter (fun n -> n > 7)
|> Array.filter isTruncatablePrime
|> Array.sum









    Out[8]:





748317



In [ ]: