Dato un numero n, stampa l'ennesimo numero primo di Fermat, dove i numeri di Fermat sono nel formato 2 ^{2 ^k} +1. Questo codice dovrebbe in teoria per qualsiasi n (cioè non hardcode esso), anche se non si prevede di sospendere per n> 4. (Dovrebbe non tornare 4.294.967,297 mila per n = 5, come 4.294.967,297 mila non è un numero primo.)

Si noti che mentre tutti i numeri primi Fermat sono nella forma 2 ^{2 ⁿ} +1, non tutti i numeri della forma 2 ^{2 ⁿ} +1 sono primi. L'obiettivo di questa sfida è restituire l'ennesimo numero primo.

Casi test

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

Regole

Le scappatoie standard non sono ammesse.
0-indicizzazione e 1-indicizzazione sono entrambi accettabili.
Questo è code-golf , vince il conteggio dei byte più basso.

Correlati: n-gons costruibili

code-golf primes

— poi830
fonte

1

Sono o alcune delle risposte fraintendono la sfida? Non stiamo semplicemente scrivendo un programma che emette 2^(2^n) + 1, dov'è nl'input? Ciò si allinea ai casi di test (che sappiamo essere già primi, quindi non è necessario verificarli). E non ti aspetti che il programma funzioni dove n> 4 (e n = 5 è il primo non primo).

— jstnthms,

Il programma dovrebbe teoricamente funzionare per n> 4, anche se in pratica non funzionerà mai, dato che conosciamo solo 5 numeri primi di Fermat.

— poi830,

Non capisco davvero lo scopo di lavorare teoricamente per tutti i numeri primi di Fermat, dal momento che ci sono solo 5 termini noti.

— Mr. Xcoder,

2

@CodyGray I test sono fuorvianti, perché funziona per n=1:4. Tutti i numeri primi fermati sono della forma 2^2^n+1, ma ciò non significa che tutti i numeri della forma 2^2^n+1siano in realtà primi. Questo è il caso n=1:4, ma non n=5per esempio.

— JAD,

3

Penso che una parte della confusione sia che stai dicendo che l'input è ne l'output deve essere della forma 2^(2^n)+1. Se si utilizzano variabili diverse per l'input e l'esponente, si potrebbe ridurre la confusione. Potrebbe anche essere utile se dichiari esplicitamente che "n = 5 non deve essere emesso in tempo ragionevole, ma non deve produrre 4294967297"

— Kamil Drakari,

6

Python 2 , 53 byte

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

Provalo online!

Usa il test di 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

Provalo online!

— XNOR
fonte

3

Gelatina , 13 11 byte

ÆẸ⁺‘©ÆPµ#ṛ®

Utilizza l'indicizzazione basata su 1.

Provalo online!

Come funziona

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

— Dennis
fonte

Oh, quindi uno usa ṛper cancellare il risultato ... TIL

— Leaky Nun,

Oh, quindi uno usa ÆẸinvece che 2*per un singolo numero intero ... TIL

— Erik the Outgolfer

2

Perl 6 , 45 42 byte

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

Provalo

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

Provalo

Allargato:

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

— Brad Gilbert b2gills
fonte

1

Mathematica, 56 byte

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

Provalo online!

— J42161217
fonte

0

Pyth , 14 byte

e.f&P_ZsIltZQ3

Provalo online!

Utilizza 1-indicizzazione.

— notjagan
fonte

0

Pyth , 14 byte

Lh^2^2byfP_yTQ

Prova online.

Idea principale "presa in prestito" dalla risposta di xnor in un'altra domanda

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

— Alleks
fonte

0

05AB1E , 8 byte

Codice:

I risultati sono 1 indicizzati.

µN<oo>Dp

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione:

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

— Adnan
fonte

0

Javascript, 12 46 byte

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

Gran parte del codice è ripreso dal primo controllo, che è da qui .

— SuperStormer
fonte

Si noti che deve restituire l'ennesimo numero Fermat primo , non solo l'ennesimo numero Fermat.

— poi830,

@ poi830 ora il controllo primo occupa gran parte della funzione :(

— SuperStormer

penso che si possa dire che <2 invece di i == 1 perché zero va bene anche qui? che dovrebbe ridursi di 2 byte

— DanielIndie

0

Dyalog APL (29 personaggi)

Sono quasi certo che questo possa essere migliorato.

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

Questa è una funzione ricorsiva che controlla il numero di divisori di 1 + 2 ^ 2 ^ ⍵, dove ⍵ è l'argomento corretto della funzione. Se il numero di divisori è 2, il numero è primo e lo restituisce, altrimenti chiama di nuovo la funzione con ⍵ + 1 come argomento corretto.

Esempio

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

Qui chiamo la funzione su ciascuno di ⍳4 (i numeri 1-4). Lo applica a tutti i numeri a turno.

— James Heslip
fonte

0

Haskell , 61 byte

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

Provalo online!

Indice basato su 0

Spiegazione

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

— SEJPM
fonte

Generazione di numeri primi Fermat

Casi test

Regole

Python 2 , 53 byte

Gelatina , 13 11 byte

Come funziona

Perl 6 , 45 42 byte

Allargato:

Mathematica, 56 byte

Pyth , 14 byte

Pyth , 14 byte

05AB1E , 8 byte

Codice:

Spiegazione:

Javascript, 12 46 byte

Dyalog APL (29 personaggi)

Esempio

Haskell , 61 byte