กำหนดตัวเลข n ให้พิมพ์หมายเลขเฉพาะแฟร์มาต์หมายเลขที่หมายเลขแฟร์มาต์เป็นรูปแบบ 2 ^{2 k} +1 รหัสนี้ควรใช้งานได้จริงในทางทฤษฎีสำหรับ n ใด ๆ (เช่นอย่าฮาร์ดโค้ด) แม้ว่าจะไม่คาดว่าจะยุติการทำงานสำหรับ n> 4 (มันไม่ควรส่งคืน 4294967297 สำหรับ n = 5 เนื่องจาก 4294967297 ไม่ใช่หมายเลขเฉพาะ)

โปรดทราบว่าในขณะที่จำนวนแฟร์มาต์ทั้งหมดอยู่ในรูปแบบ 2 ^{2 n} +1 แต่ตัวเลขทั้งหมดของรูปแบบ 2 ^{2 n} +1 นั้นเป็นจำนวนเฉพาะ เป้าหมายของความท้าทายนี้คือการคืนค่านายกที่ n

กรณีทดสอบ

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

กฎระเบียบ

• ช่องโหว่มาตรฐานไม่ได้รับอนุญาต
• 0-indexing และ 1-indexing นั้นเป็นที่ยอมรับได้
• นี่คือรหัส - กอล์ฟชนะน้อยที่สุดนับไบต์

ที่เกี่ยวข้อง: Constructible n-gons

Python 2 , 53 ไบต์

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

ลองออนไลน์!

ใช้ทดสอบPépinของ

Python 2 , 54 ไบต์

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

ลองออนไลน์!

เยลลี่ , 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.

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

Mathematica, 56 ไบต์

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

ลองออนไลน์!

Pyth , 14 ไบต์

e.f&P_ZsIltZQ3

ลองออนไลน์!

ใช้การจัดทำดัชนี 1 รายการ

Pyth , 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

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

Javascript, 12 46 ไบต์

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

ส่วนใหญ่ของรหัสที่ถูกนำขึ้นมาจากการตรวจสอบที่สำคัญซึ่งอยู่ห่างจากที่นี่

Dyalog APL (29 ตัวอักษร)

ฉันเกือบจะแน่ใจว่าสิ่งนี้สามารถปรับปรุงได้

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

นี่คือฟังก์ชันเรียกซ้ำซึ่งตรวจสอบจำนวนตัวหารของ 1 + 2 ^ 2 ^ ⍵โดยที่⍵เป็นอาร์กิวเมนต์ที่ถูกต้องของฟังก์ชัน หากจำนวนตัวหารคือ 2 จำนวนนั้นจะเป็นจำนวนเฉพาะและจะส่งคืนมิฉะนั้นจะเรียกใช้ฟังก์ชันอีกครั้งโดยใช้⍵ + 1 เป็นอาร์กิวเมนต์ที่ถูกต้อง

ตัวอย่าง

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

ที่นี่ฉันเรียกฟังก์ชั่นในแต่ละ⍳4 (หมายเลข 1-4) มันใช้กับทุกหมายเลขในทางกลับกัน

Haskell , 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!   
                                                  ]