จำนวน Prothตั้งชื่อตามFrançois 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 เพื่อกำหนดว่าเป็นหมายเลข Proth หรือไม่ คุณอาจป้อนข้อมูลในรูปแบบที่เหมาะสมและควรส่งออกค่าความจริงหากเป็นหมายเลข Proth และค่าเท็จหากไม่เป็นเช่นนั้น หากภาษาของคุณมีฟังก์ชั่น "ตรวจจับหมายเลข Proth" คุณสามารถใช้ฟังก์ชันนี้ได้

ทดสอบ IO

นี่คือตัวเลข Proth 46 รายการแรกที่มีมากถึง 1,000 ( 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

อินพุตที่ถูกต้องอื่น ๆ ควรให้ค่าที่ผิดพลาด

ตามปกตินี่คือ code-golf ดังนั้นจึงใช้ช่องโหว่มาตรฐานและคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ!

ทฤษฎีจำนวนความสนุก - ข้อเท็จจริงด้าน - หมายเหตุ:

นายกที่ใหญ่ที่สุดที่รู้จักซึ่งไม่ใช่ Mersenne Prime คือ19249 * 2^13018586 + 1ซึ่งเพิ่งเกิดขึ้นเช่นกันกับหมายเลข Proth!

เยลลี่ 5 ไบต์

’&C²>

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

พื้นหลัง

ให้jเป็นจำนวนเต็มบวกอย่างเคร่งครัด j + 1สลับบิตชุดjต่อท้ายทั้งหมดและบิต unset ที่อยู่ติดกัน ยกตัวอย่างเช่น10011 ₂ + 1 = 10100 2

ตั้งแต่~ j = - (j + 1) = -j - 1 , -j = ~ j + 1ดังนั้น-nจะนำไปใช้กับ bitwise ไม่ใช่ของj (ซึ่งจะสลับบิตทั้งหมด ) จึงสลับบิตทั้งหมดก่อนหน้าสุดท้าย1 .

โดยการใช้j & -j - ค่าบิตและของjและ-j - บิตทั้งหมดก่อนและหลังบิตสุดท้ายตั้งค่าเป็นโมฆะ (เนื่องจากไม่เท่ากันในjและ-j ), จึงให้พลังงานสูงสุดของ2ที่แบ่งjเท่า ๆ กัน

สำหรับการป้อนข้อมูลNเราต้องการนำไปใช้ด้านบนเพื่อN - 1เพื่อหา2 ⁿอำนาจสูงสุดของ2ที่แบ่งN - 1 ถ้าm = N - 1 , -m = - (N - 1) = 1 - Nดังนั้น(N - 1) (1 - N)อัตราผลตอบแทน2 n

สิ่งที่เหลือในการทดสอบคือถ้า2 ⁿ > k ถ้าk> 0นี้เป็นจริงและถ้าหาก(2 ⁿ ) ² > k2 ⁿที่เป็นจริงของตัวเองและถ้าหาก(2 ⁿ ) ² ≥ k2 ⁿ + 1 = N

สุดท้ายหาก(2 ⁿ ) ² = N = k2 ⁿ + 1 , 2 ⁿจะต้องเป็นเลขคี่ ( 1 ) เพื่อให้ parities ของทั้งสองฝ่ายสามารถตรงกับหมายความว่าk = 0และN = 1 ในกรณีนี้(N - 1) (1 - N) = 0 & 0 = 0และ((N - 1) (1 - N)) ² = 0 <1 = N

ดังนั้น((N - 1) & (1 - N)) ² > Nจึงเป็นจริงถ้าหากNเป็นหมายเลข Proth

มันทำงานอย่างไร

’&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 ไบต์

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

นี่คือพอร์ตของคำตอบของฉัน Jelly ทดสอบบนIdeone

มันทำงานอย่างไร

ให้jเป็นจำนวนเต็มบวกอย่างเคร่งครัด j + 1สลับบิตชุดjต่อท้ายทั้งหมดและบิต unset ที่อยู่ติดกัน ยกตัวอย่างเช่น10011 ₂ + 1 = 10100 2

ตั้งแต่~ j = - (j + 1) = -j - 1 , -j = ~ j + 1ดังนั้น-nจะนำไปใช้กับ bitwise ไม่ใช่ของj (ซึ่งจะสลับบิตทั้งหมด ) จึงสลับบิตทั้งหมดก่อนหน้าสุดท้าย1 .

โดยการใช้j & -j - ค่าบิตและของjและ-j - บิตทั้งหมดก่อนและหลังบิตสุดท้ายตั้งค่าเป็นโมฆะ (เนื่องจากไม่เท่ากันในjและ-j ), จึงให้พลังงานสูงสุดของ2ที่แบ่งjเท่า ๆ กัน

สำหรับการป้อนข้อมูลNเราต้องการนำไปใช้ด้านบนเพื่อN - 1เพื่อหา2 ⁿอำนาจสูงสุดของ2ที่แบ่งN - 1 ถ้าm = N - 1 , -m = - (N - 1) = 1 - Nดังนั้น(N - 1) (1 - N)อัตราผลตอบแทน2 n

สิ่งที่เหลือในการทดสอบคือถ้า2 ⁿ > k ถ้าk> 0นี้เป็นจริงและถ้าหาก(2 ⁿ ) ² > k2 ⁿที่เป็นจริงของตัวเองและถ้าหาก(2 ⁿ ) ² ≥ k2 ⁿ + 1 = N

สุดท้ายหาก(2 ⁿ ) ² = N = k2 ⁿ + 1 , 2 ⁿจะต้องเป็นเลขคี่ ( 1 ) เพื่อให้ parities ของทั้งสองฝ่ายสามารถตรงกับหมายความว่าk = 0และN = 1 ในกรณีนี้(N - 1) (1 - N) = 0 & 0 = 0และ((N - 1) (1 - N)) ² = 0 <1 = N

ดังนั้น((N - 1) & (1 - N)) ² > Nจึงเป็นจริงถ้าหากNเป็นหมายเลข Proth

ละเว้นความไม่ถูกต้องของจุดลอยตัวซึ่งเทียบเท่ากับรหัสN-1&1-N>N**.5ในการนำไปใช้

Python 2, 23 ไบต์

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

Mathematica, 50 48 45 40 38 35 31 29 29 ไบต์

โดยทั่วไปแล้ว Mathematica จะดูดเมื่อพูดถึง code golf แต่บางครั้งก็มี built-in ที่ทำให้ทุกอย่างดูดีมาก

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}

แก้ไข: จริง ๆ แล้วถ้าฉันขโมยbitwise ของDennisและความคิดฉันสามารถเอามันลงไปที่23 22 20 bytes

Mathematica, 23 22 20 bytes (ขอบคุณA Simmons )

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

05AB1E , 14 10 ไบต์

ขอบคุณEmignaสำหรับการบันทึก 4 ไบต์!

รหัส:

<©Ó¬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 ผลิตภัณฑ์จาก[3, 5]ผลการเข้า15

กรณีการทดสอบนี้เป็น truthy ตั้งแต่16 > 15

Brain-Flak , 460 350 270 266 264 188 176 ไบต์

ลองออนไลน์!

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

คำอธิบาย

โปรแกรมดำเนินการผ่านพลังสองถึงสี่จนกระทั่งพบพลังสองอันมากกว่า N-1 เมื่อพบว่ามันตรวจสอบการหารของ 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จริง Falsy เป็น0หรือเอาต์พุตว่างเปล่า (อินพุตเท่านั้นที่สร้างเอาต์พุตว่างคือ1และ2; ส่วนที่เหลือสร้างอย่างใดอย่างหนึ่ง0หรือ1)

ลองออนไลน์!

คำอธิบาย

ให้xแทนอินพุต Let Yเป็นพลังงานที่ใหญ่ที่สุดของ 2 ที่แบ่งx -1 และZ = ( x -1) / Y โปรดทราบว่าzเป็นเลขคี่โดยอัตโนมัติ ดังนั้นxคือหมายเลข Proth หากy > zหรือเท่ากันถ้า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 ไบต์

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

ลองออนไลน์!

ตรวจสอบการทดสอบทั้งหมดในครั้งเดียว (แก้ไขเล็กน้อย)

คำอธิบาย

Brachylog เป็นอนุพันธ์ของ Prolog เป็นอย่างดีในการพิสูจน์สิ่งต่าง ๆ

ที่นี่เราพิสูจน์สิ่งเหล่านี้:

>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 ไบต์

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

แก้ไข: ขอบคุณ nimi ตอนนี้ 46 ไบต์

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

ECMAScript Regex, 48 43 41 ไบต์

นีลและเอช. พีวิซ regexes (ทั้ง ECMAScript รส) มีความสวยงามในตัวของมันเอง มีวิธีอื่นที่จะทำมันซึ่งโดยบังเอิญระเบียบสวยเป็น 1 ไบต์มากกว่านีลเป็นและตอนนี้กับการเล่นกอล์ฟของปัญหา H.PWiz (ขอบคุณ!) เป็น 1 ไบต์มากขึ้นน้อยกว่า H.PWiz ของ

คำเตือน:แม้จะมีขนาดเล็ก regex นี้ก็มีสปอยเลอร์รายใหญ่ ฉันขอแนะนำให้เรียนรู้วิธีแก้ปัญหาทางคณิตศาสตร์ที่ไม่เหมือนกันใน ECMAScript regex โดยการหาข้อมูลเชิงลึกทางคณิตศาสตร์เบื้องต้นด้วยตนเอง มันเป็นการเดินทางที่น่าสนใจสำหรับฉันและฉันไม่ต้องการที่จะทำลายมันสำหรับใครก็ตามที่อาจต้องการลองด้วยตัวเองโดยเฉพาะผู้ที่มีความสนใจในทฤษฎีจำนวน ดูโพสต์ก่อนหน้านี้สำหรับรายการปัญหาที่แนะนำติดแท็กสปอยเลอร์ติดต่อกันเพื่อแก้ไขทีละรายการ

ดังนั้นไม่ได้อ่านเพิ่มเติมใด ๆ ถ้าคุณไม่ต้องการบางขั้นสูงมายากล regex เอกมากมายสำหรับคุณ หากคุณต้องการถ่ายภาพเพื่อหาเวทมนตร์นี้ด้วยตัวเองฉันขอแนะนำให้เริ่มต้นด้วยการแก้ปัญหาบางอย่างใน ECMAScript regex ดังที่ระบุไว้ในโพสต์ที่ลิงก์ด้านบน

ดังนั้น regex นี้ทำงานค่อนข้างง่าย: มันเริ่มต้นด้วยการลบหนึ่ง จากนั้นก็จะพบว่าปัจจัยที่ใหญ่ที่สุดแปลก k จากนั้นเราหารด้วยk (โดยใช้อัลกอริธึมการหารอธิบายสั้น ๆ ในย่อหน้าที่ติดแท็กสปอยเลอร์ของฉันหมายเลขแฟกโพสต์ regex ) เราลอบทำพร้อมกันยืนยันว่าผลหารมีค่ามากกว่าk หากการแบ่งตรงกันเรามีหมายเลข Proth; ถ้าไม่เราไม่

ฉันสามารถปล่อย 2 ไบต์จาก regex นี้ (43 → 41) โดยใช้เคล็ดลับที่พบโดยGrimyที่สามารถแบ่งส่วนสั้นกว่าในกรณีที่รับประกันหารจะหารมากกว่าหรือเท่ากับตัวหาร

^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

Regex (ECMAScript), 40 38 ไบต์

-2 ไบต์ต้องขอบคุณ Deadcode

^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และส่งคืน 1 หากเป็นหมายเลข Proth เป็น 0

การใช้

   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 กับหมายเลข unary โดยตรงกับ regex เดียว ปัจจุบันนี้ใช้เวลาฉัน 47 ไบต์, มากกว่า 7 ไบต์รหัส Retina ของฉันในปัจจุบันสำหรับการตรวจสอบว่าหมายเลข unary เป็นหมายเลข Proth:

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

ECMAScript Regex ขนาด 42 ไบต์

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

ลองออนไลน์!(ใช้ Retina)

ฉันจะลบ 1, หารด้วยจำนวนคี่ที่เป็นไปได้มากที่สุดk, จากนั้นตรวจสอบอย่างน้อยk+1ก็เหลือ

แต่กลับกลายเป็นว่า regex ของฉันเป็นอย่างมากคล้ายกับที่นีลจะช่วยให้ในตอนท้ายของเขาคำตอบ ผมใช้แทน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
([({}[{}(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

Maple ขนาด 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:

เว้นระยะอย่างดีสำหรับ readbility:

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

Java 1.7, 49 43 ไบต์

ฝุ่นอีก 6 ไบต์ต้องขอบคุณ @charlie

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

ลองมัน! (ideone)

สองวิธียาวเท่ากัน เช่นเดียวกับคำตอบส่วนใหญ่ที่นี่เครดิตไปที่ @Dennis แน่นอนสำหรับการแสดงออก

การหยั่งรากของด้านขวาของนิพจน์:

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

การใช้กำลังสองกับด้านซ้ายและขวาของนิพจน์:

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

สามารถลบออกทีละหนึ่งไบต์หากค่าตัวเลขบวกได้รับอนุญาตให้แสดง 'ความจริง' และค่าลบ 'เป็นเท็จ':

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

น่าเสียดายเนื่องจากมี'การแปลงดั้งเดิมที่แคบ'ไม่สามารถเขียนสิ่งนี้ใน Java และรับผลลัพธ์ที่ถูกต้อง:

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

และความพยายามใด ๆ ที่จะขยาย 'p' จะทำให้เกิดข้อผิดพลาดในการคอมไพล์เนื่องจากตัวดำเนินการระดับบิตไม่ได้รับการสนับสนุนเช่นลอยหรือเพิ่มเป็นสองเท่า :(

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

ลองออนไลน์!

Port of Dennis 'Jelly ตอบกลับอีกครั้ง - 1 ต้องขอบคุณ @Shaggy

Cjam, 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

...

ทำซ้ำผ่านความเป็นไปได้ที่เราสามารถมั่นใจได้ว่าไม่มีไม่ได้เป็นจำนวน Prouth ถ้าให้nk=1จำนวนที่ได้รับมีขนาดใหญ่กว่า N และไม่ซ้ำอื่น ๆ การแข่งขัน

ดังนั้นรหัสของฉันก็คือ "กำลังดุร้าย" ในการหาเอ็น

หลังจากอ่านคำตอบอื่น ๆ และตระหนักว่าคุณสามารถแยก N-1 ด้วย 2 เพื่อค้นหาnและทำตามเงื่อนไขได้k<2^nฉันคิดว่าโค้ดของฉันอาจเล็กลงและมีประสิทธิภาพมากขึ้นโดยใช้วิธีนี้

มันก็คุ้มค่าที่จะลอง!

ทดสอบตัวเลขทั้งหมดที่ให้มาและตัวเลข "ที่ไม่ใช่ Prouth" จำนวนน้อย ฟังก์ชันส่งคืน 1 ถ้าตัวเลขเป็นตัวเลข Prouth และ 0 ถ้าไม่ใช่

Javascript ES7, 16 ไบต์

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

พอร์ตของคำตอบ Julia ของฉันซึ่งเป็นพอร์ตของคำตอบของ @ Dennis's Jelly

ขอบคุณ @Charlie บันทึก 2 ไบต์!

C # (. NET Core) 17 ไบต์

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

ลองออนไลน์!

ท่าเรือMegaTom คำตอบของ

ฉันพยายามใช้ LINQ แต่เป็นสิ่งที่ดีเกินไป

หมึก 60 ไบต์

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

ลองออนไลน์!

จากคำตอบ Maple ของ @ DSkoog - ไม่ใช่โพสต์แรกที่ถูกโพสต์ แต่เป็นประเภทแรกที่ฉันเห็น

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 รหัสเครื่อง 15 ไบต์

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

ไบต์เหล่านี้กำหนดฟังก์ชั่นที่รับอาร์กิวเมนต์อินพุต (จำนวนเต็มไม่ได้ลงนาม) ในEDIรีจิสเตอร์ตามระเบียบการเรียก System V มาตรฐานสำหรับระบบ x86 และส่งคืนผลลัพธ์ในEAXรีจิสเตอร์เช่นเดียวกับทั้งหมดการประชุมการเรียกใช้ x86

ในตัวช่วยจำแอสเซมเบลอร์:

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 ได้ดังนี้:

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

แต่รหัสเครื่องด้านบนนั้นดีกว่าสิ่งที่คุณจะได้รับจากคอมไพเลอร์ C แม้ว่ามันจะตั้งค่าให้ปรับขนาดให้เหมาะสมที่สุดก็ตาม

"โกง" เท่านั้นที่นี่จะคืนค่า -1 เป็นค่า "ความจริง" และ 0 เป็นค่า "เท็จ" เคล็ดลับนี้จะช่วยให้การใช้งานของ 2 ไบต์SBBคำแนะนำเมื่อเทียบกับ 3 ไบต์SETBการเรียนการสอน