Un numero Proth , che prende il nome da François Proth, è un numero che può essere espresso come

N = k * 2^n + 1

Dove kè un numero intero dispari positivo ed nè un numero intero positivo tale 2^n > k. Facciamo un esempio più concreto. Take 3. 3 è un numero Proth perché può essere scritto come

(1 * 2^1) + 1

ed 2^1 > 1è soddisfatto. 5 È anche un numero Proth perché può essere scritto come

(1 * 2^2) + 1

ed 2^2 > 1è soddisfatto. Tuttavia, 7 non è un numero Proth perché l'unico modo per scriverlo nel modulo N = k * 2^n + 1è

(3 * 2^1) + 1

e 2^1 > 3non è soddisfatto.

La tua sfida è abbastanza semplice: devi scrivere un programma o una funzione che, dato un numero intero postivo, determina se si tratta di un numero Proth o meno. È possibile accettare input in qualsiasi formato ragionevole e generare un valore di verità se è un numero Proth e un valore di falsa se non lo è. Se la lingua ha qualche "Proth-numero rilevamento" funzioni, è possibile utilizzarli.

Test IO

Ecco i primi 46 numeri Proth fino a 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

Ogni altro input valido dovrebbe dare un valore falso.

Come al solito, si tratta di code-golf, quindi si applicano scappatoie standard e vince la risposta più breve in byte!

Nota a margine della teoria dei numeri:

Il più grande primo conosciuto che non è un Mersenne Prime è 19249 * 2^13018586 + 1, che è anche un numero Proth!

Gelatina , 5 byte

’&C²>

Provalo online! o verifica tutti i casi di test .

sfondo

Sia j un numero intero strettamente positivo. j + 1 attiva / disattiva tutti i bit finali impostati di j e il bit disinserito adiacente. Ad esempio, 10011 ₂ + 1 = 10100 ₂ .

Poiché ~ j = - (j + 1) = -j - 1 , -j = ~ j + 1 , quindi -n applica quanto sopra al NOT bit a bit di j (che attiva / disattiva tutti i bit), quindi attivando tutti i bit prima dell'ultimo 1 .

Prendendo j & -j - AND bit per bit di j e -j - tutti i bit prima e dopo l'ultimo bit impostato vengono annullati (poiché disuguali in j e -j ), producendo così la massima potenza di 2 che divide j uniformemente.

Per l'ingresso N , vogliamo applicare quanto sopra a N - 1 per trovare 2 ⁿ , la massima potenza di 2 che divide N - 1 . Se m = N - 1 , -m = - (N - 1) = 1 - N , quindi (N - 1) & (1 - N) produce 2 ⁿ .

Tutto ciò che resta da testare è se 2 ⁿ > k . Se k> 0 , questo è vero se e solo se (2 ⁿ ) ² > k2 ⁿ , che è vero se stessa se e solo se (2 ⁿ ) ² ≥ k2 ⁿ + 1 = N .

Infine, se (2 ⁿ ) ² = N = k2 ⁿ + 1 , 2 ⁿ deve essere dispari ( 1 ) in modo che le parità di entrambe le parti possano corrispondere, implicando che k = 0 e N = 1 . In questo caso (N - 1) e (1 - N) = 0 e 0 = 0 e ((N - 1) e (1 - N)) ² = 0 <1 = N .

Pertanto, ((N - 1) e (1 - N)) ² > N è vero se e solo se N è un numero Proth.

Come funziona

’&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 byte

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

Questa è una porta della mia risposta Jelly . Provalo su Ideone .

Come funziona

Sia j un numero intero strettamente positivo. j + 1 attiva / disattiva tutti i bit finali impostati di j e il bit disinserito adiacente. Ad esempio, 10011 ₂ + 1 = 10100 ₂ .

Poiché ~ j = - (j + 1) = -j - 1 , -j = ~ j + 1 , quindi -n applica quanto sopra al NOT bit a bit di j (che attiva / disattiva tutti i bit), quindi attivando tutti i bit prima dell'ultimo 1 .

Prendendo j & -j - AND bit per bit di j e -j - tutti i bit prima e dopo l'ultimo bit impostato vengono annullati (poiché disuguali in j e -j ), producendo così la massima potenza di 2 che divide j uniformemente.

Per l'ingresso N , vogliamo applicare quanto sopra a N - 1 per trovare 2 ⁿ , la massima potenza di 2 che divide N - 1 . Se m = N - 1 , -m = - (N - 1) = 1 - N , quindi (N - 1) & (1 - N) produce 2 ⁿ .

Tutto ciò che resta da testare è se 2 ⁿ > k . Se k> 0 , questo è vero se e solo se (2 ⁿ ) ² > k2 ⁿ , che è vero se stessa se e solo se (2 ⁿ ) ² ≥ k2 ⁿ + 1 = N .

Infine, se (2 ⁿ ) ² = N = k2 ⁿ + 1 , 2 ⁿ deve essere dispari ( 1 ) in modo che le parità di entrambe le parti possano corrispondere, implicando che k = 0 e N = 1 . In questo caso (N - 1) e (1 - N) = 0 e 0 = 0 e ((N - 1) e (1 - N)) ² = 0 <1 = N .

Pertanto, ((N - 1) e (1 - N)) ² > N è vero se e solo se N è un numero Proth.

Ignorando le imprecisioni in virgola mobile, questo equivale al codice N-1&1-N>N**.5nell'implementazione.

Python 2, 23 byte

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

Mathematica, 50 48 45 40 38 35 31 29 byte

Mathematica generalmente fa schifo quando si tratta di code golf, ma a volte c'è un built-in che rende le cose davvero belle.

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

Un test:

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}

Modifica: In realtà, se rubo l' idea AND di bit di Dennis , posso farlo scendere a 23 22 20 byte.

Mathematica, 23 22 20 byte (grazie A Simmons )

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

05AB1E , 14 10 byte

Grazie a Emigna per aver salvato 4 byte!

Codice:

<©Ó¬oD®s/›

Utilizza il CP-1252 codifica . Provalo online! .

Spiegazione:

Per la spiegazione, usiamo il numero 241 . Prima diminuiamo il numero di uno con <. Ciò si traduce in 240 . Ora, calcoliamo i fattori primi (con duplicati) utilizzando Ò. I fattori primi sono:

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

Li abbiamo divisi in due parti. Usando 2Q·0K, otteniamo l'elenco di due:

[2, 2, 2, 2]

Con ®2K, otteniamo l'elenco dei numeri rimanenti:

[3, 5]

Infine, prendi il prodotto di entrambi. [2, 2, 2, 2]risultati in 16 . Il prodotto dei [3, 5]risultati in 15 .

Questo caso di test è vero dal 16 > 15 .

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

Provalo online!

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

Spiegazione

Il programma passa attraverso potenze di due e quattro finché non trova una potenza di due maggiore di N-1. Quando lo trova controlla la divisibilità di N-1 per la potenza di due usando il modulo e genera il risultato

({}[()])      #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

Questo programma non è impilabile. Se aggiungi altri 4 byte puoi farlo impilare pulito:

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

MATL , 9 byte

qtYF1)EW<

L'output vero è 1. Falsy è 0o uscita vuota. (Gli unici input che producono output vuoti sono 1e 2; il resto produce o 0o 1).

Provalo online!

Spiegazione

Consenti a x di indicare l'input. Sia y la potenza maggiore di 2 che divide x −1 e z = ( x −1) / y . Si noti che z è automaticamente dispari. Quindi x è un numero di Proth se e solo se y > z , o equivalentemente se 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 byte

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

Provalo online!

Verifica tutti i test in una volta. (Leggermente modificato.)

Spiegazione

Brachylog, essendo un derivato di Prolog, è molto bravo a provare le cose.

Qui, dimostriamo queste cose:

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

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

Modifica: grazie a nimi, ora 46 byte

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

ECMAScript Regex, 48 43 41 byte

Le regex di Neil e H.PWiz (entrambe anche dal sapore ECMAScript) sono meravigliose a sé stanti. C'è un altro modo per farlo, che per una coincidenza abbastanza pulito era 1 byte più di Neil, e ora con il golf suggerito di H.PWiz (grazie!), È 1 byte più meno di H.PWiz di.

Avvertenza: nonostante le dimensioni ridotte di questa regex, contiene a spoiler importante . Consiglio vivamente di imparare a risolvere i problemi matematici unari nella regex di ECMAScript scoprendo le intuizioni matematiche iniziali in modo indipendente. È stato un viaggio affascinante per me e non voglio rovinarlo per nessuno che potrebbe potenzialmente provarlo da solo, in particolare quelli con un interesse per la teoria dei numeri. Vedi questo post precedente per un elenco di problemi consigliati consecutivamente con tag spoiler da risolvere uno per uno.

Così non leggere oltre se non vuoi che qualche magia regex unaria avanzata venga viziata per te . Se vuoi fare un tentativo per capire da solo questa magia, ti consiglio vivamente di iniziare risolvendo alcuni problemi nella regex di ECMAScript come indicato in quel post collegato sopra.

Quindi, questa regex funziona in modo abbastanza semplice: inizia sottrandone una. Quindi trova il più grande fattore dispari, k . Quindi dividiamo per k (usando l'algoritmo di divisione brevemente spiegato in un paragrafo con tag spoiler del mio post regex sui numeri fattoriali ). Facciamo furtivamente un'asserzione simultanea che il quoziente risultante è maggiore di k . Se la divisione corrisponde, abbiamo un numero Proth; in caso contrario, non lo facciamo.

Sono stato in grado di eliminare 2 byte da questa regex (43 → 41) usando un trucco trovato da Grimy che può ridurre ulteriormente la divisione nel caso in cui il quoziente sia garantito maggiore o uguale al divisore.

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

Provalo online!

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

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

Ringraziamenti a @Dennis per la risposta e alcuni consigli sul golf!

R, 52 50 byte

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

Il programma inizia dividendo N-1 (chiamato qui Pe x) il 2più a lungo possibile al fine di trovare la 2^nparte dell'equazione, lasciando k=(N-1)/2^n, e quindi calcola se kè inferiore o meno 2^n, utilizzando il fatto che2^n>x/2^n <=> (2^n)²>x <=> 2^2n>x

Regex (ECMAScript), 40 38 byte

-2 byte grazie a Deadcode

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

Provalo online!

Versione commentata:

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

%:<<:AND-.

Basato sulla soluzione bitwise di @Dennis .

Accetta un input n e restituisce 1 se è Proth numero 0.

uso

   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

Spiegazione

%:<<: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 byte

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

Provalo online! Spiegazione: Dato un numero Proth$k · 2^n + 1$, puoi derivare due nuovi numeri Proth $(2k±1) · 2^{n + 1} + 1$. Possiamo eseguirlo al contrario finché non otteniamo un numero Proth dove$k = 1$. Questo viene prontamente eseguito trasformando la rappresentazione binaria.

\d+
$*

Converti in unario.

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

Converti in binario.

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

Eseguire ripetutamente la formula di generazione Proth al contrario.

^10*1$

Abbina il case base della formula di generazione Proth.

Modifica: penso che in realtà sia possibile abbinare un numero Proth direttamente a un numero unario con una sola regex. Questo mi richiede attualmente 47 byte, 7 byte in più rispetto al mio attuale codice Retina per verificare se un numero unario è un numero Proth:

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

ECMAScript Regex, 42 byte

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

Provalo online! (Uso della retina)

In sostanza sottraggo 1, divido per il numero dispari più grande possibile k, quindi controllo che almeno k+1rimanga.

Si scopre che il mio regex è molto simile a quello che Neil dà alla fine della sua risposta . Io uso x(xx)*invece di(x*)\2x . E uso un metodo più breve per verificarek < 2^n

Brain-Flak , 128 byte

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

Provalo online!

Ho usato un algoritmo molto diverso rispetto alla vecchia soluzione Brain-Flak .

Fondamentalmente, divido per 2 (arrotondando per eccesso) fino a quando non raggiungo un numero pari. Quindi ho solo confrontato il risultato dell'ultima divisione con i due con la potenza del numero di volte che ho diviso.

Spiegazione:

({
  # (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
([({}[{}(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

Acero, 100 byte (spazi inclusi)

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:

Ben distanziati per la leggibilità:

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:

Stessa idea di molte altre; dividere X per 2 fino a quando X non è più uniformemente divisibile per 2, quindi controllare i criteri 2 ^ n> x.

Java 1.7, 49 43 byte

Altri 6 byte di polvere grazie a @charlie.

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

Provalo! (Ideone)

Due modi, ugualmente lunghi. Come con la maggior parte delle risposte qui, i crediti vanno ovviamente a @Dennis per l'espressione.

Prendendo la radice del lato destro dell'espressione:

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

Applicando il potere di due sul lato sinistro dell'espressione:

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

Può radere via un singolo byte se un valore numerico positivo è autorizzato a rappresentare "verità" e un valore negativo "falsa":

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

Sfortunatamente a causa della 'Narrowing Primitive Conversion' non si può semplicemente scrivere questo in Java e ottenere risultati corretti:

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

E qualsiasi tentativo di ampliare 'p' porterà a un errore di compilazione perché gli operatori bit a bit non sono supportati su float o double :(

Hy , 37 byte

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

Provalo online!

La risposta di Port of @Dennis.

C (gcc) , 29 30 byte

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

Provalo online!

Japt , 12 10 9 byte

É&1-U)>Uq

Provalo online!

Jelly di Port of Dennis risponde di nuovo. - 1 grazie a @Shaggy.

Cjam, 11 byte

Come molti di noi, abbandoniamo l'eccellente soluzione di Dennis:

qi_(_W*&2#<

Provalo online

C (137 byte)

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;}

Sono venuto a leggere le risposte solo dopo averlo provato.

Considerando N=k*2^n+1con il condizionale di k<2^n( k=1,3,5..en=1,2,3..

Con n=1ne abbiamo uno kdisponibile per il test. Man mano che aumentiamo nne otteniamo altri ancora k'sper testare in questo modo:

n = 1; k = 1

n = 2; k = 1 k = 3

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

...

Scorrendo queste possibilità possiamo essere certi che N non è un numero Prouth se per un dato numero nil k=1numero ottenuto è maggiore di N e nessun'altra iterazione è stata una corrispondenza.

Quindi il mio codice sostanzialmente "forza bruta" si fa strada nel trovare N.

Dopo aver letto le altre risposte e aver realizzato che puoi calcolare il fattore N-1 con 2 per trovare ne quindi condizionare k<2^n, penso che il mio codice potrebbe essere più piccolo ed efficiente usando questo metodo.

Valeva la pena di provare!

Ho testato tutti i numeri forniti e alcuni numeri "non Prouth". La funzione restituisce 1 se il numero è un numero Prouth e 0 se non lo è.

Javascript ES7, 16 byte

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

Porta della mia risposta Julia, che è un porto della risposta Jelly di @Dennis.

Grazie @Charlie per 2 byte salvati!

C # (.NET Core) , 17 byte

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

Provalo online!

Porto di La risposta C MegaTom .

Ho provato una soluzione basata su LINQ, ma era troppo buona.

inchiostro , 60 byte

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

Provalo online!

Basato sulla risposta di Maple di @ DSkoog : non è stato il primo del suo genere ad essere pubblicato, ma è stato il primo del suo genere che ho visto.

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

Codice macchina x86, 15 byte

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

Questi byte definiscono una funzione che accetta l'argomento input (un numero intero senza segno) nel EDIregistro, seguendo la convenzione di chiamata standard System V per i sistemi x86, e restituisce il risultato nel EAXregistro, come tutti le convenzioni di chiamata x86.

In assemblatore mnemonico:

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)

Provalo online!

È una soluzione piuttosto semplice e concettualmente simile alla versione C di MegaTom . In effetti, potresti scriverlo in C come qualcosa di simile al seguente:

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

ma il codice della macchina sopra è migliore rispetto a quello che otterrai da un compilatore C, anche quando è impostato per ottimizzare le dimensioni.

L'unico "cheat" qui sta restituendo -1 come valore "true" e 0 come valore "false". Questo trucco consente l'uso SBBdell'istruzione a 2 byte rispetto all'istruzione a 3 byte SETB.