Có nhiều cách thông minh để xác định xem một số có phải là lũy thừa không 2. Đó không còn là vấn đề thú vị nữa, vì vậy hãy xác định xem một số nguyên đã cho có phải là số nguyên của -2 không . Ví dụ:

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

Quy tắc

• Bạn có thể viết một chương trình hoặc một chức năng và sử dụng bất kỳ phương pháp tiêu chuẩn nào để nhận đầu vào và cung cấp đầu ra.

• Đầu vào của bạn là một số nguyên duy nhất và đầu ra phải là một giá trị trung thực nếu số nguyên là công suất nguyên là -2 và ngược lại là một giá trị giả. Không có đầu ra khác (ví dụ như tin nhắn cảnh báo) được cho phép.

• Áp dụng quy tắc tràn số nguyên thông thường: giải pháp của bạn phải có thể hoạt động cho các số nguyên lớn tùy ý trong phiên bản giả định (hoặc có thể có thật) của ngôn ngữ của bạn trong đó tất cả các số nguyên không bị ràng buộc theo mặc định, nhưng nếu chương trình của bạn không thực hiện do thực hiện do thực hiện không hỗ trợ số nguyên lớn, điều đó không làm mất hiệu lực giải pháp.

• Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

Điều kiện chiến thắng

Đây là một cuộc thi chơi gôn mã : câu trả lời có ít byte nhất (theo mã hóa bạn chọn) là người chiến thắng.

Toán học, 22 byte

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

Hãy thử trực tuyến! (Thay vào đó, sử dụng Toán học, giải pháp này cũng hoạt động.)

Tôi đã cố gắng tìm một giải pháp với các toán tử bitwise trong một thời gian, và trong khi một giải pháp chắc chắn tồn tại, cuối cùng tôi đã tìm thấy một thứ có lẽ đơn giản hơn:

• Max[#,-2#]nhân số đầu vào bằng -2 nếu âm. Nhân với một yếu tố khác của -2 sẽ không thay đổi cho dù giá trị đó có phải là lũy thừa -2 hay không. Nhưng bây giờ tất cả các sức mạnh kỳ lạ của -2 đã được chuyển thành sức mạnh chẵn của -2 .
• Nhưng ngay cả các lũy thừa của -2 cũng là các lũy thừa của 2 , vì vậy chúng ta có thể sử dụng một đơn giản Log2@...và kiểm tra xem kết quả có phải là số nguyên không (để kiểm tra xem đó có phải là lũy thừa 2 không ). Điều này đã tiết kiệm được hai byte Log[4,...](một cách khác để xem xét các lũy thừa -2 ).
• Là một phần thưởng bổ sung, kiểm tra xem một giá trị có phải là số nguyên chẵn hay không, chỉ kiểm tra xem đó có phải là số nguyên hay không: chúng ta có thể lưu thêm ba byte bằng cách sử dụng EvenQthay vì IntegerQ.

Thạch , 5 byte

æḟ-2=

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

-2 byte nhờ @ovs.

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

Chức năng sử dụng:

g(4) # put your number between the brackets

Hãy thử trực tuyến!

Thạch , 6 byte

b-2S⁼1

Hãy thử trực tuyến!

Điều này dựa trên cách Jelly chuyển đổi một số nguyên N thành bất kỳ cơ sở B tùy ý , làm như vậy bằng cách chuyển đổi N thành một mảng, trong đó mỗi số nguyên là một chữ số d của ( N ) _B , có thể có giá trị 0≤ V _d < B . Ở đây, chúng tôi sẽ 0-index chữ số từ cánh phải, như vậy mỗi chữ số thêm V _d B ^d để tạo thành N . V _d < B ⇔ V _d B ^d < BB ^d = B ^{d 1} , do đó mỗi thểN chỉ có một đại diện độc đáo, nếu chúng ta bỏ qua leading 0s trong ( N ) _B .

Ở đây, d = đầu vào, B = -2. N = B ^d = 1 B ^d = V _d B ^d 1 = V _d ⇔ V _d = 1, và, vì chúng tôi không thêm bất kỳ bội số sức mạnh nào khác của B , mọi V khác sẽ là 0. Ngay bây giờ, mảng phải là 1 nối với d 0s. Vì chỉ số Jelly 1 từ bên trái, chúng ta nên kiểm tra xem phần tử thứ 1 của mảng có phải là 1 hay không và tất cả các phần tử khác là 0.

Hmm ... tất cả đều tốt, phải không? Không? Chuyện gì đang xảy ra vậy? Ồ vâng, tôi có một ý tưởng tốt hơn! Trước tiên, hãy lấy tổng của tất cả các số nguyên trong mảng, coi nó như một mảng số nguyên chứ không phải là một số trong cơ sở -2. Nếu là 1, điều đó có nghĩa là chỉ có 1 và tất cả các số nguyên khác là 0. Vì không thể có các số 0 đứng đầu, ngoại trừ trong trường hợp 0 _-2(trong đó tổng sẽ là 0 1 dù sao), số nguyên thứ 1 phải khác không. Số nguyên duy nhất khác không trong mảng là 1, vì vậy nó phải là số nguyên đầu tiên. Do đó, đây là trường hợp duy nhất mà tổng của tất cả các số nguyên trong mảng sẽ là 1, vì tổng nhỏ nhất có thể có của một cặp số nguyên dương là Σ {1,1} = 2, vì số nguyên dương nhỏ nhất là 1 Mọi số nguyên trong biểu diễn cơ sở đều không âm, vì vậy cách duy nhất của tổng là 1 chỉ có 1 và tất cả các số nguyên khác là 0. Do đó, chúng ta chỉ có thể kiểm tra xem tổng của tất cả các số nguyên trong mảng là 1.

Đây là những gì mã làm:

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 byte

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

Hãy thử trực tuyến!

Python 2 , 98 50 byte

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

Hãy thử trực tuyến!

Excel, 40 36 byte

^{Đã lưu 4 byte bởi CallumDA}

Excel chắc chắn có thể làm điều đó nhưng sửa lỗi thêm 11 byte

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

Đầu vào là trong ô A1. Đầu ra là TRUEhoặcFALSE

Nếu nó được phép trả về FALSEhoặc #NUM!lỗi cho các giá trị sai, nó sẽ chỉ có 25 byte:

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

05AB1E , 8 byte

Y(IÄÝm¹å

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

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 byte

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

Đã lưu 4 byte nhờ 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 byte

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

Hãy thử trực tuyến!

MATL , 9 8 byte

2_y|:q^m

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

Hãy xem xét đầu vào -8như một ví dụ

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

Octave , 28 byte

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

Điều này xác định một chức năng ẩn danh. Cách tiếp cận tương tự như trong câu trả lời MATL của tôi.

Hãy thử trực tuyến!

PHP, 41 byte

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

PHP, 52 byte

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

PHP, 64 byte

Làm việc với Regex

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

Python 3, 34 byte

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

JavaScript (ES6), 21 byte

Hàm đệ quy trả về 0hoặc true.

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

Làm thế nào nó hoạt động

Điều này không bao gồm bất kỳ thử nghiệm rõ ràng nào - như nlà lẻ hoặc abs(n)ít hơn một - để ngăn chặn đệ quy sớm khi đầu vào không phải là công suất chính xác là -2.

Chúng tôi chỉ thoát khi nchính xác bằng 1hoặc 0.

Tuy nhiên, điều này không hoạt động bởi vì bất kỳ số float nào của IEEE-754 cuối cùng sẽ được làm tròn thành 0khi chia cho 2 (hoặc -2) đủ số lần, vì dòng chảy số học .

Các trường hợp thử nghiệm

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 byte

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

Hãy thử trực tuyến!

Java 7, 55 byte

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

Giải trình:

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

Mã kiểm tra:

Hãy thử nó ở đây.

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

Đầu ra:

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

Haskell, 24 23 byte

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

Xác định hàm ftrả về 1quyền hạn -2 và mặt 0khác.

Một phiên bản golf của đệ trình đầu tiên của tôi cho các thách thức khác .

Javascript (ES7), 45 byte

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

Perl 6 , 21 byte

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

Thử nó

Mở rộng:

{  # 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
}

Lưu ý rằng 0.lsbtrả về Nilmà tạo ra một cảnh báo khi được sử dụng như một số, do đó toán tử //được xác định hoặc toán tử  được sử dụng.
(Nghĩ //như ||với một xiên khác)

Một cuộc gọi phương thức không có invocant trong đó một thuật ngữ được mong đợi sẽ được gọi ngầm $_. ( .lsb)

Cũng làm việc với.msb .

Prolog (SWI) , 44 byte

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

Phiên dịch trực tuyến

Python , 24 byte

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

Hãy thử trực tuyến!

Thủ thuật bit k&k-1==0kiểm tra xem có phải klà lũy thừa 2 (hoặc k==0) không. Kiểm tra điều này k=n*nnhư n*n&n*n-1==0cho chúng ta biết liệu abs(n)sức mạnh của 2.

Để biết thêm nếu ncó công suất -2, chúng ta chỉ cần kiểm tra xem n%3==1. Điều này hoạt động vì mod 3, giá trị -2 bằng 1, do đó, quyền hạn của nó là 1. Ngược lại, phủ định của chúng là 2 mod 3 và tất nhiên 0 cho 0 mod 3.

Chúng tôi kết hợp kiểm tra n*n&n*n-1==0và n%3==1thành một biểu thức duy nhất. Đầu tiên có thể được viết với <1cho ==0, vì nó không bao giờ tiêu cực. Các n%3==1tương đương với n%3%2, cho 0 hoặc 1. Vì vậy, chúng ta có thể kết hợp chúng như n*n&n*n-1<n%3%2.

R, 22 byte

Lấy đầu vào từ stdin, trả về TRUEhoặc FALSEtheo đó.

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

Tôi không chắc chắn 100% rằng đây là một câu trả lời hợp lệ, vì nó chỉ hoạt động đối với các số nguyên có giới hạn kích thước của R và nếu các số nguyên không bị ràng buộc thì nó sẽ không hoạt động. Tuy nhiên, các quy tắc nêu rõ:

Áp dụng quy tắc tràn số nguyên thông thường: giải pháp của bạn phải có thể hoạt động cho các số nguyên lớn tùy ý trong phiên bản giả định (hoặc có thể có thật) của ngôn ngữ của bạn trong đó tất cả các số nguyên không bị ràng buộc theo mặc định, nhưng nếu chương trình của bạn không thực hiện do thực hiện do thực hiện không hỗ trợ số nguyên lớn, điều đó không làm mất hiệu lực giải pháp.

Trong một phiên bản giả của R mà không cho phép số nguyên vô biên, sau đó chúng ta có thể sử dụng đoạn mã sau, đối với số lượng tương tự byte:

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

Tất nhiên, trong R thực, mã trên chỉ cung cấp Error in 0:Inf : result would be too long a vector.

bc 88 byte

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"

Tôi có cái này trong một tập tin neg2.shvà nó in ra 1cho quyền hạn -2và mặt 0khác

Tôi biết nó rất dài, nhưng nó rất vui

Kiểm tra

$ 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

Giải trình

Cơ thể chính có hai nửa, cả hai đều cố gắng bằng không cho sức mạnh của -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 byte

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

Hãy thử trực tuyến!

Fourier , 53 byte

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

Tôi sẽ làm việc này sau này, nhưng phác thảo của nó là:

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

Trường hợp đầu ra là 0cho falsey và 1cho sự thật .

Hãy thử trực tuyến!

Casio BASIC , 76 byte

Lưu ý rằng 76 byte là những gì nó nói trên máy tính của tôi.

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

Đây là liên doanh đầu tiên của tôi vào Casio BASIC ... Tôi chưa bao giờ nhận ra mình có thể viết những chương trình đàng hoàng như vậy trên máy tính: D

Python 2.7, 40 byte

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

Tín dụng cho ông Xcoder cho mã gốc có độ dài 43 byte. Phải đăng như một câu trả lời riêng vì tôi không đủ danh tiếng để bình luận.

Võng mạc , 27 byte

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

Hãy thử trực tuyến!

Đưa đầu vào vào unary, khá chuẩn cho Retina. Hai dòng đầu tiên thực hiện chuyển đổi một phần từ unary sang nhị phân dựa trên hai dòng mã đầu tiên từ mục Hướng dẫn (bất kỳ 1s không liên quan nào cũng sẽ khiến trận đấu không thành công), trong khi dòng cuối cùng kiểm tra công suất bốn hoặc công suất lẻ âm của hai.

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

Hãy thử trực tuyến!

Lần này tôi thực hiện một phần unary để chuyển đổi cơ sở bốn. Sức mạnh của bốn kết thúc như ^1_*$trong khi sức mạnh kỳ lạ tiêu cực của hai kết thúc như ^-11_*$.

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

Hãy thử trực tuyến!

Lần này tôi chỉ cần chia cho bốn càng nhiều càng tốt và kiểm tra 1hoặc -11cuối cùng.

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

Hãy thử trực tuyến!

Một cách khác để chia cho bốn. Và vẫn còn khó chịu 27 byte ...

Lược đồ, 60 byte

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

Giải pháp đệ quy.