"Триплетна дужка" (яку я склав для цього виклику) - це одне з наступних:

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

Збалансована триплетна дужка-рядок (BTBS коротко) - це порожня рядок, два об'єднані BTBS, або одна з вищевказаних дужок триплетів, кожна з яких ...замінена BTBS.

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

Приклади

Ваша програма повинна повернути truthy для таких рядків:

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

Ваша програма повинна повернути помилкове значення для таких рядків:

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

Japt, 25 байт

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

Перевірте це в Інтернеті!

eon string - це рекурсивно-замінна функція. Другий параметр за замовчуванням пустий рядок, що означає, що цей рекурсивно видаляє збіги "%(%+%)|%[:]|\{%|}|<->"регулярного вираження 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 не має поняття truthy / falesy, тому я розглядаю порожню строку truthy та непустую фальшиву струну. Це перевіряється, чи вважаємо ми умовними /^$/.

Дякуємо @Neil за те, що виграли 1 байт!

Спробуйте в Інтернеті!

Пітон, 77 байт

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

Використовує ідею заміни Арнаульда . Створює та оцінює довгий рядок, як

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

переходити між заміною всіх типів дужок. Потім перевіряє, чи є результат порожнім рядком.

Математика, 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

Спробуйте в Інтернеті!

Цикли тривають (a) разів, замінюючи всі випадки порожніх дужок триплетів ( "(+)[:]{|}<->"<>3де <>оператор "групи", => ["(+)"; "[:]"; "{|}"; "<->"]) порожнім рядком ( x). Ця кількість повторень є надмірною, але її завжди буде більш ніж достатньо, щоб повністю звести всі правильно сформовані дужки триплетів ні до чого. Після завершення циклу виводиться !a: 0if atruthy (все ще має деякі символи), 1якщо afalsey (порожній).