I numeri fermat sono numeri interi positivi che possono essere espressi come 2 ^{2 x} +1 con un numero intero x.

Definiamo ora un attributo di un numero chiamato "Fermat-ness":

• Il fermateness del numero è uno in meno della lunghezza della catena di poteri di due, a partire dalla base, con poteri di due espansi in modo da massimizzare il fermateness.
• Un numero che non è un numero Fermat ha Fermat-ness pari a zero.

Quindi, 17 (= 2 ^{2 2 2 0} +1) ha Fermat-ness tre.

Sfida

Dato un intero diverso da zero positivo come input, emette la Fermat-ness del numero.

Regole

• Puoi prendere l'input in binario, decimale, esadecimale, come un bignum, o qualunque formato ti consenta di giocare a golf
• La soluzione deve essere in grado di elaborare numeri con lunghezze di bit superiori a 64, indipendentemente dalla rappresentazione utilizzata.
• Poteri interi non negativi.
• Le scappatoie standard sono ovviamente vietate.
• Questo è code-golf , quindi vince la risposta più breve.

Casi test

Questi sono in formato input->output. L'input è in formato esadecimale per risparmiare spazio.

10000000000000000000000000000000000000000000000000000000000000001 -> 2
1000000000000BC00000000000000000000000000000000001000000000000001 ->0
1234567890ABCDEF -> 0
100000000000000000000000000000001 -> 1
5 -> 2
11 -> 3
10001 -> 4
101 -> 1

Lo stesso in decimale:

115792089237316195423570985008687907853269984665640564039457584007913129639937 -> 2
115792089237316497527923305698859709742143344804209838213621568094470773145601 -> 0
1311768467294899695 -> 0
340282366920938463463374607431768211457 -> 1
5 ->2
17 -> 3
65537 -> 4
257 -> 1

Grazie a geokavel per l'inestimabile input nella sandbox.

Gelatina , 15 14 byte

1 byte grazie a Jonathan Allan.

’µBḊ⁸LṀ?µÐĿḊḊL

Provalo online!

Python 2 , 103 81 byte

n=input()-1
i=l=0
while 2**2**i<=n:
 if n==2**2**i:n=2**i;i=-1;l+=1
 i+=1
print l

Provalo online!

Mi sono reso conto che non essere stupido mi avrebbe aiutato a ridurre il numero di byte, quindi l'ho fatto. Anche esponenziazione rispetto ai logaritmi.

RProgN 2 , 75 byte

«\`n=1\]{1-\n*\]}:[»`^=«1-`n=001{]2\^2\^ne{2\^`n=1+0}{1+}?]2\^2\^n>¬}:[»`¤=

Provalo online!

Sono solo 70 byte se non aggiungi il carattere «»'¤=che assegna il calcolo Fermatness al ¤personaggio. Se lo fai, dovrai inserire il numero nella sezione Intestazione di TIO anziché nel Piè di pagina come è ora.

Questo utilizza effettivamente la stessa logica della mia risposta Python, quindi se non ti interessa come funziona RProgN 2, guarda quello per una spiegazione di ciò che sta succedendo. Altrimenti

Analisi del codice:

«\`n=1\]{1-\n*\]}:[»`^=
«                  »`^=`                            # Create a local function and assign it to the ^ character (x y ^ is x to the power of y)
 \`n=                                               # Swap the top two values of the stack and assign the new top to the variable n
     1\]                                            # Push a 1 (our starting point for x to the y), swap with the y value, then duplicate y
        {       }:                                  # Start a while loop that pops the top stack value and loops if it is truthy
         1-                                         # Subtract 1 from y to keep a tally of how many multiplications we've done
           \n*                                      # Swap the counter with our current value and multiply it by n
              \]                                    # Swap this new value with the current value of y, and duplicate it to be used as the truthy value for the loop

«1-`n=001{]2\^2\^ne{2\^`n=1+0}{1+}?]2\^2\^n>¬}:[»`¤=# The main Fermatness function (x ¤ to get the Fermatness of x)
«                                               »`¤=# Create another local function for this calculation
 1-`n=                                              # Decrement the input by 1 and assign it to n
      001                                           # Push a counter for Fermatness, a counter for calculating 2^2^i, and an initial truthy value
         {                                   }:     # Start a while loop for calculating the Fermatness
          ]2\^2\^ne                                 # Duplicate i, calculate 2^2^i, and compare it to n
                   {         }{  }?                 # Start an if statement based on the equality of 2^2^i and n
                    2\^`n=                          # n==2^2^i, so set n to 2^i (same as saying n=log_2(n))
                          1+0                       # Increment the Fermatness counter and reset i
                               1+                   # n!=2^2^i, so just increment i
                                   ]2\^2\^n>¬       # Duplicate the counter and check if 2^2^i<=n, if true the loop continues, else it exits
                                               [    # Pop i from the stack, leaving us with just the Fermatness counter

Sfortunatamente la funzione log Še la normale funzione esponenziale ^mancano della precisione per farlo in modo nativo, quindi ho dovuto ridefinire il modo in cui l'esponenziazione ha funzionato poiché la moltiplicazione porta molta più precisione. Senza quella ridefinizione, questa risposta sarebbe più corta di 23 byte.

Perl 6 , 62 byte

{my@a=first :kv,*>=0,(^∞).map(2**2** *+1-$_);++@a[0]*!@a[1]}

Provalo online!