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)

Cubic Special Primes

From Rosetta Code
Cubic Special Primes is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task

n   is smallest prime such that the difference of successive terms are the smallest cubics of positive integers, where     n   <   15000.

F#[edit]

 
// Cubic Special Primes: Nigel Galloway. March 30th., 2021
let fN=let N=[for n in [0..25]->n*n*n] in let mutable n=2 in (fun g->match List.contains(g-n)N with true->n<-g; true |_->false)
primes32()|>Seq.takeWhile((>)16000)|>Seq.filter fN|>Seq.iter(printf "%d "); printfn ""
 
Output:
2 3 11 19 83 1811 2027 2243 2251 2467 2531 2539 3539 3547 4547 5059 10891 12619 13619 13627 13691 13907 14419

Go[edit]

Translation of: Wren
package main
 
import (
"fmt"
"math"
)
 
func sieve(limit int) []bool {
limit++
// True denotes composite, false denotes prime.
c := make([]bool, limit) // all false by default
c[0] = true
c[1] = true
// no need to bother with even numbers over 2 for this task
p := 3 // Start from 3.
for {
p2 := p * p
if p2 >= limit {
break
}
for i := p2; i < limit; i += 2 * p {
c[i] = true
}
for {
p += 2
if !c[p] {
break
}
}
}
return c
}
 
func isCube(n int) bool {
s := int(math.Cbrt(float64(n)))
return s*s*s == n
}
 
func commas(n int) string {
s := fmt.Sprintf("%d", n)
if n < 0 {
s = s[1:]
}
le := len(s)
for i := le - 3; i >= 1; i -= 3 {
s = s[0:i] + "," + s[i:]
}
if n >= 0 {
return s
}
return "-" + s
}
 
func main() {
c := sieve(14999)
fmt.Println("Cubic special primes under 15,000:")
fmt.Println(" Prime1 Prime2 Gap Cbrt")
lastCubicSpecial := 3
gap := 1
count := 1
fmt.Printf("%7d %7d %6d %4d\n", 2, 3, 1, 1)
for i := 5; i < 15000; i += 2 {
if c[i] {
continue
}
gap = i - lastCubicSpecial
if isCube(gap) {
cbrt := int(math.Cbrt(float64(gap)))
fmt.Printf("%7s %7s %6s %4d\n", commas(lastCubicSpecial), commas(i), commas(gap), cbrt)
lastCubicSpecial = i
count++
}
}
fmt.Println("\n", count+1, "such primes found.")
}
Output:
Same as Wren example.

Julia[edit]

using Primes
 
function cubicspecialprimes(N = 15000)
pmask = primesmask(1, N)
cprimes, maxidx = [2], isqrt(N)
while (n = cprimes[end]) < N
for i in 1:maxidx
q = n + i * i * i
if q > N
return cprimes
elseif pmask[q] # got next qprime
push!(cprimes, q)
break
end
end
end
end
 
println("Cubic special primes < 15000:")
foreach(p -> print(rpad(p[2], 6), p[1] % 10 == 0 ? "\n" : ""), enumerate(cubicspecialprimes()))
 
Output:
Cubic special primes < 16000:
2     3     11    19    83    1811  2027  2243  2251  2467  
2531  2539  3539  3547  4547  5059  10891 12619 13619 13627 
13691 13907 14419

Phix[edit]

See Quadrat_Special_Primes#Phix

Raku[edit]

A two character difference from the Quadrat Special Primes entry. (And it could have been one.)

my @sqp = 2, -> $previous {
my $next;
for (1..).map: *³ {
$next = $previous + $_;
last if $next.is-prime;
}
$next
}*;
 
say "{+$_} matching numbers:\n", $_».fmt('%5d').batch(7).join: "\n" given
@sqp[^(@sqp.first: * > 15000, :k)];
Output:
23 matching numbers:
    2     3    11    19    83  1811  2027
 2243  2251  2467  2531  2539  3539  3547
 4547  5059 10891 12619 13619 13627 13691
13907 14419

REXX[edit]

/*REXX program finds the smallest primes such that the difference of successive terms   */
/*───────────────────────────────────────────────────── are the smallest cubic numbers. */
parse arg hi cols . /*obtain optional argument from the CL.*/
if hi=='' | hi=="," then hi= 15000 /* " " " " " " */
if cols=='' | cols=="," then cols= 10 /* " " " " " " */
call genP /*build array of semaphores for primes.*/
w= 10 /*width of a number in any column. */
@cbp= 'the smallest primes < ' commas(hi) " such that the" ,
'difference of successive terma are the smallest cubic numbers'
if cols>0 then say ' index │'center(@cbp , 1 + cols*(w+1) )
if cols>0 then say '───────┼'center("" , 1 + cols*(w+1), '─')
cbp= 0; idx= 1 /*initialize number of cbp and index.*/
op= 1
$= /*a list of nice primes (so far). */
do j=0 by 0
do k=1 until !.np; np= op + k**3 /*find the next square + oldPrime.*/
if np>= hi then leave j /*Is newPrime too big? Then quit.*/
end /*k*/
cbp= cbp + 1 /*bump the number of cbp's. */
op= np /*assign the newPrime to the oldPrime*/
if cols==0 then iterate /*Build the list (to be shown later)? */
c= commas(np) /*maybe add commas to the number. */
$= $ right(c, max(w, length(c) ) ) /*add a nice prime ──► list, allow big#*/
if cbp//cols\==0 then iterate /*have we populated a line of output? */
say center(idx, 7)'│' substr($, 2); $= /*display what we have so far (cols). */
idx= idx + cols /*bump the index count for the output*/
end /*j*/
 
if $\=='' then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/
say
say 'Found ' commas(cbp) " of " @cbp
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?
/*──────────────────────────────────────────────────────────────────────────────────────*/
genP: !.= 0 /*placeholders for primes (semaphores).*/
@.1=2; @.2=3; @.3=5; @.4=7; @.5=11 /*define some low primes. */
 !.2=1;  !.3=1;  !.5=1;  !.7=1;  !.11=1 /* " " " " flags. */
#=5; s.#= @.# **2 /*number of primes so far; prime². */
/* [↓] generate more primes ≤ high.*/
do [email protected].#+2 by 2 to hi /*find odd primes from here on. */
parse var j '' -1 _; if _==5 then iterate /*J divisible by 5? (right dig)*/
if j// 3==0 then iterate /*" " " 3? */
if j// 7==0 then iterate /*" " " 7? */
/* [↑] the above five lines saves time*/
do k=5 while s.k<=j /* [↓] divide by the known odd primes.*/
if j // @.k == 0 then iterate j /*Is J ÷ X? Then not prime. ___ */
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; s.#= j*j;  !.j= 1 /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return
output   when using the default inputs:
 index │  the smallest primes  <  15,000  such that the difference of successive terma are the smallest cubic numbers
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │          2          3         11         19         83      1,811      2,027      2,243      2,251      2,467
  11   │      2,531      2,539      3,539      3,547      4,547      5,059     10,891     12,619     13,619     13,627
  21   │     13,691     13,907     14,419

Found  23  of  the smallest primes  <  15,000  such that the difference of successive terma are the smallest cubic numbers

Ring[edit]

Also see Quadrat_Special_Primes#Ring

 
load "stdlib.ring"
 
see "working..." + nl
 
Primes = []
limit1 = 50
oldPrime = 2
add(Primes,2)
 
for n = 1 to limit1
nextPrime = oldPrime + pow(n,3)
if isprime(nextPrime)
n = 1
add(Primes,nextPrime)
oldPrime = nextPrime
else
nextPrime = nextPrime - oldPrime
ok
next
 
see "prime1 prime2 Gap Cbrt" + nl
for n = 1 to Len(Primes)-1
diff = Primes[n+1] - Primes[n]
for m = 1 to diff
if pow(m,3) = diff
cbrt = m
exit
ok
next
see ""+ Primes[n] + " " + Primes[n+1] + " " + diff + " " + cbrt + nl
next
 
see "Found " + Len(Primes) + " of the smallest primes < 15,000 such that the difference of successive terma are the smallest cubic numbers" + nl
 
see "done..." + nl
 
Output:
working...
prime1 prime2 Gap Cbrt
2      3    1     1
3      11    8     2
11      19    8     2
19      83    64     4
83      1811    1728     12
1811      2027    216     6
2027      2243    216     6
2243      2251    8     2
2251      2467    216     6
2467      2531    64     4
2531      2539    8     2
2539      3539    1000     10
3539      3547    8     2
3547      4547    1000     10
4547      5059    512     8
5059      10891    5832     18
10891      12619    1728     12
12619      13619    1000     10
13619      13627    8     2
13627      13691    64     4
13691      13907    216     6
13907      14419    512     8
Found 23 of the smallest primes < 15,000  such that the difference of successive terma are the smallest cubic numbers
done...

Wren[edit]

Library: Wren-math
Library: Wren-fmt
import "/math" for Int, Math
import "/fmt" for Fmt
 
var isCube = Fn.new { |n|
var c = Math.cbrt(n).round
return c*c*c == n
}
 
var primes = Int.primeSieve(14999)
System.print("Cubic special primes under 15,000:")
System.print(" Prime1 Prime2 Gap Cbrt")
var lastCubicSpecial = 3
var gap = 1
var count = 1
Fmt.print("$,7d $,7d $,6d $4d", 2, 3, 1, 1)
for (p in primes.skip(2)) {
gap = p - lastCubicSpecial
if (isCube.call(gap)) {
Fmt.print("$,7d $,7d $,6d $4d", lastCubicSpecial, p, gap, Math.cbrt(gap).round)
lastCubicSpecial = p
count = count + 1
}
}
System.print("\n%(count+1) such primes found.")
Output:
Cubic special primes under 15,000:
 Prime1  Prime2    Gap  Cbrt
      2       3      1    1
      3      11      8    2
     11      19      8    2
     19      83     64    4
     83   1,811  1,728   12
  1,811   2,027    216    6
  2,027   2,243    216    6
  2,243   2,251      8    2
  2,251   2,467    216    6
  2,467   2,531     64    4
  2,531   2,539      8    2
  2,539   3,539  1,000   10
  3,539   3,547      8    2
  3,547   4,547  1,000   10
  4,547   5,059    512    8
  5,059  10,891  5,832   18
 10,891  12,619  1,728   12
 12,619  13,619  1,000   10
 13,619  13,627      8    2
 13,627  13,691     64    4
 13,691  13,907    216    6
 13,907  14,419    512    8

23 such primes found.