"Braket triplet" (yang saya buat untuk tantangan ini) adalah salah satu dari yang berikut:

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

String braket triplet seimbang (singkatnya BTBS) adalah string kosong, dua BTBS bersambung, atau salah satu dari braket triplet di atas yang masing-masing ...diganti dengan BTBS.

Tugas Anda adalah menulis program atau fungsi yang memeriksa apakah string yang hanya terdiri dari (+)[:]{|}<->seimbang. Kode terpendek menang.

Contohnya

Program Anda harus mengembalikan kebenaran untuk string berikut:

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

Program Anda harus mengembalikan falsy untuk string berikut:

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

Japt, 25 byte

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

Uji secara online!

eon strings adalah fungsi rekursif-ganti. Parameter kedua default ke string kosong, yang berarti ini secara rekursif menghapus kecocokan dari regex Japt "%(%+%)|%[:]|\{%|}|<->"(dalam istilah biasa, /\(\+\)|\[:]|{\|}|<->/). Ini mengembalikan string kosong untuk string triplet seimbang dan string non-kosong untuk non-seimbang, sehingga nilai pengembalian yang benar adalah BUKAN logis dari ini.

JavaScript (ES6), 77 58 57 56 byte

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

Uji kasus

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 tidak memiliki konsep truthy / falsy, jadi saya mempertimbangkan string kosong truthy dan string non-empty falsy. Ini memeriksa jika kita mempertimbangkan persyaratan /^$/.

Terima kasih kepada @Neil untuk bermain golf 1 byte!

Cobalah online!

Python, 77 byte

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

Menggunakan ide pengganti Arnauld . Menghasilkan dan mengevaluasi string panjang seperti

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

untuk siklus antara mengganti semua jenis braket. Kemudian, periksa apakah hasilnya adalah string kosong.

Mathematica, 55 byte

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

Fungsi anonim. Mengambil string sebagai input dan mengembalikan Trueatau Falsesebagai output. Menggunakan metode standar untuk melakukan ini.

Grime , 39 byte

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

Cobalah online! Sayangnya, versi TIO kehabisan memori pada sebagian besar kasus uji.

Penjelasan

Tidak ada yang terlalu mewah di sini. _adalah singkatan untuk seluruh pola, dan v*sama dengan *, tetapi dengan prioritas lebih rendah.

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

Mirip dengan yang lain, ini juga didasarkan pada metode Arnauld .

Pemakaian

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

Penjelasan

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

Ini pada dasarnya ide yang sama dengan jawaban yang lain, tetapi dengan beberapa scala boilerplate.

tanpa mencuri ide dari orang lain (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

Cobalah online!

Loops len (a) kali, menggantikan semua kemunculan kurung triplet kosong ( "(+)[:]{|}<->"<>3, di mana <>operator "grup", => ["(+)"; "[:]"; "{|}"; "<->"]) dengan string kosong ( x). Banyak iterasi ini berlebihan, tetapi akan selalu lebih dari cukup untuk sepenuhnya mengurangi semua kurung triplet yang terbentuk dengan benar menjadi nol. Setelah loop selesai, output !a: 0jika abenar (masih memiliki beberapa karakter), 1jika afalsey (kosong).