Cousin primes: Difference between revisions

{{trans|Nim}}

F isPrime(n)

L(cousins) cousinList

print(String(cousins).center(10), end' I (L.index + 1) % 7 == 0 {"\n"} E ‘ ’)

{{out}}

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

{{libheader|Action! Sieve of Eratosthenes}}

PROC Main()

OD

PrintF("%E%EThere are %I pairs",count)

{{out}}

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

=={{header|Ada}}==

procedure Cousin_Primes is

New_Line;

Put_Line (Count'Image & " pairs.");

{{out}}

<pre>[ 3, 7] [ 7, 11] [ 13, 17] [ 19, 23] [ 37, 41] [ 43, 47] [ 67, 71] [ 79, 83]

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

{{libheader|ALGOL 68-primes}}

# sieve the primes as required by the task #

PR read "primes.incl.a68" PR

OD;

print( ( newline, "Found ", whole( p count, 0 ), " cousin primes", newline ) )

{{out}}

<pre>

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

integer MAX_PRIME;

MAX_PRIME := 1000;

write( i_w := 1, s_w := 0, "Found ", cCount, " cousin prime pairs up to ", MAX_PRIME )

end

{{out}}

<pre>

=={{header|APL}}==

{{out}}

=={{header|AppleScript}}==

script o

property numberList : {missing value}

if (p - 4 is in primes) then set end of output to {p - 4, p's contents}

end repeat

{{output}}

=={{header|Arturo}}==

primesUpto: select 0..upto => prime?

return select primesUpto => [prime? & + 4]

]

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f COUSIN_PRIMES.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

=={{header|BASIC}}==

20 FOR P=2 TO SQR(L)

30 IF S(P) THEN 50

80 IF S(P)+S(P+4)=0 THEN N=N+1: PRINT P,P+4

90 NEXT

{{out}}

=={{header|BCPL}}==

manifest $( LIMIT = 1000 $)

$)

writef("*N%N pairs found.*N", count)

{{out}}

<pre style="height:14em;">3, 7

=={{header|C}}==

#include <string.h>

printf("There are %d cousin prime pairs below %d.\n", count, LIMIT);

return 0;

{{out}}

=={{header|COBOL}}==

PROGRAM-ID. COUSIN-PRIMES.

FLAG-PRIME. MOVE 1 TO PRIME-FLAG(Q).

UNFLAG-PRIME. MOVE 0 TO PRIME-FLAG(Q).

{{out}}

<pre style='height:14em;'> 3 7

=={{header|Cowgol}}==

const LIMIT := 1000;

print(" cousin prime pairs below ");

print_i16(LIMIT);

{{out}}

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

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

// Cousin Primes: Nigel Galloway. April 2nd., 2021

primes32()|>Seq.pairwise|>Seq.takeWhile(fun(_,n)->n<1000)|>Seq.filter(fun(n,g)->g-n=4)|>Seq.iter(fun(n,g)->printf "(%d,%d) "n g); printfn ""

{{out}}

<pre>

=={{header|Factor}}==

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

sequences ;

[ [ prime? ] all? ] lfilter ;

{{out}}

<pre style="height:14em">

=={{header|FOCAL}}==

01.20 T %4

01.30 F N=3,2,996;D 2

03.50 S K=K+1

03.60 G 3.2

{{out}}

=={{header|Forth}}==

{{works with|Gforth}}

: not-prime! ( n -- ) here + 1 swap c! ;

1000 cousin-primes

{{out}}

Use one of the primality testing examples as an include.

dim as uinteger c=0, i

print using "Pair ##: #### and ####"; c; i; i+4

end if

{{out}}

=={{header|Go}}==

{{trans|Wren}}

import "fmt"

}

fmt.Printf("\n\n%d pairs found\n", count)

{{out}}

=={{header|Haskell}}==

import Data.List.Split (chunksOf)

import Data.Numbers.Primes (isPrime, primes)

let ws = maximum . fmap length <$> transpose rows

pw = printf . flip intercalate ["%", "s"] . show

{{Out}}

<pre>41 cousin prime pairs:

=={{header|J}}==

{{out}}

<pre style="height:14em;"> 3 7

'''Works with gojq, the Go implementation of jq'''

def cousins:

# [2,6] is not a cousin so we can start at 3

| [., .+4];

{{out}}

See below.

'''The Count'''

{{out}}

<pre>

=={{header|Julia}}==

{{trans|Wren}}

let

println("\n\n$pcount pairs found.")

end

<pre>

Cousin prime pairs under 1,000:

=={{header|MAD}}==

BOOLEAN PRIME

DIMENSION PRIME(1000)

VECTOR VALUES COUSIN = $I4,2H: ,I4*$

VECTOR VALUES TOTAL = $15HTOTAL COUSINS: ,I2*$

{{out}}

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

primes = {primes, primes + 4} // Transpose;

Select[primes, AllTrue[PrimeQ]]

{{out}}

<pre>{{3,7},{7,11},{13,17},{19,23},{37,41},{43,47},{67,71},{79,83},{97,101},{103,107},{109,113},{127,131},{163,167},{193,197},{223,227},{229,233},{277,281},{307,311},{313,317},{349,353},{379,383},{397,401},{439,443},{457,461},{463,467},{487,491},{499,503},{613,617},{643,647},{673,677},{739,743},{757,761},{769,773},{823,827},{853,857},{859,863},{877,881},{883,887},{907,911},{937,941},{967,971}}

=={{header|Nim}}==

We use a simple primality test (which is in fact executed at compile time). For large values of N, it would be better to use a sieve of Erathostenes and to replace the constants “PrimeList” and “PrimeSet” by read-only variables.

const N = 1000

stdout.write ($cousins).center(10)

stdout.write if (i+1) mod 7 == 0: '\n' else: ' '

{{out}}

{{works with|Free Pascal}}

{{works with|Delphi}}Sieving only odd numbers.

//Free Pascal Compiler version 3.2.1 [2020/11/03] for x86_64fpc

{$IFDEF FPC}

setlength(primes,0);

{{out}}

<pre>

=={{header|Perl}}==

{{libheader|ntheory}}

use feature 'say';

use ntheory 'is_prime';

my($limit, @cp) = 1000;

is_prime($_) and is_prime($_+4) and push @cp, "$_/@{[$_+4]}" for 2..$limit;

{{out}}

<pre>41 cousin prime pairs < 1000:

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">has_cousin</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">+</span><span style="color: #000000;">4</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">7</span> <span style="color: #008080;">do</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%,d cousin prime pairs less than %,d found: %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #000000;">tn</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">min</span><span style="color: #0000FF;">(</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">-</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)))})</span>

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

<small>(Uses tn-9 instead of the more obvious tn-4 since none of 96,95,94,93,92 or similar with 9..99999 prefix could ever be prime. Note that {97,101} is deliberately excluded from < 100.)</small>

{{out}}

=={{header|Python}}==

from itertools import chain, takewhile

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>41 cousin pairs below 1000:

=={{header|REXX}}==

This REXX version allows the limit to be specified, &nbsp; as well as the number of cousin prime pairs to be shown per line.

parse arg hi cols . /*get optional number of primes to find*/

if hi=='' | hi=="," then hi= 1000 /*Not specified? Then assume default.*/

#= # + 1; @.#= j; !.j= 1 /*bump prime count; assign prime & flag*/

end /*j*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

===Filter===

Favoring brevity over efficiency due to the small range of n, the most concise solution is:

{{out}}

<pre>

A more efficient and versatile approach is to generate an infinite list of cousin primes, using this info from https://oeis.org/A023200 :

:Apart from the first term, all terms are of the form 6n + 1.

my $count = @cousins.first: :k, *.[0] > 1000;

{{out}}

<pre>

=={{header|Ring}}==

load "stdlib.ring"

see "done..." + nl

{{out}}

<pre>

=={{header|Ruby}}==

primes = Prime.each(1000).to_a

p cousins = primes.filter_map{|pr| [pr, pr+4] if primes.include?(pr+4) }

puts "#{cousins.size} cousins found."

{{out}}

<pre>[[3, 7], [7, 11], [13, 17], [19, 23], [37, 41], [43, 47], [67, 71], [79, 83], [97, 101], [103, 107], [109, 113], [127, 131], [163, 167], [193, 197], [223, 227], [229, 233], [277, 281], [307, 311], [313, 317], [349, 353], [379, 383], [397, 401], [439, 443], [457, 461], [463, 467], [487, 491], [499, 503], [613, 617], [643, 647], [673, 677], [739, 743], [757, 761], [769, 773], [823, 827], [853, 857], [859, 863], [877, 881], [883, 887], [907, 911], [937, 941], [967, 971]]

=={{header|Seed7}}==

const func boolean: isPrime (in integer: number) is func

end for;

writeln("\n" <& count <& " cousin prime pairs found < 1000.");

{{out}}

<pre style="height:14em">

=={{header|Sidef}}==

var pairs = (limit-5).primes.map { [_, _+4] }.grep { .tail.is_prime }

say "Cousin prime pairs whose elements are less than #{limit.commify}:"

say pairs

{{out}}

<pre>

=={{header|Swift}}==

func primeSieve(limit: Int) -> [Bool] {

}

}

{{out}}

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

i = i + 2

}

{{out}}