कुछ लोनली प्राइम्स

Question

मुझे पता है, मुझे पता है, अभी तक एक और primes चुनौती ...

सम्बंधित

एक अकेला (या पृथक) प्रधानमंत्री अभाज्य संख्या है pऐसा है कि p-2, p+2, p-4, p+4... p-2k, p+2kकुछ के लिए kसभी समग्र कर रहे हैं। हम इस तरह के प्राइम को एक kथ-टाइम-पृथक प्राइम कहते हैं।

उदाहरण के लिए, 5 वीं-बार-पृथक प्राइम है 211, क्योंकि सभी 201, 203, 205, 207, 209, 213, 215, 217, 219, 221मिश्रित हैं। ( p-2*5=201, p-2*4=203आदि)

चुनौती

दो इनपुट पूर्णांकों को देखते हुए, n > 3और k > 0, सबसे छोटे kवें-टाइम-प्राइम-प्राइम को आउटपुट करता है जो कि सख्ती से बड़ा है n।

उदाहरण के लिए, k = 5किसी भी nरेंज में 4 ... 210, आउटपुट होना चाहिए 211, क्योंकि यह सबसे छोटा 5 वीं-बार-प्राइम प्राइम सख्ती से इनपुट से बड़ा है n।

उदाहरण

n=55 k=1
67

n=500 k=1
503

n=2100 k=3
2153

n=2153 k=3
2161

n=14000 k=7
14107

n=14000 k=8
14107

नियम

• यदि लागू हो, तो आप मान सकते हैं कि इनपुट / आउटपुट आपकी भाषा के देशी पूर्णांक प्रकार में फिट होगा।
• इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

क्या 3 गुना-अलग-थलग प्रधान भी 2-बार-पृथक प्रधान है?

— एर्ग आउटफोलर

@EriktheOutgolfer पिछले दो परीक्षण मामले वास्तव में इसकी पुष्टि करते हैं।

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

@ केविनक्रूजसेन टेस्ट मामले चुनौती विनिर्देश का हिस्सा नहीं हैं।

— एर्ग आउटफॉलर

@EriktheOutgolfer हाँ, एक kगु-बार-पृथक भी है, परिभाषा के अनुसार, k-1ध, k-2ध, आदि

— AdmBorkBork

@AdmBorkBork बस जाँच करना चाहता था, धन्यवाद।

— आउटगोल्फर

Answer 1

जेली , 17 13 बाइट्स

_æR+⁼ḟ
‘ç1#Ḥ}

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

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

‘ç1#Ḥ}  Main link. Left argument: n. Right argument: k

‘       Increment; yield n+1.
    Ḥ}  Unhalve right; yield 2k.
 ç1#    Call the helper link with arguments m = n+1, n+2, ... and k until 1 one
        them returns a truthy value. Return the matching [m].


_æR+⁼ḟ  Helper link. Left argument: m. Right argument: k

_       Subtract; yield m-2k.
   +    Add; yield m+2k.
 æR     Prime range; yield the array of primes in [m-2k, ..., m+2k].
     ḟ  Filterfalse; yield the elements of [m] that do not occur in [k], i.e., [m]
        if m ≠ 2k and [] otherwise.
        The result to the left will be non-empty when m = 2k, as there always is
        a prime in [0, ..., 2m], since m > n > 3.
    ⁼   Test the results to both sides for equality.
        This yields 1 iff m is the only prime in [m-2k, ..., m+2k].

Answer 2

भूसी , 13 बाइट्स

ḟ§=;ofṗM+ṡD⁰→

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

व्याख्या

बहुत सीधा।

ḟ§=;ofṗM+ṡD⁰→  Inputs are k and n.
            →  Increment n
ḟ              and find the first number m >= n+1 such that:
         ṡD⁰    Take symmetric range [-2k,..,2k].
       M+       Add m to each.
    ofṗ         Keep those that are prime.
 §=             Check equality with
   ;            the singleton [m].

Answer 3

जावा 8, 144 143 बाइट्स

(n,k)->{for(k*=2;;)if(p(++n)>1){int i=-k;for(;i<=k&p(n+i)<2|i==0;i+=2);if(i>k)return n;}}int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

स्पष्टीकरण:

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

(n,k)->{                      // Method with two integer parameters and integer return-type
  for(k*=2;                   //  Multiply `k` by 2
      ;)                      //  Loop indefinitely
    if(p(++n)>1){             //   Increase `n` by 1 before every iteration with `++n`
                              //   And if it's a prime:
      int i=-k;for(;i<=k      //    Loop `i` from `-k` to `k` (inclusive)
        &p(n+i)<2|i==0;       //    As long as `n+i` is not a prime (skipping `n` itself)
        i+=2);                //    And iterate in steps of 2 instead of 1
      if(i>k)                 //    If we've reached the end of the loop:
        return n;}}           //     We've found our result, so return it

// Separated method to check if `n` is a prime
// `n` is a prime if it remained unchanged, and not when it became 0 or 1
int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

Answer 4

पायथन 2 , 105 104 बाइट्स

^{-1 बाइट ओवस के लिए धन्यवाद}

n,k=input()
n+=1
while sum(all(x%i for i in range(2,x))^(x==n)for x in range(n-k*2,2*k-~n)):n+=1
print n

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

Answer 5

स्टैक्स , 14 बाइट्स

åΣ▀ë F▬&■º↔╔^∞

इसे चलाएं और डीबग करें

यह असिसी प्रतिनिधित्व है।

w^x:r{Hn+|p_!=m0#

w                   while; run the rest of the program until a falsy value remains
 ^                  increment candidate value.
  x:r               [-x, ..., -1, 0, 1, ... x] where x is the first input
     {        m     map using block, using k from -x to x
      Hn+           double and add to candidate value - this is "p+2k"
         |p         is it prime? produces 0 or 1
           _!       k is zero?
             =      two values are equal; always true for a passing candidate
               0#   any falses left after mapping? if so, continue running

Answer 6

जावास्क्रिप्ट (Node.js) , 94 92 89 बाइट्स

f=(n,k)=>(Q=y=>y<-k||(P=(a,b=2)=>a>b?a%b&&P(a,b+1):1)(n+2*y)^!!y&&Q(--y))(k,++n)?n:f(n,k)

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

रहस्यमय ढंग से, आगे के गोल्फ स्टैक ओवरफ्लो खत्म हो जाते हैं। केवल यह 14000 के आकार में काम करता है।

अंत में एक गोल्फ जो 14000 पर स्टैक ओवरफ्लो को समाप्त नहीं करेगा।

व्याख्या

f=(n,k)=>            // Two inputs
 (Q=y=>              // Function checking whether all numbers in 
                     // [n-2*k, n+2*k] except n are all composite
  y<-k               // The counter runs from k to -k
                     // If none breaks the rule, return true
  ||(P=(a,b=2)=>     // Function checking primality
   a>b?              // Check if a>b
   a%b&&P(a,b+1)     // If a>b and a%b==0 return false, else proceed
   :1                // If a<=b return 1 (prime)
  )(n+2*y)^!!y       // If n+2*y is prime, then y must be 0
                     // If n+2*y is not prime, then y must be non-zero
                     // If none of the conditions are met, return false
  &&Q(--y)           // Else proceed to the next counter
 )
 (k,++n)?            // Add 1 to n first, then start the check
 n                   // If conditions are met, return n
 :f(n,k)             // Else proceed to the next n.

Answer 7

सी (जीसीसी) , 113 बाइट्स

P(n,d,b){for(b=d=n>1;++d<n;)b=b&&n%d;n=b;}f(n,k,i,f){for(f=n;f;)for(f=i=!P(++n);i++<k;f|=P(n+i+i)|P(n-i-i));f=n;}

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

Answer 8

रूबी + -rprime, 73 71 61 57 बाइट्स

->n,k{n+=1;(-k..k).all?{|i|(i*2+n).prime?^(i!=0)}?n:redo}

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

सीखने में अच्छा लगता है! मैं उन तकनीकों Integer#[]और redoतकनीकों का उपयोग कर रहा हूं जो मैंने यहां पीपीसीजी पर सीखीं। मजेदार तकनीकों के मातम में खो रहे हैं ...

-1 बाइट: कम से कम महत्वपूर्ण बिट प्राप्त करने के n%2बजाय उपयोग करें n[0]। धन्यवाद, असोन तुहिद !

-1 बाइट: बूलियन एक्सप्रेशन के बजाय टर्नेरी ऑपरेटर का उपयोग करें। धन्यवाद, असोन तुहिद !

-10 बाइट्स: .prime?दो बार टाइपिंग से बचने के लिए एक्सओआर ऑपरेटर का उपयोग करें ... यह सिर्फ उतना ही है जितना कि तुहिद का जवाब है कि मेरा नाम :)

-4 बाइट्स: मानों की जांच करने में भी कोई बुराई नहीं है n। असोन तुहिद नॉन-स्टॉप है।

Ungolfed:

->n,k{
  n += 1;                   # Increment n
  (-k..k).all?{|i|          # In the set [n-2*k, n+2*k], is every number
    (i*2+n).prime? ^ (i!=0) #    EITHER prime XOR different from n itself?
  } ? n                     # If yes, return the current value of n
  : redo                    # Otherwise, restart the block
}

Comments

झंडे को अब बाइट की गिनती में शामिल करने की आवश्यकता नहीं है। ध्वज के प्रत्येक अलग आह्वान को इसके बजाय एक अलग भाषा माना जाता है । तो यह उत्तर रूबी + -rprime, 73 बाइट्स

— मिस्टर एक्सकोडर

आह प्यारी! मुझे मेटा, @ Mr.Xcoder पर अद्यतित रखने के लिए धन्यवाद।

— बेंज़ 2240

71 बाइट्स । n%2से भी कम है n[0]इस मामले में और ?...:की तुलना में कम हो सकता है&&...||

— Asone Tuhid

-10 बाइट्स :)

— असोन तुहिद

यह छोटा है लेकिन यह पता चला है "n%2+ " बेकार था

— Asone Tuhid

Answer 9

परी / जीपी , 55 बाइट्स

f(n,k)=until(isprime(n++)&&#primes([n-2*k,n+2*k])<2,);n

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

Answer 10

पर्ल 6 , 63 बाइट्स

{$^k;first {[grep *.is-prime,$_-2*$k..$_+2*$k]eqv[$_]},$^a^..*}

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