มีวิธีการที่ชาญฉลาดในการพิจารณาว่าตัวเลขเป็นกำลัง 2 นั่นไม่ใช่ปัญหาที่น่าสนใจอีกต่อไปดังนั้นลองพิจารณาว่าจำนวนเต็มที่กำหนดเป็นกำลังจำนวนเต็ม-2หรือไม่ ตัวอย่างเช่น:

-2 => yes: (-2)¹
-1 => no
0 => no
1 => yes: (-2)⁰
2 => no
3 => no
4 => yes: (-2)²

กฎระเบียบ

• คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่นและใช้วิธีการมาตรฐานใด ๆ ในการรับอินพุตและจัดเตรียมเอาต์พุต

• อินพุตของคุณเป็นจำนวนเต็มเดียวและเอาต์พุตต้องเป็นค่าจริงหากจำนวนเต็มเป็นกำลังของเลขจำนวนเต็ม -2 และค่าเท็จเป็นอย่างอื่น ไม่อนุญาตให้ใช้เอาต์พุตอื่น (เช่นข้อความเตือน)

• ใช้กฎโอเวอร์โฟลว์จำนวนเต็มตามปกติ: วิธีแก้ปัญหาของคุณจะต้องสามารถทำงานกับจำนวนเต็มขนาดใหญ่ตามอำเภอใจในภาษาของคุณ (หรืออาจจะเป็นจริง) ในรูปแบบสมมุติซึ่งจำนวนเต็มทั้งหมดถูก จำกัด โดยค่าเริ่มต้น แต่หากโปรแกรมของคุณล้มเหลวในทางปฏิบัติ ไม่รองรับจำนวนเต็มที่มีขนาดใหญ่ซึ่งไม่ได้ทำให้โซลูชันไม่ถูกต้อง

• คุณอาจใช้ภาษาการเขียนโปรแกรมใด ๆแต่โปรดทราบว่าช่องโหว่เหล่านี้เป็นสิ่งต้องห้ามตามค่าเริ่มต้น

สภาพการชนะ

นี่คือการประกวดcode-golf : คำตอบที่มีจำนวนไบต์น้อยที่สุด (ในการเข้ารหัสที่คุณเลือก) เป็นผู้ชนะ

Mathematica ขนาด 22 ไบต์

EvenQ@Log2@Max[#,-2#]&

ลองออนไลน์! (ใช้ Mathics แทนซึ่งโซลูชันนี้ใช้งานได้ด้วย)

ฉันพยายามหาวิธีแก้ปัญหาด้วยตัวดำเนินการระดับบิตในขณะที่หนึ่งมีอยู่แน่นอนฉันจบลงด้วยการค้นหาสิ่งที่อาจจะง่ายกว่า:

• Max[#,-2#]คูณอินพุตด้วย-2ถ้ามันเป็นลบ การคูณด้วยปัจจัยอีกตัวของ-2จะไม่เปลี่ยนแปลงว่าค่านั้นเป็นกำลังของ-2หรือไม่ แต่ตอนนี้ทุกอำนาจคี่-2ได้รับกลายเป็นอำนาจแม้แต่-2
• แต่แม้แต่พาวเวอร์ของ-2ยังเป็นพาวเวอร์2ดังนั้นเราสามารถใช้ง่ายLog2@...และตรวจสอบว่าผลที่ได้เป็นจำนวนเต็ม (เพื่อตรวจสอบว่ามันเป็นพลังของ2 ) สิ่งนี้จะช่วยประหยัดสองไบต์ไปแล้วLog[4,...](อีกวิธีหนึ่งในการดูกำลังคู่ของ-2 )
• เป็นโบนัสเพิ่มการตรวจสอบว่าค่าเป็นจำนวนเต็มแม้จะสั้นกว่าเพียงแค่การตรวจสอบไม่ว่าจะเป็นจำนวนเต็ม: เราสามารถบันทึกสามไบต์มากขึ้นโดยใช้แทนEvenQIntegerQ

เยลลี่ 5 ไบต์

æḟ-2=

ลองออนไลน์!

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

æḟ-2=  Main link. Argument: n

æḟ-2   Round n towards 0 to the nearest power of -2.
    =  Test if the result is equal to n.

Pythonขนาด 46 ไบต์

-2 ไบต์ขอบคุณ @ovs

def g(x):
 while x%-2==0!=x:x/=-2
 return x==1

ฟังก์ชั่นที่มีการใช้งาน:

g(4) # put your number between the brackets

ลองออนไลน์!

เยลลี่ 6 ไบต์

b-2S⁼1

ลองออนไลน์!

นี้จะขึ้นอยู่กับวิธีการที่วุ้นแปลงจำนวนเต็มNใด ๆ โดยพลฐานBทำเช่นนั้นโดยการแปลงNให้กับอาร์เรย์ซึ่งในแต่ละจำนวนเต็มเป็นหลักdของ ( N ) _Bซึ่งสามารถมีค่า0≤ V _d < B . ที่นี่เราจะตัวเลข 0 ดัชนีจากขวาเพื่อให้ทุกบาทเพิ่มV _d B ^dในรูปแบบN V _d < B ⇔ V _d B ^d < BB ^d = B ^{d +1}ดังนั้นจึงเป็นไปได้Nมีเพียงหนึ่งการแสดงที่ไม่ซ้ำกันถ้าเราไม่สนใจ 0s ชั้นนำใน ( N ) B

ที่นี่d = อินพุตB = -2 N = B ^d = 1 B ^d = V _d B ^d ⇔1 = V _d ⇔ V _d = 1 และเนื่องจากเราไม่ได้เพิ่มพลังทวีคูณของBอื่น ๆVทุกตัวจะเป็น 0 ในขณะนี้ อาร์เรย์ควรเป็น 1 การต่อเชื่อมกับd 0s เนื่องจากดัชนี Jelly 1 จากด้านซ้ายเราควรตรวจสอบว่าองค์ประกอบที่ 1 ของอาร์เรย์เป็น 1 และองค์ประกอบอื่น ๆ ทั้งหมดเป็น 0

อืม ... ดีทั้งหมดใช่มั้ย ไม่มี? เกิดอะไรขึ้น? โอ้ใช่ฉันมีความคิดที่ดีกว่า! อันดับแรกเรามาหาผลรวมของจำนวนเต็มทั้งหมดในอาเรย์โดยถือว่ามันเป็นอาร์เรย์จำนวนเต็มไม่ใช่จำนวนในฐาน -2 ถ้าเป็น 1 ก็หมายความว่ามีเพียง 1 ตัวเท่านั้นและจำนวนเต็มอื่น ๆ ทั้งหมดคือ 0 เนื่องจากไม่มีเลขศูนย์นำหน้ายกเว้นในกรณีที่ 0 _-2(โดยที่ผลรวมจะเป็น 0 ≠ 1 ต่อไป) จำนวนเต็มที่ 1 จะต้องไม่เป็นศูนย์ จำนวนเต็มที่ไม่เป็นศูนย์ในอาเรย์คือ 1 ดังนั้นมันจะต้องเป็นค่าแรก ดังนั้นนี่เป็นกรณีเดียวที่ผลรวมของจำนวนเต็มทั้งหมดในอาร์เรย์จะเป็น 1 เนื่องจากผลรวมที่น้อยที่สุดที่เป็นไปได้ของคู่ของจำนวนเต็มบวกคือΣ {1,1} = 2 เนื่องจากจำนวนเต็มบวกที่น้อยที่สุดคือ 1 . จำนวนเต็มทุกตัวในการแทนค่าฐานไม่ใช่ค่าลบดังนั้นวิธีเดียวที่ผลรวมคือ 1 จะมีเพียง 1 ตัวเท่านั้นและจำนวนเต็มอื่น ๆ ทั้งหมดคือ 0 ดังนั้นเราสามารถตรวจสอบว่าผลรวมของจำนวนเต็มทั้งหมดใน อาร์เรย์คือ 1

นี่คือสิ่งที่รหัสทำ:

b-2S⁼1 Main link. Arguments: d
b-2    Convert d to base -2.
   S   Take the sum.
    ⁼1 Check if the sum is equal to 1.

Python 2 , 35 34 32 ไบต์

f=lambda n:n==1or n!=n%2<f(n/-2)

ลองออนไลน์!

Python 2 , 98 50 ไบต์

lambda x:x*(x&-x==abs(x))*((x<0)^x.bit_length()&1)

ลองออนไลน์!

Excel, 40 36 ไบต์

^{บันทึก 4 ไบต์โดย CallumDA}

Excel สามารถทำได้อย่างแน่นอน แต่การแก้ไขข้อผิดพลาดจะเพิ่ม 11 ไบต์

=IFERROR(-2^IMREAL(IMLOG2(A1)),1)=A1

A1ป้อนข้อมูลอยู่ในมือถือ ผลลัพธ์คือTRUEหรือFALSE

หากได้รับอนุญาตให้ส่งคืนFALSEหรือเกิด#NUM!ข้อผิดพลาดสำหรับค่าเท็จมันจะเป็นเพียง 25 ไบต์:

=-2^IMREAL(IMLOG2(A1))=A1

05AB1E , 8 ไบต์

Y(IÄÝm¹å

ลองออนไลน์! หรือเป็นชุดทดสอบ

คำอธิบาย

Y(         # push -2
  IÄÝ      # push range [0 ... abs(input)]
     m     # element-wise power
      ¹å   # check if input is in the resulting list

JavaScript (ES6), 37 28 24 ไบต์

f=x=>!x|x%2?x==1:f(x/-2)

บันทึกแล้ว 4 ไบต์ขอบคุณ Arnauld

f=x=>!x|x%2?x==1:f(x/-2)

console.log(f(-2));
console.log(f(-1));
console.log(f(0));
console.log(f(1));
console.log(f(2));
console.log(f(3));
console.log(f(4));

C (gcc) , 34 29 ไบต์

f(n){n=n%2?n==1:f(n?n/-2:2);}

ลองออนไลน์!

MATL , 9 8 ไบต์

2_y|:q^m

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

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

พิจารณาการป้อนข้อมูล-8เป็นตัวอย่าง

2_    % Push -2
      % STACK: -2
y     % Implicit input. Duplicate from below
      % STACK: -8, -2, -8
|     % Absolute value
      % STACK: -8, -2, 8
:     % Range
      % STACK: -8, -2, [1 2 3 4 5 6 7 8]
q     % Subtract 1, element-wise
      % STACK: -8, -2, [0 1 2 3 4 5 6 7]
^     % Power, element-wise
      % STACK: -8, [1 -2 4 -8 16 -32 64 -128]
m     % Ismember. Implicit display
      % STACK: 1

อ็อกเทฟ 28 ไบต์

@(n)any((-2).^(0:abs(n))==n)

สิ่งนี้นิยามฟังก์ชันที่ไม่ระบุชื่อ วิธีการคล้ายกับที่อยู่ในคำตอบ MATL ของฉัน

ลองออนไลน์!

PHP, 41 ไบต์

for(;$argn%-2==0;)$argn/=-2;echo$argn==1;

PHP, 52 ไบต์

echo($l=log(abs($argn),2))==($i=$l^0)&&$argn>0^$i%2;

PHP, 64 ไบต์

ทำงานกับ Regex

echo preg_match("#^".($argn>0?1:"1+0")."(00)*$#",decbin($argn));

Python 3, 34 ไบต์

lambda n:n==(-2)**~-n.bit_length()

JavaScript (ES6), 21 ไบต์

ฟังก์ชั่น recursive ว่าผลตอบแทนหรือ0true

f=n=>n==1||n&&f(n/-2)

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

นี่ไม่รวมการทดสอบที่ชัดเจนใด ๆ - เช่นnเป็นเลขคี่หรือabs(n)มีค่าน้อยกว่าหนึ่ง - เพื่อหยุดการเรียกซ้ำก่อนกำหนดเมื่ออินพุตไม่ใช่กำลังที่แน่นอนของ -2

เราออกเฉพาะเมื่อnจะเท่ากับอย่างใดอย่างหนึ่งหรือ10

สิ่งนี้ใช้งานได้ แต่เนื่องจากการลอยตัวของ IEEE-754 ในที่สุดจะถูกปัดเศษเป็น0หารด้วย 2 (หรือ -2) เวลาเพียงพอเนื่องจากการคำนวณทางคณิตศาสตร์ต่ำเกินไป

กรณีทดสอบ

f=n=>n==1||n&&f(n/-2)

console.log(f(-2));
console.log(f(-1));
console.log(f(0));
console.log(f(1));
console.log(f(2));
console.log(f(3));
console.log(f(4));

C (gcc) , 33 ไบต์

f(n){return n%2?n==1:n&&f(n/-2);}

ลองออนไลน์!

Java 7, 55 ไบต์

boolean c(int n){return n==0?0>1:n%-2==0?c(n/-2):n==1;}

คำอธิบาย:

boolean c(int n){  // Method with integer parameter and boolean return-type
  return n==0 ?    //  If n is zero:
    0>1//false     //   Return false
   : n%-2==0 ?     //  Else-if n mod -2 is zero:
    c(n/-2)        //   Recursive call for the input divided by -2
   :               //  Else:
    n==1;          //   Return if n is one
}                  // End of method

รหัสทดสอบ:

ลองที่นี่

class M{
  static boolean c(int n){return n==0?0>1:n%-2==0?c(n/-2):n==1;}

  public static void main(String[] a){
    for(int i = -2; i <= 4; i++){
      System.out.println(i + ": " + c(i));
    }
  }
}

เอาท์พุท:

-2: true
-1: false
0: false
1: true
2: false
3: false
4: true

Haskell, 24 23 ไบต์

f 0=0
f 1=1
f n=f(-n/2)

กำหนดฟังก์ชั่นfที่ส่งกลับ1สำหรับพลังของ -2 และ0อื่น ๆ

รุ่นแข็งแรงเล่นกอล์ฟของการส่งครั้งแรกของฉันกับความท้าทายอื่น ๆ

Javascript (ES7), 45 ไบต์

x=>-1**Math.log2(Math.abs(x))*Math.abs(x)==x

Perl 6 , 21 ไบต์

{$_==(-2)**(.lsb//0)}

ลองมัน

ขยาย:

{  # bare block lambda with implicit parameter ｢$_｣

  $_                  # is the input
  ==                  # equal to
  (-2)**( .lsb // 0 ) # -2 to the power of the least significant bit of the input
}

โปรดทราบว่า0.lsbผลตอบแทนNilซึ่งเป็นผู้ผลิตคำเตือนเมื่อใช้เป็นจำนวนมากดังนั้นที่กำหนดไว้หรือผู้ประกอบการ  //จะใช้
(คิด//เหมือนกับ||เอียงอื่น)

โทรวิธีการที่ไม่มี invocant $_ที่ระยะที่คาดว่าจะถูกเรียกโดยปริยาย ( .lsb)

.msbยังทำงานร่วมกับ

Prolog (SWI) 44 ไบต์

p(X):-X=1;X\=0,X mod 2=:=0,Z is X/(-2),p(Z).

ล่ามออนไลน์

Pythonขนาด 24 ไบต์

lambda n:n*n&n*n-1<n%3%2

ลองออนไลน์!

เคล็ดลับบิตk&k-1==0ตรวจสอบว่าkเป็นพลังของ 2 (หรือk==0) การตรวจสอบสิ่งนี้k=n*nตามที่n*n&n*n-1==0บอกเราว่าabs(n)เป็นพลังของ 2

ที่จะเห็นต่อไปถ้าnเป็นอำนาจของ -2 n%3==1เราจะต้องตรวจสอบว่า สิ่งนี้ทำงานได้เพราะ mod 3 ค่า -2 เท่ากับ 1 ดังนั้นพลังของมันคือ 1 ในทางตรงกันข้ามการปฏิเสธของพวกเขาคือ 2 mod 3 และแน่นอน 0 ให้ 0 mod 3

เรารวมการตรวจสอบn*n&n*n-1==0และn%3==1เป็นนิพจน์เดียว เป็นครั้งแรกที่สามารถเขียนได้ด้วย<1สำหรับ==0เนื่องจากมันไม่เชิงลบ n%3==1เทียบเท่ากับการn%3%2ให้เป็น 0 หรือ 1 n*n&n*n-1<n%3%2ดังนั้นเราสามารถรวมพวกเขาเป็น

R, 22 ไบต์

รับอินพุตจาก stdin, return TRUEหรือFALSEตาม

scan()%in%(-2)^(0:1e4)

ฉันไม่แน่ใจ 100% ว่านี่เป็นคำตอบที่ถูกต้องเพราะมันใช้ได้กับจำนวนเต็มถึงขีด จำกัด ขนาด R เท่านั้นและหากจำนวนเต็มที่ไม่ได้ จำกัด จะไม่ทำงาน อย่างไรก็ตามกฎกติกา:

ใช้กฎโอเวอร์โฟลว์จำนวนเต็มตามปกติ: วิธีแก้ปัญหาของคุณจะต้องสามารถทำงานกับจำนวนเต็มขนาดใหญ่ตามอำเภอใจในภาษาของคุณ (หรืออาจจะเป็นจริง) ในรูปแบบสมมุติซึ่งจำนวนเต็มทั้งหมดถูก จำกัด โดยค่าเริ่มต้น แต่หากโปรแกรมของคุณล้มเหลวในทางปฏิบัติ ไม่รองรับจำนวนเต็มที่มีขนาดใหญ่ซึ่งไม่ได้ทำให้โซลูชันไม่ถูกต้อง

ในรุ่นสมมุติ R ซึ่งไม่อนุญาตให้จำนวนเต็มมากมายแล้วเราสามารถใช้รหัสต่อไปนี้สำหรับการนับไบต์เดียวกัน

scan()%in%(-2)^(0:Inf)

แน่นอนในแบบ real R, Error in 0:Inf : result would be too long a vectorโค้ดข้างต้นเป็นเพียงแค่ช่วยให้

bc 88 ไบต์

bc -l <<< "n=$1;q=l(sqrt(n*n));p=4*a(1);((n<1)*c(q/l(2)*p/2)+(n>1)*(s(q/l(4)*p)))^2==0"

ฉันมีสิ่งนี้ในไฟล์neg2.shและมันจะพิมพ์ออกมา1สำหรับพลังของ-2และ0อื่น ๆ

ฉันรู้ว่ามันนานมาก แต่ก็สนุก

ทดสอบ

$ for i in {-129..257}; do echo -n "$i: "; ./neg2.sh $i; done | grep ': 1'
-128: 1
-32: 1
-8: 1
-2: 1
1: 1
4: 1
16: 1
64: 1
256: 1

คำอธิบาย

-2ตัวหลักมีสองส่วนทั้งกำลังพยายามที่จะเท่ากับศูนย์สำหรับอำนาจของ

q=l(sqrt(n*n))               % ln of the absolute value of the input
p=4*a(1)                     % pi: arctan(1) == pi/4
q/l(2) -> l(sqrt(n*n))/l(2)  % change of base formula -- this gives
                             % the power to which 2 is raised to equal
                             % sqrt(n*n). It will be an integer for 
                             % numbers of interest
n<1                          % 1 if true, 0 if false. for negative
                             % numbers check for powers of 2
n>1                          % for positive numbers, check for powers
                             % of 4
c(q/l(2)*p/2)                % cos(n*pi/2) == 0 for integer n (2^n)
s(q/l(4)*p)                  % sin(n*pi) == 0 for integer n (4^n)
(....)^2==0                  % square the result because numbers are
                             % not exactly zero and compare to 0

Julia 0.5 , 20 ไบต์

!n=n∈(-2).^(0:n^2)

ลองออนไลน์!

ฟูริเยร์ 53 ไบต์

I~X1~N~G0(0-2*G~GX*X~PG*G>P{1}{0~O~N}G{X}{1~O0~N}N)Oo

ฉันจะเล่นกอล์ฟต่อไปในภายหลัง แต่โครงร่างของเรื่องนี้คือ:

X = User input
G = N = 1
Loop until N = 0
    G = -2 * G
    P = X*X 
    If G*G > P then
        N = O = 0
    End if
    If G = X then
        O = 1
        N = 0
    End if
End loop
Print O

ไหนออกเป็น0สำหรับfalseyและ1สำหรับtruthy

ลองออนไลน์!

Casio BASICขนาด 76 ไบต์

โปรดทราบว่า 76 ไบต์เป็นสิ่งที่กล่าวไว้ในเครื่องคิดเลขของฉัน

?→X
0→O
While Abs(X)≥1
X÷-2→X
If X=1
Then 1→O
IfEnd
WhileEnd
O

นี่คือการลงทุนครั้งแรกของฉันใน Casio BASIC ... ฉันไม่เคยรู้เลยว่าฉันสามารถเขียนโปรแกรมที่เหมาะสมเช่นนี้บนเครื่องคิดเลข: D

Python 2.7, 40 ไบต์

a=input()
while a%-2==0:a/=-2
print a==1

มอบเครดิตให้กับนาย Xcoderสำหรับรหัสเดิมที่มีความยาว 43 ไบต์ ต้องโพสต์เป็นคำตอบแยกต่างหากเนื่องจากฉันไม่มีชื่อเสียงพอที่จะแสดงความคิดเห็น

เรติน่า 27 ไบต์

+`(1+)\1
$1_
^(1|-1_)(__)*$

ลองออนไลน์!

ใช้อินพุตในเอกภาพซึ่งค่อนข้างเป็นมาตรฐานสำหรับ Retina สองบรรทัดแรกทำบางส่วน unary เป็นการแปลงแบบไบนารี่โดยยึดตามโค้ดสองบรรทัดแรกจากรายการบทช่วยสอน (ส่วนที่ไม่เกี่ยวข้องใด ๆ1จะทำให้การจับคู่ล้มเหลวต่อไป) ในขณะที่บรรทัดสุดท้ายตรวจสอบพลังสี่หรือพลังคี่เชิงลบ ของสอง

+`(1+)\1\1\1
$1_
^(-1)?1_*$

ลองออนไลน์!

เวลานี้ฉันทำบางสิ่งบางอย่างพร้อมเพรียงกันเพื่อแปลงสี่ฐาน พลังทั้งสี่จบลงใน^1_*$ขณะที่พลังแปลก ๆ ที่เป็นลบของทั้งสองจบลง^-11_*$ด้วย

+`\b(1111)*$
$#1$*
^(-1)?1$

ลองออนไลน์!

เวลานี้ฉันแค่หารด้วยสี่เท่าที่จะทำได้และตรวจสอบ1หรือ-11ท้ายที่สุด

+`\b(1+)\1\1\1$
$1
^(-1)?1$

ลองออนไลน์!

อีกวิธีในการหารด้วยสี่ และยังคงน่ารำคาญ 27 ไบต์ ...

แบบแผน 60 ไบต์

(define(f n)(cond((= 1 n)#t)((<(abs n)1)#f)(#t(f(/ n -2)))))

โซลูชันแบบเรียกซ้ำ