"이 도전을 위해 만든"트리플렛 브래킷은 다음 중 하나입니다.

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

균형이 잡힌 삼중 괄호 문자열 (BTBS)은 빈 문자열, 두 개의 BTBS가 연결되거나 위의 삼중 괄호 중 하나가 ...BTBS로 대체 된 것입니다.

당신의 임무는 오직 문자열로 구성되어 있는지 확인하는 프로그램이나 함수를 작성하는 것 (+)[:]{|}<->입니다. 가장 짧은 코드가 승리합니다.

예

프로그램은 다음 문자열에 대해 진실성을 반환해야합니다.

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

프로그램은 다음 문자열에 대해 거짓을 반환해야합니다.

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

apt, 25 바이트

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

온라인으로 테스트하십시오!

e문자열에서 재귀 대체 함수입니다. JAPT 정규식이 반복적으로 제거합니다 일치를 의미하는 빈 문자열에 두 번째 매개 변수의 기본값 "%(%+%)|%[:]|\{%|}|<->"(정규 측면에서, /\(\+\)|\[:]|{\|}|<->/). 균형이 잡힌 삼중 항 문자열의 경우 빈 문자열을, 균형이 맞지 않는 경우 비어 있지 않은 문자열을 반환하므로 올바른 반환 값은 이것의 논리적 NOT입니다.

자바 스크립트 (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 는 진실 / 거짓의 개념을 가지고 있지 않기 때문에 빈 끈 진실과 비어 있지 않은 끈 거짓을 고려하고 있습니다. 조건부로 간주되는지 확인합니다 /^$/.

1 바이트를 골라 낸 @Neil에게 감사드립니다!

온라인으로 사용해보십시오!

파이썬, 77 바이트

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

Arnauld의 대체 아이디어를 사용합니다 . 다음과 같은 긴 문자열을 생성하고 평가합니다

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

모든 브래킷 유형 교체 사이를 순환합니다. 그런 다음 결과가 빈 문자열인지 확인합니다.

수학, 55 바이트

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

익명의 기능. 문자열을 입력 및 리턴 True또는 False출력 으로 취합니다 . 이를 위해 표준 방법을 사용합니다.

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

이것은 기본적으로 다른 답변과 동일하지만 일부 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

온라인으로 사용해보십시오!

빈 트리플렛 괄호 ( "(+)[:]{|}<->"<>3, 여기서 <>"group"연산자는 => ["(+)"; "[:]"; "{|}"; "<->"])를 모두 빈 문자열 ( x)로 바꾸어 len (a) 번 반복 합니다. 이 많은 반복은 과잉이지만, 올바르게 구성된 모든 삼중 항 브래킷을 완전히 줄이려면 충분할 것입니다. 루프가 완료된 후 출력 !a: 0if ais truthy (여전히 일부 문자가 있음), 1if ais falsey (비어 있음).