Ausgeglichene Triplett-Klammern

19

Eine "Triplett-Klammer" (die ich für diese Herausforderung erfunden habe) ist eine der folgenden:

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

Eine symmetrische Triplett-Klammer-Zeichenfolge (kurz BTBS) ist entweder eine leere Zeichenfolge, zwei verkettete BTBS oder eine der obigen Triplett-Klammern, wobei jede ...durch eine BTBS ersetzt wird.

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die überprüft, ob eine Zeichenfolge, die nur aus (+)[:]{|}<->besteht, ausgeglichen ist. Kürzester Code gewinnt.

Beispiele

Ihr Programm sollte für die folgenden Zeichenfolgen die Wahrheit zurückgeben:

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

Ihr Programm sollte für die folgenden Zeichenfolgen einen Fehler zurückgeben:

:[
<|>
(+(+)
[:][:](+[[:]):]
{|{|{|(+{|{|{|}}}}}+)}[:]{|}
{{||}}
<<->-<->-<->>
[(+):((+)+)+(+(+))]
<<<<<->->->->->->
jimmy23013
quelle
Ist (|)gültig. Ich glaube nicht, aber ich bin nicht sicher
Roman Gräf
@ RomanGräf Nein, wie <|>in den falschen Beispielen.
Jimmy23013

Antworten:

1

Japt, 25 Bytes

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

Testen Sie es online!

eon strings ist eine rekursive Ersetzungsfunktion. Der zweite Parameter ist standardmäßig die leere Zeichenfolge. Dies bedeutet, dass Übereinstimmungen mit dem "%(%+%)|%[:]|\{%|}|<->"regulären Ausdruck Japt rekursiv entfernt werden /\(\+\)|\[:]|{\|}|<->/. Dies gibt eine leere Zeichenfolge für ausgeglichene Triplett-Zeichenfolgen und eine nicht leere Zeichenfolge für nicht ausgeglichene zurück, sodass der richtige Rückgabewert das logische NICHT davon ist.

ETHproductions
quelle
14

JavaScript (ES6), 77 58 57 56 Bytes

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

Testfälle

Arnauld
quelle
2
Die gleiche Idee in Retina ist 26 Bytes (die erste Zeile macht es nur zu einer Testsuite): retina.tryitonline.net/…
Martin Ender
1
Und 39 mit Perl: perl -lpe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=!$_'.
Dada
@Dada Das wird 0ein BTBS berücksichtigen. Verwenden Sie stattdessen diese 38:perl -pe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=/^$/'
Ton Hospel
@TonHospel Habe in der Tat nicht daran gedacht .. danke, dass du darauf hingewiesen hast! (zögern Sie nicht, es zu posten, wenn Sie wollen, oder zumindest nicht wegen mir zurückhalten)
Dada
Diese S / S-Mischung war vielleicht etwas verwirrend f=s=>s==(s=s.replace(...))?!s:f(s)?
Neil
5

sed, 28 27 bytes

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

sed hat kein Konzept von Wahrhaftigkeit / Falschheit, daher betrachte ich eine leere Zeichenfolge als wahr und eine nicht leere Zeichenfolge als falsch. Dies prüft, ob wir die Bedingung berücksichtigen /^$/.

Vielen Dank an @Neil für das Golfen ab 1 Byte!

Probieren Sie es online!

Dennis
quelle
1
Ausnahmsweise ist BRE ein Vorteil .
Dennis
Benötigen Sie das \]oder reicht das ]aus?
Neil
Ich nicht. Vielen Dank!
Dennis
4

Python, 77 Bytes

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

Verwendet Arnauld's Ersatzidee . Erzeugt und wertet einen langen String wie

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

um zwischen dem Ersetzen aller Klammertypen zu wechseln. Überprüft dann, ob das Ergebnis die leere Zeichenfolge ist.

xnor
quelle
3

Mathematica, 55 Bytes

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

Anonyme Funktion. Nimmt einen String als Eingabe und gibt ihn zurück Trueoder Falseals Ausgabe. Verwendet dazu die Standardmethode.

LegionMammal978
quelle
2

Schmutz , 39 Bytes

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

Probieren Sie es online! Leider verfügt die TIO-Version in den meisten Testfällen nicht über genügend Arbeitsspeicher.

Erläuterung

Nichts Besonderes hier. _Abkürzung für das gesamte Muster ist, und v*ist das gleiche wie *, aber mit einer geringeren Priorität.

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

J, 48 Bytes

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

Ähnlich wie die anderen basiert auch dies auf der Methode von Arnauld .

Verwendung

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

Erläuterung

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
Meilen
quelle
0

Scala, 96 Bytes

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

Dies ist im Grunde die gleiche Idee wie die anderen Antworten, aber mit etwas Scala-Boilerplate.

ohne Ideen von anderen zu stehlen (188 Bytes):

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
quelle
0

Pip , 26 Bytes

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

Probieren Sie es online!

Schleifen Sie len (a) times und ersetzen Sie alle Vorkommen von leeren Triplett-Klammern ( "(+)[:]{|}<->"<>3wobei <>der Operator "group" ist, => ["(+)"; "[:]"; "{|}"; "<->"]) durch leere Zeichenfolge ( x). Diese vielen Iterationen sind übertrieben, aber es wird immer mehr als genug sein, um alle richtig geformten Triplett-Klammern vollständig auf Null zu reduzieren. Nach Beendigung der Schleife wird Folgendes ausgegeben !a: 0if aist wahr (hat noch einige Zeichen), 1if aist falsch (leer).

DLosc
quelle