Wyważone wsporniki trojaczki

19

„Trójkątny wspornik” (który przygotowałem na to wyzwanie) to jedno z poniższych:

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

Zrównoważony ciąg nawiasów tripletowych (w skrócie BTBS) jest albo pustym ciągiem, połączonymi dwoma BTBS, albo jednym z powyższych nawiasów tripletowych, z których każdy jest ...zastąpiony BTBS.

Twoim zadaniem jest napisanie programu lub funkcji, która sprawdza, czy ciąg składający się tylko z (+)[:]{|}<->jest zrównoważony. Najkrótszy kod wygrywa.

Przykłady

Twój program powinien zwracać wartość true dla następujących ciągów:

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

Twój program powinien zwrócić fałsz dla następujących ciągów:

:[
<|>
(+(+)
[:][:](+[[:]):]
{|{|{|(+{|{|{|}}}}}+)}[:]{|}
{{||}}
<<->-<->-<->>
[(+):((+)+)+(+(+))]
<<<<<->->->->->->
jimmy23013
źródło
Jest (|)ważny Nie sądzę, ale nie jestem pewien
Roman Gräf
@ RomanGräf Nie, jak <|>w przykładach fałszerstwa.
jimmy23013

Odpowiedzi:

1

Japt, 25 bajtów

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

Przetestuj online!

ena ciągach jest funkcją zastępowania rekurencyjnego. Drugi parametr domyślnie przyjmuje pusty ciąg, co oznacza, że ​​rekurencyjnie usuwa dopasowania wyrażenia "%(%+%)|%[:]|\{%|}|<->"regularnego Japt (w normalnych warunkach /\(\+\)|\[:]|{\|}|<->/). Zwraca pusty ciąg dla zrównoważonych ciągów tripletowych i niepusty ciąg dla niezrównoważonych, więc poprawna wartość zwracana jest logicznym NIE tego.

ETHprodukcje
źródło
14

JavaScript (ES6), 77 58 57 56 bajtów

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

Przypadki testowe

Arnauld
źródło
2
Ten sam pomysł w Retinie ma 26 bajtów (pierwszy wiersz sprawia, że ​​jest to zestaw testowy): retina.tryitonline.net/…
Martin Ender
1
I 39 z Perl: perl -lpe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=!$_'.
Dada,
@Dada To rozważa 0BTBS. Zamiast tego użyj 38:perl -pe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=/^$/'
Ton Hospel
@TonHospel Nie myślałem o tym, rzeczywiście .. dzięki za zwrócenie na to uwagi! (nie krępuj się opublikować, jeśli chcesz, a przynajmniej nie powstrzymuj się przeze mnie)
Dada,
Być może ten miks S / S był nieco mylący f=s=>s==(s=s.replace(...))?!s:f(s)?
Neil,
5

sed, 28 27 bajtów

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

sed nie ma pojęcia „prawda / fałsz”, więc rozważam pusty ciąg znaków „prawda” i niepusty ciąg znaków „fałsz”. Sprawdza to, czy rozważamy warunki warunkowe /^$/.

Dzięki @Neil za grę w golfa z 1 bajtu!

Wypróbuj online!

Dennis
źródło
1
Tym razem BRE jest zaletą .
Dennis
Potrzebujesz \]lub ]wystarcza?
Neil
Ja nie. Dzięki!
Dennis
4

Python, 77 bajtów

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

Wykorzystuje pomysł zastępowania Arnaulda . Generuje i ocenia długi ciąg znaków

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

aby przełączać się między wymianą wszystkich typów wsporników. Następnie sprawdza, czy wynikiem jest pusty ciąg.

xnor
źródło
3

Mathematica, 55 bajtów

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

Funkcja anonimowa. Bierze ciąg jako dane wejściowe i zwraca Truelub Falsedane wyjściowe. Używa do tego standardowej metody.

LegionMammal978
źródło
2

Brud , 39 bajtów

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

Wypróbuj online! Niestety w większości przypadków testowych w wersji TIO zabrakło pamięci.

Wyjaśnienie

Nie ma tu nic nadzwyczajnego. _jest skrótem dla całego wzoru i v*jest taki sam jak *, ale z niższym priorytetem.

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

J, 48 bajtów

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

Podobnie jak inne, jest to również oparte na metodzie Arnaulda .

Stosowanie

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

Wyjaśnienie

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
mile
źródło
0

Scala, 96 bajtów

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

Jest to zasadniczo ten sam pomysł, co inne odpowiedzi, ale z pewną płytą kotłową Scala.

bez kradzieży pomysłów od innych (188 bajtów):

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}!_
corvus_192
źródło
0

Pip , 26 bajtów

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

Wypróbuj online!

Pętle len (a) razy, zastępując wszystkie wystąpienia pustych nawiasów trypletowych ( "(+)[:]{|}<->"<>3gdzie <>operator „grupy”, => ["(+)"; "[:]"; "{|}"; "<->"]) pustym łańcuchem ( x). Tak wiele iteracji to przesada, ale zawsze wystarczy, aby całkowicie zredukować wszystkie poprawnie utworzone nawiasy trójkątowe do zera. Po zakończeniu pętli wyprowadza !a: 0if ajest prawdą (nadal ma kilka znaków), 1jeśli ajest falsey (pusty).

DLosc
źródło