Ada cara pintar untuk menentukan apakah angka adalah kekuatan 2. Itu bukan lagi masalah yang menarik, jadi mari kita tentukan apakah bilangan bulat yang diberikan adalah kekuatan bilangan bulat -2 . Sebagai contoh:

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

Aturan

• Anda dapat menulis sebuah program atau fungsi dan menggunakan salah satu metode standar untuk menerima input dan memberikan output.

• Input Anda adalah bilangan bulat tunggal, dan output harus nilai kebenaran jika bilangan bulat adalah kekuatan bilangan bulat -2, dan nilai palsu sebaliknya. Tidak ada output lain (mis. Pesan peringatan) diizinkan.

• Aturan bilangan bulat bilangan bulat yang biasa berlaku: solusi Anda harus dapat bekerja untuk bilangan bulat besar yang sewenang-wenang dalam versi hipotetis (atau mungkin nyata) bahasa Anda di mana semua bilangan bulat tidak terikat secara default, tetapi jika program Anda gagal dalam praktik karena implementasi tidak mendukung bilangan bulat yang besar, itu tidak membatalkan solusi.

• Anda dapat menggunakan bahasa pemrograman apa pun , tetapi perhatikan bahwa celah ini dilarang secara default.

Kondisi menang

Ini adalah kontes kode-golf : jawabannya yang memiliki byte paling sedikit (dalam pengkodean pilihan Anda) adalah pemenangnya.

Mathematica, 22 byte

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

Cobalah online! (Sebaliknya, menggunakan Matematika, tempat solusi ini juga berfungsi.)

Saya mencoba mencari solusi dengan operator bitwise untuk sementara waktu, dan meskipun ada yang pasti, saya akhirnya menemukan sesuatu yang mungkin lebih sederhana:

• Max[#,-2#]mengalikan input dengan -2 jika negatif. Mengalikan dengan faktor -2 lainnya tidak mengubah apakah nilainya kekuatan -2 atau tidak. Tapi sekarang semua kekuatan ganjil -2 telah berubah menjadi kekuatan genap -2 .
• Tetapi bahkan kekuatan -2 juga bahkan kekuatan 2 , jadi kita bisa menggunakan yang sederhana Log2@...dan memeriksa apakah hasilnya bilangan bulat (untuk memeriksa apakah itu kekuatan 2 ). Ini sudah menghemat dua byte lebih Log[4,...](cara lain untuk melihat kekuatan genap -2 ).
• Sebagai bonus tambahan, memeriksa apakah suatu nilai bilangan bulat genap lebih pendek dari sekadar memeriksa apakah itu bilangan bulat: kita bisa menghemat tiga byte lebih banyak dengan menggunakan EvenQalih-alih IntegerQ.

Jelly , 5 byte

æḟ-2=

Cobalah online!

Bagaimana itu bekerja

æḟ-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 terima kasih kepada @ovs.

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

Fungsi dengan penggunaan:

g(4) # put your number between the brackets

Cobalah online!

Jelly , 6 byte

b-2S⁼1

Cobalah online!

Ini didasarkan pada bagaimana Jelly mengkonversi bilangan bulat N ke sembarang basis B , dengan melakukan konversi N ke array, di mana setiap bilangan bulat adalah digit d dari ( N ) _B , yang dapat memiliki nilai 0≤ V _d < B . Di sini, kita akan 0-indeks digit dari kanan, sehingga setiap digit menambahkan V _d B ^d untuk membentuk N . V _d < B ⇔ V _d B ^d < BB ^d = B ^{d +1} , oleh karena itu setiap kemungkinanN hanya memiliki satu representasi yang unik, jika kita mengabaikan 0s terkemuka di ( N ) _B .

Di sini, d = input, B = -2. N = B ^d = 1 B ^d = V _d B ^d ⇔1 = V _d ⇔ V _d = 1, dan, karena kita tidak menambahkan kelipatan kekuatan B lainnya , setiap V lainnya akan menjadi 0. Saat ini, array harus berupa 1 concatenated dengan d 0s. Karena Jelly 1-indeks dari kiri, kita harus memeriksa apakah elemen 1 array adalah 1, dan semua elemen lainnya adalah 0.

Hmm ... semuanya baik-baik saja, kan? Tidak? Apa yang sedang terjadi? Oh ya, aku punya ide yang lebih baik! Pertama, mari kita ambil jumlah semua bilangan bulat dalam array, memperlakukannya seolah-olah itu adalah array integer dan bukan angka di basis -2. Jika angka 1, itu berarti bahwa hanya ada satu angka 1, dan semua bilangan bulat lainnya adalah 0. Karena tidak mungkin ada angka nol di depannya, kecuali dalam kasus 0 _-2(di mana jumlahnya adalah 0 ≠ 1), integer 1 harus bukan nol. Satu-satunya bilangan bulat bukan nol dalam array adalah 1, jadi harus yang pertama. Oleh karena itu, ini adalah satu-satunya kasus bahwa jumlah semua bilangan bulat dalam array adalah 1, karena jumlah terkecil dari sepasang bilangan bulat positif adalah Σ {1,1} = 2, karena bilangan bulat positif terkecil adalah 1 Setiap bilangan bulat dalam representasi basis adalah non-negatif, jadi satu-satunya cara penjumlahannya adalah 1 adalah dengan hanya memiliki 1, dan semua bilangan bulat lainnya adalah 0. Oleh karena itu, kami hanya dapat memeriksa apakah jumlah semua bilangan bulat dalam array adalah 1.

Inilah yang dilakukan oleh kode:

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)

Cobalah online!

Python 2 , 98 50 byte

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

Cobalah online!

Excel, 40 36 byte

^{Disimpan 4 byte oleh CallumDA}

Excel pasti dapat melakukannya tetapi memperbaiki kesalahan menambah 11 byte

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

Input ada di sel A1. Output adalah TRUEatauFALSE

Jika diizinkan untuk mengembalikan salah FALSEatau #NUM!kesalahan untuk nilai-nilai salah, itu hanya akan menjadi 25 byte:

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

05AB1E , 8 byte

Y(IÄÝm¹å

Cobalah online! atau sebagai Test suite

Penjelasan

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)

Disimpan 4 byte berkat 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);}

Cobalah online!

MATL , 9 8 byte

2_y|:q^m

Cobalah online! Atau verifikasi semua kasus uji .

Bagaimana itu bekerja

Pertimbangkan input -8sebagai contoh

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

Oktaf , 28 byte

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

Ini mendefinisikan fungsi anonim. Pendekatannya mirip dengan yang ada di jawaban MATL saya.

Cobalah online!

PHP, 41 Bytes

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

PHP, 52 Bytes

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

PHP, 64 Bytes

Bekerja dengan 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

Fungsi rekursif yang mengembalikan 0atau true.

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

Bagaimana itu bekerja

Ini tidak termasuk tes eksplisit - seperti nmenjadi aneh atau abs(n)kurang dari satu - untuk menghentikan rekursi lebih awal ketika input bukan kekuatan tepat -2.

Kami keluar hanya ketika npersis sama dengan salah satu 1atau 0.

Namun ini berhasil karena setiap float IEEE-754 pada akhirnya akan dibulatkan menjadi 0ketika dibagi dengan 2 (atau -2) kali yang cukup, karena aritmatika underflow .

Uji kasus

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

Cobalah online!

Java 7, 55 byte

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

Penjelasan:

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

Kode uji:

Coba di sini.

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

Keluaran:

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

Menentukan fungsi fyang mengembalikan 1kekuatan -2 dan 0sebaliknya.

Versi golf dari pengiriman pertama saya ke tantangan lain .

Javascript (ES7), 45 byte

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

Perl 6 , 21 byte

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

Cobalah

Diperluas:

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

Perhatikan bahwa 0.lsbpengembalian Nilyang menghasilkan peringatan ketika digunakan sebagai angka, sehingga operator yang didefinisikan atau  //digunakan.
(Anggap //sebagai ||dengan kemiringan yang berbeda)

Panggilan metode tanpa undangan di mana istilah diharapkan secara implisit dipanggil $_. ( .lsb)

Juga bekerja dengan.msb .

Prolog (SWI) , 44 byte

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

Penerjemah online

Python , 24 byte

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

Cobalah online!

Trik bit k&k-1==0memeriksa apakah kkekuatan 2 (atau k==0). Memeriksa ini k=n*nsebagai n*n&n*n-1==0memberi tahu kita apakah abs(n)kekuatan 2.

Untuk lebih jauh melihat apakah nkekuatan -2, kita hanya perlu memeriksa itu n%3==1. Ini berfungsi karena mod 3, nilai -2 sama dengan 1, jadi kekuatannya adalah 1. Sebaliknya, negasinya adalah 2 mod 3, dan tentu saja 0 memberikan 0 mod 3.

Kami menggabungkan cek n*n&n*n-1==0dan n%3==1menjadi satu ekspresi. Yang pertama dapat ditulis dengan <1untuk ==0, karena itu tidak pernah negatif. Ini n%3==1sama dengan n%3%2, memberi 0 atau 1. Jadi, kita bisa menggabungkannya sebagai n*n&n*n-1<n%3%2.

R, 22 byte

Mengambil input dari stdin, mengembalikan TRUEatau FALSEsesuai.

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

Saya tidak 100% yakin bahwa ini adalah jawaban yang valid, karena hanya berfungsi untuk bilangan bulat hingga batas ukuran R, dan jika bilangan bulat tidak terikat itu tidak akan berfungsi. Namun, aturannya menyatakan:

Aturan bilangan bulat bilangan bulat yang biasa berlaku: solusi Anda harus dapat bekerja untuk bilangan bulat besar yang sewenang-wenang dalam versi hipotetis (atau mungkin nyata) bahasa Anda di mana semua bilangan bulat tidak terikat secara default, tetapi jika program Anda gagal dalam praktik karena implementasi tidak mendukung bilangan bulat yang besar, itu tidak membatalkan solusi.

Dalam versi hipotetis R yang memungkinkan bilangan bulat tidak terikat, maka kita bisa menggunakan kode berikut, untuk jumlah byte yang sama:

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

Tentu saja, dalam R nyata, kode di atas hanya memberi 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"

Saya memiliki ini dalam file neg2.shdan mencetak 1untuk kekuatan -2dan 0sebaliknya

Saya tahu ini sangat panjang, tapi itu menyenangkan

Uji

$ 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

Penjelasan

Tubuh utama memiliki dua bagian, keduanya berusaha sama dengan nol untuk kekuatan -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)

Cobalah online!

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

Saya akan mengerjakan golf ini nanti, tetapi garis besarnya adalah:

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

Di mana hasilnya adalah 0untuk falsey dan 1untuk kebenaran .

Cobalah online!

Casio BASIC , 76 byte

Perhatikan bahwa 76 byte adalah apa yang tertulis di kalkulator saya.

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

Ini adalah usaha pertama saya ke Casio BASIC ... Saya tidak pernah menyadari bahwa saya dapat menulis program yang layak seperti itu di kalkulator: D

Python 2.7, 40 byte

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

Kredit ke Tn. Xcoder untuk kode asli panjang 43 byte. Harus memposting sebagai jawaban terpisah karena saya tidak memiliki reputasi yang cukup untuk berkomentar.

Retina , 27 byte

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

Cobalah online!

Mengambil input di unary, yang cukup standar untuk Retina. Dua baris pertama melakukan konversi unary ke binary sebagian berdasarkan pada dua baris pertama kode dari entri Tutorial (setiap 1tambahan akan menyebabkan kecocokan tetap gagal), sedangkan baris terakhir memeriksa kekuatan empat atau kekuatan ganjil negatif dari dua.

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

Cobalah online!

Kali ini saya melakukan sebagian unary ke base empat konversi. Kekuatan empat berakhir sebagai ^1_*$sementara kekuatan aneh negatif dua berakhir sebagai ^-11_*$.

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

Cobalah online!

Kali ini saya hanya membagi empat sebanyak yang saya bisa dan memeriksa 1atau -11pada akhirnya.

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

Cobalah online!

Cara lain untuk membaginya dengan empat. Dan masih mengganggu 27 byte ...

Skema, 60 byte

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

Solusi rekursif.