Staffe triplette bilanciate


19

Una "parentesi tripla" (che ho inventato per questa sfida) è una delle seguenti:

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

Una stringa di parentesi di terzina bilanciata (in breve BTBS) è una stringa vuota, due BTBS concatenati o una delle parentesi di terzina di cui sopra ciascuna ...sostituita da una BTBS.

Il tuo compito è scrivere un programma o una funzione che controlli se una stringa composta solo da (+)[:]{|}<->è bilanciata. Il codice più corto vince.

Esempi

Il tuo programma dovrebbe restituire la verità per le seguenti stringhe:

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

Il tuo programma dovrebbe restituire falsy per le seguenti stringhe:

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

È (|)valido Non credo, ma non ne sono sicuro
Roman Gräf,

@ RomanGräf No, come <|>negli esempi di falsi.
jimmy23013,

Risposte:


1

Japt, 25 byte

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

Provalo online!

esulle stringhe è una funzione di sostituzione ricorsiva. Il secondo parametro viene impostato automaticamente sulla stringa vuota, il che significa che rimuove in modo ricorsivo le corrispondenze della regex di Japt "%(%+%)|%[:]|\{%|}|<->"(in termini regolari, /\(\+\)|\[:]|{\|}|<->/). Ciò restituisce una stringa vuota per stringhe di terzine bilanciate e una stringa non vuota per non bilanciate, quindi il valore di ritorno corretto è il NOT logico di questo.


14

JavaScript (ES6), 77 58 57 56 byte

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

Casi test


2
La stessa idea in Retina è di 26 byte (la prima riga ne fa solo una suite di test): retina.tryitonline.net/…
Martin Ender,

1
E 39 con perl: perl -lpe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=!$_'.
Dada,

@Dada che prenderà in considerazione 0un BTBS. Usa invece questo 38:perl -pe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=/^$/'
Ton Hospel il

@TonHospel Non ci ho pensato, anzi .. grazie per averlo sottolineato! (sentiti libero di pubblicarlo se vuoi comunque, o almeno non trattenerti a causa mia)
Dada,

Quel mix di S / s era leggermente confuso, forse f=s=>s==(s=s.replace(...))?!s:f(s)?
Neil,

5

sed, 28 27 byte

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

sed non ha un concetto di verità / falsità, quindi sto considerando una verità di stringa vuota e una falsità di stringa non vuota. Questo verifica se consideriamo il condizionale /^$/.

Grazie a @Neil per giocare a golf a 1 byte!

Provalo online!


1
Per una volta, BRE è in realtà un vantaggio .
Dennis,

Ti serve \]o è ]sufficiente?
Neil,

Io non. Grazie!
Dennis,

4

Python, 77 byte

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

Utilizza l'idea di sostituzione di Arnauld . Genera e valuta una stringa lunga come

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

per alternare tra la sostituzione di tutti i tipi di parentesi. Quindi, controlla se il risultato è la stringa vuota.


3

Mathematica, 55 byte

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

Funzione anonima. Prende una stringa come input e restituisce Trueo Falsecome output. Utilizza il metodo standard per farlo.


2

Grime , 39 byte

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

Provalo online! Purtroppo, la versione TIO esaurisce la memoria nella maggior parte dei casi di test.

Spiegazione

Niente di speciale qui. _è una scorciatoia per l'intero modello ed v*è uguale a *, ma con precedenza inferiore.

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

2

J, 48 byte

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

Simile agli altri, anche questo si basa sul metodo di Arnauld .

uso

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

Spiegazione

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

0

Scala, 96 byte

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

Questa è sostanzialmente la stessa idea delle altre risposte, ma con un po 'di scala.

senza rubare idee dagli altri (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}!_

0

Pip , 26 byte

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

Provalo online!

Cicli len (a) volte, sostituendo tutte le occorrenze delle parentesi vuote di terzine ( "(+)[:]{|}<->"<>3, dove si <>trova l'operatore "gruppo", => ["(+)"; "[:]"; "{|}"; "<->"]) con stringa vuota ( x). Queste molte iterazioni sono eccessive, ma sarà sempre più che sufficiente per ridurre completamente a zero tutte le parentesi di terzine correttamente formate. Al termine del ciclo, genera !a: 0if ais truey (ha ancora alcuni caratteri), 1if ais falsey (vuoto).

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.