Są sprytne sposoby określania, czy liczba jest potęgą 2. To już nie jest interesujący problem, więc ustalmy, czy dana liczba całkowita jest potęgą liczby całkowitej -2 . Na przykład:

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

Zasady

• Możesz napisać program lub funkcję i użyć dowolnej ze standardowych metod odbierania danych wejściowych i dostarczania danych wyjściowych.

• Dane wejściowe są jedną liczbą całkowitą, a wartość wyjściowa musi być zgodna z prawdą, jeśli liczba całkowita jest potęgą całkowitą -2, a w przeciwnym razie wartością falsy. Żadne inne dane wyjściowe (np. Komunikaty ostrzegawcze) są niedozwolone.

• Obowiązują zwykłe reguły przepełnienia liczb całkowitych: twoje rozwiązanie musi być w stanie pracować dla dowolnie dużych liczb całkowitych w hipotetycznej (lub być może rzeczywistej) wersji twojego języka, w której wszystkie liczby całkowite są domyślnie nieograniczone, ale jeśli twój program zawiedzie w praktyce z powodu implementacji brak obsługi liczb całkowitych tak dużych, co nie unieważnia rozwiązania.

• Możesz używać dowolnego języka programowania , ale pamiętaj, że te luki są domyślnie zabronione.

Warunki wygranej

To jest konkurs golfowy : odpowiedź, która ma najmniej bajtów (w wybranym przez ciebie kodowaniu), jest zwycięzcą.

Mathematica, 22 bajty

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

Wypróbuj online! (Zamiast tego używa matematyki, gdzie to rozwiązanie również działa).

Przez jakiś czas próbowałem znaleźć rozwiązanie z operatorami bitowymi i chociaż jeden z nich zdecydowanie istnieje, znalazłem coś, co prawdopodobnie jest prostsze:

• Max[#,-2#]mnoży wejście przez -2, jeśli jest ujemne. Mnożenie przez inny współczynnik -2 nie zmienia, czy wartość jest potęgą -2, czy nie. Ale teraz wszystkie nieparzyste potęgi -2 zostały zamienione na parzyste potęgi -2 .
• Ale nawet potęgi -2 są również parzyste potęgi 2 , więc możemy użyć prostej Log2@...i sprawdzić, czy wynikiem jest liczba całkowita (aby sprawdzić, czy jest to potęga 2 ). To już oszczędza dwa bajty Log[4,...](inny sposób patrzenia na parzyste potęgi -2 ).
• Dodatkową zaletą jest to, że sprawdzenie, czy wartość jest parzystą liczbą całkowitą, jest krótsze niż samo sprawdzenie, czy jest ona liczbą całkowitą: możemy zaoszczędzić jeszcze trzy bajty, używając EvenQzamiast IntegerQ.

Galaretka , 5 bajtów

æḟ-2=

Wypróbuj online!

Jak to działa

æḟ-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 bajtów

-2 bajty dzięki @ovs.

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

Funkcja z użyciem:

g(4) # put your number between the brackets

Wypróbuj online!

Galaretka , 6 bajtów

b-2S⁼1

Wypróbuj online!

Jest to oparte na tym, jak Jelly przekształca liczbę całkowitą N na dowolną dowolną zasadę B , robiąc to przez konwersję N na tablicę, w której każda liczba całkowita jest cyfrą d ( N ) _B , która może mieć wartość 0 ≤ V _d < B . Tutaj będziemy cyfry 0 indeksy z prawej strony, więc każda cyfra dodaje V _d B ^d tworząc N . V _d < B ⇔ V _d B ^d < BB ^d = B ^{d +1} , dlatego wszystkie możliweN posiada tylko jedną unikalną reprezentacji jeśli pominiemy prowadzące 0s w ( n ) _B .

Tutaj d = wejście, B = -2. N = B ^d = 1 B ^d = V _d B ^d ⇔1 = V _d ⇔ V _d = 1, a ponieważ nie dodajemy żadnych innych wielokrotności mocy B , każde inne V będzie wynosić 0. W tej chwili, tablica powinna być 1 połączona z d 0. Ponieważ Jelly 1-indeksuje od lewej, powinniśmy sprawdzić, czy pierwszy element tablicy ma wartość 1, a wszystkie pozostałe elementy mają wartość 0.

Hmm ... wszystko dobrze, prawda? Nie? Co się dzieje? O tak, mam lepszy pomysł! Najpierw weźmy sumę wszystkich liczb całkowitych w tablicy, traktując ją tak, jakby była tablicą liczb całkowitych, a nie liczbą w bazie -2. Jeśli jest 1, oznacza to, że istnieje tylko jeden 1, a wszystkie inne są całkowitymi 0. Ponieważ nie mogą być zerami, z wyjątkiem przypadku 0 _-2(gdzie i tak suma wynosiłaby 0 ≠ 1), 1. liczba całkowita musi być niezerowa. Jedyną niezerową liczbą całkowitą w tablicy jest 1, więc musi być pierwszą. Dlatego jest to jedyny przypadek, w którym suma wszystkich liczb całkowitych w tablicy wynosi 1, ponieważ najmniejsza możliwa suma dodatnich liczb całkowitych wynosi is {1,1} = 2, ponieważ najmniejsza dodatnia liczba całkowita wynosi 1 Każda liczba całkowita w reprezentacji podstawowej jest nieujemna, więc jedynym sposobem, w jaki suma jest 1, ma tylko jeden 1, a wszystkie inne liczby całkowite wynoszą 0. Dlatego możemy po prostu sprawdzić, czy suma wszystkich liczb całkowitych w tablica to 1.

Oto, co robi kod:

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 bajty

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

Wypróbuj online!

Python 2 , 98 50 bajtów

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

Wypróbuj online!

Excel, 40 36 bajtów

^{Zapisane 4 bajty przez CallumDA}

Excel z pewnością może to zrobić, ale poprawianie błędów dodaje 11 bajtów

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

Dane wejściowe są w komórce A1. Dane wyjściowe to TRUElubFALSE

Gdyby dozwolone było zwrócenie jednego FALSElub #NUM!błędu dla fałszywych wartości, byłoby to tylko 25 bajtów:

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

05AB1E , 8 bajtów

Y(IÄÝm¹å

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

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 bajtów

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

Zaoszczędź 4 bajty dzięki Arnauldowi.

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 bajtów

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

Wypróbuj online!

MATL , 9 8 bajtów

2_y|:q^m

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Jak to działa

Rozważ dane wejściowe -8jako przykład

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

Oktawa , 28 bajtów

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

Definiuje to anonimową funkcję. Podejście jest podobne do tego w mojej odpowiedzi MATL.

Wypróbuj online!

PHP, 41 bajtów

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

PHP, 52 bajty

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

PHP, 64 bajty

Praca z regexem

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

Python 3, 34 bajty

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

JavaScript (ES6), 21 bajtów

Funkcja rekurencyjna, która zwraca 0lub true.

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

Jak to działa

Nie obejmuje to żadnego wyraźnego testu - takiego jak nbycie nieparzystym lub abs(n)bycie mniejszym niż jeden - w celu wczesnego zatrzymania rekurencji, gdy dane wejściowe nie są dokładną siłą -2.

Mamy wyjść tylko wtedy, gdy njest dokładnie równy albo 1albo 0.

Działa to jednak, ponieważ dowolna liczba zmiennoprzecinkowa IEEE-754 zostanie ostatecznie zaokrąglona, 0gdy zostanie podzielona przez 2 (lub -2) wystarczającą liczbę razy, z powodu niedomiaru arytmetycznego .

Przypadki testowe

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 bajty

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

Wypróbuj online!

Java 7, 55 bajtów

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

Wyjaśnienie:

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

Kod testowy:

Wypróbuj tutaj.

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

Wynik:

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

Haskell, 24 23 bajty

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

Definiuje funkcję, fktóra zwraca 1dla potęg -2 lub 0innych.

Golfowa wersja mojego pierwszego poddania się drugiemu wyzwaniu .

JavaScript (ES7), 45 bajtów

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

Perl 6 , 21 bajtów

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

Spróbuj

Rozszerzony:

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

Zauważ, że 0.lsbzwraca, Nilktóra generuje ostrzeżenie, gdy jest używana jako liczba, więc //używany jest zdefiniowany lub operator  .
(Pomyśl, //jak ||z innym skosów)

Wywołanie metody bez wywołującego, w którym spodziewany jest termin, jest domyślnie wywoływane $_. ( .lsb)

Działa również z.msb .

Prolog (SWI) , 44 bajty

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

Tłumacz online

Python , 24 bajty

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

Wypróbuj online!

Bitowa sztuczka k&k-1==0sprawdza, czy kjest potęgą 2 (lub k==0). Sprawdzanie tego k=n*njako n*n&n*n-1==0mówi nam, czy abs(n)jest potęgą 2.

Aby dalej sprawdzić, czy njest potęgą -2, musimy tylko to sprawdzić n%3==1. Działa to, ponieważ mod 3, wartość -2 jest równa 1, więc jego moc wynosi 1. Natomiast ich negacje to 2 mod 3, i oczywiście 0 daje 0 mod 3.

Łączymy czeki n*n&n*n-1==0i n%3==1w jedno wyrażenie. Pierwszy można napisać <1dla ==0, ponieważ nigdy nie jest on negatywny. Jest n%3==1to równoważne z n%3%2podaniem 0 lub 1. Możemy więc połączyć je jako n*n&n*n-1<n%3%2.

R, 22 bajty

Pobiera dane wejściowe ze standardowego wejścia, zwraca TRUElub FALSEodpowiednio.

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

Nie jestem w 100% pewien, że jest to prawidłowa odpowiedź, ponieważ działa tylko dla liczb całkowitych do limitu rozmiaru R, a jeśli liczby całkowite byłyby nieograniczone, nie działałoby. Jednak zasady stanowią:

Obowiązują zwykłe reguły przepełnienia liczb całkowitych: twoje rozwiązanie musi być w stanie pracować dla dowolnie dużych liczb całkowitych w hipotetycznej (lub być może rzeczywistej) wersji twojego języka, w której wszystkie liczby całkowite są domyślnie nieograniczone, ale jeśli twój program zawiedzie w praktyce z powodu implementacji brak obsługi liczb całkowitych tak dużych, co nie unieważnia rozwiązania.

W hipotetycznym wersji R, która ma umożliwić nieograniczone całkowitymi, to możemy użyć następującego kodu dla tej samej liczby bajtów:

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

Oczywiście w prawdziwym R powyższy kod po prostu daje Error in 0:Inf : result would be too long a vector.

bc 88 bajtów

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"

Mam to w pliku neg2.shi drukuje 1dla potęgi -2i 0innych

Wiem, że to naprawdę długo, ale było fajnie

Test

$ 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

Wyjaśnienie

Główny korpus ma dwie połówki, obie próbują wyrównać zero do mocy -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 bajtów

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

Wypróbuj online!

Fouriera , 53 bajty

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

Później będę pracował nad golfem, ale jego zarys jest następujący:

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

Gdzie wyjście jest 0dla falsey i 1dla prawdy .

Wypróbuj online!

Casio BASIC , 76 bajtów

Zauważ, że 76 bajtów to, co mówi mój kalkulator.

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

To moje pierwsze przedsięwzięcie w Casio BASIC ... Nigdy nie zdawałem sobie sprawy, że mogę napisać tak przyzwoite programy na kalkulatorze: D

Python 2.7, 40 bajtów

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

Podziękowania dla pana Xcodera za oryginalny kod o długości 43 bajtów. Musiałem opublikować jako osobną odpowiedź, ponieważ nie mam wystarczającej reputacji, aby móc komentować.

Siatkówka , 27 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe jednoargumentowe, co jest dość standardowe dla Retina. Pierwsze dwa wiersze wykonują częściową konwersję jednoargumentową na binarną na podstawie pierwszych dwóch wierszy kodu z pozycji samouczka (wszelkie obce 1spowodują, że dopasowanie i tak się nie powiedzie), podczas gdy ostatni wiersz sprawdza moc czterech lub ujemną moc nieparzystą z dwóch.

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

Wypróbuj online!

Tym razem dokonuję częściowej jedności, aby oprzeć cztery konwersje. Moce czterech kończą się tak ^1_*$, jak podczas gdy ujemne nieparzyste moce dwóch kończą się jako ^-11_*$.

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

Wypróbuj online!

Tym razem dzielę tyle, ile mogę, i sprawdzam, 1czy -11na końcu.

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

Wypróbuj online!

Kolejny sposób dzielenia przez cztery. I wciąż irytująco 27 ​​bajtów ...

Schemat, 60 bajtów

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

Rozwiązanie rekurencyjne.