Les nombres de Fermat sont des entiers positifs qui peuvent être exprimés comme 2 ^{2 x} +1 avec un entier x.

Définissons maintenant un attribut d'un nombre appelé "Fermat-ness":

• La fermeté du nombre est inférieure de un à la longueur de la chaîne de puissances de deux, à partir de la base, avec des puissances de deux étendues de manière à maximiser la fermeté.
• Un nombre qui n'est pas un nombre de Fermat a la fermeté de zéro.

Donc, 17 (= 2 ^{2 2 2 0} +1) a trois fermetés.

Défi

Étant donné un entier positif non nul en entrée, affichez la fermeté du nombre.

Règles

• Vous pouvez prendre l'entrée en binaire, décimal, hexadécimal, comme un bignum, ou dans le format qui vous permet de jouer au mieux
• Votre solution doit être en mesure de traiter des nombres dont la longueur en bits est supérieure à 64, quelle que soit la représentation que vous utilisez.
• Puissances entières non négatives uniquement.
• Les failles standard sont bien entendu interdites.
• C'est le code-golf , donc la réponse la plus courte l'emporte.

Cas de test

Ce sont au format input->output. L'entrée est en hexadécimal pour économiser de l'espace.

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

La même chose en décimal:

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

Merci à geokavel pour son apport inestimable dans le bac à sable.

Gelée , 15 14 octets

1 octet merci à Jonathan Allan.

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

Essayez-le en ligne!

Python 2 , 103 81 octets

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

Essayez-le en ligne!

J'ai réalisé que ne pas être stupide aiderait à réduire mon nombre d'octets, alors je l'ai fait. Exponentiation également par opposition aux logarithmes.

RProgN 2 , 75 octets

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

Essayez-le en ligne!

Ce n'est que 70 octets si vous n'ajoutez pas le «»'¤=qui assigne le calcul de Fermatness au¤ caractère. Si vous faites cela, vous devrez mettre le numéro dans la section En-tête de TIO plutôt que dans le pied de page tel qu'il est maintenant.

Cela utilise effectivement la même logique que ma réponse Python, donc si vous ne vous souciez pas de la façon dont RProgN 2 fonctionne, regardez-la pour une explication de ce qui se passe. Autrement

Répartition du code:

«\`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

Malheureusement, la fonction logarithmique Šet la fonction d'exponentiation normale ^manquent de précision pour le faire de manière native, j'ai donc dû redéfinir le fonctionnement de l'exponentiation car la multiplication est beaucoup plus précise. Sans cette redéfinition, cette réponse serait 23 octets plus courte.

Perl 6 , 62 octets

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

Essayez-le en ligne!