Emirp primes: Difference between revisions
Rename Perl 6 -> Raku, alphabetize, minor clean-up
(Add R solution) |
Thundergnat (talk | contribs) (Rename Perl 6 -> Raku, alphabetize, minor clean-up) |
||
Line 403:
% ./a.out a b # you get the idea
948349
</pre>
Line 565 ⟶ 487:
10000th:
948349
</pre>
=={{header|C++}}==
<lang Cpp>#include <vector>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <cmath>
bool isPrime ( int number ) {
if ( number <= 1 )
return false ;
if ( number == 2 )
return true ;
for ( int i = 2 ; i <= std::sqrt( number ) ; i++ ) {
if ( number % i == 0 )
return false ;
}
return true ;
}
int reverseNumber ( int n ) {
std::ostringstream oss ;
oss << n ;
std::string numberstring ( oss.str( ) ) ;
std::reverse ( numberstring.begin( ) , numberstring.end( ) ) ;
return std::stoi ( numberstring ) ;
}
bool isEmirp ( int n ) {
return isPrime ( n ) && isPrime ( reverseNumber ( n ) )
&& n != reverseNumber ( n ) ;
}
int main( ) {
std::vector<int> emirps ;
int i = 1 ;
while ( emirps.size( ) < 20 ) {
if ( isEmirp( i ) ) {
emirps.push_back( i ) ;
}
i++ ;
}
std::cout << "The first 20 emirps:\n" ;
for ( int i : emirps )
std::cout << i << " " ;
std::cout << '\n' ;
int newstart = 7700 ;
while ( newstart < 8001 ) {
if ( isEmirp ( newstart ) )
std::cout << newstart << '\n' ;
newstart++ ;
}
while ( emirps.size( ) < 10000 ) {
if ( isEmirp ( i ) ) {
emirps.push_back( i ) ;
}
i++ ;
}
std::cout << "the 10000th emirp is " << emirps[9999] << " !\n" ;
return 0 ;
}</lang>
{{out}}
<pre>13 17 31 37 71 73 79 97 107 113 149 157 167 179 199 311 337 347 359 389
7717
7757
7817
7841
7867
7879
7901
7927
7949
7951
7963
the 10000th emirp is 948349 !
</pre>
Line 588:
10,000: 948349
</pre>
=={{header|Common Lisp}}==
Line 628 ⟶ 626:
Emirps between 7700 and 8000: 7717 7757 7817 7841 7867 7879 7901 7927 7949 7951 7963
The 10,000'th emirp: 948349</pre>
=={{header|D}}==
Line 2,075 ⟶ 2,071:
948349
</pre>
=={{header|Modula-2}}==
<lang modula2>MODULE Emirp;
Line 2,544 ⟶ 2,541:
Between 7700 and 8000: 7717 7757 7817 7841 7867 7879 7901 7927 7949 7951 7963
The 10_000'th emirp: 948349</pre>
=={{header|Phix}}==
Line 3,069 ⟶ 3,026:
The 10000th emirp: 948349
</pre>
=={{header|Racket}}==
This implementation seems to have exploded somewhat due to
Line 3,270 ⟶ 3,228:
948349
Sieve size: 999998</pre>
=={{header|Raku}}==
(formerly Perl 6)
{{Works with|Rakudo|2018.10}}
For better performance, build the lazy list using module <code>Math::Primesieve</code>, not the built-in, then display results based on parameters passed in. The default is to display an array slice starting and stopping at the given indices. Alternately, ask for all values between two endpoints.
<lang perl6>use Math::Primesieve;
sub prime-hash (Int $max) {
my $sieve = Math::Primesieve.new;
my @primes = $sieve.primes($max);
@primes.Set;
}
sub MAIN ($start, $stop = Nil, $display = <slice>) {
my $end = $stop // $start;
my %primes = prime-hash(100*$end);
my @emirps = lazy gather for 1 .. * -> $n {
take $n if %primes{$n} and %primes{$n.flip} and $n != $n.flip
}
given $display {
when 'slice' { return @emirps[$start-1 .. $end-1] };
when 'values' {
my @values = gather for @emirps {
.take if $start < $_ < $end;
last if $_> $end
}
return @values
}
}
}</lang>
{{out}}
Run with passed parameters: 1 20
('slice' is the default. you <i>could</i> pass it in, but it isn't necessary.)
<pre>13 17 31 37 71 73 79 97 107 113 149 157 167 179 199 311 337 347 359 389</pre>
Run with passed parameters: 7700 8000 values
<pre>7717 7757 7817 7841 7867 7879 7901 7927 7949 7951 7963</pre>
Run with passed parameter: 10000
<pre>948349</pre>
=={{header|REXX}}==
Line 3,686 ⟶ 3,685:
The 10,000'th emirp: 948349
</pre>
=={{header|Smalltalk}}==
Works with Smalltalk/X
Line 3,933:
10,000: 948349
</pre>
=={{header|VBA}}==
| |||