Es gibt clevere Methoden, um zu bestimmen, ob eine Zahl eine Potenz von 2 ist. Das ist kein interessantes Problem mehr. Lassen Sie uns also feststellen, ob eine bestimmte Ganzzahl eine ganzzahlige Potenz von -2 ist . Zum Beispiel:

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

Regeln

• Sie können ein Programm oder eine Funktion schreiben und eine der Standardmethoden zum Empfangen von Eingaben und zum Bereitstellen von Ausgaben verwenden.

• Ihre Eingabe ist eine einzelne Ganzzahl, und die Ausgabe muss ein wahrer Wert sein, wenn die Ganzzahl eine ganzzahlige Potenz von -2 ist, andernfalls ein falscher Wert. Andere Ausgaben (z. B. Warnmeldungen) sind nicht zulässig.

• Es gelten die üblichen Überlaufregeln für Ganzzahlen: Ihre Lösung muss in der Lage sein, für beliebig große Ganzzahlen in einer hypothetischen (oder möglicherweise realen) Version Ihrer Sprache zu arbeiten, in der standardmäßig alle Ganzzahlen unbegrenzt sind, Ihr Programm jedoch aufgrund der Implementierung in der Praxis fehlschlägt Ganzzahlen, die so groß sind, werden nicht unterstützt, was die Lösung nicht ungültig macht.

• Sie können jede Programmiersprache verwenden , aber beachten Sie, dass diese Lücken standardmäßig verboten sind.

Gewinnbedingung

Dies ist ein Code-Golf- Wettbewerb: Die Antwort mit den wenigsten Bytes (in der von Ihnen gewählten Codierung) ist der Gewinner.

Mathematica, 22 Bytes

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

Probieren Sie es online! (Verwenden Sie stattdessen Mathematik, wo diese Lösung auch funktioniert.)

Ich habe eine Weile versucht, eine Lösung mit bitweisen Operatoren zu finden, und obwohl es eine gibt, habe ich am Ende etwas gefunden, das wahrscheinlich einfacher ist:

• Max[#,-2#]multipliziert die Eingabe mit -2, wenn sie negativ ist. Das Multiplizieren mit einem anderen Faktor von -2 ändert nichts daran, ob der Wert eine Potenz von -2 ist oder nicht. Aber jetzt sind alle ungeraden Potenzen von -2 in gerade Potenzen von -2 umgewandelt worden .
• Aber gerade Potenzen von -2 sind auch gerade Potenzen von 2 , also können wir eine einfache verwenden Log2@...und prüfen, ob das Ergebnis eine ganze Zahl ist (um zu prüfen, ob es sich um eine Potenz von 2 handelt ). Dies spart bereits zwei Bytes Log[4,...](eine andere Möglichkeit, gerade Potenzen von -2 zu betrachten ).
• Als zusätzlichen Bonus ist die Überprüfung, ob ein Wert eine gerade Ganzzahl ist, kürzer als nur die Überprüfung, ob es sich um eine Ganzzahl handelt: Wir können drei weitere Bytes einsparen, indem wir EvenQanstelle von verwenden IntegerQ.

Gelee , 5 Bytes

æḟ-2=

Probieren Sie es online!

Wie es funktioniert

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

-2 Bytes dank @ovs.

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

Funktion mit nutzung:

g(4) # put your number between the brackets

Probieren Sie es online!

Gelee , 6 Bytes

b-2S⁼1

Probieren Sie es online!

Dies basiert darauf, wie Jelly eine ganze Zahl N in eine beliebige Basis B konvertiert, indem N in ein Array konvertiert wird , in dem jede ganze Zahl eine Ziffer d von ( N ) _{B ist} , die einen Wert von 0 ≤ V _d < B haben kann . Hier werden die Ziffern von rechts mit 0 indiziert, sodass jede Ziffer V _d B ^d zu N addiert . V _d < B ⇔ V _d B ^d < BB ^d = B ^{d + 1} , also alle möglichenN hat nur eine eindeutige Darstellung, wenn wir führende Nullen in ( N ) _B ignorieren .

Hier ist d = Eingang, B = -2. N = B ^d = 1 B ^d = V _d B ^d ⇔ 1 = V _d ⇔ V _d = 1, und da wir keine anderen Vielfachen von Potenzen von B addieren , wäre jedes andere V 0. Im Moment Das Array sollte eine 1 sein, die mit d 0s verkettet ist . Da Jelly 1 von links indiziert, sollten wir prüfen, ob das erste Element des Arrays 1 ist und alle anderen Elemente 0 sind.

Hmm ... alles gut, oder? Nein? Was ist los? Oh ja, ich habe eine bessere Idee! Nehmen wir zunächst die Summe aller Ganzzahlen im Array und behandeln sie so, als ob es sich um ein ganzzahliges Array und nicht um eine Zahl zur Basis -2 handelt. Wenn es 1 ist, bedeutet dies, dass es nur eine 1 gibt und alle anderen Ganzzahlen 0. Da es keine führenden Nullen geben kann, außer im Fall von _0-2(wo die Summe ohnehin 0 ≠ 1 wäre), muss die 1. Ganzzahl ungleich Null sein. Die einzige Ganzzahl ungleich Null im Array ist die 1, daher muss es die erste sein. Daher ist dies der einzige Fall, in dem die Summe aller Ganzzahlen im Array 1 ist, da die kleinstmögliche Summe eines Paares positiver Ganzzahlen Σ {1,1} = 2 ist, da die kleinste positive Ganzzahl 1 ist Jede Ganzzahl in einer Basisrepräsentation ist nicht negativ, so dass die Summe nur 1 ist, um nur eine 1 zu haben, und alle anderen Ganzzahlen sind 0. Daher können wir nur überprüfen, ob die Summe aller Ganzzahlen in der Array ist 1.

Der Code bewirkt Folgendes:

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 Bytes

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

Probieren Sie es online!

Python 2 , 98 50 Bytes

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

Probieren Sie es online!

Excel, 40 36 Bytes

^{4 Bytes von CallumDA gespeichert}

Excel kann das sicher, aber die Korrektur von Fehlern fügt 11 Bytes hinzu

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

Die Eingabe erfolgt in Zelle A1. Ausgang ist TRUEoderFALSE

Wenn es erlaubt wäre, entweder einen FALSEoder einen #NUM!Fehler für falsche Werte zurückzugeben, wären es nur 25 Bytes:

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

05AB1E , 8 Bytes

Y(IÄÝm¹å

Probieren Sie es online! oder als Testsuite

Erläuterung

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 Bytes

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

4 Bytes dank Arnauld gespeichert.

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 Bytes

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

Probieren Sie es online!

MATL , 9 8 Bytes

2_y|:q^m

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Wie es funktioniert

Betrachten Sie die Eingabe -8als Beispiel

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

Oktave , 28 Bytes

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

Dies definiert eine anonyme Funktion. Der Ansatz ähnelt dem in meiner MATL-Antwort.

Probieren Sie es 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

Mit einem Regex arbeiten

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

Python 3, 34 Bytes

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

JavaScript (ES6), 21 Byte

Eine rekursive Funktion, die 0oder zurückgibt true.

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

Wie es funktioniert

Dies beinhaltet keinen expliziten Test - wie nungerade oder abs(n)weniger als eins -, um die Rekursion vorzeitig zu stoppen, wenn die Eingabe keine exakte Potenz von -2 ist.

Wir verlassen nur, wenn nentweder 1oder genau gleich ist 0.

Dies funktioniert jedoch, da ein IEEE-754-Float 0aufgrund eines arithmetischen Unterlaufs eventuell auf gerundet wird, wenn er durch 2 (oder -2) mal genug geteilt wird .

Testfälle

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 Bytes

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

Probieren Sie es online!

Java 7, 55 Bytes

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

Erläuterung:

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

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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

Haskell, 24 23 Bytes

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

Definiert eine Funktion, fdie 1für Potenzen von -2 und 0anders zurückgibt .

Eine Golfversion meines ersten Beitrags zur anderen Herausforderung .

Javascript (ES7), 45 Byte

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

Perl 6 , 21 Bytes

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

Versuch es

Erweitert:

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

Beachten Sie, dass 0.lsbkehrt Nildie eine Warnung erzeugt , wenn es als Nummer verwendet, so dass der definierte oder Betreiber  //verwendet wird.
(Stellen Sie sich vor //wie ||mit einer anderen Neigung)

Ein Methodenaufruf ohne Aufruf, bei dem ein Term erwartet wird, wird implizit aufgerufen $_. ( .lsb)

Funktioniert auch mit.msb .

Prolog (SWI) , 44 Bytes

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

Online-Dolmetscher

Python , 24 Bytes

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

Probieren Sie es online!

Der Bittrick k&k-1==0prüft, ob keine Potenz von 2 (oder k==0) ist. Wenn Sie dies auf k=n*nas n*n&n*n-1==0prüfen, erfahren Sie, ob abs(n)eine Potenz von 2 vorliegt.

Um weiter zu sehen, ob neine Potenz von -2 ist, müssen wir nur das überprüfen n%3==1. Dies funktioniert, weil mod 3, der Wert -2 gleich 1 ist, also sind seine Potenzen 1. Im Gegensatz dazu sind ihre Negationen 2 mod 3 und natürlich ergibt 0 0 mod 3.

Wir kombinieren die Prüfungen n*n&n*n-1==0und n%3==1zu einem einzigen Ausdruck. Das erste kann mit <1for geschrieben werden ==0, da es niemals negativ ist. Das n%3==1entspricht n%3%2, 0 oder 1 gebend. Also können wir sie als kombinieren n*n&n*n-1<n%3%2.

R, 22 Bytes

Übernimmt Eingaben von stdin, gibt TRUEoder FALSEentsprechend zurück.

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

Ich bin nicht zu 100% sicher, dass dies eine gültige Antwort ist, da es nur für ganze Zahlen bis zur Größenbeschränkung von R funktioniert und wenn die ganzen Zahlen nicht begrenzt wären, würde es nicht funktionieren. In den Regeln heißt es jedoch:

Es gelten die üblichen Überlaufregeln für Ganzzahlen: Ihre Lösung muss in der Lage sein, für beliebig große Ganzzahlen in einer hypothetischen (oder möglicherweise realen) Version Ihrer Sprache zu arbeiten, in der standardmäßig alle Ganzzahlen unbegrenzt sind, Ihr Programm jedoch aufgrund der Implementierung in der Praxis fehlschlägt Ganzzahlen, die so groß sind, werden nicht unterstützt, was die Lösung nicht ungültig macht.

In einer hypothetischen Version von R , die nicht unbegrenzt ganze Zahlen erlauben, dann könnten wir den folgenden Code für die gleiche Byteanzahl verwenden:

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

Natürlich gibt der obige Code in real R nur Error in 0:Inf : result would be too long a vector.

BC 88 Bytes

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"

Ich habe dies in einer Datei neg2.shund es druckt 1für Befugnisse von -2und 0anders

Ich weiß, es ist sehr lang, aber es hat Spaß gemacht

Prüfung

$ 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

Erläuterung

Der Hauptkörper hat zwei Hälften, beide versuchen für Potenzen von gleich Null zu sein -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 Bytes

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

Probieren Sie es online!

Fourier , 53 Bytes

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

Ich werde später daran arbeiten, Golf zu spielen.

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

Wo die Ausgabe 0für Falschgeld und 1für Wahrhaftigkeit ist .

Probieren Sie es online!

Casio BASIC , 76 Bytes

Beachten Sie, dass auf meinem Taschenrechner 76 Byte stehen.

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

Dies ist mein erstes Projekt in Casio BASIC ... Ich hätte nie gedacht, dass ich so anständige Programme auf einem Taschenrechner schreiben könnte: D

Python 2.7, 40 Bytes

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

Dank an Mr. Xcoder für den ursprünglichen Code mit einer Länge von 43 Bytes. Musste als separate Antwort posten, da ich nicht genug Reputation habe, um Kommentare abzugeben.

Retina , 27 Bytes

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

Probieren Sie es online!

Nimmt Eingaben in Unary auf, was für Retina ziemlich üblich ist. Die ersten beiden Zeilen sind aufgrund der ersten beiden Codezeilen des Lernprogrammeintrags teilweise unärgerlich für die Binärkonvertierung (jedes fremde 1s führt dazu, dass die Übereinstimmung trotzdem fehlschlägt), während die letzte Zeile nach einer Potenz von vier oder einer negativen ungeraden Potenz sucht von zwei.

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

Probieren Sie es online!

Diesmal bin ich teilweise unärgerlich, um vier Konvertierungen zu stützen. ^1_*$Potenzen von vier enden als, während negative ungerade Potenzen von zwei als enden ^-11_*$.

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

Probieren Sie es online!

Dieses Mal teile ich einfach so oft ich kann durch vier und überprüfe nach 1oder -11am Ende.

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

Probieren Sie es online!

Eine andere Art, durch vier zu teilen. Und immer noch ärgerlich 27 Bytes ...

Schema, 60 Bytes

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

Rekursive Lösung.