Cuban primes: Difference between revisions

{{task|Prime Numbers}}

 

fact that cubes   (3^rd powers)   play a role in its definition.

 

::*   show the first   200   cuban primes   (in a multi─line horizontal format).

::*   show the   100,000^th   cuban prime.

::*   show all output here.

 

 

 

 

;Also see:

<br><br>

 

=={{header|ALGOL 68}}==

# find some cuban primes (using the definition: a prime p is a cuban prime if #

# p = n^3 - ( n - 1 )^3 #

# for some n > 0) #

# returns a string representation of n with commas #

PROC commatise = ( LONG INT n )STRING:

END # commatise # ;

 

INT sieve max = 2 000 000;

 

# find the cuban primes #

INT max cuban = 100 000; # mximum number of cubans to find #

INT print limit = 200; # show all cubans up to this one #

LONG INT prev cube := 1;

FOR n FROM 2 WHILE

IF ODD p THEN

# 2 is not a cuban prime so we only test odd numbers #

# have a cuban prime #

# must show this cuban #

STRING p formatted = commatise( p );

IF cuban count MOD 10 /= 0 THEN print( ( newline ) ) FI;

print( ( "The ", commatise( max cuban ), " cuban prime is: ", commatise( final cuban ), newline ) )

{{out}}

<pre>

7 19 37 61 127 271 331 397 547 631

919 1,657 1,801 1,951 2,269 2,437 2,791 3,169 3,571 4,219

</pre>

 

 

 

 

 

{{out}}

<pre>The first 200 cuban primes:

Progress to the 100,000th cuban prime: ..................................................

The 100,000th cuban prime is 1,792,617,147,127

 

{{trans|Visual Basic .NET}}

(of the Snail Version)

using System.Collections.Generic;

using System.Linq;

if (System.Diagnostics.Debugger.IsAttached) Console.ReadKey();

}

{{out}}

<pre>The first 200 cuban primes:

The 100,000th cuban prime is 1,792,617,147,127

Computation time was 63.578673 seconds</pre>

 

=={{header|Factor}}==

{{trans|Sidef}}

math.primes sequences tools.memory.private ;

IN: rosetta-code.cuban-primes

 

1e5 cuban-primes last commas "100,000th cuban prime is: %s\n"

{{out}}

<pre>

 

100,000th cuban prime is: 1,792,617,147,127

</pre>

 

=={{header|Go}}==

 

import (

}

fmt.Println("\nThe 100,000th cuban prime is", commatize(cube100k))

 

{{out}}

</pre>

 

 

=={{header|J}}==

I've used assertions to demonstrate and to prove the defined verbs

 

isPrime =: 1&p:

[: (#~ 1&p:) (-&(^&3)~ >:)

 

=={{header|Julia}}==

 

{{trans|Go}}

 

function cubanprimes(N)

j = BigInt(i + 1)

cube2 = j^3

diff = cube2 - cube1

if isprime(diff)

if count == 100000

cube100k = diff

println("The first $N cuban primes are: ")

foreach(x -> print(lpad(cubans[x] == 0 ? "" : cubans[x], 10), x % 8 == 0 ? "\n" : ""), 1:N)

end

 

cubanprimes(200)

<pre>

The first 200 cuban primes are:

The 100,000th cuban prime is 1,792,617,147,127

</pre>

 

=={{header|Pascal}}==

100: 283,669; 1000: 65,524,807; 10000: 11,712,188,419; 100000: 1,792,617,147,127

 

{$IFDEF FPC}

{$MODE DELPHI}

OutFirstCntCubPrimes(200,10);

OutNthCubPrime(100000);

{{out}}

<pre> 7 19 37 61 127 271 331 397 547 631

=={{header|Perl}}==

{{libheader|ntheory}}

use ntheory 'is_prime';

 

for my $n (1 .. 6) {

say "10^$n-th cuban prime is: ", commify((cuban_primes(10**$n))[-1]);

{{out}}

<pre>

</pre>

 

{{out}}

919 1,657 1,801 1,951 2,269 2,437 2,791 3,169 3,571 4,219

4,447 5,167 5,419 6,211 7,057 7,351 8,269 9,241 10,267 11,719

1,372,957 1,409,731 1,422,097 1,426,231 1,442,827 1,451,161 1,480,519 1,484,737 1,527,247 1,570,357

 

 

 

{{trans|C#}}

import datetime

import math

st = datetime.datetime.now()

 

found = False

u += 6

v += u

for item in primes:

print ("The {:,}th{} is {:,}".format(c, tn, v))

print("Computation time was {} seconds".format((datetime.datetime.now() - st).seconds))

 

{{out}}

Progress to the 100,000th cuban prime:..................................................

 

=={{header|REXX}}==

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

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

end /*j*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default input of: &nbsp; &nbsp; <tt> 200 </tt>}}

</pre>

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> -100000 </tt>}}

1,792,617,147,127

</pre>

 

=={{header|Sidef}}==

1..Inf -> lazy.map {|k| 3*k*(k+1) + 1 }\

.grep{ .is_prime }\

}

 

{{out}}

<pre>

100,000th cuban prime is: 1,792,617,147,127

</pre>

 

 

7 19 37 61 127 271 331 397 547 631

919 1,657 1,801 1,951 2,269 2,437 2,791 3,169 3,571 4,219

1,125,469 1,155,061 1,177,507 1,181,269 1,215,397 1,253,887 1,281,187 1,285,111 1,324,681 1,328,671

1,372,957 1,409,731 1,422,097 1,426,231 1,442,827 1,451,161 1,480,519 1,484,737 1,527,247 1,570,357

The 100,000th cuban prime is 1,792,617,147,127

 

{{out}}

 

The 100,000th cuban prime is 1,792,617,147,127

 

=={{header|zkl}}==

 

[[Extensible prime generator#zkl]] could be used instead.

cubans:=(1).walker(*).tweak('wrap(n){ // lazy iterator

p:=3*n*(n + 1) + 1;

 

cubans.drop(100_000 - cubans.n).value :

{{out}}

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

</pre>

Now lets get big.

println("First %d cuban primes where k = %,d:".fmt(z,k));

foreach n in ([BI(1)..]){

if(p.probablyPrime()){ println("%,d".fmt(p)); z-=1; }

if(z<=0) break;

{{out}}

<pre>