Due numeri primi sono definiti come numeri primi gemelli se differiscono per due. Ad esempio, 3 e 5 sono numeri primi gemelli come 29 e 31.

Scrivi un programma che trova l'ennesima coppia di numeri primi gemelli (dove n viene da STDIN) e li stampa su STDOUT, separati da una virgola e da uno spazio. Questo è code-golf, quindi vince il codice più corto.

Input di esempio:

3

Uscita campione:

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

Forza bruta tutti i numeri primi gemelli e stampa l' ^ennesima coppia.

CJam, 29 26 byte

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

Provalo online.

Esempi

$ 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

Come funziona

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 caratteri, basandosi sul commento di aschepler

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

101 caratteri, risposta precedente

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

Uso:

$ perl ./twin_primes.pl 10
107, 109

Spiegazione

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

Il funzionamento della regex di non primalità è spiegato in questa domanda SO .

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

Esecuzione di esempio:

$ 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

Grazie per l'aiuto di Dennis, Bebe e Alchymist.

CJam - 26

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

Funziona con numeri primi inferiori a 10000; è possibile sostituire 4con un esponente più elevato per numeri più grandi (potenzialmente fino a 10 ²⁰ ), ma il programma diventerà più lento e utilizzerà più memoria.

Provalo su http://cjam.aditsu.net/

Spiegazione:

1e4,crea l'array [0 1 2 ... 9999]
{mp},seleziona solo i numeri primi
_2f- copie matrice e sottrae 2 da ciascun componente
&interseca le due matrici, trovando così i numeri primi inferiori di ciascuna coppia primo gemello
qilegge l'ingresso e convertiti intero
(=regola la indice e ottiene il primo gemello (inferiore) corrispondente dall'array
_2+copia il primo e aggiunge 2
", "\mette la virgola e lo spazio tra i due numeri primi

Mathematica - 63 caratteri

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

Gli appunti

Questa è in realtà un'implementazione piuttosto semplice. L'accorciamento ha provocato quasi nessuna offuscamento.

NextPrime è un builtin che trova il primo primo dopo un numero.

NestWhile[NextPrime,#,#2-#1!=2&,2]& è una funzione anonima che trova il primo più grande della prossima coppia di primi gemelli dopo un numero.

Nest applica questa funzione anonima n .

Print[#-2,", ",#]&è una funzione anonima che stampa su stdout secondo le specifiche. Purtroppo questo da solo occupa 18 caratteri della soluzione di 63 caratteri.

Esempio

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

Aggiornamento: è possibile salvare due caratteri reimplementando questa soluzione CJam . Tuttavia, questo algoritmo limita il valore massimo di n. Sostituisci semplicemente la Nest...parte conIntersection[#,#-2][[5]]&@Prime@Range[999]

Javascript (E6) 92 96

Più breve e conforme - usa la shell spidermonkey per leggere stdin / scrivere stdout (con virgola e spazio). Trova la 10000esima coppia 1260989, 1260991 in meno di un minuto sul mio PC
Potrebbe essere più breve usando p[n]=o=ninvece di p.push(o=n), in modo che l'array p sia scarso. Ma è piuttosto lento e non vincerò comunque per la lunghezza del codice.

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)

Per provare nella console di Firefox:

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

Una funzione che ha trovato tutti i primi m gemelli (restituisce il valore più grande):

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
}

Esempio: 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]

Solo l'ultimo:

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
}

Quindi, prendi quelle 2 righe e aggiungi IO

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 byte

Ho deciso di seguire un approccio semplice. La funzione ttrova il primo primo gemello dato un numero primo come input (ora questo è incluso nella ffunzione). La funzione ftrova l'ennesimo numero primo gemello. Questo è anche il primo vero programma che ho scritto in J.

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

Esempi:

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

Solo per alcuni sopracciglia, avere la versione non golfata.

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

Spiegazione:

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

Test online: 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

Forza bruta un CTE per trovare numeri primi, funzione finestra per contare n, seguita da un join per trovare il gemello. Funziona in un secondo per output <1.000, poco meno di un minuto per output <10.000.

Golfed (SQLFiddle here ):

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)

Leggibile:

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;', '*

Test online: link

Codice annotato:

~                       # 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

Non uno più piccolo, ma uno prova da 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

Continua a ottenere i numeri primi successivi e memorizza i termini pari e dispari, quindi controlla se la differenza è due.

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 caratteri

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=", ")

Niente di speciale:

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=", ")

Uso:

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

-4 byte grazie a Shaggy

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

Eseguilo online

JavaScript (Node.js), 162 caratteri

Legge da stdin, emette su stdout, esce "in anticipo" per l'input <= 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}}}

Utilizzo (script sopra salvato come 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

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

Eseguendolo:

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

(1a riga dopo l'immissione del comando, la 2a viene emessa)

Questo si basa su un proprio algoritmo di generatore principale che chiamo "setaccio galleggiante di erastostene" (fino a quando non lo trovo descritto altrove) che memorizza solo la parte necessaria del setaccio e i numeri primi già calcolati.

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)

Quindi cosa sta succedendo qui?

Innanzitutto, diamo un'occhiata all'espressione all(n%i&~2for i in range(2,n-2)) , che controlla se (n-2,n)sono una coppia di numeri primi gemelli.

L'espressione più all(n%i for i in range(2,n))semplice controlla semplicemente se nè primo provando tutti i divisori inell'intervallo 2<=i<=n-1e vedendo se tutti i resti sono diversi da zero. Questo allcontrolla esattamente questo, poiché Python considera 0comeFalse e tutti gli altri numeri comeTrue .

Ora, osservalo (n-2)%i==0esattamente quando n%i==2per i divisori i>2. Quindi, possiamo eseguire il controllo della primalità ne n-2allo stesso tempo controllando i resti per entrambi 0e 2. Questo potrebbe essere fatto come all(n%i not in [0,2] for i in range(2,n-2)). Proviamo solo i divisori nella gamma 2<=i<=n-3per il gusto di n-2, ma questo è sufficiente nanche da allora n-1e n-2non può essere divisori a meno che n<=4. Proveremo solo a npartire da dispari 5per evitare questa complicazione e quella del divisorei=2 .

Abbiamo il golf l'espressione n%i not in [0,2]in n%i&~2, ricordando che 0è falso e altri numeri sono True. La precedenza dell'operatore (n%i)&(~2)è esattamente ciò che è necessario. Il complemento di bit ~2è ...11111101, quindi è bit anda bit con un numero azzera il2 valore della posizione binaria. Questo dà 0(cioè, False) solo per 0e 2, esattamente ciò che vogliamo.

Accidenti! Ora abbiamo che l'espressione all(n%i&~2for i in range(2,n-2))controlla se nè il numero superiore di una doppia coppia gemella. Ciò che rimane è iterare su di essi fino a quando non ne vediamo c, dov'è cil numero immesso. Iniziamo con il 5conto 2alla rovescia per evitare problemi con i divisori. Decrementiamo cogni volta che incontriamo qualcosa nche funziona, fermandoci quando c=0. Infine, stampiamo la doppia coppia gemella con cui finiamo.

T-SQL (2012 +), 255 caratteri

Un cercatore gemello T-SQL più compatto che accelera anche un po '.

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

Formato leggibile dall'uomo ::

    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

L'essenza di base è che usiamo la tabella dei numeri incorporata (master..spt_values ​​type = 'p') e alias che con un CTE come qualcosa di breve. Aggiungiamo 2 per rimuovere la preoccupazione di tirare 0 o 1 errori banali per il nostro set, quindi ora abbiamo candidati di 2.2050.

Z la query più interna ottiene tutti i numeri primi da 2 a 2050, filtrando qualsiasi numero n che è divisibile per un numero inferiore a n. Quindi utilizziamo un'elegante funzione di windowing T-SQL 2012 lagche ci consente di ottenere il risultato precedente, quindi ora i risultati di Z aeb sono i numeri primi P[n]e P[n-1]rispettivamente. La query R crea la stringa di output, filtra i numeri primi non gemellati e crea anche un numero di sequenza per l'output che chiamiamo K. Infine, l'ultima query R ci consente di filtrare e ottenere il Kth twin prime modificando la sua variabile.

Mathematica - 71 byte

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