Rosetta Code

Primes whose first and last number is 3: Difference between revisions

Page Discussion

Primes whose first and last number is 3 (view source)

Revision as of 16:16, 28 January 2024

13,982 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Sidef}}: optimization)
m (→‎{{header|Wren}}: Minor tidy)
 
(27 intermediate revisions by 18 users not shown)
Line 1:
{{Draft task|Prime Numbers}}
 
;Task:
Line 10:
Find and show only the   ''number''   of these types of primes   that are   '''<   1,000,000'''.
<br><br>
 
=={{header|11l}}==
{{trans|Nim}}
 
<syntaxhighlight lang="11l">F is_prime(n)
I n == 2
R 1B
I n < 2 | n % 2 == 0
R 0B
L(i) (3 .. Int(sqrt(n))).step(2)
I n % i == 0
R 0B
R 1B
 
V lim = 1'000'000
V primes3x3 = [3]
V m = 100
V count = 1
L m * 3 < lim
L(n) (3 * m + 3 .. 4 * m - 7).step(10)
I n > lim
L.break
I is_prime(n)
count++
I n < 4000
primes3x3.append(n)
m *= 10
 
print(‘Found ’primes3x3.len‘ primes starting and ending with 3 below 4000:’)
L(n) primes3x3
print(‘#4’.format(n), end' I (L.index + 1) % 11 == 0 {"\n"} E ‘ ’)
 
print("\nFound "count‘ primes starting and ending with 3 below 1000000.’)</syntaxhighlight>
 
{{out}}
<pre>
Found 33 primes starting and ending with 3 below 4000:
3 313 353 373 383 3023 3083 3163 3203 3253 3313
3323 3343 3373 3413 3433 3463 3533 3583 3593 3613 3623
3643 3673 3733 3793 3803 3823 3833 3853 3863 3923 3943
 
Found 2251 primes starting and ending with 3 below 1000000.
</pre>
 
=={{header|Action!}}==
{{libheader|Action! Sieve of Eratosthenes}}
<syntaxhighlight lang="action!">INCLUDE "H6:SIEVE.ACT"
 
BYTE Func IsSpecialPrime(INT i BYTE ARRAY primes)
BYTE d,first
 
IF primes(i)=0 THEN
RETURN (0)
FI
first=1
WHILE i#0
DO
d=i MOD 10
IF first THEN
IF d#3 THEN
RETURN (0)
FI
first=0
FI
i==/10
OD
IF d#3 THEN
RETURN (0)
FI
RETURN (1)
 
PROC Main()
DEFINE MAX="3999"
BYTE ARRAY primes(MAX+1)
INT i,count=[0]
 
Put(125) PutE() ;clear the screen
Sieve(primes,MAX+1)
FOR i=2 TO MAX
DO
IF IsSpecialPrime(i,primes) THEN
PrintI(i) Put(32)
count==+1
FI
OD
PrintF("%E%EThere are %I primes",count)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Primes_whose_first_and_last_number_is_3.png Screenshot from Atari 8-bit computer]
<pre>
3 313 353 373 383 3023 3083 3163 3203 3253 3313 3323 3343 3373 3413 3433 3463
3533 3583 3593 3613 3623 3643 3673 3733 3793 3803 3823 3833 3853 3863 3923 3943
 
There are 33 primes
</pre>
 
=={{header|ALGOL 68}}==
{{Trans|ALGOL W}} With added stretch goal. As with the Go and other samples, generates the candidate sequence.
{{libheader|ALGOL 68-primes}}
<lang algol68>BEGIN # find some primes whose first and last digits are 3 #
<syntaxhighlight lang="algol68">BEGIN # find some primes whose first and last digits are 3 #
INT max prime = 1 000 000; # largest number to consider #
# sieve the primes to max prime #
PR read "primes.incl.a68" PR
[ 1 : max prime ]BOOL prime;
prime[ 1 ] := FALSE;BOOL prime[ 2= ]PRIMESIEVE :=max TRUEprime;
FOR i FROM 3 BY 2 TO UPB prime DO prime[ i ] := TRUE OD;
FOR i FROM 4 BY 2 TO UPB prime DO prime[ i ] := FALSE OD;
FOR i FROM 3 BY 2 TO ENTIER sqrt( max prime ) DO
IF prime[ i ] THEN FOR s FROM i * i BY i + i TO UPB prime DO prime[ s ] := FALSE OD FI
OD;
INT p3count := 0;
# prints n, if it is prime, handles newlines #
Line 30 ⟶ 121:
IF ( p3count +:= 1 ) MOD 12 = 0 THEN print( ( newline ) ) FI
FI # p #;
# find 1,3x3 primes 2, 3 and 4 digit 3x3 primes #
p( 3 ); p( 33 ); FOR i FROM 0 BY 10 TO 90 DO p( 303 + i ) OD; FOR i FROM 0 BY 10 TO 990 DO p( 3003 + i ) OD; # a & 2 digit 3x3 primes #
FOR i FROM 0 BY 10 TO 90 DO p( 303 + i ) OD; # 3 digit 3x3 primes #
FOR i FROM 0 BY 10 TO 990 DO p( 3003 + i ) OD; # 4 digit 3x3 primes #
# 5 and 6 digit 3x3 primes #
FOR i FROM 0 BY 10 TO 9 990 DO IF prime[ 30 003 + i ] THEN p3count +:= 1 FI OD;
FOR i FROM 0 BY 10 TO 99 990 DO IF prime[ 300 003 + i ] THEN p3count +:= 1 FI OD;
print( ( newline, "Found ", whole( p3count, 0 ), " ""3x3"" primes below 1000000", newline ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 47 ⟶ 140:
=={{header|ALGOL W}}==
As with the Go and oher samples, finds the numbers by generating the candidate seuence.
<langsyntaxhighlight lang="algolw">begin % find some primes whose first and last digits are 3 %
integer MAX_PRIME;
MAX_PRIME := 4000;
Line 73 ⟶ 166:
for i := 0 step 10 until 990 do p( 3003 + i );
end
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 80 ⟶ 173:
3733 3793 3803 3823 3833 3853 3863 3923 3943
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">firstAndLastIs3?: function [n][
if not? prime? n -> return false
return and? -> 3 = first digits n
-> 3 = last digits n
]
 
primesWithFirstAndLast3: select 1..4000 => firstAndLastIs3?
 
loop split.every: 11 primesWithFirstAndLast3 'x ->
print map x 's -> pad to :string s 5
 
nofPrimesBelow1M: enumerate 1..1000000 => firstAndLastIs3?
 
print ""
print ["Found" nofPrimesBelow1M "primes starting and ending with 3 below 1000000."]</syntaxhighlight>
 
{{out}}
 
<pre> 3 313 353 373 383 3023 3083 3163 3203 3253 3313
3323 3343 3373 3413 3433 3463 3533 3583 3593 3613 3623
3643 3673 3733 3793 3803 3823 3833 3853 3863 3923 3943
 
Found 2251 primes starting and ending with 3 below 1000000. </pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f PRIMES_WHOSE_FIRST_AND_LAST_NUMBER_IS_3.AWK
BEGIN {
start = 1
stop = 3999
for (i=start; i<=stop; i++) {
if (is_prime(i) && i ~ /^3/ && i ~ /3$/) {
printf("%5d%1s",i,++count1%10?"":"\n")
}
}
printf("\nPrimes beginning and ending with '3' %d-%d: %d\n",start,stop,count1)
start = 1
stop = 999999
for (i=start; i<=stop; i++) {
if (is_prime(i) && i ~ /^3/ && i ~ /3$/) {
count2++
}
}
printf("Primes beginning and ending with '3' %d-%d: %d\n",start,stop,count2)
exit(0)
}
function is_prime(x, i) {
if (x <= 1) {
return(0)
}
for (i=2; i<=int(sqrt(x)); i++) {
if (x % i == 0) {
return(0)
}
}
return(1)
}
</syntaxhighlight>
{{out}}
<pre>
3 313 353 373 383 3023 3083 3163 3203 3253
3313 3323 3343 3373 3413 3433 3463 3533 3583 3593
3613 3623 3643 3673 3733 3793 3803 3823 3833 3853
3863 3923 3943
Primes beginning and ending with '3' 1-3999: 33
Primes beginning and ending with '3' 1-999999: 2251
</pre>
 
=={{header|C}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="c">#include<stdio.h>
#include<stdlib.h>
#include<math.h>
 
int isprime( int p ) {
int i;
if(p==2) return 1;
if(!(p%2)) return 0;
for(i=3; i*i<=p; i+=2) {
if(!(p%i)) return 0;
}
return 1;
}
 
int main(void) {
int np = 1, d, i, n;
printf( "3 " );
for(d=1; d<6; d++) {
for(i=3; i<pow(10,d)-1; i+=10) {
n = i + 3*pow(10,d);
if(isprime(n)) {
++np;
if(n<4009) {
printf("%d ",n);
if(!(np%10)) printf("\n");
}
}
}
}
printf( "\n\nThere were %d primes of the form 3x3 below one million.\n", np );
return 0;
}</syntaxhighlight>
{{out}}<pre>
3 313 353 373 383 3023 3083 3163 3203 3253
3313 3323 3343 3373 3413 3433 3463 3533 3583 3593
3613 3623 3643 3673 3733 3793 3803 3823 3833 3853
3863 3923 3943
 
There were 2251 primes of the form 3x3 below one million.</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
function IsPrime(N: int64): boolean;
{Fast, optimised prime test}
var I,Stop: int64;
begin
if (N = 2) or (N=3) then Result:=true
else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
else
begin
I:=5;
Stop:=Trunc(sqrt(N+0.0));
Result:=False;
while I<=Stop do
begin
if ((N mod I) = 0) or ((N mod (I + 2)) = 0) then exit;
Inc(I,6);
end;
Result:=True;
end;
end;
 
 
 
 
procedure GetDigits(N: integer; var IA: TIntegerDynArray);
{Get an array of the integers in a number}
var T: integer;
begin
SetLength(IA,0);
repeat
begin
T:=N mod 10;
N:=N div 10;
SetLength(IA,Length(IA)+1);
IA[High(IA)]:=T;
end
until N<1;
end;
 
 
 
procedure ShowFirstLast3Prime(Memo: TMemo);
var I,Cnt1,Cnt2: integer;
var IA: TIntegerDynArray;
var S: string;
 
function FirstLast3(N: integer): boolean;
var I: integer;
begin
GetDigits(N,IA);
Result:=(IA[0]=3) and (IA[High(IA)]=3);
end;
 
begin
Cnt1:=0; Cnt2:=0;
S:='';
for I:=0 to 1000000-1 do
if IsPrime(I) then
if FirstLast3(I) then
begin
Inc(Cnt1);
if I<4000 then
begin
Inc(Cnt2);
S:=S+Format('%5D',[I]);
If (Cnt2 mod 5)=0 then S:=S+CRLF;
end;
end;
Memo.Lines.Add(S);
Memo.Lines.Add('Count < 1,000 = '+IntToStr(Cnt2));
Memo.Lines.Add('Count < 1,000,000 = '+IntToStr(Cnt1));
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
3 313 353 373 383
3023 3083 3163 3203 3253
3313 3323 3343 3373 3413
3433 3463 3533 3583 3593
3613 3623 3643 3673 3733
3793 3803 3823 3833 3853
3863 3923 3943
Count < 1,000 = 33
Count < 1,000,000 = 2251
Elapsed Time: 181.797 ms.
 
</pre>
 
 
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<langsyntaxhighlight lang="fsharp">
//3 Sandwich Primes. Nigel Galloway: July 25th., 2021
primes32()|>Seq.takeWhile((>)4000)|>Seq.filter(fun n->n%10=3 && (n=3||(n>29 && n<40)||(n>299 && n<400)||n>2999))|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
3 313 353 373 383 3023 3083 3163 3203 3253 3313 3323 3343 3373 3413 3433 3463 3533 3583 3593 3613 3623 3643 3673 3733 3793 3803 3823 3833 3853 3863 3923 3943
</pre>
 
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: formatting grouping io kernel lists lists.lazy math
math.functions math.primes sequences ;
 
Line 114 ⟶ 414:
 
3 1,000,000 surrounded llength
"Found %d primes beginning and ending with 3 under 1,000,000.\n" printf</langsyntaxhighlight>
{{out}}
<pre>
Line 144 ⟶ 444:
 
Found 2251 primes beginning and ending with 3 under 1,000,000.
</pre>
 
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">np := 1;
!(3,' ');
for d = 1 to 5 do
for i = 3 to 10^d-1 by 10 do
n:=3*10^d + i;
if Isprime(n) = 1 then
np:=np+1;
if n<4000 then
!(n,' ');
if Divides(10,np) then !! fi;
fi;
fi;
od;
od;
!!;
!!;
!!('There were ',np,' primes of the form 3...3 below 1,000,000');
</syntaxhighlight>
{{out}}<pre>
3 313 353 373 383 3023 3083 3163 3203 3253
 
3313 3323 3343 3373 3413 3433 3463 3533 3583 3593
 
3613 3623 3643 3673 3733 3793 3803 3823 3833 3853
 
3863 3923 3943
 
There were 2251 primes of the form 3...3 below 1,000,000
</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">#include "isprime.bas"
 
dim as integer np = 1, d, n, i
print 3;" "; 'three counts, but is a special case
for d = 1 to 5 'how many digits after the initial 3
for i = 3 to 10^d-1 step 10 'the actual digits
n = 3*10^d + i
if isprime(n) then
np += 1
if n<4000 then
print n;" ";
if np mod 10 = 0 then print
end if
end if
next i
next d
print : print
print "There were ";np;" 3...3 primes below 1000000"</syntaxhighlight>
{{out}}<pre>
3 313 353 373 383 3023 3083 3163 3203 3253
3313 3323 3343 3373 3413 3433 3463 3533 3583 3593
3613 3623 3643 3673 3733 3793 3803 3823 3833 3853
3863 3923 3943
 
There were 2251 3...3 primes below 1000000
</pre>
 
=={{header|Go}}==
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 190 ⟶ 549:
pcc := rcu.Commatize(pc)
fmt.Println("\nFound", pcc, "primes under 1,000,000 which begin and end with 3.")
}</langsyntaxhighlight>
 
{{out}}
Line 202 ⟶ 561:
 
Found 2,251 primes under 1,000,000 which begin and end with 3.
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">
isPrime :: Int -> Bool
isPrime n
|n == 2 = True
|n == 1 = False
|otherwise = null $ filter (\i -> mod n i == 0 ) [2 .. root]
where
root :: Int
root = floor $ sqrt $ fromIntegral n
 
condition :: Int -> Bool
condition n = isPrime n && head numstr == '3' && last numstr == '3'
where
numstr :: String
numstr = show n
 
solution :: [Int]
solution = filter condition [1..3999]
 
main :: IO ( )
main = do
print solution
putStrLn ( "There are " ++ ( show $ length $ filter condition [1..999999]
) ++ " 3 x 3 primes below 1000000!" )
</syntaxhighlight>
{{out}}
<pre>
[3,313,353,373,383,3023,3083,3163,3203,3253,3313,3323,3343,3373,3413,3433,3463,3533,3583,3593,3613,3623,3643,3673,3733,3793,3803,3823,3833,3853,3863,3923,3943]
There are 2251 3 x 3 primes below 1000000!
</pre>
 
=={{header|J}}==
<syntaxhighlight lang="j"> primes3x3=. 3 ;@; 10 <@(#~ 1&p:)@(30&* + 3 + 10 * i.)@^ i.
 
primes3x3 3
3 313 353 373 383 3023 3083 3163 3203 3253 3313 3323 3343 3373 3413 3433 3463 3533 3583 3593 3613 3623 3643 3673 3733 3793 3803 3823 3833 3853 3863 3923 3943
 
# primes3x3 5
2251</syntaxhighlight>
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
 
See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.
<syntaxhighlight lang="jq"># For the stretch goal:
def count(s): reduce s as $x (null; .+1);
 
# $n is the max number of intervening digits
def task($n):
3,
(range(1; $n+1) as $power
| (3 * pow(10; $power+1) + 3) as $min
| ("3" + ((pow(10; $power) -1)|tostring) + "4"|tonumber) as $max
| range($min; $max; 10)
| select(is_prime) ) ;
 
task(2),
"\nStretch goal: \(count( task(4) ))"</syntaxhighlight>
{{out}}
<pre>
3
313
353
373
383
3023
3083
3163
3203
3253
3313
3323
3343
3373
3413
3433
3463
3533
3583
3593
3613
3623
3643
3673
3733
3793
3803
3823
3833
3853
3863
3923
3943
 
Stretch goal: 2251
</pre>
 
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Primes
 
isxbyx(n, base=10, dig=3) = n ÷ prevpow(base, n) == dig && n % base == dig
p3x3(N, base=10, dig=3) = [p for p in primes(N) if isxbyx(p, base, dig)]
 
for d in 1:2:9
println("\n$(d)x$d primes < 10000:")
foreach(p -> print(rpad(last(p), 5), first(p) % 11 == 0 ? "\n" : ""),
enumerate(p3x3(10000, 10, d)))
println("\nTotal $(d)x$d primes less than 1,000,000: ", length(p3x3(1_000_000, 10, d)), ".")
end
</syntaxhighlight>{{out}}
<pre>
1x1 primes < 10000:
11 101 131 151 181 191 1021 1031 1051 1061 1091
1151 1171 1181 1201 1231 1291 1301 1321 1361 1381 1451
1471 1481 1511 1531 1571 1601 1621 1721 1741 1801 1811
1831 1861 1871 1901 1931 1951
Total 1x1 primes less than 1,000,000: 2387.
 
3x3 primes < 10000:
3 313 353 373 383 3023 3083 3163 3203 3253 3313
3323 3343 3373 3413 3433 3463 3533 3583 3593 3613 3623
3643 3673 3733 3793 3803 3823 3833 3853 3863 3923 3943
 
Total 3x3 primes less than 1,000,000: 2251.
 
5x5 primes < 10000:
5
Total 5x5 primes less than 1,000,000: 1.
 
7x7 primes < 10000:
7 727 757 787 797 7027 7057 7127 7177 7187 7207
7237 7247 7297 7307 7417 7457 7477 7487 7507 7517 7537
7547 7577 7607 7687 7717 7727 7757 7817 7867 7877 7907
7927 7937
Total 7x7 primes less than 1,000,000: 2104.
 
9x9 primes < 10000:
919 929 9029 9049 9059 9109 9199 9209 9239 9319 9349
9419 9439 9479 9539 9619 9629 9649 9679 9689 9719 9739
9749 9769 9829 9839 9859 9929 9949
Total 9x9 primes less than 1,000,000: 2053.
</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Cases[NestWhileList[NextPrime,
2, # < 4000 &], _?(IntegerDigits[#][[{1, -1}]] === {3, 3} &)]</syntaxhighlight>
 
{{out}}<pre>
{3,313,353,373,383,3023,3083,3163,3203,3253,3313,3323,3343,3373,3413,3433,3463,3533,3583,3593,3613,3623,3643,3673,3733,3793,3803,3823,3833,3853,3863,3923,3943}
</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strformat
 
func isPrime(n: Positive): bool =
Line 234 ⟶ 746:
stdout.write &"{n:4}", if (i + 1) mod 11 == 0: '\n' else: ' '
 
echo &"\nFound {count} primes starting and ending with 3 below 1_000_000."</langsyntaxhighlight>
 
{{out}}
Line 246 ⟶ 758:
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Primes_whose_first_and_last_number_is_3
Line 255 ⟶ 767:
my $n33 = grep /^3/ && /3$/, @{ primes( 1_000_000 ) };
print @n33 . " under 4000\n\n@n33" =~ s/.{75}\K /\n/gr,
"\n\n$n33 under 1000000\n";</langsyntaxhighlight>
{{out}}
<pre>
Line 268 ⟶ 780:
=={{header|Phix}}==
Works for any digit, partly inspired by the Wren entry.
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">primes_with_first_and_last_digit</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">d</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">p10</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">-- d should be 0..9
Line 292 ⟶ 805:
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">primes_with_first_and_last_digit</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"There are %d primes under 1,000,000 which begin and end in 3\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)})</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 305 ⟶ 818:
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>my $upto = 1e4;
 
for 1,3,5,7,9 -> $bracket {
Line 315 ⟶ 828:
cache $list;
$title ~ $list.batch($cols)».fmt($fmt).join: "\n"
}</langsyntaxhighlight>
{{out}}
<pre>Primes up to 10000 bracketed by 1 - 39 matching:
Line 348 ⟶ 861:
 
Also, &nbsp; if a negative &nbsp; '''cols''' &nbsp; is specified, &nbsp; only the &nbsp; ''count'' &nbsp; of primes found is shown.
<langsyntaxhighlight lang="rexx">/*REXX pgm finds and displays primes (base ten) that contain a leading and trailing 3. */
parse arg hi cols dig . /*obtain optional argument from the CL.*/
if hi=='' | hi=="," then hi= 4000 /*Not specified? Then use the default.*/
Line 392 ⟶ 905:
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; sq.#= j*j /*bump # of Ps; assign next P; P square*/
end /*j*/; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 411 ⟶ 924:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 430 ⟶ 943:
see nl + "Found " + row + " numbers" + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 441 ⟶ 954:
Found 33 numbers
done...
</pre>
 
=={{header|RPL}}==
Uses a candidate numbers generator to speed up execution.
{{works with|HP|49}}
≪ { } 3
'''WHILE''' DUP 4000 < '''REPEAT'''
'''IF''' DUP ISPRIME? '''THEN''' SWAP OVER + SWAP '''END'''
10 +
'''IF''' DUP MANT IP 3 ≠ '''THEN''' XPON 1 + ALOG 3 * 3 + '''END'''
'''END''' DROP
≫ '<span style="color:blue">33PRIMES</span>' STO
{{out}}
<pre>
1: { 3 313 353 373 383 3023 3083 3163 3203 3253 3313 3323 3343 3373 3413 3433 3463 3533 3583 3593 3613 3623 3643 3673 3733 3793 3803 3823 3833 3853 3863 3923 3943 }
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
 
puts "Primes below #{n=4000} which start and end with #{d=3}: "
p Prime.each(n).select{|pr| p_d = pr.digits; p_d.first == d && p_d.last == d}
 
print "\nCount of primes below #{n=1_000_000} which start and en with #{d=3}: "
puts Prime.each(n).count{|pr| p_d = pr.digits; p_d.first == d && p_d.last == d}
</syntaxhighlight>
{{out}}
<pre>Primes below 4000 which start and end with 3:
[3, 313, 353, 373, 383, 3023, 3083, 3163, 3203, 3253, 3313, 3323, 3343, 3373, 3413, 3433, 3463, 3533, 3583, 3593, 3613, 3623, 3643, 3673, 3733, 3793, 3803, 3823, 3833, 3853, 3863, 3923, 3943]
 
Count of primes below 1000000 which start and en with 3: 2251
</pre>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func numbers_with_edges(upto, base = 10, s = [3]) {
Enumerator({|callback|
callback(s.digits2num(base))
Line 471 ⟶ 1,015:
var count = numbers_with_edges(n).grep{.is_prime}.len
say "\nThere are #{count} primes <= #{n.commify} which begin and end in 3"
}</langsyntaxhighlight>
{{out}}
<pre>
Line 485 ⟶ 1,029:
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-traititerate}}
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
 
===Basic task===
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int
import "./traititerate" for Stepped
import "./seqfmt" for LstFmt
import "/fmt" for Fmt
 
var primes = []
Line 500 ⟶ 1,042:
}
System.print("Primes under 4,000 which begin and end in 3:")
for (chunk in Lst.chunks(primes, 11)) Fmt.printtprint("$,5d", chunkprimes, 11)
System.print("\nFound %(primes.count) such primes.")</langsyntaxhighlight>
 
{{out}}
Line 515 ⟶ 1,057:
===More general===
This version deals with primes (in base 10) beginning and ending with any specified digit and with up to a given number of digits.
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int
import "./traititerate" for Stepped
import "./seqfmt" for LstFmt
import "/fmt" for Fmt
 
var getQualifyingPrimes = Fn.new { |x, d|
Line 540 ⟶ 1,081:
var len = d + ((d-1)/3).floor
Fmt.print("Primes under $,%(len)d which begin and end in $d:", 10.pow(d), x)
for (chunk in Lst.chunks(primes, 10)) Fmt.printtprint("$,%(len)d", chunkprimes, 10)
System.print("\nFound %(primes.count) such primes.\n")
}
Line 548 ⟶ 1,089:
var primes = getQualifyingPrimes.call(x, d)
Fmt.print("Found $,d primes under $,d which begin and end with $d.\n", primes.count, 10.pow(d), x)
}</langsyntaxhighlight>
 
{{out}}
Line 603 ⟶ 1,144:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func IsPrime(N); \Return 'true' if N is a prime number
int N, I;
[if N <= 1 then return false;
Line 640 ⟶ 1,181:
Text(0, " such primes found below 1,000,000.
");
]</langsyntaxhighlight>
 
{{out}}
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/313886...354928"