Một "khung ba" (mà tôi đã tạo ra cho thử thách này) là một trong những điều sau đây:

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

Chuỗi khung bộ ba cân bằng (viết tắt là BTBS) là một chuỗi trống, hai BTBS được nối hoặc một trong các khung bộ ba ở trên với mỗi chuỗi được ...thay thế bằng BTBS.

Nhiệm vụ của bạn là viết một chương trình hoặc hàm kiểm tra xem một chuỗi chỉ bao gồm có (+)[:]{|}<->cân bằng hay không. Mã ngắn nhất sẽ thắng.

Ví dụ

Chương trình của bạn sẽ trả về sự thật cho các chuỗi sau:

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

Chương trình của bạn sẽ trả về falsy cho các chuỗi sau:

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

Japt, 25 byte

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

Kiểm tra nó trực tuyến!

etrên chuỗi là một hàm đệ quy thay thế. Tham số thứ hai mặc định cho chuỗi trống, có nghĩa là điều này sẽ loại bỏ đệ quy các kết quả khớp của biểu thức Japt "%(%+%)|%[:]|\{%|}|<->"(theo thuật ngữ thông thường /\(\+\)|\[:]|{\|}|<->/). Điều này trả về một chuỗi rỗng cho các chuỗi bộ ba cân bằng và một chuỗi không trống cho không cân bằng, vì vậy giá trị trả về đúng là logic KHÔNG của điều này.

JavaScript (ES6), 77 58 57 56 byte

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

Các trường hợp thử nghiệm

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 byte

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

sed không có khái niệm về sự thật / giả dối, vì vậy tôi đang xem xét một chuỗi sự thật trống rỗng và một chuỗi giả không trống rỗng. Điều này kiểm tra nếu chúng ta xem xét các điều kiện /^$/.

Cảm ơn @Neil vì đã chơi golf 1 byte!

Hãy thử trực tuyến!

Python, 77 byte

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

Sử dụng ý tưởng thay thế của Arnauld . Tạo và đánh giá một chuỗi dài như

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

để chu kỳ giữa thay thế tất cả các loại khung. Sau đó, kiểm tra nếu kết quả là chuỗi rỗng.

Toán học, 55 byte

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

Chức năng ẩn danh. Lấy một chuỗi làm đầu vào và trả về Truehoặc Falselà đầu ra. Sử dụng phương pháp tiêu chuẩn để làm điều này.

Vết bẩn , 39 byte

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

Hãy thử trực tuyến! Đáng buồn thay, phiên bản TIO hết bộ nhớ trên hầu hết các trường hợp thử nghiệm.

Giải trình

Không có gì quá lạ mắt ở đây. _là tốc ký cho toàn bộ mô hình, và v*giống như *, nhưng với độ ưu tiên thấp hơn.

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

J, 48 byte

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

Tương tự như những người khác, điều này cũng dựa trên phương pháp của Arnauld .

Sử dụng

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

Giải trình

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

Scala, 96 byte

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

Điều này về cơ bản là cùng một ý tưởng như các câu trả lời khác, nhưng với một số bản tóm tắt scala.

không lấy cắp ý tưởng từ người khác (188 byte):

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}!_

Pip , 26 byte

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

Hãy thử trực tuyến!

Vòng lặp len (a) lần, thay thế tất cả các lần xuất hiện của dấu ngoặc ba trống ( "(+)[:]{|}<->"<>3, trong đó <>toán tử "nhóm", => ["(+)"; "[:]"; "{|}"; "<->"]) bằng chuỗi rỗng ( x). Nhiều lần lặp này là quá mức cần thiết, nhưng nó sẽ luôn luôn là quá đủ để giảm hoàn toàn tất cả các dấu ngoặc ba được hình thành đúng thành không có gì. Sau khi vòng lặp hoàn thành, kết quả đầu ra !a: 0if alà thật (vẫn còn một số ký tự), 1nếu alà falsey (trống).