Zwei Primzahlen werden als Doppelprimzahlen definiert, wenn sie sich um zwei unterscheiden. Zum Beispiel sind 3 und 5 zwei Primzahlen, ebenso wie 29 und 31.

Schreiben Sie ein Programm, das das n-te Paar von Doppelprimzahlen findet (wobei n von STDIN stammt) und diese durch Komma und Leerzeichen getrennt auf STDOUT ausgibt. Das ist Code-Golf, also gewinnt der kürzeste Code.

Beispieleingabe:

3

Beispielausgabe:

11, 13

Haskell 118

main=putStrLn.(!!)[show n++", "++show(n+2)|n<-[2..],all((>0).rem n)[2..n-1],all((>0).rem(n+2))[2..n]].(+)(-1)=<<readLn

Brute-Force alle Doppelprimzahlen und druckt das n- ^te Paar.

CJam, 29 26 Bytes

Y4]{{:)_{mp}/&!}g}q~*", "*

Probieren Sie es online aus.

Beispiele

$ for i in {1..10}; do cjam twin-primes.cjam <<< $i; echo; done
3, 5
5, 7
11, 13
17, 19
29, 31
41, 43
59, 61
71, 73
101, 103
107, 109

Wie es funktioniert

Y4]        " Push [ 2 4 ].                                                            ";
{          "                                                                          ";
  {        "                                                                          ";
    :)     " Increment each integer in the array.                                     ";
    _      " Duplicate the array.                                                     ";
    {mp}/  " For each integer in the array, push 1 if it's prime and 0 otherwise.     ";
    &!     " Compute the logical NOT of the bitwise AND of the two previous integers. "; 
  }g       " If the result is non-zero, repeat the loop.                              ";
}q~*       " Do the above “N” times, where “N” is the integer read from STDIN.        ";
", "       " Join the array by comma and space.                                       ";

Perl, 101 87

87 Zeichen, die auf Ascheplers Kommentar aufbauen

$n=pop;$r='^1$|^(11+?)\1+$';($t=1x$s)=~$r||"11t"=~$r||--$n||die"$s, ",$s+2,$/while++$s

101 Zeichen, frühere Antwort

$n=pop;$r=qr/^1$|^(11+?)\1+$/;(1x$s)!~$r&&(1x($s+2))!~$r&&++$i==$n&&say($s,", ",$s+2)&&exit while++$s

Verwendung:

$ perl ./twin_primes.pl 10
107, 109

Erläuterung

$n = pop;                 # Pulls twin prime pair counter from @ARGV
$r = qr/^1$|^(11+?)\1+$/; # The money line - a regex that verifies
                          # if a string of 1's has non-prime length

while ( ++$s ) {          # Loop over integers

                          # '&&' short-circuits
    (1 x  $s    ) !~ $r   # Negated regex match evaluates to true if $s is prime
 && (1 x ($s+2) ) !~ $r   # Same for $s + 2
 &&          ++$i == $n   # Counter to control which pair to print
 && say( $s, ", ", $s+2 ) # Print the line
 && exit                  # Terminate program
}

Die Funktionsweise des Nicht-Primalitäts-Regex wird in dieser SO-Frage erläutert .

C: 113

n,c,l;main(i){for(scanf("%d",&n),l=2;n;l=c==i?n-=i==l+2,i:l,i+=2)for(c=2;c<i&&i%c++;);printf("%d, %d\n",l-2,l);}

Probelauf:

$ for i in $(seq 1 10); do echo $i | ./twinprimes; done
3, 5
5, 7
11, 13
17, 19
29, 31
41, 43
59, 61
71, 73
101, 103
107, 109

Vielen Dank für die Hilfe von Dennis, Bebe und Alchymist.

CJam - 26

1e4,{mp},_2f-&qi(=_2+", "\

Es funktioniert für Primzahlen kleiner als 10000; Sie können 4größere Zahlen durch einen höheren Exponenten ersetzen (möglicherweise bis zu 10 ²⁰ ), aber das Programm wird langsamer und benötigt mehr Speicher.

Versuchen Sie es unter http://cjam.aditsu.net/

Erläuterung:

1e4,schafft die array [0 1 2 ... 9999]
{mp},wählt nur die Primzahlen
_2f-kopiert das Array und 2 subtrahiert von jedem Einzelteil
&schneidet die zwei Arrays, wodurch die unteren Primzahlen aus jedem Zwillingspaar prime finden
qidie Eingabe und wandelt lesen auf ganzzahlige
(=die justiert index und ruft die entsprechende (niedrigere) Doppelprimzahl aus dem Array ab,
_2+kopiert die Primzahl und fügt 2 hinzu, wobei
", "\Komma und Leerzeichen zwischen den beiden Primzahlen stehen

Mathematica - 63 Zeichen

Print[#-2,", ",#]&@Nest[NestWhile[NextPrime,#,#2-#!=2&,2]&,1,n]

Anmerkungen

Dies ist in der Tat eine ziemlich einfache Implementierung. Verkürzung führte zu fast keiner Verschleierung.

NextPrime ist ein Builtin, das nach einer Zahl die nächste Primzahl findet.

NestWhile[NextPrime,#,#2-#1!=2&,2]& ist eine anonyme Funktion, die nach einer Zahl die größere Primzahl des nächsten Twin-Prim-Paares findet.

Nestwendet diese anonyme funktion nmal an.

Print[#-2,", ",#]&ist eine anonyme Funktion, die gemäß den Spezifikationen auf stdout druckt. Leider nimmt dies allein 18 Zeichen der 63-Zeichen-Lösung ein.

Beispiel

In[1]:= Do[                                                                     
         Print[#-2,", ",#]&@Nest[NestWhile[NextPrime,#,#2-#!=2&,2]&,1,n],
         {n, 1, 10}
        ]
3, 5
5, 7
11, 13
17, 19
29, 31
41, 43
59, 61
71, 73
101, 103
107, 109

Update: Durch die Neuimplementierung dieser CJam-Lösung können zwei Zeichen gespeichert werden . Dieser Algorithmus begrenzt jedoch den Maximalwert von n. Ersetzen Sie einfach das Nest...Teil durchIntersection[#,#-2][[5]]&@Prime@Range[999]

Javascript (E6) 92 96

Kürzere und konforme - Verwenden Sie die Spidermonkey-Shell, um stdin zu lesen / stdout zu schreiben (mit Komma und Leerzeichen). Es findet das 10000. Paar 1260989, 1260991 in weniger als einer Minute auf meinem PC.
Könnte kürzer sein, wenn man p[n]=o=nanstelle von verwendet p.push(o=n), so dass das p-Array spärlich ist. Aber das ist ziemlich langsam und ich werde sowieso nicht für die Codelänge gewinnen.

m=readline();for(n=3,o=p=[];m;n+=2)p.every(e=>n%e)&&(m-=n-o<3,p.push(o=n));print(o-2+', '+o)

So probieren Sie die Firefox-Konsole aus:

m=prompt();for(n=3,o=p=[];m;n+=2)p.every(e=>n%e)&&(m-=n-o<3,p.push(o=n));alert(o-2+', '+o)

Ungolfed

Eine Funktion, die alle ersten m Zwillinge gefunden hat (gibt den größten Wert zurück):

T=m=>{
  for (o=n=3, p=[2], t=[]; !t[m-1]; n+=2)
    p.every(e => n%e) && (n-o-2 ? 0 : t.push(n), p.push(o=n))
  return t
}

Beispiel: console.log(T(50))

[5, 7, 13, 19, 31, 43, 61, 73, 103, 109, 139, 151, 181, 193, 199, 229, 241, 271, 283, 313, 349, 421, 433, 463, 523, 571, 601, 619, 643, 661, 811, 823, 829, 859, 883, 1021, 1033, 1051, 1063, 1093, 1153, 1231, 1279, 1291, 1303, 1321, 1429, 1453, 1483, 1489]

Nur das letzte:

L=m=>{
  for (o=n=3,p=[2]; m; n+=2)
    p.every(e => n%e) && (m -= n-o==2, p.push(o=n))
  return o
}

Nehmen Sie dann diese 2 Zeilen und fügen Sie IO hinzu

m = prompt()
for (o=n=3, p=[2]; m; n+=2)
  p.every(e => n%e) && (m -= n-o==2, p.push(o=n))
alert('o-2+', '+o)

J - 49 60 55 51 Bytes

Ich entschied mich für einen einfachen Ansatz. Die Funktion tfindet die nächste Doppelprimzahl mit einer Primzahl als Eingabe (jetzt ist dies in der fFunktion enthalten). Funktion ffindet die n-te Twin-Primzahl. Dies ist auch das erste Programm, das ich in J geschrieben habe.

f=:[:(":,', ',":@+&2)(4&p:(,{~-=2:)])^:_@>:^:(]`2:)

Beispiele:

   f 1
3, 5
   f 2
5, 7
   f 3
11, 13
   f 4
17, 19
   f 5
29, 31
   f 100000
18409199, 18409201

Haben Sie nur für einige Augenbrauen die ungolfed Version.

twin =: (4&p:)(($:@[)`(,)@.(=(]+2:)))]
f    =: ((]-2:),])((0:{twin) ^: (]`(2:)))

Erläuterung:

f=:[:(":,', ',":@+&2)(4&p:(,{~-=2:)])^:_@>:^:(]`2:)
                     (4&p:(,{~-=2:)])^:_@>:^:(]`2:)
                                        @>:^:(]`2:)  main loop
                                           ^:(]`2:)  Repeat n times, starting with value of 2
                                        @>:          Add one to the current value and apply to the following function.
                     (4&p:(,{~-=2:)])^:_             Get the next twin prime
                                     ^:_             Recurse until there's no change
                          (,{~-=2:)                  If next prime - current value == 2, return current value, otherwise the next prime.
                      4&p:                           Get the next prime
     (":,', ',":@+&2)                                Format the output and add 2 to the second value.
   [:                                                Apply the twin prime to the formatter.

Basically, if n is 4, this creates a recursion tree like this:
 let T be the recursion inside t
 and numbers between rows the return values of according function
   (t * n) 3
-> (t * 4) 3
-> t  t  t  t  3
   17 11 5  3
-> (T  T) (T  T) T  T  3
    17 13  11 7  5  3
-> 17

C # 265

using System.Linq;class P{static void Main(string[] args){var i=int.Parse(args[0]);int f=0,c=0;for(int j=1;;j+=2){var b=(Enumerable.Range(1,j).Count(x=>j%x==0)==2);if(f==0 && b){f=j;continue;}if(b){c++;if(c==i){System.Console.WriteLine(f+","+j);break;}j-=2;}f=0;}}}

Ruby 94

require'mathn'
n=gets.to_i
a=1
(a+=2;a.prime?&&(a+2).prime?&&n-=1)while n>0
$><<"#{a}, #{a+2}"

Online-Test: http://ideone.com/B2wxnG

Perl, 100 95

$n=<>;$i=3;while($c<$n&&($l=$i++)){$i++until!grep{$i%$_<1}(2..$i-1);$c++if$i-$l<3}print"$l, $i"

Ungolfed:

$n = <>;          # Read from STDIN
$i = 3;           # Tiny hack because I know I don't need the number 2
while ($c<$n && ($l = $i++)) {   # $c counts the pairs, $l is the last prime
  $i++ until ! grep {$i%$_<1} (2..$i-1);   # Increase $i until it's not divisible by anything
  $c++ if $i-$l < 3   # If $i and $l are twin primes, count it
}
print "$l, $i"    # That damned comma added a whole character to my code!

T-SQL (2008+): 344

Brute erzwinge einen CTE, Primzahlen zu finden, Fensterfunktion, um n zu zählen, gefolgt von einem Join, um den Zwilling zu finden. Funktioniert in einer Sekunde für Ausgaben <1.000, knapp eine Minute für Ausgaben <10.000.

Golf (SQLFiddle hier ):

WITH x(i) AS(SELECT 99 UNION ALL SELECT i-2
FROM x WHERE i>3),z AS(SELECT RANK()OVER(ORDER BY x.i)n,x.i
FROM x x LEFT JOIN x y ON x.i%y.i=0 AND y.i NOT IN(x.i,1)
WHERE y.i IS NULL)SELECT LTRIM(a)+', '+LTRIM(b)FROM(SELECT RANK()
OVER(ORDER BY x.i)n,x.i a,y.i b FROM z x,z y WHERE x.n=y.n-1
AND x.i=y.i-2) o WHERE n=3
OPTION(MAXRECURSION 0)

Lesbar:

WITH x(i) AS (
   SELECT 99
    UNION ALL
   SELECT i-2
   FROM x
   WHERE i > 3
)
,z AS (
SELECT RANK()OVER(ORDER BY x.i)n,x.i
FROM x x
WHERE NOT EXISTS
  (SELECT *
   FROM x y
   WHERE x.i%y.i = 0
    AND y.i NOT IN (x.i,1)
  )
)
SELECT LTRIM(a)+', '+LTRIM(b)
FROM (
    SELECT RANK()OVER(ORDER BY x.i)n,x.i a, y.i b
    FROM z x, z y
    WHERE x.n = y.n+1
    AND x.i = y.i+2
) o
WHERE n = 3
OPTION(MAXRECURSION 0)

GolfScript 46

~[1 3]\{\{))}%.{:x,{)x\%!},,2=}/*@\-.}do;', '*

Online-Test: Link

Kommentierter Code:

~                       # parse the input as an int
[1 3]                   # add the array [1, 3] on the stack
\                       # invert the items on the stack
{                       # begin loop
  \                     # bring the array to the top of the stack
  {))}%                 # add 2 to each of the numbers in the array
  .{:x,{)x\%!},,2=}/    # check if numbers are prime (leaves a 0 or 1 for both numbers on the stack)
  *                     # multiply the two 0/1 numbers (will only get 1 if both are 1)
  @\-                   # subtract the result from the inital int
  .                     # copy the new int value on the stack to be consumed by the 'do' loop
}do                     # repeat until the initial int was taken down to 0
                        # at this point the array contains the two numbers we're looking for
;                       # get rid of the 0 from the stack
', '*                   # format the output

PHP 5.4, 223

Kein kleinerer, aber ein Versuch von PHP.

$n=$argv[1];function i($k){for($i=2;$i<=(int)($k/2);$i++)if($k%$i==0)return 0;return 1;}function t($t){return (i($t) && i($t+2))?1:0;}$g=1;$d=0;do{if(t($g)==1){if($d<$n){$d++;}else{print_r([$g,$g+2]);break;}}$g++;}while(1);

C 309

Erhält weiterhin die nächsten Primzahlen und speichert gerade und ungerade Terme und prüft dann, ob der Unterschied zwei ist.

int main()
{
int n;
scanf("%d",&n);
int a=2,b=3,k=2,q;
int odd=1;
int p;
if(n>0)
{
while(n)
{
k++;
p=1;
q=ceil(sqrt(k));
for(int i=2;i<=q;i++)
{
if(k%i==0)
{
p=0;
break;
}
}
if(p)
{
if(odd%2==0)a=k;
else b=k;
if(abs(a-b)==2)n--;
odd++;
}
}
}
printf("%d %d\n",a,b);
return 0;
}

R 91 Zeichen

a=scan();n=1;p=5;while(n!=a){p=p+1;q=p-2;if(sum(!p%%2:p,!q%%2:q)<3)n=n+1};cat(q,p,sep=", ")

Nichts wirklich ausgefallenes:

a=scan()
n=1
p=5
while(n!=a){
    p=p+1
    q=p-2
    if(sum(!p%%2:p,!q%%2:q)<3) # Check that p and q are both primes by checking
       n=n+1                   # the number of zeroes resulting from 
}                              # p modulo each integers 2 to p and same for q
cat(q,p,sep=", ")

Verwendung:

> a=scan();n=1;p=5;while(n!=a){p=p+1;q=p-2;if(sum(!p%%2:p,!q%%2:q)<3)n=n+1};cat(q,p,sep=", ")
1: 10
2: 
Read 1 item
107, 109

Japt, 23 19 Bytes

-4 Bytes dank Shaggy

@µX°j ©°Xj}f
[UU+2]

Führen Sie es online aus

JavaScript (Node.js), 162 Zeichen

Liest von stdin, gibt auf stdout aus und beendet "früh" für die Eingabe <= 0.

t=process.argv[2],c=0,l=1;if(t>0){for(i=0;;i++){p=!Array(i+1).join(1).match(/^1?$|^(11+?)\1+$/);if(p){if(i-2==l){if(c>=t-1){console.log(l+", "+i);break}c++}l=i}}}

Verwendung (Skript oben gespeichert als ntp.js):

>for /l %x in (0, 1, 10) do node ntp.js %x
>node ntp.js 0
>node ntp.js 1
3, 5
>node ntp.js 2
5, 7
>node ntp.js 3
11, 13
>node ntp.js 4
17, 19
>node ntp.js 5
29, 31
>node ntp.js 6
41, 43
>node ntp.js 7
59, 61
>node ntp.js 8
71, 73
>node ntp.js 9
101, 103
>node ntp.js 10
107, 109

AWK - 129

Die Datei fsoe-pairs.awk:

{n=2;N=1
for(;;){if(n in L){p=L[n];del L[n]}else{p=n
if(n-N==2)if(!--$0){print N", "n;exit}N=n}P=p+n++
while(P in L)P+=p;L[P]=p}}

Laufen es:

$ awk -f fsoe-pairs.awk
1
3, 5
$ awk -f fsoe-pairs.awk
2
5, 7
$ awk -f fsoe-pairs.awk
10
107, 109

(1. Zeile nach Eingabe des Befehls, die 2. Zeile wird ausgegeben)

Dies basiert auf einem eigenen Primgenerator-Algorithmus, den ich "Floating Sieve of Erastosthenes" nenne (bis ich ihn an anderer Stelle beschreibe), der nur den benötigten Teil des Siebs und die bereits berechneten Primzahlen speichert.

Python 2 (75)

c=input()
n=3
while c:n+=2;c-=all(n%i&~2for i in range(2,n-2))
print(n-2,n)

Also, was ist hier los?

Schauen wir uns zunächst den Ausdruck an all(n%i&~2for i in range(2,n-2)), der prüft, ob (n-2,n)es sich um ein Paar Doppelprimzahlen handelt.

Der einfachere Ausdruck all(n%i for i in range(2,n))prüft einfach, ob nPrimzahl vorliegt, indem er jeden Divisor iim Bereich ausprobiert 2<=i<=n-1und feststellt, ob alle Reste ungleich Null sind. Dies allüberprüft genau dies, da Python 0as Falseund alle anderen Zahlen als behandelt True.

Beobachten Sie nun (n-2)%i==0genau das, wenn es sich n%i==2um Teiler handelt i>2. So können wir die primality Überprüfung durchführen nund n-2zugleich durch die Reste für beide Überprüfung 0und 2. Das könnte so gemacht werden all(n%i not in [0,2] for i in range(2,n-2)). Wir versuchen nur Teilern im Bereich 2<=i<=n-3zum Wohle n-2, aber das genügt für nauch da n-1und n-2nicht Teilern es sei denn , sein kann n<=4. Wir werden nur ungerade nbeginnen 5, um diese Komplikation und die des Divisors zu vermeiden i=2.

Wir spielen den Ausdruck n%i not in [0,2]in Golf n%i&~2und erinnern uns, dass 0das falsch ist und andere Zahlen sind True. Die Operator-Priorität (n%i)&(~2)ist genau das, was benötigt wird. Das Bitkomplement ~2ist ...11111101, also bitweise andmit einer Zahl von Nullen, der 2binäre Platzwert des Bits . Dies gibt 0(dh False) nur für 0und 2genau das, was wir wollen.

Puh! Nun haben wir, dass der Ausdruck all(n%i&~2for i in range(2,n-2))prüft, ob ndie obere Zahl eines Twin-Prim-Paares ist. Was bleibt, ist über sie zu iterieren, bis wir cvon ihnen sehen, wo cdie eingegebene Zahl ist. Wir beginnen mit 5und zählen auf 2, um Teilerprobleme zu vermeiden. Wir dekrementieren cjedes Mal n, wenn wir auf ein Problem stoßen , das funktioniert, und hören auf, wenn c=0. Schließlich drucken wir das Twin-Prim-Paar, mit dem wir enden.

T-SQL (2012 +), 255 Zeichen

Ein kompakterer T-SQL Twin Prime Finder, der auch ein bisschen schneller wird.

with t(n)as(select 2+number from spt_values where type='p')select*from(select concat(b,', ',a),rank()over(order by a)from(select n,lag(n)over(order by n)from t where not exists(select*from t f where f.n<t.n and t.n%f.n=0))z(a,b)where a=b+2)r(s,k)where k=2

Menschenlesbares Format ::

    with t(n)as(
        select 2+number 
        from spt_values 
        where type='p'
    )
    select *
    from(
        select concat(b,', ',a),rank() over (order by a)
        from(
            select n, lag(n) over(order by n)


    from t 
        where not exists(
            select 1 from t f 
            where f.n<t.n and t.n%f.n=0)
    ) z(a,b)
    where a=b+2
) r(s,k)
where k=2

Der Grundgedanke ist, dass wir die eingebaute Zahlentabelle (master..spt_values ​​type = 'p') und den Alias ​​mit einem CTE als etwas Kurzes verwenden. Wir addieren 2, um die Sorge zu beseitigen, 0 oder 1 unbedeutende Fehler für unser Set zu ziehen, und haben nun Kandidaten von 2.2050.

Z Die innerste Abfrage erhält alle Primzahlen von 2 bis 2050, indem jede Zahl n herausgefiltert wird, die durch eine Zahl kleiner als n teilbar ist. Wir verwenden dann eine schicke T-SQL 2012 Windowing - Funktion , lagdie wir das vorherige Ergebnis ziehen läßt, so dass nun Zs Ergebnisse a und b die Primzahlen sind P[n]und P[n-1]jeweils. Die R-Abfrage erstellt die Ausgabezeichenfolge und filtert Nicht-Twin-Primzahlen sowie eine Folgenummer für die Ausgabe, die wir K nennen. Schließlich ermöglicht die letzte Abfrage R das Filtern und Abrufen der K-ten Twin-Primzahl durch Ändern ihrer Variablen.

Mathematica - 71 Bytes

n=Input[];
i=j=0;
While[j<n,i++;If[And@@PrimeQ[x={i,i+2}],j++]];Print@x