«Тройка скобок» (которую я составил для этого испытания) является одним из следующих:

(...+...)
[...:...]
{...|...}
<...-...>

Сбалансированная строка триплетных скобок (для краткости BTBS) представляет собой либо пустую строку, две сцепленные BTBS, либо одну из указанных выше тройных скобок, каждая из которых ...заменяется на BTBS.

Ваша задача - написать программу или функцию, которая проверяет, (+)[:]{|}<->сбалансирована ли строка, состоящая только из одной строки . Самый короткий код выигрывает.

Примеры

Ваша программа должна вернуть truey для следующих строк:

(+)(+)(+)
[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)
<<<<<<<<<<<<->->->->->->->->->->->->
{|(+[:<-{|(+[:<->])}>])}
[[[:]:[:]]:[[:]:[:]]]
{[:](+)|<->{|}}[(+)<->:{|}(+)]

Ваша программа должна возвращать ложные значения для следующих строк:

:[
<|>
(+(+)
[:][:](+[[:]):]
{|{|{|(+{|{|{|}}}}}+)}[:]{|}
{{||}}
<<->-<->-<->>
[(+):((+)+)+(+(+))]
<<<<<->->->->->->

Japt, 25 байт

!Ue"%(%+%)|%[:]|\{%|}|<->

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

eв строках - это функция рекурсивного замещения. Второй параметр по умолчанию равен пустой строке, что означает, что это рекурсивно удаляет совпадения регулярного выражения Japt "%(%+%)|%[:]|\{%|}|<->"(в обычных терминах, /\(\+\)|\[:]|{\|}|<->/). Это возвращает пустую строку для сбалансированных триплетных строк и непустую строку для несбалансированных, поэтому правильное возвращаемое значение является логическим НЕ этого.

JavaScript (ES6), 77 58 57 56 байт

f=s=>s==(s=s.replace(/\(\+\)|\[:]|{\|}|<->/,''))?!s:f(s)

Контрольные примеры

f=s=>s==(s=s.replace(/\(\+\)|\[:]|{\|}|<->/,''))?!s:f(s)

console.log("Testing truthy values");
console.log(f("(+)(+)(+)"));
console.log(f("[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)"));
console.log(f("<<<<<<<<<<<<->->->->->->->->->->->->"));
console.log(f("{|(+[:<-{|(+[:<->])}>])}"));
console.log(f("[[[:]:[:]]:[[:]:[:]]]"));
console.log(f("{[:](+)|<->{|}}[(+)<->:{|}(+)]"));

console.log("Testing falsy values");
console.log(f(":["));
console.log(f("<|>"));
console.log(f("(+(+)"));
console.log(f("[:][:](+[[:]):]"));
console.log(f("{|{|{|(+{|{|{|}}}}}+)}[:]{|}"));
console.log(f("{{||}}"));
console.log(f("<<->-<->-<->>"));
console.log(f("[(+):((+)+)+(+(+))]"));
console.log(f("<<<<<->->->->->->"));

sed, 28 27 байтов

:
s#(+)\|\[:]\|{|}\|<->##
t

У sed нет понятия истина / ложь, поэтому я рассматриваю пустую строку как истину и непустую ложную строку. Это проверяет, если мы считаем условным /^$/.

Спасибо @Neil за игру в 1 байт!

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

Python, 77 байт

lambda s:eval("s"+".replace('%s','')"*4%('(+)','[:]','{|}','<->')*len(s))==''

Использует идею замены Арно . Генерирует и оценивает длинную строку как

s.replace('(+)','').replace('[:]','').replace('{|}','').replace('<->','').replace('(+)','').replace('[:]','').replace('{|}','').replace('<->','')

цикл между заменой всех типов кронштейнов. Затем проверяет, является ли результат пустой строкой.

Mathematica, 55 байт

StringDelete["(+)"|"[:]"|"{|}"|"<->"]~FixedPoint~#==""&

Анонимная функция. Принимает строку как ввод и возвращает Trueили Falseкак вывод. Использует стандартный метод для этого.

Грязь , 39 байт

e`\(_\+_\)|\[_\:_\]|\{_\|_\}|\<_\-_\>v*

Попробуйте онлайн! К сожалению, версия TIO не хватает памяти в большинстве тестовых случаев.

объяснение

Здесь нет ничего особенного. _является сокращением для всего шаблона и v*является таким же, как *, но с более низким приоритетом.

e`                                       Match entire input against this pattern:
  \(_\+_\)                               '(', match of _, '+', match of _, ')'
          |                              or
           \[_\:_\]|\{_\|_\}|\<_\-_\>    same for the other bracket types
                                     v*  repeated 0-∞ times

J, 48 байтов

a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_

Подобно другим, это также основано на методе Арно .

использование

   f =: a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_
   f '(+)(+)(+)'
1
   f '[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)'
1
   f '<<<<<<<<<<<<->->->->->->->->->->->->'
1
   f '<|>'
0
   f '[:][:](+[[:]):]'
0
   f '{|{|{|(+{|{|{|}}}}}+)}[:]{|}'
0

объяснение

a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_  Input: string S
   (                                        )^:_  Repeat until convergence
                                         ]          Get S
                 '(+)';'[:]';'{|}';'<->';           Append to ['(+)', '[:]', '{|}', '<->']
    [:delstring&.>/                                 Reduce right-to-left by deleting
                                                    occurrences of each string on the
                                                    left from the right
                                                    Return the final string as the new S
a:=                                               Test if the final value of S is empty

Скала, 96 байт

def&(s:String):Any={val t=s.replaceAll(raw"\(\+\)|\[:]|\{\|}|<->","")
if(t==s)t.size<1 else&(t)}

Это в основном та же идея, что и в других ответах, но с некоторыми шаблонами scala.

без кражи идей у ​​других (188 байт):

import scala.util.parsing.combinator._
val a = new RegexParsers{def r:Parser[_]="("~r~"+"~r~")"|"["~r~":"~r~"]"|"{"~r~"|"~r~"}"|"<"~r~"-"~r~">"|""
def!(s:String)= !parseAll(r,s).isEmpty}!_

Пип , 26 байт

L#aaR:"(+)[:]{|}<->"<>3x!a

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

Обрабатывает len (a) раз, заменяя все вхождения пустых триплетных скобок ( "(+)[:]{|}<->"<>3где <>оператор "group" => ["(+)"; "[:]"; "{|}"; "<->"]) пустой строкой ( x). Это много итераций - излишне, но этого всегда будет более чем достаточно, чтобы полностью свести все правильно сформированные триплетные скобки к нулю. После завершения цикла выдает !a: 0if ais true (по-прежнему содержит несколько символов), 1if a- false (пусто).