Cho một số n, in số Fermat nguyên tố thứ n , trong đó các số Fermat có dạng 2 ^{2 k} +1. Mã này nên về mặt lý thuyết làm việc cho bất kỳ n (tức là không hardcode nó), mặc dù nó không được kỳ vọng sẽ chấm dứt đối với n> 4. (Nó nên không trở 4294967297 cho n = 5, như 4294967297 không phải là một số nguyên tố.)

Xin lưu ý rằng mặc dù tất cả các số nguyên tố Fermat đều có dạng 2 ^{2 n} +1, nhưng không phải tất cả các số có dạng 2 ^{2 n} +1 đều là số nguyên tố. Mục tiêu của thử thách này là trả lại số nguyên tố thứ n .

Các trường hợp thử nghiệm

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

Quy tắc

• Sơ hở tiêu chuẩn là không được phép.
• Cả hai chỉ mục và 1 chỉ mục đều được chấp nhận.
• Đây là môn đánh gôn , đánh số byte thấp nhất.

Liên quan: n-gons xây dựng

Python 2 , 53 byte

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

Hãy thử trực tuyến!

Sử dụng thử nghiệm Pépin .

Python 2 , 54 byte

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

Hãy thử trực tuyến!

Thạch , 13 11 byte

ÆẸ⁺‘©ÆPµ#ṛ®

Sử dụng lập chỉ mục dựa trên 1.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ÆẸ⁺‘©Æ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 byte

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

Thử nó

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

Thử nó

Mở rộng:

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

Toán học, 56 byte

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

Hãy thử trực tuyến!

Bình thường , 14 byte

e.f&P_ZsIltZQ3

Hãy thử trực tuyến!

Sử dụng 1 chỉ mục.

Bình thường , 14 byte

Lh^2^2byfP_yTQ

Hãy thử trực tuyến.

Ý chính "mượn" từ câu trả lời của xnor trong một câu hỏi khác

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 byte

Mã số:

Kết quả là 1 chỉ số.

µN<oo>Dp

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Giải trình:

µ              # 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 byte

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

Hầu hết các mã được đưa lên bởi kiểm tra chính, đó là từ đây .

APL Dyalog (29 ký tự)

Tôi gần như chắc chắn điều này có thể được cải thiện.

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

Đây là hàm đệ quy kiểm tra số lượng ước của 1 + 2 ^ 2 ^, trong đó là đối số đúng của hàm. Nếu số lượng ước là 2, số đó là số nguyên tố và nó trả về nó, nếu không, nó gọi lại hàm với ⍵ + 1 là một đối số đúng.

Thí dụ

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

Ở đây tôi gọi hàm trên mỗi ⍳4 (các số 1-4). Nó áp dụng nó cho mỗi số lần lượt.

Haskell , 61 byte

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

Hãy thử trực tuyến!

Chỉ số dựa trên 0

Giải trình

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