Je suis 2/3 jumeaux avec mon frère, c'est-à-dire né le même jour du même mois mais douze ans plus tard. Quand j'avais 5 ans, il avait 17 ans, les deux premiers; la dernière paire d'âges sur laquelle nous pouvons raisonnablement compter est [71, 83], tous les deux étant vivants et capables de célébrer ce jubilé coïncident.

Tâche

Créez un code qui

• prend deux entiers en entrée: la différence entre le compteur et le "jumeau" comme un entier positif k (enfin oui, je suis le plus jeune) et la borne supérieure comme un entier positif u (considération d'exécution)

• et donne la sortie sous forme de tableau ou de liste de tous les i nombres inférieurs ou égaux à u pour lesquels i et i + k sont des nombres premiers. La sortie n'a pas besoin d'être triée.

Cas de test

12, 1000 -> [5, 7, 11, 17, 19, 29, 31, 41, 47, 59, 61, 67, 71, 89, 97, 101, 127, 137, 139, 151, 167, 179, 181, 199, 211, 227, 229, 239, 251, 257, 269, 271, 281, 337, 347, 367, 389, 397, 409, 419, 421, 431, 449, 467, 479, 487, 491, 509, 557, 587, 601, 607, 619, 631, 641, 647, 661, 727, 739, 757, 761, 797, 809, 811, 827, 907, 929, 941, 971, 997]
2, 999 -> [3, 5, 11, 17, 29, 41, 59, 71, 101, 107, 137, 149, 179, 191, 197, 227, 239, 269, 281, 311, 347, 419, 431, 461, 521, 569, 599, 617, 641, 659, 809, 821, 827, 857, 881]
3, 1500 -> [2]
30, 1500 -> [7, 11, 13, 17, 23, 29, 31, 37, 41, 43, 53, 59, 67, 71, 73, 79, 83, 97, 101, 107, 109, 127, 137, 149, 151, 163, 167, 181, 193, 197, 199, 211, 227, 233, 239, 241, 251, 263, 277, 281, 283, 307, 317, 337, 349, 353, 359, 367, 379, 389, 401, 409, 419, 431, 433, 449, 457, 461, 479, 491, 541, 547, 557, 563, 569, 571, 577, 587, 601, 613, 617, 631, 643, 647, 653, 661, 709, 727, 739, 743, 757, 797, 809, 823, 827, 829, 853, 857, 877, 881, 907, 911, 937, 941, 947, 953, 967, 983, 991, 1009, 1019, 1021, 1031, 1033, 1039, 1061, 1063, 1087, 1093, 1123, 1151, 1163, 1171, 1187, 1193, 1201, 1229, 1249, 1259, 1277, 1289, 1291, 1297, 1399, 1409, 1423, 1429, 1451, 1453, 1459, 1481, 1493]

Éditer

Comme je n'ai pas précisé la limite supérieure, les solutions inclusives et exclusives sont les bienvenues.

Édition n ° 2

Le défi se termine le 1er septembre, une semaine après le début.
On dirait que nous avons un gagnant, mais en cas d'égalité, c'est le bris d'égalité; dans ce cas, la "seconde" sera compensée par une prime.

Gelée, 8 7 octets

+ÆR©_f®

Essayez-le en ligne!

Explication

+          add the upper bound and the difference
 ÆR        find all primes up to that number
   ©       save that in the register
    _      subtract the difference from each
     f®    remove anything not in the original prime list

Brachylog , 27 23 octets

:1f
hS,?tye.:S+:.L*$pL,

Essayez-le en ligne!

Vérifiez tous les cas de test.

Prédicat 0 (prédicat principal)

:1f                     Find all solutions of predicate 1
                        given Input as Input,
                        Unify Output with the set of all solutions.

Prédicat 1 (prédicat auxiliaire)

hS,?tye.:S+:.L*$pL,

hS                      the first element of Input is S,
   ?tye.                Output is an element between 0 and
                        the last element of Input,
       .:S+:.L          The list [Output+S,Output] is L,
             L*$pL      The product of L, prime-factorized, is still L

05AB1E , 9 octets

Code:

LDpÏDI+pÏ

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Pyke, 10 octets

S#_PiQ+_P&

Essayez-le ici!

S#         - filter(range(input_2), V) as i
  _P       -   is_prime(i)
         & -  ^ & V
    iQ+    -    i + input_1
       _P  -   is_prime(^)

Aussi 10 octets:

S#_DP.IQ-P

Essayez-le ici!

Octave, 34 33 octets

@(k,u)(a=primes(u))(isprime(a+k))

MATL , 8 octets

Nous remercions @alephalpha pour son approche , qui m'a aidé à économiser 3 octets

Zqti+Zp)

Essayez-le en ligne!

Zq    % Take input implicitly. Vector of primes up to that. Call this vector A
ti+   % Duplicate, take second input, add element-wise. Call this vector B
Zp    % Vector containing true for prime numbers in B
)     % Use as an index into A. Display implicitly

Python 3, 114 92 90 octets

Merci à @Dennis pour -2 octets

def f(k,u):
 i=P=1;l={0}
 while i<u+k:l|={P%i*i};P*=i*i;i+=1
 return{i-k for i in l}&l-{0}

Une fonction qui prend l'entrée via un argument et retourne un ensemble non trié. Ceci est exclusif par rapport à la limite supérieure.

Ceci utilise la méthode dans la réponse de @ xnor ici pour trouver des nombres premiers.

Essayez-le sur Ideone

Comment ça fonctionne

Premier constat

Nous initialisons d'abord une valeur de test iet un produit Pcomme 1, et une liste de nombres premiers lcomme l'ensemble contenant 0. Ensuite, une whileboucle qui teste toutes les valeurs de ila plage [1, u+k-1]de primalité est exécutée. L'idée est qu'en multipliant Ppar i^2à la fin de chaque itération, on Pprend la valeur (i-1)!^2lors du test i, c'est-à-dire le produit des entiers au [1, i+1]carré. Le test de primalité réel est ensuite effectué en calculant P mod i; si cela renvoie zéro, alors ine peut pas être premier car cela implique qu'il iest divisible par au moins une des valeurs qui composent le produit. Si cela revient 1, alorsi doit être premier car il n'est divisible par aucune des valeurs du produit. Si iest premier, il est ajouté à l, et sinon,0 est ajouté. La mise au carré du produit évite une fausse identification de 4comme premier, et est utile ici car elle garantit que seul 0ou 1sera retourné, permettant de faire le choix de la valeur à ajouter en multipliant simplement le résultat par i.

Identification des nombres premiers «jumeaux»

Nous créons maintenant un ensemble plus complet, contenant tous les éléments de l-k, élément par élément. L'intersection de cet ensemble et lse trouve alors à l'aide de &, ce qui laisse un ensemble ne contenant que les éléments communs aux deux ensembles. Un certain nombre iest que dans les deux ensembles si les deux iet i+ksont premiers, ce qui signifie que cela laisse la sortie désirée. Cependant, si kest premier, 0sera présent dans les deux ensembles, ce qui signifie que cela doit être supprimé avant de revenir.

R, 98 octets

function(k,u){v=c();for(i in 1:u)if(sum(i%%(1:i)==0)==2&&sum((i+k)%%(1:(i+k))==0)==2){v=c(v,i)};v}

Non golfé:

function(k,u)
v=c()                                                    #Empty vector

for(i in 1:u)
    if(sum(i%%(1:i)==0)==2&&sum((i+k)%%(1:(i+k))==0)==2) #If both i and i+k only have 
                                                         #2 divisors such as the rest of the 
                                                         #euclidian division is 0 
                                                         #(i.e., they're both prime) :
        v=c(v,i)
v

CJam, 17 octets

Soit en programme complet:

q~{_mp\W$+mp&},p;

Essayez-le en ligne!

Ou comme un bloc sans nom:

{:X;{_mp\X+mp&},}

Essayez-le en ligne!

Java 7, 185 175 octets

import java.util.*;List c(int k,int u){List l=new ArrayList();for(int i=1;++i<u;)if(p(i)&p(i+k))l.add(i);return l;}boolean p(int n){for(int i=2;i<n;)n=n%i++<1?0:n;return n>1;}

Code non testé et testé:

Essayez-le ici.

import java.util.*;
class M{
  static List c(int k, int u){
    List l = new ArrayList();
    for(int i = 1; ++i < u; ){
      if(p(i) & p(i+k)){
        l.add(i);
      }
    }
    return l;
  }

  static boolean p(int n){
    for(int i = 2; i < n; ){
      n = n % i++ < 1
           ? 0
           : n;
    }
    return n>1;
  }

  public static void main(String[] a){
    System.out.println(c(12, 1000));
    System.out.println(c(2, 999));
    System.out.println(c(3, 1500));
    System.out.println(c(30, 1500));
  }
}

Production:

[5, 7, 11, 17, 19, 29, 31, 41, 47, 59, 61, 67, 71, 89, 97, 101, 127, 137, 139, 151, 167, 179, 181, 199, 211, 227, 229, 239, 251, 257, 269, 271, 281, 337, 347, 367, 389, 397, 409, 419, 421, 431, 449, 467, 479, 487, 491, 509, 557, 587, 601, 607, 619, 631, 641, 647, 661, 727, 739, 757, 761, 797, 809, 811, 827, 907, 929, 941, 971, 997]
[3, 5, 11, 17, 29, 41, 59, 71, 101, 107, 137, 149, 179, 191, 197, 227, 239, 269, 281, 311, 347, 419, 431, 461, 521, 569, 599, 617, 641, 659, 809, 821, 827, 857, 881]
[2]
[7, 11, 13, 17, 23, 29, 31, 37, 41, 43, 53, 59, 67, 71, 73, 79, 83, 97, 101, 107, 109, 127, 137, 149, 151, 163, 167, 181, 193, 197, 199, 211, 227, 233, 239, 241, 251, 263, 277, 281, 283, 307, 317, 337, 349, 353, 359, 367, 379, 389, 401, 409, 419, 431, 433, 449, 457, 461, 479, 491, 541, 547, 557, 563, 569, 571, 577, 587, 601, 613, 617, 631, 643, 647, 653, 661, 709, 727, 739, 743, 757, 797, 809, 823, 827, 829, 853, 857, 877, 881, 907, 911, 937, 941, 947, 953, 967, 983, 991, 1009, 1019, 1021, 1031, 1033, 1039, 1061, 1063, 1087, 1093, 1123, 1151, 1163, 1171, 1187, 1193, 1201, 1229, 1249, 1259, 1277, 1289, 1291, 1297, 1399, 1409, 1423, 1429, 1451, 1453, 1459, 1481, 1493]

PARI / GP, 39 octets

k->u->[x|x<-primes([1,u]),isprime(x+k)]

Mathematica, 43 octets

(Prime@Range@PrimePi@#2+#)~Select~PrimeQ-#&

Générez tous les nombres premiers inférieurs ou égaux à la limite supérieure. Ajoutez la différence d'âge au résultat. Sélectionnez des nombres premiers parmi eux. Soustrayez la différence d'âge au résultat.

Swift, 142 octets

func f(a:Int,b:Int)->Array<Int>{let p={(n:Int)->Int in([Int]()+(2..<n)).filter{n%$0<1}.count}
return([Int]()+(2...b)).filter{p($0)+p($0+a)<1}}

Perl 6 ,  39  37 octets

->\k,\u{grep {($_&$_+k).is-prime},2..u}

->\k,\u{grep {($_&$_+k).is-prime},^u}

Explication:

-> \k, \u {

  # find all the values
  grep

  # where
  {
    # ｢all｣ junction of the two values
    ( $_   &   $_ + k ) # ｢ all( $_, $_ + k ) ｣

    # autothread a method call against the junction
    .is-prime
  },

  # from the values up to (and excluding) ｢u｣
  ^ u # short for ｢ 0 ..^ u ｣
  # for inclusive use ｢ 2 .. u ｣

}

SILOS , 205 octets

GOTO b
funce
n = p
p - 1
f = 1
lbla
f * p
f % n
p - 1
if p a
return
lblb
readIO 
s = i
readIO 
i - 2
lblc
i + 1
p = i
GOSUB e
F = f
p = i
p + s
GOSUB e
F * f
if F g
GOTO h
lblg
printInt i
lblh
i - 2
if i c

Essayez-le en ligne!

Test de primauté par le théorème de Wilson .

En fait , 12 octets

L'entrée est ualors k. Suggestions de golf bienvenues. Essayez-le en ligne!

╖R`;p@╜+p*`░

Ungolfing:

╖              Store k in register 0.
 R             Range [1..u]
  `       `░   Start a function f and push values i of the range where f(i) is truthy.
   ;p@         Duplicate i, check if i is prime, and swap with the other i.
      ╜+p      Push k, add to i, check if i+k is prime.
         *     Multiply the two if results together.
                 Similar to logical AND. 1 if both are true, else 0.

R, 104 octets

Contrairement à l'autre solution R publiée, celle-ci prend les données de stdin.

s=scan();sapply(1:s[2],function(i){j=i+s[1];if((all(i%%(3:i-1)!=0)|i==2)&all(j%%(3:j-1)!=0))cat(i," ")})

Non golfé:

s=scan();        # Read from stdin
sapply(1:s[2],   # For i from 1 to u,
    function(i){     # apply this function:
        j=i+s[1];                # Define i+k
        if((all(i%%(3:i-1)!=0)   # Test if i is prime
           | i==2)               # (i is prime if i==2)
           & all(j%%(3:j-1)!=0)) # Test if i+k is prime
        cat(i," ")               # If i and i+k are prime, print i
    }
)

Javascript (ES6), 90 83 80 75 octets

(k,u)=>(r=n=>n++<u+k?r(P[P.every(i=>n%i)*n]=n):P.filter(n=>P[n+k]))(1,P=[])

Exemple:

let F =
(k,u)=>(r=n=>n++<u+k?r(P[P.every(i=>n%i)*n]=n):P.filter(n=>P[n+k]))(1,P=[])

console.log(F(2, 999))

Pyth, 13 octets

f&P_TP_+ThQSe

Un programme qui prend en entrée une liste du formulaire [k, u] et imprime une liste.

Essayez-le en ligne

Comment ça fonctionne

f&P_TP_+ThQSe  Program. Input: Q
           Se  1-indexed range up to Q[1], yielding [1, 2, 3, ..., u]
f              Filter that, using variable T, by:
  P_T           T is prime
 &              and
     P_+ThQ     T+Q[0], i.e. T+k, is prime
               Implicitly print