Proth 번호 프랑수아 프로스 따서는 다음과 같이 표현 될 수있는 수이며

N = k * 2^n + 1

k홀수 양의 정수는 어디에 있고 다음과 n같은 양의 정수는 어디에 있습니까 2^n > k? 좀 더 구체적인 예를 사용합시다. 3은 3으로 쓸 수 있기 때문에 Proth 번호입니다.

(1 * 2^1) + 1

그리고 2^1 > 1만족된다. 5 또한 다음과 같이 쓸 수 있기 때문에 Proth 번호입니다

(1 * 2^2) + 1

그리고 2^2 > 1만족된다. 그러나 7은 하지 형태를 쓸 수있는 유일한 방법이 있기 때문에 Proth 번호 N = k * 2^n + 1입니다

(3 * 2^1) + 1

그리고 2^1 > 3만족하지 않습니다.

당신의 도전은 매우 간단합니다 : 당신은 postive integer가 주어지면 그것이 Proth 수인지 아닌지를 결정하는 프로그램이나 함수를 작성해야합니다. 합리적인 형식으로 입력을받을 수 있으며, Proth 번호 인 경우 정확한 값을, 그렇지 않은 경우 잘못된 값을 출력해야합니다. 언어에 "Proth-number detection"기능이있는 경우 사용할 수 있습니다.

IO 테스트

다음은 1000까지의 첫번째 46 Proth 수입니다. ( 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

다른 모든 유효한 입력은 잘못된 값을 제공해야합니다.

평소와 같이 이것은 코드 골프이므로 표준 허점이 적용되며 바이트 단위의 최단 답변이 이깁니다!

숫자 이론의 재미있는 사실 참고 사항 :

메르 센 프라임 이 아닌 가장 큰 알려진 프라임 19249 * 2^13018586 + 1은 Proth 번호이기도합니다!

젤리 , 5 바이트

’&C²>

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

배경

j를 양의 정수로 하자 . j + 1 은 j의 모든 후행 설정 비트 와 인접 비 설정 비트를 토글합니다 . 예를 들어, 10011 ₂ + 1 = 10100 ₂ 입니다.

이후 ~ J = - (j + 1) = -j - 1 , -j ~ = J + 1 , 그래서 -n NOT의 비트에 상기 적용 J (토글 모든 따라서 마지막 전에 모든 비트를 토글 링, 비트) 1 .

취하여 J 및 -j를 비트 단위 AND의 - J 및 -j - 모든 비트 전에 마지막 세트 비트 (의 불균등 때문에 무효 후 J 및 -j를 따라서 최고 전력 산출) 이 그 분할의 J를 균일.

입력의 N , 우리는 위의를 적용 할 1 - N 찾기 위해 2 ^N 의 가장 높은 전원 이 그 분할 (1) - N을 . 경우 1 - m = N , -m = - (N - 1) = 1 - N , 그래서 (N - 1) (1 - N) 수득 2 ^N을 .

테스트해야 할 것은 2 ⁿ > k 입니다. 경우 K> 0 이 참의 경우에만, (2 ^N ) ² > K2 ^N , 경우에만, 자체 참인 (2 ^N ) ² ≥ K2 ^{, N} + N = 1 .

마지막으로, 만약 (2 ^N ) ² = K2 = N ^{, N} + 1 , (2) ^n이 홀수이어야 ( 1 ) 양면의 패리티가 일치 할 수 있도록, 암시 (K) = 0 및 N = 1 . 이 경우 (N-1) & (1-N) = 0 & 0 = 0 및 ((N-1) & (1-N)) ² = 0 <1 = N 입니다.

따라서 N 이 Proth 번호 인 경우에만 ((N-1) & (1-N)) ² > N 이 참 입니다.

작동 원리

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

파이썬, 22 바이트

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

이것은 나의 젤리 답변 의 포트입니다 . Ideone에서 테스트하십시오 .

작동 원리

j를 양의 정수로 하자 . j + 1 은 j의 모든 후행 설정 비트 와 인접 비 설정 비트를 토글합니다 . 예를 들어, 10011 ₂ + 1 = 10100 ₂ 입니다.

이후 ~ J = - (j + 1) = -j - 1 , -j ~ = J + 1 , 그래서 -n NOT의 비트에 상기 적용 J (토글 모든 따라서 마지막 전에 모든 비트를 토글 링, 비트) 1 .

취하여 J 및 -j를 비트 단위 AND의 - J 및 -j - 모든 비트 전에 마지막 세트 비트 (의 불균등 때문에 무효 후 J 및 -j를 따라서 최고 전력 산출) 이 그 분할의 J를 균일.

입력의 N , 우리는 위의를 적용 할 1 - N 찾기 위해 2 ^N 의 가장 높은 전원 이 그 분할 (1) - N을 . 경우 1 - m = N , -m = - (N - 1) = 1 - N , 그래서 (N - 1) (1 - N) 수득 2 ^N을 .

테스트해야 할 것은 2 ⁿ > k 입니다. 경우 K> 0 이 참의 경우에만, (2 ^N ) ² > K2 ^N , 경우에만, 자체 참인 (2 ^N ) ² ≥ K2 ^{, N} + N = 1 .

마지막으로, 만약 (2 ^N ) ² = K2 = N ^{, N} + 1 , (2) ^n이 홀수이어야 ( 1 ) 양면의 패리티가 일치 할 수 있도록, 암시 (K) = 0 및 N = 1 . 이 경우 (N-1) & (1-N) = 0 & 0 = 0 및 ((N-1) & (1-N)) ² = 0 <1 = N 입니다.

따라서 N 이 Proth 번호 인 경우에만 ((N-1) & (1-N)) ² > N 이 참 입니다.

부동 소수점 부정확성을 무시하면 N-1&1-N>N**.5구현 의 코드와 동일합니다 .

파이썬 2, 23 바이트

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

Mathematica, 50 48 45 40 38 35 31 29 바이트

Mathematica는 일반적으로 코드 골프와 관련하여 짜증이 나지만 때로는 물건을 정말 멋지게 만드는 내장 기능이 있습니다.

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

시험:

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}

편집 : 실제로, Dennis 의 비트 및 아이디어를 훔치면 23 22 20 바이트 로 줄일 수 있습니다 .

Mathematica, 23 22 20 바이트 ( Simmons 덕분 에 )

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

05AB1E , 14 10 바이트

4 바이트를 절약 한 Emigna 에게 감사드립니다 !

암호:

<©Ó¬oD®s/›

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

설명:

설명을 위해 숫자 241을 사용하십시오 . 먼저로 숫자를 하나씩 줄입니다 <. 결과는 240 입니다. 이제를 사용하여 주요 요인 (중복 포함)을 계산합니다 Ò. 주요 요인은 다음과 같습니다.

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

우리는 그것들을 두 부분으로 나누었습니다. 를 사용하여 2Q·0K두 가지 목록을 얻습니다.

[2, 2, 2, 2]

를 사용 ®2K하면 나머지 숫자 목록을 얻습니다.

[3, 5]

마지막으로 두 제품을 모두 가져갑니다. [2, 2, 2, 2]결과 16 . 15[3, 5] 결과 의 곱 .

이 테스트 사례는 16 > 15 이래로 확실 합니다.

뇌 플랙 , 460 350 270 266 264 188 176 바이트

온라인으로 사용해보십시오!

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

설명

프로그램은 N-1보다 큰 2의 거듭 제곱을 찾을 때까지 2와 4의 거듭 제곱을 거칩니다. 그것이 발견되면 모듈로를 사용하여 2의 거듭 제곱으로 N-1의 분할 성을 확인하고 결과를 출력합니다.

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

이 프로그램은 스택이 깨끗하지 않습니다. 여분의 4 바이트를 추가하면 스택을 깨끗하게 만들 수 있습니다.

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

MATL , 9 바이트

qtYF1)EW<

진실한 결과물은 1입니다. 거짓 0또는 출력 이 비어 있습니다. (빈 출력을 생성하는 유일한 입력은 다음 1과 2상기 나머지 생산하거나 0또는 1).

온라인으로 사용해보십시오!

설명

하자 x는 입력을 나타낸다. y를 x -1 을 나누고 z = ( x -1) / y 를 나누는 최대 2의 거듭 제곱 이라고합시다 . 참고 Z가 자동 홀수이다. 그런 다음 , X가 Proth 번호 경우에만, Y > Z , 또는 동일하다면 예 ² > 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 바이트

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

온라인으로 사용해보십시오!

모든 테스트 케이스를 한 번에 확인하십시오. (약간 수정되었습니다.)

설명

Prolog의 파생 상품 인 Brachylog는 사물을 입증하는 데 매우 능숙합니다.

여기서 우리는 다음을 증명합니다.

>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

하스켈, 55 46 바이트

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

편집 : 이제 46 바이트 인 nimi 덕분에

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

ECMAScript 정규식, 48 43 41 바이트

Neil 's와 H.PWiz의 정규 표현식 (ECMAScript 맛)도 그 자체로 아름답습니다. 그것을 할 수있는 또 다른 방법이 있습니다. 꽤 깔끔한 우연의 일치로 Neil보다 1 바이트 더 많았으며 이제 H.PWiz의 제안 된 골프 (감사합니다!)를 사용하면 H.PWiz보다 1 바이트 더 작습니다.

경고 : 이 정규식의 작은 크기에도 불구하고 주요 스포일러 가 포함되어 있습니다 . 초기 수학적 통찰력을 독립적으로 파악하여 ECMAScript 정규식에서 단항 수학 문제를 해결하는 방법을 배우는 것이 좋습니다. 그것은 나를위한 매혹적인 여행이었습니다. 저는 스스로 그것을 시도하고 싶을 수도있는 사람, 특히 수 이론에 관심이있는 사람들을 위해 그것을 망치고 싶지 않습니다. 스포일러 태그가 붙은 권장 문제를 하나씩 해결하기위한 연속적인 문제 목록은 이 게시물 을 참조하십시오 .

따라서 고급 단항 정규식 마법을 원하지 않는다면 더 이상 읽지 마십시오 . 이 마법을 스스로 파악하는 데 총력을 기울이고 싶다면 위에 링크 된 게시물에 요약 된 ECMAScript 정규식의 일부 문제를 해결하는 것이 좋습니다.

따라서이 정규식은 매우 간단하게 작동합니다. 그런 다음 가장 큰 홀수 인 k를 찾습니다 . 그런 다음 우리는 k로 나눕니다 ( 나누기 정규 표현식 post 의 스포일러 태그 단락에 간략하게 설명 된 나누기 알고리즘 사용 ). 우리는 결과 몫이 k 보다 크다는 것을 동시에 주장합니다 . 부서가 일치하면 Proth 번호가 있습니다. 그렇지 않다면 그렇지 않습니다.

몫이 제수보다 크거나 같은 경우 Grimy 가 발견 한 트릭을 사용 하여이 정규식 (43 → 41)에서 2 바이트를 삭제할 수있었습니다 .

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

온라인으로 사용해보십시오!

 # 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*$
 

줄리아, 16 바이트

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

답변과 골프 팁에 대한 @Dennis의 크레딧!

R, 52 50 바이트

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

프로그램은 분할함으로써 시작된다 N-1(여기서는 호출 P하고 x)에 의해 2찾기하기 위해 가능한 길게 2^n남게 방정식의 일부를 k=(N-1)/2^n다음 연산 어떠했는지 여부 k떨어진다 2^n는 사실 것을 사용2^n>x/2^n <=> (2^n)²>x <=> 2^2n>x

정규식 (ECMAScript), 40 38 바이트

Deadcode 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

댓글 버전 :

# 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 바이트

%:<<:AND-.

@Dennis의 비트 단위 솔루션을 기반으로 합니다 .

입력을 n받아서 Proth 번호가 0이면 1을 반환합니다.

용법

   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

설명

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

레티 나 0.8.2 , 47 바이트

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

단항으로 변환합니다.

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

이진으로 변환합니다.

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

Proth 생성 공식을 반복해서 거꾸로 실행하십시오.

^10*1$

Proth 생성 공식의 기본 사례와 일치합니다.

편집 : 실제로 단일 정규 표현식으로 단항 번호와 Proth 번호를 직접 일치시키는 것이 가능하다고 생각합니다. 이것은 현재 단항 숫자가 Proth 숫자인지 여부를 확인하기 위해 47 바이트, 현재 Retina 코드보다 7 바이트 더 걸립니다.

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

ECMAScript 정규식, 42 바이트

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

온라인으로 사용해보십시오! (레티 나 사용)

나는 본질적으로 1을 빼고 가능한 가장 큰 홀수로 나눈 k다음 적어도 k+1남아 있는지 확인합니다 .

내 정규 표현식은 Neil이 그의 답변 끝에 제공 한 것과 매우 유사하다는 것이 밝혀졌습니다 . x(xx)*대신에 사용 합니다 (x*)\2x. 그리고 나는 더 짧은 방법을 사용하여 확인합니다.k < 2^n

Brain-Flak , 128 바이트

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

온라인으로 사용해보십시오!

이전 Brain-Flak 솔루션 과는 매우 다른 알고리즘을 사용했습니다 .

기본적으로 짝수에 도달 할 때까지 2로 반올림합니다. 그런 다음 마지막 나눗셈의 결과를 두 나누기와 나눈 횟수의 거듭 제곱과 비교합니다.

설명:

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

메이플, 100 바이트 (공백 포함)

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:

가독성이 좋은 공간 :

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:

다른 사람들과 같은 생각; X를 더 이상 2로 나눌 수 없을 때까지 X를 2로 나눈 다음 기준 2 ^ n> x를 확인하십시오.

자바 1.7, 49 43 바이트

@charlie 덕분에 또 다른 6 바이트의 먼지가 발생합니다.

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

시도 해봐! (아이디어)

두 가지 방법으로 똑같이 길다. 대부분의 답변과 마찬가지로 크레딧은 표현을 위해 @Dennis로 이동합니다.

표현의 오른쪽에서 뿌리 내리기 :

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

표현식의 왼쪽에 2의 거듭 제곱 적용 :

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

양수 값이 'truthy'를 나타내고 음수 값이 'falsy'인 경우 단일 바이트를 제거 할 수 있습니다.

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

불행히도 'Narrowing Primitive Conversion'으로 인해 Java로 간단히 작성하고 올바른 결과를 얻을 수는 없습니다.

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

그리고 'p'를 넓히려 고 시도하면 비트 연산자가 float 또는 double에서 지원되지 않기 때문에 컴파일 오류가 발생합니다.

Hy , 37 바이트

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

온라인으로 사용해보십시오!

@Dennis 포트 답변.

C (gcc) , 29 30 바이트

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

온라인으로 사용해보십시오!

Japt , 12 10 9 바이트

É&1-U)>Uq

온라인으로 사용해보십시오!

Dennis Port Jelly가 다시 대답합니다. -@Shaggy에게 감사드립니다.

잼, 11 바이트

우리 중 많은 사람들과 마찬가지로 Dennis의 탁월한 솔루션을 피기 백합니다.

qi_(_W*&2#<

온라인으로 사용해보십시오

C (137 바이트)

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

내가 시도한 후에 만 ​​답을 읽게되었습니다.

고려 N=k*2^n+1의 조건과 k<2^n( k=1,3,5..와n=1,2,3..

함께 n=1우리는 하나가 k테스트에 사용할 수 있습니다. 우리가 증가함에 따라 다음 과 같이 테스트 할 n것이 조금 더 있습니다 k's.

n = 1; k = 1

n = 2; k = 1 k = 3

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

...

그 가능성을 반복하는 것은 우리는 N이 주어진위한 경우 Prouth 번호가 아닙니다 확신 할 수 얻을 수는 N보다 크고 다른 반복이 일치하지 않았다.nk=1

그래서 내 코드는 기본적으로 N을 찾는 길을 "브 루트 포스"합니다.

다른 답변을 읽고 2로 N-1을 인수 분해 n하여의 조건 을 찾은 다음 조건을 만들 수 있음을 알게 k<2^n되면이 방법을 사용하여 코드가 더 작고 효율적 일 수 있다고 생각합니다.

시도해 볼 가치가있었습니다!

주어진 모든 숫자와 "비정품"숫자를 테스트했습니다. 함수는 숫자가 Prouth 숫자이면 1을 반환하고 그렇지 않으면 0을 반환합니다.

자바 스크립트 ES7, 16 바이트

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

@Dennis의 Jelly 답변 포트 인 My Julia 답변 포트.

2 바이트 절약 된 @Charlie에게 감사드립니다!

C # (. NET 코어) , 17 바이트

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

온라인으로 사용해보십시오!

MegaTom의 C 답변 포트 .

LINQ 기반 솔루션을 시도했지만 너무 좋았습니다.

잉크 , 60 바이트

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

온라인으로 사용해보십시오!

@DSkoog의 메이플 답변을 기반으로 -게시 된 최초의 것은 아니지만 내가 본 종류 중 첫 번째였습니다.

언 골프

= 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 머신 코드, 15 바이트

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

이 바이트 EDI는 x86 시스템에 대한 표준 System V 호출 규칙 에 따라 레지스터 에서 입력 인수 (부호없는 정수)를 취하는 함수를 정의하고 모든 x86 호출 규칙 EAX과 같이 레지스터에 결과를 반환합니다 .

어셈블러 니모닉에서 :

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)

온라인으로 사용해보십시오!

이것은 매우 간단한 솔루션이며 개념적으로 MegaTom의 C 버전 과 유사합니다 . 실제로 C에서 다음과 같이 작성할 수 있습니다.

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

그러나 위의 기계 코드는 크기를 최적화하도록 설정되어 있어도 C 컴파일러에서 얻는 것보다 더 뛰어납니다.

여기서 유일한 "치트"는 -1을 "거짓"값으로, 0을 "거짓"값으로 반환합니다. 이 트릭을 사용하면 SBB3 바이트 명령어가 아닌 2 바이트 명령어를 사용할 수 있습니다 SETB.