"Üçlü ayraç" (bu zorluk için oluşturduğum) aşağıdakilerden biridir:

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

Dengeli bir üçlü braket dizesi (kısaca BTBS), boş bir dize, iki BTBS birleştirilir veya her biri ...bir BTBS ile değiştirilen yukarıdaki üçlü braketlerden biridir.

Göreviniz, yalnızca oluşan bir dizenin (+)[:]{|}<->dengeli olup olmadığını kontrol eden bir program veya işlev yazmaktır . En kısa kod kazanır.

Örnekler

Programınız aşağıdaki dizeler için doğrulukla dönmelidir:

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

Programınız aşağıdaki dizeler için falsi döndürmelidir:

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

Japt, 25 bayt

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

Çevrimiçi test edin!

edizelerde özyinelemeli değiştirme işlevidir. İkinci parametre, varsayılan olarak boş dizgidir; bu, bunun Japt normal ifadesinin "%(%+%)|%[:]|\{%|}|<->"(düzenli olarak /\(\+\)|\[:]|{\|}|<->/) eşleşmelerini yinelemeli olarak kaldırdığı anlamına gelir . Bu, dengeli üçlü dizeler için boş bir dize ve dengeli olmayanlar için boş olmayan bir dize döndürür, bu nedenle doğru dönüş değeri bunun mantıksal DEĞİLDİR.

JavaScript (ES6), 77 58 57 56 bayt

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

Test senaryoları

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 bayt

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

sed doğruluk / falsi kavramına sahip değil, bu yüzden boş bir string doğruluk ve boş olmayan bir string falsy düşünüyoruz. Bu, şartlı olup olmadığımızı kontrol eder /^$/.

1 bayt golf için @Neil için teşekkürler!

Çevrimiçi deneyin!

Python, 77 bayt

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

Arnauld'un yerine geçen fikri kullanır . Gibi uzun bir dize oluşturur ve değerlendirir

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

tüm braket tiplerini değiştirme arasında geçiş yapmak için. Ardından, sonucun boş dize olup olmadığını kontrol eder.

Mathematica, 55 bayt

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

Anonim işlev. Bir dizgiyi girdi ve döndürme Trueveya Falseçıktı olarak alır. Bunu yapmak için standart yöntemi kullanır.

Kir , 39 bayt

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

Çevrimiçi deneyin! Ne yazık ki, TIO sürümü test senaryolarının çoğunda bellek yetersiz.

açıklama

Burada çok süslü bir şey yok. _tüm desen için kısayoldur ve v*aynıdır *, ancak daha düşük önceliğe sahiptir.

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

J, 48 bayt

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

Diğerlerine benzer şekilde, bu da Arnauld'un yöntemine dayanmaktadır .

kullanım

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

açıklama

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 bayt

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

Bu temel olarak diğer cevaplarla aynı fikirdir, ancak bazı scala kazan plakası ile.

başkalarının fikirlerini çalmadan (188 bayt):

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 bayt

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

Çevrimiçi deneyin!

Döngüler len, (a) katı, boş üçlü parantez tüm oluşumları değiştirilmesi ( "(+)[:]{|}<->"<>3, burada <>bir "grubu" operatörü => ["(+)"; "[:]"; "{|}"; "<->"]) boş bir dizge ile ( x). Bu birçok iterasyon aşırıdır, ancak her zaman uygun şekilde oluşturulmuş üçüz parantezlerini hiçbir şeye tamamen azaltmak her zaman fazlasıyla yeterli olacaktır. Döngü tamamlandıktan sonra çıktılar !a: 0if adoğruysa (hala bazı karakterler vardır), falsey 1ise a(boş).