Twin primes: Difference between revisions

{{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>

=={{header|Arturo}}==

 

count: 0

j: 0

print ["From 2 to" ToNum ": there are" x "pairs of twin primes"]

ToNum: ToNum * 10

 

{{out}}

From 2 to 1000000 : there are 8169 pairs of twin primes</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f TWIN_PRIMES.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

function isPrime(v)

if v < 2 then return False

next i

end

{{out}}

<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 10,000,000,000 is 27,412,679

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

</pre>

 

=={{header|C sharp}}==

===Conventional===

 

class Program {

Console.Write("{0} sec", sw.Elapsed.TotalSeconds);

}

{{out|Output @ Tio.run}}

<pre> 2 twin primes below 10

{{works with|C sharp|8}}

Runs in about 18 seconds.

using System.Linq;

using System.Collections;

}

}

{{out}}

<pre style="height:30ex;overflow:scroll">

{{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>

=={{header|FreeBASIC}}==

{{trans|AWK}}

Function isPrime(Byval ValorEval As Integer) As Boolean

If ValorEval <=1 Then Return False

Print !"\n--- terminado, pulsa RETURN---"

Sleep

{{out}}

<pre>

pares de primos gemelos por debajo de < 100000 : 1224

pares de primos gemelos por debajo de < 1000000 : 8169

</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>

> 1000

> 35 twin prime pairs.

</pre>

 

=={{header|J}}==

{{out}}

NB. test larger limits, and get their time/space usage

440312

 

=={{header|jq}}==

'''Slightly modified from the [[#C|C]] entry'''

 

. as $n

| if ($n % 3 == 0) then $n == 3

| .count;

 

{{out}}

<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|Mathematica}}/{{header|Wolfram Language}}==

TwinPrimeCount[mx_] := Module[{pmax, min, max, total},

pmax = PrimePi[mx];

total

]

{{out}}

<pre>{10,2}

{100000000,440312}

{1000000000,3424506}</pre>

 

=={{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>

"16.2s"

</pre>

 

=={{header|PureBasic}}==

{{trans|FreeBASIC}}

Procedure isPrime(v.i)

If v <= 1 : ProcedureReturn #False

CloseConsole()

End

{{out}}

<pre>

=={{header|Python}}==

 

 

 

test(1000000)

test(10000000)

{{out}}

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

<code>primes</code> and <code>eratosthenes</code> are defined at [[Sieve of Eratosthenes#Quackery]].

 

[ eratosthenes

0 1 primes share ]

10 i^ 1+ ** dup echo

say " is "

 

{{out}}

{{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.*/

prev= @.#; #= #+1; sq.#= j*j; @.#= j /*save prev. P; bump # primes; assign P*/

if j-2==prev then tp= tp + 1 /*This & previous prime twins? Bump TP.*/

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

<pre>

This version won't return a correct value (for the number of twin pairs) for a limit < 73 &nbsp; (because of the manner in

<br>which low primes are generated from a list), &nbsp; however, &nbsp; the primes are returned from the function.

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

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

prev= @.#; #= #+1; sq.#= j*j; @.#= j /*save prev. P; bump # primes; assign P*/

if j-2==prev then tp= tp + 1 /*This & previous prime twins? Bump TP.*/

 

=={{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>

 

=={{header|Ruby}}==

 

(1..8).each do |n|

puts "Twin primes below 10**#{n}: #{count}"

end

{{out}}

<pre>Twin primes below 10**1: 2

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}}

 

=={{header|Sidef}}==

var count = 0

var p1 = 2

var count = twin_primes_count(10**n)

say "There are #{count} twin primes <= 10^#{n}"

{{out}}

<pre>

{{works with|Visual Basic|5}}

{{works with|Visual Basic|6}}

Dim i As Long

If x Mod 2 = 0 Then

Test 1000000

Test 10000000

{{out}}

<pre>Twin prime pairs below 10: 2

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

 

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

start = limit + 1

limit = limit * 10

 

{{out}}

=={{header|XPL0}}==

100 million takes 150 seconds on Pi4.

int N, I;

[if N <= 2 then return N = 2;

IntOut(0, Twins(10_000_000)); CrLf(0);

IntOut(0, Twins(100_000_000)); CrLf(0);

 

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

sub isPrime(v)

if v < 2 then return False : fi

next i

end

{{out}}

<pre>