Twin primes: Difference between revisions

 

Twin primes are pairs of natural numbers   (P₁  and  P₂)   that satisfy the following:

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Simplifies array bound checking by using the equivalent definition of twin primes: p and p - 2.

# count twin primes (where p and p - 2 are prime) #

PR heap=128M PR # set heap memory size for Algol 68G #

FOR p FROM 3 BY 2 TO max number - 1 DO IF primes[ p ] AND primes[ p - 2 ] THEN twin count +:= 1 FI OD;

print( ( "twin prime pairs below ", whole( max number, 0 ), ": ", whole( twin count, 0 ), newline ) )

{{out}}

<pre>

twin prime pairs below 10000000: 58980

</pre>

=={{header|AWK}}==

# syntax: GAWK -f TWIN_PRIMES.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

twin prime pairs < 1000000 : 8169

</pre>

 

=={{header|C}}==

#include <stdint.h>

#include <stdio.h>

test(100000000);

return 0;

{{out}}

<pre>Number of twin prime pairs less than 10 is 2

(The module Math::Primesieve, which is used by the Raku example on this page, is implemented

on top of this library.)

#include <iostream>

#include <string>

}

return 0;

 

{{out}}

Number of twin prime pairs less than 100,000,000,000 is 224,376,048

</pre>

 

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{Trans|Wren}}

program Primes;

 

end.

 

 

{{out}}

Under 1,000,000,000 there are 3,424,506 pairs of twin primes.

</pre>

 

=={{header|F Sharp|F#}}==

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

printfn "twin primes below 100000: %d" (primes64()|>Seq.takeWhile(fun n->n<=100000L)|>Seq.pairwise|>Seq.filter(fun(n,g)->g=n+2L)|>Seq.length)

printfn "twin primes below 1000000: %d" (primes64()|>Seq.takeWhile(fun n->n<=1000000L)|>Seq.pairwise|>Seq.filter(fun(n,g)->g=n+2L)|>Seq.length)

printfn "twin primes below 10000000000: %d" (primes64()|>Seq.takeWhile(fun n->n<=10000000000L)|>Seq.pairwise|>Seq.filter(fun(n,g)->g=n+2L)|>Seq.length)

printfn "twin primes below 100000000000: %d" (primes64()|>Seq.takeWhile(fun n->n<=100000000000L)|>Seq.pairwise|>Seq.filter(fun(n,g)->g=n+2L)|>Seq.length)

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2020-07-03}}

sequences tools.memory.private ;

 

 

"Search size: " write flush readln string>number

{{out}}

<pre>

Search size: 1,000,000,000

3,424,506 twin prime pairs.

</pre>

 

=={{header|Go}}==

{{trans|Wren}}

 

import "fmt"

limit *= 10

}

 

{{out}}

===Alternative using primegen package===

See [[Extensible prime generator#Go]].

 

import (

previous = prime

}

 

{{out}}

=={{header|Java}}==

BigInteger Implementation:

import java.math.BigInteger;

import java.util.Scanner;

}

}

{{out}}

<pre>

</pre>

 

 

=={{header|Julia}}==

 

function counttwinprimepairsbetween(n1, n2)

lpad(format(paircount, commas=true), 8), " pairs of twin primes.")

end

<pre>

Under 100 there are 8 pairs of twin primes.

prime pair as a difference tuple of (2,), and a prime quadruplet such as [11, 13, 17, 19] as the

tuple starting with 11 of type (2, 6, 8).

 

const PMAX = 1_000_000_000

println("Count of a form of prime octets from 1 to 1 million: ",

format(countprimetuples((2, 6, 12, 14, 20, 24, 26), 1000000), commas=true))

<pre>

Count of prime pairs from 1 to 1 billion: 3,424,506

=={{header|Kotlin}}==

{{trans|Java}}

import java.util.*

 

}

return true

 

=={{header|Nim}}==

As, except for the pair (3, 5), all twins pairs are composed of a number congruent to 2 modulo 3 and a number congruent to 1 modulo 3, we can save some time by using a step of 6. Unfortunately, this is the filling of the sieve which is the most time consuming, so the gain is not very important (on our computer, half a second on a total time of 8.3 s).

 

 

const N = 1_000_000_000

if lim > N: break

 

 

{{out}}

 

=={{header|Perl}}==

use warnings;

 

sub comma { reverse ((reverse shift) =~ s/(.{3})/$1,/gr) =~ s/^,//r }

 

{{out}}

<pre>Twin prime pairs less than 10: 2

The time complexity here is all about building a table of primes. It turns out that using the builtin get_prime() is actually faster

than using an explicit sieve (as per Delphi/Go/Wren) due to retaining all the intermediate 0s, not that I particularly expect this to win any performance trophies.

{{out}}

<pre>

Twin prime pairs less than 1,000,000,000: 3,424,506

"16.2s"

</pre>

 

{{works with|Rakudo|2020.07}}

 

 

use Math::Primesieve;

my $p = Math::Primesieve.new;

 

{{out}}

 

=={{header|REXX}}==

=== straight-forward prime generator ===

The &nbsp; '''genP''' &nbsp; function could be optimized for higher specifications of the limit(s).

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

if $='' | $="," then $= 10 100 1000 10000 100000 1000000 10000000 /*No $? Use default.*/

commas: parse arg _; do ?=length(_)-3 to 1 by -3; _=insert(',', _, ?); end; return _

/*──────────────────────────────────────────────────────────────────────────────────────*/

/* [↓] divide by the primes. ___ */

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

<pre>

This REXX version has some optimization for prime generation.

 

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

if $='' | $="," then $= 100 1000 10000 100000 1000000 10000000 /*No $? Use default.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

genP: arg y; _= 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101

do aa=1 for #; @.aa= word(_, aa) /*assign some low primes for quick ÷'s.*/

end /*aa*/

 

do a=4 for 23 /*divide low primes starting with seven*/

end /*a*/

/* [↓] divide by the primes. ___ */

if j//@.k ==0 then iterate j /*÷ by prev. prime? ¬prime ___ */

end /*k*/ /* [↑] only divide up to √ J */

 

=={{header|Ring}}==

load "stdlib.ring"

 

see "twin prime pairs below " + pow(10,n) + ": " + numTwin[n] + nl + nl

next

Output:

<pre>

Maximum: 10000000

twin prime pairs below 10000000: 58980

</pre>

 

Limits can be specified on the command line, otherwise the twin prime counts for powers

of ten from 1 to 10 are shown.

// primal = "0.3"

// num-format = "0.4"

twin_prime_count_for_powers_of_ten(10);

}

 

{{out}}

Number of twin prime pairs less than 10,000,000,000 is 27,412,679

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

 

var c = Int.primeSieve(1e8-1, false)

start = limit + 1

limit = limit * 10

 

{{out}}

Under 10,000,000 there are 58,980 pairs of twin primes.

Under 100,000,000 there are 440,312 pairs of twin primes.

</pre>