Wenn Sie eine positive Ganzzahl in Binärform ohne führende Nullen ausdrücken und jede 1durch a (und jede 0durch a ersetzen ), stimmen dann alle Klammern überein?

In den meisten Fällen werden sie nicht. Beispiel: 9 ist eine 1001Binärzahl, ())(bei der nur die ersten beiden Klammern übereinstimmen.

Aber manchmal passen sie zusammen. Beispiel: 44 ist 101100binär, dh ()(()), alle linken Klammern haben eine übereinstimmende rechte Klammer.

Schreiben Sie ein Programm oder eine Funktion, die eine positive ganze Zahl zur Basis 10 verwendet und einen Wahrheitswert ausgibt oder zurückgibt , wenn die Binärklammern -Version der Zahl alle übereinstimmenden Klammern enthält. Wenn dies nicht der Fall ist, drucken Sie einen falschen Wert oder geben Sie ihn zurück .

Der kürzeste Code in Bytes gewinnt.

Verwandte OEIS-Sequenz.

Wahrheitsbeispiele unter 100:

2, 10, 12, 42, 44, 50, 52, 56

Falsche Beispiele unter 100:

1, 3, 4, 5, 6, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43, 45, 46, 47, 48, 49, 51, 53, 54, 55, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99

TeaScript , 9 Bytes 16 18 20 22 24

2 Bytes gespart dank @ETHproductions

!x÷W(n,¢)

Woah. Das ist kurz Verwendet den @ xnor-Ansatz. Dies wird die rekursive Ersetzungsfunktion ( W) verwenden, die alle 10gleich ()mit nichts ersetzt. Wenn die Zeichenfolge leer ist, ist sie ausgeglichen.

Wenn Sie eine Version von TeaScript verwenden, die nach dem Posten dieser Aufforderung erstellt wurde, können dies 7 Bytes werden:

!x÷W(n)

Ungolfed

!xT(2)W(n,``)

Erläuterung

!      // NOT, returns true if empty string, else false
 xT(2)   // To binary
 W(n,``) // n is 10, reclusive replaces 10 or (), with nothing.

Pyth, 10 Bytes

!uscG`T.BQ

Probieren Sie diese Testsuite im Pyth-Compiler aus.

Wie es funktioniert

              (implicit) Store the evaluated input in Q.
       .BQ    Return the binary string representation of Q.
 u            Reduce w/base case; set G to .BQ and begin a loop:
     `T         Return str(10) = "10".
   cG           Split G (looping variable) at occurrences of "10".
  s             Join the pieces without separators.
              Set G to the returned string.
              If the value of G changed, repeat the loop.
              This will eventually result in either an empty string or a
              non-empty string without occurrences of "10".
!             Return (and print) the logical NOT of the resulting string.

Python2, 87 Bytes

try:exec"print 1,"+"".join(["],","["][int(c)]for c in bin(input())[2:])
except:print 0

Eine schreckliche Implementierung, die Syntaxfehler missbraucht.

JavaScript (ES6), 55 54 51 Byte

n=>![...n.toString(d=2)].some(c=>(d+=c*2-1)<2)*d==2

Gespeicherte Bytes dank @ Vɪʜᴀɴ und @xsot !

Erläuterung

n=>
  ![...n.toString(    // convert the input to an array of binary digits
    d=2)]             // d = current depth (+2)
      .some(c=>       // iterate through the digits
        (d+=c*2-1)    // increment or decrement the parenthesis depth
          <2          // if the depth goes negative, return false
      )*
        d==2          // if we finished at a depth of 0, return true

Python 2, 45 Bytes

f=lambda n,i=1:i*n>0<f(n/2,i+(-1)**n)or n<i<2

Eine rekursive Funktion. Liest Binärziffern nvom Ende und zählt idie aktuelle Verschachtelungsebene der Parens. Wenn es darunter fällt 0, lehnen Sie ab. Wenn wir am Start angelangt sind, wird geprüft, ob die Zählung erfolgt 0.

Eigentlich fangen wir mit der Zählung an i=1, um zu überprüfen, ob sie gefallen ist 0. Der einzige Terminalerfolgsfall ist n==0und i==1, geprüft mit n<i<2. Wir zwingen diese Prüfung passieren , wenn n==0, oder wenn iStürzen 0, in diesem Fall ist es nicht automatisch.

feersum sparte zwei bytes durch restrukturierung der nichtrekursiven fälle mit ungleichheit zum kurzschluss.

CJam, 11 Bytes

ri2b"}{"f=~

Dies ist ein bisschen unrein: Bei parenthifizierbaren Zahlen werden ein oder mehrere Blöcke gedruckt. Bei nicht parenthifizierbaren Zahlen stürzt das Programm ab, ohne dass etwas an STDOUT ausgegeben wird. Wenn Sie dies online im CJam-Interpreter versuchen , beachten Sie, dass nicht zwischen STDOUT und STDERR unterschieden wird.

Da nicht leere / leere Zeichenfolgen in CJam wahr / falsch sind und die gedruckte Ausgabe immer eine Zeichenfolge ist, entspricht sie möglicherweise den Regeln. Bei den zusätzlichen Kosten von 3 weiteren Bytes für insgesamt 14 Bytes können wir tatsächlich eine wahrheitsgemäße oder falsche Zeichenfolge auf dem Stapel belassen , der gedruckt wird:

Lri2b"}{"f=~]s

Dies stürzt immer noch für nicht parenthifizierbare Nummern ab, was standardmäßig zulässig ist .

Testläufe

$ cjam <(echo 'ri2b"}{"f=~') <<< 52 2>&-; echo
{{}{}}
$ cjam <(echo 'ri2b"}{"f=~') <<< 53 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 54 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 55 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 56 2>&-; echo
{{{}}}

Wie es funktioniert

ri          e# Read an integer from STDIN.
  2b        e# Push the array of its binary digits.
    "}{"f=  e# Replace 0's with }'s and 1's with {'s.
          ~ e# Evaluate the resulting string.
            e# If the brackets match, this pushes one or more blocks.
            e# If the brackets do not match, the interpreter crashes.

CJam, 15 Bytes

ri2bs_,{As/s}*!

Probieren Sie diese Geige im CJam-Interpreter aus oder überprüfen Sie alle Testfälle auf einmal .

Wie es funktioniert

ri               Read an integer from STDIN.
  2b             Push the array of its binary digits.
    s            Cast to string.
     _,          Push the string's length.
       {    }*   Do that many times:
        As/        Split at occurrences of "10".
           s       Cast to string to flatten the array of strings.
              !  Push the logical NOT of the result.

Python, 51 Bytes

lambda n:eval("'0b'==bin(n)"+".replace('10','')"*n)

Eine anonyme Funktion. Wird zu einem Ausdruck ausgewertet, der aussieht wie

'0b'==bin(n).replace('10','').replace('10','').replace('10','')...

Jeder Ersatz entfernt alle 10, die entsprechen (). Nachdem alle Ersetzungen vorgenommen wurden, gibt die Funktion zurück, ob es sich nur noch um das binäre Präfix handelt 0b. Es ist mehr als ausreichend, nErsetzungen vorzunehmen , da eine kzweistellige Zahl höchstens k/2Schritte benötigt und ihr Wert am höchsten ist 2**k.

Rubin, 40

->i{n='%0b'%i;1while n.slice!'10';n<?0}

Einfache Stringmanipulation. Drops '10', bis es keine mehr gibt.

Im Ernst , 17 Bytes

,;2@¡@`""9u$(Æ`nY

Ausgaben 0für false und 1für true. Probieren Sie es online aus .

Erläuterung:

,      get value from stdin
;      dupe top of stack
2@¡    pop a: push a string containing the binary representation of a (swapping to get order of operands correct)
@      swap top two elements to get original input back on top
`""9u$(Æ` define a function:
  ""     push empty string
  9u$    push "10" (push 9, add 1, stringify)
  (      rotate stack right by 1
  Æ      pop a,b,c: push a.replace(b,c) (replace all occurrences of "10" in the binary string with "")
n      pop f,a: call f a times
Y      pop a: push boolean negation of a (1 if a is falsey else 0)

Japt, 23 Bytes

Japt ist eine verkürzte Version von Ja vaScri pt . Dolmetscher

Us2 a e@+X?++P:P-- &&!P

Das erinnert mich daran, wie weit Japt im Vergleich zu TeaScript noch ist. Nachdem ich den Interpreter in den nächsten Tagen überarbeitet habe, möchte ich "Shortcut" -Zeichen wie Vɪʜᴀɴs hinzufügen.

Wie es funktioniert

       // Implicit: U = input number, P = empty string
Us2 a  // Convert U to base 2, then split the digits into an array.
e@     // Assert that every item X in this array returns truthily to:
 +X?   //  If X = 1,
 ++P   //   ++P. ++(empty string) returns 1.
 :P--  //  Otherwise, P--. Returns false if P is now -1.
&&!P   // Return the final result && !P (true if P is 0; false otherwise).
       // Implicit: output final expression

Kurz nach dieser Herausforderung half mir @ Vɪʜᴀɴ (jetzt als @Downgoat bekannt), eine Funktion zum rekursiven Ersetzen wie Win der TeaScript-Antwort zu implementieren. Dies bedeutet, dass diese Herausforderung jetzt in nur 5 Bytes durchgeführt werden kann:

!¢eAs  // Implicit: U = input integer, A = 10
 ¢     // Convert U to binary.
  eAs  // Recursively remove instances of A.toString().
!      // Return the logical NOT of the result (true only for the empty string).

Online testen!

Mathematica, 49 Bytes

(#~IntegerDigits~2//.{x___,1,0,y___}:>{x,y})=={}&

Oktave, 48 Bytes

@(a)~((b=cumsum(2*dec2bin(a)-97))(end)|any(b<0))

C ++, 104 94 Bytes

#include<iostream>
int n,c;int main(){for(std::cin>>n;n&c>=0;n>>=1)c+=n&1?-1:1;std::cout<<!c;}

Mit diesem Compiler ausführen , muss vor der Ausführung die Standardeingabe angegeben werden.

Erläuterung

• Deklarationen außerhalb von main werden auf 0 initialisiert.
• Das Lesen einer Dezimalstelle wird implizit in eine Binärzahl konvertiert, da dies ein Computer ist.
• Wir prüfen Bits / Klammern von rechts nach links wegen n>>=1.
• c+=n&1?-1:1Zählt die offenen Klammern ).
• n&c>=0 stoppt, wenn nur führende Nullen übrig bleiben oder Klammern mehr schließen als öffnen.

Haskell, 49 46 Bytes

0#l=l==1
_#0=2<1
n#l=div n 2#(l+(-1)^n)
f=(#1)

Anwendungsbeispiel: f 13-> False.

Ich verfolge die Verschachtelungsebene lwie viele andere Antworten. Der "ausgeglichene" Fall wird jedoch durch dargestellt 1, so dass der "mehr- )als- (" Fall vorliegt 0.

PS: Die Anpassung der Verschachtelungsebene wurde l+(-1)^nin der Antwort von xnor gefunden .

Python 2, 60 57 56 55 53 52 50 49 Bytes

n=input()
i=1
while i*n:i+=1|n%-2;n/=2
print i==1

Vielen Dank an xnor für das Speichern von zwei Bytes und feersum für die Erhöhung der letzten Byteanzahl auf 49!

Erläuterung

Die eingegebene Nummer nwird von ihrem niedrigstwertigen Bit verarbeitet. iist ein Zähler, der die Anzahl der Nullen und Einsen verfolgt. Beachten Sie, dass es 1zum Speichern eines Bytes initialisiert ist . Die Schleife wird abgebrochen, bevor n0 erreicht wird, wenn die Anzahl der Einsen die Anzahl der Nullen überschreitet ( i<=0).

Für das Ausbalancieren der Klammern sind zwei Bedingungen erforderlich:

• Die Anzahl der Nullen und Einsen ist gleich (dh i==1)
• Die Anzahl der Einsen übersteigt dabei niemals die Anzahl der Nullen (dh die Schleife wird nicht vorzeitig abgebrochen n==0). Edit: Ich habe festgestellt, dass diese Bedingung nicht notwendig ist, da isie nicht positiv sein muss, wenn n!=0die vorherige Bedingung ausreicht.

JavaScript ES5, 118 87 85 82 77 Bytes

Interessante Technik meiner Meinung nach. Minus verdammt viel, dank @ETHproductions und @NotthatCharles

function p(x){x=x.toString(2);while(/10/.test(x))x=x.replace(10,"");return!x}

JavaScript ES6, 77 57 56 54 Bytes

-21 Bytes zu ETHproductions.

x=>[...x=x.toString(2)].map(_=>x=x.replace(10,""))&&!x

D, 209 170 Bytes

import std.stdio;import std.format;import std.conv;void main(char[][]a){string b=format("%b",to!int(a[1]));int i;foreach(c;b){i+=c=='1'?1:-1;if(i<0)break;}writeln(i==0);}

Dies macht genau das, was es tun soll, ohne irgendwelche Zusätze oder Vorteile.

C 67 Bytes

n;main(i){for(scanf("%d",&n);n*i;n/=2)i+=1-n%2*2;putchar(48+!~-i);}

Ziemlich genau ein Port meines Python-Beitrags.

Prolog, 147 Bytes

b(N,[X|L]):-N>1,X is N mod 2,Y is N//2,b(Y,L).
b(N,[N]).
q([H|T],N):-N>=0,(H=0->X is N+1;X is N-1),q(T,X).
q([],N):-N=0.
p(X):-b(X,L),!,q(L,0).

Wie es funktioniert

b(N,[X|L]):-N>1,X is N mod 2,Y is N//2,b(Y,L).
b(N,[N]).

Konvertiert die Dezimalzahl N in ihre binäre Darstellung als Liste (umgekehrt). Bedeutung:

b(42,[0,1,0,1,0,1]) is true

Dann:

q([H|T],N):-N>=0,(H=0->X is N+1;X is N-1),q(T,X).
q([],N):-N=0.

Rekurs über Liste [H | T], wobei N erhöht wird, wenn das Kopfelement 0 ist, andernfalls wird es verringert.
Wenn N zu irgendeinem Zeitpunkt negativ wird oder wenn N am Ende nicht 0 ist, wird false zurückgegeben, andernfalls true.

Der Einschnitt

p(X):-b(X,L),!,q(L,0).

Gibt es eine Möglichkeit, das Backtracking zu verhindern und nicht-binäre Lösungen für das

Testen von b (N, [N]) zu finden ?
Probieren Sie es hier online aus.
Führen Sie die folgende Abfrage aus:

p(42).

PowerShell, 106 Bytes

param($a)$b=[convert]::ToString($a,2);1..$b.Length|%{if($b[$_-1]%2){$c++}else{$c--}if($c-lt0){0;exit}};!$c

_{Ich bin mir sicher, dass ich keine Wettbewerbe mit kürzester Dauer gewinnen werde. Aber hey, zumindest schlägt es Java?}

Verwendet den sehr langen .NET-Aufruf [convert]::ToString($a,2), um unsere Eingabenummer in eine Zeichenfolge zu konvertieren, die die Binärziffern darstellt. Wir durchlaufen diese Zeichenfolge dann mit for-loop 1..$b.length|%{..}. In jeder Schleife erhöhen wir unseren Zähler , wenn unsere Ziffer a ist 1(ausgewertet mit, %2anstatt -eq1ein paar Bytes zu speichern). sonst dekrementieren wir es. Wenn wir jemals negativ werden, bedeutet dies, dass wir mehr )als bisher (angetroffen haben, also geben wir 0und aus exit. Sobald wir die Schleife durchlaufen haben, $cist entweder 0oder eine Zahl >0, also nehmen wir das logische Nicht !davon, was ausgegeben wird.

Dies hat die Eigenheit, auszugeben, 0wenn die Parens nicht übereinstimmen, weil wir mehr haben ), aber auszugeben, Falsewenn die Parens nicht übereinstimmen, weil wir mehr haben (. Im Wesentlichen funktional äquivalente falsche Aussagen, nur interessant. Wenn alle Parens übereinstimmen, wird ausgegeben True.

GNU Sed (mit eval extension), 27

s/.*/dc -e2o&p/e
:
s/10//
t

Sed hat nicht wirklich eine definierte Vorstellung von Wahrheit und Falschheit, daher behaupte ich hier, dass die leere Zeichenfolge Wahrheit bedeutet und alle anderen Zeichenfolgen Falschheit bedeuten.

Wenn dies nicht akzeptabel ist, können wir Folgendes tun:

GNU Sed (mit eval extension), 44

s/.*/dc -e2o&p/e
:
s/10//
t
s/.\+/0/
s/^$/1/

Dies gibt 1 für wahr und 0 sonst.

𝔼𝕊𝕄𝕚𝕟 (ESMin), 21 Zeichen / 43 Byte

ô⟦ïßḂ]Ĉ⇀+$?⧺Ḁ:Ḁ‡)⅋!Ḁ)

Try it here (Firefox only).

Beachten Sie, dass dies Variablen verwendet, die für Zahlen vordefiniert sind (insbesondere 2 und 0). Es gibt vordefinierte Zahlenvariablen von 0 bis 256.

19 Zeichen / 40 Byte, nicht wettbewerbsfähig

⟦ïßḂ]Ĉ⇀+$?⧺Ḁ:Ḁ‡)⅋!Ḁ

Try it here (Firefox only).

Beschlossen, implizite Ausgabe zu implementieren ... Vorherige Ausgabeformulare werden jedoch weiterhin unterstützt, sodass Sie mehrere Ausgabeoptionen erhalten!

Java, 129 131 Bytes

boolean T(int i){int j=0,k=0;for(char[]a=Integer.toString(i,2).toCharArray();j<a.length&&k>=0;j++){k+=a[j]=='1'?1:-1;}return k==0;}

Kann wahrscheinlich gekürzt werden. Erklärung zu kommen. Danke an Geobits für 4 Bytes!

C ++, 61 Bytes

Ich denke, die aktuelle C ++ - Antwort ist falsch: Sie gibt einen Wahrheitswert für alle geraden Zahlen zurück, z. B. 4. Haftungsausschluss: Ich konnte den genannten Compiler nicht verwenden, also habe ich g ++ 4.8.4 verwendet. Das Problem liegt in der Verwendung des binären UND-Operators anstelle des logischen UND, das zum vorzeitigen Aufbrechen verwendet wird, wenn die Anzahl der schließenden Klammern die Anzahl der öffnenden Klammern überschreitet. Dieser Ansatz könnte funktionieren, wenn trueals ein Wort mit einem alles wahren Bitmuster dargestellt wird. Auf meinem System und wahrscheinlich auf den meisten anderen Systemen trueist dies äquivalent zu 1; nur ein bisschen ist wahr. Auch n/=2ist kürzer als n>>=1. Hier ist eine verbesserte Version als Funktion:

int f(int n,int c=0){for(;c>=0&&n;n/=2)c+=n&1?-1:1;return c;}

𝔼𝕊𝕄𝕚𝕟 (sehr nicht konkurrierend), 6 Zeichen / 8 Byte

!ïⓑĦⅩ

Try it here (Firefox only).

Ich habe mich entschlossen, diese Herausforderung nach einer sehr, sehr langen Zeit erneut anzunehmen. 𝔼𝕊𝕄𝕚𝕟 ist so viel besser geworden.

Der Grund, warum dies eine separate Antwort ist, ist, dass die beiden Versionen fast völlig unterschiedlich sind.

Erläuterung

Konvertiert Eingaben in Binärdaten, ersetzt rekursiv Instanzen von 10 und prüft dann, ob das Ergebnis eine leere Zeichenfolge ist.

C # 98 Bytes

bool f(int m){int i=0;foreach(char s in Convert.ToString((m),2)){if(s=='1')i+=2;i--;}return i==0;}

offen für Vorschläge. Ich mag diese Herausforderung, obwohl sie altmodisch ist