"วงเล็บสามเหลี่ยม" (ที่ฉันทำขึ้นสำหรับความท้าทายนี้) เป็นหนึ่งในสิ่งต่อไปนี้:

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

สตริงวงเล็บเหลี่ยม triplet สมดุล (BTBS สำหรับช่วงสั้น ๆ ) เป็นสตริงว่างเปล่า, สอง BTBSes ที่ต่อกันหรือหนึ่งในวงเล็บสามด้านบนซึ่งแต่ละอัน...ถูกแทนที่ด้วย BTBS

งานของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นที่ตรวจสอบว่าสตริงที่ประกอบด้วยเพียง(+)[:]{|}<->นั้นมีความสมดุลหรือไม่ รหัสที่สั้นที่สุดชนะ

ตัวอย่าง

โปรแกรมของคุณควรกลับมาเป็นจริงสำหรับสตริงต่อไปนี้:

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

โปรแกรมของคุณควรคืนค่าเท็จสำหรับสตริงต่อไปนี้:

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

Japt 25 ไบต์

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

ทดสอบออนไลน์!

eon strings เป็นฟังก์ชั่นแบบเรียกซ้ำ พารามิเตอร์ที่สองมีค่าเริ่มต้นเป็นสตริงว่างซึ่งหมายความว่าสิ่งนี้จะลบการจับคู่ของ Japt regex ซ้ำ"%(%+%)|%[:]|\{%|}|<->"(ในเงื่อนไขปกติ/\(\+\)|\[:]|{\|}|<->/) สิ่งนี้จะส่งคืนสตริงว่างสำหรับสตริง triplet แบบสมดุลและสตริงที่ไม่ว่างเปล่าสำหรับแบบไม่สมดุลดังนั้นค่าส่งคืนที่ถูกต้องคือตรรกะที่ไม่เกี่ยวกับสิ่งนี้

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 / falsy ดังนั้นฉันพิจารณา truthy สตริงว่างและไม่ว่างเปล่า falsy สตริง สิ่งนี้จะตรวจสอบว่าเราพิจารณาเงื่อนไข/^$/หรือไม่

ขอบคุณ @Neil สำหรับการตีกอล์ฟ 1 ไบต์!

ลองออนไลน์!

Python ขนาด 77 ไบต์

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

ใช้ความคิดของการเปลี่ยน Arnauld สร้างและประเมินสตริงที่มีความยาวเช่น

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&.>/'(+)';'[:]';'{|}';'<->';])^:_

คล้ายกับคนอื่น ๆ นี่เป็นพื้นฐานของ Arnauld วิธีการ

การใช้

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

นี่เป็นแนวคิดเดียวกันกับคำตอบอื่น ๆ

โดยไม่ขโมยความคิดจากผู้อื่น (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}!_

Pipขนาด 26 ไบต์

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

ลองออนไลน์!

ลูป len (a) ครั้งแทนที่การเกิดขึ้นทั้งหมดของวงเล็บสามเหลี่ยมว่างเปล่า ( "(+)[:]{|}<->"<>3ซึ่ง<>เป็นตัวดำเนินการ "กลุ่ม", => ["(+)"; "[:]"; "{|}"; "<->"]) ด้วยสตริงว่าง ( x) การทำซ้ำหลายครั้งนี้เกินความจริง แต่มันจะมากเกินพอที่จะลดทริปเล็ตทริปเลตที่เกิดขึ้นอย่างถูกต้องทั้งหมดให้เป็นอะไร หลังจากลูปเสร็จสมบูรณ์เอาต์พุต!a: 0ถ้าaเป็นความจริง (ยังมีอักขระบางตัว) 1หากaเป็นเท็จ (ว่าง)