François Proth ismini taşıyan bir Proth numarası , olarak ifade edilebilecek bir sayıdır.

N = k * 2^n + 1

kTek bir pozitif tamsayı nerede ve nböyle bir pozitif tamsayıdır 2^n > k. Daha somut bir örnek kullanalım. 3'ü alın. 3 bir Proth numarasıdır, çünkü

(1 * 2^1) + 1

ve 2^1 > 1memnun. 5 Ayrıca Proth numarasıdır, çünkü

(1 * 2^2) + 1

ve 2^2 > 1memnun. Ancak, 7 değil şeklinde yazmak için tek yol, çünkü bir PROTH sayı N = k * 2^n + 1olduğu

(3 * 2^1) + 1

ve 2^1 > 3memnun değil.

Buradaki zorluk oldukça basittir: Pozitif bir tamsayı verildiğinde Proth sayısı olup olmadığını belirleyen bir program veya işlev yazmalısınız. Herhangi bir makul formatta girdi alabilir ve eğer bir Proth numarası ise yanlış bir değer, eğer değilse sahte bir değer vermelisiniz. Dilinizde herhangi bir "Proth-sayı tespiti" işlevi varsa , bunları kullanabilirsiniz.

Test IO

İşte 1000'e kadar ilk 46 Proth sayısı. ( 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

Diğer her geçerli giriş sahte bir değer vermelidir.

Her zaman olduğu gibi, bu kod golf, bu yüzden standart boşluklar geçerli ve bayt cinsinden en kısa cevap kazanıyor!

Sayı teorisi eğlence gerçeği notu:

Mersenne Başbakanı olmayan bilinen en büyük asal, 19249 * 2^13018586 + 1bir Proth sayısı da olur!

Jöle , 5 bayt

’&C²>

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Arka fon

Let j kesinlikle pozitif tamsayı. j + 1 , j'nin ve bitişikteki ayarlanmamış bitin tüm küme bitlerini değiştirir . Örneğin, 10011 ₂ + 1 = 10100 ₂ .

Yana ~ J = - (j + 1) = -j - 1 , -j = ~ j + 1 , çok -n değil bit cinsinden yukarıda geçerlidir j (geçiş yapar tüm bu şekilde son önce tüm bit geçiş, bit) 1 .

Alarak j & -j Bitwise VE ait - j ve j - tüm bitleri öncesi ve son ayarlanan bit (içinde eşitsiz beri sıfırlanmış olup sonra j ve j böylece en yüksek gücü vererek) 2 olduğu böler j eşit.

Giriş için N , biz yukarıda uygulamak istediğiniz 1 - N bulmak için 2 ⁿ , en yüksek güç 2. o böler 1 - N . Eğer 1 - m = N , -m = - (N - 1) = 1 - N , yani (N - 1) ve (1 - N) elde edilir 2 ⁿ .

Test etmek için geriye kalan tek şey 2 ⁿ > k . Eğer k> 0 ise , bu sadece ve eğer (2 ⁿ ) ² > k2 ⁿ ise, ve eğer sadece (2 ⁿ ) ² ≥ k2 ⁿ + 1 = N ise doğrudur .

Son olarak, eğer (2 ^N ) ² = N-k2 ^{, n} + 1 , 2 ^{, n} tek olmalıdır ( 1 ) her iki taraftan pariteleri eşleşebilir, ima k = 0 ve N = 1 . Bu durumda ve - (1N) (1 - N) 0 & 0 = 0 = ve - (- 1) ve (1 N) (N) ² = 0 <1 = N .

Bu nedenle, ((N - 1) & (1 - N)) ² > N , N'nin Proth numarası olması durumunda geçerlidir .

Nasıl çalışır

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

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

Bu Jelly cevabımın bir limanı . İdeone üzerinde test et .

Nasıl çalışır

Let j kesinlikle pozitif tamsayı. j + 1 , j'nin ve bitişikteki ayarlanmamış bitin tüm küme bitlerini değiştirir . Örneğin, 10011 ₂ + 1 = 10100 ₂ .

Yana ~ J = - (j + 1) = -j - 1 , -j = ~ j + 1 , çok -n değil bit cinsinden yukarıda geçerlidir j (geçiş yapar tüm bu şekilde son önce tüm bit geçiş, bit) 1 .

Alarak j & -j Bitwise VE ait - j ve j - tüm bitleri öncesi ve son ayarlanan bit (içinde eşitsiz beri sıfırlanmış olup sonra j ve j böylece en yüksek gücü vererek) 2 olduğu böler j eşit.

Giriş için N , biz yukarıda uygulamak istediğiniz 1 - N bulmak için 2 ⁿ , en yüksek güç 2. o böler 1 - N . Eğer 1 - m = N , -m = - (N - 1) = 1 - N , yani (N - 1) ve (1 - N) elde edilir 2 ⁿ .

Test etmek için geriye kalan tek şey 2 ⁿ > k . Eğer k> 0 ise , bu sadece ve eğer (2 ⁿ ) ² > k2 ⁿ ise, ve eğer sadece (2 ⁿ ) ² ≥ k2 ⁿ + 1 = N ise doğrudur .

Son olarak, eğer (2 ^N ) ² = N-k2 ^{, n} + 1 , 2 ^{, n} tek olmalıdır ( 1 ) her iki taraftan pariteleri eşleşebilir, ima k = 0 ve N = 1 . Bu durumda ve - (1N) (1 - N) 0 & 0 = 0 = ve - (- 1) ve (1 N) (N) ² = 0 <1 = N .

Bu nedenle, ((N - 1) & (1 - N)) ² > N , N'nin Proth numarası olması durumunda geçerlidir .

Kayan nokta yanlışlıklarını dikkate almamak N-1&1-N>N**.5, uygulamadaki koda eşdeğerdir .

Python 2, 23 bayt

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

Mathematica, 50 48 45 40 38 35 31 29 bayt

Mathematica genellikle golf kodlaması söz konusu olduğunda berbattır, ancak bazen işlerin gerçekten güzel görünmesini sağlayan bir yerleşik sistem vardır.

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

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

Düzenleme: Aslında, Dennis'in bitsel AND fikirini çalarsam, 23 22 20 bayta indirebilirim .

Mathematica, 23 22 20 bayt (teşekkürler A Simmons )

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

05AB1E , 14 10 bayt

4 bayt kaydettiğiniz için Emigna'ya teşekkürler !

Kod:

<©Ó¬oD®s/›

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin! .

Açıklama:

Açıklama için 241 sayısını kullanalım . İlk önce sayıyı birer birer azaltırız <. Bu 240 sonuçlanır . Şimdi, asal çarpanları (kopyalarla) kullanarak hesaplıyoruz Ò. Başlıca faktörler:

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

Onları iki bölüme ayırdık. Kullanarak 2Q·0K, ikisinin listesini alırız:

[2, 2, 2, 2]

İle ®2Kkalan sayıların listesini alırız:

[3, 5]

Son olarak, her ikisinin de ürününü alın. 16[2, 2, 2, 2] sonuçlanır . Ürünü içine sonuçları 15 .[3, 5]

Bu test durumu beri truthy olan 16 > 15 .

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

Çevrimiçi deneyin!

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

açıklama

Program N-1'den iki kişilik bir güç bulana kadar iki ve dört kişilik güçlerden geçer. Bulduğunda, N-1'in bölünebilirliğini, modulo kullanarak ikisinin gücü ile kontrol eder ve sonucu verir.

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

Bu program temiz yığın değil. Fazladan 4 bayt eklerseniz, yığını temizleyebilirsiniz:

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

MATL , 9 bayt

qtYF1)EW<

Gerçek çıktı 1. Sahte 0çıktı veya boş çıktı. (Boş çıktı üreten tek girdiler 1ve 2; ya gerisi ya 0da üretir 1).

Çevrimiçi deneyin!

açıklama

Let x girişi belirtir. Let y 2 bu bölme en büyük enerji olarak X 1, ve z = ( x -1) / y . Not z otomatik garip. O zaman x , yalnızca y > z ise ve eşdeğerde y ² > x −1 ise bir Proth numarasıdır .

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 bayt

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

Çevrimiçi deneyin!

Tüm test durumlarını bir kerede doğrulayın. (Hafifçe değiştirilmiş.)

açıklama

Prolog'un bir türevi olan Brachylog, kanıtlamakta çok iyidir.

İşte, bunları kanıtlıyoruz:

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

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

Düzenleme: nimi sayesinde, şimdi 46 bayt

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

ECMAScript Regex, 48 43 41 bayt

Neil'in ve H.PWiz'in regex'leri (hem ECMAScript tadı) kendi başlarına güzeller. Bunu yapmanın başka bir yolu var, oldukça temiz bir tesadüfle Neil'inkinden 1 byte daha fazla ve şimdi H.PWiz'in önerdiği golf ile (teşekkürler!) H.PWiz'inkinden 1 byte daha az.

Uyarı: Bu regex'in küçük boyutuna rağmen, büyük bir spoiler içerir . ECMAScript regex'deki unary matematik problemlerini bağımsız olarak başlangıçtaki matematiksel bilgileri çözerek çözmeyi öğrenmenizi şiddetle tavsiye ederim. Benim için büyüleyici bir yolculuk oldu ve bunu denemek isteyebilecek herhangi biri için, özellikle de sayı teorisine ilgi duyanlar için onu mahvetmek istemiyorum. Birbiri ardına çözmek için art arda spoiler etiketli önerilen sorunların bir listesi için bu önceki yazıya bakın .

Bu yüzden , sizin için şımarık bazı gelişmiş regex sihrini istemiyorsanız, daha fazla okumayın . Bu sihri kendiniz bulmaya bir göz atmak istiyorsanız, yukarıda belirtilen bağlantıda belirtildiği gibi ECMAScript regex'deki bazı sorunları çözerek başlamanızı şiddetle tavsiye ederim.

Yani, bu regex oldukça basit çalışır: Bir çıkarılarak başlar. Sonra en büyük garip faktörü bulur, k . Sonra k ile bölüyoruz ( faktoring numaralarımın regex post'unun spoiler etiketli bir paragrafında kısaca açıklanan bölüm algoritmasını kullanarak ). Sinsi olarak, sonuçta elde edilen bölümün k'dan büyük olduğu iddiasını ileri sürüyoruz . Eğer bölüm eşleşirse, bir Proth numaramız var; eğer değilse, biz değiliz.

Bölümün bölene eşit veya ondan daha büyük olması garanti edildiğinde, bölünmeyi daha da kısaltabilen Grimy'nin bulduğu bir numara kullanarak bu regex'ten (43 → 41) 2 bayt bırakmayı başardım .

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

Çevrimiçi deneyin!

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

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

Cevap ve bazı golf ipuçları için @Dennis Kredileri!

R, 5250 bayt

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

Program , denklemin bir bölümünü bulmak için mümkün olduğunca bölerek N-1(burada Pve adıyla anılır x) ile başlar , ayrılır ve sonra gerçekte aşağılık olup olmadığını hesaplar .22^nk=(N-1)/2^nk2^n2^n>x/2^n <=> (2^n)²>x <=> 2^2n>x

Regex (ECMAScript), 40 38 bayt

Deadcode sayesinde -2 bayt

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

Çevrimiçi deneyin!

Yorumlanan sürüm:

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

%:<<:AND-.

@Dennis 'bitwise çözümüne dayanarak .

Giriş alır nve Proth numarası 0 ise 0 değerini döndürür.

kullanım

   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

açıklama

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

\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+
$*

Birliğe dönüştür.

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

İkili dosyaya dönüştür.

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

Proth nesil formülünü arka arkaya tersten çalıştırın.

^10*1$

Proth nesil formülünün temel durumunu eşleştirin.

Düzenleme: Proth sayısının doğrudan tek bir regex ile tek bir sayıyla karşılaştırılması mümkün olduğunu düşünüyorum. Bu, şu anda bana bir bayt numarasının Proth numarası olup olmadığını kontrol etmek için mevcut Retina kodumdan 7 bayt daha fazla 47 bayt sürüyor:

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

ECMAScript Regex, 42 bayt

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

Çevrimiçi deneyin! (Retina'yı Kullanarak)

Ben esasen 1'i çıkardım, mümkün olan en büyük tek sayıya böldüm k, sonra en azından k+1bırakıldığını kontrol ettim .

Benim regex benim Neil'in cevabının sonunda verdiğine çok benziyor . Kullandığım x(xx)*yerine (x*)\2x. Ve kontrol etmek için daha kısa bir yöntem kullanıyorumk < 2^n

Brain-Flak , 128 bayt

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

Çevrimiçi deneyin!

Eski Brain-Flak çözümünden çok farklı bir algoritma kullandım .

Temel olarak, çift sayıya çarpıncaya kadar 2'ye (yukarı yuvarlayarak) bölerim. Sonra son bölümün sonucunu, ikisi ile bölüştüğüm sayının gücüyle karşılaştırırım.

Açıklama:

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

Akçaağaç, 100 bayt (boşluklar dahil)

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:

Okunabilirlik için oldukça aralıklı:

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:

Diğerleri ile aynı fikir; X artık 2 ile bölünemez hale gelene kadar X'i 2'ye bölün, ardından 2 ^ n> x ölçütünü kontrol edin.

Java 1.7, 49 43 bayt

Başka bir 6 byte bycharlie sayesinde tozu.

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

Dene! (ideone)

İki yol, eşit derecede uzun. Buradaki çoğu cevapta olduğu gibi, ifadeler için elbette krediler @Dennis'e gider.

İfadenin sağ tarafının kökü alarak:

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

İfadenin sol tarafına ikisinin gücünü uygulamak:

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

Olumlu bir sayısal değerin 'gerçeği' ve negatif bir değeri 'sahte' olarak temsil etmesine izin verilirse, tek bir baytı tıraş edebilirsiniz:

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

Maalesef, 'İlkel Dönüşümü Daraltma' nedeniyle biri bunu basitçe Java'da yazamaz ve doğru sonuçlar alamaz:

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

Ve 'p' yi genişletme denemesi derleme hatasına neden olacaktır çünkü bitsel operatörler yüzer veya çiftler üzerinde desteklenmez :(

Hy , 37 bayt

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

Çevrimiçi deneyin!

@Dennis 'cevabının limanı.

C (GCC) , 29 30 bayt

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

Çevrimiçi deneyin!

Japt , 12 10 9 bayt

É&1-U)>Uq

Çevrimiçi deneyin!

Dennis 'Jelly Limanı tekrar cevap verdi. - @Shaggy'e 1 teşekkür.

Cjam, 11 bayt

Birçoğumuz gibi, Dennis’in mükemmel çözümünden bahsetmek:

qi_(_W*&2#<

Çevrimiçi deneyin

C (137 bayt)

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

Sadece denedim sonra cevapları okumak için geldi.

Göz önüne alındığında N=k*2^n+1koşullu ile k<2^n( k=1,3,5..ven=1,2,3..

İle n=1biz bir var ktestine kullanılabilir. Yükseldikçe, bunun gibi test etmek niçin birkaç tane daha alırız k's:

n = 1; k = 1

n = 2; k = 1 k = 3

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

...

Bu olasılıklara yineleme biz N Verilen için eğer bir Prouth sayı değildir emin olabilirsiniz elde numara N daha büyüktür ve başka hiçbir yineleme bir maç oldu.nk=1

Yani benim kodum temelde N'yi bulma yolunda "kaba kuvvet" yaratıyor.

Diğer cevapları okuduktan ve N-1'i faktör 2 ile bulup nkoşullu hale getirmek için 2 ile faktörlendirebileceğinizi anladıktan sonra k<2^n, kodumun bu yöntemi kullanarak daha küçük ve daha verimli olabileceğini düşünüyorum.

Denemeye değerdi!

Verilen tüm sayıları ve birkaç "Prouth olmayan" sayıları test etti. İşlev, bir Prouth numarası ise 1, değilse 0 döndürür.

Javascript ES7, 16 bayt

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

Julia cevabımın limanı, @ Dennis'in Jelly cevabının limanı.

2 bayt için teşekkürler @ Charlie kaydedildi!

C # (.NET Core) , 17 bayt

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

Çevrimiçi deneyin!

Port Megatom en C cevap .

LINQ tabanlı bir çözümü denedim, ama bu çok iyiydi.

mürekkep , 60 bayt

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

Çevrimiçi deneyin!

@ DSkoog'un Maple cevabına dayanarak - gönderilecek türünün ilk örneği değildi, ama ilk gördüğüm türden biriydi.

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

x86 Makine Kodu, 15 bayt

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

Bu baytlar EDI, x86 sistemleri için standart System V çağrı kuralını izleyen , kayıttaki giriş argümanını (işaretsiz bir tamsayı) alan ve tüm x86 çağrı kuralları EAXgibi sonuçları kayıt cihazında döndüren bir işlev tanımlar .

Assembler anımsatıcısında:

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)

Çevrimiçi deneyin!

Oldukça basit bir çözüm - ve kavramsal olarak MegaTom'un C versiyonuna benziyor . Aslında, bunu C'ye aşağıdaki gibi yazabilirsiniz:

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

ancak yukarıdaki makine kodu, boyut için optimize edilmek üzere ayarlanmış olsa bile, bir C derleyicisinden alacağınızdan daha iyidir.

Burada sadece "hile", "truthy" değeri olarak -1, "falsy" değeri olarak döndürüyor. Bu numara SBB, 3 byte SETBkomutunun aksine 2 byte komutunun kullanımına izin verir .