Special neighbor primes: Difference between revisions
(→{{header|ALGOL 68}}: Bug fix) |
|||
| Line 222: | Line 222: | ||
Found 103,611 special neighbor primes under 10,000,000. |
Found 103,611 special neighbor primes under 10,000,000. |
||
</pre> |
|||
=={{header|jq}}== |
|||
{{works with|jq}} |
|||
'''Works with gojq, the Go implementation of jq''' |
|||
This entry uses `is_prime` as defined at [[Erd%C5%91s-primes#jq]]. |
|||
<lang jq># Assumes . > 2 |
|||
def next_prime: |
|||
first(range(.+2; infinite) | select(is_prime)); |
|||
def specialNP($savePairs): |
|||
. as $limit |
|||
| {p1: 2, p2: 3} |
|||
| until( .p2 >= $limit; |
|||
if (.p1 + .p2 - 1 | is_prime) |
|||
then .pcount += 1 |
|||
| if $savePairs then .neighbors = .neighbors + [[.p1, .p2]] else . end |
|||
else . |
|||
end |
|||
| .p1 = .p2 |
|||
| .p2 = (.p1|next_prime) |
|||
) |
|||
| if $savePairs then {pcount, neighbors} else {pcount} end; |
|||
100|specialNP(true)</lang> |
|||
{{out}} |
|||
<pre> |
|||
{"pcount":13,"neighbors":[[3,5],[5,7],[7,11],[11,13],[13,17],[19,23],[29,31],[31,37],[41,43],[43,47],[61,67],[67,71],[73,79]]} |
|||
</pre> |
</pre> |
||
Revision as of 16:37, 3 September 2021
- Task
Let (p1, p2) are neighbor primes.
Find and show here in base ten if p1+ p2 -1 is prime, where p1, p2 < 100.
ALGOL 68
<lang algol68>BEGIN # find adjacent primes p1, p2 such that p1 + p2 - 1 is also prime #
INT max prime = 100;
# sieve the primes to max prime * 2 #
PR read "primes.incl.a68" PR
[]BOOL prime = PRIMESIEVE ( max prime * 2 );
# count the primes up to max prime #
INT p count := 0; FOR i TO max prime DO IF prime[ i ] THEN p count +:= 1 FI OD;
# construct a list of the primes up to max prime #
[ 1 : p count ]INT low prime;
INT low pos := 0;
FOR i WHILE low pos < UPB low prime DO IF prime[ i ] THEN low prime[ low pos +:= 1 ] := i FI OD;
# find the adjacent primes p1, p2 such that p1 + p2 - 1 is prime #
FOR i TO UPB low prime - 1 DO
IF INT p1 plus p2 minus 1 = ( low prime[ i ] + low prime[ i + 1 ] ) - 1;
prime[ p1 plus p2 minus 1 ]
THEN print( ( "(", whole( low prime[ i ], -3 )
, " +", whole( low prime[ i + 1 ], -3 )
, " ) - 1 = ", whole( p1 plus p2 minus 1, -3 )
, newline
)
)
FI
OD
END</lang>
- Output:
( 3 + 5 ) - 1 = 7 ( 5 + 7 ) - 1 = 11 ( 7 + 11 ) - 1 = 17 ( 11 + 13 ) - 1 = 23 ( 13 + 17 ) - 1 = 29 ( 19 + 23 ) - 1 = 41 ( 29 + 31 ) - 1 = 59 ( 31 + 37 ) - 1 = 67 ( 41 + 43 ) - 1 = 83 ( 43 + 47 ) - 1 = 89 ( 61 + 67 ) - 1 = 127 ( 67 + 71 ) - 1 = 137 ( 73 + 79 ) - 1 = 151
AWK
<lang AWK>
- syntax: GAWK -f SPECIAL_NEIGHBOR_PRIMES.AWK
BEGIN {
start = 3
stop = 99
old_prime = 2
for (n=start; n<=stop; n++) {
if (is_prime(n) && is_prime(old_prime)) {
sum = old_prime + n - 1
if (is_prime(sum)) {
count++
printf("%d,%d -> %d\n",old_prime,n,sum)
}
old_prime = n
}
}
printf("Special neighbor primes %d-%d: %d\n",start,stop,count)
exit(0)
} function is_prime(x, i) {
if (x <= 1) {
return(0)
}
for (i=2; i<=int(sqrt(x)); i++) {
if (x % i == 0) {
return(0)
}
}
return(1)
} </lang>
- Output:
3,5 -> 7 5,7 -> 11 7,11 -> 17 11,13 -> 23 13,17 -> 29 19,23 -> 41 29,31 -> 59 31,37 -> 67 41,43 -> 83 43,47 -> 89 61,67 -> 127 67,71 -> 137 73,79 -> 151 Special neighbor primes 3-99: 13
F#
This task uses Extensible Prime Generator (F#) <lang fsharp> // Special neighbor primes. Nigel Galloway: August 6th., 2021 pCache|>Seq.pairwise|>Seq.takeWhile(snd>>(>)100)|>Seq.filter(fun(n,g)->isPrime(n+g-1))|>Seq.iter(printfn "%A") </lang>
- Output:
(3, 5) (5, 7) (7, 11) (11, 13) (13, 17) (19, 23) (29, 31) (31, 37) (41, 43) (43, 47) (61, 67) (67, 71) (73, 79)
Factor
<lang factor>USING: kernel lists lists.lazy math math.primes math.primes.lists prettyprint sequences ;
lprimes dup cdr lzip [ sum 1 - prime? ] lfilter [ second 100 < ] lwhile [ . ] leach</lang>
- Output:
{ 3 5 }
{ 5 7 }
{ 7 11 }
{ 11 13 }
{ 13 17 }
{ 19 23 }
{ 29 31 }
{ 31 37 }
{ 41 43 }
{ 43 47 }
{ 61 67 }
{ 67 71 }
{ 73 79 }
Go
<lang go>package main
import (
"fmt" "rcu"
)
const MAX = 1e7 - 1
var primes = rcu.Primes(MAX)
func specialNP(limit int, showAll bool) {
if showAll {
fmt.Println("Neighbor primes, p1 and p2, where p1 + p2 - 1 is prime:")
}
count := 0
for i := 1; i < len(primes); i++ {
p2 := primes[i]
if p2 >= limit {
break
}
p1 := primes[i-1]
p3 := p1 + p2 - 1
if rcu.IsPrime(p3) {
if showAll {
fmt.Printf("(%2d, %2d) => %3d\n", p1, p2, p3)
}
count++
}
}
ccount := rcu.Commatize(count)
climit := rcu.Commatize(limit)
fmt.Printf("\nFound %s special neighbor primes under %s.\n", ccount, climit)
}
func main() {
specialNP(100, true)
var pow = 1000
for i := 3; i < 8; i++ {
specialNP(pow, false)
pow *= 10
}
}</lang>
- Output:
Neighbor primes, p1 and p2, where p1 + p2 - 1 is prime: ( 3, 5) => 7 ( 5, 7) => 11 ( 7, 11) => 17 (11, 13) => 23 (13, 17) => 29 (19, 23) => 41 (29, 31) => 59 (31, 37) => 67 (41, 43) => 83 (43, 47) => 89 (61, 67) => 127 (67, 71) => 137 (73, 79) => 151 Found 13 special neighbor primes under 100. Found 71 special neighbor primes under 1,000. Found 367 special neighbor primes under 10,000. Found 2,165 special neighbor primes under 100,000. Found 14,526 special neighbor primes under 1,000,000. Found 103,611 special neighbor primes under 10,000,000.
jq
Works with gojq, the Go implementation of jq
This entry uses `is_prime` as defined at Erdős-primes#jq. <lang jq># Assumes . > 2 def next_prime:
first(range(.+2; infinite) | select(is_prime));
def specialNP($savePairs):
. as $limit
| {p1: 2, p2: 3}
| until( .p2 >= $limit;
if (.p1 + .p2 - 1 | is_prime)
then .pcount += 1
| if $savePairs then .neighbors = .neighbors + .p1, .p2 else . end
else .
end
| .p1 = .p2
| .p2 = (.p1|next_prime)
)
| if $savePairs then {pcount, neighbors} else {pcount} end;
100|specialNP(true)</lang>
- Output:
{"pcount":13,"neighbors":[[3,5],[5,7],[7,11],[11,13],[13,17],[19,23],[29,31],[31,37],[41,43],[43,47],[61,67],[67,71],[73,79]]}
Julia
<lang julia>using Primes
function specialneighbors(N, savepairs=true)
neighbors, p1, pcount = Pair{Int}[], 2, 0
while (p2 = nextprime(p1 + 1)) < N
if isprime(p2 + p1 - 1)
savepairs && push!(neighbors, p1 => p2)
pcount += 1
end
p1 = p2
end
return neighbors, pcount
end
spn, n = specialneighbors(100) println("$n special neighbor prime pairs under 100:") println("p1 p2 p1 + p2 - 1\n--------------------------") for (p1, p2) in specialneighbors(100)[1]
println(lpad(p1, 2), " ", rpad(p2, 7), p1 + p2 - 1)
end
print("\nCount of such prime pairs under 1,000,000,000: ",
specialneighbors(1_000_000_000, false)[2])
</lang>
- Output:
13 special neighbor prime pairs under 100: p1 p2 p1 + p2 - 1 -------------------------- 3 5 7 5 7 11 7 11 17 11 13 23 13 17 29 19 23 41 29 31 59 31 37 67 41 43 83 43 47 89 61 67 127 67 71 137 73 79 151 Count of such prime pairs under 1,000,000,000: 6041231
Nim
<lang Nim>import strutils, sugar
const Max = 100 - 1
func isPrime(n: Positive): bool =
if n == 1: return false if n mod 2 == 0: return n == 2 for d in countup(3, n, 2): if d * d > n: break if n mod d == 0: return false result = true
const Primes = collect(newSeq):
for n in 2..Max:
if n.isPrime: n
let list = collect(newSeq):
for i in 0..<Primes.high:
let p1 = Primes[i]
let p2 = Primes[i + 1]
if (p1 + p2 - 1).isPrime: (p1, p2)
echo "Found $1 special neighbor primes less than $2:".format(list.len, Max + 1) echo list.join(", ")</lang>
- Output:
Found 13 special neighbor primes less than 100: (3, 5), (5, 7), (7, 11), (11, 13), (13, 17), (19, 23), (29, 31), (31, 37), (41, 43), (43, 47), (61, 67), (67, 71), (73, 79)
Perl
<lang perl>#!/usr/bin/perl
use strict; # https://rosettacode.org/wiki/Special_neighbor_primes use warnings; use ntheory qw( primes is_prime );
my @primes = @{ primes(100) }; for ( 1 .. $#primes )
{
is_prime( $@ = $primes[$_-1] + $primes[$_] - 1 ) and
printf "%2d + %2d - 1 = %3d\n", $primes[$_-1], $primes[$_], $@;
}</lang>
- Output:
3 + 5 - 1 = 7 5 + 7 - 1 = 11 7 + 11 - 1 = 17 11 + 13 - 1 = 23 13 + 17 - 1 = 29 19 + 23 - 1 = 41 29 + 31 - 1 = 59 31 + 37 - 1 = 67 41 + 43 - 1 = 83 43 + 47 - 1 = 89 61 + 67 - 1 = 127 67 + 71 - 1 = 137 73 + 79 - 1 = 151
Phix
with javascript_semantics function np(integer n) return is_prime(get_prime(n)+get_prime(n+1)-1) end function function npt(integer p) return filter(tagset(length(get_primes_le(p))-1),np) end function sequence s = npt(100) printf(1,"Found %d special neighbour primes < 100:\n",length(s)) for i=1 to length(s) do integer si = s[i], pi = get_prime(si), pj = get_prime(si+1) printf(1," (%2d,%2d) => %d\n",{pi,pj,pi+pj-1}) end for printf(1,"\n") for i=2 to 7 do integer p = power(10,i), l = length(npt(p)) printf(1,"Found %,d special neighbour primes < %,d\n",{l,p}) end for
- Output:
Found 13 special neighbour primes < 100: ( 3, 5) => 7 ( 5, 7) => 11 ( 7,11) => 17 (11,13) => 23 (13,17) => 29 (19,23) => 41 (29,31) => 59 (31,37) => 67 (41,43) => 83 (43,47) => 89 (61,67) => 127 (67,71) => 137 (73,79) => 151 Found 13 special neighbour primes < 100 Found 71 special neighbour primes < 1,000 Found 367 special neighbour primes < 10,000 Found 2,165 special neighbour primes < 100,000 Found 14,526 special neighbour primes < 1,000,000 Found 103,611 special neighbour primes < 10,000,000
Raku
<lang perl6># 20210809 Raku programming solution
for (grep {.is-prime}, 3..*).rotor(2 => -1) -> (\P1,\P2) {
last if P2 ≥ Ⅽ; ($_ = P1+P2-1).is-prime and printf "%2d, %2d => %3d\n", P1, P2, $_
}</lang>
- Output:
3, 5 => 7 5, 7 => 11 7, 11 => 17 11, 13 => 23 13, 17 => 29 19, 23 => 41 29, 31 => 59 31, 37 => 67 41, 43 => 83 43, 47 => 89 61, 67 => 127 67, 71 => 137 73, 79 => 151
REXX
A little extra code was added to present the results in a grid-like format. <lang rexx>/*REXX pgm finds special neighbor primes: P1, P2, P1+P2-1 are prime, and P1 and P2<100*/ parse arg hi cols . /*obtain optional argument from the CL.*/ if hi== | hi=="," then hi= 100 /*Not specified? Then use the default.*/ if cols== | cols=="," then cols= 5 /* " " " " " " */ call genP hi /*build semaphore array for low primes.*/
do p=1 while @.p<hi
end /*p*/; lim= p-1; q= p+1 /*set LIM to prime for P; calc. 2nd HI.*/
- m= # - 1
call genP @.# + @.#m - 1 /*build semaphore array for high primes*/ w= 20 /*width of a number in any column. */ title= ' special neighbor primes: P1, P2, P1+P2-1 are primes, and P1 and P2 < ' ,
commas(hi)
if cols>0 then say ' index │'center(title, 1 + cols*(w+1) ) if cols>0 then say '───────┼'center("" , 1 + cols*(w+1), '─') found= 0; idx= 1 /*initialize # neighbor primes & index.*/ $= /*a list of neighbor primes (so far).*/
do j=1 to lim; jp= j+1; q= @.jp /*look for neighbor primes within range*/
y= @.j + q - 1; if \!.y then iterate /*is X also a prime? No, then skip it.*/
found= found + 1 /*bump the number of neighbor primes. */
if cols==0 then iterate /*Build the list (to be shown later)? */
$= $ right( @.j','q"──►"y, w) /*add neighbor prime ──► the $ list. */
if found//cols\==0 then iterate /*have we populated a line of output? */
say center(idx, 7)'│' substr($, 2); $= /*display what we have so far (cols). */
idx= idx + cols /*bump the index count for the output*/
end /*j*/
if $\== then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/ if cols>0 then say '───────┴'center("" , 1 + cols*(w+1), '─') say say 'Found ' commas(found) title exit 0 /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ? /*──────────────────────────────────────────────────────────────────────────────────────*/ genP: !.= 0; parse arg limit /*placeholders for primes (semaphores).*/
@.1=2; @.2=3; @.3=5; @.4=7; @.5=11 /*define some low primes. */
!.2=1; !.3=1; !.5=1; !.7=1; !.11=1 /* " " " " flags. */
#=5; sq.#= @.# **2 /*number of primes so far; prime². */
/* [↓] generate more primes ≤ high.*/
do j=@.#+2 by 2 to limit /*find odd primes from here on. */
parse var j -1 _; if _==5 then iterate /*J ÷ by 5? (right digit).*/
if j//3==0 then iterate; if j//7==0 then iterate /*" " " 3? J ÷ by 7? */
do k=5 while sq.k<=j /* [↓] divide by the known odd primes.*/
if j // @.k == 0 then iterate j /*Is J ÷ X? Then not prime. ___ */
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; sq.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return</lang>
- output when using the default inputs:
index │ special neighbor primes: P1, P2, P1+P2-1 are primes, and P1 and P2 < 100 ───────┼────────────────────────────────────────────────────────────────────────────────────────────────────────── 1 │ 3,5──►7 5,7──►11 7,11──►17 11,13──►23 13,17──►29 6 │ 19,23──►41 29,31──►59 31,37──►67 41,43──►83 43,47──►89 11 │ 61,67──►127 67,71──►137 73,79──►151 ───────┴────────────────────────────────────────────────────────────────────────────────────────────────────────── Found 13 special neighbor primes: P1, P2, P1+P2-1 are primes, and P1 and P2 < 100
Ring
<lang ring> load "stdlib.ring"
see "working..." + nl see "Special neighbor primes are:" + nl row = 0 oldPrime = 2
for n = 3 to 100
if isprime(n) and isprime(oldPrime)
sum = oldPrime + n - 1
if isprime(sum)
row++
see "" + oldPrime + "," + n + " => " + sum + nl
ok
oldPrime = n
ok
next
see "Found " + row + " special neighbor primes" see "done..." + nl </lang>
- Output:
working... Special neighbor primes are: 3,5 => 7 5,7 => 11 7,11 => 17 11,13 => 23 13,17 => 29 19,23 => 41 29,31 => 59 31,37 => 67 41,43 => 83 43,47 => 89 61,67 => 127 67,71 => 137 73,79 => 151 Found 13 special neighbor primes done...
Sidef
<lang ruby>func special_neighbor_primes(upto) {
var list = []
upto.primes.each_cons(2, {|p1,p2|
var n = (p1 + p2 - 1)
if (n.is_prime) {
list << [p1, p2, n]
}
})
return list
}
with (100) {|n|
var list = special_neighbor_primes(n)
say "Found #{list.len} special neighbour primes < n:"
list.each_2d {|p1,p2,q|
printf(" (%2s, %2s) => %s\n", p1, p2, q)
}
}
say
for n in (1..7) {
var list = special_neighbor_primes(10**n)
say "Found #{list.len} special neighbour primes < 10^#{n}"
}</lang>
- Output:
Found 13 special neighbour primes < n: ( 3, 5) => 7 ( 5, 7) => 11 ( 7, 11) => 17 (11, 13) => 23 (13, 17) => 29 (19, 23) => 41 (29, 31) => 59 (31, 37) => 67 (41, 43) => 83 (43, 47) => 89 (61, 67) => 127 (67, 71) => 137 (73, 79) => 151 Found 2 special neighbour primes < 10^1 Found 13 special neighbour primes < 10^2 Found 71 special neighbour primes < 10^3 Found 367 special neighbour primes < 10^4 Found 2165 special neighbour primes < 10^5 Found 14526 special neighbour primes < 10^6 Found 103611 special neighbour primes < 10^7
Wren
I assume that 'neighbor' primes means pairs of successive primes.
Anticipating a likely stretch goal. <lang ecmascript>import "/math" for Int import "/fmt" for Fmt
var max = 1e7 - 1 var primes = Int.primeSieve(max)
var specialNP = Fn.new { |limit, showAll|
if (showAll) System.print("Neighbor primes, p1 and p2, where p1 + p2 - 1 is prime:")
var count = 0
var p3
for (i in 1...primes.where { |p| p < limit }.count) {
var p2 = primes[i]
var p1 = primes[i-1]
if (Int.isPrime(p3 = p1 + p2 - 1)) {
if (showAll) Fmt.print("($2d, $2d) => $3d", p1, p2, p3)
count = count + 1
}
}
Fmt.print("\nFound $,d special neighbor primes under $,d.", count, limit)
}
specialNP.call(100, true) for (i in 3..7) {
specialNP.call(10.pow(i), false)
}</lang>
- Output:
Neighbor primes, p1 and p2, where p1 + p2 - 1 is prime: ( 3, 5) => 7 ( 5, 7) => 11 ( 7, 11) => 17 (11, 13) => 23 (13, 17) => 29 (19, 23) => 41 (29, 31) => 59 (31, 37) => 67 (41, 43) => 83 (43, 47) => 89 (61, 67) => 127 (67, 71) => 137 (73, 79) => 151 Found 13 special neighbor primes under 100. Found 71 special neighbor primes under 1,000. Found 367 special neighbor primes under 10,000. Found 2,165 special neighbor primes under 100,000. Found 14,526 special neighbor primes under 1,000,000. Found 103,611 special neighbor primes under 10,000,000.
XPL0
<lang XPL0>func IsPrime(N); \Return 'true' if N is a prime number int N, I; [if N <= 1 then return false; for I:= 2 to sqrt(N) do
if rem(N/I) = 0 then return false;
return true; ];
int P, P1, P2; [P:= 2; loop [P1:= P;
repeat P:= P+1;
if P >= 100 then quit;
until IsPrime(P);
P2:= P;
if IsPrime(P1+P2-1) then
[IntOut(0, P1); ChOut(0, ^ );
IntOut(0, P2); ChOut(0, ^ );
IntOut(0, P1+P2-1); CrLf(0);
];
];
]</lang>
- Output:
3 5 7 5 7 11 7 11 17 11 13 23 13 17 29 19 23 41 29 31 59 31 37 67 41 43 83 43 47 89 61 67 127 67 71 137 73 79 151