Quadrat special primes: Difference between revisions

Line 10:

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

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

I n == 2

R 1B

Line 35:

print(‘Quadrat special primes < 16000:’)

L(qp) quadraPrimes

print(‘#5’.format(qp), end' I (L.index + 1) % 7 == 0 {"\n"} E ‘ ’)</~~lang~~>

print(‘#5’.format(qp), end' I (L.index + 1) % 7 == 0 {"\n"} E ‘ ’)</syntaxhighlight>

Line 51:

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

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

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

DEFINE MAX="15999"

Line 93:

p=FindNextQuadraticPrime(p)

OD

RETURN</~~lang~~>

RETURN</syntaxhighlight>

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

Line 105:

<~~lang~~ algol68>BEGIN # find some primes where the gap between the current prime and the next is a square #

<syntaxhighlight lang="algol68">BEGIN # find some primes where the gap between the current prime and the next is a square #

# an array of squares #

PROC get squares = ( INT n )[]INT:

Line 132:

DO sq pos +:= 2 OD

OD

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 143:

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

<~~lang~~ algolw>begin % find some primes where the gap between the current prime and the next is a square %

<syntaxhighlight lang="algolw">begin % find some primes where the gap between the current prime and the next is a square %

% sets p( 1 :: n ) to a sieve of primes up to n %

procedure Eratosthenes ( logical array p( * ) ; integer value n ) ;

Line 185:

end while_thisPrime_lt_MAX_NUMBER

end

end.</~~lang~~>

end.</syntaxhighlight>

<pre>

Line 195:

</pre>

=={{header|AWK}}==

# syntax: GAWK -f QUADRAT_SPECIAL_PRIMES.AWK

# converted from FreeBASIC

Line 228:

return(1)

}

</syntaxhighlight>

</lang>

<pre>

Line 243:

==={{header|Applesoft BASIC}}===

<~~lang~~ gwbasic> 100 FOR P = 2 TO 16000

<syntaxhighlight lang="gwbasic"> 100 FOR P = 2 TO 16000

110 PRINT S$P;

120 LET S$ = " "

Line 264:

290 IF NOT ISPRIME THEN RETURN

300 NEXT D

310 RETURN</~~lang~~>

310 RETURN</syntaxhighlight>

==={{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 291:

j = 1

end while

end</~~lang~~>

end</syntaxhighlight>

==={{header|PureBasic}}===

<~~lang~~ ~~PureBasic~~>Procedure isPrime(v.i)

<syntaxhighlight lang="purebasic">Procedure isPrime(v.i)

If v <= 1 : ProcedureReturn #False

ElseIf v < 4 : ProcedureReturn #True

Line 333:

ForEver

Input()

CloseConsole()</~~lang~~>

CloseConsole()</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 361:

j = 1

loop

end</~~lang~~>

end</syntaxhighlight>

=={{header|Factor}}==

<~~lang~~ factor>USING: fry io kernel lists lists.lazy math math.primes prettyprint ;

<syntaxhighlight lang="factor">USING: fry io kernel lists lists.lazy math math.primes prettyprint ;

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

lfrom-by [ 16000 < ] lwhile [ pprint bl ] leach nl</~~lang~~>

lfrom-by [ 16000 < ] lwhile [ pprint bl ] leach nl</syntaxhighlight>

<pre>

Line 375:

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>

#include "isprime.bas"

Line 391:

loop

print

</syntaxhighlight>

</lang>

<pre>

Line 399:

=={{header|Go}}==

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 473:

}

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

}</~~lang~~>

}</syntaxhighlight>

Line 481:

=={{header|J}}==

<~~lang~~ J>{{

<syntaxhighlight lang="j">{{

j=. 0

r=. 2

Line 488:

end.

}} p:i.p:inv 16e3

2 3 7 11 47 83 227 263 587 911 947 983 1019 1163 1307 1451 1487 1523 1559 2459 3359 4259 4583 5483 5519 5843 5879 6203 6779 7103 7247 7283 7607 7643 8219 8363 10667 11243 11279 11423 12323 12647 12791 13367 13691 14591 14627 14771 15671</~~lang~~>

2 3 7 11 47 83 227 263 587 911 947 983 1019 1163 1307 1451 1487 1523 1559 2459 3359 4259 4583 5483 5519 5843 5879 6203 6779 7103 7247 7283 7607 7643 8219 8363 10667 11243 11279 11423 12323 12647 12791 13367 13691 14591 14627 14771 15671</syntaxhighlight>

=={{header|jq}}==

'''Adaptation of [[#Julia|Julia]]

Line 495:

For the definition of `is_prime` used here, see https://rosettacode.org/wiki/Additive_primes

# Input: a number > 2

# Output: an array of the quadrat primes less than `.`

Line 516:

"Quadrat special primes < 16000:",

(16000 | quadrat[])

</syntaxhighlight>

</lang>

<pre>

Line 530:

=={{header|Julia}}==

<~~lang~~ julia>using Primes

<syntaxhighlight lang="julia">using Primes

function quadrat(N = 16000)

Line 550:

println("Quadrat special primes < 16000:")

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

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

</syntaxhighlight>{{out}}

<pre>

Quadrat special primes < 16000:

Line 561:

=={{header|Ksh}}==

<~~lang~~ ksh>

#!/bin/ksh

Line 613:

done

printf "\n"

</syntaxhighlight>

</lang>

{{out}}<pre>

2 3 7 11 47 83 227 263 587 911 947 983 1019 1163 1307 1451 1487 1523 1559 2459 3359 4259 4583 5483 5519 5843 5879 6203 6779 7103 7247 7283 7607 7643 8219 8363 10667 11243 11279 11423 12323 12647 12791 13367 13691 14591 14627 14771 15671

Line 619:

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

<~~lang~~ ~~Mathematica~~>ps = {2};

<syntaxhighlight lang="mathematica">ps = {2};

Do[

Line 636:

];

ps //= Most;

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

Multicolumn[ps, {Automatic, 7}, Appearance -> "Horizontal"]</syntaxhighlight>

<pre>2 3 7 11 47 83 227

Line 647:

=={{header|Nim}}==

<~~lang~~ ~~Nim~~>import math, strutils, sugar

<syntaxhighlight lang="nim">import math, strutils, sugar

func isPrime(n: Natural): bool =

Line 685:

for qp in quadraPrimes(Max):

inc count

stdout.write ($qp).align(5), if count mod 7 == 0: '\n' else: ' '</~~lang~~>

stdout.write ($qp).align(5), if count mod 7 == 0: '\n' else: ' '</syntaxhighlight>

Line 699:

=={{header|Perl}}==

<~~lang~~ perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

use feature 'say';

Line 712:

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

pop @sp and say ((sprintf '%-7d'x@sp, @sp) =~ s/.{1,$#sp}\K\s/\n/gr);</~~lang~~>

pop @sp and say ((sprintf '%-7d'x@sp, @sp) =~ s/.{1,$#sp}\K\s/\n/gr);</syntaxhighlight>

<pre>2 3 7 11 47 83 227

Line 723:

=={{header|Phix}}==

constant desc = split("linear quadratic cubic quartic quintic sextic septic octic nonic decic"),

limits = {1, 16000, 15000, 14e9, 8025e5, 25e12, 195e12,75e11, 3e9, 11e8}

Line 745:

printf(1,"Found %d %s special primes < %g:\n%s\n",{length(res),desc[p],N,r})

end for

<pre>

Line 786:

=={{header|Python}}==

<~~lang~~ python>#!/usr/bin/python

<syntaxhighlight lang="python">#!/usr/bin/python

def isPrime(n):

Line 808:

break

print(p, end = " ");

j = 1</~~lang~~>

j = 1</syntaxhighlight>

=={{header|Raku}}==

<lang ~~perl6~~>my @sqp = 2, -> $previous {

<syntaxhighlight lang="raku" line>my @sqp = 2, -> $previous {

my $next;

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

Line 822:

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

@sqp[^(@sqp.first: * > 16000, :k)];</~~lang~~>

@sqp[^(@sqp.first: * > 16000, :k)];</syntaxhighlight>

<pre>49 matching numbers:

Line 834:

=={{header|REXX}}==

<~~lang~~ rexx>/*REXX program finds the smallest primes such that the difference of successive terms */

<syntaxhighlight lang="rexx">/*REXX program finds the smallest primes such that the difference of successive terms */

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

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

Line 883:

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 899:

=={{header|Ring}}==

<~~lang~~ ring>load "stdlib.ring"

<syntaxhighlight lang="ring">load "stdlib.ring"

/* Searching for the smallest prime gaps under a limit,

Line 942:

s = string(x) l = len(s)

if l > y y = l ok

return substr(" ", 11 - y + l) + s</~~lang~~>

return substr(" ", 11 - y + l) + s</syntaxhighlight>

<pre style="height:20em">working...

Line 1,072:

=={{header|Sidef}}==

<~~lang~~ ruby>func quadrat_primes(callback) {

<syntaxhighlight lang="ruby">func quadrat_primes(callback) {

var prev = 2

Line 1,089:

take(k)

})

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 1,098:

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

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

import "/fmt" for Fmt

Line 1,121:

}

System.print("\n%(count+1) such primes found.")</~~lang~~>

System.print("\n%(count+1) such primes found.")</syntaxhighlight>

Line 1,181:

=={{header|XPL0}}==

Find primes where the difference between the current one and a following one is a perfect square.

<~~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 1,206:

Text(0, " such primes found below 16000.

");

]</~~lang~~>

]</syntaxhighlight>