Rosetta Code

Erdős-primes: Difference between revisions

Page Discussion

Erdős-primes (view source)

Revision as of 14:16, 10 April 2024

15,964 bytes added ,  1 month ago
Add APL
(→‎{{header|PL/0}}: Added a solution.)
(Add APL)
 
(24 intermediate revisions by 10 users not shown)
Line 73:
The 7875th Erdos prime is 999721.
</pre>
 
=={{header|ABC}}==
<syntaxhighlight lang="abc">HOW TO REPORT prime n:
SELECT:
n < 2: FAIL
n mod 2 = 0: REPORT n=2
ELSE: REPORT NO d IN {2..floor (root n)} HAS n mod d = 0
 
HOW TO REPORT erdos p:
IF NOT prime p: FAIL
PUT 1, 1 IN k, k.fac
WHILE k.fac < p:
IF prime (p - k.fac): FAIL
PUT k+1 IN k
PUT k.fac*k IN k.fac
SUCCEED
 
PUT 0 IN nprimes
FOR n IN {1..2499}:
IF erdos n:
WRITE n>>6
PUT nprimes+1 IN nprimes
IF nprimes mod 10 = 0: WRITE/
 
WRITE /
WRITE "There are `nprimes` Erdos primes < 2500."/
 
PUT 2499 IN n
WHILE nprimes < 7875:
PUT n+2 IN n
IF erdos n: PUT nprimes + 1 IN nprimes
 
WRITE "The `nprimes`th Erdos prime is `n`."/</syntaxhighlight>
{{out}}
<pre> 2 101 211 367 409 419 461 557 673 709
769 937 967 1009 1201 1259 1709 1831 1889 2141
2221 2309 2351 2411 2437
There are 25 Erdos primes < 2500.
The 7875th Erdos prime is 999721.</pre>
 
=={{header|Action!}}==
Line 121 ⟶ 160:
 
=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">BEGIN # find Erdős primes - primes p such that p-k! is composite for all 1<=k!<p #
BEGIN # find Erdős primes - primes p where p-k! is composite for all 1<=k!<p #
# returns TRUE if p is an Erdős prime #
PROC is erdos prime = ( INT p )BOOL:
Line 133 ⟶ 173:
result
FI # is erdos prime # ;
INT max prime = 25001 000 000; # maximum number we will consider #
INT max erdos = 7 875; # maximum Erdős prime to find #
# construct a table of factorials large enough for max prime #
# construct a table of factorials large enough for max prime #
[ 1 : 12 ]INT factorial;
factorial[ 1 ] := 1;
Line 140 ⟶ 181:
factorial[ f ] := factorial[ f - 1 ] * f
OD;
#PR sieve theread "primes.incl.a68" toPR max # include prime utilities #
[]BOOL prime = PRIMESIEVE max prime; # sieve the primes to max prime #
PR read "primes.incl.a68" PR
[]BOOLINT primemax show = PRIMESIEVE max2 prime500;
# find the Erdős primes, showing the ones up to max show #
INT e count := 0;
IF is erdos prime( 2 ) THEN
Line 149 ⟶ 190:
e count +:= 1
FI;
INT last erdos := 0;
FOR p FROM 3 BY 2 TO UPB prime DO
FOR p FROM 3 BY 2 TO max show DO
IF is erdos prime( p ) THEN
print( ( " ", whole( p, 0 ) ) );
elast counterdos +:= 1p;
e count +:= 1
FI
OD;
print( ( newline, "Found ", whole( e count, 0 ), " Erdos primes" ) )
, " Erdos primes up to ", whole( max show, 0 ), newline ) );
END</syntaxhighlight>
# find the max erdos'th Erdős prime #
FOR p FROM max show WHILE e count < max erdos DO
IF is erdos prime( p ) THEN
last erdos := p;
e count +:= 1
FI
OD;
print( ( whole( last erdos, 0 ), " is Erdos prime ", whole( e count, 0 ), newline ) )
END
</syntaxhighlight>
{{out}}
<pre>
2 101 211 367 409 419 461 557 673 709 769 937 967 1009 1201 1259 1709 1831 1889 2141 2221 2309 2351 2411 2437
Found 25 Erdos primes up to 2500
999721 is Erdos prime 7875
</pre>
 
=={{header|APL}}==
<syntaxhighlight lang="apl">erdos_primes←{
prime ← {(⍵≥2) ∧ 0∧.≠(1↓⍳⌊⍵*÷2)|⍵}
erdos ← {(prime ⍵) ∧ ∧/~prime¨ ⍵-!⍳⌊(!⍣¯1)⍵}
e2500 ← (erdos¨e)/e←⍳2500
⎕←e2500
⎕←'There are ',(⍕⍴e2500),' Erdős numbers ≤ 2500'
}</syntaxhighlight>
{{out}}
<pre>2 101 211 367 409 419 461 557 673 709 769 937 967 1009 1201 1259 1709 1831 1889 2141 2221 2309 2351 2411 2437
There are 25 Erdős numbers ≤ 2500</pre>
 
=={{header|Arturo}}==
Line 282 ⟶ 348:
25 2437
7875 999721
</pre>
 
==={{header|Palo Alto Tiny BASIC}}===
{{trans|Tiny BASIC|Removed overlapping loops.}}
Without the stretch goal because numbers are limited to signed 16-bit integers.
<syntaxhighlight lang="basic">
10 REM ERDOS-PRIMES
20 LET P=2,C=1
30 PRINT C," ",P
40 FOR P=3 TO 2500 STEP 2
50 LET Z=P;GOSUB 1000
60 IF A=0 GOTO 160
70 REM F = K!
80 LET K=1,F=1,Z=P-F
90 IF Z<0 GOTO 150
100 GOSUB 1000
110 IF A=1 GOTO 150
120 LET K=K+1,F=F*K,Z=P-F
130 IF Z<0 GOTO 150
140 GOTO 100
150 IF Z<0 LET C=C+1;PRINT C," ",P
160 NEXT P
170 STOP
980 REM PRIMALITY OF Z BY TRIAL DIVISION
990 REM RESULT IS IN A
1000 LET A=0
1010 IF Z=2 LET A=1;RETURN
1020 IF Z<3 RETURN
1030 LET Y=2
1040 IF (Z/Y)*Y=Z RETURN
1050 IF Y*Y>=Z LET A=1;RETURN
1060 LET Y=Y+1
1070 GOTO 1040
1080 RETURN
</syntaxhighlight>
{{out}}
<pre>
1 2
2 101
3 211
4 367
5 409
6 419
7 461
8 557
9 673
10 709
11 769
12 937
13 967
14 1009
15 1201
16 1259
17 1709
18 1831
19 1889
20 2141
21 2221
22 2309
23 2351
24 2411
25 2437
</pre>
 
Line 346 ⟶ 474:
24 2411
25 2437
</pre>
 
=={{header|C}}==
{{trans|Wren}}
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <locale.h>
 
#define LIMIT 1000000
#define LOWER_LIMIT 2500
 
bool *sieve(int limit) {
int i, p;
limit++;
// True denotes composite, false denotes prime.
bool *c = calloc(limit, sizeof(bool)); // all false by default
c[0] = true;
c[1] = true;
for (i = 4; i < limit; i += 2) c[i] = true;
p = 3; // Start from 3.
while (true) {
int p2 = p * p;
if (p2 >= limit) break;
for (i = p2; i < limit; i += 2 * p) c[i] = true;
while (true) {
p += 2;
if (!c[p]) break;
}
}
return c;
}
 
int main() {
int i, j, fact, ec = 0, ec2 = 0, lastErdos = 0;
bool found;
bool *c = sieve(LIMIT-1);
int erdos[30];
for (i = 2; i < LIMIT;) {
if (!c[i]) {
j = 1;
fact = 1;
found = true;
while (fact < i) {
if (!c[i-fact]) {
found = false;
break;
}
++j;
fact *= j;
}
if (found) {
if (i < LOWER_LIMIT) erdos[ec2++] = i;
lastErdos = i;
++ec;
}
}
i = (i > 2) ? i + 2 : i + 1;
}
setlocale(LC_NUMERIC, "");
printf("The %'d Erdős primes under %'d are:\n", ec2, LOWER_LIMIT);
for (i = 0; i < ec2; ++i) {
printf("%6d ", erdos[i]);
if (!((i+1)%10)) printf("\n");
}
printf("\n\nThe %'dth Erdős prime is %'d.\n", ec, lastErdos);
free(c);
return 0;
}</syntaxhighlight>
 
{{out}}
<pre>
The 25 Erdős primes under 2,500 are:
2 101 211 367 409 419 461 557 673 709
769 937 967 1009 1201 1259 1709 1831 1889 2141
2221 2309 2351 2411 2437
 
The 7,875th Erdős prime is 999,721.
</pre>
 
Line 443 ⟶ 649:
 
The 7,875th Erdős prime is 999,721.
</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
Executes in 225 ms. It could be faster with a Factorial lookup table.
 
<syntaxhighlight lang="Delphi">
function IsPrime(N: integer): boolean;
{Optimised prime test - about 40% faster than the naive approach}
var I,Stop: integer;
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));
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;
 
 
 
function Factorial(N: Word): int64;
var I: integer;
begin
Result:= 1;
for I := 2 to N do Result:=Result * I;
end;
 
 
function IsErdosPrime(P: integer): boolean;
{Test if specified Primes is Erdos}
{i.e. all p-k! for 1<=k!<p are composite.}
var K: integer;
var F: int64;
begin
K:=1;
Result:=False;
while True do
begin
F:=Factorial(K);
if F>=P then break;
if IsPrime(P-F) then exit;
Inc(K);
end;
Result:=True;
end;
 
 
procedure FindErdosPrimes(Memo: TMemo);
{Collect and display Erdos primes}
var P,I,Cnt: integer;
var Erdos: array of integer;
var S: string;
begin
{Collect all Erdos Primes<1,000,000}
for P:=2 to 1000000 do
if IsPrime(P) then
if IsErdosPrime(P) then
begin
SetLength(Erdos,Length(Erdos)+1);
Erdos[High(Erdos)]:=P;
end;
{Display the data in several different ways}
Memo.Lines.Add('25 Erdos primes less than 2500');
S:='';
for I:=0 to 24 do
begin
S:=S+Format('%8d',[Erdos[I]]);
if (((I+1) mod 5)=0) or (I=24) then
begin
Memo.Lines.Add(S);
S:='';
end;
end;
Memo.Lines.Add('Summary:');
Memo.Lines.Add('Number of Erdos Primes < 1-million: '+IntToStr(Length(Erdos)));
Memo.Lines.Add('Last Erdos Prime < 1-million: '+IntToStr(Erdos[High(Erdos)]));
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
25 Erdos primes less than 2500
2 101 211 367 409
419 461 557 673 709
769 937 967 1009 1201
1259 1709 1831 1889 2141
2221 2309 2351 2411 2437
Summary:
Number of Erdos Primes < 1-million: 7875
Last Erdos Prime < 1-million: 999721
 
</pre>
 
 
=={{header|EasyLang}}==
{{trans|Action!}}
<syntaxhighlight>
fastfunc isprim num .
if num < 2
return 0
.
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
func iserdosprim p .
if isprim p = 0
return 0
.
k = 1
f = 1
while f < p
if isprim (p - f) = 1
return 0
.
k += 1
f *= k
.
return 1
.
for p = 2 to 2499
if iserdosprim p = 1
write p & " "
.
.
</syntaxhighlight>
{{out}}
<pre>
2 101 211 367 409 419 461 557 673 709 769 937 967 1009 1201 1259 1709 1831 1889 2141 2221 2309 2351 2411 2437
</pre>
 
Line 460 ⟶ 811:
7875th Erdos prime is 999721
</pre>
 
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
Line 554 ⟶ 906:
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<syntaxhighlight lang="go">package main
 
import "fmt"(
"fmt"
 
"rcu"
func sieve(limit int) []bool {
)
limit++
// True denotes composite, false denotes prime.
c := make([]bool, limit) // all false by default
c[0] = true
c[1] = true
for i := 4; i < limit; i += 2 {
c[i] = true
}
p := 3 // Start from 3.
for {
p2 := p * p
if p2 >= limit {
break
}
for i := p2; i < limit; i += 2 * p {
c[i] = true
}
for {
p += 2
if !c[p] {
break
}
}
}
return c
}
 
func commatize(n int) string {
s := fmt.Sprintf("%d", n)
if n < 0 {
s = s[1:]
}
le := len(s)
for i := le - 3; i >= 1; i -= 3 {
s = s[0:i] + "," + s[i:]
}
if n >= 0 {
return s
}
return "-" + s
}
 
func main() {
limit := int(1e6)
clowerLimit := sieve(limit - 1)2500
c := rcu.PrimeSieve(limit-1, true)
var erdos []int
lastErdos := 0
ec := 0
for i := 2; i < limit; {
if !c[i] {
Line 617 ⟶ 933:
}
if found {
erdosif =i append(erdos,< i)lowerLimit {
erdos = append(erdos, i)
}
lastErdos = i
ec++
}
}
Line 626 ⟶ 946:
}
}
fmt.Printf("The %d Erdős primes under %s are\n", len(erdos), rcu.Commatize(lowerLimit))
lowerLimit := 2500
rcu.PrintTable(erdos, 10, 6, false)
var erdosLower []int
fmt.Printf("\nThe %s Erdős prime is %s.\n", rcu.Commatize(ec), rcu.Commatize(lastErdos))
for _, e := range erdos {
if e < lowerLimit {
erdosLower = append(erdosLower, e)
} else {
break
}
}
fmt.Printf("The %d Erdős primes under %s are\n", len(erdosLower), commatize(lowerLimit))
for i, e := range erdosLower {
fmt.Printf("%6d", e)
if (i+1)%10 == 0 {
fmt.Println()
}
}
show := 7875
fmt.Printf("\n\nThe %s Erdős prime is %s.\n", commatize(show), commatize(erdos[show-1]))
}</syntaxhighlight>
 
Line 649 ⟶ 954:
<pre>
The 25 Erdős primes under 2,500 are
2 101 211 367 409 419 461 557 673 709
769 937 967 1009 1201 1259 1709 1831 1889 2141
2221 2309 2351 2411 2437
 
The 7,875 Erdős prime is 999,721.
Line 843 ⟶ 1,148:
The 7875th Erdős prime is 999,721
</pre>
 
=={{header|Lua}}==
<syntaxhighlight lang="lua">function isPrime (x)
if x < 2 then return false end
if x < 4 then return true end
if x % 2 == 0 then return false end
for d = 3, math.sqrt(x), 2 do
if x % d == 0 then return false end
end
return true
end
 
function primes ()
local x, maxInt = 3, 2^53
local function yieldPrimes ()
coroutine.yield(2)
repeat
if isPrime(x) then coroutine.yield(x) end
x = x + 2
until x == maxInt
end
return coroutine.wrap(function() yieldPrimes() end)
end
 
function factorial (n)
local f = 1
for i = 2, n do
f = f * i
end
return f
end
 
function isErdos (p)
local k, factK = 1
repeat
factK = factorial(k)
if isPrime(p - factK) then return false end
k = k + 1
until factK >= p
return true
end
 
local nextPrime, count, prime = primes(), 0
while count < 7875 do
prime = nextPrime()
if isErdos(prime) then
if prime < 2500 then io.write(prime .. " ") end
count = count + 1
end
end
print("\n\nThe 7875th Erdos prime is " .. prime)</syntaxhighlight>
{{out}}
<pre>2 101 211 367 409 419 461 557 673 709 769 937 967 1009 1201 1259 1709 1831 1889 2141 2221 2309 2351 2411 2437
 
The 7875th Erdos prime is 999721</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Line 866 ⟶ 1,226:
25
{7875, 999721}</pre>
 
=={{header|Miranda}}==
<syntaxhighlight lang="miranda">main :: [sys_message]
main = [Stdout (lay (map show erdos2500)),
Stdout ("There are " ++ show (#erdos2500) ++ " Erdos numbers <2500\n")]
where erdos2500 = filter erdos [1..2499]
 
erdos :: num->bool
erdos p = prime p & ~or [prime (p-k) | k <- takewhile (<p) (scan (*) 1 [2..])]
 
prime :: num->bool
prime n = n=2 \/ n=3, if n<=4
prime n = False, if n mod 2=0
prime n = and [n mod d ~= 0 | d <- [2..entier (sqrt n)]]</syntaxhighlight>
{{out}}
<pre>2
101
211
367
409
419
461
557
673
709
769
937
967
1009
1201
1259
1709
1831
1889
2141
2221
2309
2351
2411
2437
There are 25 Erdos numbers <2500</pre>
 
=={{header|Nim}}==
Line 1,074 ⟶ 1,475:
2411
2437
</pre>
 
=={{header|PL/M}}==
{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)
Basic task only as PL/M integers are 8/16 bit unsigned.
<syntaxhighlight lang="plm">
100H: /* FIND ERDOS PRIMES: PRIMES P WHERE P-K! IS COMPOSITE FOR ALL 1<=K!<P */
 
/* CP/M SYSTEM CALL AND I/O ROUTINES */
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
PR$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;
PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;
PR$NL: PROCEDURE; CALL PR$CHAR( 0DH ); CALL PR$CHAR( 0AH ); END;
PR$NUMBER: PROCEDURE( N ); /* PRINTS A NUMBER IN THE MINIMUN FIELD WIDTH */
DECLARE N ADDRESS;
DECLARE V ADDRESS, N$STR ( 6 )BYTE, W BYTE;
V = N;
W = LAST( N$STR );
N$STR( W ) = '$';
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
DO WHILE( ( V := V / 10 ) > 0 );
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
END;
CALL PR$STRING( .N$STR( W ) );
END PR$NUMBER;
 
/* TASK */
 
DECLARE MAX$NUMBER LITERALLY '2500'
, FALSE LITERALLY '0'
, TRUE LITERALLY '0FFH'
;
 
DECLARE PRIME ( MAX$NUMBER )BYTE; /* SIEVE THE PRIMES TO MAX$NUMBER - 1 */
DECLARE I ADDRESS;
PRIME( 0 ), PRIME( 1 ) = FALSE;
PRIME( 2 ) = TRUE;
DO I = 3 TO LAST( PRIME ) BY 2; PRIME( I ) = TRUE; END;
DO I = 4 TO LAST( PRIME ) BY 2; PRIME( I ) = FALSE; END;
DO I = 3 TO LAST( PRIME ) BY 2;
IF PRIME( I ) THEN DO;
DECLARE S ADDRESS;
DO S = I + I TO LAST( PRIME ) BY I;
PRIME( S ) = FALSE;
END;
END;
END;
 
/* TABLE OF FACTORIALS */
DECLARE FACTORIAL ( 8 )ADDRESS INITIAL( 1, 1, 2, 6, 24, 120, 720, 5040 );
 
/* RETURNS TRUE IF P IS AN ERDOS PRIME, FALSE OTHERWISE */
IS$ERDOS$PRIME: PROCEDURE( P )BYTE;
DECLARE P ADDRESS;
DECLARE RESULT BYTE;
RESULT = PRIME( P );
IF RESULT THEN DO;
DECLARE K BYTE;
K = 1;
DO WHILE FACTORIAL( K ) < P AND RESULT;
RESULT = NOT PRIME( P - FACTORIAL( K ) );
K = K + 1;
END;
END;
RETURN RESULT;
END IS$ERDOS$PRIME ;
 
/* FIND THE ERDOS PRIMES */
DECLARE ( P, COUNT ) ADDRESS;
COUNT = 0;
IF IS$ERDOS$PRIME( 2 ) THEN DO;
COUNT = COUNT + 1;
CALL PR$STRING( .' 2$' );
END;
P = 1;
DO WHILE COUNT < 25;
P = P + 2;
IF IS$ERDOS$PRIME( P ) THEN DO;
COUNT = COUNT + 1;
CALL PR$CHAR( ' ' );
IF P < 1000 THEN CALL PR$CHAR( ' ' );
CALL PR$NUMBER( P );
IF COUNT MOD 5 = 0 THEN CALL PR$NL;
END;
END;
 
EOF
</syntaxhighlight>
{{out}}
<pre>
2 101 211 367 409
419 461 557 673 709
769 937 967 1009 1201
1259 1709 1831 1889 2141
2221 2309 2351 2411 2437
</pre>
 
Line 1,091 ⟶ 1,587:
 
The 7,875th Erdős prime is: 999,721</pre>
 
Alternately, using fewer hard coded values:
 
 
<syntaxhighlight lang="raku" line>use Lingua::EN::Numbers;
use List::Divvy;
 
my @factorial = 1, |[\*] 1..*;
my @Erdős = ^∞ .grep: { .is-prime and none($_ «-« @factorial.&upto: $_).is-prime }
 
put "Erdős primes < 2500:\n" ~ @Erdős.&before(2500)».&comma.batch(8)».fmt("%5s").join: "\n";
put "\nThe largest Erdős prime less than {comma 1e6.Int} is {comma .[*-1]} in {.&ordinal-digit} position."
given @Erdős.&before(1e6);</syntaxhighlight>
{{out}}
<pre>Erdős primes < 2500:
2 101 211 367 409 419 461 557
673 709 769 937 967 1,009 1,201 1,259
1,709 1,831 1,889 2,141 2,221 2,309 2,351 2,411
2,437
 
The largest Erdős prime less than 1,000,000 is 999,721 in 7875th position.</pre>
 
=={{header|REXX}}==
Line 1,161 ⟶ 1,678:
 
999,721 is the 7,875th Erdos prime.
</pre>
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">
load "stdlibcore.ring"
see "working..." + nl
row = 0
limit = 2500
 
for p = 1 to limit
flag = 1
if isprime(p)
for k = 1 to p
if factorial(k) < p
temp = p - factorial(k)
if not isprime(temp)
flag = 1
else
flag = 0
exit
ok
else
exit
ok
next
else
flag = 0
ok
if flag = 1
row++
see "" + p + " "
if row % 5 = 0
see nl
ok
ok
next
 
see nl + "Found " + row + " Erdos primes less than 2500" + nl
see "done..." + nl
</syntaxhighlight>
{{out}}
<pre>
working...
2 101 211 367 409
419 461 557 673 709
769 937 967 1009 1201
1259 1709 1831 1889 2141
2221 2309 2351 2411 2437
 
Found 25 Erdos primes less than 2500
done...
</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
« 0 → p k
« 1 SF
'''WHILE''' p 'k' INCR FACT - DUP 0 > 1 FS? AND '''REPEAT'''
'''IF''' ISPRIME? '''THEN''' 1 CF '''END'''
'''END'''
DROP 1 FS?
» » '<span style="color:blue">ERDOS?</span>' STO <span style="color:grey">@ ( n → erdös(n) )</span>
« { } 2
'''WHILE''' DUP 2500 < '''REPEAT'''
'''IF''' DUP <span style="color:blue">ERDOS?</span> '''THEN''' SWAP OVER + SWAP '''END'''
NEXTPRIME
'''END'''
DROP DUP SIZE "count" →TAG
» '<span style="color:blue">TASK</span>' STO <span style="color:grey">@ ( → results )</span>
 
{{out}}
<pre>
2: { 2 101 211 367 409 419 461 557 673 709 769 937 967 1009 1201 1259 1709 1831 1889 2141 2221 2309 2351 2411 2437 }
1: count: 25.
</pre>
 
Line 1,217 ⟶ 1,809:
</pre>
 
=={{header|SETL}}==
<syntaxhighlight lang="setl">program erdos_primes;
loop for e in [1..2499] | erdos e do
nprint(lpad(str e, 6));
if (n +:= 1) mod 10=0 then print; end if;
end loop;
 
print;
print("There are " + str n + " Erdos numbers < 2500");
 
e := 2499;
loop while n < 7875 do
loop until erdos e do
e +:= 2;
end loop;
n +:= 1;
end loop;
 
print("The " + str n + "th Erdos number is " + str e);
 
op erdos(p);
return prime p and not exists k in faclist p | prime (p-k);
end erdos;
 
op faclist(n);
f := 1;
return [[i+:=1, f*:=i](2) : until n<f](..i-1);
end op;
 
op prime(n);
if n<=4 then
return n in [2,3];
end if;
return odd n and not exists d in [3, 5..floor (sqrt n)] | n mod d=0;
end op;
end program;</syntaxhighlight>
{{out}}
<pre> 2 101 211 367 409 419 461 557 673 709
769 937 967 1009 1201 1259 1709 1831 1889 2141
2221 2309 2351 2411 2437
There are 25 Erdos numbers < 2500
The 7875th Erdos number is 999721</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func is_erdos_prime(p) {
Line 1,243 ⟶ 1,877:
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="ecmascriptwren">import "./math" for Int
import "./seqfmt" for LstFmt
import "/fmt" for Fmt
 
var limit = 1e6
var lowerLimit = 2500
var primes = Int.primeSieve(limit - 1, true)
var c = Int.primeSieve(limit - 1, false)
var erdos = []
var lastErdos = 0
for (p in primes) {
var iec = 10
var facti = 12
while (i < limit) {
var found = true
whileif (fact < p!c[i]) {
ifvar (Int.isPrime(pj -= fact)) {1
var foundfact = false1
var found = breaktrue
while (fact < i) {
if (!c[i - fact]) {
found = false
break
}
j = j + 1
fact = fact * j
}
if (found) {
if (i < lowerLimit) erdos.add(i)
lastErdos = i
ec = ec + 1
}
i = i + 1
fact = fact * i
}
i = (i > 2) ? i + 2 : i + 1
if (found) erdos.add(p)
}
 
var lowerLimit = 2500
Fmt.print("The $,d Erdős primes under $,d are:", erdos.count, lowerLimit)
var erdosLower = erdos.where { |e| e < lowerLimit}.toList
Fmt.tprint("$6d", erdos, 10)
Fmt.print("The $,d Erdős primes under $,d are:", erdosLower.count, lowerLimit)
Fmt.print("\nThe $,r Erdős prime is $,d.", ec, lastErdos)</syntaxhighlight>
for (chunk in Lst.chunks(erdosLower, 10)) Fmt.print("$6d", chunk)
var show = 7875
Fmt.print("\nThe $,r Erdős prime is $,d.", show, erdos[show-1])</syntaxhighlight>
 
{{out}}
<pre>
The 25 Erdős primes under 2,500 are:
2 101 211 367 409 419 461 557 673 709
769 937 967 1009 1201 1259 1709 1831 1889 2141
2221 2309 2351 2411 2437
 
The 7,875th Erdős prime is 999,721.
Not a robot
2,099

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/337185...363433"