Data commit

Task/Twin-primes/00-META.yaml

@@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Twin_primes
+note: Prime Numbers

Task/Twin-primes/00-TASK.txt

@@ -0,0 +1,35 @@
+Twin primes are pairs of natural numbers &nbsp; (P<sub>1</sub> &nbsp;and&nbsp; P<sub>2</sub>) &nbsp; that satisfy the following:
+
+::# &nbsp; &nbsp; P<sub>1</sub> &nbsp; and &nbsp; P<sub>2</sub> &nbsp; are primes
+::# &nbsp; &nbsp; P<sub>1</sub> &nbsp;+&nbsp; '''2''' &nbsp; = &nbsp; P<sub>2</sub>
+
+
+;Task:
+Write a program that displays the number of <b>pairs of twin primes</b> that can be found <u>under</u> a user-specified number
+<br>(P<sub>1</sub> < <i>user-specified number</i> & P<sub>2</sub>  < <i>user-specified number</i>).
+
+
+;Extension:
+::# Find all twin prime pairs under 100000, 10000000 and 1000000000.
+::# What is the time complexity of the program? Are there ways to reduce computation time?
+
+
+;Examples:
+<pre>
+> Search Size: 100
+> 8 twin prime pairs.
+</pre>
+
+<pre>
+> Search Size: 1000
+> 35 twin prime pairs.
+</pre>
+
+
+;Also see:
+* &nbsp; The OEIS entry: [[oeis:A001097|A001097: Twin primes]]. 
+* &nbsp; The OEIS entry: [[oeis:A167874|A167874: The number of distinct primes < 10^n which are members of twin-prime pairs]]. 
+* &nbsp; The OEIS entry: [[oeis:A077800|A077800: List of twin primes {p, p+2}, with repetition]]. 
+* &nbsp; The OEIS entry: [[oeis:A007508|A007508: Number of twin prime pairs below 10^n]]. 
+<br><br>
+

Task/Twin-primes/ALGOL-68/twin-primes.alg

@@ -0,0 +1,26 @@
+BEGIN
+    # count twin primes (where p and p - 2 are prime)                             #
+    PR heap=128M PR # set heap memory size for Algol 68G                          #
+    # sieve of Eratosthenes: sets s[i] to TRUE if i is a prime, FALSE otherwise   #
+    PROC sieve = ( REF[]BOOL s )VOID:
+         BEGIN
+            FOR i TO UPB s DO s[ i ] := TRUE OD;
+            s[ 1 ] := FALSE;
+            FOR i FROM 2 TO ENTIER sqrt( UPB s ) DO
+                IF s[ i ] THEN FOR p FROM i * i BY i TO UPB s DO s[ p ] := FALSE OD FI
+            OD
+         END # sieve # ;
+    # find the maximum number to search for twin primes                           #
+    INT max;
+    print( ( "Maximum: " ) );
+    read( ( max, newline ) );
+    INT max number = max;
+    # construct a sieve of primes up to the maximum number                        #
+    [ 1 : max number ]BOOL primes;
+    sieve( primes );
+    # count the twin primes                                                       #
+    # note 2 cannot be one of the primes in a twin prime pair, so we start at 3   #
+    INT twin count := 0;
+    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 ) )
+END

Task/Twin-primes/AWK/twin-primes.awk

@@ -0,0 +1,33 @@
+# syntax: GAWK -f TWIN_PRIMES.AWK
+BEGIN {
+    n = 1
+    for (i=1; i<=6; i++) {
+      n *= 10
+      printf("twin prime pairs < %8s : %d\n",n,count_twin_primes(n))
+    }
+    exit(0)
+}
+function count_twin_primes(limit,  count,i,p1,p2,p3) {
+    p1 = 0
+    p2 = p3 = 1
+    for (i=5; i<=limit; i++) {
+      p3 = p2
+      p2 = p1
+      p1 = is_prime(i)
+      if (p3 && p1) {
+        count++
+      }
+    }
+    return(count)
+}
+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)
+}

Task/Twin-primes/Applesoft-BASIC/twin-primes.basic

@@ -0,0 +1,10 @@
+ 0  INPUT "SEARCH SIZE: ";S: FOR N = 1 TO S - 3 STEP 2:P = N: GOSUB 3: IF F THEN P = N + 2: GOSUB 3:C = C + F
+ 1 J = J + (N > 5): IF J = 3 THEN N = N + 4:J = 0
+ 2  NEXT N: PRINT C" TWIN PRIME PAIRS.": END
+ 3 F = 0: IF P < 2 THEN  RETURN
+ 4 F = P = 2: IF F THEN  RETURN
+ 5 F = P -  INT (P / 2) * 2: IF  NOT F THEN  RETURN
+ 6  FOR B = 3 TO  SQR (P) STEP 2: IF B >  = P THEN  NEXT B
+ 7  IF B >  = P THEN  RETURN
+ 8 F = 0: FOR I = B TO  SQR (P) STEP 2: IF P -  INT (P / I) * I = 0 THEN  RETURN
+ 9  NEXT I:F = 1: RETURN

Task/Twin-primes/Arturo/twin-primes.arturo

@@ -0,0 +1,22 @@
+pairsOfPrimes: function [upperLim][
+    count: 0
+    j: 0
+    k: 1
+    i: 0
+    while [i=<upperLim][
+        i: (6 * k) - 1
+        j: i + 2
+        if and? [prime? i] [prime? j] [
+            count: count + 1
+        ]
+        k: k + 1
+    ]
+    return count + 1
+]
+
+ToNum: 10
+while [ToNum =< 1000000][
+    x: pairsOfPrimes ToNum
+    print ["From 2 to" ToNum ": there are" x "pairs of twin primes"]
+    ToNum: ToNum * 10
+]

Task/Twin-primes/BASIC256/twin-primes.basic

@@ -0,0 +1,31 @@
+function isPrime(v)
+  if v < 2 then return False
+  if v mod 2 = 0 then return v = 2
+  if v mod 3 = 0 then return v = 3
+  d = 5
+  while d * d <= v
+    if v mod d = 0 then return False else d += 2
+  end while
+  return True
+end function
+
+function paresDePrimos(limite)
+  p1 = 0
+  p2 = 1
+  p3 = 1
+  cont = 0
+  for i = 5 to limite
+    p3 = p2
+    p2 = p1
+    p1 = isPrime(i)
+    if (p3 and p1) then cont += 1
+  next i
+  return cont
+end function
+
+n = 1
+for i = 1 to 6
+  n = n * 10
+  print "pares de primos gemelos por debajo de < "; n; " : "; paresDePrimos(n)
+next i
+end

Task/Twin-primes/C++/twin-primes.cpp

@@ -0,0 +1,31 @@
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <primesieve.hpp>
+
+void print_twin_prime_count(long long limit) {
+    std::cout << "Number of twin prime pairs less than " << limit
+        << " is " << (limit > 0 ? primesieve::count_twins(0, limit - 1) : 0) << '\n';
+}
+
+int main(int argc, char** argv) {
+    std::cout.imbue(std::locale(""));
+    if (argc > 1) {
+        // print number of twin prime pairs less than limits specified
+        // on the command line
+        for (int i = 1; i < argc; ++i) {
+            try {
+                print_twin_prime_count(std::stoll(argv[i]));
+            } catch (const std::exception& ex) {
+                std::cerr << "Cannot parse limit from '" << argv[i] << "'\n";
+            }
+        }
+    } else {
+        // if no limit was specified then show the number of twin prime
+        // pairs less than powers of 10 up to 100 billion
+        uint64_t limit = 10;
+        for (int power = 1; power < 12; ++power, limit *= 10)
+            print_twin_prime_count(limit);
+    }
+    return 0;
+}

Task/Twin-primes/C-sharp/twin-primes-1.cs

@@ -0,0 +1,58 @@
+using System;
+
+class Program {
+
+    static uint[] res = new uint[10];
+    static uint ri = 1, p = 10, count = 0;
+
+    static void TabulateTwinPrimes(uint bound) {
+        if (bound < 5) return; count++;
+        uint cl = (bound - 1) >> 1, i = 1, j,
+             limit = (uint)(Math.Sqrt(bound) - 1) >> 1;
+        var comp = new bool[cl]; bool lp;
+        for (j = 3; j < cl; j += 3) comp[j] = true;
+        while (i < limit) {
+            if (lp = !comp[i]) {
+                uint pr = (i << 1) + 3;
+                for (j = (pr * pr - 2) >> 1; j < cl; j += pr)
+                    comp[j] = true;
+            }
+            if (!comp[++i]) {
+                uint pr = (i << 1) + 3;
+                if (lp) {
+                    if (pr > p) {
+                        res[ri++] = count;
+                        p *= 10;
+                    }
+                    count++;
+                    i++;
+                }
+                for (j = (pr * pr - 2) >> 1; j < cl; j += pr)
+                    comp[j] = true;
+            }
+        }
+        cl--;
+        while (i < cl) {
+            lp = !comp[i++];
+            if (!comp[i] && lp) {
+                if ((i++ << 1) + 3 > p) {
+                    res[ri++] = count;
+                    p *= 10;
+                }
+                count++;
+            }
+        }
+        res[ri] = count;
+    }
+
+    static void Main(string[] args) {
+        var sw = System.Diagnostics.Stopwatch.StartNew();
+        string fmt = "{0,9:n0} twin primes below {1,-13:n0}";
+        TabulateTwinPrimes(1_000_000_000);
+        sw.Stop();
+        p = 1;
+        for (var j = 1; j <= ri; j++)
+            Console.WriteLine(fmt, res[j], p *= 10);
+        Console.Write("{0} sec", sw.Elapsed.TotalSeconds);
+    }
+}

Task/Twin-primes/C-sharp/twin-primes-2.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+
+public static class TwinPrimes
+{
+    public static void Main()
+    {
+        CountTwinPrimes(Enumerable.Range(1, 9).Select(i => (int)Math.Pow(10, i)).ToArray());
+    }
+
+    private static void CountTwinPrimes(params int[] bounds)
+    {
+        Array.Sort(bounds);
+        int b = 0;
+        int count = 0;
+        string format = "There are {0:N0} twin primes below {1:N0}";
+        foreach (var twin in FindTwinPrimes(bounds[^1])) {
+            if (twin.p2 >= bounds[b]) {
+                Console.WriteLine(format, count, bounds[b]);
+                b++;
+            }
+            count++;
+        }
+        Console.WriteLine(format, count, bounds[b]);
+    }
+
+    private static IEnumerable<(int p1, int p2)> FindTwinPrimes(int bound) =>
+        PrimeSieve(bound).Pairwise().Where(pair => pair.p1 + 2 == pair.p2);
+
+    private static IEnumerable<int> PrimeSieve(int bound)
+    {
+        if (bound < 2) yield break;
+        yield return 2;
+
+        var composite = new BitArray((bound - 1) / 2);
+        int limit = (int)(Math.Sqrt(bound) - 1) / 2;
+        for (int i = 0; i < limit; i++) {
+            if (composite[i]) continue;
+            int prime = 2 * i + 3;
+            yield return prime;
+            for (int j = (prime * prime - 2) / 2; j < composite.Count; j += prime) {
+                composite[j] = true;
+            }
+        }
+        for (int i = limit; i < composite.Count; i++) {
+            if (!composite[i]) yield return 2 * i + 3;
+        }
+    }
+
+    private static IEnumerable<(T p1, T p2)> Pairwise<T>(this IEnumerable<T> source)
+    {
+        using var e = numbers.GetEnumerator();
+        if (!e.MoveNext()) yield break;
+        T p1 = e.Current;
+        while (e.MoveNext()) {
+            T p2 = e.Current;
+            yield return (p1, p2);
+            p1 = p2;
+        }
+    }
+}

Task/Twin-primes/C/twin-primes.c

@@ -0,0 +1,58 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+
+bool isPrime(int64_t n) {
+    int64_t i;
+
+    if (n < 2)       return false;
+    if (n % 2 == 0)  return n == 2;
+    if (n % 3 == 0)  return n == 3;
+    if (n % 5 == 0)  return n == 5;
+    if (n % 7 == 0)  return n == 7;
+    if (n % 11 == 0) return n == 11;
+    if (n % 13 == 0) return n == 13;
+    if (n % 17 == 0) return n == 17;
+    if (n % 19 == 0) return n == 19;
+
+    for (i = 23; i * i <= n; i += 2) {
+        if (n % i == 0) return false;
+    }
+
+    return true;
+}
+
+int countTwinPrimes(int limit) {
+    int count = 0;
+
+    //       2          3          4
+    int64_t p3 = true, p2 = true, p1 = false;
+    int64_t i;
+
+    for (i = 5; i <= limit; i++) {
+        p3 = p2;
+        p2 = p1;
+        p1 = isPrime(i);
+        if (p3 && p1) {
+            count++;
+        }
+    }
+    return count;
+}
+
+void test(int limit) {
+    int count = countTwinPrimes(limit);
+    printf("Number of twin prime pairs less than %d is %d\n", limit, count);
+}
+
+int main() {
+    test(10);
+    test(100);
+    test(1000);
+    test(10000);
+    test(100000);
+    test(1000000);
+    test(10000000);
+    test(100000000);
+    return 0;
+}

Task/Twin-primes/Delphi/twin-primes.delphi

@@ -0,0 +1,119 @@
+program Primes;
+
+{$APPTYPE CONSOLE}
+
+{$R *.res}
+
+uses
+  System.SysUtils;
+
+function IsPrime(a: UInt64): Boolean;
+var
+  d: UInt64;
+begin
+  if (a < 2) then
+    exit(False);
+
+  if (a mod 2) = 0 then
+    exit(a = 2);
+
+  if (a mod 3) = 0 then
+    exit(a = 3);
+
+  d := 5;
+
+  while (d * d <= a) do
+  begin
+    if (a mod d = 0) then
+      Exit(false);
+    inc(d, 2);
+
+    if (a mod d = 0) then
+      Exit(false);
+    inc(d, 4);
+  end;
+
+  Result := True;
+end;
+
+
+function Sieve(limit: UInt64): TArray<Boolean>;
+var
+  p, p2, i: UInt64;
+begin
+  inc(limit);
+  SetLength(Result, limit);
+  FillChar(Result[2], sizeof(Boolean) * limit - 2, 0); // all false except 1,2
+  FillChar(Result[0], sizeof(Boolean) * 2, 1); // 1,2 are true
+
+  p := 3;
+  while true do
+  begin
+    p2 := p * p;
+    if p2 >= limit then
+      break;
+
+    i := p2;
+    while i < limit do
+    begin
+      Result[i] := true;
+      inc(i, 2 * p);
+    end;
+
+    while true do
+    begin
+      inc(p, 2);
+      if not Result[p] then
+        Break;
+    end;
+  end;
+end;
+
+function Commatize(const n: UInt64): string;
+var
+  str: string;
+  digits: Integer;
+  i: Integer;
+begin
+  Result := '';
+  str := n.ToString;
+  digits := str.Length;
+
+  for i := 1 to digits do
+  begin
+    if ((i > 1) and (((i - 1) mod 3) = (digits mod 3))) then
+      Result := Result + ',';
+    Result := Result + str[i];
+  end;
+end;
+
+var
+  limit, start, twins: UInt64;
+  c: TArray<Boolean>;
+  i, j: UInt64;
+
+begin
+
+  c := Sieve(Trunc(1e9 - 1));
+  limit := 10;
+  start := 3;
+  twins := 0;
+  for i := 1 to 9 do
+  begin
+    j := start;
+    while j < limit do
+    begin
+      if (not c[j]) and (not c[j - 2]) then
+        inc(twins);
+      inc(j, 2);
+    end;
+    Writeln(Format('Under %14s there are %10s pairs of twin primes.', [commatize
+      (limit), commatize(twins)]));
+
+    start := limit + 1;
+    limit := 10 * limit;
+  end;
+
+  readln;
+
+end.

Task/Twin-primes/F-Sharp/twin-primes.fs

@@ -0,0 +1,7 @@
+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 10000000: %d" (primes64()|>Seq.takeWhile(fun n->n<=10000000L)|>Seq.pairwise|>Seq.filter(fun(n,g)->g=n+2L)|>Seq.length)
+printfn "twin primes below 100000000: %d" (primes64()|>Seq.takeWhile(fun n->n<=100000000L)|>Seq.pairwise|>Seq.filter(fun(n,g)->g=n+2L)|>Seq.length)
+printfn "twin primes below 1000000000: %d" (primes64()|>Seq.takeWhile(fun n->n<=1000000000L)|>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)

Task/Twin-primes/Factor/twin-primes.factor

@@ -0,0 +1,9 @@
+USING: io kernel math math.parser math.primes.erato math.ranges
+sequences tools.memory.private ;
+
+: twin-pair-count ( n -- count )
+    [ 5 swap 2 <range> ] [ sieve ] bi
+    [ over 2 - over [ marked-prime? ] 2bi@ and ] curry count ;
+
+"Search size: " write flush readln string>number
+twin-pair-count commas write " twin prime pairs." print

Task/Twin-primes/FreeBASIC/twin-primes.basic

@@ -0,0 +1,26 @@
+Function isPrime(Byval ValorEval As Integer) As Boolean
+    If ValorEval <=1 Then Return False
+    For i As Integer = 2 To Int(Sqr(ValorEval))
+        If ValorEval Mod i = 0 Then Return False
+    Next i
+    Return True
+End Function
+
+Function paresDePrimos(limite As Uinteger) As Uinteger
+    Dim As Uinteger p1 = 0, p2 = 1, p3 = 1, count = 0
+    For i As Uinteger = 5 To limite
+        p3 = p2
+        p2 = p1
+        p1 = isPrime(i)
+        If (p3 And p1) Then count += 1
+    Next i
+    Return count
+End Function
+
+Dim As Uinteger n = 1
+For i As Byte = 1 To 6
+    n *= 10
+    Print Using "pares de primos gemelos por debajo de < ####### : ####"; n; paresDePrimos(n)
+Next i
+Print !"\n--- terminado, pulsa RETURN---"
+Sleep

Task/Twin-primes/Frink/twin-primes.frink

@@ -0,0 +1,15 @@
+upper = eval[input["Enter upper bound:"]]
+countTwins[upper]
+countTwins[100000]
+countTwins[10000000]
+countTwins[1000000000]
+
+countTwins[upper] :=
+{
+   count = 0
+   for n = primes[2, upper-2]
+      if isPrime[n+2]
+         count = count + 1
+
+   println["$count twin primes under $upper"]
+}

Task/Twin-primes/Go/twin-primes-1.go

@@ -0,0 +1,61 @@
+package main
+
+import "fmt"
+
+func sieve(limit uint64) []bool {
+    limit++
+    // True denotes composite, false denotes prime.
+    c := make([]bool, limit) // all false by default
+    c[0] = true
+    c[1] = true
+    // no need to bother with even numbers over 2 for this task
+    p := uint64(3) // Start from 3.
+    for {
+        p2 := p * p
+        if p2 >= limit {
+            break
+        }
+        for i := p2; i < limit; i += 2 * p {
+            c[i] = true
+        }
+        for {
+            p += 2
+            if !c[p] {
+                break
+            }
+        }
+    }
+    return c
+}
+
+func commatize(n int) string {
+    s := fmt.Sprintf("%d", n)
+    if n < 0 {
+        s = s[1:]
+    }
+    le := len(s)
+    for i := le - 3; i >= 1; i -= 3 {
+        s = s[0:i] + "," + s[i:]
+    }
+    if n >= 0 {
+        return s
+    }
+    return "-" + s
+}
+
+func main() {
+    c := sieve(1e10 - 1)
+    limit := 10
+    start := 3
+    twins := 0
+    for i := 1; i < 11; i++ {
+        for i := start; i < limit; i += 2 {
+            if !c[i] && !c[i-2] {
+                twins++
+            }
+        }
+        fmt.Printf("Under %14s there are %10s pairs of twin primes.\n", commatize(limit), commatize(twins))
+        start = limit + 1
+        limit *= 10
+    }
+}

Task/Twin-primes/Go/twin-primes-2.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+    "fmt"
+    "github.com/jbarham/primegen.go"
+)
+
+func main() {
+    p := primegen.New()
+    count := 0
+    previous := uint64(0)
+    power := 1
+    limit := uint64(10)
+    for {
+        prime := p.Next()
+        if prime >= limit {
+            fmt.Printf("Number of twin prime pairs less than %d: %d\n", limit, count)
+            power++
+            if power > 10 {
+                break
+            }
+            limit *= 10
+        }
+        if previous > 0 && prime == previous + 2 {
+            count++
+        }
+        previous = prime
+    }
+}

Task/Twin-primes/J/twin-primes.j

@@ -0,0 +1,9 @@
+tp=: 3 : '+/ (*. _2&(|.!.0)) 1 p: i. y'
+
+NB. 3 : ''     explicitly define a "monad" (a one-argument function)
+NB. i. y       list integers up to the provided argument
+NB. 1 p:       create list of 0s, 1s where those ints are prime
+NB. _2&(|.!.0) "shift" that list to the right by two, filling left side with 0
+NB. (*. g) y   create a "hook". "and" together the original and shifted lists
+NB.            the result will have a 1 only if that i, and i-2, are both prime
+NB. +/         sum the and-ed list (get the number of twin pairs)

Task/Twin-primes/Java/twin-primes.java

@@ -0,0 +1,26 @@
+import java.math.BigInteger;
+import java.util.Scanner;
+
+public class twinPrimes {
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+        System.out.println("Search Size: ");
+        BigInteger max = input.nextBigInteger();
+        int counter = 0;
+        for(BigInteger x = new BigInteger("3"); x.compareTo(max) <= 0; x = x.add(BigInteger.ONE)){
+            BigInteger sqrtNum = x.sqrt().add(BigInteger.ONE);
+            if(x.add(BigInteger.TWO).compareTo(max) <= 0) {
+                counter += findPrime(x.add(BigInteger.TWO), x.add(BigInteger.TWO).sqrt().add(BigInteger.ONE)) && findPrime(x, sqrtNum) ? 1 : 0;
+            }
+        }
+        System.out.println(counter + " twin prime pairs.");
+    }
+    public static boolean findPrime(BigInteger x, BigInteger sqrtNum){
+        for(BigInteger divisor = BigInteger.TWO; divisor.compareTo(sqrtNum) <= 0; divisor = divisor.add(BigInteger.ONE)){
+            if(x.remainder(divisor).compareTo(BigInteger.ZERO) == 0){
+                return false;
+            }
+        }
+        return true;
+    }
+}

Task/Twin-primes/Jq/twin-primes.jq

@@ -0,0 +1,25 @@
+def odd_gt2_is_prime:
+  . as $n
+  | if   ($n % 3 == 0)  then $n == 3
+    elif ($n % 5 == 0)  then $n == 5
+    elif ($n % 7 == 0)  then $n == 7
+    elif ($n % 11 == 0) then $n == 11
+    elif ($n % 13 == 0) then $n == 13
+    elif ($n % 17 == 0) then $n == 17
+    elif ($n % 19 == 0) then $n == 19
+    else {i:23}
+         | until( (.i * .i) > $n or ($n % .i == 0); .i += 2)
+	 | .i * .i > $n
+    end;
+
+def twin_primes($max):
+    {count:0, i:3, isprime:true}
+    | until(.i >= $max;
+        .i += 2
+        | if .isprime
+          then if .i|odd_gt2_is_prime then .count+=1 else .isprime = false end
+          else .isprime = (.i|odd_gt2_is_prime)
+	  end )
+    | .count;
+
+pow(10; range(1;8)) | "Number of twin primes less than \(.) is \(twin_primes(.))."

Task/Twin-primes/Julia/twin-primes-1.julia

@@ -0,0 +1,19 @@
+using Formatting, Primes
+
+function counttwinprimepairsbetween(n1, n2)
+    npairs, t = 0, nextprime(n1)
+    while t < n2
+        p = nextprime(t + 1)
+        if p - t == 2
+            npairs += 1
+        end
+        t = p
+    end
+    return npairs
+end
+
+for t2 in (10).^collect(2:8)
+    paircount = counttwinprimepairsbetween(1, t2)
+    println("Under", lpad(format(t2, commas=true), 12), " there are",
+        lpad(format(paircount, commas=true), 8), " pairs of twin primes.")
+end

Task/Twin-primes/Julia/twin-primes-2.julia

@@ -0,0 +1,19 @@
+using Formatting, Primes
+
+const PMAX = 1_000_000_000
+const pmb = primesmask(PMAX)
+const primestoabillion = [i for i in 2:PMAX if pmb[i]]
+
+tuplefitsat(k, tup, arr) = all(i -> arr[k + i] - arr[k] == tup[i], 1:length(tup))
+
+function countprimetuples(tup, n)
+    arr =  filter(i -> i <= n, primestoabillion)
+    return count(k -> tuplefitsat(k, tup, arr), 1:length(arr) - length(tup))
+end
+
+println("Count of prime pairs from 1 to 1 billion: ",
+    format(countprimetuples((2,), 1000000000), commas=true))
+println("Count of a form of prime quads from 1 to 1 million: ",
+    format(countprimetuples((2, 6, 8), 1000000), commas=true))
+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))

Task/Twin-primes/Kotlin/twin-primes.kotlin

@@ -0,0 +1,33 @@
+import java.math.BigInteger
+import java.util.*
+
+fun main() {
+    val input = Scanner(System.`in`)
+    println("Search Size: ")
+    val max = input.nextBigInteger()
+    var counter = 0
+    var x = BigInteger("3")
+    while (x <= max) {
+        val sqrtNum = x.sqrt().add(BigInteger.ONE)
+        if (x.add(BigInteger.TWO) <= max) {
+            counter += if (findPrime(
+                    x.add(BigInteger.TWO),
+                    x.add(BigInteger.TWO).sqrt().add(BigInteger.ONE)
+                ) && findPrime(x, sqrtNum)
+            ) 1 else 0
+        }
+        x = x.add(BigInteger.ONE)
+    }
+    println("$counter twin prime pairs.")
+}
+
+fun findPrime(x: BigInteger, sqrtNum: BigInteger?): Boolean {
+    var divisor = BigInteger.TWO
+    while (divisor <= sqrtNum) {
+        if (x.remainder(divisor).compareTo(BigInteger.ZERO) == 0) {
+            return false
+        }
+        divisor = divisor.add(BigInteger.ONE)
+    }
+    return true
+}

Task/Twin-primes/Mathematica/twin-primes.math

@@ -0,0 +1,16 @@
+ClearAll[TwinPrimeCount]
+TwinPrimeCount[mx_] := Module[{pmax, min, max, total},
+  pmax = PrimePi[mx];
+  total = 0;
+  Do[
+   min = 10^6 i;
+   min = Max[min, 1];
+   max = 10^6 (i + 1);
+   max = Min[max, pmax];
+   total += Count[Differences[Prime[Range[min, max]]], 2]
+   ,
+   {i, 0, Ceiling[pmax/10^6]}
+   ];
+  total
+ ]
+Do[Print[{10^i, TwinPrimeCount[10^i]}], {i, 9}]

Task/Twin-primes/Nim/twin-primes.nim

@@ -0,0 +1,30 @@
+import math, strformat, strutils
+
+const N = 1_000_000_000
+
+proc sieve(n: Positive): seq[bool] =
+  ## Build and fill a sieve of Erathosthenes.
+  result.setLen(n + 1)  # Default to false which means prime.
+  result[0] = true
+  result[1] = true
+  for n in countup(3, sqrt(N.toFloat).int, 2):
+    if not result[n]:
+      for k in countup(n * n, N, 2 * n):
+        result[k] = true
+
+let composite = sieve(N)
+
+proc findTwins(composite: openArray[bool]) =
+  var
+    lim = 10
+    count = 1     # Start with 3, 5 which is a special case.
+    n = 7         # First prime congruent to 1 modulo 3.
+  while true:
+    if not composite[n] and not composite[n - 2]: inc count
+    inc n, 6      # Next odd number congruent to 1 modulo 3.
+    if n > lim:
+      echo &"There are {insertSep($count)} pairs of twin primes under {insertSep($lim)}."
+      lim *= 10
+      if lim > N: break
+
+composite.findTwins()

Task/Twin-primes/Perl/twin-primes.pl

@@ -0,0 +1,8 @@
+use strict;
+use warnings;
+
+use Primesieve;
+
+sub comma { reverse ((reverse shift) =~ s/(.{3})/$1,/gr) =~ s/^,//r }
+
+printf "Twin prime pairs less than %14s: %s\n", comma(10**$_), comma count_twins(1, 10**$_) for 1..10;

Task/Twin-primes/Phix/twin-primes.phix

@@ -0,0 +1,27 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">twin_primes</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">maxp</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">bool</span> <span style="color: #000000;">both</span><span style="color: #0000FF;">=</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span>  <span style="color: #000080;font-style:italic;">-- result</span>
+             <span style="color: #000000;">pn</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- next prime index</span>
+             <span style="color: #000000;">p</span><span style="color: #0000FF;">,</span>      <span style="color: #000080;font-style:italic;">-- a prime, &lt;= maxp</span>
+             <span style="color: #000000;">prev_p</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">2</span>
+     <span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>
+         <span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pn</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">both</span> <span style="color: #008080;">and</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">maxp</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">prev_p</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">if</span> <span style="color: #0000FF;">(</span><span style="color: #008080;">not</span> <span style="color: #000000;">both</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">maxp</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #000000;">prev_p</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">p</span>
+         <span style="color: #000000;">pn</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">n</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+ <span style="color: #004080;">integer</span> <span style="color: #000000;">mp</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">6</span> <span style="color: #000080;font-style:italic;">-- prompt_number("Enter limit:")</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;">"Twin prime pairs less than %,d: %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">mp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">twin_primes</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mp</span><span style="color: #0000FF;">)})</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;">"Twin prime pairs less than %,d: %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">mp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">twin_primes</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mp</span><span style="color: #0000FF;">,</span><span style="color: #004600;">false</span><span style="color: #0000FF;">)})</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">9</span> <span style="color: #008080;">do</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">p10</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)</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;">"Twin prime pairs less than %,d: %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">p10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">twin_primes</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p10</span><span style="color: #0000FF;">)})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+ <span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>
+<!--

Task/Twin-primes/PureBasic/twin-primes.basic

@@ -0,0 +1,44 @@
+Procedure 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
+
+Procedure paresDePrimos(limite.d)
+  p1.i = 0
+  p2.i = 1
+  p3.i = 1
+  count.i = 0
+  For i.i = 5 To limite
+    p3 = p2
+    p2 = p1
+    p1 = isPrime(i)
+    If p3 And p1
+       count + 1
+    EndIf
+  Next i
+  ProcedureReturn count
+EndProcedure
+
+OpenConsole()
+n.i = 1
+For i.i = 1 To 6
+  n = n * 10
+  PrintN("pares de primos gemelos por debajo de < " + Str(n) + " : " + Str(paresDePrimos(n)))
+Next i
+PrintN(#CRLF$ + "--- terminado, pulsa RETURN---"): Input()
+CloseConsole()
+End

Task/Twin-primes/Python/twin-primes.py

@@ -0,0 +1,38 @@
+primes = [2, 3, 5, 7, 11, 13, 17, 19]
+
+
+def count_twin_primes(limit: int) -> int:
+    global primes
+    if limit > primes[-1]:
+        ram_limit = primes[-1] + 90000000 - len(primes)
+        reasonable_limit = min(limit, primes[-1] ** 2, ram_limit) - 1
+
+        while reasonable_limit < limit:
+            ram_limit = primes[-1] + 90000000 - len(primes)
+            if ram_limit > primes[-1]:
+                reasonable_limit = min(limit, primes[-1] ** 2, ram_limit)
+            else:
+                reasonable_limit = min(limit, primes[-1] ** 2)
+
+            sieve = list({x for prime in primes for x in
+                          range(primes[-1] + prime - (primes[-1] % prime), reasonable_limit, prime)})
+            primes += [x - 1 for i, x in enumerate(sieve) if i and x - 1 != sieve[i - 1] and x - 1 < limit]
+
+    count = len([(x, y) for (x, y) in zip(primes, primes[1:]) if x + 2 == y])
+
+    return count
+
+
+def test(limit: int):
+    count = count_twin_primes(limit)
+    print(f"Number of twin prime pairs less than {limit} is {count}\n")
+
+
+test(10)
+test(100)
+test(1000)
+test(10000)
+test(100000)
+test(1000000)
+test(10000000)
+test(100000000)

Task/Twin-primes/Quackery/twin-primes.quackery

@@ -0,0 +1,17 @@
+  [ dup dip
+      [ eratosthenes
+        0 1 primes share ]
+    bit 1 - & 1 >>
+    [ dup while
+      dup 5 & 5 = if
+        [ rot 1+ unrot ]
+      2 >>
+      dip [ 2 + ]
+      again ]
+    2drop ]                is twinprimes ( n --> [ )
+
+  5 times
+    [ say "Number of twin primes below "
+      10 i^ 1+ ** dup echo
+      say " is "
+      twinprimes echo say "." cr ]

Task/Twin-primes/REXX/twin-primes-1.rexx

@@ -0,0 +1,26 @@
+/*REXX pgm counts the number of twin prime pairs under a specified number N (or a list).*/
+parse arg $ .                                    /*get optional number of primes to find*/
+if $='' | $=","  then $= 10 100 1000 10000 100000 1000000 10000000  /*No $? Use default.*/
+w= length( commas( word($, words($) ) ) )        /*get length of the last number in list*/
+@found= ' twin prime pairs found under '         /*literal used in the showing of output*/
+
+       do i=1  for words($);       x= word($, i) /*process each N─limit in the  $  list.*/
+       say right( commas(genP(x)), 20)     @found     right(commas(x), max(length(x), w) )
+       end   /*i*/
+exit 0                                           /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+commas:  parse arg _;  do ?=length(_)-3  to 1  by -3; _=insert(',', _, ?); end;   return _
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+genP: parse arg y; @.1=2;  @.2=3;  @.3=5;  @.4=7;  @.5=11;  @.6=13; #= 6; tp= 2; sq.6= 169
+      if y>10  then tp= tp+1
+         do j=@.#+2  by 2  for max(0, y%2-@.#%2-1)      /*find odd primes from here on. */
+         parse var  j   ''  -1  _                /*obtain the last digit of the  J  var.*/
+         if    _==5  then iterate;  if j// 3==0  then iterate  /*J ÷ by 5?   J ÷ by  3? */
+         if j//7==0  then iterate;  if j//11==0  then iterate  /*" "  " 7?   " "  " 11? */
+                                                 /* [↓]  divide by the primes.   ___    */
+               do k=6  to #  while  sq.k<=j      /*divide  J  by other primes ≤ √ J     */
+               if j//@.k == 0  then iterate j    /*÷ by prev. prime?  ¬prime     ___    */
+               end   /*k*/                       /* [↑]   only divide up to     √ J     */
+         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.*/
+         end         /*j*/;            return tp

Task/Twin-primes/REXX/twin-primes-2.rexx

@@ -0,0 +1,33 @@
+/*REXX pgm counts the number of twin prime pairs under a specified number N (or a list).*/
+parse arg $ .                                    /*get optional number of primes to find*/
+if $='' | $=","  then $= 100 1000 10000 100000 1000000 10000000    /*No $?  Use default.*/
+w= length( commas( word($, words($) ) ) )        /*get length of the last number in list*/
+@found= ' twin prime pairs found under '         /*literal used in the showing of output*/
+
+       do i=1  for words($);       x= word($, i) /*process each N─limit in the  $  list.*/
+       say right( commas(genP(x)), 20)     @found     right(commas(x), max(length(x), w) )
+       end   /*i*/
+exit 0                                           /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+commas:  parse arg _;  do ?=length(_)-3  to 1  by -3; _=insert(',', _, ?); end;   return _
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+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
+      tp=8;          #= words(_); sq.103=103*103 /*#: number of prims; TP: # twin pairs.*/
+        do aa=1  for #;  @.aa= word(_, aa)       /*assign some low primes for quick ÷'s.*/
+        end   /*aa*/
+
+        do j=@.#+2  by 2  while j<y              /*continue with the next prime past 101*/
+        parse var  j  ''  -1  _                  /*obtain the last digit of the  J  var.*/
+        if _    ==5       then iterate           /*is this integer a multiple of five?  */
+        if j//3 ==0       then iterate           /* "   "     "    "     "     " three? */
+
+           do a=4  for 23                        /*divide low primes starting with seven*/
+           if j//@.a ==0  then iterate j         /*is integer a multiple of a low prime?*/
+           end           /*a*/
+                                                 /* [↓]  divide by the primes.   ___    */
+                   do k=27  to #  while sq.k<= j /*divide  J  by other primes ≤ √ J     */
+                   if j//@.k ==0  then iterate j /*÷ by prev. prime?  ¬prime     ___    */
+                   end   /*k*/                   /* [↑]   only divide up to     √ J     */
+        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.*/
+        end              /*j*/;        return tp

Task/Twin-primes/Raku/twin-primes.raku

@@ -0,0 +1,7 @@
+use Lingua::EN::Numbers;
+
+use Math::Primesieve;
+
+my $p = Math::Primesieve.new;
+
+printf "Twin prime pairs less than %14s: %s\n", comma(10**$_), comma $p.count(10**$_, :twins) for 1 .. 10;

Task/Twin-primes/Ring/twin-primes.ring

@@ -0,0 +1,35 @@
+load "stdlib.ring"
+
+limit = list(7)
+for n = 1 to 7
+    limit[n] = pow(10,n)
+next
+
+TwinPrimes = []
+
+for n = 1 to limit[7]-2
+    bool1 = isprime(n)
+    bool2 = isprime(n+2)
+    bool = bool1 and bool2
+    if bool =1
+       add(TwinPrimes,[n,n+2])
+    ok
+next
+
+numTwin = list(7)
+len = len(TwinPrimes)
+
+for n = 1 to len
+    for p = 1 to 6
+        if TwinPrimes[n][2] < pow(10,p) and TwinPrimes[n+1][1] > pow(10,p)-2
+           numTwin[p] = n
+        ok
+    next
+next
+
+numTwin[7] = len
+
+for n = 1 to 7
+    see "Maximum: " + pow(10,n) + nl
+    see "twin prime pairs below " + pow(10,n) + ": " + numTwin[n] + nl + nl
+next

Task/Twin-primes/Ruby/twin-primes.rb

@@ -0,0 +1,6 @@
+require 'prime'
+
+(1..8).each do |n|
+  count = Prime.each(10**n).each_cons(2).count{|p1, p2| p2-p1 == 2}
+  puts "Twin primes below 10**#{n}: #{count}"
+end

Task/Twin-primes/Rust/twin-primes.rust

@@ -0,0 +1,61 @@
+// [dependencies]
+// primal = "0.3"
+// num-format = "0.4"
+
+use num_format::{Locale, ToFormattedString};
+
+fn twin_prime_count_for_powers_of_ten(max_power: u32) {
+    let mut count = 0;
+    let mut previous = 0;
+    let mut power = 1;
+    let mut limit = 10;
+    for prime in primal::Primes::all() {
+        if prime > limit {
+            println!(
+                "Number of twin prime pairs less than {} is {}",
+                limit.to_formatted_string(&Locale::en),
+                count.to_formatted_string(&Locale::en)
+            );
+            limit *= 10;
+            power += 1;
+            if power > max_power {
+                break;
+            }
+        }
+        if previous > 0 && prime == previous + 2 {
+            count += 1;
+        }
+        previous = prime;
+    }
+}
+
+fn twin_prime_count(limit: usize) {
+    let mut count = 0;
+    let mut previous = 0;
+    for prime in primal::Primes::all().take_while(|x| *x < limit) {
+        if previous > 0 && prime == previous + 2 {
+            count += 1;
+        }
+        previous = prime;
+    }
+    println!(
+        "Number of twin prime pairs less than {} is {}",
+        limit.to_formatted_string(&Locale::en),
+        count.to_formatted_string(&Locale::en)
+    );
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() > 1 {
+        for i in 1..args.len() {
+            if let Ok(limit) = args[i].parse::<usize>() {
+                twin_prime_count(limit);
+            } else {
+                eprintln!("Cannot parse limit from string {}", args[i]);
+            }
+        }
+    } else {
+        twin_prime_count_for_powers_of_ten(10);
+    }
+}

Task/Twin-primes/Sidef/twin-primes.sidef

@@ -0,0 +1,16 @@
+func twin_primes_count(upto) {
+    var count = 0
+    var p1 = 2
+    each_prime(3, upto, {|p2|
+        if (p2 - p1 == 2) {
+            ++count
+        }
+        p1 = p2
+    })
+    return count
+}
+
+for n in (1..9) {
+    var count = twin_primes_count(10**n)
+    say "There are #{count} twin primes <= 10^#{n}"
+}

Task/Twin-primes/Visual-Basic/twin-primes.vb

@@ -0,0 +1,36 @@
+Function IsPrime(x As Long) As Boolean
+    Dim i As Long
+    If x Mod 2 = 0 Then
+        Exit Function
+    Else
+        For i = 3 To Int(Sqr(x)) Step 2
+            If x Mod i = 0 Then Exit Function
+        Next i
+    End If
+    IsPrime = True
+End Function
+
+Function TwinPrimePairs(max As Long) As Long
+    Dim p1 As Boolean, p2 As Boolean, count As Long, i As Long
+    p2 = True
+    For i = 5 To max Step 2
+        p1 = p2
+        p2 = IsPrime(i)
+        If p1 And p2 Then count = count + 1
+    Next i
+    TwinPrimePairs = count
+End Function
+
+Sub Test(x As Long)
+    Debug.Print "Twin prime pairs below" + Str(x) + ":" + Str(TwinPrimePairs(x))
+End Sub
+
+Sub Main()
+    Test 10
+    Test 100
+    Test 1000
+    Test 10000
+    Test 100000
+    Test 1000000
+    Test 10000000
+End Sub

Task/Twin-primes/Wren/twin-primes.wren

@@ -0,0 +1,17 @@
+import "/math" for Int
+import "/fmt" for Fmt
+
+var c = Int.primeSieve(1e8-1, false)
+var limit = 10
+var start = 3
+var twins = 0
+for (i in 1..8) {
+    var j = start
+    while (j < limit) {
+        if (!c[j] && !c[j-2]) twins = twins + 1
+        j = j + 2
+    }
+    Fmt.print("Under $,11d there are $,7d pairs of twin primes.", limit, twins)
+    start = limit + 1
+    limit = limit * 10
+}

Task/Twin-primes/XPL0/twin-primes.xpl0

@@ -0,0 +1,29 @@
+func IsPrime(N);        \Return 'true' if N is prime
+int  N, I;
+[if N <= 2 then return N = 2;
+if (N&1) = 0 then \even >2\ return false;
+for I:= 3 to sqrt(N) do
+    [if rem(N/I) = 0 then return false;
+    I:= I+1;
+    ];
+return true;
+];
+
+func Twins(Limit);
+int  Limit, C, N;
+[C:= 0;  N:= 3;
+repeat  if IsPrime(N) then
+           loop [N:= N+2;
+                if N >= Limit then return C;
+                if not IsPrime(N) then quit;
+                C:= C+1;
+                ];
+        N:= N+2;
+until   N >= Limit;
+return C;
+];
+
+[IntOut(0, Twins(100_000));  CrLf(0);
+ IntOut(0, Twins(10_000_000));  CrLf(0);
+ IntOut(0, Twins(100_000_000));  CrLf(0);
+]

Task/Twin-primes/Yabasic/twin-primes.basic

@@ -0,0 +1,28 @@
+sub isPrime(v)
+    if v < 2 then return False : fi
+    if mod(v, 2) = 0 then return v = 2 : fi
+    if mod(v, 3) = 0 then return v = 3 : fi
+    d = 5
+    while d * d <= v
+        if mod(v, d) = 0 then return False else d = d + 2 : fi
+    wend
+    return True
+end sub
+
+sub paresDePrimos(limite)
+    p1 = 0 : p2 = 1 : p3 = 1 : count = 0
+    for i = 5 to limite
+        p3 = p2
+        p2 = p1
+        p1 = isPrime(i)
+        if (p3 and p1) then count = count + 1 : fi
+    next i
+    return count
+end sub
+
+n = 1
+for i = 1 to 6
+    n = n * 10
+    print "pares de primos gemelos por debajo de < ", n, " : ", paresDePrimos(n)
+next i
+end