मैं अपने भाई के साथ 2/3 जुड़वाँ बच्चे हूँ, यानी उसी महीने के उसी दिन पैदा हुए थे लेकिन बारह साल बाद। जब मैं 5 वर्ष का था, तब वह 17 वर्ष का था, दोनों ही अपराध; युगों की अंतिम जोड़ी हम यथोचित रूप से गिन सकते हैं [71, 83] हम दोनों जीवित हैं और इस संयोग की जयंती मनाने में सक्षम हैं।

कार्य

एक कोड बनाएं जो

इनपुट के रूप में दो पूर्णांकों को लेता है: काउंटर और "ट्विन" के बीच का अंतर एक धनात्मक पूर्णांक k (अच्छी तरह से हाँ, मैं छोटा हूँ) और ऊपरी भाग एक सकारात्मक पूर्णांक u (रनटाइम विचार) के रूप में होता है।
और एक सरणी या सभी की सूची के रूप में उत्पादन देता है मैं संख्या की तुलना में कम या बराबर यू जिसके लिए दोनों मैं और मैं + K अभाज्य संख्या है। आउटपुट को सॉर्ट करने की आवश्यकता नहीं है।

परीक्षण के मामलों

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]

संपादित करें

चूंकि मैं ऊपरी बाउंड को निर्दिष्ट करने में विफल रहा, इसलिए दोनों समावेशी और अनन्य समाधान स्वागत योग्य हैं।

सं। २ संपादित करें

यह चुनौती 1 सितंबर को शुरू होने के एक सप्ताह बाद समाप्त होती है।
ऐसा लगता है कि हमारे पास एक विजेता है लेकिन टाई की लोकप्रियता के मामले में टाई-ब्रेकर है; इस मामले में "दूसरा" का भुगतान इनाम के माध्यम से किया जाएगा।

code-golf primes

— user3819867
स्रोत

सम्बंधित।

— मार्टिन एंडर

5

जेली, 8 7 बाइट्स

+ÆR©_f®

इसे ऑनलाइन आज़माएं!

व्याख्या

+          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

— PurkkaKoodari
स्रोत

बधाई हो @ Pietu1998!

— user3819867

6

ब्रेकीलॉग , 27 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सभी टेस्टकेस को सत्यापित करें।

विधेय 0 (मुख्य विधेय)

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

1 समर्पित करें (सहायक विधेय)

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

— लीक नन
स्रोत

5

05AB1E , 9 बाइट्स

कोड:

LDpÏDI+pÏ

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

4

पाइके, 10 बाइट्स

S#_PiQ+_P&

यहाँ कोशिश करो!

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

इसके अलावा 10 बाइट्स:

S#_DP.IQ-P

यहाँ कोशिश करो!

— नीला
स्रोत

एक और 10-बाइट ।

— लीक नुन्

@LeakyNum वास्तव में बहुत चालाक है!

— ब्लू

4

ऑक्टेव, 34 33 बाइट्स

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

— alephalpha
स्रोत

महान दृष्टिकोण! इसने मुझे अपने उत्तर में फ्रॉम 11 से 8 बाइट्स कम करने की अनुमति दी

— लुइस मेंडो

4

MATL , 8 बाइट्स

उनके दृष्टिकोण के लिए @alephalpha को श्रेय , जिसने मुझे 3 बाइट्स बचाने में मदद की

Zqti+Zp)

इसे ऑनलाइन आज़माएं!

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

— लुइस मेंडो
स्रोत

4

पायथन 3, 114 92 90 बाइट्स

-2 बाइट्स के लिए @ डेनिस को धन्यवाद

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}

एक फ़ंक्शन जो तर्क के माध्यम से इनपुट लेता है और एक बिना सेट सेट लौटाता है। यह ऊपरी सीमा के संबंध में अनन्य है।

यह @ xnor के उत्तर में विधि का उपयोग करता है यहाँ है प्राइम्स खोजने के लिए ।

Ideone पर इसे आज़माएं

यह काम किस प्रकार करता है

प्राइम फाइंडिंग

हम पहले एक परीक्षण मूल्य iऔर एक उत्पाद के Pरूप में 1, और lसेट युक्त के रूप में primes की एक सूची शुरू करते हैं 0। फिर, एक whileलूप जो परिमाण के लिए iसीमा के सभी मूल्यों का परीक्षण करता [1, u+k-1]है। विचार यह है कि प्रत्येक पुनरावृत्ति के अंत में गुणा Pकरके i^2, परीक्षण करते समय Pमान लेता है , यानी पूर्णांक का उत्पाद । वास्तविक प्रायोगिक परीक्षण तब गणना करके किया जाता है ; यदि यह शून्य देता है, तो इसका मतलब यह नहीं हो सकता है कि यह उत्पाद बनाने वाले मूल्यों में से कम से कम एक से विभाज्य है। अगर यह लौट आए , तो(i-1)!^2i[1, i+1]P mod iii1iप्राइम होना चाहिए क्योंकि यह उत्पाद के किसी भी मूल्य से विभाज्य नहीं है। यदि iप्रधान है, तो इसे जोड़ा जाता है l, और यदि नहीं, तो ।0जोड़ा गया है। उत्पाद का स्क्वेरिंग 4प्राइम के रूप में गलत पहचान को रोकता है , और यहां उपयोगी है क्योंकि यह गारंटी देता है कि केवल 0या 1वापस लौटा दिया जाएगा, जिससे वैल्यू के विकल्प को केवल परिणाम द्वारा गुणा करके बनाया जा सकता है।i

'जुड़वा' की पहचान

अब हम एक फेरर सेट बनाते हैं, जिसमें l-kतत्व-वार सभी तत्व होते हैं। इस सेट का प्रतिच्छेदन और lफिर इसका उपयोग करते हुए पाया जाता है &, जो एक सेट को छोड़ देता है जिसमें दोनों तत्वों के लिए सामान्य तत्व होते हैं। एक संख्या iकेवल दोनों सेटों में होती है यदि दोनों अभाज्य हैं iऔर इसका i+kअर्थ है कि यह वांछित आउटपुट को छोड़ देता है। हालांकि, अगर kप्राइम है , तो 0दोनों सेट में मौजूद रहेंगे, इसका मतलब है कि लौटने से पहले इसे हटा दिया जाना चाहिए।

— TheBikingViking
स्रोत

2

k,u=input();i=P=1;l={0};exec'l|={P%i*i};P*=i*i;i+=1;'*(u+k);print{i-k for i in l}&lपायथन में 83 बाइट्स के लिए काम करता है। 3 में भी, एक सेट का निर्माण इस तरह से कुछ बाइट्स को बचाना चाहिए।

— डेनिस

@ डेनिस धन्यवाद - यह पायथन 3 में कुछ बाइट्स को बचाता है। हालांकि, मुझे 0अंतिम सेट से हटाना पड़ा, क्योंकि अगर kयह प्रमुख है, तो यह गलती से वापस आ जाता है ।

— बाइकिंग लंबी पैदल यात्रा

3

आर, 98 बाइट्स

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}

अधूरा:

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

— फ़्रेडरिक
स्रोत

3

सीजेएम, 17 बाइट्स

या तो एक पूर्ण कार्यक्रम के रूप में:

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

इसे ऑनलाइन आज़माएं!

या अनाम ब्लॉक के रूप में:

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

इसे ऑनलाइन आज़माएं!

— मार्टिन एंडर
स्रोत

2

जावा 7, 185 175 बाइट्स

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

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

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

आउटपुट:

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

— केविन क्रूज़सेन
स्रोत

2

PARI / GP, 39 बाइट्स

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

— alephalpha
स्रोत

2

गणितज्ञ, 43 बाइट्स

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

ऊपरी सीमा से कम या उसके बराबर के सभी अपराध उत्पन्न करें। परिणाम में उम्र का अंतर जोड़ें। उनमें से प्राइम नंबर चुनें। परिणाम के लिए उम्र के अंतर को घटाएं।

2

स्विफ्ट, 142 बाइट्स

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

— jrich
स्रोत

2

पर्ल 6 , 39 37 बाइट्स

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

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

स्पष्टीकरण:

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

}

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

एसआईओएस , 205 बाइट्स

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

इसे ऑनलाइन आज़माएं!

विल्सन के प्रमेय द्वारा परीक्षण ।

— लीक नन
स्रोत

1

दरअसल , 12 बाइट्स

इनपुट uतो है k। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

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

— Sherlock9
स्रोत

1

आर, 104 बाइट्स

पोस्ट किए गए अन्य आर समाधान के विपरीत, यह एक स्टड से इनपुट लेता है।

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

— rturnbull
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 90 83 80 75 बाइट्स

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

उदाहरण:

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

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

पायथ, 13 बाइट्स

f&P_TP_+ThQSe

एक प्रोग्राम जो फॉर्म की एक सूची का इनपुट लेता है और एक सूची [k, u]प्रिंट करता है।

इसे ऑनलाइन आज़माएं

यह काम किस प्रकार करता है

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

— TheBikingViking
स्रोत

चर प्रधान "जुड़वां"

कार्य

परीक्षण के मामलों

संपादित करें

सं। २ संपादित करें

जेली, 8 7 बाइट्स

व्याख्या

ब्रेकीलॉग , 27 23 बाइट्स

विधेय 0 (मुख्य विधेय)

1 समर्पित करें (सहायक विधेय)

05AB1E , 9 बाइट्स

पाइके, 10 बाइट्स

ऑक्टेव, 34 33 बाइट्स

MATL , 8 बाइट्स

पायथन 3, 114 92 90 बाइट्स

आर, 98 बाइट्स

सीजेएम, 17 बाइट्स

जावा 7, 185 175 बाइट्स

PARI / GP, 39 बाइट्स

गणितज्ञ, 43 बाइट्स

स्विफ्ट, 142 बाइट्स

पर्ल 6 , 39 37 बाइट्स

स्पष्टीकरण:

एसआईओएस , 205 बाइट्स

दरअसल , 12 बाइट्स

आर, 104 बाइट्स

जावास्क्रिप्ट (ईएस 6), 90 83 80 75 बाइट्स

पायथ, 13 बाइट्स