Мы называем группу паренов открытым пареном (, его близким паренем )и всем, что внутри.

Группа или строка parens называется сбалансированной в скобках, если она не содержит ничего или содержит только две группы parens, сбалансированных в скобках.

Например:

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.

Точно так же:

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.

Таким образом, строка со скобками в скобках или группа скобок должны:

• Вообще ничего не содержать
• Или содержат только и ровно 2 группы сбалансированных скобок. Он не должен содержать ничего другого.

Задача:

Ваша задача - написать функцию или программу, которая проверяет, является ли данная строка сбалансированной в скобках или нет.

Входные данные:

На входе будет строка или список символов или что-то подобное. Вы можете предположить, что строка будет состоять только из символов '('и ')'. Вы также можете предположить, что у каждого открытого парена (будет свой близкий парен ), поэтому не беспокойтесь о строках типа "((("или ")("или "(())("...

^{Примечание: Как упомянуто @DigitalTrauma в своем замечании сильфона, это нормально subtitute с ()комбо другими символами (например <>, []...), если это вызывает дополнительную работу , как избежать в некоторых языках}

Выход:

Все, что указывает на то, сбалансирована ли строка в скобках или нет (true или false, 1 или 0, ...). Пожалуйста, укажите в своем ответе, что ваша функция / программа должна приносить.

Примеры:

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

^{Последние два примера действительно имели значение!}

Удачи!

Japt v2, 20 байт

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

Проверьте это онлайн!

Сначала все неправильно поняли задачу, и хотя каждая пара скобок должна была содержать четное число подпар, тогда как на самом деле в запросе запрашивается 0 или 2 подпары. Итак, вот мой пересмотренный ответ, используя ту же технику, что и раньше.

Мы все еще можем решить проблему с рекурсивной заменой. Дело в том, что вместо того, чтобы просто удалить все вхождения ()(), нам нужно убедиться, что в этой же оболочке ()()нет ()()()()ничего, кроме (другими словами, нет или что- то в этом роде ). Мы можем сделать это путем рекурсивной замены (()())на ().

Новая проблема состоит в том, что у самого ввода нет одной пары внешних скобок (поскольку это сделало бы его строкой, не сбалансированной в скобках), что вынуждает нас обернуть его в дополнительную пару, чтобы полностью уменьшить его. Наконец, конечный результат для сбалансированных строк теперь ()вместо пустой строки, поэтому мы проверяем равенство, а не просто принимаем логическое НЕ вывода.

сед 4.2.2, 30

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

Попробуйте онлайн .

Это возвращает код завершения оболочки 1 для True и 0 для False.

:               # 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 байта

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

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Редактировать: 2 байта сохранены благодаря @JoKing. Пояснение: просто рекурсивное регулярное выражение. Внешняя группа захвата представляет сбалансированную строку, <за которой следует необязательная сбалансированная строка, за которой следует >дважды. Обратите внимание, что большинство других ответов могут использовать ()s, но это стоит дополнительных двух байтов:

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

Попробуйте онлайн! Ссылка включает в себя тестовые случаи.

6502 машинного кода , 48 байтов

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

Ожидает указатель на строку в $fb /, $fcкоторая должна содержать только (и ). Сбрасывает флаг C (Carry), если строка «сбалансирована по парантезе», устанавливает ее иначе (что является типичной идиомой для 6502, установите перенос «при ошибке»). Ничего толкового при неправильном вводе не делает.

Хотя алгоритм рекурсивный, он не вызывает сам себя (что потребует большего количества байтов и делает позицию кода зависимым), но вместо этого поддерживает глубину рекурсии и использует «простое» ветвление.

Прокомментировал разборку

; 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

Пример C64 ассемблерной программы с использованием подпрограммы:

Онлайн демо

Код в синтаксисе ca65 :

.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 байтов

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

Попробуйте онлайн! или проверьте все контрольные примеры!

é(                      " 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                                ^()$

Брахилог , 28 байт

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

Попробуйте онлайн!

объяснение

                                    --  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 байтов

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

Попробуйте онлайн!

объяснение

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

Попробуйте онлайн!

MATL , 26 25 байт

oo~`tnw52B5LZttnb<]XB10X-

Попробуйте онлайн!

Благодаря ответу @ETHProductions за идею "replace (() ()) with ()" и комментарию вопроса @JungHwan Min за идею видеть скобки в виде двоичных цифр.

Выходные данные - это пустой массив для truey, положительное число для falsey, которое, как мне кажется, допускается комментарием OP: «Могут быть категории. То есть истинные значения, указывающие на истинность, и ложные значения, указывающие на обратное» Если это не так, мы можем добавить nв конце +1 байт, чтобы иметь 0 в качестве истинного вывода и 1 в качестве ложного вывода.

С комментариями:

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 байт

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

Попробуйте онлайн!

Haskell , 82 59 байт

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

Попробуйте онлайн!

Я предполагаю, что это может быть игра в гольф намного дальше, так как я впервые играю в гольф на Haskell, поэтому любые трюки или комментарии приветствуются.

РЕДАКТИРОВАТЬ - Спасибо @nimi за сохранение 23 байта (более 28% от первоначального представления :)

JavaScript (ES6), 63 байта

Принимает ввод как массив символов. Возвращает false для сбалансированных по скобкам, true для не сбалансированных по скобкам.

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

Попробуйте онлайн!

комментарии

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

Рекурсивный, 54 байта

Использование рекурсивных замен (как в ответе Japt от ETHproductions ) значительно короче.

Принимает ввод в виде строки. Возвращает 1 для сбалансированных по скобкам, 0 для не сбалансированных по скобкам.

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

Попробуйте онлайн!

Рекурсивный, 46 байт

Этот бросает ошибку рекурсии для не сбалансированного в скобках:

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

Попробуйте онлайн!

Perl 6 ,  43 41  37 байт

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

Проверь это

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

Проверь это

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

Проверь это

Expanded:

{  # 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 байт

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

Попробуйте онлайн!

• портирование рекурсивного решения Japt @ETHproductions
• -2 байта благодаря @JayCe

Другое, более продолжительное решение, но интересное для другого подхода.

R 85 байт

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

Попробуйте онлайн!

Пояснение:

Возьмите входную строку и замените:

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

затем оценивает полученное выражение. Если он равен нулю, он сбалансирован, иначе нет. Использование sumнеобходимо только для обработки пустого строкового регистра, потому что его оценка возвращается NULL.

например

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

Wolfram Language (Mathematica) , 65 байт

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

Попробуйте онлайн!

05AB1E , 18 16 13 байт

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

Порт ответа @ETHproductions на Japt для исправления тестового примера ()(()()(()())(()())).
-2 байта благодаря @Adnan .

Основываясь на этом комментарии OP, я теперь использую ()как истинное значение, а все остальное как ложь. Если оба значения должны быть непротиворечивыми, а не только одно, это будет старый 16-байтовый ответ вместо ( …(ÿ)…(()∞„()©:®Q), возвращающий0 байтовый для истинных и 1ложных тестовых случаев.

Попробуйте онлайн илипроверьте все контрольные примеры .

объяснение

…(ÿ)             # 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)

(Старый 18-байтовый ответ, который не удался для контрольного примера ()(()()(()())(()()))..):

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

Попробуйте онлайн или проверьте все контрольные примеры .

APL (Dyalog Classic) , 27 байтов

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

Попробуйте онлайн!

Пролог , 46 байт

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

Попробуйте онлайн! или проверьте все контрольные примеры!

Использует списки lи в rкачестве входных данных, например "()()", проверяется какf([l,r,l,r]). .

Первые три строки - это грамматика допустимых строк в синтаксисе грамматики « Определенное предложение» Пролога . a(A,B).возвращает trueкогда Aсписок, следующий за грамматикой и Bпустой. Таким образом, основная функция fберет некоторые Xи проверяет, a(X,[])выполняется ли .

Python 2 , 73 71 байт

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

Попробуйте онлайн!

брейкфук, 50 байт

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

отформатирован:

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

Ожидается строка с завершающим символом новой строки (и )без нее, а также выводится значение \x01true и \x00false. (Для разборчивости вы можете, например, добавить 48 +с до финала, .чтобы сделать его печатным 1и 0вместо этого.)

Попробуйте онлайн

Это поддерживает стек с количеством групп на каждой глубине, выделяя символы по четности и проверяя, находится ли число групп в {0, 2} после каждой закрывающей скобки; если условие не выполняется, потребляет оставшуюся часть ввода и устанавливает флаг; затем снова проверяет условие в конце программы.

Если нам разрешено завершать входной поток нечетным символом, мы можем пропустить последнюю проверку, <[--[>->]]чтобы сохранить 10 байтов. (Если бы \nне было даже неудобства, я мог бы предложить этот вариант в качестве основного ответа.)

(Мы могли бы также сохранить несколько байтов, изменив формат вывода \x00на true и не \x00на false, что, как представляется, допускается (возможно, случайно) в заявлении о проблеме, как написано, но в любом случае это не будет очень интересно, и я предпочитаю не делать этого изменения.)

Python2, 95 94 байта

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

Попробуйте онлайн!

Функция f () преобразует строку во вложенный кортеж, который передается в g ().

g () рекурсивно перемещается по кортежу и возвращает False, если какой-либо элемент не имеет точно 0 или 2 дочерних элементов.

Сохранение одного байта с использованием форматирования строки.

Stax , 13 11 байт

₧aaS▐îî»Å·╢

Запустите и отладьте его

Я сохранил два байта, когда понял, что входные данные могут быть неявно оценены как литералы массива. Удаляя двойные кавычки, ввод упрощается.

Общая идея состоит в том, чтобы оценить входные данные как литерал массива и рекурсивно отобразить элементы, чтобы проверить баланс между ними. Если окончательное утверждение когда-либо не удастся, тогда будет пустой всплеск. В stax всплывание с пустыми стеками немедленно завершает программу.

Распакованный, размазанный и прокомментированный, это выглядит так.

        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

Запустите этот

Java 10, 99 96 95 83 байта

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

Порт моего ответа 05AB1E (так же возвращается ()как правдивый и все остальное как фальси).

Попробуйте онлайн.

Объяснение:

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;может быть, return"()".equals(s);если требуется фактический логический результат.