Find squares n where n+1 is prime: Difference between revisions

Line 6:

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

<~~lang~~ algol68>BEGIN # find squares n where n + 1 is prime #

<syntaxhighlight lang="algol68">BEGIN # find squares n where n + 1 is prime #

PR read "primes.incl.a68" PR

[]BOOL prime = PRIMESIEVE 1 000; # construct a sieve of primes up to 1000 #

Line 19:

FI

OD

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 27:

=={{header|AutoHotkey}}==

<~~lang~~ ~~AutoHotkey~~>n := 0

<syntaxhighlight lang="autohotkey">n := 0

while ((n2 := (n+=2)**2) < 1000)

if isPrime(n2+1)

Line 39:

return False

return True

}</~~lang~~>

}</syntaxhighlight>

=={{header|AWK}}==

# syntax: GAWK -f FIND_SQUARES_N_WHERE_N+1_IS_PRIME.AWK

BEGIN {

Line 77:

return(1)

}

</syntaxhighlight>

</lang>

<pre>

Line 85:

=={{header|BASIC}}==

<~~lang~~ basic>10 DEFINT A-Z: N=1000

<syntaxhighlight lang="basic">10 DEFINT A-Z: N=1000

20 DIM C(N)

30 FOR P=2 TO SQR(N)

Line 94:

80 X=I-1: R=SQR(X)

90 IF R*R=X THEN PRINT X;

100 NEXT</~~lang~~>

100 NEXT</syntaxhighlight>

=={{header|BCPL}}==

<~~lang~~ bcpl>get "libhdr"

<syntaxhighlight lang="bcpl">get "libhdr"

manifest $( MAX = 1000 $)

Line 140:

$)

wrch('*N')

$)</~~lang~~>

$)</syntaxhighlight>

=={{header|C}}==

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

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

#include <stdbool.h>

#include <math.h>

Line 173:

printf("\n");

return 0;

}</~~lang~~>

}</syntaxhighlight>

=={{header|CLU}}==

<~~lang~~ clu>isqrt = proc (s: int) returns (int)

<syntaxhighlight lang="clu">isqrt = proc (s: int) returns (int)

x0: int := s/2

if x0=0 then return(s) end

Line 217:

if is_square(n) then stream$puts(po, int$unparse(n) || " ") end

end

end start_up</~~lang~~>

end start_up</syntaxhighlight>

=={{header|COBOL}}==

<~~lang~~ cobol> IDENTIFICATION DIVISION.

<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.

PROGRAM-ID. SQUARE-PLUS-1-PRIME.

Line 260:

CHECK-DSOR.

DIVIDE P BY DSOR GIVING DIVTEST.

IF DIVISIBLE, MOVE SPACE TO PRIME-FLAG.</~~lang~~>

IF DIVISIBLE, MOVE SPACE TO PRIME-FLAG.</syntaxhighlight>

<pre>0001

Line 274:

=={{header|Cowgol}}==

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

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

const MAX := 1000;

Line 317:

end if;

i := i + 1;

end loop;</~~lang~~>

end loop;</syntaxhighlight>

<pre>1

Line 332:

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

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

<~~lang~~ fsharp>

// Find squares n where n+1 is prime. Nigel Galloway: December 17th., 2021

seq{yield 1; for g in 2..2..30 do let n=g*g in if isPrime(n+1) then yield n}|>Seq.iter(printf "%d "); printfn ""

</syntaxhighlight>

</lang>

<pre>

Line 342:

=={{header|Fermat}}==

<~~lang~~ fermat>!!1;

<syntaxhighlight lang="fermat">!!1;

i:=2;

i2:=4;

Line 349:

i:+2;

i2:=i^2;

od;</~~lang~~>

od;</syntaxhighlight>

{{out}}<pre>1

4

Line 363:

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>function isprime(n as integer) as boolean

<syntaxhighlight lang="freebasic">function isprime(n as integer) as boolean

if n<0 then return isprime(-n)

if n<2 then return false

Line 382:

n+=2

n2=n^2

wend</~~lang~~>

wend</syntaxhighlight>

{{out}}<pre> 1 4 16 36 100 196 256 400 576 676</pre>

Line 388:

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 413:

fmt.Println("There are", len(squares), "square numbers 'n' where 'n+1' is prime, viz:")

fmt.Println(squares)

}</~~lang~~>

}</syntaxhighlight>

Line 422:

=={{header|GW-BASIC}}==

<~~lang~~ gwbasic>10 PRINT 1

<syntaxhighlight lang="gwbasic">10 PRINT 1

20 N = 2 : N2 = 4

30 WHILE N2 < 1000

Line 441:

180 I=I +2

190 WEND

200 RETURN</~~lang~~>

200 RETURN</syntaxhighlight>

{{out}}<pre>1

4

Line 455:

=={{header|J}}==

<~~lang~~ j>((<.=])@%:#+)@(i.&.(p:^:_1)-1:) 1000</~~lang~~>

Line 465:

See [[Erdős-primes#jq]] for a suitable definition of `is_prime` as used here.

<~~lang~~ jq>def squares_for_which_successor_is_prime:

<syntaxhighlight lang="jq">def squares_for_which_successor_is_prime:

(. // infinite) as $limit

| {i:1, sq: 1}

Line 472:

| select((. + 1)|is_prime) ;

1000 | squares_for_which_successor_is_prime</~~lang~~>

1000 | squares_for_which_successor_is_prime</syntaxhighlight>

<pre>

Line 488:

=={{header|Julia}}==

<~~lang~~ julia>using Primes

<syntaxhighlight lang="julia">using Primes

isintegersquarebeforeprime(n) = isqrt(n)^2 == n && isprime(n + 1)

foreach(p -> print(lpad(last(p), 5)), filter(isintegersquarebeforeprime, 1:1000))

</~~lang~~>{{out}}<pre> 1 4 16 36 100 196 256 400 576 676 </pre>

</syntaxhighlight>{{out}}<pre> 1 4 16 36 100 196 256 400 576 676 </pre>

=={{header|MAD}}==

<~~lang~~ ~~MAD~~> NORMAL MODE IS INTEGER

<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER

BOOLEAN PRIME

DIMENSION PRIME(1000)

Line 528:

VECTOR VALUES FMT = $I4*$

END OF PROGRAM</~~lang~~>

END OF PROGRAM</syntaxhighlight>

<pre> 1

Line 541:

676</pre>

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

<~~lang~~ ~~Mathematica~~>Cases[Table[n^2, {n, 101}], _?(PrimeQ[# + 1] &)]</~~lang~~>

<syntaxhighlight lang="mathematica">Cases[Table[n^2, {n, 101}], _?(PrimeQ[# + 1] &)]</syntaxhighlight>

{{out}}<pre>

{1,4,16,36,100,196,256,400,576,676,1296,1600,2916,3136,4356,5476,7056,8100,8836}

Line 547:

=={{header|Modula-2}}==

<~~lang~~ modula2>MODULE SquareAlmostPrime;

<syntaxhighlight lang="modula2">MODULE SquareAlmostPrime;

FROM InOut IMPORT WriteCard, WriteLn;

FROM MathLib IMPORT sqrt;

Line 590:

END;

END SquareAlmostPrime.</~~lang~~>

END SquareAlmostPrime.</syntaxhighlight>

<pre> 1

Line 606:

This is not terribly efficient, but it does show off the issquare and isprime functions.

<~~lang~~ parigp>for(n = 1, 1000, if(issquare(n)&&isprime(n+1),print(n)))</~~lang~~>

<syntaxhighlight lang="parigp">for(n = 1, 1000, if(issquare(n)&&isprime(n+1),print(n)))</syntaxhighlight>

{{out}}<pre>1

Line 621:

=={{header|Perl}}==

===Simple and Clear===

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

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

use strict; # https://rosettacode.org/wiki/Find_squares_n_where_n%2B1_is_prime

use warnings;

Line 627:

my @answer = grep is_square($_), map $_ - 1, @{ primes(1000) };

print "@answer\n";</~~lang~~>

print "@answer\n";</syntaxhighlight>

<pre>

Line 634:

===More Than One Way===

TMTOWTDI, right? So do it.

<~~lang~~ perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

use feature 'say';

Line 649:

# or dispense with the module and find primes the slowest way possible

(1 x (1+$_**2)) !~ /^(11+)\1+$/ and say $_**2 for 1 .. int sqrt 1000;</~~lang~~>

(1 x (1+$_**2)) !~ /^(11+)\1+$/ and say $_**2 for 1 .. int sqrt 1000;</syntaxhighlight>

In all cases:

Line 664:

=={{header|Phix}}==

with javascript_semantics

sequence res = {1}

Line 676:

end while

printf(1,"%V\n",{res})

<pre>

Line 682:

</pre>

Alternative, same output, but 168 iterations/tests compared to just 16 by the above:

with javascript_semantics

function sq(integer n) return integer(sqrt(n)) end function

pp(filter(sq_sub(get_primes_le(1000),1),sq))

Drop the filter to get the 168 (cheekily humorous) squares-of-integers-and-non-integers result of Raku (and format/arrange them identically):

puts(1,join_by(apply(true,sprintf,{{"%3d"},sq_sub(get_primes_le(1000),1)}),1,20," "))

=={{header|Python}}==

<~~lang~~ python>

limit = 1000

print("working...")

Line 715:

print()

print("done...")

</syntaxhighlight>

</lang>

<pre>

Line 725:

=={{header|Raku}}==

Use up to to one thousand (1,000) rather than up to one (1.000) as otherwise it would be a pretty short list...

<lang ~~perl6~~>say ({$++²}…^*>Ⅿ).grep: (*+1).is-prime</~~lang~~>

<syntaxhighlight lang="raku" line>say ({$++²}…^*>Ⅿ).grep: (*+1).is-prime</syntaxhighlight>

Although, technically, there is absolutely nothing in the task directions specifying that '''n''' needs to be the square of an ''integer''. So, more accurately...

<lang ~~perl6~~>put (^Ⅿ).grep(*.is-prime).map(*-1).batch(20)».fmt("%3d").join: "\n"</~~lang~~>

<syntaxhighlight lang="raku" line>put (^Ⅿ).grep(*.is-prime).map(*-1).batch(20)».fmt("%3d").join: "\n"</syntaxhighlight>

<pre> 1 2 4 6 10 12 16 18 22 28 30 36 40 42 46 52 58 60 66 70

Line 743:

=={{header|Ring}}==

<~~lang~~ ring>

load "stdlib.ring"

row = 0

Line 766:

return 0

</syntaxhighlight>

</lang>

<pre>

Line 785:

=={{header|Sidef}}==

<~~lang~~ ruby>1..1000.isqrt -> map { _**2 }.grep { is_prime(_+1) }.say</~~lang~~>

<syntaxhighlight lang="ruby">1..1000.isqrt -> map { _**2 }.grep { is_prime(_+1) }.say</syntaxhighlight>

<pre>

Line 792:

=={{header|Tiny BASIC}}==

<~~lang~~ tinybasic> PRINT 1

<syntaxhighlight lang="tinybasic"> PRINT 1

LET N = 2

LET M = 4

Line 808:

IF I*I < J THEN GOTO 30

LET P = 1

RETURN</~~lang~~>

RETURN</syntaxhighlight>

{{out}}<pre>1

4

Line 822:

=={{header|Wren}}==

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

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

var squares = []

Line 833:

}

System.print("There are %(squares.count) square numbers 'n' where 'n+1' is prime, viz:")

System.print(squares)</~~lang~~>

System.print(squares)</syntaxhighlight>

Line 842:

=={{header|XPL0}}==

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

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

int N, I;

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

Line 857:

if IsPrime(N*N+1) then

[IntOut(0, N*N); ChOut(0, ^ )];

]</~~lang~~>

]</syntaxhighlight>