Deux nombres premiers sont définis comme des nombres premiers jumeaux s'ils diffèrent par deux. Par exemple, 3 et 5 sont des nombres premiers jumeaux, tout comme 29 et 31.

Écrivez un programme qui trouve la nième paire de nombres premiers jumeaux (d'où n vient de STDIN) et les imprime sur STDOUT, séparés par une virgule et un espace. C'est le code-golf, donc le code le plus court l'emporte.

Exemple d'entrée:

3

Exemple de sortie:

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 tous les nombres premiers jumeaux et imprime la n ^ème paire.

CJam, 29 26 octets

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

Essayez-le en ligne.

Exemples

$ 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

Comment ça marche

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 caractères, construisant sur le commentaire d'un aspirateur

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

101 caractères, réponse antérieure

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

Usage:

$ perl ./twin_primes.pl 10
107, 109

Explication

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

Le fonctionnement du regex de non-primalité est expliqué dans cette question 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);}

Exemple d'exécution:

$ 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

Merci pour l'aide de Dennis, bebe et Alchymist.

CJam - 26

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

Cela fonctionne pour des nombres premiers inférieurs à 10000; vous pouvez remplacer 4par un exposant plus élevé pour les plus grands nombres (potentiellement jusqu'à 10 ²⁰ ), mais le programme deviendra plus lent et utilisera plus de mémoire.

Essayez-le sur http://cjam.aditsu.net/

Explication:

1e4,crée le tableau [0 1 2 ... 9999]
{mp},sélectionne uniquement les nombres premiers
_2f-copie le tableau et soustrait 2 de chaque élément
&intersecte les deux tableaux, trouvant ainsi les nombres premiers inférieurs de chaque paire principale jumelle
qilit l'entrée et convertit en entier
(=ajuste le index et obtient le nombre premier (inférieur) correspondant du tableau
_2+copie le nombre premier et ajoute 2
", "\place la virgule et l'espace entre les deux nombres premiers

Mathematica - 63 caractères

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

Remarques

Il s'agit en fait d'une mise en œuvre plutôt simple. Le raccourcissement n'a entraîné pratiquement aucune obfuscation.

NextPrime est une fonction intégrée qui trouve le premier nombre premier après un nombre.

NestWhile[NextPrime,#,#2-#1!=2&,2]& est une fonction anonyme qui trouve le plus grand nombre premier de la paire de paires jumelles suivante après un nombre.

Nestapplique cette fonction anonyme nfois.

Print[#-2,", ",#]&est une fonction anonyme qui imprime sur stdout selon les spécifications. Malheureusement, cela à lui seul occupe 18 caractères de la solution à 63 caractères.

Exemple

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

Mise à jour: Deux caractères pourraient être enregistrés en réimplémentant cette solution CJam . Cependant, cet algorithme limite la valeur maximale de n. Remplacez simplement la Nest...pièce parIntersection[#,#-2][[5]]&@Prime@Range[999]

Javascript (E6) 92 96

Plus court et conforme - utilisez le shell spidermonkey pour lire stdin / écrire stdout (avec virgule et espace). Il trouve la 10000e paire 1260989, 1260991 en moins d'une minute sur mon PC. Il
pourrait être plus court à utiliser à la p[n]=o=nplace de p.push(o=n), de sorte que la matrice p est rare. Mais c'est assez lent, et je ne gagnerai pas de toute façon pour la longueur du code.

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)

Pour essayer dans la console 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)

Non golfé

Une fonction qui a trouvé tous les m premiers jumeaux (renvoie la plus grande valeur):

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
}

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

Juste la dernière:

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
}

Ensuite, prenez ces 2 lignes et ajoutez 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 octets

J'ai décidé de suivre une approche simple. La fonction ttrouve le premier jumeau suivant en fonction d' un nombre premier en entrée (maintenant, cela est inclus dans la ffonction). La fonction ftrouve le nième nombre premier. C'est aussi le premier programme réel que j'ai écrit en J.

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

Exemples:

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

Juste pour quelques sourcils, ayez la version non golfée.

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

Explication:

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

Rubis 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 en ligne: 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"

Non golfé:

$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 force un CTE à trouver des nombres premiers, une fonction de fenêtre à compter n, suivie d'une jointure pour trouver le jumeau. Fonctionne en une seconde pour les sorties <1 000, un peu moins d'une minute pour les sorties <10 000.

Golfé (SQLFiddle ici ):

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)

Lisible:

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 en ligne: lien

Code annoté:

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

Pas un plus petit, mais un essai de 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

Continue d'obtenir les nombres premiers suivants et stocke les termes pairs et impairs, puis vérifie si la différence est de deux.

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 caractères

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

Rien d'extraordinaire:

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

Usage:

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

-4 octets grâce à Shaggy

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

Exécutez-le en ligne

JavaScript (Node.js), 162 caractères

Lit depuis stdin, sort vers stdout, quitte "tôt" pour l'entrée <= 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}}}

Utilisation (script ci-dessus enregistré sous 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

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

Exécuter:

$ 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ère ligne après l'entrée de la commande, la 2ème sortie)

Ceci est basé sur un propre algorithme de générateur principal que j'appelle "tamis flottant d'érastosthènes" (jusqu'à ce que je le trouve décrit ailleurs) qui ne stocke que la partie nécessaire du tamis et les nombres premiers déjà calculés.

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)

Alors qu'est-ce qui se passe ici?

Tout d'abord, regardons l'expression all(n%i&~2for i in range(2,n-2)), qui vérifie s'il (n-2,n)s'agit d'une paire de nombres premiers jumeaux.

L'expression plus all(n%i for i in range(2,n))simple vérifie simplement si nest premier en essayant tous les diviseurs ide la plage 2<=i<=n-1et en voyant si tous les restes sont différents de zéro. Cela allvérifie exactement cela, car Python traite 0comme Falseet tous les autres nombres comme True.

Maintenant, observez cela (n-2)%i==0exactement n%i==2pour les diviseurs i>2. Ainsi, nous pouvons effectuer le contrôle de primalité sur net n-2en même temps en vérifiant les restes pour 0et 2. Cela pourrait se faire comme all(n%i not in [0,2] for i in range(2,n-2)). Nous essayons uniquement les diviseurs de la gamme 2<=i<=n-3pour le plaisir de n-2, mais cela suffit naussi depuis n-1et n-2ne peut pas être des diviseurs à moins n<=4. Nous n'essaierons que de bizarre à npartir de 5pour éviter cette complication et celle du diviseur i=2.

Nous jouons l'expression n%i not in [0,2]en nous n%i&~2souvenant que 0c'est faux et que d'autres chiffres le sont True. La priorité de l'opérateur (n%i)&(~2)est exactement ce qui est nécessaire. Le complément de bits ~2est ...11111101, donc son bit andavec un nombre met à zéro la 2valeur de position binaire de. Cela donne 0(c'est-à-dire False) uniquement pour 0et 2exactement ce que nous voulons.

Phew! Maintenant, nous avons que l'expression all(n%i&~2for i in range(2,n-2))vérifie si nest le nombre supérieur d'une paire principale jumelle. Il reste à les parcourir jusqu'à ce que nous les voyions c, où cest le nombre entré. Nous commençons par 5et comptons 2pour éviter les problèmes de diviseurs. Nous décrémentons cchaque fois que nous rencontrons un nqui fonctionne, s'arrêtant quand c=0. Enfin, nous imprimons la paire prime jumelle avec laquelle nous terminons.

T-SQL (2012 +), 255 caractères

Un Twin Prime Finder T-SQL plus compact qui obtient également un peu d'accélération.

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

Format lisible par l'homme ::

    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'essentiel de base est que nous utilisons la table de nombres intégrée (master..spt_values ​​type = 'p') et l'alias avec un CTE comme quelque chose de court. Nous ajoutons 2 pour supprimer le souci de tirer 0 ou 1 erreurs triviales pour notre ensemble, nous avons donc maintenant des candidats de 2,2050.

Z la requête la plus interne obtient tous les nombres premiers de 2 à 2050, en filtrant tout nombre n divisible par un nombre inférieur à n. Nous utilisons ensuite une fonction de fenêtrage astucieuse T-SQL 2012 lagqui nous permet de tirer le résultat précédent, alors maintenant les résultats de Z a et b sont les nombres premiers P[n]et P[n-1]respectivement. La requête R crée la chaîne de sortie, filtre les nombres premiers non jumeaux et crée également un numéro de séquence pour la sortie que nous appelons K. Enfin, la dernière requête R nous permet de filtrer et d'obtenir le Kth twin prime en changeant sa variable.

Mathematica - 71 octets

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