Sono 2/3 gemelli con mio fratello, cioè nato lo stesso giorno dello stesso mese ma dodici anni dopo. Quando avevo 5 anni, aveva 17 anni, entrambi primi; l'ultima coppia di età su cui possiamo ragionevolmente contare è [71, 83] con entrambi che siamo vivi e in grado di celebrare questo giubileo casuale.

Compito

Crea un codice che

• accetta due numeri interi come input: la differenza tra il contatore e il "gemello" come numero intero positivo k (bene sì, sono il più giovane) e il limite superiore come numero intero positivo u (considerazione di runtime)

• e fornisce un output come un array o un elenco di tutti i numeri i inferiori o uguali a u per i quali sia i che i + k sono numeri primi. Non è necessario ordinare l'output.

Casi 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]

modificare

Poiché non sono riuscito a specificare il limite superiore, sono benvenute soluzioni inclusive ed esclusive.

Modifica n. 2

La sfida termina il 1 settembre, una settimana dall'inizio.
Sembra che abbiamo un vincitore, ma in caso di pareggio la popolarità è il pareggio; in questo caso il "secondo" sarà compensato tramite ricompensa.

Gelatina, 8 7 byte

+ÆR©_f®

Provalo online!

Spiegazione

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

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

Provalo online!

Verifica tutti i test.

Predicato 0 (predicato principale)

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

Predicato 1 (predicato ausiliario)

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 byte

Codice:

LDpÏDI+pÏ

Utilizza la codifica CP-1252 . Provalo online! .

Pyke, 10 byte

S#_PiQ+_P&

Provalo qui!

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

Anche 10 byte:

S#_DP.IQ-P

Provalo qui!

Ottava, 34 33 byte

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

MATL , 8 byte

Ringraziamo @alephalpha per il suo approccio , che mi ha aiutato a salvare 3 byte

Zqti+Zp)

Provalo online!

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 byte

Grazie a @Dennis per -2 byte

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}

Una funzione che accetta input tramite argomento e restituisce un set non ordinato. Questo è esclusivo rispetto al limite superiore.

Questo utilizza il metodo nella risposta di @ xnor qui per trovare i numeri primi.

Provalo su Ideone

Come funziona

Prime scoperte

Inizializziamo prima un valore di test ie un prodotto Pas 1e un elenco di numeri primi lcome l'insieme contenente 0. Quindi, viene eseguito un whileciclo che verifica tutti i valori inell'intervallo [1, u+k-1]per primalità. L'idea è che moltiplicando Pper i^2alla fine di ogni iterazione, Passume il valore (i-1)!^2durante il test i, ovvero il prodotto degli interi al [1, i+1]quadrato. Il test di primalità effettiva viene quindi eseguito calcolando P mod i; se questo restituisce zero, inon può essere primo in quanto implica che iè divisibile per almeno uno dei valori che compongono il prodotto. Se questo ritorna 1, alloraideve essere primo poiché non è divisibile per nessuno dei valori nel prodotto. Se iè primo, viene aggiunto le, in caso contrario, 0viene aggiunto. La quadratura del prodotto impedisce la falsa identificazione di 4come primo, ed è utile qui poiché garantisce che solo 0o 1verrà restituito, consentendo di scegliere il valore da aggiungere semplicemente moltiplicando il risultato per i.

Identificazione di numeri primi "gemellati"

Ora creiamo un set di furter, contenente tutti gli elementi di l-k, elemento-saggio. L'intersezione di questo set lviene quindi trovata usando &, che lascia un set contenente solo gli elementi comuni a entrambi i set. Un numero iè solo in entrambi i set se entrambi ie i+ksono primi, il che significa che ciò lascia l'output desiderato. Tuttavia, se kè primo, 0sarà presente in entrambi i set, il che significa che questo deve essere rimosso prima di tornare.

R, 98 byte

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}

Ungolfed:

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 byte

O come programma completo:

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

Provalo online!

O come blocco senza nome:

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

Provalo online!

Java 7, 185 175 byte

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

Codice non testato e test:

Provalo qui.

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

Produzione:

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

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

Mathematica, 43 byte

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

Genera tutti i numeri primi inferiori o uguali al limite superiore. Aggiungi la differenza di età al risultato. Seleziona numeri primi tra loro. Sottrarre la differenza di età al risultato.

Rapido, 142 byte

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 byte

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

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

Spiegazione:

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

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

Provalo online!

Test di primalità del teorema di Wilson .

In realtà , 12 byte

L'input è uquindi k. Suggerimenti di golf benvenuti. Provalo online!

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

A differenza dell'altra soluzione R pubblicata, questa prende input dallo 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," ")})

Ungolfed:

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 byte

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

Esempio:

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 byte

f&P_TP_+ThQSe

Un programma che accetta l'input di un elenco del modulo [k, u]e stampa un elenco.

Provalo online

Come funziona

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