Rosetta Code

Quad-power prime seeds: Difference between revisions

Page Discussion

Quad-power prime seeds (view source)

Revision as of 22:45, 15 December 2023

22,060 bytes added ,  5 months ago
Added Sidef
(Added Sidef)
 
(27 intermediate revisions by 14 users not shown)
Line 1:
{{draft task}}
 
Generate the sequence of quad-power prime seeds: positive integers '''n''' such that:
Line 7:
 
;Task
* Find and display the first fifty quad-power prime seeds. (Or as many as are reasonably supported by your languages math capability if it is less.)
 
 
Line 15:
 
;See also
;*[[Penta-power prime seeds|Task: Penta-power prime seeds]]
;*[[oeis:A219117|A219117 - Numbers n such that n^1+n+1, n^2+n+1, n^3+n+1 and n^4+n+1 are all prime]]
 
Line 21 ⟶ 22:
 
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 3.0.3 under WindopwsWindows 10}}
This uses ALGOL 68G's LONG LONG INT during the Miller Rabin testing, under ALGOL 68G version three, the default precision of LONG LONG INT is 72 digits and LONG INT is 128 bit.
A sieve is used to (hopefully) quickly eliminate non-prime 2n+1 numbers - Miller Rabin is used for n^2+n+1 etc. that are larger than the sieve.
This is about 10 times slower than the equivalent Penta-powwr prime seed program, possibly because even numbers are included and the n+2 test in the Penta-powers eliminates more numbers before the higher powers must be calculated.
{{libheader|ALGOL 68-primes}}
<br>
NB: The source of the ALGOL 68-primes library is on a Rosetta Code code page linked from the above.<br>
Note that to run this with ALGOL 68G under Windows (and probably Linux) a large heap sie must be specified on the command line, e.g. <code>-heap 1024M</code>.
Note that to run this with ALGOL 68G under Windows (and probably Linux) a large heap size must be specified on the command line, e.g. <code>-heap 1024M</code>.
<lang algol68>BEGIN # find some Quad power prime seeds, numbers n such that: #
<syntaxhighlight lang="algol68">BEGIN # find some Quad power prime seeds, numbers n such that: #
# n^p + n + 1 is prime for p = 1, 2, 3, 4 #
PR read "primes.incl.a68" PR # include prime utilities #
Line 64 ⟶ 66:
THEN
# n^1 + n + 1 is prime #
LONG INT np := LENG n * LENG n;
IF is prime( np + n1 ) THEN
# n^2 + n + 1 is prime #
Line 93 ⟶ 95:
FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 113 ⟶ 115:
First element over 9000000: 9055151, index: 645
First element over 10000000: 10023600, index: 701
</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="arturo">quadPowerPrime?: function [n]->
every? [[n+n+1] [1+n+n^2] [1+n+n^3] [1+n+n^4]] 'x ->
prime? do x
 
first50qpps: select.first:50 1..∞ => quadPowerPrime?
 
loop split.every: 10 first50qpps 'x ->
print map x 's -> pad to :string s 7</syntaxhighlight>
 
{{out}}
 
<pre> 1 2 5 6 69 131 426 1665 2129 2696
5250 7929 9689 13545 14154 14286 16434 19760 25739 27809
29631 36821 41819 46619 48321 59030 60500 61955 62321 73610
77685 79646 80535 82655 85251 86996 91014 96566 97739 105939
108240 108681 119754 122436 123164 126489 140636 150480 153179 163070</pre>
 
=={{header|C}}==
{{trans|Wren}}
{{libheader|GMP}}
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdbool.h>
#include <locale.h>
#include <gmp.h>
 
mpz_t p, p2;
 
bool isQuadPowerPrimeSeed(unsigned int n) {
int i;
mpz_set_ui(p, n);
unsigned int k = n + 1;
mpz_add_ui(p2, p, k);
if (!mpz_probab_prime_p(p2, 15)) return false;
for (i = 0; i < 3; ++i) {
mpz_mul_ui(p, p, n);
mpz_set(p2, p);
mpz_add_ui(p2, p2, k);
if (!mpz_probab_prime_p(p2, 15)) return false;
}
return true;
}
 
const char *ord(int c) {
int m = c % 100;
if (m >= 4 && m <= 20) return "th";
m %= 10;
return (m == 1) ? "st" :
(m == 2) ? "nd" :
(m == 3) ? "rd" : "th";
}
 
int main() {
unsigned int n;
int c = 0, m = 1;
mpz_init(p);
mpz_init(p2);
setlocale(LC_NUMERIC, "");
printf("First fifty quad-power prime seeds:\n");
for (n = 1; c < 50; ++n) {
if (isQuadPowerPrimeSeed(n)) {
printf("%'7u ", n);
if (!((++c) % 10)) printf("\n");
}
}
 
printf("\nFirst quad-power prime seed greater than:\n");
while (1) {
if (isQuadPowerPrimeSeed(n)) {
++c;
if (n > 1000000 * m) {
printf(" %2d million is the %d%s: %'10u\n", m, c, ord(c), n);
if (++m == 11) break;
}
}
++n;
}
return 0;
}</syntaxhighlight>
 
{{out}}
<pre>
First fifty quad-power prime seeds:
1 2 5 6 69 131 426 1,665 2,129 2,696
5,250 7,929 9,689 13,545 14,154 14,286 16,434 19,760 25,739 27,809
29,631 36,821 41,819 46,619 48,321 59,030 60,500 61,955 62,321 73,610
77,685 79,646 80,535 82,655 85,251 86,996 91,014 96,566 97,739 105,939
108,240 108,681 119,754 122,436 123,164 126,489 140,636 150,480 153,179 163,070
 
First quad-power prime seed greater than:
1 million is the 141st: 1,009,286
2 million is the 234th: 2,015,496
3 million is the 319th: 3,005,316
4 million is the 383rd: 4,004,726
5 million is the 452nd: 5,023,880
6 million is the 514th: 6,000,554
7 million is the 567th: 7,047,129
8 million is the 601st: 8,005,710
9 million is the 645th: 9,055,151
10 million is the 701st: 10,023,600
</pre>
 
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
// Quad-power prime seeds. Nigel Galloway: August 22nd., 2022
let fG n g=let n=bigint(n:int) in let n=n**g+n+1I in Open.Numeric.Primes.MillerRabin.IsProbablePrime &n
let fN(n,g)=Seq.initInfinite((+)n)|>Seq.filter(fun n->let g=fG n in g 1&&g 2&&g 3&&g 4)|>Seq.mapi(fun n g->(n,g))|>Seq.find(snd>>(<)g)
Seq.initInfinite((+)1)|>Seq.filter(fun n->let g=fG n in g 1&&g 2&&g 3&&g 4)|>Seq.take 50|>Seq.iter(printf "%d "); printfn "\n"
[1000000..1000000..10000000]|>Seq.scan(fun(n,g,x) l->let i,e=fN(g,l) in (n+i,e,l))(0,0,0)|>Seq.skip 1|>Seq.iter(fun(n,g,l)->printfn $"First element over %8d{l} is %9d{g} at index %3d{n}")
</syntaxhighlight>
{{out}}
<pre>
1 2 5 6 69 131 426 1665 2129 2696 5250 7929 9689 13545 14154 14286 16434 19760 25739 27809 29631 36821 41819 46619 48321 59030 60500 61955 62321 73610 77685 79646 80535 82655 85251 86996 91014 96566 97739 105939 108240 108681 119754 122436 123164 126489 140636 150480 153179 163070
 
First element over 1000000 is 1009286 at index 140
First element over 2000000 is 2015496 at index 233
First element over 3000000 is 3005316 at index 318
First element over 4000000 is 4004726 at index 382
First element over 5000000 is 5023880 at index 451
First element over 6000000 is 6000554 at index 513
First element over 7000000 is 7047129 at index 566
First element over 8000000 is 8005710 at index 600
First element over 9000000 is 9055151 at index 644
First element over 10000000 is 10023600 at index 700
</pre>
 
=={{header|Factor}}==
{{works with|Factor|0.99 2022-04-03}}
<langsyntaxhighlight lang="factor">USING: grouping io kernel lists lists.lazy math math.functions
math.primes prettyprint sequences tools.memory.private ;
 
Line 127 ⟶ 256:
 
"First fifty quad-power prime seeds:" print
50 quads ltake list>array 10 group simple-table.</langsyntaxhighlight>
{{out}}
<pre>
Line 137 ⟶ 266:
108,240 108,681 119,754 122,436 123,164 126,489 140,636 150,480 153,179 163,070
</pre>
 
=={{header|FreeBASIC}}==
{{libheader|GMP}}
<syntaxhighlight lang="freebasic">' version 13-04-2023
' compile with: fbc -s console
 
#Include "gmp.bi"
#Define sieve_max 20050000
 
Dim As Mpz_ptr n2 = Allocate (Len(__mpz_struct))
Dim As Mpz_ptr n3 = Allocate (Len(__mpz_struct))
Dim As Mpz_ptr n4 = Allocate (Len(__mpz_struct))
Mpz_init(n2) : Mpz_init(n3) : Mpz_init(n4)
 
Dim As ULongInt i, j
ReDim As boolean sieve(sieve_max)
 
' default value on initialization is FALSE
sieve(2) = TRUE
' set all odd numbers to TRUE
For i = 3 To sieve_max Step 2
sieve(i) = TRUE
Next
For i = 3 To Sqr(sieve_max) Step 2
If sieve(i) = TRUE Then
For j = i * i To sieve_max Step i * 2
sieve(j) = FALSE
Next
End If
Next
 
Dim As ULongInt n, count, k
Dim As LongInt si = 15
 
Print "The first fifty quad-power prime seeds are:"
While count < 50
n += 1
k = n +1
If sieve(n + k) Then ' skip if n + k is not prime
Mpz_ui_pow_ui(n4, n , 4)
Mpz_add_ui(n4, n4, k)
If Mpz_probab_prime_p(n4, si) < 1 Then Continue While ' skip if not prime
Mpz_ui_pow_ui(n3, n, 3)
Mpz_add_ui(n3, n3, k)
If Mpz_probab_prime_p(n3, si) < 1 Then Continue While ' skip if not prime
Mpz_ui_pow_ui(n2, n, 2)
Mpz_add_ui(n2, n2, k)
If Mpz_probab_prime_p(n2, si) >= 1 Then ' if prime then print n
Print Using "########"; n;
count += 1
If (count Mod 10) = 0 Then Print
End If
End If
Wend
 
Dim As ULongInt m = 1, million = 1000000
 
Print !"\n\nFirst quad-power prime seed greater than:"
While m < 11
n += 1
k = n +1
If sieve(n + k) Then ' skip if n + k is not prime
Mpz_ui_pow_ui(n4, n , 4)
Mpz_add_ui(n4, n4, k)
If Mpz_probab_prime_p(n4, si) < 1 Then Continue While ' skip if not prime
Mpz_ui_pow_ui(n3, n, 3)
Mpz_add_ui(n3, n3, k)
If Mpz_probab_prime_p(n3, si) < 1 Then Continue While ' skip if not prime
Mpz_ui_pow_ui(n2, n, 2)
Mpz_add_ui(n2, n2, k)
If Mpz_probab_prime_p(n2, si) >= 1 Then
count += 1
If n > million Then
Print Using " ## million is #########, at index ### "; m; n; count
m += 1
million = m * 1000000
End If
End If
End If
Wend
 
Mpz_clear(n4) : Mpz_clear(n3) : Mpz_clear(n2)
 
 
' empty keyboard buffer
While InKey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End</syntaxhighlight>
{{out}}
<pre>The first fifty quad-power prime seeds are:
1 2 5 6 69 131 426 1665 2129 2696
5250 7929 9689 13545 14154 14286 16434 19760 25739 27809
29631 36821 41819 46619 48321 59030 60500 61955 62321 73610
77685 79646 80535 82655 85251 86996 91014 96566 97739 105939
108240 108681 119754 122436 123164 126489 140636 150480 153179 163070
 
 
First quad-power prime seed greater than:
1 million is 1,009,286 at index 141
2 million is 2,015,496 at index 234
3 million is 3,005,316 at index 319
4 million is 4,004,726 at index 383
5 million is 5,023,880 at index 452
6 million is 6,000,554 at index 514
7 million is 7,047,129 at index 567
8 million is 8,005,710 at index 601
9 million is 9,055,151 at index 645
10 million is 10,023,600 at index 701</pre>
 
=={{header|Go}}==
{{trans|Wren}}
{{libheader|GMP(Go wrapper)}}
{{libheader|Go-rcu}}
<syntaxhighlight lang="go">package main
 
import (
"fmt"
big "github.com/ncw/gmp"
"rcu"
)
 
var p, p2 *big.Int
 
func isQuadPowerPrimeSeed(n uint64) bool {
nn := new(big.Int).SetUint64(n)
p.Set(nn)
k := new(big.Int).SetUint64(n + 1)
p2.Add(p, k)
if !p2.ProbablyPrime(15) {
return false
}
for i := 0; i < 3; i++ {
p.Mul(p, nn)
p2.Set(p)
p2.Add(p2, k)
if !p2.ProbablyPrime(15) {
return false
}
}
return true
}
 
func ord(c int) string {
m := c % 100
if m > 4 && m <= 20 {
return "th"
}
m %= 10
switch m {
case 1:
return "st"
case 2:
return "nd"
case 3:
return "rd"
default:
return "th"
}
}
 
func main() {
p = new(big.Int)
p2 = new(big.Int)
c := 0
m := 1
n := uint64(1)
fmt.Println("First fifty quad-power prime seeds:")
for ; c < 50; n++ {
if isQuadPowerPrimeSeed(n) {
fmt.Printf("%7s ", rcu.Commatize(int(n)))
c++
if c%10 == 0 {
fmt.Println()
}
}
}
 
fmt.Println("\nFirst quad-power prime seed greater than:")
for {
if isQuadPowerPrimeSeed(n) {
c++
if n > 1000000*uint64(m) {
ns := rcu.Commatize(int(n))
fmt.Printf(" %2d million is the %d%s: %10s\n", m, c, ord(c), ns)
m++
if m == 11 {
break
}
}
}
n++
}
}</syntaxhighlight>
 
{{out}}
<pre>
First fifty quad-power prime seeds:
1 2 5 6 69 131 426 1,665 2,129 2,696
5,250 7,929 9,689 13,545 14,154 14,286 16,434 19,760 25,739 27,809
29,631 36,821 41,819 46,619 48,321 59,030 60,500 61,955 62,321 73,610
77,685 79,646 80,535 82,655 85,251 86,996 91,014 96,566 97,739 105,939
108,240 108,681 119,754 122,436 123,164 126,489 140,636 150,480 153,179 163,070
 
First quad-power prime seed greater than:
1 million is the 141st: 1,009,286
2 million is the 234th: 2,015,496
3 million is the 319th: 3,005,316
4 million is the 383rd: 4,004,726
5 million is the 452nd: 5,023,880
6 million is the 514th: 6,000,554
7 million is the 567th: 7,047,129
8 million is the 601st: 8,005,710
9 million is the 645th: 9,055,151
10 million is the 701st: 10,023,600
</pre>
 
=={{header|J}}==
<syntaxhighlight lang="j"> quadpower =. (5 = (] >:)^:((5 > ]) *. 1 p: 1 + [ + ^)^:_"0) & 1x
_10 ]\ I. quadpower i. 170000
1 2 5 6 69 131 426 1665 2129 2696
5250 7929 9689 13545 14154 14286 16434 19760 25739 27809
29631 36821 41819 46619 48321 59030 60500 61955 62321 73610
77685 79646 80535 82655 85251 86996 91014 96566 97739 105939
108240 108681 119754 122436 123164 126489 140636 150480 153179 163070</syntaxhighlight>
 
=={{header|Java}}==
<syntaxhighlight lang="java">
import java.math.BigInteger;
 
public final class QuadPowerPrimeSeeds {
 
public static void main(String[] args) {
System.out.println("The first 50 quad-power prime seeds:");
int index = 0;
int number = 1;
while ( index < 50 ) {
if ( isQuadPowerPrimeSeed(number) ) {
index += 1;
System.out.print(String.format("%7d%s", number, ( index % 10 == 0 ? "\n" : " " )));
}
number += 1;
}
System.out.println();
System.out.println("The first quad-power prime seed greater than:");
int multiple = 1;
while ( multiple <= 3 ) {
if ( isQuadPowerPrimeSeed(number) ) {
index += 1;
if ( number > multiple * 1_000_000 ) {
System.out.println(" " + multiple + " million is " + number + " at index " + index);
multiple += 1;
}
}
number += 1;
}
}
private static boolean isQuadPowerPrimeSeed(long number) {
BigInteger p = BigInteger.valueOf(number);
BigInteger nPlus1 = BigInteger.valueOf(number + 1);
for ( int i = 1; i <= 4; i++ ) {
if ( ! p.add(nPlus1).isProbablePrime(15) ) {
return false;
}
p = p.multiply(BigInteger.valueOf(number));
}
return true;
}
 
}
</syntaxhighlight>
{{ out }}
<pre>
The first 50 quad-power prime seeds:
1 2 5 6 69 131 426 1665 2129 2696
5250 7929 9689 13545 14154 14286 16434 19760 25739 27809
29631 36821 41819 46619 48321 59030 60500 61955 62321 73610
77685 79646 80535 82655 85251 86996 91014 96566 97739 105939
108240 108681 119754 122436 123164 126489 140636 150480 153179 163070
 
The first quad-power prime seed greater than:
1 million is 1009286 at index 141
2 million is 2015496 at index 234
3 million is 3005316 at index 319
</pre>
 
=={{header|Julia}}==
{{trans|Python}}
<syntaxhighlight lang="julia">using Primes, Formatting
 
isquadpowerprime(x) = all(isprime, [2x + 1, x^2 + x + 1, x^3 + x + 1, x^4 + x + 1])
 
const qpprimes = filter(isquadpowerprime, Int128(1):10_100_000)
 
foreach(n -> print(lpad(qpprimes[n], 9), n % 10 == 0 ? "\n" : ""), 1:50)
 
for j in 1_000_000:1_000_000:10_000_000
for p in qpprimes
if p > j
println("The first quad-power prime seed over ", format(j, commas = true),
" is ", format(p, commas = true))
break
end
end
end
 
</syntaxhighlight>{{out}}
<pre>
1 2 5 6 69 131 426 1665 2129 2696
5250 7929 9689 13545 14154 14286 16434 19760 25739 27809
29631 36821 41819 46619 48321 59030 60500 61955 62321 73610
77685 79646 80535 82655 85251 86996 91014 96566 97739 105939
108240 108681 119754 122436 123164 126489 140636 150480 153179 163070
The first quad-power prime seed over 1,000,000 is 1,009,286
The first quad-power prime seed over 2,000,000 is 2,015,496
The first quad-power prime seed over 3,000,000 is 3,005,316
The first quad-power prime seed over 4,000,000 is 4,004,726
The first quad-power prime seed over 5,000,000 is 5,023,880
The first quad-power prime seed over 6,000,000 is 6,000,554
The first quad-power prime seed over 7,000,000 is 7,047,129
The first quad-power prime seed over 8,000,000 is 8,005,710
The first quad-power prime seed over 9,000,000 is 9,055,151
The first quad-power prime seed over 10,000,000 is 10,023,600
</pre>
 
=={{header|Nim}}==
{{libheader|Nim-Integers}}
<syntaxhighlight lang="Nim">import std/[strformat, strutils]
import integers
 
func isQuadPowerPrimeSeeds(n: Integer): bool =
var p = newInteger(n)
var n1 = n + 1
for _ in 1..4:
if not isPrime(p + n1): return false
p *= n
result = true
 
const N = 1_000_000
 
echo "First 30 quad-power prime seeds:"
var count = 0
var n = 1
var limit = N
while true:
if n.isQuadPowerPrimeSeeds():
inc count
if count <= 50:
stdout.write &"{n:7}"
stdout.write if count mod 10 == 0: '\n' else: ' '
if count == 50: echo()
elif n > limit:
echo &"First quad-power prime seed greater than {insertSep($limit)} " &
&"is {insertSep($n)} at position {count}."
inc limit, N
if limit > 3 * N: break
inc n
</syntaxhighlight>
 
{{out}}
<pre>First 30 quad-power prime seeds:
1 2 5 6 69 131 426 1665 2129 2696
5250 7929 9689 13545 14154 14286 16434 19760 25739 27809
29631 36821 41819 46619 48321 59030 60500 61955 62321 73610
77685 79646 80535 82655 85251 86996 91014 96566 97739 105939
108240 108681 119754 122436 123164 126489 140636 150480 153179 163070
 
First quad-power prime seed greater than 1_000_000 is 1_009_286 at position 141.
First quad-power prime seed greater than 2_000_000 is 2_015_496 at position 234.
First quad-power prime seed greater than 3_000_000 is 3_005_316 at position 319.
</pre>
 
=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl" line>use v5.36;
use bigint;
use ntheory 'is_prime';
use List::Util 'max';
 
sub comma { reverse ((reverse shift) =~ s/(.{3})/$1,/gr) =~ s/^,//r }
sub table ($c, @V) { my $t = $c * (my $w = 2 + max map { length } @V); ( sprintf( ('%'.$w.'s')x@V, @V) ) =~ s/.{1,$t}\K/\n/gr }
 
my($n,@qpps);
while (@qpps < 50) {
my $k = 1 + ++$n;
push @qpps, comma $n if
is_prime($n + $k) and
is_prime($n**2 + $k) and
is_prime($n**3 + $k) and
is_prime($n**4 + $k);
}
 
say 'First fifty quad-power prime seeds:';
say table(10,@qpps);</syntaxhighlight>
{{out}}
<pre>First fifty quad-power prime seeds:
1 2 5 6 69 131 426 1,665 2,129 2,696
5,250 7,929 9,689 13,545 14,154 14,286 16,434 19,760 25,739 27,809
29,631 36,821 41,819 46,619 48,321 59,030 60,500 61,955 62,321 73,610
77,685 79,646 80,535 82,655 85,251 86,996 91,014 96,566 97,739 105,939
108,240 108,681 119,754 122,436 123,164 126,489 140,636 150,480 153,179 163,070</pre>
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
Line 175 ⟶ 708:
<span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 197 ⟶ 730:
ten million is 10,023,600 (the seven hundred and first)
</pre>
 
=={{header|Python}}==
<syntaxhighlight lang="python">""" quad-power prime root numbers """
 
from sympy import isprime
 
 
def isquadpowerprime(cand):
""" return if is a quad power prime root number """
return all(isprime(i) for i in
[cand + cand + 1, cand**2 + cand + 1, cand**3 + cand + 1, cand**4 + cand + 1])
 
 
qpprimes = [k for k in range(10_100_000) if isquadpowerprime(k)]
 
for i in range(50):
print(f'{qpprimes[i]: 9,}', end='\n' if (i + 1) % 10 == 0 else '')
 
 
for j in range(1_000_000, 10_000_001, 1_000_000):
for p in qpprimes:
if p > j:
print(f'The first quad-power prime seed over {j:,} is {p:,}')
break
</syntaxhighlight>{{out}}
<pre>
1 2 5 6 69 131 426 1,665 2,129 2,696
5,250 7,929 9,689 13,545 14,154 14,286 16,434 19,760 25,739 27,809
29,631 36,821 41,819 46,619 48,321 59,030 60,500 61,955 62,321 73,610
77,685 79,646 80,535 82,655 85,251 86,996 91,014 96,566 97,739 105,939
108,240 108,681 119,754 122,436 123,164 126,489 140,636 150,480 153,179 163,070
The first quad-power prime seed over 1,000,000 is 1,009,286
The first quad-power prime seed over 2,000,000 is 2,015,496
The first quad-power prime seed over 3,000,000 is 3,005,316
The first quad-power prime seed over 4,000,000 is 4,004,726
The first quad-power prime seed over 5,000,000 is 5,023,880
The first quad-power prime seed over 6,000,000 is 6,000,554
The first quad-power prime seed over 7,000,000 is 7,047,129
The first quad-power prime seed over 8,000,000 is 8,005,710
The first quad-power prime seed over 9,000,000 is 9,055,151
The first quad-power prime seed over 10,000,000 is 10,023,600
</pre>
 
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>use Lingua::EN::Numbers;
 
my @qpps = lazy (1..*).hyper(:2000batch5000batch).grep: -> \n { my \k = n + 1; (n+k).is-prime && (n²+k).is-prime && (n³+k).is-prime && (n⁴+k).is-prime }
 
say "First fifty quad-power prime seeds:\n" ~ @qpps[^50].batch(10)».&comma».fmt("%7s").join: "\n";
Line 207 ⟶ 783:
say "\nFirst quad-power prime seed greater than:";
 
for 1..510 {
my $threshold = Int(1e6 *× $_);
my $key = @qpps.first: * > $threshold, :k;
say "{$threshold.&cardinal.fmt: '%13s'} is the {ordinal-digit $key + 1}: {@qpps[$key].&comma}";
}</langsyntaxhighlight>
{{out}}
<pre>First fifty quad-power prime seeds:
Line 225 ⟶ 801:
three million is the 319th: 3,005,316
four million is the 383rd: 4,004,726
five million is the 452nd: 5,023,880</pre>
six million is the 514th: 6,000,554
seven million is the 567th: 7,047,129
eight million is the 601st: 8,005,710
nine million is the 645th: 9,055,151
ten million is the 701st: 10,023,600</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
« { } 1
'''WHILE''' OVER SIZE 50 < '''REPEAT'''
1 SF
1 4 '''FOR''' j
DUP j ^ OVER + 1 +
'''IF''' ISPRIME? NOT '''THEN''' 1 CF 4 'j' STO '''END'''
'''NEXT'''
'''IF''' 1 FS? '''THEN''' SWAP OVER + SWAP '''END '''
1 +
'''END'''
» '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: {1 2 5 6 69 131 426 1665 2129 2696 5250 7929 9689 13545 14154 14286 16434 19760 25739 27809 29631 36821 41819 46619 48321 59030 60500 61955 62321 73610 77685 79646 80535 82655 85251 86996 91014 96566 97739 105939 108240 108681 119754 122436 123164 126489 140636 150480 153179 163070}
</pre>
Runs in around 8 minutes on an IOS-based emulator.
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'openssl'
 
quad_pow_primes = (1..).lazy.select{|n| (1..4).all?{|exp| OpenSSL::BN.new(n**exp + n + 1).prime?} }
 
n = 50
puts "The first #{n} quad-power prime seeds:"
quad_pow_primes.take(n).each_slice(10){|s| puts "%8s"*s.size % s}</syntaxhighlight>
{{out}}
<pre>The first 50 quad-power prime seeds:
1 2 5 6 69 131 426 1665 2129 2696
5250 7929 9689 13545 14154 14286 16434 19760 25739 27809
29631 36821 41819 46619 48321 59030 60500 61955 62321 73610
77685 79646 80535 82655 85251 86996 91014 96566 97739 105939
108240 108681 119754 122436 123164 126489 140636 150480 153179 163070
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var qpps = (1..Inf -> by(2).lazy.grep { .is_prime }.map {|n| (n-1)>>1 }.grep {|n|
is_prime(n**2 + n + 1) && all_prime(n**3 + n + 1, n**4 + n + 1)
})
 
with (50) {|n|
say "First #{n} quad-power prime seeds:"
qpps.first(n).each_slice(10, {|*s| say s.map{ '%6s' % _ }.join(' ') })
}</syntaxhighlight>
{{out}}
<pre>
First 50 quad-power prime seeds:
1 2 5 6 69 131 426 1665 2129 2696
5250 7929 9689 13545 14154 14286 16434 19760 25739 27809
29631 36821 41819 46619 48321 59030 60500 61955 62321 73610
77685 79646 80535 82655 85251 86996 91014 96566 97739 105939
108240 108681 119754 122436 123164 126489 140636 150480 153179 163070
</pre>
 
=={{header|Wren}}==
Line 231 ⟶ 867:
{{libheader|Wren-fmt}}
GMP allows us to stretch a little more.
<langsyntaxhighlight ecmascriptlang="wren">import "./gmp" for Mpz
import "./fmt" for Fmt
 
Line 267 ⟶ 903:
}
n = n + 1
}</langsyntaxhighlight>
 
{{out}}
Trizen
2,747

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/322205...355768"