Smarandache prime-digital sequence: Difference between revisions

* https://www.scribd.com/document/214851583/On-the-Smarandache-prime-digital-subsequence-sequences

<br><br>

 

=={{header|ALGOL 68}}==

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 <stdint.h>

#include <stdio.h>

 

if (n == 0)

return 2;

case 2:

return n + 1;

}

 

if (n < 2)

return false;

if (n % 3 == 0)

return n == 3;

}

}

 

int main() {

printf("First 25 SPDS primes:\n");

for (int i = 0; n < limit; ) {

if (i < 25) {

if (i > 0)

}

else if (i == 25)

++i;

if (i == 100)

else if (i == 1000)

}

return 0;

 

{{out}}

<pre>

First 25 SPDS primes:

</pre>

 

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

#include <cstdint>

 

if (n == 0)

return 2;

case 2:

return n + 1;

if (n % 3 == 0)

return n == 3;

}

}

 

int main() {

std::cout << "First 25 SPDS primes:\n";

for (int i = 0; n < limit; ) {

if (i < 25) {

if (i > 0)

std::cout << n;

}

++i;

if (i == 100)

else if (i == 1000)

}

return 0;

 

{{out}}

<pre>

First 25 SPDS primes:

</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>

100000th member: 23325232253

</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}}

Same as before.

</pre>

=={{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"

num = 0

next

{{Out}}

<pre>

</pre>

 

=={{header|Rust}}==

if n < 2 {

return false;

return n == 3;

}

}

}

}

 

 

fn main() {

let mut seq = smarandache_prime_digital_sequence().take_while(|x| *x < limit);

println!("First 25 SPDS primes:");

if let Some(p) = seq.by_ref().nth(999 - 100) {

println!("1000th SPDS prime: {}", p);

}

if let Some(p) = seq.last() {

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

}

 

{{out}}

100th SPDS prime: 33223

1000th SPDS prime: 3273527

</pre>

 

=={{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>

33223

</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>