फर्मेट प्राइम्स बनाना

Question

एक नंबर n को देखते हुए, nth Prime Fermat नंबर प्रिंट करें , जहां Fermat नंबर फॉर्म 2 ^{2 k} +1 के हैं। इस कोड को सैद्धांतिक रूप से किसी भी n (यानी इसे हार्डकोड न करें) के लिए काम करना चाहिए, हालांकि यह n> 4 के लिए समाप्त होने की उम्मीद नहीं है। (यह n = 5 के लिए 4294967297 वापस नहीं आना चाहिए , क्योंकि 4294967297 एक प्रमुख संख्या नहीं है।)

ध्यान दें कि जबकि सभी फर्मेट अभाज्य संख्या प्रपत्र 2 के हैं क्या ^{2 n} +1, नहीं प्रपत्र के सभी नंबरों को 2 ^{2 n} +1 प्रधानमंत्री हैं। इस चुनौती का लक्ष्य एन-वें प्राइम को वापस करना है ।

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

0 -> 3
1 -> 5
2 -> 17
3 -> 257
4 -> 65537

नियम

• मानक खामियों को अस्वीकार कर दिया जाता है।
• 0-इंडेक्सिंग और 1-इंडेक्सिंग दोनों स्वीकार्य हैं।
• यह कोड-गोल्फ , सबसे कम बाइट-काउंट जीत है।

संबंधित: कंस्ट्रक्टेबल n-gons

Comments

क्या मैं या कुछ जवाब चुनौती को गलत बता रहे हैं? क्या हम केवल एक प्रोग्राम नहीं लिख रहे हैं जो आउटपुट 2^(2^n) + 1, nइनपुट कहाँ है? यह आपके परीक्षण मामलों (जो हम जानते हैं कि पहले से ही प्राइम हैं, इसलिए जाँचने की कोई आवश्यकता नहीं है) और आप इस कार्यक्रम की उम्मीद नहीं करते हैं जहां n> 4 (और n = 5 पहला गैर-प्राइम) है।

— jstnthms

कार्यक्रम को सैद्धांतिक रूप से n> 4 के लिए कार्य करना चाहिए, हालांकि यह अभ्यास में कभी काम नहीं करेगा, क्योंकि हम केवल 5 फर्मेट प्राइम्स के बारे में जानते हैं।

— पोय 830

मैं वास्तव में सभी फरमैट प्राइम के लिए सैद्धांतिक रूप से काम करने के उद्देश्य को नहीं समझता हूं, क्योंकि केवल 5 ज्ञात शब्द हैं।

— श्री Xcoder

@CodyGray वृषण भ्रामक हैं, क्योंकि यह काम करता है n=1:4। सभी फर्मेट प्राइम्स फॉर्म के हैं 2^2^n+1, लेकिन इसका मतलब यह नहीं है कि फॉर्म के सभी नंबर 2^2^n+1वास्तव में प्राइम हैं। यह है के लिए मामला n=1:4है, लेकिन के लिए नहीं n=5, उदाहरण के लिए।

— JAD

मुझे लगता है कि भ्रम का कुछ हिस्सा यह है कि आप कह रहे हैं कि इनपुट है nऔर आउटपुट फॉर्म का होना चाहिए 2^(2^n)+1। यदि आप इनपुट और प्रतिपादक के लिए विभिन्न चर का उपयोग करते हैं तो कुछ भ्रम कम हो सकते हैं। यदि आप स्पष्ट रूप से यह

— बता

Answer 1

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

k=input();F=2
while k:F*=F;k-=3**(F/2)%-~F/F
print-~F

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

पेपिन के परीक्षण का उपयोग करता है ।

---

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

f=lambda k,F=4:k and f(k-3**(F/2)%-~F/F,F*F)or F**.5+1

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

Answer 2

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

ÆẸ⁺‘©ÆPµ#ṛ®

1-आधारित अनुक्रमण का उपयोग करता है।

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

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

ÆẸ⁺‘©ÆPµ#ṛ®  Main link. No argument.

        #    Read an integer n from STDIN and call the chain to the left with
             arguments k = 0, 1, 2, ... until n matches were found.
ÆẸ           Find the integer with prime exponents [k], i.e., 2**k.
  ⁺          Repeat the previous link, yielding 2**2**k.
   ‘         Increment, yielding 2**2**k+1 and...
    ©        copy the result to the register.
     ÆP      Test the result for primality.
          ®  Yield the value from the register, i.e., the n-th Fermar prime.
         ṛ   Yield the result to the right.

Comments

ओह, तो एक ṛपरिणाम को साफ करने के लिए उपयोग करता है ... TIL

— लीक नून

ओह, इसलिए एक एकल पूर्णांक के ÆẸबजाय एक का उपयोग करता है 2*... टीआईएल

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

Answer 3

पर्ल 6 ,  45  42 बाइट्स

{({1+[**] 2,2,$++}...*).grep(*.is-prime)[$_]}

कोशिश करो

{({1+2**2**$++}...*).grep(*.is-prime)[$_]}

कोशिश करो

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  (  # generate a sequence of the Fermat numbers

    {
      1 +
      2 ** 2 **
        $++            # value which increments each time this block is called
    }
    ...                # keep generating until:
    *                  # never stop

  ).grep(*.is-prime)\  # reject all of the non-primes
  [$_]                 # index into that sequence
}

Answer 4

मैथेमेटिका, 56 बाइट्स

(t=n=0;While[t<=#,If[(PrimeQ[s=2^(2^n)+1]),t++];n++];s)&

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

Answer 5

अजगर , 14 बाइट्स

e.f&P_ZsIltZQ3

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

1-अनुक्रमण का उपयोग करता है।

Answer 6

अजगर , 14 बाइट्स

Lh^2^2byfP_yTQ

ऑनलाइन कोशिश करें।

एक अन्य प्रश्न में xnor के उत्तर से मुख्य विचार "उधार"

Lh^2^2byfP_yTQ

L                    define a function with name y and variable b, which:
 h^2^2b                returns 1+2^2^b
       y             call the recently defined function with argument:
        f    Q         the first number T >= Q (the input) for which:
         P_yT            the same function with argument T returns a prime
                     and implicitly print

Answer 7

05AB1E , 8 बाइट्स

कोड:

परिणाम 1-अनुक्रमित हैं।

µN<oo>Dp

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

स्पष्टीकरण:

µ              # Run the following n succesful times..
 N             #   Push Nn
  oo           #   Compute 2 ** (2 ** n)
    >          #   Increment by one
     D         #   Duplicate
      p        #   Check if the number is prime
               # Implicit, output the duplicated number which is on the top of the stack

Answer 8

जावास्क्रिप्ट, 12 46 बाइट्स

k=>eval('for(i=n=2**2**k+1;n%--i;);1==i&&n')

अधिकांश कोड प्राइम चेक द्वारा लिया जाता है, जो यहां से है ।

Comments

ध्यान दें कि यह केवल nth Fermat नंबर नहीं, बल्कि nth प्राइम फ़र्मैट नंबर को वापस करना होगा ।

— पोइ 830

@ po8830 अब प्राइम चेक में सबसे अधिक कार्य होता है :(

— सुपरस्टॉर्मर

मुझे लगता है कि आप कह सकते हैं कि मैं = 2 के बजाय i == 1 क्योंकि यहां भी शून्य अच्छा है? यह कम होना चाहिए 2 बाइट

— DanielIndie

Answer 9

दिल्लोग एपीएल (29 वर्ण)

मुझे लगभग तय है कि इसमें सुधार किया जा सकता है।

{2=+/0=(⍳|⊢)a←1+2*2*⍵:a⋄∇⍵+1}

यह एक पुनरावर्ती फ़ंक्शन है जो 1 + 2 ^ 2 ^ rec के विभाजकों की संख्या की जांच करता है, जहां ⍵ फ़ंक्शन का सही तर्क है। यदि भाजक की संख्या 2 है, तो संख्या अभाज्य है, और वह इसे वापस कर देता है, अन्यथा, यह सही तर्क के रूप में फ़ंक्शन को right + 1 के साथ फिर से कॉल करता है।

उदाहरण

{2=+/0=(⍳|⊢)a←1+2*2*⍵:a ⋄ ∇ ⍵+1}¨⍳4
      5 17 257 65537

यहां मैं प्रत्येक ⍳4 (संख्या 1-4) पर फ़ंक्शन को कॉल करता हूं। यह बदले में हर नंबर पर लागू होता है।

Answer 10

हास्केल , 61 बाइट्स

p n=2^2^n;f=(!!)[p x+1|x<-[0..],all((>)2.gcd(p x+1))[2..p x]]

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

0-आधारित सूचकांक

व्याख्या

p n=2^2^n;                                          -- helper function 
                                                    -- that computes what it says
f=                                                  -- main function
  (!!)                                              -- partially evaluate 
                                                    -- index access operator
      [p x+1|                                       -- output x-th fermat number
             x<-[0..],                              -- try all fermat number indices
                      all                 [2..p x]  -- consider all numbers smaller F_x
                                                    -- if for all of them...
                         ((>)2                      -- 2 is larger than...
                              .gcd(p x+1))          -- the gcd of F_x 
                                                    -- and the lambda input 
                                                    -- then it is a Fermat prime!   
                                                  ]