I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Cuban primes

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  (the country),   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.

•   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

`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
```

## Bracmat

Translation of: julia
`( ( cubanprimes  =      .   !arg:(?N.?bigN)      & :?cubans      & (0.1.1):(?cube100k.?cube1.?count)      & 0:?i      &   whl        ' ( 1+!i:?i          & !i+1:?j          & !j^3:?cube2          & !cube2+-1*!cube1:?diff          & ( !diff^1/2:~(!diff^?)            |   (   !count:~>!N                  & !diff !cubans:?cubans                |                 )              & ( !count:<!bigN                | !diff:?cube100k&~                )              & 1+!count:?count            )          & !cube2:?cube1          )      & ( columnwidth        =   cols          .   !arg:(%@:@(?:? [?cols)) ?            & div\$(-1+!cols.3)*4+1        )      & columnwidth\$!cubans:?colwidth      & \n:?table      & 0:?col      & ( format        =   n col cif R          .   !arg:(?n.?col)            & -1:?cif            &     vap                \$ ( (                     =                         .   (   mod\$(1+!cif:?cif.3):0                            & -2+!col:?col                            & ","                          | -1+!col:?col&                          )                          !arg                    )                  . rev\$!n                  )              : "," ?R            & rev\$(str\$!R):?R            &   whl              ' ( !col+-1:?col:>-2                & " " !R:?R                )            & str\$!R        )      &   whl        ' ( !cubans:%?cuban ?cubans          & mod\$(1+!col:?col.10):?col          &     (!col:0&\n|" ")                format\$(!cuban.!colwidth)                !table            : ?table          )      & out\$(str\$("The first " !N " cuban primes are: " !table))      &   out        \$ ( str          \$ ( "The 100,000th cuban prime is "              format\$(!cube100k.columnwidth\$!cube100k)            )          )  )& cubanprimes\$(200.100000))`
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```

## C

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

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#

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```

## C++

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```

## Common Lisp

Works with: sbcl version 1.1.14.debian
Works with: clisp version 2.49

For some reason, this solution is very slow: it takes about 10 minutes to find the 100,000th cuban number on sbcl and longer than I had the patience to wait on clisp. I thought this was due to my own `primep` function, so I tried to use `cl-primality:primep` from quicklisp. To my surprise, however, that was taking enen longer, so I went back to my own function. On the other hand, Common Lisp makes it a breeze to format the output with multiple columns, commas and all.

`;;; Show the first 200 and the 100,000th cuban prime.;;; Cuban primes are the difference of 2 consecutive cubes. (defun primep (n)  (cond ((< n 4) t)        ((evenp n) nil)        ((zerop (mod n 3)) nil)        (t (loop for i from 5 upto (isqrt n) by 6              when (or                     (zerop (mod n i))                     (zerop (mod n (+ i 2))))                return nil              finally (return t))))) (defun cube (n) (* n n n)) (defun cuban (n)  (loop for i from 1          for j from 2         for cube-diff = (- (cube j) (cube i))          when (primep cube-diff)             collect cube-diff into cuban-primes            and count i into counter          when (= counter n)            return cuban-primes))  (format t "~a~%" "1st to 200th cuban prime numbers:")(format t     "~{~<~%~,120:;~10:d ~>~}~%"    (cuban 200))  (format t "~%100,000th cuban prime number = ~:d"     (car (last (cuban 100000)))) (princ #\newline)`
Output:
```1st to 200th cuban prime numbers:
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 number = 1,792,617,147,127
```

## D

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```

See Pascal.

## F#

### The functions

This task uses Extensible Prime Generator (F#)

` // Generate cuban primes. Nigel Galloway: June 9th., 2019let 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)) `

` 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

Translation of: Sidef
`USING: formatting grouping io kernel lists lists.lazy mathmath.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
```

## Forth

` include ./miller-rabin.fs \ commatized print\: d.,r ( d n -- ) \ write double precision int, commatized.    >r tuck dabs    <# begin  2dup 1.000 d>  while  # # # [char] , hold  repeat #s rot sign #>    r> over - spaces type ; : .,r  ( n1 n2 -- ) \ write integer commatized.    >r s>d r> d.,r ;  \ generate and print cuban primes\: sq  s" dup *" evaluate ; immediate: next-cuban ( n -- n' p )    begin        1+ dup sq 3 * 1+ dup 3 and 0=  \ first check == 0 (mod 4)        if 2 rshift dup prime?            if exit            else drop            then        else drop        then    again ; : task1    1    20 0 do        cr 10 0 do            next-cuban 12 .,r        loop    loop drop ; : task2    cr ." The 100,000th cuban prime is "    1  99999 0 do next-cuban drop loop next-cuban 0 .,r drop ;  task1 crtask2 crbye `
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
```

## FreeBASIC

`function isprime( n as ulongint ) as boolean    if n mod 2 = 0 then return false    for i as uinteger = 3 to int(sqr(n))+1 step 2        if n mod i = 0 then return false    next i    return trueend function function diff_cubes( n as uinteger ) as ulongint    return 3*n*(n+1) + 1end function function padto( n as uinteger, s as integer ) as string    dim as string outstr=""    dim as integer k = len(str(n))    for i as integer = 1 to s-k        outstr = " " + outstr    next i    return outstr + str(n)end function dim as integer nc = 0, i = 1, diwhile nc < 100000    di = diff_cubes(i)    if isprime(di) then        nc += 1        if nc <= 200 then             print padto(di,8);" ";            if nc mod 10 = 0 then print        end if        if nc = 100000 then            print : print : print di            exit while        end if    end if    i += 1wend`
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
```

## Go

`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
```

## Groovy

Translation of: Java
`class CubanPrimes {    private static int MAX = 1_400_000    private static boolean[] primes = new boolean[MAX]     static void main(String[] args) {        preCompute()        cubanPrime(200, true)        for (int i = 1; i <= 5; i++) {            int max = (int) Math.pow(10, i)            printf("%,d-th cuban prime = %,d%n", max, cubanPrime(max, false))        }    }     private static long cubanPrime(int n, boolean display) {        int count = 0        long result = 0        for (long i = 0; count < n; i++) {            long test = 1l + 3 * i * (i + 1)            if (isPrime(test)) {                count++                result = test                if (display) {                    printf("%10s%s", String.format("%,d", test), count % 10 == 0 ? "\n" : "")                }            }        }        return result    }     private static boolean isPrime(long n) {        if (n < MAX) {            return primes[(int) n]        }        int max = (int) Math.sqrt(n)        for (int i = 3; i <= max; i++) {            if (primes[i] && n % i == 0) {                return false            }        }        return true    }     private static final void preCompute() {        //  primes        for (int i = 2; i < MAX; i++) {            primes[i] = true        }        for (int i = 2; i < MAX; i++) {            if (primes[i]) {                for (int j = 2 * i; j < MAX; j += i) {                    primes[j] = false                }            }        }    }}`
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-th cuban prime = 631
100-th cuban prime = 283,669
1,000-th cuban prime = 65,524,807
10,000-th cuban prime = 11,712,188,419
100,000-th cuban prime = 1,792,617,147,127```

`import Data.Numbers.Primes (isPrime)import Data.List (intercalate)import Data.List.Split (chunksOf)import Text.Printf (printf) cubans :: [Int]cubans = filter isPrime . map (\x -> (succ x ^ 3) - (x ^ 3)) \$ [1 ..] main :: IO ()main = do  mapM_ (\row -> mapM_ (printf "%10s" . thousands) row >> printf "\n") \$ rows cubans  printf "\nThe 100,000th cuban prime is: %10s\n" \$ thousands \$ cubans !! 99999  where    rows = chunksOf 10 . take 200    thousands = reverse . intercalate "," . chunksOf 3 . reverse . show`

Where filter over map could also be expressed in terms of concatMap, or a list comprehension:

`cubans :: [Int]cubans =    [ x    | n <- [1 ..]     , let x = (succ n ^ 3) - (n ^ 3)     , isPrime x ]`
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
```

## J

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 ydcc =: -&(^&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 dccassert 7 19 37 61 127 271 331 397 547 631 919 -: cubanPrime i. 20 NB. comatose copies with comma fillcomatose =: (#!.','~ (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 :01,0001,23812989,832)    CP =: cubanPrime i. 800000x   # CP  NB. tally, I've stored more than 100000 cuban primes103278   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┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐│        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│└─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘    NB. the one hundred thousandth cuban prime   comatose (<: 100000) { CP1,792,617,147,127     cubanPrime f.              NB. cubanPrime with fixed adverbs[: (#~ 1&p:) (-&(^&3)~ >:)  `

## Java

` public class CubanPrimes {     private static int MAX = 1_400_000;    private static boolean[] primes = new boolean[MAX];     public static void main(String[] args) {        preCompute();        cubanPrime(200, true);        for ( int i = 1 ; i <= 5 ; i++ ) {            int max = (int) Math.pow(10, i);            System.out.printf("%,d-th cuban prime = %,d%n", max, cubanPrime(max, false));        }    }     private static long cubanPrime(int n, boolean display) {        int count = 0;        long result = 0;        for ( long i = 0 ; count < n ; i++ ) {            long test = 1l + 3 * i * (i+1);            if ( isPrime(test) ) {                count++;                result = test;                if ( display ) {                    System.out.printf("%10s%s", String.format("%,d", test), count % 10 == 0 ? "\n" : "");                }            }        }        return result;    }     private static boolean isPrime(long n) {        if ( n < MAX ) {            return primes[(int)n];        }        int max = (int) Math.sqrt(n);        for ( int i = 3 ; i <= max ; i++ ) {            if ( primes[i] && n % i == 0 ) {                return false;            }        }        return true;    }     private static final void preCompute() {        //  primes        for ( int i = 2 ; i < MAX ; i++ ) {            primes[i] = true;                    }        for ( int i = 2 ; i < MAX ; i++ ) {            if ( primes[i] ) {                for ( int j = 2*i ; j < MAX ; j += i ) {                    primes[j] = false;                }            }        }    }} `
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-th cuban prime = 631
100-th cuban prime = 283,669
1,000-th cuban prime = 65,524,807
10,000-th cuban prime = 11,712,188,419
100,000-th cuban prime = 1,792,617,147,127
```

## jq

Works with: jq

Works with gojq, the Go implementation of jq

In this entry, the formula for the differences of cubes (2n(n+1)+1) is used, in part for efficiency and in part because the C implementation of jq has an upper bound of 2^53 for accurate integer arithmetic.

For a suitable implementation of `is_prime` see e.g. Erdős-primes#jq.

Preliminaries

`# input should be a non-negative integerdef commatize:  def digits: tostring | explode | reverse;  [foreach digits[] as \$d (-1; .+1;     (select(. > 0 and . % 3 == 0)|44), \$d)]     # "," is 44   | reverse | implode  ;  def count(stream): reduce stream as \$i (0; .+1); def lpad(\$len): tostring | (\$len - length) as \$l | (" " * \$l)[:\$l] + .; def nwise(\$n):  def n: if length <= \$n then . else .[0:\$n] , (.[\$n:] | n) end;  n;`

` # Emit an unbounded stream# The differences between successive cubes: 3n(n+1)+1def cubanprimes:  foreach range(1;infinite) as \$i (null;     (3 * \$i * (\$i + 1) + 1) as \$d     | if \$d|is_prime then \$d else null end;     select(.) ); (200 | "The first \(.) cuban primes are:", ([limit(.; cubanprimes) | commatize | lpad(10)] | nwise(10) | join(" "))), "\nThe 100,000th cuban prime is \(nth(100000 - 1; cubanprimes) | commatize)"`
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
```

## Julia

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

Translation of: D
`import kotlin.math.ceilimport 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```

## Lua

### Original

Translation of: D
`local primes = {3, 5}local cutOff = 200local bigUn = 100000local chunks = 50local little = math.floor(bigUn / chunks)local tn = " cuban prime"print(string.format("The first %d%ss", cutOff, tn))local showEach = truelocal c = 0local u = 0local v = 1for i=1,10000000000000 do    local found = false    u = u + 6    v = v + u    local mx = math.ceil(math.sqrt(v))    --for _,item in pairs(primes) do -- why: latent traversal bugfix (and performance), 6/11/2020 db    for _,item in ipairs(primes) do        if item > mx then            break        end        if v % item == 0 then            --print("[DEBUG] :( i = " .. i .. "; v = " .. v)            found = true            break        end    end    if not found then        --print("[DEBUG] :) i = " .. i .. "; v = " .. v)        c = c + 1        if showEach then            --local z = primes[table.getn(primes)] + 2 -- why: modernize (deprecated), 6/11/2020 db            local z = primes[#primes] + 2            while z <= v - 2 do                local fnd = false                --for _,item in pairs(primes) do -- why: latent traversal bugfix (and performance), 6/11/2020 db                for _,item in ipairs(primes) do                    if item > mx then                        break                    end                    if z % item == 0 then                        fnd = true                        break                    end                end                if not fnd then                    table.insert(primes, z)                end                z = z + 2            end            table.insert(primes, v)            io.write(string.format("%11d", v))            if c % 10 == 0 then                print()            end            if c == cutOff then                showEach = false                io.write(string.format("\nProgress to the %dth%s: ", bigUn, tn))            end        end        if c % little == 0 then            io.write(".")            if c == bigUn then                break            end        end    endend--print(string.format("\nThe %dth%s is %17d", c, tn, v)) -- why: correcting reported inaccuracy in output, 6/11/2020 dbprint(string.format("\nThe %dth%s is %.0f", 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```

### Alternate

Perhaps a more "readable" structure, and with specified formatting..

`-- cuban primes in Lua (alternate version 6/12/2020 db)-------------------- PRIME SUPPORT:------------------local sqrt, sieve, primes, N = math.sqrt, {false}, {}, 1400000for i = 2,N do sieve[i]=true endfor i = 2,N do if sieve[i] then for j=i*i,N,i do sieve[j]=false end end endfor i = 2,N do if sieve[i] then primes[#primes+1]=i end end; sieve=nillocal function isprime(n)  if (n <= 1) then return false end  local limit = sqrt(n)  for i,p in ipairs(primes) do    if (n % p == 0) then return false end    if (p > limit) then return true end  end  error("insufficient list of primes")end -------------------- PRINT SUPPORT:------------------local write, format = io.write, string.formatlocal function commafy(i) return tostring(i):reverse():gsub("(%d%d%d)","%1,"):reverse():gsub("^,","") end ------------------ ACTUAL TASK:----------------local COUNT, DOTAT, DOTPER, count, n = 100000, 200, 2000, 0, 0while (count < COUNT) do  local h = 3 * n * (n + 1) + 1 -- A003215  if (isprime(h)) then    count = count + 1    if (count <= DOTAT) then      write(format("%11s%s", commafy(h), count%10==0 and "\n" or ""))    elseif (count == COUNT) then      print(format("\n%s", commafy(h)))    elseif (count % DOTPER == 0) then      write(".")    end  end  n = n + 1end `
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```

## Maple

 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```

## Mathematica/Wolfram Language

`cubans[m_Integer] := Block[{n = 1, result = {}, candidate},  While[Length[result] < m,   n++;   candidate = n^3 - (n - 1)^3;   If[PrimeQ[candidate], AppendTo[result, candidate]]];  result]cubans[200]NumberForm[Last[cubans[100000]], NumberSeparator -> ",", DigitBlock -> 3]`
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}

3,432,424,324,232```

## Nim

Translation of: C#
`import strformatimport strutilsimport math const cutOff = 200const bigUn = 100000const chunks = 50const little = bigUn div chunks echo fmt"The first {cutOff} cuban primes"var primes: seq[int] = @[3, 5]var c, u = 0var showEach: bool = truevar v = 1for 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:        breakwrite(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

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

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
```

## Phix

Library: Phix/mpfr
```with javascript_semantics
include mpfr.e
integer np = 0,
i = 2
mpz p3 = mpz_init(1*1*1),
i3 = mpz_init(),
p = mpz_init(),
pn = mpz_init()

printf(1,"The first 200 cuban primes are:\n")
sequence first200 = {}
atom t0 = time()
constant lim = iff(platform()=JS?10000:100000)
while np<lim do
mpz_ui_pow_ui(i3,i,3)
mpz_sub(p,i3,p3)
if mpz_prime(p) 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)})
{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

Translation of: C#
` import datetimeimport math primes = [ 3, 5 ] cutOff = 200 bigUn =  100_000chunks = 50little = bigUn / chunks tn = " cuban prime"print ("The first {:,}{}s:".format(cutOff, tn)) c = 0showEach = Trueu = 0v = 1st = 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

`#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```

## Raku

(formerly Perl 6)

Library: ntheory

### The task (k == 1)

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

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

Note that Raku 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```

## REXX

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
```

## Ring

` load "stdlib.ring" sum = 0limit = 1000 see "First 200 cuban primes:" + nl for n = 1 to limit    pr = pow(n+1,3) - pow(n,3)    if isprime(pr)       sum = sum + 1       if sum < 201          see "" + pr + " "       else          exit       ok    oknext see "done..." + nl `

Output:

```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
```

## Ruby

`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?  endend 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

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

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.SafeLongimport spire.implicits._ import scala.annotation.tailrecimport 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

`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
```

## Transd

Translation of: Python
` #lang transd MainModule: {    primes: Vector<ULong>([3, 5]),    lim: 200,    bigUn: 100000,    chunks: 50,    little: 0,    c: 0,    showEach: true,    u: ULong(0),    v: ULong(1),     _start: (λ found Bool() fnd Bool() mx Int() z ULong()        (= little (/ bigUn chunks))        (for i in Range(1 (pow 2 20)) do            (= found false)            (+= u 6) (+= v u) (= mx (to-Int (sqrt v) 1))            (for item in primes do                (if (> item mx) break)                (if (not (mod v item)) (= found true)                     break))            (if (not found)                (+= c 1)                (if showEach                    (= z (get primes -1))                    (while (< z (- v 2))                        (+= z 2) (= fnd false)                        (for item in primes do                            (if (> item mx) break)                            (if (not (mod z item)) (= fnd true)                                break))                        (if (not fnd) (append primes z)))                    (append primes v)                    (textout :width 11 :group v)                    (if (not (mod c 10)) (textout :nl))                    (if (== c lim) (= showEach false)                         (textout "Progress to the " :group bigUn                                 "'th cuban prime:" ))                )                (if (not (mod c little)) (textout "."))                (if (== c bigUn) break)            )        )        (lout "The " :group c "'th cuban prime is " v )    )} `
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
Progress to the 100,000'th cuban prime:..................................................
The 100,000th cuban prime is 1,792,617,147,127
```

## Visual Basic .NET

### Corner Cutting Version

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 SubEnd 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

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 SubEnd 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

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

## Wren

Translation of: Python
Library: Wren-fmt
`import "/fmt" for Fmt var start = System.clockvar primes = [3, 5]var cutOff = 200var bigOne = 100000var cubans = []var bigCuban = ""var c = 0var showEach = truevar u = 0var v = 1 for (i in 1...(1<<20)) {     var found = false    u = u + 6    v = v + u    var mx = v.sqrt.floor    for (item in primes) {        if (item > mx) break        if (v%item == 0) {            found = true            break        }    }    if (!found) {        c = c + 1        if (showEach) {            var z = primes[-1]            while (z <= v -2) {                z = z + 2                var fnd = false                for (item in primes) {                    if (item > mx) break                    if (z%item == 0) {                        fnd = true                        break                    }                }                if (!fnd) {                    primes.add(z)                }            }            primes.add(v)            cubans.add(Fmt.commatize(v))            if (c == cutOff) showEach = false        }        if (c == bigOne) {            bigCuban = Fmt.commatize(v)            break        }    }} System.print("The first 200 cuban primes are:-")for (i in 0...20) {    var j = i * 10    for (k in j...j+10) System.write(Fmt.s(10, cubans[k])) // 10 per line say    System.print()} System.print("\nThe 100,000th cuban prime is %(bigCuban)")System.print("\nTook %(System.clock - start) secs")`
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

Took 623.849545 secs
```

## zkl

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");  // libGMPcubans:=(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
```