Ist diese Zahl eine ganzzahlige Potenz von -2?


41

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 Wettbewerb: Die Antwort mit den wenigsten Bytes (in der von Ihnen gewählten Codierung) ist der Gewinner.


17
@KritixiLithos Ich verstehe nicht, warum es sollte. Es gibt keine isolche Ganzzahl , dass(-2)^i = 2
am

2
Sind die Exponenten positiv oder -0.5sollten gültig sein, da es 2 ^ (- 1) ist .
Mr. Xcoder

1
@ Mr.Xcoder, Da Eingaben immer Ganzzahlen sind , ist ein negativer Exponent nicht erforderlich (oder möglich).
Toby Speight

1
@ Sigsegv vielleicht während iist nicht natürlich
Mr. Xcoder

2
@ Jason, so viele wie unterstützt / natürlich in Ihrer Sprache - siehe die dritte Regel. Und es ist Code-Golf, weil es ein objektives Gewinnkriterium braucht , um hier zum Thema zu kommen - "eine ansprechende Lösung" bringt es nicht (obwohl mir die Mathematica-Antwort gefällt - das hat mich überrascht).
Toby Speight

Antworten:


26

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.

Hilft es zu berücksichtigen, dass gerade Potenzen von -2 ganzzahlige Potenzen von 4 sind? Ich mag die Idee, mit -2 zu multiplizieren, um alles positiv zu machen - obwohl ich enttäuscht bin, bis jetzt kein bisschen herumzudrehen.
Toby Speight

5
@TobySpeight Wenn Sie sie als Zweierpotenzen behandeln, sparen Sie tatsächlich 5 Bytes. Anfangs habe ich Potenzen von 4 verwendet, aber Log[4,...]ist länger als Log2@...und IntegerQist länger als EvenQ.
Martin Ender


12

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!


print g(8)DruckeFalse
Felipe Nardi Batista

2
@FelipeNardiBatista sollte es nicht?
Mr. Xcoder

2
Entschuldigung, mein Beispiel war schlecht, print g(4)macht das gleiche
Felipe Nardi Batista

Warten Sie, es gibt einen kleinen Fehler, der ihn in Kürze
behebt

1
Ich habe einen ;anstelle eines Zeilenumbruchs gesetzt ... Entschuldigung. Behoben @FelipeNardiBatista
Mr. Xcoder

11

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 < BV 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 dV 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.

1
Puh, es hat
einige

Ich würde es hassen zu sehen, wie eine Erklärung für ein langes Programm dann aussehen würde ...
Boboquack

1
@boboquack Hier erkläre ich, warum ich das Base-Conversion-Zeug verwende. Ich denke nicht, dass eine Erklärung für lange Programme so lang wäre. Ein Beitrag kann bis zu 30000 Abschriften enthalten, und Erklärungen für längere Sendungen wären sowieso knapper. Außerdem habe ich viel längere Erklärungen gelesen, und sie sind nicht so langweilig.
Erik der Outgolfer



10

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

Hier ist eine kleine Verbesserung:=IFERROR(-2^IMREAL(IMLOG2(A1)),1)=A1
CallumDA

1
@ CallumDA Danke! Ich habe versucht, einen Weg zu finden, die komplexen Zahlenfunktionen zu verwenden, aber alles, was ich mir ausgedacht habe, war länger.
Ingenieur Toast

9

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

Warum die Gegenstimme?
Kritixi Lithos

@KritixiLithos: Scheint, als hätte jemand alle Golfsprachen abgelehnt.
Emigna

6
Bemerkte das auch. Obwohl ich PPCG noch nicht lange kenne, habe ich gelernt, dass kreative und interessante Lösungen in Standardsprachen weitaus mehr geschätzt werden als 3-Byte-Lösungen in Golfsprachen. Es gibt jedoch einige Leute, die (leider) sehr kreative Lösungen in Golfsprachen ablehnen, einfach weil sie denken, dass alles eingebaut ist und nicht verstehen, wie gut die Algorithmen sind (obwohl sie in Golfsprachen geschrieben sind). +1 für die unglaubliche Lösung @Emigna
Mr. Xcoder

ÄLY(småOfür 8. Y(sÄLm¢Zfür 8 ... Nevermind, alle 8.
Magic Octopus Urn

9

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


Warum sehe ich einige Fehler (vor den wahren / falschen Werten), wenn ich auf "Code-Snippet ausführen" klicke?
Numbermaniac

@numbermaniac Ich bin mir nicht sicher, ob Sie einen Browser verwenden, der ES6 nicht vollständig unterstützt.
Tom

Welp, aktualisiert und erneut versucht, keine Fehler. Ich bin nicht sicher, was beim ersten Mal passiert ist.
Numbermaniac


8

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

Wenn ich Ihre Erklärung richtig verstehe, wird bei der Eingabe nein Array mit der Größe nals Zwischenschritt erstellt. Gute Arbeit, dass Effizienz hier kein Kriterium ist!
Toby Speight

2
@Toby Natürlich! Das ist Code-Golf. Wer kümmert sich um Effizienz? :-D
Luis Mendo


6

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

5

Python 3, 34 Bytes

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

5

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



4

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

Der nicht-rekursive Weg ist kürzer um 5 Bytes: boolean c(int n){while(0==n%-2)n/=-2;return 1==n;}.
Olivier Grégoire

Leider @ OlivierGrégoire dass man funktioniert nicht n=0in Java, weil 0%-2==0sein wird trueund 0/-2ist nach wie vor 0, eine Endlosschleife verursacht, weshalb ich den zusätzlichen n==0?0>1Teil meiner rekursive Methode.
Kevin Cruijssen

Schön entdeckt!
Olivier Grégoire

4

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 .


3

Javascript (ES7), 45 Byte

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

Math.abs (x) ist länger als x> 0? X: -x, 11 Byte bis 8 Byte. Sie sollten auch in der Lage sein, -2 ** ... anstelle von -1 ... zu tun, um das zweite Math.abs (x)
fəˈnəˈtɪk am

Was ist das Besondere an ES7?
Arjun

@ DobbyTheFree-Elf, **ist.
Qwertiy

3

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 .


Ich mag dieses!
Tale852150


3

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.


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.


2

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

Ich hätte nie mit Trigonometrie gerechnet! Gute Antwort!
Toby Speight


2

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!


In der Algo-Beschreibung wäre es nicht besser, die P-Variable nicht zu verwenden und zu schreiben. Wenn G * G> X * X dann ...?
RosLuP

@RosLuP Das wäre besser, aber Fourier würde das einfach so behandeln(G*G > X)*X
Beta Decay

2

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


1

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.


Es ist eine Art von der gleichen Sache, da ich meine Antwort versions universal gemacht haben, so dass es sowohl in Python 2 und 3 funktioniert Wenn Sie dies in Python 3 tun waren, sollten Sie hinzugefügt haben , int(input())die sich über die Grenze gegangen wäre von die defähnliche Funktion. Darüber hinaus müssen Sie in Python 3 verwenden, print()was 1 Byte verschwendet. Deshalb habe ich diesen Weg gewählt, weil es in Python 3 länger wird ...
Mr. Xcoder

1

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


1

Schema, 60 Bytes

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

Rekursive Lösung.

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.