Cuban primes

From Rosetta Code
Task
Cuban primes
You are encouraged to solve this task according to the task description, using any language you may know.

The name   cuban   has nothing to do with Cuba,   but has to do with the fact that cubes   (3rd powers)   play a role in its definition.


Some definitions of cuban primes
  •   primes which are the difference of two consecutive cubes.
  •   primes of the form:   (n+1)3 - n3.
  •   primes of the form:   n3 - (n-1)3.
  •   primes   p   such that   n2(p+n)   is a cube for some   n>0.
  •   primes   p   such that   4p = 1 + 3n2.


Cuban primes were named in 1923 by Allan Joseph Champneys Cunningham.


Task requirements
  •   show the first   200   cuban primes   (in a multi─line horizontal format).
  •   show the   100,000th   cuban prime.
  •   show all cuban primes with commas   (if appropriate).
  •   show all output here.


Note that   cuban prime   isn't capitalized   (as it doesn't refer to the nation of Cuba).


Also see
  •   Wikipedia entry:     cuban prime.
  •   MathWorld entry:   cuban prime.
  •   The OEIS entry:     A002407.     The   100,000th   cuban prime can be verified in the   2nd   example   on this OEIS web page.



ALGOL 68[edit]

BEGIN
# 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:
BEGIN
STRING result := "";
STRING unformatted = whole( n, 0 );
INT ch count := 0;
FOR c FROM UPB unformatted BY -1 TO LWB unformatted DO
IF ch count <= 2 THEN ch count +:= 1
ELSE ch count := 1; "," +=: result
FI;
unformatted[ c ] +=: result
OD;
result
END # commatise # ;
 
# sieve the primes #
INT sieve max = 2 000 000;
[ sieve max ]BOOL sieve; FOR i TO UPB sieve DO sieve[ i ] := TRUE OD;
sieve[ 1 ] := FALSE;
FOR s FROM 2 TO ENTIER sqrt( sieve max ) DO
IF sieve[ s ] THEN
FOR p FROM s * s BY s TO sieve max DO sieve[ p ] := FALSE OD
FI
OD;
# count the primes, we can ignore 2, as we know it isn't a cuban prime #
sieve[ 2 ] := FALSE;
INT prime count := 0;
FOR s TO UPB sieve DO IF sieve[ s ] THEN prime count +:= 1 FI OD;
# construct a list of the primes #
[ 1 : prime count ]INT primes;
INT prime pos := LWB primes;
FOR s FROM LWB sieve TO UPB sieve DO
IF sieve[ s ] THEN primes[ prime pos ] := s; prime pos +:= 1 FI
OD;
 
# find the cuban primes #
INT cuban count := 0;
LONG INT final cuban := 0;
INT max cuban = 100 000; # mximum number of cubans to find #
INT print limit = 200; # show all cubans up to this one #
print( ( "First ", commatise( print limit ), " cuban primes: ", newline ) );
LONG INT prev cube := 1;
FOR n FROM 2 WHILE
LONG INT this cube = ( LENG n * n ) * n;
LONG INT p = this cube - prev cube;
prev cube := this cube;
IF ODD p THEN
# 2 is not a cuban prime so we only test odd numbers #
BOOL is prime := TRUE;
INT max factor = SHORTEN ENTIER long sqrt( p );
FOR f FROM LWB primes WHILE is prime AND primes[ f ] <= max factor DO
is prime := p MOD primes[ f ] /= 0
OD;
IF is prime THEN
# have a cuban prime #
cuban count +:= 1;
IF cuban count <= print limit THEN
# must show this cuban #
STRING p formatted = commatise( p );
print( ( " "[ UPB p formatted : ], p formatted ) );
IF cuban count MOD 10 = 0 THEN print( ( newline ) ) FI
FI;
final cuban := p
FI
FI;
cuban count < max cuban
DO SKIP OD;
IF cuban count MOD 10 /= 0 THEN print( ( newline ) ) FI;
print( ( "The ", commatise( max cuban ), " cuban prime is: ", commatise( final cuban ), newline ) )
END
Output:
First 200 cuban primes: 
          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
      4,447      5,167      5,419      6,211      7,057      7,351      8,269      9,241     10,267     11,719
     12,097     13,267     13,669     16,651     19,441     19,927     22,447     23,497     24,571     25,117
     26,227     27,361     33,391     35,317     42,841     45,757     47,251     49,537     50,311     55,897
     59,221     60,919     65,269     70,687     73,477     74,419     75,367     81,181     82,171     87,211
     88,237     89,269     92,401     96,661    102,121    103,231    104,347    110,017    112,327    114,661
    115,837    126,691    129,169    131,671    135,469    140,617    144,541    145,861    151,201    155,269
    163,567    169,219    170,647    176,419    180,811    189,757    200,467    202,021    213,067    231,019
    234,361    241,117    246,247    251,431    260,191    263,737    267,307    276,337    279,991    283,669
    285,517    292,969    296,731    298,621    310,087    329,677    333,667    337,681    347,821    351,919
    360,187    368,551    372,769    374,887    377,011    383,419    387,721    398,581    407,377    423,001
    436,627    452,797    459,817    476,407    478,801    493,291    522,919    527,941    553,411    574,219
    584,767    590,077    592,741    595,411    603,457    608,851    611,557    619,711    627,919    650,071
    658,477    666,937    689,761    692,641    698,419    707,131    733,591    742,519    760,537    769,627
    772,669    784,897    791,047    812,761    825,301    837,937    847,477    863,497    879,667    886,177
    895,987    909,151    915,769    925,741    929,077    932,419    939,121    952,597    972,991    976,411
    986,707    990,151    997,057  1,021,417  1,024,921  1,035,469  1,074,607  1,085,407  1,110,817  1,114,471
  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,000 cuban prime is: 1,792,617,147,127

C[edit]

Translation of: C++
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
 
typedef long long llong_t;
struct PrimeArray {
llong_t *ptr;
size_t size;
size_t capacity;
};
 
struct PrimeArray allocate() {
struct PrimeArray primes;
 
primes.size = 0;
primes.capacity = 10;
primes.ptr = malloc(primes.capacity * sizeof(llong_t));
 
return primes;
}
 
void deallocate(struct PrimeArray *primes) {
free(primes->ptr);
primes->ptr = NULL;
}
 
void push_back(struct PrimeArray *primes, llong_t p) {
if (primes->size >= primes->capacity) {
size_t new_capacity = (3 * primes->capacity) / 2 + 1;
llong_t *temp = realloc(primes->ptr, new_capacity * sizeof(llong_t));
if (NULL == temp) {
fprintf(stderr, "Failed to reallocate the prime array.");
exit(1);
} else {
primes->ptr = temp;
primes->capacity = new_capacity;
}
}
 
primes->ptr[primes->size++] = p;
}
 
int main() {
const int cutOff = 200, bigUn = 100000, chunks = 50, little = bigUn / chunks;
struct PrimeArray primes = allocate();
int c = 0;
bool showEach = true;
llong_t u = 0, v = 1, i;
 
push_back(&primes, 3);
push_back(&primes, 5);
 
printf("The first %d cuban primes:\n", cutOff);
for (i = 1; i < LLONG_MAX; ++i) {
bool found = false;
llong_t mx = ceil(sqrt(v += (u += 6)));
llong_t j;
 
for (j = 0; j < primes.size; ++j) {
if (primes.ptr[j] > mx) {
break;
}
if (v % primes.ptr[j] == 0) {
found = true;
break;
}
}
if (!found) {
c += 1;
if (showEach) {
llong_t z;
for (z = primes.ptr[primes.size - 1] + 2; z <= v - 2; z += 2) {
bool fnd = false;
 
for (j = 0; j < primes.size; ++j) {
if (primes.ptr[j] > mx) {
break;
}
if (z % primes.ptr[j] == 0) {
fnd = true;
break;
}
}
if (!fnd) {
push_back(&primes, z);
}
}
push_back(&primes, v);
printf("%11lld", v);
if (c % 10 == 0) {
printf("\n");
}
if (c == cutOff) {
showEach = false;
printf("\nProgress to the %dth cuban prime: ", bigUn);
}
}
if (c % little == 0) {
printf(".");
if (c == bigUn) {
break;
}
}
}
}
printf("\nThe %dth cuban prime is %lld\n", c, v);
 
deallocate(&primes);
return 0;
}
Output:
The first 200 cuban primes:
          7         19         37         61        127        271        331        397        547        631
        919       1657       1801       1951       2269       2437       2791       3169       3571       4219
       4447       5167       5419       6211       7057       7351       8269       9241      10267      11719
      12097      13267      13669      16651      19441      19927      22447      23497      24571      25117
      26227      27361      33391      35317      42841      45757      47251      49537      50311      55897
      59221      60919      65269      70687      73477      74419      75367      81181      82171      87211
      88237      89269      92401      96661     102121     103231     104347     110017     112327     114661
     115837     126691     129169     131671     135469     140617     144541     145861     151201     155269
     163567     169219     170647     176419     180811     189757     200467     202021     213067     231019
     234361     241117     246247     251431     260191     263737     267307     276337     279991     283669
     285517     292969     296731     298621     310087     329677     333667     337681     347821     351919
     360187     368551     372769     374887     377011     383419     387721     398581     407377     423001
     436627     452797     459817     476407     478801     493291     522919     527941     553411     574219
     584767     590077     592741     595411     603457     608851     611557     619711     627919     650071
     658477     666937     689761     692641     698419     707131     733591     742519     760537     769627
     772669     784897     791047     812761     825301     837937     847477     863497     879667     886177
     895987     909151     915769     925741     929077     932419     939121     952597     972991     976411
     986707     990151     997057    1021417    1024921    1035469    1074607    1085407    1110817    1114471
    1125469    1155061    1177507    1181269    1215397    1253887    1281187    1285111    1324681    1328671
    1372957    1409731    1422097    1426231    1442827    1451161    1480519    1484737    1527247    1570357

Progress to the 100000th cuban prime: ..................................................
The 100000th cuban prime is 1792617147127

using GMP[edit]

So that we can go arbitrarily large, and it's faster to boot.

#include <gmp.h>
#include <stdio.h>
 
typedef unsigned long int uint;
 
int main(void)
{
mpz_t a, b;
mpz_init(a);
mpz_init(b);
 
int found = 0;
int col = 0;
for (uint n = 1; ; n++) {
mpz_ui_pow_ui(a, n, 3);
mpz_ui_pow_ui(b, n + 1, 3);
mpz_sub(a, b, a);
 
if (!mpz_probab_prime_p(a, 5)) continue;
 
if (++found <= 200) {
gmp_printf("%10Zu", a);
if (++col == 8) {
putchar('\n');
col = 0;
}
} else if (found == 100000) {
gmp_printf("100000th: %Zu\n", a);
} else if (found == 1000000) {
gmp_printf("1000000th: %Zu\n", a);
break;
}
}
return 0;
}
 

C++[edit]

Translation of: C#
#include <iostream> 
#include <vector>
#include <chrono>
#include <climits>
#include <cmath>
 
using namespace std;
 
vector <long long> primes{ 3, 5 };
 
int main()
{
cout.imbue(locale(""));
const int cutOff = 200, bigUn = 100000,
chunks = 50, little = bigUn / chunks;
const char tn[] = " cuban prime";
cout << "The first " << cutOff << tn << "s:" << endl;
int c = 0;
bool showEach = true;
long long u = 0, v = 1;
auto st = chrono::system_clock::now();
 
for (long long i = 1; i <= LLONG_MAX; i++)
{
bool found = false;
long long mx = (long long)(ceil(sqrt(v += (u += 6))));
for (long long item : primes)
{
if (item > mx) break;
if (v % item == 0) { found = true; break; }
}
if (!found)
{
c += 1; if (showEach)
{
for (long long z = primes.back() + 2; z <= v - 2; z += 2)
{
bool fnd = false;
for (long long item : primes)
{
if (item > mx) break;
if (z % item == 0) { fnd = true; break; }
}
if (!fnd) primes.push_back(z);
}
primes.push_back(v); cout.width(11); cout << v;
if (c % 10 == 0) cout << endl;
if (c == cutOff)
{
showEach = false;
cout << "\nProgress to the " << bigUn << "th" << tn << ": ";
}
}
if (c % little == 0) { cout << "."; if (c == bigUn) break; }
}
}
cout << "\nThe " << c << "th" << tn << " is " << v;
chrono::duration<double> elapsed_seconds = chrono::system_clock::now() - st;
cout << "\nComputation time was " << elapsed_seconds.count() << " seconds" << endl;
return 0;
}
Output:
The first 200 cuban primes:
          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
      4,447      5,167      5,419      6,211      7,057      7,351      8,269      9,241     10,267     11,719
     12,097     13,267     13,669     16,651     19,441     19,927     22,447     23,497     24,571     25,117
     26,227     27,361     33,391     35,317     42,841     45,757     47,251     49,537     50,311     55,897
     59,221     60,919     65,269     70,687     73,477     74,419     75,367     81,181     82,171     87,211
     88,237     89,269     92,401     96,661    102,121    103,231    104,347    110,017    112,327    114,661
    115,837    126,691    129,169    131,671    135,469    140,617    144,541    145,861    151,201    155,269
    163,567    169,219    170,647    176,419    180,811    189,757    200,467    202,021    213,067    231,019
    234,361    241,117    246,247    251,431    260,191    263,737    267,307    276,337    279,991    283,669
    285,517    292,969    296,731    298,621    310,087    329,677    333,667    337,681    347,821    351,919
    360,187    368,551    372,769    374,887    377,011    383,419    387,721    398,581    407,377    423,001
    436,627    452,797    459,817    476,407    478,801    493,291    522,919    527,941    553,411    574,219
    584,767    590,077    592,741    595,411    603,457    608,851    611,557    619,711    627,919    650,071
    658,477    666,937    689,761    692,641    698,419    707,131    733,591    742,519    760,537    769,627
    772,669    784,897    791,047    812,761    825,301    837,937    847,477    863,497    879,667    886,177
    895,987    909,151    915,769    925,741    929,077    932,419    939,121    952,597    972,991    976,411
    986,707    990,151    997,057  1,021,417  1,024,921  1,035,469  1,074,607  1,085,407  1,110,817  1,114,471
  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

Progress to the 100,000th cuban prime: ..................................................
The 100,000th cuban prime is 1,792,617,147,127
Computation time was 35.5644 seconds

C#[edit]

Translation of: Visual Basic .NET

(of the Snail Version)

using System;
using System.Collections.Generic;
using System.Linq;
 
static class Program
{
static List<long> primes = new List<long>() { 3, 5 };
 
static void Main(string[] args)
{
const int cutOff = 200;
const int bigUn = 100000;
const int chunks = 50;
const int little = bigUn / chunks;
const string tn = " cuban prime";
Console.WriteLine("The first {0:n0}{1}s:", cutOff, tn);
int c = 0;
bool showEach = true;
long u = 0, v = 1;
DateTime st = DateTime.Now;
for (long i = 1; i <= long.MaxValue; i++)
{
bool found = false;
int mx = System.Convert.ToInt32(Math.Ceiling(Math.Sqrt(v += (u += 6))));
foreach (long item in primes)
{
if (item > mx) break;
if (v % item == 0) { found = true; break; }
}
if (!found)
{
c += 1; if (showEach)
{
for (var z = primes.Last() + 2; z <= v - 2; z += 2)
{
bool fnd = false;
foreach (long item in primes)
{
if (item > mx) break;
if (z % item == 0) { fnd = true; break; }
}
if (!fnd) primes.Add(z);
}
primes.Add(v); Console.Write("{0,11:n0}", v);
if (c % 10 == 0) Console.WriteLine();
if (c == cutOff)
{
showEach = false;
Console.Write("\nProgress to the {0:n0}th{1}: ", bigUn, tn);
}
}
if (c % little == 0) { Console.Write("."); if (c == bigUn) break; }
}
}
Console.WriteLine("\nThe {1:n0}th{2} is {0,17:n0}", v, c, tn);
Console.WriteLine("Computation time was {0} seconds", (DateTime.Now - st).TotalSeconds);
if (System.Diagnostics.Debugger.IsAttached) Console.ReadKey();
}
}
Output:
The first 200 cuban primes:
          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
      4,447      5,167      5,419      6,211      7,057      7,351      8,269      9,241     10,267     11,719
     12,097     13,267     13,669     16,651     19,441     19,927     22,447     23,497     24,571     25,117
     26,227     27,361     33,391     35,317     42,841     45,757     47,251     49,537     50,311     55,897
     59,221     60,919     65,269     70,687     73,477     74,419     75,367     81,181     82,171     87,211
     88,237     89,269     92,401     96,661    102,121    103,231    104,347    110,017    112,327    114,661
    115,837    126,691    129,169    131,671    135,469    140,617    144,541    145,861    151,201    155,269
    163,567    169,219    170,647    176,419    180,811    189,757    200,467    202,021    213,067    231,019
    234,361    241,117    246,247    251,431    260,191    263,737    267,307    276,337    279,991    283,669
    285,517    292,969    296,731    298,621    310,087    329,677    333,667    337,681    347,821    351,919
    360,187    368,551    372,769    374,887    377,011    383,419    387,721    398,581    407,377    423,001
    436,627    452,797    459,817    476,407    478,801    493,291    522,919    527,941    553,411    574,219
    584,767    590,077    592,741    595,411    603,457    608,851    611,557    619,711    627,919    650,071
    658,477    666,937    689,761    692,641    698,419    707,131    733,591    742,519    760,537    769,627
    772,669    784,897    791,047    812,761    825,301    837,937    847,477    863,497    879,667    886,177
    895,987    909,151    915,769    925,741    929,077    932,419    939,121    952,597    972,991    976,411
    986,707    990,151    997,057  1,021,417  1,024,921  1,035,469  1,074,607  1,085,407  1,110,817  1,114,471
  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

Progress to the 100,000th cuban prime: ..................................................
The 100,000th cuban prime is 1,792,617,147,127
Computation time was 63.578673 seconds

D[edit]

Translation of: C#
import std.math;
import std.stdio;
 
void main() {
long[] primes = [3, 5];
 
immutable cutOff = 200;
immutable bigUn = 100_000;
immutable chunks = 50;
immutable little = bigUn / chunks;
immutable tn = " cuban prime";
writefln("The first %s%ss:", cutOff, tn);
int c;
bool showEach = true;
long u;
long v = 1;
for (long i = 1; i > 0; ++i) {
bool found;
u += 6;
v += u;
int mx = cast(int)ceil(sqrt(cast(real)v));
foreach (item; primes) {
if (item > mx) break;
if (v % item == 0) {
found = true;
break;
}
}
if (!found) {
c++;
if (showEach) {
for (auto z = primes[$-1] + 2; z <= v - 2; z += 2) {
bool fnd;
foreach (item; primes) {
if (item > mx) break;
if (z % item == 0) {
fnd = true;
break;
}
}
if (!fnd) {
primes ~= z;
}
}
primes ~= v;
writef("%11d", v);
if (c % 10 == 0) writeln;
if (c == cutOff) {
showEach = false;
writef("\nProgress to the %sth%s: ", bigUn, tn);
}
}
if (c % little == 0) {
write('.');
if (c == bigUn) {
break;
}
}
}
}
writefln("\nThe %sth%s is %17s", c, tn, v);
}
Output:
The first 200 cuban primes:
          7         19         37         61        127        271        331        397        547        631
        919       1657       1801       1951       2269       2437       2791       3169       3571       4219
       4447       5167       5419       6211       7057       7351       8269       9241      10267      11719
      12097      13267      13669      16651      19441      19927      22447      23497      24571      25117
      26227      27361      33391      35317      42841      45757      47251      49537      50311      55897
      59221      60919      65269      70687      73477      74419      75367      81181      82171      87211
      88237      89269      92401      96661     102121     103231     104347     110017     112327     114661
     115837     126691     129169     131671     135469     140617     144541     145861     151201     155269
     163567     169219     170647     176419     180811     189757     200467     202021     213067     231019
     234361     241117     246247     251431     260191     263737     267307     276337     279991     283669
     285517     292969     296731     298621     310087     329677     333667     337681     347821     351919
     360187     368551     372769     374887     377011     383419     387721     398581     407377     423001
     436627     452797     459817     476407     478801     493291     522919     527941     553411     574219
     584767     590077     592741     595411     603457     608851     611557     619711     627919     650071
     658477     666937     689761     692641     698419     707131     733591     742519     760537     769627
     772669     784897     791047     812761     825301     837937     847477     863497     879667     886177
     895987     909151     915769     925741     929077     932419     939121     952597     972991     976411
     986707     990151     997057    1021417    1024921    1035469    1074607    1085407    1110817    1114471
    1125469    1155061    1177507    1181269    1215397    1253887    1281187    1285111    1324681    1328671
    1372957    1409731    1422097    1426231    1442827    1451161    1480519    1484737    1527247    1570357

Progress to the 100000th cuban prime: ..................................................
The 100000th cuban prime is     1792617147127

F#[edit]

The functions[edit]

This task uses Extensible Prime Generator (F#)

 
// Generate cuban primes. Nigel Galloway: June 9th., 2019
let cubans=Seq.unfold(fun n->Some(n*n*n,n+1L)) 1L|>Seq.pairwise|>Seq.map(fun(n,g)->g-n)|>Seq.filter(isPrime64)
let cL=let g=System.Globalization.CultureInfo("en-GB") in (fun (n:int64)->n.ToString("N0",g))
 

The Task[edit]

 
cubans|>Seq.take 200|>List.ofSeq|>List.iteri(fun n g->if n%8=7 then printfn "%12s" (cL(g)) else printf "%12s" (cL(g)))
 
Output:
           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       4,447       5,167       5,419       6,211
       7,057       7,351       8,269       9,241      10,267      11,719      12,097      13,267
      13,669      16,651      19,441      19,927      22,447      23,497      24,571      25,117
      26,227      27,361      33,391      35,317      42,841      45,757      47,251      49,537
      50,311      55,897      59,221      60,919      65,269      70,687      73,477      74,419
      75,367      81,181      82,171      87,211      88,237      89,269      92,401      96,661
     102,121     103,231     104,347     110,017     112,327     114,661     115,837     126,691
     129,169     131,671     135,469     140,617     144,541     145,861     151,201     155,269
     163,567     169,219     170,647     176,419     180,811     189,757     200,467     202,021
     213,067     231,019     234,361     241,117     246,247     251,431     260,191     263,737
     267,307     276,337     279,991     283,669     285,517     292,969     296,731     298,621
     310,087     329,677     333,667     337,681     347,821     351,919     360,187     368,551
     372,769     374,887     377,011     383,419     387,721     398,581     407,377     423,001
     436,627     452,797     459,817     476,407     478,801     493,291     522,919     527,941
     553,411     574,219     584,767     590,077     592,741     595,411     603,457     608,851
     611,557     619,711     627,919     650,071     658,477     666,937     689,761     692,641
     698,419     707,131     733,591     742,519     760,537     769,627     772,669     784,897
     791,047     812,761     825,301     837,937     847,477     863,497     879,667     886,177
     895,987     909,151     915,769     925,741     929,077     932,419     939,121     952,597
     972,991     976,411     986,707     990,151     997,057   1,021,417   1,024,921   1,035,469
   1,074,607   1,085,407   1,110,817   1,114,471   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
 
printfn "\n\n%s" (cL(Seq.item 99999 cubans))
 
Output:
1,792,617,147,127

Factor[edit]

Translation of: Sidef
USING: formatting grouping io kernel lists lists.lazy math
math.primes sequences tools.memory.private ;
IN: rosetta-code.cuban-primes
 
: cuban-primes ( n -- seq )
1 lfrom [ [ 3 * ] [ 1 + * ] bi 1 + ] <lazy-map>
[ prime? ] <lazy-filter> ltake list>array ;
 
200 cuban-primes 10 <groups>
[ [ commas ] map [ "%10s" printf ] each nl ] each nl
 
1e5 cuban-primes last commas "100,000th cuban prime is: %s\n"
printf
Output:
         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
     4,447     5,167     5,419     6,211     7,057     7,351     8,269     9,241    10,267    11,719
    12,097    13,267    13,669    16,651    19,441    19,927    22,447    23,497    24,571    25,117
    26,227    27,361    33,391    35,317    42,841    45,757    47,251    49,537    50,311    55,897
    59,221    60,919    65,269    70,687    73,477    74,419    75,367    81,181    82,171    87,211
    88,237    89,269    92,401    96,661   102,121   103,231   104,347   110,017   112,327   114,661
   115,837   126,691   129,169   131,671   135,469   140,617   144,541   145,861   151,201   155,269
   163,567   169,219   170,647   176,419   180,811   189,757   200,467   202,021   213,067   231,019
   234,361   241,117   246,247   251,431   260,191   263,737   267,307   276,337   279,991   283,669
   285,517   292,969   296,731   298,621   310,087   329,677   333,667   337,681   347,821   351,919
   360,187   368,551   372,769   374,887   377,011   383,419   387,721   398,581   407,377   423,001
   436,627   452,797   459,817   476,407   478,801   493,291   522,919   527,941   553,411   574,219
   584,767   590,077   592,741   595,411   603,457   608,851   611,557   619,711   627,919   650,071
   658,477   666,937   689,761   692,641   698,419   707,131   733,591   742,519   760,537   769,627
   772,669   784,897   791,047   812,761   825,301   837,937   847,477   863,497   879,667   886,177
   895,987   909,151   915,769   925,741   929,077   932,419   939,121   952,597   972,991   976,411
   986,707   990,151   997,057 1,021,417 1,024,921 1,035,469 1,074,607 1,085,407 1,110,817 1,114,471
 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

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

Go[edit]

package main
 
import (
"fmt"
"math/big"
)
 
func commatize(n uint64) string {
s := fmt.Sprintf("%d", n)
le := len(s)
for i := le - 3; i >= 1; i -= 3 {
s = s[0:i] + "," + s[i:]
}
return s
}
 
func main() {
var z big.Int
var cube1, cube2, cube100k, diff uint64
cubans := make([]string, 200)
cube1 = 1
count := 0
for i := 1; ; i++ {
j := i + 1
cube2 = uint64(j * j * j)
diff = cube2 - cube1
z.SetUint64(diff)
if z.ProbablyPrime(0) { // 100% accurate for z < 2 ^ 64
if count < 200 {
cubans[count] = commatize(diff)
}
count++
if count == 100000 {
cube100k = diff
break
}
}
cube1 = cube2
}
fmt.Println("The first 200 cuban primes are:-")
for i := 0; i < 20; i++ {
j := i * 10
fmt.Printf("%9s\n", cubans[j : j+10]) // 10 per line say
}
fmt.Println("\nThe 100,000th cuban prime is", commatize(cube100k))
}
Output:
The first 200 cuban primes are:-
[        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]
[    4,447     5,167     5,419     6,211     7,057     7,351     8,269     9,241    10,267    11,719]
[   12,097    13,267    13,669    16,651    19,441    19,927    22,447    23,497    24,571    25,117]
[   26,227    27,361    33,391    35,317    42,841    45,757    47,251    49,537    50,311    55,897]
[   59,221    60,919    65,269    70,687    73,477    74,419    75,367    81,181    82,171    87,211]
[   88,237    89,269    92,401    96,661   102,121   103,231   104,347   110,017   112,327   114,661]
[  115,837   126,691   129,169   131,671   135,469   140,617   144,541   145,861   151,201   155,269]
[  163,567   169,219   170,647   176,419   180,811   189,757   200,467   202,021   213,067   231,019]
[  234,361   241,117   246,247   251,431   260,191   263,737   267,307   276,337   279,991   283,669]
[  285,517   292,969   296,731   298,621   310,087   329,677   333,667   337,681   347,821   351,919]
[  360,187   368,551   372,769   374,887   377,011   383,419   387,721   398,581   407,377   423,001]
[  436,627   452,797   459,817   476,407   478,801   493,291   522,919   527,941   553,411   574,219]
[  584,767   590,077   592,741   595,411   603,457   608,851   611,557   619,711   627,919   650,071]
[  658,477   666,937   689,761   692,641   698,419   707,131   733,591   742,519   760,537   769,627]
[  772,669   784,897   791,047   812,761   825,301   837,937   847,477   863,497   879,667   886,177]
[  895,987   909,151   915,769   925,741   929,077   932,419   939,121   952,597   972,991   976,411]
[  986,707   990,151   997,057 1,021,417 1,024,921 1,035,469 1,074,607 1,085,407 1,110,817 1,114,471]
[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


J[edit]

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

 
 
isPrime =: 1&p:
assert 1 0 -: isPrime 3 9
 
 
NB. difference, but first cube, of incremented y with y
dcc =: -&(^&3)~ >:
assert ((8 9 13^3)-7 8 12^3) -: dcc 7 8 12
 
Filter =: (#~`)(`:6)
assert 2 3 5 7 11 13 -: isPrime Filter i. 16
 
cubanPrime =: [: isPrime Filter dcc
assert 7 19 37 61 127 271 331 397 547 631 919 -: cubanPrime i. 20
 
NB. comatose copies with comma fill
comatose =: (#!.','~ (1 1 1j1 1 1 1j1 1 1 1j1 1 1 1j1 1 1 1j1 1 1 1j1 1 1 1 {.~ [email protected]:#))@:":&>
assert (comatose 1000 1238 12 989832) -: [;._2 ] 0 :0
1,000
1,238
12
989,832
)
 
CP =: cubanPrime i. 800000x
# CP NB. tally, I've stored more than 100000 cuban primes
103278
NB. granted, I used wolframalpha Solve[(n+1)^3-n^3==1792617147127,n]
 
9!:17]2 2 NB. specify bottom right position in box
 
comatose&.> 10 20 $ CP
┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
71937611272713313975476319191,6571,8011,9512,2692,4372,7913,1693,5714,219
├─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
4,4475,1675,4196,2117,0577,3518,2699,24110,26711,71912,09713,26713,66916,65119,44119,92722,44723,49724,57125,117
├─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
26,22727,36133,39135,31742,84145,75747,25149,53750,31155,89759,22160,91965,26970,68773,47774,41975,36781,18182,17187,211
├─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
88,23789,26992,40196,661102,121103,231104,347110,017112,327114,661115,837126,691129,169131,671135,469140,617144,541145,861151,201155,269
├─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
163,567169,219170,647176,419180,811189,757200,467202,021213,067231,019234,361241,117246,247251,431260,191263,737267,307276,337279,991283,669
├─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
285,517292,969296,731298,621310,087329,677333,667337,681347,821351,919360,187368,551372,769374,887377,011383,419387,721398,581407,377423,001
├─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
436,627452,797459,817476,407478,801493,291522,919527,941553,411574,219584,767590,077592,741595,411603,457608,851611,557619,711627,919650,071
├─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
658,477666,937689,761692,641698,419707,131733,591742,519760,537769,627772,669784,897791,047812,761825,301837,937847,477863,497879,667886,177
├─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
895,987909,151915,769925,741929,077932,419939,121952,597972,991976,411986,707990,151997,0571,021,4171,024,9211,035,4691,074,6071,085,4071,110,8171,114,471
├─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
1,125,4691,155,0611,177,5071,181,2691,215,3971,253,8871,281,1871,285,1111,324,6811,328,6711,372,9571,409,7311,422,0971,426,2311,442,8271,451,1611,480,5191,484,7371,527,2471,570,357
└─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘
 
NB. the one hundred thousandth cuban prime
comatose (<: 100000) { CP
1,792,617,147,127
 
 
cubanPrime f. NB. cubanPrime with fixed adverbs
[: (#~ 1&p:) (-&(^&3)~ >:)
 
 

Julia[edit]

Translation of: Go
Works with: Julia version 1.2
using Primes
 
function cubanprimes(N)
cubans = zeros(Int, N)
cube100k, cube1, count = 0, 1, 1
for i in Iterators.countfrom(1)
j = BigInt(i + 1)
cube2 = j^3
diff = cube2 - cube1
if isprime(diff)
count ≤ N && (cubans[count] = diff)
if count == 100000
cube100k = diff
break
end
count += 1
end
cube1 = cube2
end
println("The first $N cuban primes are: ")
foreach(x -> print(lpad(cubans[x] == 0 ? "" : cubans[x], 10), x % 8 == 0 ? "\n" : ""), 1:N)
println("\nThe 100,000th cuban prime is ", cube100k)
end
 
cubanprimes(200)
 
Output:
The first 200 cuban primes are:
         7        19        37        61       127       271       331       397
       547       631       919      1657      1801      1951      2269      2437
      2791      3169      3571      4219      4447      5167      5419      6211
      7057      7351      8269      9241     10267     11719     12097     13267
     13669     16651     19441     19927     22447     23497     24571     25117
     26227     27361     33391     35317     42841     45757     47251     49537
     50311     55897     59221     60919     65269     70687     73477     74419
     75367     81181     82171     87211     88237     89269     92401     96661
    102121    103231    104347    110017    112327    114661    115837    126691
    129169    131671    135469    140617    144541    145861    151201    155269
    163567    169219    170647    176419    180811    189757    200467    202021
    213067    231019    234361    241117    246247    251431    260191    263737
    267307    276337    279991    283669    285517    292969    296731    298621
    310087    329677    333667    337681    347821    351919    360187    368551
    372769    374887    377011    383419    387721    398581    407377    423001
    436627    452797    459817    476407    478801    493291    522919    527941
    553411    574219    584767    590077    592741    595411    603457    608851
    611557    619711    627919    650071    658477    666937    689761    692641
    698419    707131    733591    742519    760537    769627    772669    784897
    791047    812761    825301    837937    847477    863497    879667    886177
    895987    909151    915769    925741    929077    932419    939121    952597
    972991    976411    986707    990151    997057   1021417   1024921   1035469
   1074607   1085407   1110817   1114471   1125469   1155061   1177507   1181269
   1215397   1253887   1281187   1285111   1324681   1328671   1372957   1409731
   1422097   1426231   1442827   1451161   1480519   1484737   1527247   1570357

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

Kotlin[edit]

Translation of: D
import kotlin.math.ceil
import kotlin.math.sqrt
 
fun main() {
val primes = mutableListOf(3L, 5L)
val cutOff = 200
val bigUn = 100_000
val chunks = 50
val little = bigUn / chunks
 
println("The first $cutOff cuban primes:")
var showEach = true
var c = 0
var u = 0L
var v = 1L
var i = 1L
while (i > 0) {
var found = false
u += 6
v += u
val mx = ceil(sqrt(v.toDouble())).toInt()
for (item in primes) {
if (item > mx) break
if (v % item == 0L) {
found = true
break
}
}
if (!found) {
c++
if (showEach) {
var z = primes.last() + 2
while (z <= v - 2) {
var fnd = false
for (item in primes) {
if (item > mx) break
if (z % item == 0L) {
fnd = true
break
}
}
if (!fnd) {
primes.add(z)
}
z += 2
}
primes.add(v)
print("%11d".format(v))
if (c % 10 == 0) println()
if (c == cutOff) {
showEach = false
print("\nProgress to the ${bigUn}th cuban prime: ")
}
}
if (c % little == 0) {
print(".")
if (c == bigUn) break
}
}
i++
}
println("\nThe %dth cuban prime is %17d".format(c, v))
}
Output:
The first 200 cuban primes:
          7         19         37         61        127        271        331        397        547        631
        919       1657       1801       1951       2269       2437       2791       3169       3571       4219
       4447       5167       5419       6211       7057       7351       8269       9241      10267      11719
      12097      13267      13669      16651      19441      19927      22447      23497      24571      25117
      26227      27361      33391      35317      42841      45757      47251      49537      50311      55897
      59221      60919      65269      70687      73477      74419      75367      81181      82171      87211
      88237      89269      92401      96661     102121     103231     104347     110017     112327     114661
     115837     126691     129169     131671     135469     140617     144541     145861     151201     155269
     163567     169219     170647     176419     180811     189757     200467     202021     213067     231019
     234361     241117     246247     251431     260191     263737     267307     276337     279991     283669
     285517     292969     296731     298621     310087     329677     333667     337681     347821     351919
     360187     368551     372769     374887     377011     383419     387721     398581     407377     423001
     436627     452797     459817     476407     478801     493291     522919     527941     553411     574219
     584767     590077     592741     595411     603457     608851     611557     619711     627919     650071
     658477     666937     689761     692641     698419     707131     733591     742519     760537     769627
     772669     784897     791047     812761     825301     837937     847477     863497     879667     886177
     895987     909151     915769     925741     929077     932419     939121     952597     972991     976411
     986707     990151     997057    1021417    1024921    1035469    1074607    1085407    1110817    1114471
    1125469    1155061    1177507    1181269    1215397    1253887    1281187    1285111    1324681    1328671
    1372957    1409731    1422097    1426231    1442827    1451161    1480519    1484737    1527247    1570357

Progress to the 100000th cuban prime: ..................................................
The 100000th cuban prime is     1792617147127

Maple[edit]

This example is incorrect. Please fix the code and remove this message.
Details:

The output is still incorrect.

It appears that the Maple solution isn't using a correct formula for computing cuban primes.

See output from other entries for the first 200 cuban primes.

The first three cuban primes are:       7     19     37     ···


It also appears that most of the program is missing.

CubanPrimes := proc(n) local i, cp; 
cp := Array([]);
for i by 2 while numelems(cp) < n do
if isprime(3/4*i^2 + 1/4) then
ArrayTools:-Append(cp, 3/4*i^2 + 1/4);
end if;
end do;
return cp;
end proc;
Output:
 The first 200 cuban primes are
[1407, 3819, 7437, 12261, 25527, 54471, 66531, 79797, 109947, 126831, 184719, 333057, 362001, 392151, 456069, 489837, 560991, 636969, 717771, 848019, 893847, 1038567, 1089219, 1248411, 1418457, 1477551, 1662069, 1857441, 2063667, 2355519, 2431497, 2666667, 2747469, 3346851, 3907641, 4005327, 4511847, 4722897, 4938771, 5048517, 5271627, 5499561, 6711591, 7098717, 8611041, 9197157, 9497451, 9956937, 10112511, 11235297, 11903421, 12244719, 13119069, 14208087, 14768877, 14958219, 15148767, 16317381, 16516371, 17529411, 17735637, 17943069, 18572601, 19428861, 20526321, 20749431, 20973747, 22113417, 22577727, 23046861, 23283237, 25464891, 25962969, 26465871, 27229269, 28264017, 29052741, 29318061, 30391401, 31209069, 32876967, 34013019, 34300047, 35460219, 36343011, 38141157, 40293867, 40606221, 42826467, 46434819, 47106561, 48464517, 49495647, 50537631, 52298391, 53011137, 53728707, 55543737, 56278191, 57017469, 57388917, 58886769, 59642931, 60022821, 62327487, 66265077, 67067067, 67873881, 69912021, 70735719, 72397587, 74078751, 74926569, 75352287, 75779211, 77067219, 77931921, 80114781, 81882777, 85023201, 87762027, 91012197, 92423217, 95757807, 96239001, 99151491, 105106719, 106116141, 111235611, 115418019, 117538167, 118605477, 119140941, 119677611, 121294857, 122379051, 122922957, 124561911, 126211719, 130664271, 132353877, 134054337, 138641961, 139220841, 140382219, 142133331, 147451791, 149246319, 152867937, 154695027, 155306469, 157764297, 159000447, 163364961, 165885501, 168425337, 170342877, 173562897, 176813067, 178121577, 180093387, 182739351, 184069569, 186073941, 186744477, 187416219, 188763321, 191471997, 195571191, 196258611, 198328107, 199020351, 200408457, 205304817, 206009121, 208129269, 215996007, 218166807, 223274217, 224008671, 226219269, 232167261, 236678907, 237435069, 244294797, 252031287, 257518587, 258307311, 266260881, 267062871, 275964357, 283355931, 285841497, 286672431, 290008227, 291683361, 297584319, 298432137, 306976647, 315641757]
The 200th cuban prime is: 1,570,357
The 100000th cuban prime is: 1792617147127

Nim[edit]

Translation of: C#
import strformat
import strutils
import math
 
const cutOff = 200
const bigUn = 100000
const chunks = 50
const little = bigUn div chunks
 
echo fmt"The first {cutOff} cuban primes"
var primes: seq[int] = @[3, 5]
var c, u = 0
var showEach: bool = true
var v = 1
for i in 1..high(BiggestInt):
var found: bool
inc u, 6
inc v, u
var mx = int(ceil(sqrt(float(v))))
for item in primes:
if item > mx:
break
if v mod item == 0:
found = true
break
if not found:
inc c
if showEach:
for z in countup(primes[^1] + 2, v - 2, step=2):
var fnd: bool = false
for item in primes:
if item > mx:
break
if z mod item == 0:
fnd = true
break
if not fnd:
primes.add(z)
primes.add(v)
write(stdout, fmt"{insertSep($v, ','):>11}")
if c mod 10 == 0:
write(stdout, "\n")
if c == cutOff:
showEach = false
write(stdout, fmt"Progress to the {bigUn}th cuban prime: ")
stdout.flushFile
if c mod little == 0:
write(stdout, ".")
stdout.flushFile
if c == bigUn:
break
write(stdout, "\n")
echo fmt"The {c}th cuban prime is {insertSep($v, ',')}"
Output:
The first 200 cuban primes
          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
      4,447      5,167      5,419      6,211      7,057      7,351      8,269      9,241     10,267     11,719
     12,097     13,267     13,669     16,651     19,441     19,927     22,447     23,497     24,571     25,117
     26,227     27,361     33,391     35,317     42,841     45,757     47,251     49,537     50,311     55,897
     59,221     60,919     65,269     70,687     73,477     74,419     75,367     81,181     82,171     87,211
     88,237     89,269     92,401     96,661    102,121    103,231    104,347    110,017    112,327    114,661
    115,837    126,691    129,169    131,671    135,469    140,617    144,541    145,861    151,201    155,269
    163,567    169,219    170,647    176,419    180,811    189,757    200,467    202,021    213,067    231,019
    234,361    241,117    246,247    251,431    260,191    263,737    267,307    276,337    279,991    283,669
    285,517    292,969    296,731    298,621    310,087    329,677    333,667    337,681    347,821    351,919
    360,187    368,551    372,769    374,887    377,011    383,419    387,721    398,581    407,377    423,001
    436,627    452,797    459,817    476,407    478,801    493,291    522,919    527,941    553,411    574,219
    584,767    590,077    592,741    595,411    603,457    608,851    611,557    619,711    627,919    650,071
    658,477    666,937    689,761    692,641    698,419    707,131    733,591    742,519    760,537    769,627
    772,669    784,897    791,047    812,761    825,301    837,937    847,477    863,497    879,667    886,177
    895,987    909,151    915,769    925,741    929,077    932,419    939,121    952,597    972,991    976,411
    986,707    990,151    997,057  1,021,417  1,024,921  1,035,469  1,074,607  1,085,407  1,110,817  1,114,471
  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
Progress to the 100000th cuban prime: ..................................................
The 100000th cuban prime is 1,792,617,147,127

Pascal[edit]

Library: primTrial
Works with: Free Pascal

uses trial division to check primility.Slow in such number ranges.
OutNthCubPrime(10000) takes only 0,950 s.
100: 283,669; 1000: 65,524,807; 10000: 11,712,188,419; 100000: 1,792,617,147,127

program CubanPrimes;
{$IFDEF FPC}
{$MODE DELPHI}
{$OPTIMIZATION ON,Regvar,PEEPHOLE,CSE,ASMCSE}
{$CODEALIGN proc=32}
{$ENDIF}
uses
primTrial;
const
COLUMNCOUNT = 10*10;
 
procedure FormOut(Cuban:Uint64;ColSize:Uint32);
var
s : String;
pI,pJ :pChar;
i,j : NativeInt;
Begin
str(Cuban,s);
i := length(s);
If i>3 then
Begin
//extend s by the count of comma to be inserted
j := i+ (i-1) div 3;
setlength(s,j);
pI := @s[i];
pJ := @s[j];
while i > 3 do
Begin
// copy 3 digits
pJ^ := pI^;dec(pJ);dec(pI);
pJ^ := pI^;dec(pJ);dec(pI);
pJ^ := pI^;dec(pJ);dec(pI);
// insert comma
pJ^ := ',';dec(pJ);
dec(i,3);
end;
//the digits in front are in the right place
end;
write(s:ColSize);
end;
 
procedure OutFirstCntCubPrimes(Cnt : Int32;ColCnt : Int32);
var
cbDelta1,
cbDelta2 : Uint64;
ClCnt,ColSize : NativeInt;
Begin
If Cnt <= 0 then
EXIT;
IF ColCnt <= 0 then
ColCnt := 1;
ColSize := COLUMNCOUNT DIV ColCnt;
dec(ColCnt);
 
ClCnt := ColCnt;
cbDelta1 := 0;
cbDelta2 := 1;
 
repeat
if isPrime(cbDelta2) then
Begin
FormOut(cbDelta2,ColSize);
dec(Cnt);
 
dec(ClCnt);
If ClCnt < 0 then
Begin
Writeln;
ClCnt := ColCnt;
end;
end;
inc(cbDelta1,6);// 0,6,12,18...
inc(cbDelta2,cbDelta1);//1,7,19,35...
until Cnt<= 0;
 
writeln;
end;
 
procedure OutNthCubPrime(n : Int32);
var
cbDelta1,
cbDelta2 : Uint64;
Begin
If n <= 0 then
EXIT;
cbDelta1 := 0;
cbDelta2 := 1;
 
repeat
inc(cbDelta1,6);
inc(cbDelta2,cbDelta1);
if isPrime(cbDelta2) then
dec(n);
until n<=0;
 
FormOut(cbDelta2,20);
writeln;
end;
 
Begin
OutFirstCntCubPrimes(200,10);
OutNthCubPrime(100000);
end.
Output:
         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
     4,447     5,167     5,419     6,211     7,057     7,351     8,269     9,241    10,267    11,719
    12,097    13,267    13,669    16,651    19,441    19,927    22,447    23,497    24,571    25,117
    26,227    27,361    33,391    35,317    42,841    45,757    47,251    49,537    50,311    55,897
    59,221    60,919    65,269    70,687    73,477    74,419    75,367    81,181    82,171    87,211
    88,237    89,269    92,401    96,661   102,121   103,231   104,347   110,017   112,327   114,661
   115,837   126,691   129,169   131,671   135,469   140,617   144,541   145,861   151,201   155,269
   163,567   169,219   170,647   176,419   180,811   189,757   200,467   202,021   213,067   231,019
   234,361   241,117   246,247   251,431   260,191   263,737   267,307   276,337   279,991   283,669
   285,517   292,969   296,731   298,621   310,087   329,677   333,667   337,681   347,821   351,919
   360,187   368,551   372,769   374,887   377,011   383,419   387,721   398,581   407,377   423,001
   436,627   452,797   459,817   476,407   478,801   493,291   522,919   527,941   553,411   574,219
   584,767   590,077   592,741   595,411   603,457   608,851   611,557   619,711   627,919   650,071
   658,477   666,937   689,761   692,641   698,419   707,131   733,591   742,519   760,537   769,627
   772,669   784,897   791,047   812,761   825,301   837,937   847,477   863,497   879,667   886,177
   895,987   909,151   915,769   925,741   929,077   932,419   939,121   952,597   972,991   976,411
   986,707   990,151   997,057 1,021,417 1,024,921 1,035,469 1,074,607 1,085,407 1,110,817 1,114,471
 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

   1,792,617,147,127  //user    2m1.950s

Perl[edit]

Library: ntheory
use feature 'say';
use ntheory 'is_prime';
 
sub cuban_primes {
my ($n) = @_;
 
my @primes;
for (my $k = 1 ; ; ++$k) {
my $p = 3 * $k * ($k + 1) + 1;
if (is_prime($p)) {
push @primes, $p;
last if @primes >= $n;
}
}
 
return @primes;
}
 
sub commify {
scalar reverse join ',', unpack '(A3)*', reverse shift;
}
 
my @c = cuban_primes(200);
 
while (@c) {
say join ' ', map { sprintf "%9s", commify $_ } splice(@c, 0, 10);
}
 
say '';
for my $n (1 .. 6) {
say "10^$n-th cuban prime is: ", commify((cuban_primes(10**$n))[-1]);
}
Output:
        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
    4,447     5,167     5,419     6,211     7,057     7,351     8,269     9,241    10,267    11,719
   12,097    13,267    13,669    16,651    19,441    19,927    22,447    23,497    24,571    25,117
   26,227    27,361    33,391    35,317    42,841    45,757    47,251    49,537    50,311    55,897
   59,221    60,919    65,269    70,687    73,477    74,419    75,367    81,181    82,171    87,211
   88,237    89,269    92,401    96,661   102,121   103,231   104,347   110,017   112,327   114,661
  115,837   126,691   129,169   131,671   135,469   140,617   144,541   145,861   151,201   155,269
  163,567   169,219   170,647   176,419   180,811   189,757   200,467   202,021   213,067   231,019
  234,361   241,117   246,247   251,431   260,191   263,737   267,307   276,337   279,991   283,669
  285,517   292,969   296,731   298,621   310,087   329,677   333,667   337,681   347,821   351,919
  360,187   368,551   372,769   374,887   377,011   383,419   387,721   398,581   407,377   423,001
  436,627   452,797   459,817   476,407   478,801   493,291   522,919   527,941   553,411   574,219
  584,767   590,077   592,741   595,411   603,457   608,851   611,557   619,711   627,919   650,071
  658,477   666,937   689,761   692,641   698,419   707,131   733,591   742,519   760,537   769,627
  772,669   784,897   791,047   812,761   825,301   837,937   847,477   863,497   879,667   886,177
  895,987   909,151   915,769   925,741   929,077   932,419   939,121   952,597   972,991   976,411
  986,707   990,151   997,057 1,021,417 1,024,921 1,035,469 1,074,607 1,085,407 1,110,817 1,114,471
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

10^1-th cuban prime is: 631
10^2-th cuban prime is: 283,669
10^3-th cuban prime is: 65,524,807
10^4-th cuban prime is: 11,712,188,419
10^5-th cuban prime is: 1,792,617,147,127
10^6-th cuban prime is: 255,155,578,239,277

Perl 6[edit]

Works with: Rakudo version 2018.12

The task (k == 1)[edit]

Not the most efficient, but concise, and good enough for this task. Use the ntheory library for prime testing; gets it down to around 20 seconds.

use Lingua::EN::Numbers;
use ntheory:from<Perl5> <:all>;
 
my @cubans = lazy (1..Inf).map({ ($_+1)³ - .³ }).grep: *.&is_prime;
 
put @cubans[^200]».&comma».fmt("%9s").rotor(10).join: "\n";
 
put '';
 
put @cubans[99_999].&comma; # zero indexed
Output:
        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
    4,447     5,167     5,419     6,211     7,057     7,351     8,269     9,241    10,267    11,719
   12,097    13,267    13,669    16,651    19,441    19,927    22,447    23,497    24,571    25,117
   26,227    27,361    33,391    35,317    42,841    45,757    47,251    49,537    50,311    55,897
   59,221    60,919    65,269    70,687    73,477    74,419    75,367    81,181    82,171    87,211
   88,237    89,269    92,401    96,661   102,121   103,231   104,347   110,017   112,327   114,661
  115,837   126,691   129,169   131,671   135,469   140,617   144,541   145,861   151,201   155,269
  163,567   169,219   170,647   176,419   180,811   189,757   200,467   202,021   213,067   231,019
  234,361   241,117   246,247   251,431   260,191   263,737   267,307   276,337   279,991   283,669
  285,517   292,969   296,731   298,621   310,087   329,677   333,667   337,681   347,821   351,919
  360,187   368,551   372,769   374,887   377,011   383,419   387,721   398,581   407,377   423,001
  436,627   452,797   459,817   476,407   478,801   493,291   522,919   527,941   553,411   574,219
  584,767   590,077   592,741   595,411   603,457   608,851   611,557   619,711   627,919   650,071
  658,477   666,937   689,761   692,641   698,419   707,131   733,591   742,519   760,537   769,627
  772,669   784,897   791,047   812,761   825,301   837,937   847,477   863,497   879,667   886,177
  895,987   909,151   915,769   925,741   929,077   932,419   939,121   952,597   972,991   976,411
  986,707   990,151   997,057 1,021,417 1,024,921 1,035,469 1,074,607 1,085,407 1,110,817 1,114,471
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

1,792,617,147,127

k == 2 through 10[edit]

After reading up a bit, the general equation for cuban primes is prime numbers of the form ((x+k)3 - x3)/k where k mod 3 is not equal 0.

The cubans where k == 1 (the focus of this task) is one of many possible groups. In general, it seems like the cubans where k == 1 and k == 2 are the two primary cases, but it is possible to have cubans with a k of any integer that is not a multiple of 3.

Here are the first 20 for each valid k up to 10:

sub comma { $^i.flip.comb(3).join(',').flip }
 
for 2..10 -> \k {
next if k %% 3;
my @cubans = lazy (1..Inf).map({ (($_+k)³ - .³)/k }).grep: *.is-prime;
put "First 20 cuban primes where k = {k}:";
put @cubans[^20]».&comma».fmt("%7s").rotor(10).join: "\n";
put '';
}
 
Output:
First 20 cuban primes where k = 2:
     13     109     193     433     769   1,201   1,453   2,029   3,469   3,889
  4,801  10,093  12,289  13,873  18,253  20,173  21,169  22,189  28,813  37,633

First 20 cuban primes where k = 4:
     31      79     151     367   1,087   1,327   1,879   2,887   3,271   4,111
  4,567   6,079   7,207   8,431  15,991  16,879  17,791  19,687  23,767  24,847

First 20 cuban primes where k = 5:
     43      67      97     223     277     337     727     823   1,033   1,663
  2,113   2,617   2,797   3,373   4,003   5,683   6,217   7,963  10,273  10,627

First 20 cuban primes where k = 7:
     73     103     139     181     229     283     409     643     733     829
  1,039   1,153   1,399   1,531   1,669   2,281   2,803   3,181   3,583   3,793

First 20 cuban primes where k = 8:
    163     379     523     691     883   2,203   2,539   3,691   5,059   5,563
  6,091   7,219   8,443   9,091  10,459  11,923  15,139  19,699  24,859  27,091

First 20 cuban primes where k = 10:
    457     613     997   1,753   2,053   2,377   4,357   6,373   9,433  13,093
 16,453  21,193  27,673  28,837  31,237  37,657  46,153  47,653  49,177  62,233

k == 2^128[edit]

Note that Perl 6 has native support for arbitrarily large integers and does not need to generate primes to test for primality. Using k of 2^128; finishes in well under a second.

sub comma { $^i.flip.comb(3).join(',').flip }
 
my \k = 2**128;
put "First 10 cuban primes where k = {k}:";
.&comma.put for (lazy (0..Inf).map({ (($_+k)³ - .³)/k }).grep: *.is-prime)[^10];
First 10 cuban primes where k = 340282366920938463463374607431768211456:
115,792,089,237,316,195,423,570,985,008,687,908,160,544,961,995,247,996,546,884,854,518,799,824,856,507
115,792,089,237,316,195,423,570,985,008,687,908,174,836,821,405,927,412,012,346,588,030,934,089,763,531
115,792,089,237,316,195,423,570,985,008,687,908,219,754,093,839,491,289,189,512,036,211,927,493,764,691
115,792,089,237,316,195,423,570,985,008,687,908,383,089,629,961,541,751,651,931,847,779,176,235,685,011
115,792,089,237,316,195,423,570,985,008,687,908,491,299,422,642,400,183,033,284,972,942,478,527,291,811
115,792,089,237,316,195,423,570,985,008,687,908,771,011,528,251,411,600,000,178,900,251,391,998,361,371
115,792,089,237,316,195,423,570,985,008,687,908,875,137,932,529,218,769,819,971,530,125,513,071,648,307
115,792,089,237,316,195,423,570,985,008,687,908,956,805,700,590,244,001,051,181,435,909,137,442,897,427
115,792,089,237,316,195,423,570,985,008,687,909,028,264,997,643,641,078,378,490,103,469,808,767,771,907
115,792,089,237,316,195,423,570,985,008,687,909,158,933,426,541,281,448,348,425,952,723,607,761,904,131

Phix[edit]

Library: mpfr
include mpfr.e
integer np = 0,
i = 2
mpz p3 = mpz_init(1*1*1),
i3 = mpz_init(),
p = mpz_init(),
pn = mpz_init()
atom randstate = gmp_randinit_mt()
 
printf(1,"The first 200 cuban primes are:\n")
sequence first200 = {}
atom t0 = time()
while np<100000 do
mpz_ui_pow_ui(i3,i,3)
mpz_sub(p,i3,p3)
if mpz_probable_prime_p(p,randstate) then
mpz_set(pn,p)
np += 1
if np<=200 then
first200 = append(first200,sprintf("%,9d",mpz_get_integer(pn)))
if mod(np,10)=0 then
printf(1,"%s\n",join(first200[-10..-1]))
end if
end if
end if
mpz_set(p3,i3)
i += 1
end while
printf(1,"\nThe %,dth cuban prime is %s\n",{np,mpz_get_str(pn,comma_fill:=true)})
randstate = gmp_randclear(randstate)
{p3,i3,p} = mpz_free({p3,i3,p})
?elapsed(time()-t0)
Output:
The first 200 cuban primes are:
        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
    4,447     5,167     5,419     6,211     7,057     7,351     8,269     9,241    10,267    11,719
   12,097    13,267    13,669    16,651    19,441    19,927    22,447    23,497    24,571    25,117
   26,227    27,361    33,391    35,317    42,841    45,757    47,251    49,537    50,311    55,897
   59,221    60,919    65,269    70,687    73,477    74,419    75,367    81,181    82,171    87,211
   88,237    89,269    92,401    96,661   102,121   103,231   104,347   110,017   112,327   114,661
  115,837   126,691   129,169   131,671   135,469   140,617   144,541   145,861   151,201   155,269
  163,567   169,219   170,647   176,419   180,811   189,757   200,467   202,021   213,067   231,019
  234,361   241,117   246,247   251,431   260,191   263,737   267,307   276,337   279,991   283,669
  285,517   292,969   296,731   298,621   310,087   329,677   333,667   337,681   347,821   351,919
  360,187   368,551   372,769   374,887   377,011   383,419   387,721   398,581   407,377   423,001
  436,627   452,797   459,817   476,407   478,801   493,291   522,919   527,941   553,411   574,219
  584,767   590,077   592,741   595,411   603,457   608,851   611,557   619,711   627,919   650,071
  658,477   666,937   689,761   692,641   698,419   707,131   733,591   742,519   760,537   769,627
  772,669   784,897   791,047   812,761   825,301   837,937   847,477   863,497   879,667   886,177
  895,987   909,151   915,769   925,741   929,077   932,419   939,121   952,597   972,991   976,411
  986,707   990,151   997,057 1,021,417 1,024,921 1,035,469 1,074,607 1,085,407 1,110,817 1,114,471
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
"5.9s"

Python[edit]

Translation of: C#
 
import datetime
import math
 
primes = [ 3, 5 ]
 
cutOff = 200
 
bigUn = 100_000
chunks = 50
little = bigUn / chunks
 
tn = " cuban prime"
print ("The first {:,}{}s:".format(cutOff, tn))
 
c = 0
showEach = True
u = 0
v = 1
st = datetime.datetime.now()
 
for i in range(1, int(math.pow(2,20))):
found = False
u += 6
v += u
mx = int(math.sqrt(v))
 
for item in primes:
if (item > mx):
break
if (v % item == 0):
found = True
break
 
if (found == 0):
c += 1
if (showEach):
z = primes[-1]
while (z <= v - 2):
z += 2
 
fnd = False
for item in primes:
if (item > mx):
break
if (z % item == 0):
fnd = True
break
 
if (not fnd):
primes.append(z)
 
primes.append(v)
print("{:>11,}".format(v), end='')
 
if (c % 10 == 0):
print("");
if (c == cutOff):
showEach = False
print ("Progress to the {:,}th {}:".format(bigUn, tn), end='')
if (c % little == 0):
print('.', end='')
if (c == bigUn):
break
 
print("");
print ("The {:,}th{} is {:,}".format(c, tn, v))
print("Computation time was {} seconds".format((datetime.datetime.now() - st).seconds))
 
Output:
The first 200 cuban primes:
          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
      4,447      5,167      5,419      6,211      7,057      7,351      8,269      9,241     10,267     11,719
     12,097     13,267     13,669     16,651     19,441     19,927     22,447     23,497     24,571     25,117
     26,227     27,361     33,391     35,317     42,841     45,757     47,251     49,537     50,311     55,897
     59,221     60,919     65,269     70,687     73,477     74,419     75,367     81,181     82,171     87,211
     88,237     89,269     92,401     96,661    102,121    103,231    104,347    110,017    112,327    114,661
    115,837    126,691    129,169    131,671    135,469    140,617    144,541    145,861    151,201    155,269
    163,567    169,219    170,647    176,419    180,811    189,757    200,467    202,021    213,067    231,019
    234,361    241,117    246,247    251,431    260,191    263,737    267,307    276,337    279,991    283,669
    285,517    292,969    296,731    298,621    310,087    329,677    333,667    337,681    347,821    351,919
    360,187    368,551    372,769    374,887    377,011    383,419    387,721    398,581    407,377    423,001
    436,627    452,797    459,817    476,407    478,801    493,291    522,919    527,941    553,411    574,219
    584,767    590,077    592,741    595,411    603,457    608,851    611,557    619,711    627,919    650,071
    658,477    666,937    689,761    692,641    698,419    707,131    733,591    742,519    760,537    769,627
    772,669    784,897    791,047    812,761    825,301    837,937    847,477    863,497    879,667    886,177
    895,987    909,151    915,769    925,741    929,077    932,419    939,121    952,597    972,991    976,411
    986,707    990,151    997,057  1,021,417  1,024,921  1,035,469  1,074,607  1,085,407  1,110,817  1,114,471
  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
Progress to the 100,000th  cuban prime:..................................................
The 100,000th cuban prime is 1,792,617,147,127
Computation time was 856 seconds

Racket[edit]

#lang racket
 
(require math/number-theory
racket/generator)
 
(define (make-cuban-prime-generator)
(generator ()
(let loop ((y 1) (y3 1))
(let* ((x (+ y 1))
(x3 (expt x 3))
(p (quotient (- x3 y3) (- x y))))
(when (prime? p) (yield p))
(loop x x3)))))
 
(define (tabulate l (line-width 80))
(let* ((w (add1 (string-length (argmax string-length (map ~a l)))))
(cols (quotient line-width w)))
(for ((n (in-range 1 (add1 (length l))))
(i l))
(display (~a i #:width w #:align 'right))
(when (zero? (modulo n cols)) (newline)))))
 
(define (progress-report x)
(when (zero? (modulo x 1000))
(eprintf (if (zero? (modulo x 10000)) "|" "."))
(flush-output (current-error-port))))
 
(let ((200-cuban-primes (for/list ((_ 200)
(p (in-producer (make-cuban-prime-generator))))
p)))
(tabulate 200-cuban-primes))
 
(begin0
(for/last ((x 100000)
(p (in-producer (make-cuban-prime-generator))))
(progress-report x)
p)
(newline))
Output:
       7      19      37      61     127     271     331     397     547     631
     919    1657    1801    1951    2269    2437    2791    3169    3571    4219
    4447    5167    5419    6211    7057    7351    8269    9241   10267   11719
   12097   13267   13669   16651   19441   19927   22447   23497   24571   25117
   26227   27361   33391   35317   42841   45757   47251   49537   50311   55897
   59221   60919   65269   70687   73477   74419   75367   81181   82171   87211
   88237   89269   92401   96661  102121  103231  104347  110017  112327  114661
  115837  126691  129169  131671  135469  140617  144541  145861  151201  155269
  163567  169219  170647  176419  180811  189757  200467  202021  213067  231019
  234361  241117  246247  251431  260191  263737  267307  276337  279991  283669
  285517  292969  296731  298621  310087  329677  333667  337681  347821  351919
  360187  368551  372769  374887  377011  383419  387721  398581  407377  423001
  436627  452797  459817  476407  478801  493291  522919  527941  553411  574219
  584767  590077  592741  595411  603457  608851  611557  619711  627919  650071
  658477  666937  689761  692641  698419  707131  733591  742519  760537  769627
  772669  784897  791047  812761  825301  837937  847477  863497  879667  886177
  895987  909151  915769  925741  929077  932419  939121  952597  972991  976411
  986707  990151  997057 1021417 1024921 1035469 1074607 1085407 1110817 1114471
 1125469 1155061 1177507 1181269 1215397 1253887 1281187 1285111 1324681 1328671
 1372957 1409731 1422097 1426231 1442827 1451161 1480519 1484737 1527247 1570357
|.........|.........|.........|.........|.........|.........|.........|.........|.........|.........
1792617147127

REXX[edit]

Cuban primes can't end in an even (decimal) digit,   or the digit   5.

Also, by their construction, cuban primes can't have a factor of   6*k + 1,   where   k   is any positive integer.

/*REXX program finds and displays a number of  cuban  primes  or the  Nth  cuban prime. */
numeric digits 20 /*ensure enough decimal digits for #s. */
parse arg N . /*obtain optional argument from the CL.*/
if N=='' | N=="," then N= 200 /*Not specified? Then use the default.*/
Nth= N<0; N= abs(N) /*used for finding the Nth cuban prime.*/
@.=0; @.0=1; @.2=1; @.3=1; @.4=1; @.5=1; @.6=1; @.8=1 /*ending digs that aren't cubans.*/
sw= linesize() - 1; if sw<1 then sw= 79 /*obtain width of the terminal screen. */
w=12; #= 1; $= right(7, w) /*start with first cuban prime; count.*/
do j=1 until #=>N; x= (j+1)**3 - j**3 /*compute a possible cuban prime. */
parse var x '' -1 _; if @._ then iterate /*check last digit for non─cuban prime.*/
do k=1 until km*km>x; km= k*6 + 1 /*cuban primes can't be ÷ by 6k+1 */
if x//km==0 then iterate j /*Divisible? Then not a cuban prime. */
end /*k*/
#= #+1 /*bump the number of cuban primes found*/
if Nth then do; if #==N then do; say commas(x); leave j; end /*display 1 num.*/
else iterate /*j*/ /*keep searching*/
end /* [↑] try to fit as many #s per line.*/
cx= commas(x); L= length(cx) /*insert commas──►X; obtain the length.*/
cx= right(cx, max(w, L) ); new= $ cx /*right justify CX; concat to new list*/
if length(new)>sw then do; say $; $= cx /*line is too long, display #'s so far.*/
end /* [↑] initialize the (new) next line.*/
else $= new /*start with cuban # that wouldn't fit.*/
end /*j*/
if \Nth & $\=='' then say $ /*check for residual cuban primes in $.*/
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg _; do jc=length(_)-3 to 1 by -3; _=insert(',', _, jc); end; return _

This REXX program makes use of   LINESIZE   REXX program   (or BIF)   which is used to determine the screen width  
(or linesize)   of the terminal (console).   Some REXXes don't have this BIF.

The   LINESIZE.REX   REXX program is included here   ───►   LINESIZE.REX.

output   when using the default input of:     200

(Shown at three-quarter size.)

           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        4,447        5,167
       5,419        6,211        7,057        7,351        8,269        9,241       10,267       11,719       12,097       13,267       13,669
      16,651       19,441       19,927       22,447       23,497       24,571       25,117       26,227       27,361       33,391       35,317
      42,841       45,757       47,251       49,537       50,311       55,897       59,221       60,919       65,269       70,687       73,477
      74,419       75,367       81,181       82,171       87,211       88,237       89,269       92,401       96,661      102,121      103,231
     104,347      110,017      112,327      114,661      115,837      126,691      129,169      131,671      135,469      140,617      144,541
     145,861      151,201      155,269      163,567      169,219      170,647      176,419      180,811      189,757      200,467      202,021
     213,067      231,019      234,361      241,117      246,247      251,431      260,191      263,737      267,307      276,337      279,991
     283,669      285,517      292,969      296,731      298,621      310,087      329,677      333,667      337,681      347,821      351,919
     360,187      368,551      372,769      374,887      377,011      383,419      387,721      398,581      407,377      423,001      436,627
     452,797      459,817      476,407      478,801      493,291      522,919      527,941      553,411      574,219      584,767      590,077
     592,741      595,411      603,457      608,851      611,557      619,711      627,919      650,071      658,477      666,937      689,761
     692,641      698,419      707,131      733,591      742,519      760,537      769,627      772,669      784,897      791,047      812,761
     825,301      837,937      847,477      863,497      879,667      886,177      895,987      909,151      915,769      925,741      929,077
     932,419      939,121      952,597      972,991      976,411      986,707      990,151      997,057    1,021,417    1,024,921    1,035,469
   1,074,607    1,085,407    1,110,817    1,114,471    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
output   when using the input of:     -100000
1,792,617,147,127

Ruby[edit]

require "openssl"
 
RE = /(\d)(?=(\d\d\d)+(?!\d))/ # Activesupport uses this for commatizing
cuban_primes = Enumerator.new do |y|
(1..).each do |n|
cand = 3*n*(n+1) + 1
y << cand if OpenSSL::BN.new(cand).prime?
end
end
 
def commatize(num)
num.to_s.gsub(RE, "\\1,")
end
 
cbs = cuban_primes.take(200)
formatted = cbs.map{|cb| commatize(cb).rjust(10) }
puts formatted.each_slice(10).map(&:join)
 
t0 = Time.now
puts "
100_000th cuban prime is #{commatize( cuban_primes.take(100_000).last)}
which took #{(Time.now-t0).round} seconds to calculate."
Output:
         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
     4,447     5,167     5,419     6,211     7,057     7,351     8,269     9,241    10,267    11,719
    12,097    13,267    13,669    16,651    19,441    19,927    22,447    23,497    24,571    25,117
    26,227    27,361    33,391    35,317    42,841    45,757    47,251    49,537    50,311    55,897
    59,221    60,919    65,269    70,687    73,477    74,419    75,367    81,181    82,171    87,211
    88,237    89,269    92,401    96,661   102,121   103,231   104,347   110,017   112,327   114,661
   115,837   126,691   129,169   131,671   135,469   140,617   144,541   145,861   151,201   155,269
   163,567   169,219   170,647   176,419   180,811   189,757   200,467   202,021   213,067   231,019
   234,361   241,117   246,247   251,431   260,191   263,737   267,307   276,337   279,991   283,669
   285,517   292,969   296,731   298,621   310,087   329,677   333,667   337,681   347,821   351,919
   360,187   368,551   372,769   374,887   377,011   383,419   387,721   398,581   407,377   423,001
   436,627   452,797   459,817   476,407   478,801   493,291   522,919   527,941   553,411   574,219
   584,767   590,077   592,741   595,411   603,457   608,851   611,557   619,711   627,919   650,071
   658,477   666,937   689,761   692,641   698,419   707,131   733,591   742,519   760,537   769,627
   772,669   784,897   791,047   812,761   825,301   837,937   847,477   863,497   879,667   886,177
   895,987   909,151   915,769   925,741   929,077   932,419   939,121   952,597   972,991   976,411
   986,707   990,151   997,057 1,021,417 1,024,921 1,035,469 1,074,607 1,085,407 1,110,817 1,114,471
 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

100_000th cuban prime is 1,792,617,147,127
which took 31 seconds to calculate.

Rust[edit]

Uses the libraries primal and separator

use std::time::Instant;
use separator::Separatable;
 
const NUMBER_OF_CUBAN_PRIMES: usize = 200;
const COLUMNS: usize = 10;
const LAST_CUBAN_PRIME: usize = 100_000;
 
fn main() {
println!("Calculating the first {} cuban primes and the {}th cuban prime...", NUMBER_OF_CUBAN_PRIMES, LAST_CUBAN_PRIME);
let start = Instant::now();
 
let mut i: u64 = 0;
let mut j: u64 = 1;
let mut index: usize = 0;
let mut cuban_primes = Vec::new();
let mut cuban: u64 = 0;
while index < 100_000 {
cuban = {j += 1; j}.pow(3) - {i += 1; i}.pow(3);
if primal::is_prime(cuban) {
if index < NUMBER_OF_CUBAN_PRIMES {
cuban_primes.push(cuban);
}
index += 1;
}
}
 
let elapsed = start.elapsed();
println!("THE {} FIRST CUBAN PRIMES:", NUMBER_OF_CUBAN_PRIMES);
cuban_primes
.chunks(COLUMNS)
.map(|chunk| {
chunk.iter()
.map(|item| {
print!("{}\t", item)
})
.for_each(drop);
println!("");
})
.for_each(drop);
println!("The {}th cuban prime number is {}", LAST_CUBAN_PRIME, cuban.separated_string());
println!("Elapsed time: {:?}", elapsed);
}
Output:
Calculating the first 200 cuban primes and the 100000th cuban prime...
THE 200 FIRST CUBAN PRIMES:
7       19      37      61      127     271     331     397     547     631
919     1657    1801    1951    2269    2437    2791    3169    3571    4219
4447    5167    5419    6211    7057    7351    8269    9241    10267   11719
12097   13267   13669   16651   19441   19927   22447   23497   24571   25117
26227   27361   33391   35317   42841   45757   47251   49537   50311   55897
59221   60919   65269   70687   73477   74419   75367   81181   82171   87211
88237   89269   92401   96661   102121  103231  104347  110017  112327  114661
115837  126691  129169  131671  135469  140617  144541  145861  151201  155269
163567  169219  170647  176419  180811  189757  200467  202021  213067  231019
234361  241117  246247  251431  260191  263737  267307  276337  279991  283669
285517  292969  296731  298621  310087  329677  333667  337681  347821  351919
360187  368551  372769  374887  377011  383419  387721  398581  407377  423001
436627  452797  459817  476407  478801  493291  522919  527941  553411  574219
584767  590077  592741  595411  603457  608851  611557  619711  627919  650071
658477  666937  689761  692641  698419  707131  733591  742519  760537  769627
772669  784897  791047  812761  825301  837937  847477  863497  879667  886177
895987  909151  915769  925741  929077  932419  939121  952597  972991  976411
986707  990151  997057  1021417 1024921 1035469 1074607 1085407 1110817 1114471
1125469 1155061 1177507 1181269 1215397 1253887 1281187 1285111 1324681 1328671
1372957 1409731 1422097 1426231 1442827 1451161 1480519 1484737 1527247 1570357
The 100000th cuban prime number is 1,792,617,147,127
Elapsed time: 11.005581564s

Scala[edit]

In this example, we start by building an infinite lazy list of cubans and filter out non-primes. This gives us a lazily evaluated list of all cuban primes, and finding the first 200 simply involves taking 200 elements off the list.

To find the 100,000th cuban prime, performance becomes an issue. To remedy this, we write a function that breaks off a chunk from the front of the list of cubans and filters it using a parallel vector, repeating this process until it's found enough cuban primes. This allows us to benefit from the memory efficiency of lazy lists and the number-crunching speed of parallel vectors at the same time.

Spire's SafeLong is used instead of Java's BigInt for performance.

import spire.math.SafeLong
import spire.implicits._
 
import scala.annotation.tailrec
import scala.collection.parallel.immutable.ParVector
 
object CubanPrimes {
def main(args: Array[String]): Unit = {
println(formatTable(cubanPrimes.take(200).toVector, 10))
println(f"The 100,000th cuban prime is: ${getNthCubanPrime(100000).toBigInt}%,d")
}
 
def cubanPrimes: LazyList[SafeLong] = cubans.filter(isPrime)
def cubans: LazyList[SafeLong] = LazyList.iterate(SafeLong(0))(_ + 1).map(n => (n + 1).pow(3) - n.pow(3))
def isPrime(num: SafeLong): Boolean = (num > 1) && !(SafeLong(2) #:: LazyList.iterate(SafeLong(3)){n => n + 2}).takeWhile(n => n*n <= num).exists(num%_ == 0)
 
def getNthCubanPrime(num: Int): SafeLong = {
@tailrec
def nHelper(rem: Int, src: LazyList[SafeLong]): SafeLong = {
val cprimes = src.take(100000).to(ParVector).filter(isPrime)
if(cprimes.size < rem) nHelper(rem - cprimes.size, src.drop(100000))
else cprimes.toVector.sortWith(_<_)(rem - 1)
}
 
nHelper(num, cubans)
}
 
def formatTable(lst: Vector[SafeLong], rlen: Int): String = {
@tailrec
def fHelper(ac: Vector[String], src: Vector[String]): String = {
if(src.nonEmpty) fHelper(ac :+ src.take(rlen).mkString, src.drop(rlen))
else ac.mkString("\n")
}
 
val maxLen = lst.map(n => f"${n.toBigInt}%,d".length).max
val formatted = lst.map(n => s"%,${maxLen + 2}d".format(n.toInt))
 
fHelper(Vector[String](), formatted)
}
}
Output:
          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
      4,447      5,167      5,419      6,211      7,057      7,351      8,269      9,241     10,267     11,719
     12,097     13,267     13,669     16,651     19,441     19,927     22,447     23,497     24,571     25,117
     26,227     27,361     33,391     35,317     42,841     45,757     47,251     49,537     50,311     55,897
     59,221     60,919     65,269     70,687     73,477     74,419     75,367     81,181     82,171     87,211
     88,237     89,269     92,401     96,661    102,121    103,231    104,347    110,017    112,327    114,661
    115,837    126,691    129,169    131,671    135,469    140,617    144,541    145,861    151,201    155,269
    163,567    169,219    170,647    176,419    180,811    189,757    200,467    202,021    213,067    231,019
    234,361    241,117    246,247    251,431    260,191    263,737    267,307    276,337    279,991    283,669
    285,517    292,969    296,731    298,621    310,087    329,677    333,667    337,681    347,821    351,919
    360,187    368,551    372,769    374,887    377,011    383,419    387,721    398,581    407,377    423,001
    436,627    452,797    459,817    476,407    478,801    493,291    522,919    527,941    553,411    574,219
    584,767    590,077    592,741    595,411    603,457    608,851    611,557    619,711    627,919    650,071
    658,477    666,937    689,761    692,641    698,419    707,131    733,591    742,519    760,537    769,627
    772,669    784,897    791,047    812,761    825,301    837,937    847,477    863,497    879,667    886,177
    895,987    909,151    915,769    925,741    929,077    932,419    939,121    952,597    972,991    976,411
    986,707    990,151    997,057  1,021,417  1,024,921  1,035,469  1,074,607  1,085,407  1,110,817  1,114,471
  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

Sidef[edit]

func cuban_primes(n) {
1..Inf -> lazy.map {|k| 3*k*(k+1) + 1 }\
.grep{ .is_prime }\
.first(n)
}
 
cuban_primes(200).slices(10).each {
say .map { "%9s" % .commify }.join(' ')
}
 
say ("\n100,000th cuban prime is: ", cuban_primes(1e5).last.commify)
Output:
        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
    4,447     5,167     5,419     6,211     7,057     7,351     8,269     9,241    10,267    11,719
   12,097    13,267    13,669    16,651    19,441    19,927    22,447    23,497    24,571    25,117
   26,227    27,361    33,391    35,317    42,841    45,757    47,251    49,537    50,311    55,897
   59,221    60,919    65,269    70,687    73,477    74,419    75,367    81,181    82,171    87,211
   88,237    89,269    92,401    96,661   102,121   103,231   104,347   110,017   112,327   114,661
  115,837   126,691   129,169   131,671   135,469   140,617   144,541   145,861   151,201   155,269
  163,567   169,219   170,647   176,419   180,811   189,757   200,467   202,021   213,067   231,019
  234,361   241,117   246,247   251,431   260,191   263,737   267,307   276,337   279,991   283,669
  285,517   292,969   296,731   298,621   310,087   329,677   333,667   337,681   347,821   351,919
  360,187   368,551   372,769   374,887   377,011   383,419   387,721   398,581   407,377   423,001
  436,627   452,797   459,817   476,407   478,801   493,291   522,919   527,941   553,411   574,219
  584,767   590,077   592,741   595,411   603,457   608,851   611,557   619,711   627,919   650,071
  658,477   666,937   689,761   692,641   698,419   707,131   733,591   742,519   760,537   769,627
  772,669   784,897   791,047   812,761   825,301   837,937   847,477   863,497   879,667   886,177
  895,987   909,151   915,769   925,741   929,077   932,419   939,121   952,597   972,991   976,411
  986,707   990,151   997,057 1,021,417 1,024,921 1,035,469 1,074,607 1,085,407 1,110,817 1,114,471
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

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

Visual Basic .NET[edit]

Corner Cutting Version[edit]

This language doesn't have a built-in for a IsPrime() function, so I was surprised to find that this runs so quickly. It builds a list of primes while it is creating the output table. Since the last item on the table is larger than the square root of the 100,000th cuban prime, there is no need to continue adding to the prime list while checking up to the 100,000th cuban prime. I found a bit of a shortcut, if you skip the iterator by just the right amount, only one value is tested for the final result. It's hard-coded in the program, so if another final cuban prime were to be selected for output, the program would need a re-write. If not skipping ahead to the answer, it takes a few seconds over a minute to eventually get to it (see Snail Version below).

Module Module1
Dim primes As List(Of Long) = {3L, 5L}.ToList()
 
Sub Main(args As String())
Const cutOff As Integer = 200, bigUn As Integer = 100000,
tn As String = " cuban prime"
Console.WriteLine("The first {0:n0}{1}s:", cutOff, tn)
Dim c As Integer = 0, showEach As Boolean = True, skip As Boolean = True,
v As Long = 0, st As DateTime = DateTime.Now
For i As Long = 1 To Long.MaxValue
v = 3 * i : v = v * i + v + 1
Dim found As Boolean = False, mx As Integer = Math.Ceiling(Math.Sqrt(v))
For Each item In primes
If item > mx Then Exit For
If v Mod item = 0 Then found = True : Exit For
Next : If Not found Then
c += 1 : If showEach Then
For z = primes.Last + 2 To v - 2 Step 2
Dim fnd As Boolean = False
For Each item In primes
If item > mx Then Exit For
If z Mod item = 0 Then fnd = True : Exit For
Next : If Not fnd Then primes.Add(z)
Next : primes.Add(v) : Console.Write("{0,11:n0}", v)
If c Mod 10 = 0 Then Console.WriteLine()
If c = cutOff Then showEach = False
Else
If skip Then skip = False : i += 772279 : c = bigUn - 1
End If
If c = bigUn Then Exit For
End If
Next
Console.WriteLine("{1}The {2:n0}th{3} is {0,17:n0}", v, vbLf, c, tn)
Console.WriteLine("Computation time was {0} seconds", (DateTime.Now - st).TotalSeconds)
If System.Diagnostics.Debugger.IsAttached Then Console.ReadKey()
End Sub
End Module
Output:
The first 200 cuban primes:
          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
      4,447      5,167      5,419      6,211      7,057      7,351      8,269      9,241     10,267     11,719
     12,097     13,267     13,669     16,651     19,441     19,927     22,447     23,497     24,571     25,117
     26,227     27,361     33,391     35,317     42,841     45,757     47,251     49,537     50,311     55,897
     59,221     60,919     65,269     70,687     73,477     74,419     75,367     81,181     82,171     87,211
     88,237     89,269     92,401     96,661    102,121    103,231    104,347    110,017    112,327    114,661
    115,837    126,691    129,169    131,671    135,469    140,617    144,541    145,861    151,201    155,269
    163,567    169,219    170,647    176,419    180,811    189,757    200,467    202,021    213,067    231,019
    234,361    241,117    246,247    251,431    260,191    263,737    267,307    276,337    279,991    283,669
    285,517    292,969    296,731    298,621    310,087    329,677    333,667    337,681    347,821    351,919
    360,187    368,551    372,769    374,887    377,011    383,419    387,721    398,581    407,377    423,001
    436,627    452,797    459,817    476,407    478,801    493,291    522,919    527,941    553,411    574,219
    584,767    590,077    592,741    595,411    603,457    608,851    611,557    619,711    627,919    650,071
    658,477    666,937    689,761    692,641    698,419    707,131    733,591    742,519    760,537    769,627
    772,669    784,897    791,047    812,761    825,301    837,937    847,477    863,497    879,667    886,177
    895,987    909,151    915,769    925,741    929,077    932,419    939,121    952,597    972,991    976,411
    986,707    990,151    997,057  1,021,417  1,024,921  1,035,469  1,074,607  1,085,407  1,110,817  1,114,471
  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
Computation time was 0.2989494 seconds

Snail Version[edit]

This one doesn't take any shortcuts. It could be sped up (Execution time about 15 seconds) by threading chunks of the search for the 100,000th cuban prime, but you would have to take a guess about how far to go, which would be hard-coded, so one might as well use the short-cut version if you are willing to overlook that difficulty.

Module Program
Dim primes As List(Of Long) = {3L, 5L}.ToList()
 
Sub Main(args As String())
Dim taskList As New List(Of Task(Of Integer))
Const cutOff As Integer = 200, bigUn As Integer = 100000,
chunks As Integer = 50, little As Integer = bigUn / chunks,
tn As String = " cuban prime"
Console.WriteLine("The first {0:n0}{1}s:", cutOff, tn)
Dim c As Integer = 0, showEach As Boolean = True,
u As Long = 0, v As Long = 1,
st As DateTime = DateTime.Now
For i As Long = 1 To Long.MaxValue
u += 6 : v += u
Dim found As Boolean = False, mx As Integer = Math.Ceiling(Math.Sqrt(v))
For Each item In primes
If item > mx Then Exit For
If v Mod item = 0 Then found = True : Exit For
Next : If Not found Then
c += 1 : If showEach Then
For z = primes.Last + 2 To v - 2 Step 2
Dim fnd As Boolean = False
For Each item In primes
If item > mx Then Exit For
If z Mod item = 0 Then fnd = True : Exit For
Next : If Not fnd Then primes.Add(z)
Next : primes.Add(v) : Console.Write("{0,11:n0}", v)
If c Mod 10 = 0 Then Console.WriteLine()
If c = cutOff Then showEach = False : _
Console.Write("{0}Progress to the {1:n0}th{2}: ", vbLf, bigUn, tn)
End If
If c Mod little = 0 Then Console.Write(".") : If c = bigUn Then Exit For
End If
Next
Console.WriteLine("{1}The {2:n0}th{3} is {0,17:n0}", v, vbLf, c, tn)
Console.WriteLine("Computation time was {0} seconds", (DateTime.Now - st).TotalSeconds)
If System.Diagnostics.Debugger.IsAttached Then Console.ReadKey()
End Sub
End Module
Output:
The first 200 cuban primes:
          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
      4,447      5,167      5,419      6,211      7,057      7,351      8,269      9,241     10,267     11,719
     12,097     13,267     13,669     16,651     19,441     19,927     22,447     23,497     24,571     25,117
     26,227     27,361     33,391     35,317     42,841     45,757     47,251     49,537     50,311     55,897
     59,221     60,919     65,269     70,687     73,477     74,419     75,367     81,181     82,171     87,211
     88,237     89,269     92,401     96,661    102,121    103,231    104,347    110,017    112,327    114,661
    115,837    126,691    129,169    131,671    135,469    140,617    144,541    145,861    151,201    155,269
    163,567    169,219    170,647    176,419    180,811    189,757    200,467    202,021    213,067    231,019
    234,361    241,117    246,247    251,431    260,191    263,737    267,307    276,337    279,991    283,669
    285,517    292,969    296,731    298,621    310,087    329,677    333,667    337,681    347,821    351,919
    360,187    368,551    372,769    374,887    377,011    383,419    387,721    398,581    407,377    423,001
    436,627    452,797    459,817    476,407    478,801    493,291    522,919    527,941    553,411    574,219
    584,767    590,077    592,741    595,411    603,457    608,851    611,557    619,711    627,919    650,071
    658,477    666,937    689,761    692,641    698,419    707,131    733,591    742,519    760,537    769,627
    772,669    784,897    791,047    812,761    825,301    837,937    847,477    863,497    879,667    886,177
    895,987    909,151    915,769    925,741    929,077    932,419    939,121    952,597    972,991    976,411
    986,707    990,151    997,057  1,021,417  1,024,921  1,035,469  1,074,607  1,085,407  1,110,817  1,114,471
  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

Progress to the 100,000th cuban prime: ..................................................
The 100,000th cuban prime is 1,792,617,147,127
Computation time was 49.5868152 seconds

k > 1 Version[edit]

A VB.NET version of the Perl 6 version where k > 1, linked at Try It Online!

zkl[edit]

Using GMP (GNU Multiple Precision Arithmetic Library, probabilistic primes), because it is easy and fast to test for primeness.

Extensible prime generator#zkl could be used instead.

var [const] BI=Import("zklBigNum");  // libGMP
cubans:=(1).walker(*).tweak('wrap(n){ // lazy iterator
p:=3*n*(n + 1) + 1;
BI(p).probablyPrime() and p or Void.Skip
});
println("First 200 cuban primes:");
do(20){ (10).pump(String, cubans.next, "%10,d".fmt).println() }
 
cubans.drop(100_000 - cubans.n).value :
println("\nThe 100,000th cuban prime is: %,d".fmt(_));
Output:
First 200 cuban primes:
         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
     4,447     5,167     5,419     6,211     7,057     7,351     8,269     9,241    10,267    11,719
    12,097    13,267    13,669    16,651    19,441    19,927    22,447    23,497    24,571    25,117
    26,227    27,361    33,391    35,317    42,841    45,757    47,251    49,537    50,311    55,897
    59,221    60,919    65,269    70,687    73,477    74,419    75,367    81,181    82,171    87,211
    88,237    89,269    92,401    96,661   102,121   103,231   104,347   110,017   112,327   114,661
   115,837   126,691   129,169   131,671   135,469   140,617   144,541   145,861   151,201   155,269
   163,567   169,219   170,647   176,419   180,811   189,757   200,467   202,021   213,067   231,019
   234,361   241,117   246,247   251,431   260,191   263,737   267,307   276,337   279,991   283,669
   285,517   292,969   296,731   298,621   310,087   329,677   333,667   337,681   347,821   351,919
   360,187   368,551   372,769   374,887   377,011   383,419   387,721   398,581   407,377   423,001
   436,627   452,797   459,817   476,407   478,801   493,291   522,919   527,941   553,411   574,219
   584,767   590,077   592,741   595,411   603,457   608,851   611,557   619,711   627,919   650,071
   658,477   666,937   689,761   692,641   698,419   707,131   733,591   742,519   760,537   769,627
   772,669   784,897   791,047   812,761   825,301   837,937   847,477   863,497   879,667   886,177
   895,987   909,151   915,769   925,741   929,077   932,419   939,121   952,597   972,991   976,411
   986,707   990,151   997,057 1,021,417 1,024,921 1,035,469 1,074,607 1,085,407 1,110,817 1,114,471
 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

Now lets get big.

k,z := BI(2).pow(128), 10;
println("First %d cuban primes where k = %,d:".fmt(z,k));
foreach n in ([BI(1)..]){
p:=( (k + n).pow(3) - n.pow(3) )/k;
if(p.probablyPrime()){ println("%,d".fmt(p)); z-=1; }
if(z<=0) break;
}
Output:
First 10 cuban primes where k = 340,282,366,920,938,463,463,374,607,431,768,211,456:
115,792,089,237,316,195,423,570,985,008,687,908,160,544,961,995,247,996,546,884,854,518,799,824,856,507
115,792,089,237,316,195,423,570,985,008,687,908,174,836,821,405,927,412,012,346,588,030,934,089,763,531
115,792,089,237,316,195,423,570,985,008,687,908,219,754,093,839,491,289,189,512,036,211,927,493,764,691
115,792,089,237,316,195,423,570,985,008,687,908,383,089,629,961,541,751,651,931,847,779,176,235,685,011
115,792,089,237,316,195,423,570,985,008,687,908,491,299,422,642,400,183,033,284,972,942,478,527,291,811
115,792,089,237,316,195,423,570,985,008,687,908,771,011,528,251,411,600,000,178,900,251,391,998,361,371
115,792,089,237,316,195,423,570,985,008,687,908,875,137,932,529,218,769,819,971,530,125,513,071,648,307
115,792,089,237,316,195,423,570,985,008,687,908,956,805,700,590,244,001,051,181,435,909,137,442,897,427
115,792,089,237,316,195,423,570,985,008,687,909,028,264,997,643,641,078,378,490,103,469,808,767,771,907
115,792,089,237,316,195,423,570,985,008,687,909,158,933,426,541,281,448,348,425,952,723,607,761,904,131