Smarandache prime-digital sequence: Difference between revisions

{{trans|Python}}

 

V divs = [1]

L(ii) 2 .< Int(n ^ 0.5) + 3

print(item, end' ‘ ’)

print()

 

{{out}}

2 3 5 7 23 37 53 73 223 227 233 257 277 337 353 373 523 557 577 727 733 757 773 2237 2273

Hundredth SPDS prime: 33223

</pre>

 

Uses a sieve to find primes. Requires --heap 256m for Algol 68G.

<br>Uses the optimisations of the Factor, Phix, etc. samples.

# digits are all primes #

# Uses the observations that the final digit of 2 or more digit Smarandache #

)

)

{{out}}

<pre>

Largest Smarandache prime under 10000000: 7777753 (Smarandache prime 1903)

</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f SMARANDACHE_PRIME-DIGITAL_SEQUENCE.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

100: 33223

</pre>

 

=={{header|C}}==

{{trans|C++}}

#include <stdbool.h>

#include <stdint.h>

printf("Largest SPDS prime less than %'u: %'u\n", limit, max);

return 0;

 

{{out}}

 

=={{header|C++}}==

#include <cstdint>

 

std::cout << "Largest SPDS prime less than " << limit << ": " << max << '\n';

return 0;

 

{{out}}

Ten thousandth SPDS prime: 273,322,727

Largest SPDS prime less than 1,000,000,000: 777,777,773

</pre>

 

=={{header|F_Sharp|F#}}==

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]

// Generate Smarandache prime-digital sequence. Nigel Galloway: May 31st., 2019

let rec spds g=seq{yield! g; yield! (spds (Seq.collect(fun g->[g*10+2;g*10+3;g*10+5;g*10+7]) g))}|>Seq.filter(isPrime)

printfn "\n\n100th item of this sequence is %d" (spds [2;3;5;7] |> Seq.item 99)

printfn "1000th item of this sequence is %d" (spds [2;3;5;7] |> Seq.item 999)

{{out}}

<pre>

=={{header|Factor}}==

===Naive===

math.parser math.primes prettyprint sequences ;

IN: rosetta-code.smarandache-naive

"100th member: " write smarandache 99 [ cdr ] times car . ;

 

{{out}}

<pre>

 

===Optimized===

math.primes prettyprint sequences ;

IN: rosetta-code.smarandache

] each ;

 

{{out}}

<pre>

 

=={{header|Forth}}==

dup 2 < if drop false exit then

dup 2 mod 0= if 2 = exit then

: spds_print ( n -- )

0 swap 0 do

loop

drop cr ;

1000 spds_nth . cr

 

 

{{out}}

 

=={{header|FreeBASIC}}==

function isprime( n as ulongint ) as boolean

if n < 2 then return false

print count, smar(count)

end if

{{out}}

<pre>

25 2273

100 33223</pre>

 

=={{header|Go}}==

===Basic===

 

import (

n = listSPDSPrimes(n+2, indices[i-1], indices[i], true)

}

 

{{out}}

 

This is more than 30 times faster than the above version (runs in about 12.5 seconds on my Celeron @1.6GHx) and could be quickened up further (to around 4 seconds) by using a wrapper for GMP rather than Go's native big.Int type.

 

import (

n = listSPDSPrimes(n.AddTwo(), indices[i-1], indices[i], true)

}

 

{{out}}

=={{header|Haskell}}==

Using the optimized approach of generated numbers from prime digits and testing for primality.

import Control.Monad (guard)

import Math.NumberTheory.Primes.Testing (isPrime)

mapM_ (uncurry (printf "The %9sth SPDS: %15s\n")) $

nextSPDSTerms [100, 1_000, 10_000, 100_000, 1_000_000]

{{out}}

<pre>The first 25 SPDS:

=={{header|Java}}==

Generate next in sequence directly from previous, inspired by previous solutions.

public class SmarandachePrimeDigitalSequence {

 

 

}

{{out}}

<pre>

10,000th Smarandache prime-digital sequence number = 273322727

100,000th Smarandache prime-digital sequence number = 23325232253

</pre>

 

add numbers that end in 3 or 7 and that only contain 2, 3, 5, and 7. This

can be done via permutations of combinations with repetition.

using Combinatorics, Primes

 

println("The 100th Smarandache prime is: ", v[100])

println("The 10000th Smarandache prime is: ", v[10000])

<pre>

The first 25 Smarandache primes are: [2, 3, 5, 7, 23, 37, 53, 73, 223, 227, 233, 257, 277, 337, 353, 373, 523, 557, 577, 727, 733, 757, 773, 2237, 2273]

 

=={{header|Lua}}==

local function T(t) return setmetatable(t, {__index=table}) end

table.firstn = function(t,n) local s=T{} n=n>#t and #t or n for i = 1,n do s[i]=t[i] end return s end

end

print("1-25 : " .. spds:firstn(25):concat(" "))

{{out}}

<pre>1-25 : 2 3 5 7 23 37 53 73 223 227 233 257 277 337 353 373 523 557 577 727 733 757 773 2237 2273

100th: 33223</pre>

 

=={{header|Pascal}}==

uses [[http://rosettacode.org/wiki/Extensible_prime_generator#Pascal:Extensible_prime_generator]]<BR>

Simple Brute force.Testing for prime takes most of the time.

 

uses

inc(DgtLimit);

until DgtLimit= 12;

{{out}}

<pre>2,3,5,7,23,37,53,73,223,227,233,257,277,337,353,373,523,557,577,727,733,757,773,2237,2273

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature 'say';

 

say 'Smarandache prime-digitals:';

{{out}}

<pre> First: 2

if they ended in 2 or 5), which we efficiently achieve by alternately adding {4,-4}. Digits to the left

of that must all be 2/3/5/7, so we add {1,2,2,-5}*10^k to cycle round those digits.

 

I had planned to effectively merge a list of potential candidates with a list of all prime numbers,

but because of the massive gaps (eg between 777,777,777 and 2,222,222,223) it proved much faster

to test each candidate for primality individually. Timings below show just how much this improves things.

{{out}}

<pre>

largest spds prime less than 1,000,000,000: 777,777,773

largest spds prime less than 10,000,000,000: 7,777,777,577

</pre>

For comparison, on the same machine:<br>

 

=={{header|Python}}==

def divisors(n):

divs = [1]

pass

print(100, generator.__next__())

 

<b>Output</b>

1 2

2 3

15 353

100 33223

 

=={{header|Raku}}==

(formerly Perl 6)

use ntheory:from<Perl5> <:all>;

 

# Implemented as a lazy, extendable list

my $spds = grep { .&is_prime }, flat [2,3,5,7], [23,27,33,37,53,57,73,77], -> $p

 

say 'Smarandache prime-digitals:';

{{out}}

<pre>Smarandache prime-digitals:

=={{header|REXX}}==

The prime number generator has been simplified and very little optimization was included.

parse arg n q /*get optional number of primes to find*/

if n=='' | n=="," then n= 25 /*Not specified? Then use the default.*/

end /*j*/ /* [↑] only display N number of primes*/

if ox<0 then say right(z, 21) /*display one (the last) SPDS prime. */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

ok

next

{{Out}}

<pre>

</pre>

 

=={{header|Rust}}==

if n < 2 {

return false;

println!("Largest SPDS prime less than {}: {}", limit, p);

}

 

{{out}}

=={{header|Ruby}}==

Attaching 3 and 7 to permutations of 2,3,5 and 7

smarandache = Enumerator.new do|y|

p seq.first(25)

p seq.last

{{out}}

<pre>[2, 3, 5, 7, 23, 37, 53, 73, 223, 227, 233, 257, 277, 337, 353, 373, 523, 557, 577, 727, 733, 757, 773, 2237, 2273]

 

=={{header|Sidef}}==

n.is_prime && n.digits.all { .is_prime }

}

 

say is_prime_digital.first(25).join(',')

{{out}}

<pre>

=={{header|Swift}}==

{{trans|C++}}

if number < 2 {

return false

max = n

}

 

{{out}}

{{libheader|Wren-math}}

Simple brute-force approach.

 

var limit = 1000

System.print(spds.take(25).toList)

System.print("\nThe 100th SPDS prime is %(spds[99])")

 

{{out}}

The 1,000th SPDS prime is 3273527

</pre>

 

=={{header|zkl}}==

 

[[Extensible prime generator#zkl]] could be used instead.

 

spds:=Walker.zero().tweak(fcn(ps){

if(p.split().filter( fcn(n){ 0==nps[n] }) ) return(Void.Skip);

p // 733 --> (7,3,3) --> () --> good, 29 --> (2,9) --> (9) --> bad

Or

var [const] nps="014689".inCommon;

p:=ps.nextPrime().toInt();

if(nps(p.toString())) return(Void.Skip);

p // 733 --> "" --> good, 29 --> "9" --> bad

spds.walk(25).concat(",").println();

 

println("The hundredth term of the sequence is: ",spds.drop(100-25).value);

{{out}}

<pre>