Double Twin Primes

From Rosetta Code
Double Twin Primes is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Definition
Let (p1,p2) and (p3,p4) be twin primes where p3 - p2 = 4.
Such primes called Double Twin Primes

Example
[5,7,11,13]
Task
Find and show here all Double Twin Primes under 1000.

See also



ALGOL 68[edit]

BEGIN # find some sequences of primes where the gaps between the elements #
      # are 2, 4, 2 - i.e., n, n+2, n+6 and n+8 are all prime             #
    PR read "primes.incl.a68" PR                # include prime utilities #
    []BOOL prime  = PRIMESIEVE 1 000;
    INT    count := 0;
    INT    p     := 3;        # 2 cannot be a twin prime, so start with 3 #
    WHILE p <= UPB prime - 8 DO
        BOOL is double twin := FALSE;
        IF prime[ p ] THEN
            IF prime[ p + 2 ] THEN
                IF prime[ p + 6 ] THEN
                    IF prime[ p + 8 ] THEN
                        count         +:= 1;
                        is double twin := TRUE;
                        print( ( "["
                               , whole( p,     -4 ), whole( p + 2, -4 )
                               , whole( p + 6, -4 ), whole( p + 8, -4 )
                               , " ]"
                               , newline
                               )
                             )
                    FI
                FI
            FI
        FI;
        p +:= IF is double twin THEN 6 ELSE 2 FI
    OD;
    print( ( "Found ", whole( count, 0 ), " double twin primes below ", whole( UPB prime, 0 ), newline ) )
END
Output:
[   5   7  11  13 ]
[  11  13  17  19 ]
[ 101 103 107 109 ]
[ 191 193 197 199 ]
[ 821 823 827 829 ]
Found 5 double twin primes beflow 1000

Arturo[edit]

r: range .step: 2 1 1000
r | map 'x -> @[x x+2 x+6 x+8]
  | select => [every? & => prime?]
  | loop => print
Output:
5 7 11 13
11 13 17 19
101 103 107 109
191 193 197 199
821 823 827 829

BASIC[edit]

BASIC256[edit]

Translation of: FreeBASIC
#include "isPrime.kbs"

num = 3
while num < 992
	if isPrime(num) then
		if isPrime(num+2) then
			if isPrime(num+6) then
				if isPrime(num+8) then print num; " "; num+2; " "; num+6; " "; num+8
			end if
		end if
	end if
	num += 2
end while
end
Output:
Same as FreeBASIC entry.

Gambas[edit]

Translation of: FreeBASIC
Public Sub Main() 

  Dim num As Integer = 3 
  Do 
    If isPrime(num) Then 
      If isPrime(num + 2) Then 
        If isPrime(num + 6) Then 
          If isPrime(num + 8) Then Print num; " "; num + 2; " "; num + 6; " "; num + 8 
        End If 
      End If 
    End If 
    num += 2 
  Loop Until num > 992

End 

Public Sub isPrime(ValorEval As Long) As Boolean   
  
  If ValorEval < 2 Then Return False   
  If ValorEval Mod 2 = 0 Then Return ValorEval = 2   
  If ValorEval Mod 3 = 0 Then Return ValorEval = 3   
  Dim d As Long = 5   
  While d * d <= ValorEval   
    If ValorEval Mod d = 0 Then Return False Else d += 2   
  Wend    
  Return True   
  
End Function
Output:
Same as FreeBASIC entry.

PureBasic[edit]

Translation of: FreeBASIC
Procedure.b isPrime(v.i)
  If     v <= 1    : ProcedureReturn #False
  ElseIf v < 4     : ProcedureReturn #True
  ElseIf v % 2 = 0 : ProcedureReturn #False
  ElseIf v < 9     : ProcedureReturn #True
  ElseIf v % 3 = 0 : ProcedureReturn #False
  Else
    Protected r = Round(Sqr(v), #PB_Round_Down)
    Protected f = 5
    While f <= r
      If v % f = 0 Or v % (f + 2) = 0
        ProcedureReturn #False
      EndIf
      f + 6
    Wend
  EndIf
  ProcedureReturn #True
EndProcedure

OpenConsole()
num.I = 3
While num < 992
  If isPrime(num):
    If isPrime(num+2):
      If isPrime(num+6):
        If isPrime(num+8):
          PrintN(Str(num) + " " + Str(num+2) + " " + Str(num+6) + " " + Str(num+8))
        EndIf
      EndIf
    EndIf
  EndIf
  num + 2
Wend

Input()
CloseConsole();
Output:
Same as FreeBASIC entry.

Run BASIC[edit]

Translation of: FreeBASIC
function isPrime(n)
if n < 2       then isPrime = 0 : goto [exit]
if n = 2       then isPrime = 1 : goto [exit]
if n mod 2 = 0 then isPrime = 0 : goto [exit]
isPrime = 1
for i = 3 to int(n^.5) step 2
  if n mod i = 0 then isPrime = 0 : goto [exit]
next i
[exit]
end function

num = 3
while num < 992
    if isPrime(num) then
        if isPrime(num+2) then
            if isPrime(num+6) then
                if isPrime(num+8) then print num; " "; num+2; " "; num+6; " "; num+8
            end if
        end if
    end if
    num = num + 2
wend
end
Output:
Same as FreeBASIC entry.

Tiny BASIC[edit]

REM Rosetta Code problem: https://rosettacode.org/wiki/Double_Twin_Primes
REM by Jjuanhdez, 03/2023

    LET I = 3
 10 LET X = I
    GOSUB 100
	IF Z = 1 THEN LET X = I + 2
	IF Z = 1 THEN GOSUB 100
	IF Z = 1 THEN LET X = I + 6
	IF Z = 1 THEN GOSUB 100	
	IF Z = 1 THEN LET X = I + 8
	IF Z = 1 THEN GOSUB 100
	IF Z = 1 THEN PRINT I, " ", I + 2, " ", I + 6, " ", I + 8 
    LET I = I + 2
	IF I > 992 THEN GOTO 20
	GOTO 10
 20 END

100 REM is X a prime? Z=1 for yes, 0 for no
    LET Z = 1
    IF X = 3 THEN RETURN
    IF X = 2 THEN RETURN    
    LET A = 1
110 LET A = A + 1
    IF (X / A) * A = X THEN GOTO 120
    IF A * A <= X THEN GOTO 110
    RETURN
120 LET Z = 0
    RETURN
Same as FreeBASIC entry.

XBasic[edit]

Translation of: BASIC256
Works with: Windows XBasic
PROGRAM  "DoubleTwinPrimes"
VERSION  "0.0000"

DECLARE FUNCTION Entry ()
INTERNAL FUNCTION ISPrime(n%%)

FUNCTION  Entry ()
num%% = 3
DO
  IF ISPrime(num%%) THEN
    IF ISPrime(num%%+2) THEN
      IF ISPrime(num%%+6) THEN
        IF ISPrime(num%%+8) THEN
          PRINT num%%; num%%+2; num%%+6; num%%+8
        ENDIF
      ENDIF
    ENDIF
  ENDIF
  num%% = num%% + 2
LOOP UNTIL num%% > 992
END FUNCTION

FUNCTION ISPrime(n%%)
  IF n%% < 2 THEN RETURN $$FALSE
  IF n%% MOD 2 = 0 THEN RETURN n%% = 2
  IF n%% MOD 3 = 0 THEN RETURN n%% = 3
  d%% = 5
  DO WHILE d%% * d%% <= n%%
      IF n%% MOD d%% = 0 THEN RETURN $$FALSE ELSE d%% = d%% + 2
  LOOP
  RETURN $$TRUE
END FUNCTION
END PROGRAM
Output:
Same as BASIC256 entry.

Yabasic[edit]

Translation of: FreeBASIC
//import isPrime

num = 3
repeat
    if isPrime(num) if isPrime(num+2) if isPrime(num+6) if isPrime(num+8) print num, " ", num+2, " ", num+6, " ", num+8
    num = num + 2
until num > 992
end
Output:
Same as FreeBASIC entry.

C[edit]

#include <stdio.h>
#include <stdbool.h>

bool isPrime(int n) {
    if (n < 2) return false;
    if (n%2 == 0) return n == 2;
    if (n%3 == 0) return n == 3;
    int d = 5;
    while (d*d <= n) {
        if (n%d == 0) return false;
        d += 2;
        if (n%d == 0) return false;
        d += 4;
    }
    return true;
}

int main() {
    printf("Double twin primes under 1,000:\n");
    for (int i = 3; i < 992; i+=2) {
        if (isPrime(i) && isPrime(i+2) && isPrime(i+6) && isPrime(i+8)) {
            printf("%4d %4d %4d %4d\n", i, i+2, i+6, i+8);
        }
    }    
    return 0;
}
Output:
Double twin primes under 1,000:
   5    7   11   13
  11   13   17   19
 101  103  107  109
 191  193  197  199
 821  823  827  829

Dart[edit]

import 'dart:math';

void main() {
  for (int num = 3; num < 992; num += 2) {
    if (isPrime(num) &&
        isPrime(num + 2) &&
        isPrime(num + 6) &&
        isPrime(num + 8)) {
      print("$num ${num + 2} ${num + 6} ${num + 8}");
    }
  }
}

bool isPrime(int n) {
  if (n <= 1) return false;
  if (n == 2) return true;
  for (int i = 2; i <= sqrt(n); ++i) {
    if (n % i == 0) return false;
  }
  return true;
}
Output:
Same as FreeBASIC entry.

Delphi[edit]

Works with: Delphi version 6.0

Uses standard TList as FIFO to hold and test groups of four sequentail prime numbers.

function IsPrime(N: integer): boolean;
{Fast, optimised prime test}
var I,Stop: integer;
begin
if (N = 2) or (N=3) then Result:=true
else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
else
     begin
     I:=5;
     Stop:=Trunc(sqrt(N));
     Result:=False;
     while I<=Stop do
           begin
           if ((N mod I) = 0) or ((N mod (I + 2)) = 0) then exit;
           Inc(I,6);
           end;
     Result:=True;
     end;
end;


function GetNextPrime(var Start: integer): integer;
{Get the next prime number after Start}
{Start is passed by "reference," so the
{original variable is incremented}
begin
repeat Inc(Start)
until IsPrime(Start);
Result:=Start;
end;

procedure ShowDoubleTwinPrimes(Memo: TMemo);
{Find sets of four primes P1,P2,P3,P4, where}
{P2-P1=2 P4-P3=2 and P3-P2=4 }
{Use TList as FIFO to test all four-prime combinations}
var LS: TList;
var Start: integer;
begin
LS:=TList.Create;
try
Start:=0;
while true do
	begin
	{Put four primes in the list}
	repeat LS.Add(Pointer(GetNextPrime(Start)))
	until LS.Count=4;
	if Integer(LS[3])>=1000 then break;
	{Test if they are double twin prime}
	if (Integer(LS[1])-Integer(LS[0])=2) and
	   (Integer(LS[3])-Integer(LS[2])=2) and
	   (Integer(LS[2])-Integer(LS[1])=4) then
	   	begin
	   	{Display the result}
	   	Memo.Lines.Add(IntToStr(Integer(LS[0]))+' '+
			IntToStr(Integer(LS[1]))+' '+
			IntToStr(Integer(LS[2]))+' '+
			IntToStr(Integer(LS[3])));
		end;
	{Delete the first prime}
	LS.Delete(0);
	end;
finally LS.Free; end;
end;
Output:
5 7 11 13
11 13 17 19
101 103 107 109
191 193 197 199
821 823 827 829


FreeBASIC[edit]

#include "isprime.bas"

Dim As Uinteger num = 3
Do
    If isPrime(num) Then
        If isPrime(num+2) Then
            If isPrime(num+6) Then
                If isPrime(num+8) Then Print num; " "; num+2; " "; num+6; " "; num+8
            End If
        End If
    End If
    num += 2
Loop Until num > 992

Sleep
Output:
5 7 11 13
11 13 17 19
101 103 107 109
191 193 197 199
821 823 827 829

FutureBasic[edit]

local fn IsPrime( n as long ) as BOOL
  long i
  BOOL result = YES
  
  if ( n < 2 ) then result = NO : exit fn
  for i = 2 to n + 1
    if ( i * i <= n ) and ( n mod i == 0 )
      result = NO : exit fn
    end if
  next
end fn = result

local fn DoubleTwinPrimes( limit as long )
  NSUInteger num = 3
  printf @"Double twin primes < %ld:", limit
  do
    if fn IsPrime( num )
      if fn IsPrime( num + 2 )
        if fn IsPrime( num + 6 )
          if fn IsPrime( num + 8 ) then printf @"%4lu%7lu%7lu%7lu", num, num + 2, num + 6, num + 8
        end if
      end if
    end if
    num += 2
  until ( num > limit )
end fn

fn DoubleTwinPrimes( 2000 )

HandleEvents
Output:
Double twin primes < 2000:
   5      7     11     13
  11     13     17     19
 101    103    107    109
 191    193    197    199
 821    823    827    829
1481   1483   1487   1489
1871   1873   1877   1879


Go[edit]

Translation of: Wren
Library: Go-rcu
package main

import (
    "fmt"
    "rcu"
)

func main() {
    p := rcu.Primes(1000)
    fmt.Println("Double twin primes under 1,000:")
    for i := 1; i < len(p)-3; i++ {
        if p[i+1]-p[i] == 2 && p[i+2]-p[i+1] == 4 && p[i+3]-p[i+2] == 2 {
            fmt.Printf("%4d\n", p[i:i+4])
        }
    }
}
Output:
Double twin primes under 1,000:
[   5    7   11   13]
[  11   13   17   19]
[ 101  103  107  109]
[ 191  193  197  199]
[ 821  823  827  829]

J[edit]

   _6 _4 0 2+/~(#~ 0,4=2-~/\])p:~.,0 1+/~/I.2=2 -~/\ i.&.(p:inv) 1000
  5   7  11  13
 11  13  17  19
101 103 107 109
191 193 197 199
821 823 827 829

Breaking this down:

   primes=: i.&.(p:inv) 1000
   twinprimes=:  p:~.,0 1+/~/I.2=2 -~/\ primes
   doubletwinprimes=: _6 _4 0 2+/~(#~ 0,4=2-~/\])

The first two expressions rely on the primitive p: which translates between the index of a prime number and the prime itself. The final expression instead filters the remaining primes (because the sequence of primes which was its argument had already been filtered enough to have made indices into that sequence into relevant information which was not worth recalculating).

jq[edit]

Works with: jq

Also works with gojq, the Go implementation of jq

# Input:  a positive integer
# Output: an array, $a, of length .+1 such that
#         $a[$i] is $i if $i is prime, and false otherwise.
def primeSieve:
  # erase(i) sets .[i*j] to false for integral j > 1
  def erase(i):
    if .[i] then 
      reduce (range(2*i; length; i)) as $j (.; .[$j] = false) 
    else .
    end;
  (. + 1) as $n
  | (($n|sqrt) / 2) as $s
  | [null, null, range(2; $n)]
  | reduce (2, 1 + (2 * range(1; $s))) as $i (.; erase($i)) ;

def double_twin_primes($n):
  [$n|primeSieve|range(0;length) as $i | select(.[$i]) | $i] as $p
  | range(1; $p|length-3) as $i
  | select( ($p[$i+1] - $p[$i]) == 2 and ($p[$i+2] - $p[$i+1]) == 4 and ($p[$i+3] - $p[$i+2]) == 2 )
  | [$p[$i, $i+1, $i+2, $i+3]] ;


"Double twin primes under 1,000:",
 double_twin_primes(1000)
Output:
Double twin primes under 1,000:
[5,7,11,13]
[11,13,17,19]
[101,103,107,109]
[191,193,197,199]
[821,823,827,829]

Julia[edit]

Translation of: C
using Primes
using Printf

function printdt(N)
    @printf("Double twin primes under 1,000:\n")
    for i in 3:2:N-8
        if isprime(i) && isprime(i+2) && isprime(i+6) && isprime(i+8)
            @printf("%4d %4d %4d %4d\n", i, i+2, i+6, i+8)
        end
    end
end

printdt(1000)
Output:
Same as C example.

Nim[edit]

import std/strformat

func isPrime(n: Positive): bool =
  if n < 2: return false
  if (n and 1) == 0: return n == 2
  if n mod 3 == 0: return n == 3
  var k = 5
  var delta = 2
  while k * k <= n:
    if n mod k == 0: return false
    inc k, delta
    delta = 6 - delta
  result = true

echo "Double twin primes under 1000:"
for n in countup(3, 991, 2):
  if isPrime(n) and isPrime(n + 2) and isPrime(n + 6) and isPrime(n + 8):
    echo &"({n:>3}, {n+2:>3}, {n+6:>3}, {n+8:>3})"
Output:
(  5,   7,  11,  13)
( 11,  13,  17,  19)
(101, 103, 107, 109)
(191, 193, 197, 199)
(821, 823, 827, 829)

Perl[edit]

Library: ntheory
use v5.36;
use ntheory 'is_prime';

sub dt ($p) { map { $p + $_ } <0 2 6 8> }
for my $n (1..1000) { say "@{[dt $n]}" if 4 == +(grep { is_prime $_ } dt $n) }
Output:
5 7 11 13
11 13 17 19
101 103 107 109
191 193 197 199
821 823 827 829

Phix[edit]

with javascript_semantics
sequence p = get_primes_le(1000)
for i=1 to length(p)-3 do
    if p[i+3]-p[i]=8 and p[i+2]-p[i]!=4 then
        printf(1,"%s\n",join(p[i..i+3],fmt:="%4d"))
    end if
end for
Output:
   5    7   11   13
  11   13   17   19
 101  103  107  109
 191  193  197  199
 821  823  827  829

Python[edit]

#!/usr/bin/python

def isPrime(n):
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False        
    return True
    
if __name__ == "__main__":
    num = 3
    while num <= 1000:
        if isPrime(num):
            if isPrime(num+2):
                if isPrime(num+6):
                    if isPrime(num+8):
                        print(num, num+2, num+6, num+8, sep="\t")
        num += 2
Output:
5	7	11	13
11	13	17	19
101	103	107	109
191	193	197	199
821	823	827	829

Raku[edit]

Cousin twin primes:

sub dt { $^p, $p+2, $p+6, $p+8 }
.&dt.say for (^1000).grep: { all .&dt».is-prime };
Output:
(5 7 11 13)
(11 13 17 19)
(101 103 107 109)
(191 193 197 199)
(821 823 827 829)

Ring[edit]

see "working..." + nl
P = []

limit = 1000
for n =1 to limit
    if isP(n)
       add(P,n)
    ok
next
lenP = len(P)-3
for m = 1 to lenP
    if isP(P[m]) AND isP(P[m+1]) AND isP(P[m+2]) AND isP(P[m+3])
       if (P[m+1] - P[m] = 2) AND (P[m+2] - P[m+1] = 4) AND (P[m+3] - P[m+2] = 2)
          see " " + P[m]+ " " + P[m+1] + " " + P[m+2] + " " + P[m+3] + nl
       ok
    ok
next

see "done..." + nl

func isP num
     if (num <= 1) return 0 ok
     if (num % 2 = 0 AND num != 2) return 0 ok     
     for i = 3 to floor(num / 2) -1 step 2
         if (num % i = 0) return 0 ok
     next
return 1
Output:
works...
 5 7 11 13
 11 13 17 19
 101 103 107 109
 191 193 197 199
 821 823 827 829
done...

Ruby[edit]

require 'prime'

res = Prime.each(1000).each_cons(4).select do |p1, p2, p3, p4| 
  p1+2 == p2 && p2+4 == p3 && p3+2 == p4
end

res.each{|slice| puts slice.join(", ")}
Output:
5, 7, 11, 13
11, 13, 17, 19
101, 103, 107, 109
191, 193, 197, 199
821, 823, 827, 829

Wren[edit]

Library: Wren-math
Library: Wren-fmt
import "./math" for Int
import "./fmt" for Fmt

var p = Int.primeSieve(1000)
System.print("Double twin primes under 1,000:")
for (i in 1...p.count-3) {
    if (p[i+1] - p[i] == 2 && p[i+2] - p[i+1] == 4 && p[i+3] - p[i+2] == 2) {
        Fmt.aprint(p[i..i+3], 4, 0, "")
    }
}
Output:
Double twin primes under 1,000:
   5    7   11   13
  11   13   17   19
 101  103  107  109
 191  193  197  199
 821  823  827  829

XPL0[edit]

func IsPrime(N);        \Return 'true' if odd N is prime
int  N, D;
[for D:= 3 to sqrt(N) do
    [if rem(N/D) = 0 then return false;
    D:= D+1;
    ];
return true;
];

int N;
[N:= 3;
repeat  if IsPrime(N) then
          if IsPrime(N+2) then
            if IsPrime(N+6) then
              if IsPrime(N+8) then
                [IntOut(0, N);   ChOut(0, ^ );
                 IntOut(0, N+2); ChOut(0, ^ );
                 IntOut(0, N+6); ChOut(0, ^ );
                 IntOut(0, N+8); CrLf(0);
                ];
        N:= N+2;
until N >= 1000-8;
]
Output:
5 7 11 13
11 13 17 19
101 103 107 109
191 193 197 199
821 823 827 829