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

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

BYTE FUNC IsZero(REAL POINTER a)

a==+1

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Smarandache_prime-digital_sequence.png Screenshot from Atari 8-bit computer]

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>

 

=={{header|AWK}}==

# syntax: GAWK -f SMARANDACHE_PRIME-DIGITAL_SEQUENCE.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

dim smar(100)

smar[1] = 2

end while

return True

{{out}}

<pre>Igual que la entrada de FreeBASIC.</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}}

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

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>

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

 

See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime` as used here.

# Output: a naively constructed stream of candidate strings of length >= 1

def Smarandache_candidates:

 

# jq counts from 0 so:

{{out}}

<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

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

SmarandachePrimeQ[n_Integer] := MatchQ[IntegerDigits[n], {(2 | 3 | 5 | 7) ..}] \[And] PrimeQ[n]

s = Select[Range[10^5], SmarandachePrimeQ];

Take[s, UpTo[25]]

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

 

const N = 35_000

inc count

if count == 100:

 

{{out}}

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

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.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|Python}}==

def divisors(n):

divs = [1]

pass

print(100, generator.__next__())

 

<b>Output</b>

1 2

2 3

15 353

100 33223

 

=={{header|Quackery}}==

===Naive===

 

[ 10 /mod

[ table 1 1 0 0 1 0 1 0 1 1 ]

25 split swap echo

cr cr

 

{{out}}

Not the same as the Factor and Factor inspired solutions, which count in base 4 with leading zeros like a telescoping pedometer; this skips over base 5 numbers with zeros in them.

 

[ 5 /mod 0 = while

dip [ 5 * 1+ ]

25 split swap echo

cr cr

 

{{out}}

(formerly Perl 6)

{{libheader|ntheory}}

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

 

 

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>

 

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

 

=={{header|XPL0}}==

int N, I;

[if N <= 2 then return N = 2;

];

Text(0, "^m^j1000th: "); IntOut(0, N); CrLf(0);

 

{{out}}

=={{header|Yabasic}}==

{{trans|Ring}}

limit = 26

limit100 = 100

wend

return True

{{out}}

<pre>Igual que la entrada de Ring.</pre>

 

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