Rosetta Code

Piprimes: Difference between revisions

Page Discussion

Piprimes (view source)

Revision as of 12:03, 25 January 2024

8,813 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|REXX}}: changed whitespace and comments, added a foot separator for the output.)
m (→‎{{header|Wren}}: Minor tidy)
 
(19 intermediate revisions by 14 users not shown)
Line 11:
:* &nbsp; the OEIS entry: &nbsp; [http://oeis.org/A000720 A0000720 pi(n), the number of primes <= n. Sometimes called PrimePi(n)...].
<br><br>
 
=={{header|11l}}==
{{trans|Nim}}
 
<syntaxhighlight lang="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
 
V pi = 0
V n = 1
L
print(‘#2’.format(pi), end' I n % 10 == 0 {"\n"} E ‘ ’)
n++
I is_prime(n)
pi++
I pi == 22
L.break
print()</syntaxhighlight>
 
{{out}}
<pre>
0 1 2 2 3 3 4 4 4 4
5 5 6 6 6 6 7 7 8 8
8 8 9 9 9 9 9 9 10 10
11 11 11 11 11 11 12 12 12 12
13 13 14 14 14 14 15 15 15 15
15 15 16 16 16 16 16 16 17 17
18 18 18 18 18 18 19 19 19 19
20 20 21 21 21 21 21 21
</pre>
 
=={{header|Action!}}==
{{libheader|Action! Sieve of Eratosthenes}}
<syntaxhighlight lang="action!">INCLUDE "H6:SIEVE.ACT"
 
PROC Main()
DEFINE MAX="100"
BYTE ARRAY primes(MAX+1)
INT n=[0],p=[1]
 
Put(125) PutE() ;clear the screen
Sieve(primes,MAX+1)
WHILE n<22
DO
PrintB(n) Put(32)
p==+1
IF primes(p) THEN
n==+1
FI
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Piprimes.png Screenshot from Atari 8-bit computer]
<pre>
0 1 2 2 3 3 4 4 4 4 5 5 6 6 6 6 7 7 8 8 8 8 9 9 9 9 9 9 10 10 11 11 11 11 11 11 12 12 12 12 13 13 14 14
14 14 15 15 15 15 15 15 16 16 16 16 16 16 17 17 18 18 18 18 18 18 19 19 19 19 20 20 21 21 21 21 21 21
</pre>
 
=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
<lang algol68>BEGIN # Show some values of pi(n) - the number of priems <= n #
<syntaxhighlight lang="algol68">BEGIN # Show some values of pi(n) - the number of priems <= n #
# reurns a sieve of primes up to n #
PROC prime sieve = ( INT n )[]BOOL:
BEGIN
[ 1 : n ]BOOL p;
p[ 1 ] := FALSE; p[ 2 ] := TRUE;
FOR i FROM 3 BY 2 TO n DO p[ i ] := TRUE OD;
FOR i FROM 4 BY 2 TO n DO p[ i ] := FALSE OD;
FOR i FROM 3 BY 2 TO ENTIER sqrt( n ) DO
IF p[ i ] THEN FOR s FROM i * i BY i + i TO n DO p[ s ] := FALSE OD FI
OD;
p
END # prime sieve # ;
# show pi(n) for n up to 21 #
INT max numberprime = 100; # guess of how large the primes we need are #
INT max pi = 21;
PR read "primes.incl.a68" PR
[]BOOL prime = prime sieve( max number );
[]BOOL prime = PRIMESIEVE max prime;
INT pi := 0;
FOR i TO maxUPB numberprime
WHILE IF prime[ i ] THEN pi +:= 1 FI;
pi <= max pi
Line 38 ⟶ 91:
IF i MOD 10 = 0 THEN print( ( newline ) ) FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 50 ⟶ 103:
20 20 21 21 21 21 21 21
</pre>
 
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">primes: select 2..1000 => prime?
piprimes: function [n] -> size select primes 'z [z =< n]
 
loop split.every: 10 select map 1..100 => piprimes => [& < 22] 'a ->
print map a => [pad to :string & 3]</langsyntaxhighlight>
 
{{out}}
Line 70 ⟶ 124:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f PIPRIMES.AWK
# converted from FreeBASIC
Line 97 ⟶ 151:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 112 ⟶ 166:
 
=={{header|BASIC}}==
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">function isPrime(v)
if v < 2 then return False
if v mod 2 = 0 then return v = 2
if v mod 3 = 0 then return v = 3
d = 5
while d * d <= v
if v mod d = 0 then return False else d += 2
end while
return True
end function
 
running = 0 : curr = 0 : limite = 22
while True
curr += 1
if isPrime(curr) then running += 1
if running = limite then exit while
print running; " ";
end while
end</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC.
</pre>
 
==={{header|FreeBASIC}}===
<langsyntaxhighlight lang="freebasic">#define UPTO 22
#include "isprime.bas"
 
Line 125 ⟶ 204:
loop
print : end
</syntaxhighlight>
</lang>
{{out}}<pre>
0 1 2 2 3 3 4 4 4 4 5 5 6 6 6 6 7 7 8 8 8 8 9 9 9 9 9 9 10 10 11 11 11 11 11 11 12 12 12 12 13 13 14 14 14 14 15 15 15 15 15 15 16 16 16 16 16 16 17 17 18 18 18 18 18 18 19 19 19 19 20 20 21 21 21 21 21 21</pre>
 
==={{header|Tiny BASIC}}===
<langsyntaxhighlight lang="tinybasic"> LET N = 0
LET P = 0
10 IF N = 22 THEN END
Line 145 ⟶ 224:
LET I = I + 1
IF I*I <= P THEN GOTO 110
RETURN</langsyntaxhighlight>
 
==={{header|Yabasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="yabasic">sub isPrime(v)
if v < 2 then return False : fi
if mod(v, 2) = 0 then return v = 2 : fi
if mod(v, 3) = 0 then return v = 3 : fi
d = 5
while d * d <= v
if mod(v, d) = 0 then return False else d = d + 2 : fi
wend
return True
end sub
 
running = 0 : curr = 0 : limite = 22
do
curr = curr + 1
if isPrime(curr) then running = running + 1 : fi
if running = limite break
print running using "##", " ";
loop
end</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC.
</pre>
 
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
 
Line 168 ⟶ 274:
}
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 175 ⟶ 281:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub isPrime(n: uint8): (r: uint8) is
Line 205 ⟶ 311:
end loop;
print_nl();
</syntaxhighlight>
</lang>
 
{{out}}
Line 217 ⟶ 323:
20 20 21 21 21 21 21 21
</pre>
 
=={{header|Dart}}==
{{trans|C}}
<syntaxhighlight lang="dart">import 'dart:math';
import 'dart:io';
 
void main() {
int n = 0, p = 1;
while (n < 22) {
stdout.write("$n ");
++p;
if (isPrime(p)) ++n;
}
}
 
bool isPrime(int n) {
if (n <= 1) return false;
if (n == 2) return true;
for (int i = 2; i <= sqrt(n); ++i) {
if (n % i == 0) return false;
}
return true;
}</syntaxhighlight>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
function IsPrime(N: int64): boolean;
{Fast, optimised prime test}
var I,Stop: int64;
begin
if (N = 2) or (N=3) then Result:=true
else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
else
begin
I:=5;
Stop:=Trunc(sqrt(N+0.0));
Result:=False;
while I<=Stop do
begin
if ((N mod I) = 0) or ((N mod (I + 2)) = 0) then exit;
Inc(I,6);
end;
Result:=True;
end;
end;
 
 
 
 
 
procedure ShowPiprimes(Memo: TMemo);
var N, P, Cnt: integer;
var S: string;
begin
N:= 0;
P:= 1;
Cnt:= 0;
S:='';
repeat
begin
S:=S+Format('%3D',[N]);
Inc(Cnt);
if (Cnt mod 10)=0 then S:=S+CRLF;
Inc(P);
if IsPrime(P) then N:= N+1;
end
until N >= 22;
Memo.Lines.Add(S);
end;
 
</syntaxhighlight>
{{out}}
<pre>
0 1 2 2 3 3 4 4 4 4
5 5 6 6 6 6 7 7 8 8
8 8 9 9 9 9 9 9 10 10
11 11 11 11 11 11 12 12 12 12
13 13 14 14 14 14 15 15 15 15
15 15 16 16 16 16 16 16 17 17
18 18 18 18 18 18 19 19 19 19
20 20 21 21 21 21 21 21
Elapsed Time: 1.328 ms.
 
</pre>
 
 
=={{header|F_Sharp|F#}}==
<lang fsharp>
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<syntaxhighlight lang="fsharp">
// PiPrimes: Nigel Galloway. April 5th., 2021
let fN=let i=primes32() in Seq.unfold(fun(n,g,l)->Some(l,if n=g then (n+1,Seq.head i,l+1) else (n+1,g,l)))(1,Seq.head i,0)
fN|>Seq.takeWhile((>)22)|>Seq.chunkBySize 20|>Seq.iter(fun n->Array.iter(printf "%2d ") n; printfn "")
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 235 ⟶ 430:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: formatting grouping io lists math.primes
math.primes.lists math.ranges math.statistics sequences ;
 
21 lprimes lnth [1,b) [ prime? ] cum-count
10 group [ [ "%2d " printf ] each nl ] each</langsyntaxhighlight>
{{out}}
<pre>
Line 253 ⟶ 448:
 
=={{header|Fermat}}==
<langsyntaxhighlight lang="fermat">n:=0; p:=0
while n<22 do !n;!' ';p:=p+1;if Isprime(p)=1 then n:=n+1; fi; od</langsyntaxhighlight>
{{out}}<pre>
0 1 2 2 3 3 4 4 4 4 5 5 6 6 6 6 7 7 8 8 8 8 9 9 9 9 9 9 10 10 11 11 11 11 11 11 12 12 12 12 13 13 14 14 14 14 15 15 15 15 15 15 16 16 16 16 16 16 17 17 18 18 18 18 18 18 19 19 19 19 20 20 21 21 21 21 21 21</pre>
 
=={{header|FOCAL}}==
<langsyntaxhighlight FOCALlang="focal">01.10 S C=0
01.20 S N=1
01.30 T %3,C
Line 272 ⟶ 467:
02.30 I (I*I-N-1)2.4;S A=1;R
02.40 S A=N/I
02.50 I (FITR(A)-A)2.2;S A=0</langsyntaxhighlight>
{{out}}
<pre>= 0= 1= 2= 2= 3= 3= 4= 4= 4= 4= 5= 5= 6= 6= 6= 6
Line 279 ⟶ 474:
= 15= 15= 15= 15= 16= 16= 16= 16= 16= 16= 17= 17= 18= 18= 18= 18
= 18= 18= 19= 19= 19= 19= 20= 20= 21= 21= 21= 21= 21= 21</pre>
 
 
=={{header|FutureBasic}}==
<syntaxhighlight futurebasic"j">
local fn IsPrime( n as NSUInteger ) as BOOL
BOOL isPrime = YES
NSUInteger i
if n < 2 then exit fn = NO
if n = 2 then exit fn = YES
if n mod 2 == 0 then exit fn = NO
for i = 3 to int(n^.5) step 2
if n mod i == 0 then exit fn = NO
next
end fn = isPrime
 
 
local fn Piprimes( limit as NSUInteger )
NSUInteger n = 0, p = 1
printf @"Piprimes from 1 through %lu:\n", limit
while ( n < limit )
printf @"%2lu \b", n
if p mod 10 == 0 then print
p++
if ( fn IsPrime(p) ) then n++
wend
end fn
 
fn Piprimes( 22 )
 
HandleEvents
</syntaxhighlight>
{{output}}}
<pre>
Piprimes from 1 through 22:
 
0 1 2 2 3 3 4 4 4 4
5 5 6 6 6 6 7 7 8 8
8 8 9 9 9 9 9 9 10 10
11 11 11 11 11 11 12 12 12 12
13 13 14 14 14 14 15 15 15 15
15 15 16 16 16 16 16 16 17 17
18 18 18 18 18 18 19 19 19 19
20 20 21 21 21 21 21 21
</pre>
 
=={{header|J}}==
<langsyntaxhighlight Jlang="j">}.@(>:@i.&.p:) 21</langsyntaxhighlight>
{{out}}
<pre>0 1 2 2 3 3 4 4 4 4 5 5 6 6 6 6 7 7 8 8 8 8 9 9 9 9 9 9 10 10 11 11 11 11 11 11 12 12 12 12 13 13 14 14 14 14 15 15 15 15 15 15 16 16 16 16 16 16 17 17 18 18 18 18 18 18 19 19 19 19 20 20 21 21 21 21 21 21</pre>
Line 288 ⟶ 529:
{{trans|Wren}}
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 320 ⟶ 561:
}
fmt.Printf("\n\nHighest n for this range = %d.\n", len(pi))
}</langsyntaxhighlight>
 
{{out}}
Line 335 ⟶ 576:
 
Highest n for this range = 78.
</pre>
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
 
This entry uses an approach based on streams of unbounded length;
this has the advantage that no guessing or smarts is needed, either
to provide a solution for the given bound (pi(n)<22) or any such bound.
 
For a suitable implementation of `is_prime` see e.g. [[Erd%C5%91s-primes#jq]].
 
'''Preliminaries'''
<syntaxhighlight lang="jq">def count(s): reduce s as $x (null; .+1);
 
def emit_until(cond; stream):
label $out | stream | if cond then break $out else . end;
 
def next_prime:
if . == 2 then 3
else first(range(.+2; infinite; 2) | select(is_prime))
end;</syntaxhighlight>
'''The task'''
<syntaxhighlight lang="jq"># Generate pi($n) for $n > 0
def pi_primes:
foreach range(1; infinite) as $i ({n:0, np: 2}; # n counts, np is the next prime
if $i < .np then .
elif $i == .np then .n += 1 | .np |= next_prime
else .
end;
.n);
 
emit_until(. >= 22; pi_primes)</syntaxhighlight>
{{out}}
<pre>
0
1
2
2
3
3
4
4
4
4
...
19
19
19
19
20
20
21
21
21
21
21
21
</pre>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Primes
 
function listpiprimes(maxpi)
Line 350 ⟶ 649:
 
listpiprimes(22)
</langsyntaxhighlight>{{out}}
<pre>
0 1 2 2 3 3 4 4 4 4
Line 361 ⟶ 660:
20 20 21 21 21 21 21 21
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">pi = PrimePi /@ Range[Prime[22] - 1];
Multicolumn[pi, {Automatic, 10}, Appearance -> "Horizontal"]</syntaxhighlight>
{{out}}
<pre>0 1 2 2 3 3 4 4 4 4
5 5 6 6 6 6 7 7 8 8
8 8 9 9 9 9 9 9 10 10
11 11 11 11 11 11 12 12 12 12
13 13 14 14 14 14 15 15 15 15
15 15 16 16 16 16 16 16 17 17
18 18 18 18 18 18 19 19 19 19
20 20 21 21 21 21 21 21 </pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strutils
 
func isPrime(n: Natural): bool =
Line 385 ⟶ 697:
inc pi
if pi == 22: break
echo()</langsyntaxhighlight>
 
 
Line 399 ⟶ 711:
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">n=0; p=0 1;
while( primepi( n ) < 22,
while(n<22, print(n); if(isprime(p),n=n+1);p=p+1)</lang>
printf( "%3d", primepi(n) );
if( n++ % 10 == 1,
print()) )</syntaxhighlight>
{{out}}
0 1 2 2 3 3 4 4 4 4
5 5 6 6 6 6 7 7 8 8
8 8 9 9 9 9 9 9 10 10
11 11 11 11 11 11 12 12 12 12
13 13 14 14 14 14 15 15 15 15
15 15 16 16 16 16 16 16 17 17
18 18 18 18 18 18 19 19 19 19
20 20 21 21 21 21 21 21
 
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'state';
Line 410 ⟶ 734:
 
my @pi = map { state $pi = 0; $pi += is_prime $_ ? 1 : 0 } 1..1e4;
do { print shift(@pi) . ' ' } until $pi[0] >= 22;</langsyntaxhighlight>
{{out}}
<pre>0 1 2 2 3 3 4 4 4 4 5 5 6 6 6 6 7 7 8 8 8 8 9 9 9 9 9 9 10 10 11 11 11 11 11 11 12 12 12 12 13 13 14 14 14 14 15 15 15 15 15 15 16 16 16 16 16 16 17 17 18 18 18 18 18 18 19 19 19 19 20 20 21 21 21 21 21 21</pre>
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">ix</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
Line 429 ⟶ 753:
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"pi[1..%d]:\n%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pi</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pi</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)})</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 442 ⟶ 766:
20 20 21 21 21 21 21 21
</pre>
 
=={{header|Quackery}}==
 
<code>isprime</code> is defined at [[Primality by trial division#Quackery]].
 
<syntaxhighlight lang="quackery"> [ 0 swap
1 - times
[ i 1+ isprime + ] ] is pi ( n --> n )
 
2 [ dup pi dup 22 < while
echo sp 1+ again ]
2drop</syntaxhighlight>
 
{{out}}
 
<pre>0 1 2 2 3 3 4 4 4 4 5 5 6 6 6 6 7 7 8 8 8 8 9 9 9 9 9 9 10 10 11 11 11 11 11 11 12 12 12 12 13 13 14 14 14 14 15 15 15 15 15 15 16 16 16 16 16 16 17 17 18 18 18 18 18 18 19 19 19 19 20 20 21 21 21 21 21 21</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>my @pi = (1..*).map: { state $pi = 0; $pi += .is-prime };
 
say @pi[^(@pi.first: * >= 22, :k)].batch(10)».fmt('%2d').join: "\n";</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 2 3 3 4 4 4 4
Line 458 ⟶ 798:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX program finds and displays pi(n) for 0 < N ≤ prime(22) {the 22nd prime is 87},*/
/*────────────────────────── where the pi function returns the number of primes ≤ N.*/
parse arg hi cols . /*obtain optional argument from the CL.*/
Line 502 ⟶ 842:
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; s.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 521 ⟶ 861:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 554 ⟶ 894:
see nl + "Found " + row + " Piprimes." + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 571 ⟶ 911:
</pre>
 
Pi primes ✔
=={{header|RPL}}==
{{works with|HP|49g}}
≪ 0
1 ROT '''FOR''' j j ISPRIME? + '''NEXT'''
≫ '<span style="color:blue">PI</span>' STO
≪ 0 → n
≪ { } 1 CF
'''DO'''
'n' INCR <span style="color:blue">PI</span>
'''IF''' DUP 22 ≤ '''THEN''' + '''ELSE''' DROP 1 SF '''END'''
'''UNTIL''' 1 FS? '''END'''
≫ '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: { 0. 1. 2. 2. 3. 3. 4. 4. 4. 4. 5. 5. 6. 6. 6. 6. 7. 7. 8. 8. 8. 8. 9. 9. 9. 9. 9. 9. 10. 10. 11. 11. 11. 11. 11. 11. 12. 12. 12. 12. 13. 13. 14. 14. 14. 14. 15. 15. 15. 15. 15. 15. 16. 16. 16. 16. 16. 16. 17. 17. 18. 18. 18. 18. 18. 18. 19. 19. 19. 19. 20. 20. 21. 21. 21. 21. 21. 21. }
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
 
pi = 0
pies = (1..).lazy.map {|n| n.prime? ? pi += 1 : pi}.take_while{ pi < 22 }
pies.each_slice(10){|s| puts "%3d"*s.size % s}</syntaxhighlight>
{{out}}
<pre> 0 1 2 2 3 3 4 4 4 4
5 5 6 6 6 6 7 7 8 8
8 8 9 9 9 9 9 9 10 10
11 11 11 11 11 11 12 12 12 12
13 13 14 14 14 14 15 15 15 15
15 15 16 16 16 16 16 16 17 17
18 18 18 18 18 18 19 19 19 19
20 20 21 21 21 21 21 21
</pre>
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">1..(prime(22)-1) -> map { .prime_count }.say</langsyntaxhighlight>
{{out}}
<pre>
Line 580 ⟶ 955:
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int
import "./seqfmt" for LstFmt
import "/fmt" for Fmt
 
var primes = Int.primeSieve(79) // go up to the 22nd
Line 601 ⟶ 974:
}
System.print("pi(n), the number of primes <= n, where n >= 1 and pi(n) < 22:")
for (chunk in Lst.chunks(pi, 10)) Fmt.printtprint("$2d", chunkpi, 10)
System.print("\nHighest n for this range = %(pi.count).")</langsyntaxhighlight>
 
{{out}}
Line 620 ⟶ 993:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func IsPrime(N); \Return 'true' if N is a prime number
int N, I;
[if N <= 1 then return false;
Line 637 ⟶ 1,010:
if IsPrime(P) then N:= N+1;
until N >= 22;
]</langsyntaxhighlight>
 
{{out}}
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/310681...354709"