Piprimes: Difference between revisions

Line 15:

<~~lang~~ 11l>F is_prime(n)

<syntaxhighlight lang="11l">F is_prime(n)

I n == 2

R 1B

Line 34:

I pi == 22

L.break

print()</~~lang~~>

print()</syntaxhighlight>

Line 50:

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

<~~lang~~ ~~Action~~!>INCLUDE "H6:SIEVE.ACT"

<syntaxhighlight lang="action!">INCLUDE "H6:SIEVE.ACT"

PROC Main()

Line 67:

FI

OD

RETURN</~~lang~~>

RETURN</syntaxhighlight>

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

Line 77:

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

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

# show pi(n) for n up to 21 #

INT max prime = 100; # guess of how large the primes we need are #

Line 91:

IF i MOD 10 = 0 THEN print( ( newline ) ) FI

OD

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 106:

=={{header|Arturo}}==

<~~lang~~ rebol>primes: select 2..1000 => prime?

<syntaxhighlight 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]</~~lang~~>

print map a => [pad to :string & 3]</syntaxhighlight>

Line 124:

=={{header|AWK}}==

# syntax: GAWK -f PIPRIMES.AWK

# converted from FreeBASIC

Line 151:

return(1)

}

</syntaxhighlight>

</lang>

<pre>

Line 168:

==={{header|BASIC256}}===

<~~lang~~ ~~BASIC256~~>function isPrime(v)

<syntaxhighlight lang="basic256">function isPrime(v)

if v < 2 then return False

if v mod 2 = 0 then return v = 2

Line 186:

print running; " ";

end while

end</~~lang~~>

end</syntaxhighlight>

<pre>

Line 193:

==={{header|FreeBASIC}}===

<~~lang~~ freebasic>#define UPTO 22

<syntaxhighlight lang="freebasic">#define UPTO 22

#include "isprime.bas"

Line 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}}===

<~~lang~~ tinybasic> LET N = 0

<syntaxhighlight lang="tinybasic"> LET N = 0

LET P = 0

10 IF N = 22 THEN END

Line 224:

LET I = I + 1

IF I*I <= P THEN GOTO 110

RETURN</~~lang~~>

RETURN</syntaxhighlight>

==={{header|Yabasic}}===

<~~lang~~ yabasic>sub isPrime(v)

<syntaxhighlight lang="yabasic">sub isPrime(v)

if v < 2 then return False : fi

if mod(v, 2) = 0 then return v = 2 : fi

Line 246:

print running using "##", " ";

loop

end</~~lang~~>

end</syntaxhighlight>

<pre>

Line 254:

=={{header|C}}==

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

#include <stdlib.h>

Line 274:

}

return 0;

}</~~lang~~>

}</syntaxhighlight>

Line 281:

=={{header|Cowgol}}==

<~~lang~~ cowgol>include "cowgol.coh";

<syntaxhighlight lang="cowgol">include "cowgol.coh";

sub isPrime(n: uint8): (r: uint8) is

Line 311:

end loop;

print_nl();

</syntaxhighlight>

</lang>

Line 326:

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

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]

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

<pre>

Line 341:

=={{header|Factor}}==

<~~lang~~ factor>USING: formatting grouping io lists math.primes

<syntaxhighlight 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</~~lang~~>

10 group [ [ "%2d " printf ] each nl ] each</syntaxhighlight>

<pre>

Line 359:

=={{header|Fermat}}==

<~~lang~~ fermat>n:=0; p:=0

<syntaxhighlight lang="fermat">n:=0; p:=0

while n<22 do !n;!' ';p:=p+1;if Isprime(p)=1 then n:=n+1; fi; od</~~lang~~>

while n<22 do !n;!' ';p:=p+1;if Isprime(p)=1 then n:=n+1; fi; od</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|FOCAL}}==

<~~lang~~ ~~FOCAL~~>01.10 S C=0

<syntaxhighlight lang="focal">01.10 S C=0

01.20 S N=1

01.30 T %3,C

Line 378:

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</~~lang~~>

02.50 I (FITR(A)-A)2.2;S A=0</syntaxhighlight>

<pre>= 0= 1= 2= 2= 3= 3= 4= 4= 4= 4= 5= 5= 6= 6= 6= 6

Line 387:

=={{header|J}}==

<~~lang~~ J>}.@(>:@i.&.p:) 21</~~lang~~>

Line 394:

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 426:

}

fmt.Printf("\n\nHighest n for this range = %d.\n", len(pi))

}</~~lang~~>

}</syntaxhighlight>

Line 454:

'''Preliminaries'''

<~~lang~~ jq>def count(s): reduce s as $x (null; .+1);

<syntaxhighlight lang="jq">def count(s): reduce s as $x (null; .+1);

def emit_until(cond; stream):

Line 462:

if . == 2 then 3

else first(range(.+2; infinite; 2) | select(is_prime))

end;</~~lang~~>

end;</syntaxhighlight>

'''The task'''

<~~lang~~ jq># Generate pi($n) for $n > 0

<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

Line 473:

.n);

emit_until(. >= 22; pi_primes)</~~lang~~>

emit_until(. >= 22; pi_primes)</syntaxhighlight>

<pre>

Line 502:

=={{header|Julia}}==

<~~lang~~ julia>using Primes

<syntaxhighlight lang="julia">using Primes

function listpiprimes(maxpi)

Line 514:

listpiprimes(22)

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

0 1 2 2 3 3 4 4 4 4

Line 527:

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

<~~lang~~ ~~Mathematica~~>pi = PrimePi /@ Range[Prime[22] - 1];

<syntaxhighlight lang="mathematica">pi = PrimePi /@ Range[Prime[22] - 1];

Multicolumn[pi, {Automatic, 10}, Appearance -> "Horizontal"]</~~lang~~>

Multicolumn[pi, {Automatic, 10}, Appearance -> "Horizontal"]</syntaxhighlight>

<pre>0 1 2 2 3 3 4 4 4 4

Line 540:

=={{header|Nim}}==

<~~lang~~ ~~Nim~~>import strutils

<syntaxhighlight lang="nim">import strutils

func isPrime(n: Natural): bool =

Line 562:

inc pi

if pi == 22: break

echo()</~~lang~~>

echo()</syntaxhighlight>

Line 576:

=={{header|PARI/GP}}==

<~~lang~~ parigp>n = 1;

<syntaxhighlight lang="parigp">n = 1;

while( primepi( n ) < 22,

printf( "%3d", primepi(n) );

if( n++ % 10 == 1,

print()) )</~~lang~~>

print()) )</syntaxhighlight>

0 1 2 2 3 3 4 4 4 4

Line 593:

=={{header|Perl}}==

<~~lang~~ perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

use feature 'state';

Line 599:

my @pi = map { state $pi = 0; $pi += is_prime $_ ? 1 : 0 } 1..1e4;

do { print shift(@pi) . ' ' } until $pi[0] >= 22;</~~lang~~>

do { print shift(@pi) . ' ' } until $pi[0] >= 22;</syntaxhighlight>

=={{header|Phix}}==

with javascript_semantics

integer ix = 1, n = 1, count = 0

Line 618:

end while

printf(1,"pi[1..%d]:\n%s\n",{length(pi),join_by(pi,1,10)})

<pre>

Line 636:

<code>isprime</code> is defined at [[Primality by trial division#Quackery]].

<~~lang~~ ~~Quackery~~> [ 0 swap

<syntaxhighlight lang="quackery"> [ 0 swap

1 - times

[ i 1+ isprime + ] ] is pi ( n --> n )

Line 642:

2 [ dup pi dup 22 < while

echo sp 1+ again ]

2drop</~~lang~~>

2drop</syntaxhighlight>

Line 649:

=={{header|Raku}}==

<lang ~~perl6~~>my @pi = (1..*).map: { state $pi = 0; $pi += .is-prime };

<syntaxhighlight lang="raku" line>my @pi = (1..*).map: { state $pi = 0; $pi += .is-prime };

say @pi[^(@pi.first: * >= 22, :k)].batch(10)».fmt('%2d').join: "\n";</~~lang~~>

say @pi[^(@pi.first: * >= 22, :k)].batch(10)».fmt('%2d').join: "\n";</syntaxhighlight>

<pre> 0 1 2 2 3 3 4 4 4 4

Line 663:

=={{header|REXX}}==

<~~lang~~ rexx>/*REXX program finds and displays pi(n) for 0 < N ≤ prime(22) {the 22nd prime is 87},*/

<syntaxhighlight 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 707:

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

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

end /*j*/; return</~~lang~~>

end /*j*/; return</syntaxhighlight>

<pre>

Line 726:

=={{header|Ring}}==

<~~lang~~ ring>

load "stdlib.ring"

Line 759:

see nl + "Found " + row + " Piprimes." + nl

see "done..." + nl

</syntaxhighlight>

</lang>

<pre>

Line 777:

=={{header|Sidef}}==

<~~lang~~ ruby>1..(prime(22)-1) -> map { .prime_count }.say</~~lang~~>

<syntaxhighlight lang="ruby">1..(prime(22)-1) -> map { .prime_count }.say</syntaxhighlight>

<pre>

Line 787:

<~~lang~~ ecmascript>import "/math" for Int

<syntaxhighlight lang="ecmascript">import "/math" for Int

import "/seq" for Lst

import "/fmt" for Fmt

Line 807:

System.print("pi(n), the number of primes <= n, where n >= 1 and pi(n) < 22:")

for (chunk in Lst.chunks(pi, 10)) Fmt.print("$2d", chunk)

System.print("\nHighest n for this range = %(pi.count).")</~~lang~~>

System.print("\nHighest n for this range = %(pi.count).")</syntaxhighlight>

Line 825:

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>func IsPrime(N); \Return 'true' if N is a prime number

<syntaxhighlight lang="xpl0">func IsPrime(N); \Return 'true' if N is a prime number

int N, I;

[if N <= 1 then return false;

Line 842:

if IsPrime(P) then N:= N+1;

until N >= 22;

]</~~lang~~>

]</syntaxhighlight>