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.
  •   show all output here.


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


Also see
  •   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 <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

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
using Formatting, Primes
 
function cubanprimes(N)
cubans = zeros(BigInt, N)
cube100k = 0
cube1 = BigInt(1)
count = 1
for i in 1:100000000
j = BigInt(i + 1)
cube2 = j^3
diff = cube2 - cube1
if isprime(diff)
if count <= N
cubans[count] = diff
end
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 ", format(cube100k, commas=true))
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

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.

sub comma { $^i.flip.comb(3).join(',').flip }
 
my @cubans = lazy (1..Inf).hyper(:8degree).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

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(0, int(math.pow(2,20))):
found = False
u += 6
v += u
mx = int(math.sqrt(u))
 
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         91        127        169        217        271        331
        397        547        631        817        919      1,027      1,261      1,387      1,657      1,801
      1,951      2,269      2,437      2,791      3,169      3,571      3,781      4,219      4,447      4,681
      5,167      5,419      6,211      7,057      7,351      7,957      8,269      8,587      9,241      9,577
     10,267     10,981     11,719     12,097     12,871     13,267     13,669     14,491     16,651     17,557
     18,019     18,961     19,441     19,927     21,421     22,447     22,969     23,497     24,571     25,117
     26,227     26,791     27,361     30,301     30,907     31,519     32,761     33,391     34,669     35,317
     37,969     39,331     40,021     42,127     42,841     44,287     45,757     47,251     48,007     49,537
     50,311     52,669     53,467     55,897     58,381     59,221     60,919     61,777     62,641     64,387
     65,269     68,857     70,687     73,477     74,419     75,367     77,281     81,181     82,171     84,169
     87,211     88,237     89,269     92,401     95,587     96,661     98,827     99,919    102,121    103,231
    104,347    106,597    110,017    112,327    114,661    115,837    118,207    119,401    124,237    126,691
    129,169    131,671    132,931    135,469    138,031    140,617    141,919    144,541    145,861    147,187
    149,857    151,201    155,269    160,777    163,567    164,971    166,381    169,219    170,647    173,521
    176,419    180,811    183,769    185,257    189,757    200,467    202,021    205,147    213,067    217,891
    222,769    224,407    227,701    229,357    231,019    234,361    241,117    242,821    246,247    251,431
    253,171    260,191    263,737    265,519    267,307    270,901    276,337    279,991    283,669    285,517
    289,231    291,097    292,969    296,731    298,621    310,087    312,019    315,901    319,807    323,737
    329,677    333,667    337,681    343,747    347,821    351,919    360,187    362,269    368,551    372,769
    374,887    377,011    383,419    387,721    392,047    398,581    405,169    407,377    420,751    423,001
Progress to the 100,000th  cuban prime:..................................................
The 100,000th cuban prime is 391,406,072,461
Computation time was 7 seconds

REXX[edit]

/*REXX program finds and displays a number of  cuban  primes  or the  Nth  cuban prime. */
numeric digits 20 /*ensure enought 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 /*used for finding the Nth cuban prime.*/
#= 0 /*number of cuban primes found so far. */
!.=0;  !.0=1;  !.2=1;  !.3=1;  !.4=1;  !.5=1;  !.6=1;  !.8=1; s=41; $=
sw= linesize() - 1; if sw<1 then sw=79 /*obtain width of the terminal screen. */
if (Nth & N==1) | N>0 then $= 7 /*handle case of the 1st cuban prime.*/
if (Nth & N==2) | N>1 then $= $ 19 /* " " " " 2nd " " */
if (Nth & N==3) | N>2 then $= $ 37 /* " " " " 3rd " " */
#= 3 /*above are needed for prime generation*/
N= abs(N) /*use absolute value of N from now on*/
if #<N then /* [↑] ending digs that aren't cubans.*/
do j=4 until #=>N; x= (j+1)**3 - j**3 /*compute a possible cuban*/
parse var x '' -1 _; if !._ then iterate /*check for the last digit*/
if x// 3==0 then iterate; if x// 7==0 then iterate /* " " ÷ 3; for ÷ 7 */
if x//11==0 then iterate; if x//13==0 then iterate /* " " ÷11; " ÷ 13 */
if x//17==0 then iterate; if x//19==0 then iterate /* " " ÷17; " ÷ 19 */
if x//23==0 then iterate; if x//29==0 then iterate /* " " ÷23; " ÷ 29 */
if x//31==0 then iterate; if x//37==0 then iterate /* " " ÷31; " ÷ 37 */
 
do k=s by 6 until k*k>x /*skip multiples of 3 (when using BY 6)*/
if x// k ==0 then iterate j /*test for a "lower" possible prime. */
if x//(k+2) ==0 then iterate j /* " " " "higher" " " */
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
new=$ commas(x) /*append a new cuban. */
if length(new)>sw then do; say $ /*line too long, show #s*/
$= commas(x) /*initialize next line. */
end
else $= new /*use this longer output*/
end /*j*/
if S\=='' then say $ /*check for any residual*/
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 _
output   when using the default input of:     200
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

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