Find adjacent primes which differ by a square integer: Difference between revisions

=={{header|11l}}==

V is_prime = [0B] * 2 [+] [1B] * (limit - 1)

L(n) 0 .< Int(limit ^ 0.5 + 1.5)

V diff = pr1 - pr2

I (is_square(diff) & diff > 36)

{{out}}

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

{{libheader|ALGOL 68-primes}}

INT min diff = 37;

INT max prime = 1 000 000;

FI

OD

{{out}}

<pre>

=={{header|AWK}}==

# syntax: GAWK -f FIND_ADJACENTS_PRIMES_WHICH_DIFFERENCE_IS_SQUARE_INTEGER.AWK

# converted from FreeBASIC

return(q)

}

{{out}}

<pre>

=={{header|C}}==

#include<stdlib.h>

}

return 0;

=={{header|CLU}}==

isqrt = proc (s: int) returns (int)

x0: int := s/2

end

end

{{out}}

<pre> 89753 - 89689 = 64 = 8^2

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

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

// Find adjacents primes which difference is square integer . Nigel Galloway: November 23rd., 2021

primes32()|>Seq.takeWhile((>)1000000)|>Seq.pairwise|>Seq.filter(fun(n,g)->let n=g-n in let g=(float>>sqrt>>int)n in g>6 && n=g*g)|>Seq.iter(printfn "%A")

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-06-02}}

math.primes.lists sequences ;

"============================" print

big-sq-adj-primes-diff [ second 1,000,000 < ] lwhile

{{out}}

<pre>

=={{header|Fermat}}==

i:=3;

j:=3;

j:=j+2;

od;

=={{header|FreeBASIC}}==

function nextprime( n as uinteger ) as uinteger

if j-i > 36 and issquare(j-i) then print i, j, j-i

i = j

{{out}}<pre>

89689 89753 64

{{trans|Wren}}

{{libheader|Go-rcu}}

import (

}

}

{{out}}

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

20 GOSUB 180

30 IF P2>1000000! THEN END

230 GOSUB 80

240 IF Q = 1 THEN P2 = P: P = T: RETURN

=={{header|J}}==

26

(,.-~/"1) p:0 1+/~I.(= <.)6.5>.%:2-~/\p:i.p:inv 1e6 NB. show them

954763 954827 64

981823 981887 64

In other words: enumerate primes less than 1e6, find the pairwise differences, find where the prime pairs where maximum of their square root and 6.5 is an integer, and list those pairs with their differences.

'''Preliminaries'''

# Primes less than . // infinite

| if $n < 3 then empty

else 2, (range(3; $n) | select(is_prime))

'''The task'''

# Output: stream of [$prime, $nextPrime]

def adjacentPrimesWhichDifferBySquare:

| "\(.[1]|l) - \(.[0]|l) = \($diff|lpad(4))" ) ;

{{out}}

As for [[#ALGOL_68]].

=={{header|Julia}}==

function squareprimegaps(limit)

squareprimegaps(10_000_000_000)

<pre>

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

ps = Partition[ps, 2, 1];

ps = {#1, #2, #2 - #1} & @@@ ps;

ps //= Select[Extract[{3}]/*GreaterThan[36]];

ps //= Select[Extract[{3}]/*Sqrt/*IntegerQ];

{{out}}

<pre>89689 89753 64

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

for(i=3,1000000,j=nextprime(i+1);if(isprime(i)&&j-i>36&&issquare(j-i),print(i," ",j," ",j-i)))

=={{header|Perl}}==

use strict; # https://rosettacode.org/wiki/Find_adjacents_primes_which_difference_is_square_integer

(my $diff = $primeref->[$i] - $primeref->[$i - 1]) > 36 or next;

is_square($diff) and print "$primeref->[$i] - $primeref->[$i - 1] = $diff\n";

{{out}}

<pre>

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">limit</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1_000_000</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=={{header|Python}}==

import math

print("working...")

print("done...")

{{out}}

<pre>

=={{header|Raku}}==

use Math::Primesieve;

say "\nGap {$p.key}: {comma @counts[$p.key]} found$ten:";

put join "\n", $p.value.batch(5)».map({"($_, {$_+ $p.key})"})».join(', ');

{{out}}

<pre>Adjacent primes up to 10,000,000,000 with a gap value that is a perfect square:

=={{header|Ring}}==

load "stdlib.ring"

see "working..." + nl

next

return 0

{{out}}

<pre>

=={{header|Ruby}}==

Prime.each(1_000_000).each_cons(2) do |a, b|

puts "#{b} - #{a} = #{diff}" if isqrt*isqrt == diff

end

{{out}}

<pre>89753 - 89689 = 64

</pre>

=={{header|Sidef}}==

var upto = 1e6

}

p = q

{{out}}

<pre>

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "./fmt" for Fmt

}

}

{{out}}

=={{header|XPL0}}==

int N, I;

[for I:= 3 to sqrt(N) do

N:= N+1; \step by 1+1 = 2 (for odd numbers)

];

{{out}}