Riparare le parentesi graffe, ecc

La tua missione, se scegli di accettarlo, è quella di aggiungere il numero minimo di parentesi, parentesi graffe e parentesi quadre per fare in modo che una determinata stringa (contenente solo parentesi, parentesi graffe e parentesi quadre) abbia una corrispondenza di parentesi graffe corretta. I legami dei simboli aggiunti devono essere interrotti avendo la distanza massima tra parentesi graffe accoppiate. È necessario restituire solo una risposta corretta che corrisponda a queste due regole; Ulteriori legami, se dovessero esistere, potrebbero essere spezzati in qualsiasi modo tu ritenga opportuno.

Esempi:

input      output
                          // Empty String is a legal input
[          []             // Boring example
[()]       [()]           // Do nothing if there's nothing to be done
({{        ({{}})         // NOT (){}{} (0 + 0 + 0). Maximum distance is 4 + 2 + 0, ({{}})
[([{])]}   {[([{}])]}     // NOT [([])]{[([])]} or similar

È possibile scrivere un programma o una funzione , ricevere l'input tramite STDIN come argomento stringa nella propria funzione, che restituisce l'output come stringa o lo stampa su STDOUT (o alternativa più vicina). Se lo si desidera, è possibile includere una nuova riga finale finale nell'output.

È possibile supporre che la stringa di input sia composta solo dai seguenti 6 caratteri (o dalla mancanza di questi): [](){}(Non è necessario il supporto <>)

Questo è code-golf , il programma più corto vince. Le scappatoie standard sono vietate, ovviamente .

code-golf string balanced-string

— durron597
fonte

Intendevi ripetere il titolo direttamente sotto il titolo effettivo o ripetere il tag direttamente sopra i tag effettivi? Ti chiedo solo nel caso in cui copiassi incollato da Sandbox e hai dimenticato di rimuoverli.

— Rainbolt,

@Rainbolt Il primo no (sandbox), il secondo sì

— durron597,

@AlexA. Riesco a vedere come sono diverse in modi minori, ma penso che siano troppo simili per essere considerate domande separate.

— NinjaBearMonkey

Giusto. Certamente non è secco e non perseguirò la chiusura se altri decidono di non farlo.

— NinjaBearMonkey

Lo considererei abbastanza diverso. Votato per riaprire.

— nderscore,

Risposte:

Python 2 - 198

Speravo di avere un po 'più di comprensione, ma non ho molto tempo per testare davvero diversi modi di fare le cose.

s="()[]{}";f=s.find
def F(S):
 r=m=""
 for c in S:
    i=f(c)^1
    if i%2:m=c+m;r+=c
    else:
     for d in m:
        if d==s[i]:break
        r+=s[f(d)^1]
     else:r=s[i]+r+c
     m=m[1:]
 for c in m:r+=s[f(c)^1]
 return r

L'OP non includeva un esempio simile {[([{}])]}{[(con gruppi adiacenti), ma se questa funzionalità è richiesta o meno, ciò genera l'output corretto{[([{}])]}{[]}

— KSab
fonte

Come sono quei 198 byte?

— Zacharý,

@ZacharyT, tabs ( \t) viene formattato come 4 spazi su overflow dello stack ma in realtà sto alternando tab e spazi (puoi farlo per i livelli di rientro in Python 2, non 3) quindi il primo livello è [space]secondo è [tab]terzo è [tab][space]avanti [tab][tab]. Inserire il codice con spazi mi dà 227 da qui mothereff.in/byte-counter , e conto 10 schede quindi 227 - (3 * 10) = 197. Huh, immagino di aver effettivamente contato troppo di 1 punto indietro quando pubblicato questo.

— KSab

DANG! È davvero un bel trucco. (Inserire alla fine della riga). È possibile combinare il ciclo for inferiore e l'istruzione return in return r+[s[f(c)^1]for c in m]per salvare byte.

— Zacharý,

Haskell, 513

La funzione h. La versione precedente non forniva risposte corrette per "({{)["e"({{)}}"

import Control.Monad

m '('=')'
m '['=']'
m '{'='}'
m ')'='('
m ']'='['
m '}'='{'

data B=B Char[B]|N[B]|Z B Char[B]
instance Eq B where(==)a b=q a==q b
instance Ord B where(<=)a b=q a<=q b

w(B o s)=o:(s>>=w)++[m o]
v(N k)=k>>=w
n(B _ k)=(sum$n<$>k)+1
q(N k)=sum$n<$>k

u(Z(Z g pc pk) c k)=Z g pc(pk++[B c k])
u(Z(N pk) c k)=N(pk++[B c k])
t(N k)=N k
t z=t$u z

f z c|elem c "([{"=[Z z c[]]
f z@(Z p o k) c|m c==o=[u z]|2>1=(u$Z(Z p o [])(m c)k):f(u z)c
f (N k)c=[Z(N[])(m c)k]

h s=v.minimum$t<$>foldM f(N [])s

— opaco
fonte