Wir bezeichnen eine Parens-Gruppe als Open Paren (, als Matching Close Paren )und als alles, was sich in ihnen befindet.

Eine Parens-Gruppe oder Zeichenfolge wird als Klammerausgleich bezeichnet, wenn sie entweder nichts oder nur 2 Klammerausgleichs-Parens-Gruppen enthält.

Beispielsweise:

The string   "(()())()"      is parenthesly balanced
              (    )()       Because it contains exactly 2 parenthesly balanced parens groups
               ()()          The left one is parenthesly balanced because it contains 2 parenthesly balanced parens groups (balanced because they are empty). The right one is parenthesly balanced because it contains nothing.

Gleichfalls:

The string   "(()(()))()"    is not parenthesly balanced
              (      )()     Because it contains a parens group that is not parenthesly balanced: the left one
               ()(  )        The left one is not balanced because it contains a parens group that is not balanced: the right one
                  ()         The right one is not balanced because it only contains one balanced group.

Eine in Klammern gesetzte Zeichenfolge oder eine Parens-Gruppe sollte also entweder:

• Überhaupt nichts enthalten.
• Oder Sie enthalten nur und genau 2 in Klammern gesetzte Gruppen. Es sollte nichts anderes enthalten.

Aufgabe:

Ihre Aufgabe ist es, eine Funktion oder ein Programm zu schreiben, das prüft, ob eine bestimmte Zeichenfolge in Klammern steht oder nicht.

Eingang:

Die Eingabe erfolgt als Zeichenfolge oder Liste von Zeichen oder ähnlichem. Sie können davon ausgehen, dass die Zeichenfolge nur aus den Zeichen '('und besteht ')'. Sie können auch davon ausgehen, dass jedes offene Paren (ein passendes enges Paren )hat. Machen Sie sich also keine Gedanken über Zeichenfolgen wie "((("oder ")("oder "(())("...

^{Hinweis: Wie bereits erwähnt durch @DigitalTrauma in seinem Kommentar unten, dann ist es in Ordnung , die subtitute ()Combo durch andere Zeichen (wie <>, [], ...), wenn es zusätzliche Arbeit verursacht , wie in einigen Sprachen zu entkommen}

Ausgabe:

Alles, was signalisiert, ob die Zeichenfolge in Klammern steht oder nicht (wahr oder falsch, 1 oder 0, ...). Bitte geben Sie in Ihrer Antwort an, welche Ergebnisse Ihre Funktion / Ihr Programm erwarten.

Beispiele:

""                                        => True
"()()"                                    => True
"()(()())"                                => True
"(()(()(()())))(()())"                    => True
"(((((((()())())())())())())())()"        => True
"()"                                      => False
"()()()"                                  => False
"(())()"                                  => False
"()(()(())())"                            => False
"(()())(((((()())()))())())"              => False
"()(()()()())"                            => False
"()(()(()())()())"                        => False

^{Die letzten beiden Beispiele haben wirklich einen Unterschied gemacht!}

Viel Glück!

Japt v2, 20 Bytes

V="()"V¥iU1 eViV²1 V

Online testen!

Jeder hat die Herausforderung zunächst missverstanden, und obwohl jedes Klammerpaar eine gerade Anzahl von Unterpaaren enthalten musste, verlangt die Herausforderung tatsächlich 0 oder 2 Unterpaare. Hier ist meine überarbeitete Antwort mit der gleichen Technik wie zuvor.

Wir können die Herausforderung immer noch durch rekursives Ersetzen lösen. Die Sache ist, anstatt nur alle Vorkommen von zu entfernen ()(), müssen wir sicherstellen, dass sich nichts anderes im selben Wrapper befindet als das ()()(mit anderen Worten, nein ()()()()oder so etwas). Wir können dies tun , indem rekursiv ersetzt (()())mit ().

Das neue Problem besteht darin, dass die Eingabe selbst kein Paar äußerer Klammern enthält (da dies keine in Klammern gesetzte Zeichenfolge wäre), sodass wir sie in ein zusätzliches Paar einschließen müssen, um sie vollständig zu reduzieren. Schließlich ist das Endergebnis für ausgeglichene Zeichenfolgen jetzt ()anstelle der leeren Zeichenfolge. Wir überprüfen daher die Gleichheit, anstatt nur das logische NICHT der Ausgabe zu verwenden.

sed 4.2.2, 30

:
s/(()())/()/
t
/^()()$\|^$/q1

Probieren Sie es online aus .

Dies gibt einen Shell-Exit-Code von 1 für True und 0 für False zurück.

:               # label
s/(()())/()/    # replace "(()())" with "()"
t               # jump back to label if above replacement matched
/^()()$\|^$/q1  # exit code 1 if remaining buffer is exactly "()()" or empty
                # otherwise exit with code 0

Perl 5 -lp, 24 22 Bytes

$_=/^((<(?1)?>){2})?$/

Probieren Sie es online! Link enthält Testfälle. Bearbeiten: 2 Bytes dank @JoKing gespeichert. Erläuterung: Nur ein rekursiver regulärer Ausdruck. Die äußere Erfassungsgruppe stellt eine ausgeglichene Zeichenfolge dar, <gefolgt von einer optionalen ausgeglichenen Zeichenfolge, gefolgt von einer >zweifachen. Beachten Sie, dass die meisten anderen Antworten ()s verwenden können, dies jedoch zwei zusätzliche Bytes kostet:

$_=/^((\((?1)?\)){2})?$/

Probieren Sie es online! Link enthält Testfälle.

6502 Maschinencode- Routine, 48 Bytes

A0 00 84 FD A2 00 B1 FB F0 0E C8 C9 29 18 F0 06 8A 48 E6 FD 90 EE B0 0A E0 01
90 06 E0 02 38 D0 01 18 A5 FD F0 09 C6 FD 68 AA E8 B0 F5 90 D7 60

Erwartet einen Zeiger auf eine Zeichenfolge in $fb/, $fcdie nur (und enthalten soll ). Löscht das C-Flag (Übertragen), wenn die Zeichenfolge "paranthesalanced" ist, und setzt es ansonsten (was eine typische Redewendung beim 6502 ist, setze Übertragen "on error"). Macht bei ungültiger Eingabe nichts Sinn.

Obwohl der Algorithmus rekursiv ist, ruft er sich nicht selbst auf (was mehr Bytes erfordern und die Codeposition abhängig machen würde), sondern behält selbst eine Rekursionstiefe bei und verwendet "einfache" Verzweigung.

Kommentierte Demontage

; function to determine a string is "paranthesly balanced"
;
; input:
;   $fb/$fc: address of the string
; output:
;   C flag set if not balanced
; clobbers:
;   $fd:     recursion depth
;   A,X,Y

 .isparbal:
A0 00       LDY #$00            ; string index
84 FD       STY $FD             ; and recursion depth
 .isparbal_r:
A2 00       LDX #$00            ; set counter for parantheses pairs
 .next:
B1 FB       LDA ($FB),Y         ; load next character
F0 0E       BEQ .done           ; end of string -> to final checks
C8          INY                 ; increment string index
C9 29       CMP #$29            ; compare with ')'
18          CLC                 ; and reset carry
F0 06       BEQ .cont           ; if ')' do checks and unwind stack
8A          TXA                 ; save counter ...
48          PHA                 ; ... on stack
E6 FD       INC $FD             ; increment recursion depth
90 EE       BCC .isparbal_r     ; and recurse
 .cont:
B0 0A       BCS .unwind         ; on previous error, unwind directly
 .done:
E0 01       CPX #$01            ; less than one parantheses pair
90 06       BCC .unwind         ; -> ok and unwind
E0 02       CPX #$02            ; test for 2 parantheses pairs
38          SEC                 ; set error flag
D0 01       BNE .unwind         ; if not 2 -> is error and unwind
18          CLC                 ; clear error flag
 .unwind:
A5 FD       LDA $FD             ; check recursion depth
F0 09       BEQ .exit           ; 0 -> we're done
C6 FD       DEC $FD             ; otherwise decrement
68          PLA                 ; get "pair counter" ...
AA          TAX                 ; ... from stack
E8          INX                 ; and increment
B0 F5       BCS .unwind         ; continue unwinding on error
90 D7       BCC .next           ; otherwise continue reading string
 .exit:
60          RTS

Beispiel C64 Assembler Programm mit der Routine:

Online-Demo

Code in ca65- Syntax:

.import isparbal   ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

.bss
linebuf:        .res    256

.data
prompt:         .byte   "> ", $0
truestr:        .byte   "true", $0
falsestr:       .byte   "false", $0

.code
inputloop:
                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<linebuf       ; read string into buffer
                ldy     #>linebuf
                ldx     #0              ; effectively 256
                jsr     readline

                lda     #<linebuf       ; address of string to $fb/fc
                sta     $fb
                lda     #>linebuf
                sta     $fc
                jsr     isparbal        ; call function

                bcs     isfalse
                lda     #<truestr
                ldy     #>truestr
                bne     printresult
isfalse:        lda     #<falsestr
                ldy     #>falsestr
printresult:    jmp     $ab1e           ; output true/false and exit

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in A/Y, buffer length in X
.proc readline
                dex
                stx     $fb
                sta     $fc
                sty     $fd
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $2              ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     checkout        ; no -> check buffer size
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                beq     getkey          ; zero -> backspace not possible
                bne     prepout         ; skip checking buffer size for bs
checkout:       lda     $fe             ; buffer index
                cmp     $fb             ; check against buffer size
                beq     getkey          ; if it would overflow, loop again
prepout:        sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
output:         lda     $2              ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                lda     $2              ; load character
store:          cli                     ; enable interrupts
                cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                sta     ($fc),y         ; store terminator in buffer
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                inc     $cc             ; disable cursor blinking
                cli                     ; enable interrupts
                rts                     ; return
backspace:      dec     $fe             ; decrement buffer index
                bcs     getkey          ; and get next key
.endproc

V , 21 , 20 Bytes

é(Á)òÓ(“()()…)òø^()$

Probieren Sie es online! oder Überprüfen Sie alle Testfälle!

é(                      " Insert '(' at the beginning of the line
  Á)                    " Append ')' at the end
    ò         ò         " Recursively...
     Ó                  "   Remove...
      (                 "     '('
       “    …           "     (Limit the part that is removed to this section of the match)
        ()()            "     '()()'
             )          "     ')'
                        " (effectively, this replaces '(()())' with '()', but it's one byte shorter than the straightforward approach
               ø        " Count...
                ^()$    "   Lines containing exactly '()' and nothing more

Hexdump:

00000000: e928 c129 f2d3 2893 2829 2829 8529 f2f8  .(.)..(.()().)..
00000010: 5e28 2924                                ^()$

Brachylog , 28 Bytes

Ẹ|~c["(",A,")(",B,")"]∧A;B↰ᵐ

Probieren Sie es online!

Erläuterung

                                    --  The string perfectly balanced iff
Ẹ                                   --      the string is empty
 |                                  --  or
  ~c["(",A,")(",B,")"]              --      the string can be written id the format of "($A)($B)"
                      ∧             --          where
                       A;B ᵐ        --          both A and B
                          ↰         --          are perfectly balanced

C (gcc) 113 Bytes

p(a,r,e,n)char*a;{if(*a-40)return 1;for(r=1,e=0;e<2;r&=e++||*a==40)for(r*=n=p(++a);n+=*a++-40?~0:1;);r=r&&*a-40;}

Probieren Sie es online!

Erläuterung

p(a,r,e,n)char*a;{   // function and variable declaration
 if(*a-40)return 1;  // string does not start with '(', thus is empty
 for(r=1,e=0;e<2;    // r: return value, e: group id (look for exactly two groups)
 r&=e++||*a==40)     // after the first group, a second shall follow
  for(r*=n=p(++a);   // check that the group is itself balanced
  n+=*a++-40?~0:1;); // skip group
 r=r&&*a-40;}        // additionally, after those two groups there shall follow none

Probieren Sie es online!

MATL , 26 25 Bytes

oo~`tnw52B5LZttnb<]XB10X-

Probieren Sie es online!

Dank der Antwort von @ETHProductions für die Idee "replace (() ()) with ()" und des Fragekommentars von @JungHwan Min für die Idee, die Klammern als Binärziffern zu sehen.

Die Ausgabe ist ein leeres Array für Wahrhaftigkeit, eine positive Zahl für Falschgeld - was meines Erachtens in OPs Kommentar erlaubt ist: "Könnten Kategorien sein, dh Wahrheitswerte, um Wahrhaftigkeit zu signalisieren, und falsche Werte, um etwas anderes zu signalisieren." Wenn dies nicht der nFall ist , können wir am Ende für +1 Byte hinzufügen , um 0 als Wahrheits- und 1 als Falschausgabe zu erhalten.

Mit Kommentaren:

o         % Convert the parantheses to their ASCII codes
          %  40 for '(', 41 for ')'
o         % Parity - 1 for odd, 0 for even
~         % Not - change 0 to 1 and vice versa, so '(' is now 1 and ')' 0
          % Input char array is now a binary array B
`         % Do-while loop
  tn          % Get the length of the array 
  w           % Bring the array B back on top
  52B         % Push the binary value of 52 on stack
              %  [1 1 0 1 0 0] (equivalent to '(()())')
  5L          % Push the constant [1 0] for '()'
  Zt          % Replace the sequence [1 1 0 1 0 0] in array B
              %  with [1 0]
  tn          % Get the length of the array after replacement 
  b<          % Has it decreased? If so, continue loop
  ]       % end loop
          % Final value for balanced input will be
          %  either [1 0 1 0] for the remaining outer '()()'
          %  or an empty array [] for empty '' input
XB        % Convert the final binary array back to decimal
10X-      % Set difference, remove 10 from that result 
          % Result is [] empty array for balanced input, otherwise 
          %  some decimal number ≠ 10 for unbalanced input

C # (.NET Core) , 78 71 Bytes

f=s=>{var r=s.Replace("(()())","()");return r==s?s==""|s=="()()":f(r);}

Probieren Sie es online!

Haskell , 82-59 Bytes

all(`elem`[0,2]).foldl(#)[0]
b#'('=0:b
(x:y:z)#_=y+1:z++[x]

Probieren Sie es online!

Ich nehme an, es kann viel weiter golfen werden, da ich zum ersten Mal in Haskell Golf spiele. Daher sind Tricks und Kommentare mehr als willkommen.

BEARBEITEN - Danke an @nimi für das Speichern von 23 Bytes (mehr als 28% der ursprünglichen Einsendung :)

JavaScript (ES6), 63 Byte

Nimmt die Eingabe als Array von Zeichen. Gibt false zurück, wenn der Wert in Klammern angegeben ist, true , wenn der Wert nicht in Klammern angegeben ist.

a=>[...a,k=0].some(c=>c<')'?!(a[k]=-~a[k++]):a[k]=~5>>a[k--]&1)

Probieren Sie es online!

Kommentiert

a =>                     // a[] = input array of characters; we are going to reuse it to
  [                      // store the number of parenthesis groups at each depth
    ...a,                // append all characters
    k = 0                // initialize k = current depth to 0 and append a value that will
  ]                      // be treated as a final closing parenthesis for the root level
  .some(c =>             // for each character c in this array:
    c < ')' ?            //   if c is an opening parenthesis:
      !(                 //     increment the number of groups at the current depth
        a[k] = -~a[k++]  //     increment the depth
      )                  //     yield false
    :                    //   else:
      a[k] = ~5          //     make sure that the current depth contains either 0 or 2
             >> a[k--]   //     groups, by shifting the 1-complement of 5 (101 in binary)
             & 1         //     and testing the least significant bit
                         //     it resets the number of groups to 0 if the bit is not set
                         //     otherwise, it forces some() to return true
                         //     decrement the depth
  )                      // end of some()

Rekursiv, 54 Bytes

Die Verwendung von rekursiven Ersetzungen (wie in der Japt-Antwort von ETHproductions ) ist jedoch erheblich kürzer.

Übernimmt die Eingabe als Zeichenfolge. Gibt 1 für den Klammerausgleich zurück, 0 für den Klammerausgleich.

f=s=>s==(s=s.split`(()())`.join`()`)?!s|s=='()()':f(s)

Probieren Sie es online!

Rekursiv, 46 Bytes

Dieser wirft einen Rekursionsfehler für nicht in Klammern ausgewogen:

f=s=>!s|s=='()()'||f(s.split`(()())`.join`()`)

Probieren Sie es online!

Perl 6 ,  43 41  37 Bytes

{my rule f{\([<&f>**2]?\)};?/^<&f>**2$|^$/}

Probier es aus

{(my$f)=/\([<$f>**2]?\)/;?/^[<$f>**2]?$/}

Probier es aus

{$!=/\([<$!>**2]?\)/;?/^[<$!>**2]?$/}

Probier es aus

Erweitert:

{  # bare block lambda with implicit parameter $_

  $! = # store regex into $! (no need to declare it)
  /
    \(

      [
        <$!> ** 2 # recurse into regex twice
      ]?          # optionally

    \)
  /;


  ?      # boolify (causes it to be run against $_)

    /
      ^         # beginning of string

      <$!> ** 2 # match using regex twice

      $         # end of string

    |           # or

      ^ $       # empty string
    /
}

R , 71 Bytes

f=function(s,r=sub('(()())','()',s,f=T))'if'(r==s,s==''|s=='()()',f(r))

Probieren Sie es online!

• Portierung der rekursiven Japt-Lösung von @ETHproductions
• -2 Bytes dank @JayCe

Eine andere - längere - Lösung, aber interessant für den anderen Ansatz

R , 85 Bytes

g=gsub;!sum(eval(parse(t=g('\\)\\(',')-(',g('\\)','-1)',g('\\(','(2+',scan(,'')))))))

Probieren Sie es online!

Erklärung:

Nehmen Sie die Eingabezeichenfolge und ersetzt:

'('  with '(2+'
')'  with '-1)'
')(' with ')-('

wertet dann den resultierenden Ausdruck aus. Wenn es gleich Null ist, ist ausgeglichen, sonst nicht. Die Verwendung von sumist nur erforderlich, um den leeren String-Fall zu behandeln, da seine Auswertung zurückgibt NULL.

z.B

()(()()) => (2+-1)-(2+(2+-1)-(2+-1)-1) = 0
(()())   => (2+(2+-1)-(2+-1)-1)        = 1

Wolfram Language (Mathematica) , 65 Byte

#=={}||{1,1}==(#//.{a___,"(",i:1...,")",b___}/;1!=+i<3:>{a,1,b})&

Probieren Sie es online!

05AB1E , 18 16 13 Bytes

…(ÿ)…(()∞„()©:®Q

Port der Japt -Antwort von @ETHproductions , um den Testfall zu beheben ()(()()(()())(()())).
-2 Bytes dank @Adnan .

Basierend auf diesem Kommentar von OP verwende ich jetzt ()als Wahrheitswert und alles andere als Falschgeld. Wenn beide Werte statt nur einem konsistent sein müssen, wird stattdessen die alte 16-Byte-Antwort ( …(ÿ)…(()∞„()©:®Q) verwendet, die 0für wahrheitsgemäße und 1falsche Testfälle zurückgegeben wird.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung

…(ÿ)             # Take the input (implicitly) and surround it with "(" and ")"
            :    # Infinite replacement of:
    …(()∞        #  "(()())"    ("(()" mirrored)
         „()     #  with "()"
                 # After the infinite replacement: return the result
                 # ("()" for truthy; falsey otherwise)

(Alte 18-Byte-Antwort, die für den Testfall fehlgeschlagen ist ()(()()(()())(()())).):

ΔD„()∞©6∍å_i®õ.:]Ā

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

APL (Dyalog Classic) , 27 Byte

3>≢'<<><>>'⎕r'<>'⍣≡1⌽'><',⎕

Probieren Sie es online!

Prolog , 46 Bytes

a-->p,p.
a-->[].
p-->[l],a,[r].
f(X):-a(X,[]).

Probieren Sie es online! oder Überprüfen Sie alle Testfälle!

Verwendet Listen von lund rals Eingabe, wird zB "()()"getestet als f([l,r,l,r])..

Die ersten drei Zeilen sind die Grammatik gültiger Zeichenfolgen in der Syntax der Definite-Clause- Grammatik von Prolog . a(A,B).Gibt zurück, truewann Aeine Liste ist, die der Grammatik folgt und Bleer ist. Somit nimmt die Hauptfunktion feinige Xund prüft, ob sie a(X,[])hält.

Python 2 , 73 71 Bytes

f=lambda s,P='(()())':P in s and f(s.replace(P,'()'))or s in['()()','']

Probieren Sie es online!

Brainfuck, 50 Bytes

,[<+>[-[->>]<[-[--[>->,]]>>]<]<[>>],]<[--[>->]]<+.

Formatiert:

,
[
  <+>
  [
    -[->>]
    <
    [
      -
      [
        --
        [
          >->,
        ]
      ]
      >>
    ]
    <
  ]
  <[>>]
  ,
]
<
[
  --
  [
    >->
  ]
]
<+.

Erwartet eine Zeichenfolge mit (und )ohne abschließende Zeilenumbrüche und gibt sie \x01für wahr und \x00falsch aus. (Aus Gründen der Lesbarkeit können Sie z. B. 48 +s vor dem Finale hinzufügen ., um den Ausdruck zu ermöglichen, 1und 0stattdessen.)

Probieren Sie es online aus

Auf diese Weise wird ein Stapel mit der Anzahl der Gruppen in jeder Tiefe verwaltet, wobei die Zeichen nach Parität unterschieden werden und nach jeder geschlossenen Klammer geprüft wird, ob die Anzahl der Gruppen in {0, 2} enthalten ist. Wenn die Bedingung nicht erfüllt ist, wird der Rest der Eingabe verbraucht und ein Flag gesetzt. prüft dann die Bedingung am Ende des Programms erneut.

Wenn wir den Eingabestream mit einem ungeraden Zeichen beenden dürfen, können wir die letzte Prüfung auslassen <[--[>->]], um 10 Bytes zu sparen. (Wenn \nes nicht gerade unpraktisch wäre, hätte ich möglicherweise diese Variante als Hauptantwort vorgeschlagen.)

(Wir könnten auch einige Bytes einsparen, indem wir das Ausgabeformat in \x00true und non- \x00for false ändern. Dies scheint in der Problembeschreibung (möglicherweise aus Versehen) zulässig zu sein, aber es wäre sowieso nicht sehr interessant, und ich bevorzuge es diese Änderung nicht vorzunehmen.)

Python2, 95 bis 94 Bytes

f=lambda i:g(eval("(%s)"%i.replace(")","),")))
g=lambda i:len(i)in(0,2)and all(g(j)for j in i)

Probieren Sie es online!

f () transformiert den String in ein verschachteltes Tupel, das an g () übergeben wird.

g () navigiert rekursiv durch das Tupel und gibt False zurück, wenn ein Element nicht genau 0 oder 2 Kinder hat.

1 Byte durch Zeichenfolgenformatierung gespeichert.

Stax , 13 11 Bytes

₧aaS▐îî»Å·╢

Führen Sie es aus und debuggen Sie es

Ich habe zwei Bytes gespart, als mir klar wurde, dass die Eingaben zufällig implizit als Array-Literale ausgewertet werden können. Durch Entfernen der doppelten Anführungszeichen wird die Eingabe vereinfacht.

Die allgemeine Idee ist, die Eingabe als Array-Literal auszuwerten und die Elemente rekursiv zuzuordnen, um das parethesische Gleichgewicht zu überprüfen. Wenn die endgültige Zusicherung jemals fehlschlägt, erscheint ein Popup auf einem leeren Stapel. Wenn Sie in stax mit leeren Stapeln poppen, wird das Programm sofort beendet.

Ausgepackt, ungolfed und kommentiert sieht es so aus.

        input is implicitly treated as array literals
L       wrap entire input stack in an array
G       jump to the trailing '}', and come back when done
}       terminate the program, the rest is a recursive call target
{Gm     map array on top of the stack by using the recursive call target
%       get the length of the mapped array
02\#    is the length one of [0, 2]?
|c      assert value is truthy, pop if not

Führen Sie dieses aus

Java 10, 99 96 95 83 Bytes

s->{s="("+s+")";for(var p="";!p.equals(s);s=s.replace("(()())","()"))p=s;return s;}

Port meiner 05AB1E Antwort (kehrt also auch ()als wahr und alles andere als falsch zurück).

Probieren Sie es online aus.

Erläuterung:

s->{                 // Method with String as both parameter and return-type
  s="("+s+")";       //  Surround the input-String between "(" and ")"
  for(var p="";      //  Previous-String, starting empty
      !p.equals(s)   //  Loop as long as the previous and current Strings differ
      ;              //    After every iteration:
       s=s.replace("(()())","()"))
                     //     Replace all "(()())" with "()"
    p=s;             //   Set the previous String with the current
  return s;}         //  Return the modified input-String
                     //  (if it's now "()" it's truthy; falsey otherwise)

return s;kann sein, return"()".equals(s);wenn ein tatsächliches boolesches Ergebnis erforderlich war.