Pierpont primes: Difference between revisions

 

<br>

 

=={{header|C}}==

{{trans|D}}

#include <stdint.h>

#include <stdio.h>

}

printf("\n");

{{out}}

<pre>First 50 Pierpont primes of the first kind:

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Numerics;

}

}

{{out}}

<pre>First 50 Pierpont primes of the first kind:

=={{header|C++}}==

{{libheader|GMP}}

#include <algorithm>

#include <iomanip>

std::cout << "250th Pierpont prime of the second kind: " << p2 << '\n';

return 0;

 

{{out}}

=={{header|D}}==

{{trans|C#}}

import std.bigint;

import std.random;

writefln("%dth Pierpont prime of the first kind: %d", p[0].length, p[0][$ - 1]);

writefln("%dth Pierpont prime of the second kind: %d", p[1].length, p[1][$ - 1]);

{{out}}

<pre>First 50 Pierpont primes of the first kind:

{{Trans|Go}}

Thanks Rudy Velthuis for the [https://github.com/rvelthuis/DelphiBigNumbers Velthuis.BigIntegers.Primes and Velthuis.BigIntegers] library.<br>

program Pierpont_primes;

 

 

readln;

=={{header|Factor}}==

math.primes prettyprint sequences sorting ;

 

"250th Pierpont prime of the second kind: " write

249 second nth .

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

 

 

 

 

np(1) += 1

np(2) += 1

 

 

=={{header|Go}}==

 

However, in order to be sure that the first 250 Pierpont primes will be generated, it is necessary to choose the loop sizes to produce somewhat more than this and then sort them into order.

 

import (

fmt.Println("\n250th Pierpont prime of the first kind:", pp[249])

fmt.Println("\n250th Pierpont prime of the second kind:", pp2[249])

 

{{out}}

These timings are for my Celeron @1.6GHz and should therefore be much faster on a more modern machine.

 

 

import (

elapsed := time.Now().Sub(start)

fmt.Printf("\nTook %s\n", elapsed)

 

{{out}}

Uses arithmoi Library: https://hackage.haskell.org/package/arithmoi-0.11.0.0 for prime generation and prime testing.<br>

n-smooth generation function based on [[Hamming_numbers#Avoiding_generation_of_duplicates]]

import Data.List (intercalate)

import Data.List.Split (chunksOf)

where

rows = chunksOf 10 . take 50

{{out}}

<pre>

./pierpoints 0.04s user 0.01s system 20% cpu 0.215 total

</pre>

 

=={{header|Java}}==

import java.math.BigInteger;

import java.text.NumberFormat;

}

 

{{out}}

 

250th Pierpont prime of the second kind: 4,111,131,172,000,956,525,894,875,083,702,271

</pre>

 

=={{header|Julia}}==

The generator method is very fast but does not guarantee the primes are generated in order. Therefore we generate two times the primes needed and then sort and return the lower half.

 

function pierponts(N, firstkind = true)

 

println("\nThe 2000th Pierpont prime (second kind) is: ", pierponts(2000, false)[2000])

<pre>

The first 50 Pierpont primes (first kind) are: BigInt[2, 3, 5, 7, 13, 17, 19, 37, 73, 97, 109, 163, 193, 257, 433, 487, 577, 769, 1153, 1297, 1459, 2593, 2917, 3457, 3889, 10369, 12289, 17497, 18433, 39367, 52489, 65537, 139969, 147457, 209953, 331777, 472393, 629857, 746497, 786433, 839809, 995329, 1179649, 1492993, 1769473, 1990657, 2654209, 5038849, 5308417, 8503057]

=={{header|Kotlin}}==

{{trans|Go}}

import kotlin.math.min

 

println("\n2000th Pierpont prime of the first kind: ${p[0][1999]}")

println("\n2000th Pierpont prime of the first kind: ${p[1][1999]}")

{{out}}

<pre>First 50 Pierpont primes of the first kind:

 

=={{header|Lua}}==

if n < 2 then return false end

if n % 2 == 0 then return n==2 end

for i, p in ipairs(p2) do

io.write(string.format("%8d%s", p, (i%10==0 and "\n" or " ")))

{{out}}

<pre>First 50 Pierpont primes of the first kind:

62207 73727 131071 139967 165887 294911 314927 442367 472391 497663

524287 786431 995327 1062881 2519423 10616831 17915903 18874367 25509167 30233087</pre>

 

=={{header|Nim}}==

 

func isPrime(n: int): bool =

stdout.write ($n).align(9)

inc count

 

{{out}}

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use feature 'say';

 

say "\n250th Pierpont prime of the first kind: " . $pierpont_1st[249];

{{out}}

<pre>First 50 Pierpont primes of the first kind:

{{trans|Go}}

I also tried using a priority queue, popping the smallest (and any duplicates of it) and pushing *2 and *3 on every iteration, which worked pretty well but ended up about 20% slower, with about 1500 untested candidates left in the queue by the time it found the 2000th second kind.

{{out}}

<pre>

Took 2 minutes and 01s

</pre>

 

=={{header|Prolog}}==

?- use_module(library(heaps)).

 

 

?- main.

{{Out}}

<pre>

=={{header|Python}}==

{{trans|Go}}

 

# Copied from https://rosettacode.org/wiki/Miller-Rabin_primality_test#Python

print "250th Pierpont prime of the second kind:", pp2[249]

 

{{out}}

<pre>First 50 Pierpont primes of the first kind:

250th Pierpont prime of the first kind: 62518864539857068333550694039553

250th Pierpont prime of the second kind: 4111131172000956525894875083702271</pre>

 

=={{header|Raku}}==

an overabundance. No need to rely on magic numbers. No need to sort them. It

produces exactly what is needed, in order, on demand.

 

sub pierpont ($kind is copy = 1) {

say "\n250th Pierpont prime of the first kind: " ~ pierpont[249];

 

 

{{out}}

(Cut down output as it is exactly the same as the first version for {2,3} +1 and {2,3} -1; leaves room to demo some other options.)

 

cache my \Smooth := gather {

my %i = (flat @list) Z=> (Smooth.iterator for ^@list);

"\nOEIS: A077314:", (2,7), -1, 20,

"\nOEIS: A174144 - (\"Humble\" primes 1st):", (2,3,5,7), 1, 20,

"\nOEIS: A077499:", (2,11), 1, 20,

"\nOEIS: A077315:", (2,11), -1, 20,

say "$title smooth \{$primes\} {$add > 0 ?? '+' !! '-'} 1 ";

put smooth-numbers(|$primes).map( * + $add ).grep( *.is-prime )[^$count]

 

{{Out}}

The REXX language has a "big num" capability to handle almost any amount of decimal digits, &nbsp; but

<br>it lacks a robust &nbsp; '''isPrime''' &nbsp; function. &nbsp; Without that, verifying very large primes is problematic.

parse arg n . /*obtain optional argument from the CL.*/

if n=='' | n=="," then n= 50 /*Not specified? Then use the default.*/

_= pu*pv + t; if _ >s then m= min(_, m)

end /*jv*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

 

see "done2..." + nl

Output:

<pre>

</pre>

 

=={{header|Sidef}}==

var s = primes.len.of { [1] }

{

say "\n#{n}th Pierpont prime of the 1st kind: #{p}"

say "#{n}th Pierpont prime of the 2nd kind: #{q}"

{{out}}

<pre>

1000th Pierpont prime of the 2nd kind: 1308088756227965581249669045506775407896673213729433892383353027814827286537163695213418982500477392209371001259166465228280492460735463423

</pre>

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-big}}

{{libheader|Wren-fmt}}

The 3-smooth version. Just the first 250 - a tolerable 14 seconds or so on my machine.

 

var pierpont = Fn.new { |n, first|

count2 = count2 + 1

}

}

}

}

 

var p = pierpont.call(250, true)

System.print("First 50 Pierpont primes of the first kind:")

 

System.print("\n250th Pierpont prime of the first kind: %(p[0][249])")

 

{{out}}

 

250th Pierpont prime of the second kind: 4111131172000956525894875083702271

</pre>

 

{{libheader|GMP}} GNU Multiple Precision Arithmetic Library

Using GMP's probabilistic primes makes it is easy and fast to test for primeness.

var [const] one=BI(1), two=BI(2), three=BI(3);

 

}

return(pps1,pps2)

 

println("The first 50 Pierpont primes (first kind):");

println("\n%4dth Pierpont prime, first kind: ".fmt(n), pps1[n-1]);

println( " second kind: ", pps2[n-1]);

{{out}}

<pre style="font-size:83%">