Sum of primes in odd positions is prime
Sum of primes in odd positions is prime 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
Let p(i) be a sequence of prime numbers. such that 2=p(1), 3=p(2), 5=p(3), ...
Consider the p(1),p(3),p(5), ... ,p(i), for each p(i) < 1,000 and i is odd.
Let sum be any prefix sum of these primesa.
If sum is prime then print i, p(i) and sum.
11l
F is_prime(n)
I n == 2
R 1B
I n < 2 | n % 2 == 0
R 0B
L(i) (3 .. Int(sqrt(n))).step(2)
I n % i == 0
R 0B
R 1B
print(‘ i p(i) sum’)
V idx = 0
V s = 0
V p = 1
L p < 1000
p++
I is_prime(p)
idx++
I idx % 2 != 0
s += p
I is_prime(s)
print(f:‘{idx:3} {p:3} {s:5}’)- Output:
i p(i) sum 1 2 2 3 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879
Action!
INCLUDE "D2:PRINTF.ACT" ;from the Action! Tool Kit
BYTE FUNC IsPrime(CARD x)
CARD i,max
i=2 max=x/2
WHILE i<=max
DO
IF x MOD i=0 THEN
RETURN (0)
FI
i==+1
OD
RETURN (1)
PROC Main()
CARD x,count,sum
CHAR ARRAY s(6)
Put(125) PutE() ;clear the screen
PrintF("%3S%5S%6S%E","i","p(i)","sum")
count=0 sum=0
FOR x=2 TO 999
DO
IF IsPrime(x) THEN
count==+1
IF (count&1)=1 THEN
sum==+x
IF IsPrime(sum) THEN
StrC(count,s) PrintF("%3S",s)
StrC(x,s) PrintF("%5S",s)
StrC(sum,s) PrintF("%6S%E",s)
FI
FI
FI
OD
RETURN- Output:
Screenshot from Atari 8-bit computer
i p(i) sum 1 2 2 3 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879
ALGOL 68
BEGIN # find primes (up to 999) p(i) for odd i such that the sum of primes p(j), j = 1, 3, 5, ..., i is prime #
PR read "primes.incl.a68" PR
INT max prime = 999;
[]BOOL prime = PRIMESIEVE 50 000; # guess that the max sum will be <= 50 000 #
[]INT low prime = EXTRACTPRIMESUPTO max prime FROMPRIMESIEVE prime; # get a list of primes up to max prime #
# find the sums of the odd primes and test for primality #
print( ( " i p[i] sum", newline ) );
INT odd prime sum := 0;
FOR i BY 2 TO UPB low prime DO
IF odd prime sum +:= low prime[ i ];
IF odd prime sum <= UPB prime
THEN
prime[ odd prime sum ]
ELSE
print( ( "Need more primes: ", whole( odd prime sum, 0 ), newline ) );
FALSE
FI
THEN
print( ( whole( i, -3 ), " ", whole( low prime[ i ], -4 ), " ", whole( odd prime sum, -6 ), newline ) )
FI
OD
END- Output:
i p[i] sum 1 2 2 3 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879
Arturo
print " i | p(i) sum"
print repeat "-" 17
idx: 0
sm: 0
p: 1
while [p < 1000][
inc 'p
if prime? p [
inc 'idx
if odd? idx [
sm: sm + p
if prime? sm ->
print (pad to :string idx 4) ++ " | " ++ (pad to :string p 3) ++ (pad to :string sm 6)
]
]
]
- Output:
i | p(i) sum ----------------- 1 | 2 2 3 | 5 7 11 | 31 89 27 | 103 659 35 | 149 1181 67 | 331 5021 91 | 467 9923 95 | 499 10909 99 | 523 11941 119 | 653 17959 143 | 823 26879
AWK
# syntax: GAWK -f SUM_OF_PRIMES_IN_ODD_POSITIONS_IS_PRIME.AWK
# converted from Ring
BEGIN {
print(" i p sum")
print("------ ------ ------")
start = 2
stop = 999
for (i=start; i<=stop; i++) {
if (is_prime(i)) {
if (++nr % 2 == 1) {
sum += i
if (is_prime(sum)) {
count++
printf("%6d %6d %6d\n",nr,i,sum)
}
}
}
}
printf("Odd indexed primes %d-%d: %d\n",start,stop,count)
exit(0)
}
function is_prime(x, i) {
if (x <= 1) {
return(0)
}
for (i=2; i<=int(sqrt(x)); i++) {
if (x % i == 0) {
return(0)
}
}
return(1)
}
- Output:
i p sum
------ ------ ------
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
Odd indexed primes 2-999: 11
C
#include<stdio.h>
#include<stdlib.h>
int isprime( int p ) {
int i;
if(p==2) return 1;
if(!(p%2)) return 0;
for(i=3; i*i<=p; i+=2) {
if(!(p%i)) return 0;
}
return 1;
}
int main( void ) {
int s=0, p, i=1;
for(p=2;p<=999;p++) {
if(isprime(p)) {
if(i%2) {
s+=p;
if(isprime(s)) printf( "%d %d %d\n", i, p, s );
}
i+=1;
}
}
return 0;
}
Delphi
Uses the Delphi Prime-Generator Object
procedure SumOddPrimes(Memo: TMemo);
var Sieve: TPrimeSieve;
var I,Inx, Sum: integer;
begin
Sieve:=TPrimeSieve.Create;
try
Sieve.Intialize(100000);
Memo.Lines.Add(' I P(I) Sum');
Memo.Lines.Add('---------------');
I:=0;
Sum:=0;
while Sieve.Primes[I]<1000 do
begin
Sum:=Sum+Sieve.Primes[I];
if Sieve.Flags[Sum] then
begin
Memo.Lines.Add(Format('%3d %4d %6d',[I,Sieve.Primes[I],Sum]));
end;
Inc(I,2);
end;
finally Sieve.Free; end;
end;
- Output:
I P(I) Sum --------------- 0 2 2 2 5 7 10 31 89 26 103 659 34 149 1181 66 331 5021 90 467 9923 94 499 10909 98 523 11941 118 653 17959 142 823 26879 Elapsed Time: 16.077 ms.
F#
This task uses Extensible Prime Generator (F#)
// Sum of primes in odd positions is prime. Nigel Galloway: November 9th., 2021
primes32()|>Seq.chunkBySize 2|>Seq.mapi(fun n g->(2*n+1,g.[0]))|>Seq.scan(fun(n,i,g)(e,l)->(e,l,g+l))(0,0,0)|>Seq.takeWhile(fun(_,n,_)->n<1000)|>Seq.filter(fun(_,_,n)->isPrime n)|>Seq.iter(fun(n,g,l)->printfn $"i=%3d{n} p[i]=%3d{g} sum=%5d{l}")
- Output:
i= 1 p[i]= 2 sum= 2 i= 3 p[i]= 5 sum= 7 i= 11 p[i]= 31 sum= 89 i= 27 p[i]=103 sum= 659 i= 35 p[i]=149 sum= 1181 i= 67 p[i]=331 sum= 5021 i= 91 p[i]=467 sum= 9923 i= 95 p[i]=499 sum=10909 i= 99 p[i]=523 sum=11941 i=119 p[i]=653 sum=17959 i=143 p[i]=823 sum=26879
Factor
USING: assocs assocs.extras kernel math.primes math.statistics
prettyprint sequences.extras ;
1000 primes-upto <evens> dup cum-sum zip [ prime? ] filter-values .
- Output:
{
{ 2 2 }
{ 5 7 }
{ 31 89 }
{ 103 659 }
{ 149 1181 }
{ 331 5021 }
{ 467 9923 }
{ 499 10909 }
{ 523 11941 }
{ 653 17959 }
{ 823 26879 }
}
Fermat
s:=0;
for ii=0 to 83 do oi:=1+2*ii;s:=s+Prime(oi);if Isprime(s)=1 then !!(oi, Prime(oi), s) fi od;FreeBASIC
#include "isprime.bas"
dim as uinteger i = 1, p, sum = 0
for p = 2 to 999
if isprime(p) then
if i mod 2 = 1 then
sum += p
if isprime(sum) then print i, p, sum
end if
i = i + 1
end if
next pGo
package main
import (
"fmt"
"rcu"
)
func main() {
primes := rcu.Primes(999)
sum := 0
fmt.Println(" i p[i] Σp[i]")
fmt.Println("----------------")
for i := 0; i < len(primes); i += 2 {
sum += primes[i]
if rcu.IsPrime(sum) {
fmt.Printf("%3d %3d %6s\n", i+1, primes[i], rcu.Commatize(sum))
}
}
}
- Output:
i p[i] Σp[i] ---------------- 1 2 2 3 5 7 11 31 89 27 103 659 35 149 1,181 67 331 5,021 91 467 9,923 95 499 10,909 99 523 11,941 119 653 17,959 143 823 26,879
GW-BASIC
10 S = 2
20 A = 1
30 PRINT 1, 2, 2
40 FOR P = 3 TO 999 STEP 2
50 GOSUB 90
60 IF Q=1 THEN GOSUB 190
70 NEXT P
80 END
90 Q=0
100 IF P=3 THEN Q=1:RETURN
110 IF P = 2 THEN Q = 1: RETURN
120 IF INT(P/2)*2= P THEN Q = 0: RETURN
130 I=1
140 I=I+2
150 IF INT(P/I)*I = P THEN RETURN
160 IF I*I<=P THEN GOTO 140
170 Q = 1
180 RETURN
190 A = A + 1
200 IF A MOD 2 = 0 THEN RETURN
210 S = S + P
220 T = P
230 P = S
240 GOSUB 90
250 IF Q = 1 THEN PRINT A, T, S
260 P = T
270 RETURNJ
(i,.p,.sum) #~ 1 p: sum=. +/\p=. p:<:i=. (#~ 2|])i. 1+p:inv 1000
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
jq
Works with gojq, the Go implementation of jq See e.g. Erdős-primes#jq for a suitable implementation of `is_prime`.
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
def task:
[2, (range(3;1000;2)|select(is_prime))]
| [.[range(0;length;2)]]
| . as $oddPositionPrimes
| foreach range(0; length) as $i ({i: -1};
.i += 2
| .sum += $oddPositionPrimes[$i];
select(.sum|is_prime)
| "\(.i|lpad(3)) \($oddPositionPrimes[$i]|lpad(3)) \(.sum|lpad(5))" ) ;
" i p[$i] sum", task- Output:
i p[$i] sum 1 2 2 3 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879
Julia
using Primes
p = primes(1000)
arr = filter(n -> isprime(n[2]), accumulate((x, y) -> (y, x[2] + y), p[1:2:length(p)], init = (0, 0)))
println(join(arr, "\n"))
- Output:
(2, 2) (5, 7) (31, 89) (103, 659) (149, 1181) (331, 5021) (467, 9923) (499, 10909) (523, 11941) (653, 17959) (823, 26879)
Mathematica/Wolfram Language
p = Prime[Range[1, PrimePi[1000], 2]];
p = {p, Accumulate[p]} // Transpose;
Select[p, Last /* PrimeQ]
- Output:
{{2,2},{5,7},{31,89},{103,659},{149,1181},{331,5021},{467,9923},{499,10909},{523,11941},{653,17959},{823,26879}}
Nim
import strformat
template isOdd(n: Natural): bool = (n and 1) != 0
template isEven(n: Natural): bool = (n and 1) == 0
func isPrime(n: Positive): bool =
if n == 1: return false
if n.isEven: return n == 2
if n mod 3 == 0: return n == 3
var d = 5
while d * d <= n:
if n mod d == 0: return false
inc d, 2
if n mod d == 0: return false
inc d, 4
result = true
# Compute the sums of primes at odd position.
echo " i p(i) sum"
var idx = 0
var sum = 0
var p = 1
while p < 1000:
inc p
if p.isPrime:
inc idx
if idx.isOdd:
inc sum, p
if sum.isPrime:
echo &"{idx:3} {p:3} {sum:5}"
- Output:
i p(i) sum 1 2 2 3 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879
OCaml
let is_prime n =
let rec test x =
let q = n / x in x > q || x * q <> n && n mod (x + 2) <> 0 && test (x + 6)
in if n < 5 then n lor 1 = 3 else n land 1 <> 0 && n mod 3 <> 0 && test 5
let () = Seq.ints 3
|> Seq.filter is_prime
|> Seq.take_while ((>) 1000)
|> Seq.zip (Seq.ints 2)
|> Seq.filter (fun (i, _) -> i land 1 = 1)
|> Seq.scan (fun (_, pi, sum) (i, p) -> i, p, sum + p) (1, 2, 2)
|> Seq.filter (fun (_, _, sum) -> is_prime sum)
|> Seq.iter (fun (i, pi, sum) -> Printf.printf "p(%u) = %u, %u\n" i pi sum)
- Output:
p(1) = 2, 2 p(3) = 5, 7 p(11) = 31, 89 p(27) = 103, 659 p(35) = 149, 1181 p(67) = 331, 5021 p(91) = 467, 9923 p(95) = 499, 10909 p(99) = 523, 11941 p(119) = 653, 17959 p(143) = 823, 26879
PARI-GP
sm=0;for(ii=0, 83, oi=1+2*ii;sm=sm+prime(oi);if(isprime(sm),print(oi," ", prime(oi)," ",sm)))- Output:
1 2 2 3 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879
Perl
use strict;
use warnings;
use ntheory 'is_prime';
my $c;
my @odd = grep { 0 != ++$c % 2 } grep { is_prime $_ } 2 .. 999;
my @sums = $odd[0];
push @sums, $sums[-1] + $_ for @odd[1..$#odd];
$c = 1;
for (0..$#sums) {
printf "%6d%6d%6d\n", $c, $odd[$_], $sums[$_] if is_prime $sums[$_];
$c += 2;
}
- Output:
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
Phix
with javascript_semantics sequence primes = get_primes_le(1000) integer total = 0 printf(1," i p sum\n") printf(1,"----------------\n") for i=1 to length(primes) by 2 do total += primes[i] if is_prime(total) then printf(1,"%3d %3d %,6d\n", {i, primes[i], total}) end if end for
- Output:
i p sum ---------------- 1 2 2 3 5 7 11 31 89 27 103 659 35 149 1,181 67 331 5,021 91 467 9,923 95 499 10,909 99 523 11,941 119 653 17,959 143 823 26,879
Quackery
isprime is defined at Primality by trial division#Quackery.
[ dip number$
over size -
space swap of
swap join echo$ ] is justify ( n n --> )
[] 1000 times
[ i^ isprime if [ i^ join ] ]
[] swap witheach
[ i^ 1 & 0 = iff join else drop ]
0 swap witheach
[ tuck + dup isprime if
[ i^ 2 * 1+ 3 justify
over 5 justify
dup 7 justify
cr ]
nip ]
drop- Output:
1 2 2 3 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879
Raku
my @odd = grep { ++$ !%% 2 }, grep &is-prime, 2 ..^ 1000;
my @sums = [\+] @odd;
say .fmt('%5d') for grep { .[2].is-prime }, ( (1,3…*) Z @odd Z @sums );
- Output:
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
REXX
/*REXX pgm shows a prime index, the prime, & sum of odd indexed primes when sum is prime*/
parse arg hi . /*obtain optional argument from the CL.*/
if hi=='' | hi=="," then hi= 1000 /*Not specified? Then use the default.*/
call genP /*build array of semaphores for primes.*/
title= 'odd indexed primes the sum of the odd indexed primes'
say ' index │'center(title, 65)
say '───────┼'center("" , 65, '─')
found= 0 /*initialize # of odd indexed primes···*/
$= 0 /*sum of odd indexed primes (so far). */
do j=1 by 2; p= @.j; if p>hi then leave /*find odd indexed primes, sum = prime.*/
$= $ + p /*add this odd index prime to the sum. */
if \!.$ then iterate /*This sum not prime? Then skip it. */
found= found + 1 /*bump the number of solutions found. */
say center(j, 7)'│' right( commas(p), 13) right( commas($), 33)
end /*j*/
say '───────┴'center("" , 65, '─')
say
say 'Found ' commas(found) ' 'subword(title, 1, 3)
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: @.1=2; @.2=3; @.3=5; @.4=7; @.5=11 /*define some low primes. */
!.=0; !.2=1; !.3=1; !.5=1; !.7=1; !.11=1 /* " " " " semaphores. */
#=5; sq.#= @.# ** 2 /*number of primes so far; prime². */
do j=@.#+2 by 2 to hi*33; parse var j '' -1 _ /*obtain the last decimal dig.*/
if _==5 then iterate; if j//3==0 then iterate; if j//7==0 then iterate
do k=5 while sq.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; sq.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return
- output when using the default inputs:
index │ odd indexed primes the sum of the odd indexed primes ───────┼───────────────────────────────────────────────────────────────── 1 │ 2 2 3 │ 5 7 11 │ 31 89 27 │ 103 659 35 │ 149 1,181 67 │ 331 5,021 91 │ 467 9,923 95 │ 499 10,909 99 │ 523 11,941 119 │ 653 17,959 143 │ 823 26,879 ───────┴───────────────────────────────────────────────────────────────── Found 11 odd indexed primes
Ring
load "stdlib.ring"
see "working..." + nl
see "i p sum" + nl
nr = 0
sum = 0
limit = 1000
for n = 2 to limit
if isprime(n)
nr++
if nr%2 = 1
sum += n
if isprime(sum)
see "" + nr + " " + n + " " + sum + nl
ok
ok
ok
next
see "done..." + nl- Output:
working... i p sum 1 2 2 3 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879 done...
RPL
≪ → max
≪ { } 0 2
1 max FOR j
SWAP OVER + SWAP
IF OVER ISPRIME? THEN
j OVER 4 PICK →V3
4 ROLL SWAP + UNROT
END
NEXTPRIME NEXTPRIME
IF DUP max ≥ THEN max 'j' STO END
2 STEP
DROP2
≫ ≫ 'TASK' STO
1000 TASK
- Output:
1:. {[1. 2. 2.] [3. 5. 7.] [11. 31. 89.] [27. 103. 659.] [35. 149. 1181.] [67. 331. 5021.] [91. 467. 9923.] [95. 499. 10909.] [99. 523. 11941.] [119. 653. 17959.] [143. 823. 26879.]}
Ruby
require 'prime'
sum = 0
Prime.each(1000).with_index(1).each_slice(2) do |(odd_i, i),(_)|
puts "%6d%6d%6d" % [i, odd_i, sum] if (sum += odd_i).prime?
end
- Output:
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
Sidef
var sum = 0
1e3.primes.each_kv {|k,v|
if (k+1 -> is_odd) {
sum += v
say "#{k+1} #{v} #{sum}" if sum.is_prime
}
}
- Output:
1 2 2 3 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879
Tiny BASIC
LET I = 0
LET S = 0
LET P = 1
10 LET P = P + 1
LET X = P
GOSUB 100
IF Z = 1 THEN LET I = I + 1
IF Z = 0 THEN GOTO 20
IF (I/2)*2<>I THEN GOSUB 200
20 IF P<917 THEN GOTO 10 REM need to cheat a little to avoid overflow
END
100 REM is X a prime? Z=1 for yes, 0 for no
LET Z = 1
IF X = 3 THEN RETURN
IF X = 2 THEN RETURN
LET A = 1
110 LET A = A + 1
IF (X/A)*A = X THEN GOTO 120
IF A*A<=X THEN GOTO 110
RETURN
120 LET Z = 0
RETURN
200 LET S = S + P
LET X = S
GOSUB 100
IF Z = 1 THEN PRINT I," ", P," ", S
RETURN- Output:
1 2 23 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879
Wren
import "./math" for Int
import "./iterate" for Indexed
import "./fmt" for Fmt
var primes = Int.primeSieve(999)
var sum = 0
System.print(" i p[i] Σp[i]")
System.print("----------------")
for (se in Indexed.new(primes, 2)) {
sum = sum + se.value
if (Int.isPrime(sum)) Fmt.print("$3d $3d $,6d", se.index + 1, se.value, sum)
}
- Output:
i p[i] Σp[i] ---------------- 1 2 2 3 5 7 11 31 89 27 103 659 35 149 1,181 67 331 5,021 91 467 9,923 95 499 10,909 99 523 11,941 119 653 17,959 143 823 26,879
XPL0
func IsPrime(N); \Return 'true' if N is a prime number
int N, I;
[if N <= 1 then return false;
for I:= 2 to sqrt(N) do
if rem(N/I) = 0 then return false;
return true;
];
int I, Sum, N;
[Text(0, "p(n) sum^m^j");
Sum:= 0; I:= 0;
for N:= 2 to 1000-1 do
[if IsPrime(N) then
[I:= I+1;
if I&1 then \odd
[Sum:= Sum + N;
if IsPrime(Sum) then
[IntOut(0, N); ChOut(0, ^ ); IntOut(0, Sum); CrLf(0)];
];
];
];
]- Output:
p(n) sum 2 2 5 7 31 89 103 659 149 1181 331 5021 467 9923 499 10909 523 11941 653 17959 823 26879
Yabasic
// Rosetta Code problem: http://rosettacode.org/wiki/Sum_of_primes_in_odd_positions_is_prime
// by Galileo, 04/2022
sub isPrime(n)
local i
if n < 4 return n >= 2
for i = 2 to sqrt(n)
if not mod(n, i) return false
next
return true
end sub
print "i\tp(n)\tsum\n----\t-----\t------"
for n = 1 to 1000
if isPrime(n) then
i = i + 1
if mod(i, 2) then
sum = sum + n
if isPrime(sum) print i, "\t", n, "\t", sum
end if
end if
next- Output:
i p(n) sum ---- ----- ------ 1 2 2 3 5 7 11 31 89 27 103 659 35 149 1181 67 331 5021 91 467 9923 95 499 10909 99 523 11941 119 653 17959 143 823 26879 ---Program done, press RETURN---
Categories:
- Draft Programming Tasks
- Prime Numbers
- 11l
- Action!
- Action! Tool Kit
- ALGOL 68
- ALGOL 68-primes
- Arturo
- AWK
- C
- Delphi
- SysUtils,StdCtrls
- F Sharp
- Factor
- Fermat
- FreeBASIC
- Go
- Go-rcu
- GW-BASIC
- J
- Jq
- Julia
- Mathematica
- Wolfram Language
- Nim
- OCaml
- PARI-GP
- Perl
- Ntheory
- Phix
- Quackery
- Raku
- REXX
- Ring
- RPL
- Ruby
- Sidef
- Tiny BASIC
- Wren
- Wren-math
- Wren-iterate
- Wren-fmt
- XPL0
- Yabasic