Cubic special primes: Difference between revisions

{{trans|FreeBASIC}}

 

I a == 2

R 1B

print(p, end' ‘ ’)

E

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Sieve of Eratosthenes}}

 

PROC Main()

OD

PrintF("%E%EThere are %I cubic special primes",count)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Cubic_Special_Primes.png Screenshot from Atari 8-bit computer]

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

{{libheader|ALGOL 68-primes}}

INT max prime = 15 000;

# sieve the primes to max prime #

OD;

print( ( newline ) )

{{out}}

<pre>

 

=={{header|ALGOL W}}==

integer MAX_PRIME, MAX_CUBE;

MAX_PRIME := 15000;

end;

write()

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f CUBIC_SPECIAL_PRIMES.AWK

# converted from FreeBASIC

return(1)

}

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

// 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 ""

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.98}}

math.primes prettyprint ;

 

2 [ 1 lfrom swap '[ 3 ^ _ + ] lmap-lazy [ prime? ] lfilter car ]

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

#include once "isprime.bas"

 

loop until p + n^3 >= 15000

print

{{out}}<pre>

2 3 11 19 83 1811 2027 2243 2251 2467 2531 2539 3539 3547 4547 5059 10891 12619 13619 13627 13691 13907 14419

=={{header|Go}}==

{{trans|Wren}}

 

import (

}

fmt.Println("\n", count+1, "such primes found.")

 

{{out}}

'''Works with gojq, the Go implementation of jq'''

 

def cubic_special_primes:

. as $N

15000

| ("Cubic special primes < \(.):",

{{out}}

<pre>

 

=={{header|Julia}}==

 

function cubicspecialprimes(N = 15000)

println("Cubic special primes < 15000:")

foreach(p -> print(rpad(p[2], 6), p[1] % 10 == 0 ? "\n" : ""), enumerate(cubicspecialprimes()))

<pre>

Cubic special primes < 16000:

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Do[

If[PrimeQ[i],

{i, 3, 15000}

]

{{out}}

<pre>{2,3,11,19,83,1811,2027,2243,2251,2467,2531,2539,3539,3547,4547,5059,10891,12619,13619,13627,13691,13907,14419}</pre>

=={{header|Nim}}==

{{trans|Go}}

 

func sieve(limit: Positive): seq[bool] =

lastCubicSpecial = n

inc count

 

{{out}}

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature 'say';

} until $sp[-1] >= 15000;

 

{{out}}

<pre>2 3 11 19 83 1811 2027 2243 2251 2467 2531 2539 3539 3547 4547 5059 10891 12619 13619 13627 13691 13907 14419</pre>

 

=={{header|Python}}==

 

def isPrime(n):

n += 1

if p + n**3 >= 15000:

{{out}}

<pre>2 3 11 19 83 1811 2027 2243 2251 2467 2531 2539 3539 3547 4547 5059 10891 12619 13619 13627 13691 13907 14419</pre>

=={{header|Raku}}==

A two character difference from the [[Quadrat_Special_Primes#Raku|Quadrat Special Primes]] entry. (And it could have been one.)

my $next;

for (1..∞).map: *³ {

 

say "{+$_} matching numbers:\n", $_».fmt('%5d').batch(7).join: "\n" given

{{out}}

<pre>23 matching numbers:

 

=={{header|REXX}}==

/*───────────────────────────────────────────────────── are the smallest cubic numbers. */

parse arg hi cols . /*obtain optional argument from the CL.*/

end /*k*/ /* [↑] only process numbers ≤ √ J */

#= #+1; @.#= j; s.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ring}}==

Also see [[Quadrat_Special_Primes#Ring]]

load "stdlib.ring"

 

see "done..." + nl

{{out}}

<pre>

 

=={{header|Sidef}}==

 

var prev = 2

take(k)

})

{{out}}

<pre>

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

 

}

}

 

{{out}}

 

=={{header|XPL0}}==

int N, I;

[if N <= 2 then return N = 2;

];

until N > 15000;

 

{{out}}