Un numéro Proth , nommé d'après François Proth, est un numéro qui peut être exprimé par

N = k * 2^n + 1

Où kest un entier positif impair et nest un entier positif tel que 2^n > k. Utilisons un exemple plus concret. Prenez 3. 3 est un numéro de Proth, car il peut être écrit comme

(1 * 2^1) + 1

et 2^1 > 1est satisfait. 5 Est également un numéro de Proth, car il peut être écrit comme

(1 * 2^2) + 1

et 2^2 > 1est satisfait. Cependant, 7 n’est pas un numéro Proth car le seul moyen de l’écrire sous la forme N = k * 2^n + 1est

(3 * 2^1) + 1

et 2^1 > 3n'est pas satisfait.

Votre défi est assez simple: vous devez écrire un programme ou une fonction qui, à partir d’un entier positif, détermine s’il s’agit d’un nombre Proth ou non. Vous pouvez prendre des entrées dans n’importe quel format raisonnable, et devez indiquer une valeur de vérité s’il s’agit d’un nombre de Proth et une valeur de faux si ce n’est pas le cas. Si votre langue possède des fonctions de "détection de numéro de proth", vous pouvez les utiliser.

Test IO

Voici les 46 premiers numéros de Proth allant jusqu'à 1000. ( A080075 )

3, 5, 9, 13, 17, 25, 33, 41, 49, 57, 65, 81, 97, 113, 129, 145, 161, 177, 193, 209, 225, 241, 257, 289, 321, 353, 385, 417, 449, 481, 513, 545, 577, 609, 641, 673, 705, 737, 769, 801, 833, 865, 897, 929, 961, 993

Toute autre entrée valide doit donner une valeur de fausseté.

Comme d'habitude, c'est du code-golf, donc les échappatoires standard s'appliquent, et la réponse la plus courte en octets gagne!

Note de la théorie des faits amusante:

Le plus grand nombre connu qui ne soit pas un prix Mersenne est 19249 * 2^13018586 + 1ce qui se trouve être aussi un numéro Proth!

Gelée , 5 octets

’&C²>

Essayez-le en ligne! ou vérifier tous les cas de test .

Contexte

Soit j un entier strictement positif. J + 1 bascule tous les bits de fin de jeu de j et le bit non défini adjacent. Par exemple, 10011 ₂ + 1 = 10100 ₂ .

Puisque ~ j = - (j + 1) = -j - 1 , -j = ~ j + 1 , alors -n applique ce qui précède au bit NOT de j (qui bascule tous les bits), basculant ainsi tous les bits avant le dernier 1 .

En prenant j & -j - le bit AND de j et -j - tous les bits avant et après le dernier bit défini sont annulés (car inégal en j et -j ), donnant ainsi la plus grande puissance de 2 qui divise j de manière égale.

Pour l’entrée N , nous voulons appliquer ce qui précède à N-1 pour trouver 2 ⁿ , la plus grande puissance de 2 qui divise N-1 . Si m = N - 1 , -m = - (N - 1) = 1 - N , donc (N - 1) et (1 - N) donne 2 ⁿ .

Tout ce qui reste à tester est si 2 ⁿ > k . Si k> 0 , cela est vrai si et seulement si (2 ⁿ ) ² > k2 ⁿ , ce qui est vrai même si et seulement si (2 ⁿ ) ² ≥ K2 ⁿ + 1 = N .

Enfin, si (2 ⁿ ) ² = N = k2 ⁿ + 1 , 2 ⁿ doit être impair ( 1 ) pour que les parités des deux côtés puissent correspondre, ce qui implique que k = 0 et N = 1 . Dans ce cas (N - 1) et (1 - n) = 0 et 0 = 0 et ((N - 1) et (1 - N)) ² = 0 <= N 1 .

Par conséquent, ((N - 1) & (1 - N)) ² > N est vrai si et seulement si N est un numéro de Proth.

Comment ça marche

’&C²>  Main link. Argument: N

’      Decrement; yield N - 1.
  C    Complement; yield 1 - N.
 &     Take the bitwise AND of both results.
   ²   Square the bitwise AND.
    >  Compare the square to N.

Python, 22 octets

lambda N:N-1&1-N>N**.5

Ceci est un port de ma réponse de gelée . Testez-le sur Ideone .

Comment ça marche

Soit j un entier strictement positif. J + 1 bascule tous les bits de fin de jeu de j et le bit non défini adjacent. Par exemple, 10011 ₂ + 1 = 10100 ₂ .

Puisque ~ j = - (j + 1) = -j - 1 , -j = ~ j + 1 , alors -n applique ce qui précède au bit NOT de j (qui bascule tous les bits), basculant ainsi tous les bits avant le dernier 1 .

En prenant j & -j - le bit AND de j et -j - tous les bits avant et après le dernier bit défini sont annulés (car inégal en j et -j ), donnant ainsi la plus grande puissance de 2 qui divise j de manière égale.

Pour l’entrée N , nous voulons appliquer ce qui précède à N-1 pour trouver 2 ⁿ , la plus grande puissance de 2 qui divise N-1 . Si m = N - 1 , -m = - (N - 1) = 1 - N , donc (N - 1) et (1 - N) donne 2 ⁿ .

Tout ce qui reste à tester est si 2 ⁿ > k . Si k> 0 , cela est vrai si et seulement si (2 ⁿ ) ² > k2 ⁿ , ce qui est vrai même si et seulement si (2 ⁿ ) ² ≥ K2 ⁿ + 1 = N .

Enfin, si (2 ⁿ ) ² = N = k2 ⁿ + 1 , 2 ⁿ doit être impair ( 1 ) pour que les parités des deux côtés puissent correspondre, ce qui implique que k = 0 et N = 1 . Dans ce cas (N - 1) et (1 - n) = 0 et 0 = 0 et ((N - 1) et (1 - N)) ² = 0 <= N 1 .

Par conséquent, ((N - 1) & (1 - N)) ² > N est vrai si et seulement si N est un numéro de Proth.

En ignorant les inexactitudes en virgule flottante, cela équivaut au code N-1&1-N>N**.5de la mise en œuvre.

Python 2, 23 octets

lambda n:(~-n&1-n)**2>n

Mathematica, 50 48 45 40 38 35 31 29 octets

Mathematica est généralement nul en ce qui concerne le golf, mais il existe parfois une fonction intégrée qui rend les choses vraiment belles.

1<#<4^IntegerExponent[#-1,2]&

Un examen:

Reap[Do[If[f[i],Sow[i]],{i,1,1000}]][[2,1]]

{3, 5, 9, 13, 17, 25, 33, 41, 49, 57, 65, 81, 97, 113, 129, 145, 161, 177, 193, 209, 225, 241, 257, 289, 321, 353, 385, 417, 449, 481, 513, 545, 577, 609, 641, 673, 705, 737, 769, 801, 833, 865, 897, 929, 961, 993}

Edit: En fait, si je vole l 'idée de Dennis au niveau des bits ET de Dennis , je peux la réduire à 23 22 20 octets.

Mathematica, 23 22 20 octets (merci A Simmons )

BitAnd[#-1,1-#]^2>#&

05AB1E , 14 à 10 octets

Merci à Emigna pour avoir économisé 4 octets!

Code:

<©Ó¬oD®s/›

Utilise le codage CP-1252 . Essayez-le en ligne! .

Explication:

Pour l'explication, utilisons le nombre 241 . Nous décrivons d’abord le nombre par un avec <. Cela se traduit par 240 . Maintenant, nous calculons les facteurs premiers (avec les doublons) en utilisant Ò. Les facteurs premiers sont:

[2, 2, 2, 2, 3, 5]

Nous les avons divisés en deux parties. En utilisant 2Q·0K, nous obtenons la liste de deux:

[2, 2, 2, 2]

Avec ®2K, nous obtenons la liste des nombres restants:

[3, 5]

Enfin, prenez le produit des deux. [2, 2, 2, 2]résultats en 16 . Le produit des [3, 5]résultats en 15 .

Ce cas de test est la vérité depuis 16 > 15 .

Brain-Flak , 460 350 270 266 264 188 176 octets

Essayez-le en ligne!

({}[()])(((<>()))){{}([(((({}<(({}){})>){}){})<>[({})(())])](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}}(<{}{}>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<>)

Explication

Le programme passe par des puissances de deux et quatre jusqu'à trouver une puissance de deux supérieure à N-1. Lorsqu'il le trouve, il vérifie la divisibilité de N-1 par la puissance de deux à l'aide de modulo et affiche le résultat.

({}[()])      #Subtract one from input
(((<>())))    #Put three ones on the other stack
{
 {}           #Pop the crap off the top
 ([(
  ((({}<(({}){})>){}){}) #Multiply the top by four and the bottom by two
  <>[({})(())])](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{} #Check if the power of four is greater than N-1
}
(<{}{}>) #Remove the power of 4
<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}><>) #Modulo N-1 by the power of two

Ce programme n'est pas propre à la pile. Si vous ajoutez 4 octets supplémentaires, vous pouvez le rendre propre:

({}[()])(((<>()))){{}([(((({}<(({}){})>){}){})<>[({})(())])](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}}(<{}{}>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}><>)

MATL , 9 octets

qtYF1)EW<

La sortie de vérité est 1. Falsy est 0ou une sortie vide. (Les seules entrées qui produisent une sortie vide sont 1et 2; le reste produit l'un 0ou l' autre ou 1).

Essayez-le en ligne!

Explication

Soit x la source. Soit y la plus grande puissance de 2 qui divise x -1, et z = ( x -1) / y . Notez que z est automatiquement impair. Alors x est un nombre de Proth si et seulement si y > z , ou de manière équivalente si y ² > x −1.

q    % Input x implicitly. Subtract 1
t    % Duplicate
YF   % Exponents of prime factorization of x-1
1)   % First entry: exponent of 2. Errors for x equal to 1 or 2
E    % Duplicate
W    % 2 raised to that. This is y squared
<    % Is x-1 less than y squared? Implicitly display

Brachylog , 28 octets

>N>0,2:N^P:K*+?,P>K:2%1,N:K=

Essayez-le en ligne!

Vérifiez tous les tests à la fois. (Légèrement modifié.)

Explication

Brachylog, étant un dérivé de Prolog, est très doué pour prouver des choses.

Ici, nous prouvons ces choses:

>N>0,2:N^P:K*+?,P>K:2%1,N:K=

>N>0                           input > N > 0
     2:N^P                     2^N = P
         P:K*+?                P*K+1 = input
                P>K            P > K
                  K:2%1        K%2 = 1
                        N:K=   [N:K] has a solution

Haskell, 55 46 octets

f x=length [x|k<-[1,3..x],n<-[1..x],k*2^n+1==x,2^n>k]>0

Edit: Merci à nimi, maintenant 46 octets

f x=or[k*2^n+1==x|k<-[1,3..x],n<-[1..x],2^n>k]

ECMAScript Regex, 48 43 41 octets

Les regex de Neil et H.PWiz (tous deux également au goût ECMAScript) sont beaux en eux-mêmes. Il y a une autre façon de le faire, qui , par une jolie coïncidence nette était de 1 octet plus de Neil, et maintenant avec le golf suggéré H.PWiz (merci!), Est de 1 octet plus moins de H.PWiz de.

Attention: malgré la petite taille de cette regex, elle contient un spoiler majeur . Je recommande fortement d'apprendre à résoudre des problèmes mathématiques unaires dans les expressions rationnelles ECMAScript en analysant indépendamment les connaissances mathématiques initiales. Ce voyage a été fascinant pour moi et je ne veux pas le gâter pour ceux qui voudraient éventuellement l'essayer eux-mêmes, en particulier ceux qui s'intéressent à la théorie des nombres. Voir ce message précédent pour une liste de problèmes recommandés consécutivement étiquetés spoiler pour résoudre un par un

Alors , ne lisez pas plus loin si vous ne voulez pas que la magie avancée des regex unaires soit gâtée . Si vous voulez vraiment essayer de découvrir cette magie vous-même, je vous recommande vivement de commencer par résoudre certains problèmes de la regex ECMAScript, comme indiqué dans l'article ci-dessus.

Donc, cette expression rationnelle fonctionne très simplement: elle commence par en soustraire une. Ensuite, il trouve le plus grand facteur impair, k . Ensuite, nous divisons par k (en utilisant l’algorithme de division brièvement expliqué dans un paragraphe étiqueté spoiler de mon nombre factoriel regex post ). Nous faisons sournoisement une affirmation simultanée que le quotient résultant est supérieur à k . Si la division correspond, nous avons un numéro Proth; sinon, nous ne le faisons pas.

J'ai pu supprimer 2 octets de cette expression rationnelle (43 → 41) en utilisant une astuce trouvée par Grimy qui peut encore raccourcir la division dans le cas où le quotient aurait la garantie d'être supérieur ou égal au diviseur.

^x(?=(x(xx)*)\1*$)((\1x*)(?=\1\4*$)x)\3*$

Essayez-le en ligne!

 # Match Proth numbers in the domain ^x*$
 ^
 x                         # tail = tail - 1
 (?=(x(xx)*)\1*$)          # \1 = largest odd factor of tail
 
 # Calculate tail / \1, but require that the quotient, \3, be > \1
 # (and the quotient is implicitly a power of 2, because the divisor
 # is the largest odd factor).
 (                         # \3 = tail / \1, asserting that \3 > \1
     (\1x*)                # \4 = \3-1
     (?=\1\4*$)            # We can skip the test for divisibility by \1-1
                           # (and avoid capturing it) because we've already
                           # asserted that the quotient is larger than the
                           # divisor.
     x
 )
 \3*$
 

Julia, 16 octets

!x=~-x&-~-x>x^.5

Crédits à @Dennis pour la réponse et des conseils de golf!

R, 52 50 octets

x=scan()-1;n=0;while(!x%%2){x=x/2;n=n+1};2^(2*n)>x

Le programme commence par diviser N-1(appelé ici Pet x) par le 2plus longtemps possible afin de trouver la 2^npartie de l'équation, en partant k=(N-1)/2^n, puis calcule si ou non kest inférieur à 2^n, en utilisant le fait que2^n>x/2^n <=> (2^n)²>x <=> 2^2n>x

Regex (ECMAScript), 40 38 octets

-2 octets grâce à Deadcode

^x(?=((xx)+?)(\1\1)*$)(?!(\1x\2*)\4*$)

Essayez-le en ligne!

Version commentée:

# Subtract 1 from the input N
^x

# Assert N is even.
# Capture \1 = biggest power of 2 that divides N.
# Capture \2 = 2.
(?=((xx)+?)(\1\1)*$)

# Assert no odd number > \1 divides N
(?!(\1x\2*)\4*$)

J, 10 octets

%:<<:AND-.

Sur la base de @Dennis bitwise solution .

Prend une entrée net retourne 1 s'il s'agit du numéro de Proth sinon 0.

Usage

   f =: %:<<:AND-.
   f 16
0
   f 17
1
   (#~f"0) >: i. 100  NB. Filter the numbers [1, 100]
3 5 9 13 17 25 33 41 49 57 65 81 97

Explication

%:<<:AND-.  Input: n
        -.  Complement. Compute 1-n
   <:       Decrement. Compute n-1
     AND    Bitwise-and between 1-n and n-1
%:          Square root of n
  <         Compare sqrt(n) < ((1-n) & (n-1))

Retina 0.8.2 , 47 octets

\d+
$*
+`(1+)\1
$+0
01
1
+`.10(0*1)$
1$1
^10*1$

$k · 2^n + 1$$(2k±1) · 2^{n + 1} + 1$$k = 1$

\d+
$*

Convertir en unaire.

+`(1+)\1
$+0
01
1

Convertir en binaire.

+`.10(0*1)$
1$1

Exécutez à plusieurs reprises la formule de génération Proth en sens inverse.

^10*1$

Faites correspondre le cas de base de la formule de génération Proth.

Edit: Je pense qu'il est en fait possible de faire correspondre un numéro de Proth directement à un nombre unaire avec une seule expression rationnelle. Cela me prend actuellement 47 octets, 7 octets de plus que mon code Retina actuel pour vérifier si un nombre unaire est un numéro Proth:

^.(?=(.+?)(\1\1)*$)(?=((.*)\4.)\3*$).*(?!\1)\3$

ECMAScript Regex, 42 octets

^x(?=(x(xx)*)\1*$)(?=(x+?)((\3\3)*$))\4\1x

Essayez-le en ligne! (Utilisation de la rétine)

Je soustrais essentiellement 1, divise par le plus grand nombre impair possible k, puis vérifie qu'il k+1reste au moins .

Il se trouve que mon expression régulière est très similaire à celle que Neil donne à la fin de sa réponse . J'utilise x(xx)*au lieu de (x*)\2x. Et j'utilise une méthode plus courte pour vérifierk < 2^n

Brain-Flak , 128 octets

({<{({}[()]<(([{}]())<>{})<>>)}{}>{{}(<>)}{}}<><(())>){([()]{}<(({}){})>)}{}([({}[{}(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

Essayez-le en ligne!

J'ai utilisé un algorithme très différent de celui de l' ancienne solution Brain-Flak .

Fondamentalement, je divise par 2 (arrondi au-dessus) jusqu'à ce que je frappe un nombre pair. Ensuite, je compare simplement le résultat de la dernière division avec les deux à la puissance du nombre de fois que j’ai divisé.

Explication:

({
  # (n+1)/2 to the other stack, n mod 2 to this stack
  <{({}[()]<(([{}]())<>{})<>>)}{}>
  # if 1 (n was odd) jump to the other stack and count the one
  {{}(<>)}{}
#end and push the sum -1, with a one under it
}<>[(())])
#use the one to get a power of two
{([()]{}<(({}){})>)}{}
#compare the power of two with the remainder after all the divisions
([({}[{}(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

Maple, 100 octets (espaces compris)

IsProth:=proc(X)local n:=0;local x:=X-1;while x mod 2<>1 do x:=x/2;n:=n+1;end do;is(2^n>x);end proc:

Bien espacés pour la lisibilité:

IsProth := proc( X )
    local n := 0;
    local x := X - 1;
    while x mod 2 <> 1 do
        x := x / 2;
        n := n + 1;
    end do;
    is( 2^n > x );
end proc:

Même idée que plusieurs autres; divisez X par 2 jusqu'à ce que X ne soit plus divisible par 2, puis vérifiez le critère 2 ^ n> x.

Java 1.7, 49 43 octets

Un autre 6 octets de la poussière grâce à @charlie.

boolean g(int p){return p--<(p&-p)*(p&-p);}

Essayez le! (ideone)

Deux façons, également longues. Comme pour la plupart des réponses ici, les crédits vont à @Dennis bien sûr pour l'expression.

Prenant la racine du côté droit de l'expression:

boolean f(int p){return(p-1&(1-p))>Math.sqrt(p);}

Application de la puissance de deux à gauche de l'expression:

boolean g(int p){return Math.pow(p-1&(1-p),2)>p;}

Peut effacer un seul octet si une valeur numérique positive est autorisée à représenter la "vérité" et une valeur négative "falsy":

double g(int p){return Math.pow(p-1&(1-p),2)-p;}

Malheureusement, à cause de la «conversion restreinte des primitives», on ne peut pas simplement écrire cela en Java et obtenir des résultats corrects:

((p - 1 & (1 - p))^2) > p;

Et toute tentative d'élargissement de 'p' conduira à une erreur de compilation car les opérateurs au niveau des bits ne sont pas supportés sur ie float ou les doubles :(

Hy , 37 octets

(defn f[n](>(**(&(- n 1)(- 1 n))2)n))

Essayez-le en ligne!

Réponse du port de @Dennis.

C (gcc) , 29 à 30 octets

z;f(x){return--x<(z=x&-x)*z;}

Essayez-le en ligne!

Japt , 12 10 9 octets

É&1-U)>Uq

Essayez-le en ligne!

La réponse de gelée du port de Dennis à nouveau. - 1 grâce à @Shaggy.

Cjam, 11 octets

Comme beaucoup d'entre nous, tirons profit de l'excellente solution de Dennis:

qi_(_W*&2#<

Essayez-le en ligne

C (137 octets)

int P(int N){int x=1,n=0,k=1,e=1,P=0;for(;e;n++){for(x=1,k=1;x&&x<N;k+=2){x=2<<n;x=x>k?x*k+1:0;if(x>N&&k==1)e=0;}if(x==N)P=1;}return P;}

Je ne suis venu lire les réponses qu'après l'avoir essayé.

Considérant N=k*2^n+1avec le conditionnel de k<2^n( k=1,3,5..etn=1,2,3..

Avec n=1nous avons un kdisponible pour tester. Au fur et à mesure que nous augmentons, nnous k'sen testons un peu plus :

n = 1; k = 1

n = 2; k = 1 k = 3

n = 3; k = 1 k = 3 k = 5 k = 7

...

Itère ces possibilités que nous pouvons être sûrs que N est pas un numéro Prouth si un donné nlak=1 nombre obtenu est supérieur à N et aucune autre itération était un match.

Donc, fondamentalement, mon code "force brute" pour trouver N.

Après avoir lu les autres réponses et réalisé que vous pouvez factoriser N-1 avec 2 pour trouver net ensuite rendre la condition dek<2^n , alors je pense que mon code pourrait être plus petit et plus efficace en utilisant cette méthode.

Ça valait le coup d'essayer!

Testé tous les nombres donnés et quelques nombres "non-Prouth". La fonction retourne 1 si le numéro est un numéro Prouth et 0 si ce n'est pas le cas.

Javascript ES7, 16 octets

x=>x--<(-x&x)**2

Réponse de Port of my Julia, qui est une réponse de @ Dennis's Jelly.

Merci @Charlie pour 2 octets sauvés!

C # (.NET Core) , 17 octets

x=>x--<(x=x&-x)*x

Essayez-le en ligne!

Réponse C du port de MegaTom .

J'ai essayé une solution basée sur LINQ, mais c'était trop bon.

encre , 60 octets

=p(n)
~n-=n>1
~temp x=1
-(k){n%2:{n<x}->->}
~x+=x
~n=n/2
->k

Essayez-le en ligne!

D' après la réponse de @DSkoog dans Maple - ce n'était pas le premier du genre à être posté, mais c'était le premier du genre que j'ai vu.

Ungolfed

= is_proth(number) =

/* It's easy to check if a number is one less than a Proth number.
   We take the number and divide it by 2 until we can't.
   Once we can't, we've found the smallest possible "k".
   If we also keep track of how many times we divided, we have our corresponding "2^n"
   All we have to do then is compare those
*/

~ number -= (number > 1)            // So, we first subtract one. Except this implementation won't ever halt for 0, so we don't subtract if the input is 1 (this is fine since the desired outputs for inputs 1 and 2 are the same)
~ temp power_of_two = 1             // We declare a variable to store our "2^n"
- (check)
  {
  - number % 2:                     // Once we can't divide by 2 anymore, we've found the smallest possible "k"
    {number < power_of_two}         // At that point, we print whether it's smaller than the "2^n" we found
    ->->                            // And then we return to where we were called from
  }

  ~ number = number / 2             // We keep dividing by 2 until we can't.
  ~ power_of_two += power_of_two    // and update our "2^n" as we go
-> check

Code machine x86, 15 octets

4F 89 F8 F7 D8 21 F8 0F AF C0 39 C7 19 C0 C3

Ces octets définissent une fonction qui prend l'argument d'entrée (un entier non signé) dans le EDIregistre, conformément à la convention d'appel standard de System V pour les systèmes x86, et renvoie le résultat dans le EAXregistre, comme tous les autres. les conventions d'appel x86.

En mnémonique assembleur:

4F          dec   edi            ; input -= 1
89 F8       mov   eax, edi       ; \ temp
F7 D8       neg   eax            ; |      =
21 F8       and   eax, edi       ; /        (input & -input)
0F AF C0    imul  eax, eax       ; temp *= temp
39 C7       cmp   edi, eax       ; set CF if (input < temp)
19 C0       sbb   eax, eax       ; EAX = -CF
C3          ret                  ; return with result in EAX
                                 ;  (-1 for Proth number; 0 otherwise)

Essayez-le en ligne!

C'est une solution assez simple, et conceptuellement similaire à la version C de MegaTom . En fait, vous pouvez écrire ceci en C comme suit:

unsigned IsProthNumber(unsigned input)
{
    --input;
    unsigned temp  = (input & -input);
    temp          *= temp;
    return (input < temp) ? -1 : 0;
}

mais le code machine ci-dessus est meilleur que ce que vous obtiendrez d'un compilateur C, même s'il est réglé pour une taille optimale.

Le seul "tricheur" ici renvoie -1 comme valeur de "vérité" et 0 comme valeur de "faux". Cette astuce permet d'utiliser l' SBBinstruction à 2 octets par opposition à l'instruction à 3 octets SETB.