Espressioni tra parentesi

Oggi la tua sfida è quella di produrre tutte le possibili parentesi complete di un'espressione.

Il tuo input è una singola riga di ASCII stampabile contenente uno o più termini separati da operatori. L'input potrebbe contenere anche spazi: è necessario ignorarli. Un termine è [a-zA-Z0-9], un operatore è [^ ()a-zA-Z0-9]. Si può presumere che l'input sia sempre valido.

Stampa tutti i modi possibili per racchiudere tra parentesi l'espressione data, separati da newline con un newline finale facoltativo.

Do non :

Termini tra parentesi - solo tra parentesi attorno agli operatori.
Riordina i termini.
Output eventuali spazi.

Esempio di input / output:

N
N

a * b
(a*b)

x_x_0
(x_(x_0))
((x_x)_0)

a * b|c|d
(a*(b|(c|d)))
(a*((b|c)|d))
((a*b)|(c|d))
((a*(b|c))|d)
(((a*b)|c)|d)

Vince il codice più piccolo in byte.

code-golf balanced-string

— orlp
fonte

Devi elencare gli operatori esatti che dobbiamo considerare. È !un operatore? Che dire ↑?

— Ottimizzatore

@Optimizer Ho elencato l'esatta espressione regolare di ciò che è considerato un operatore. !si inserisce la regex, così fa ↑, tuttavia ↑non può essere parte dell'ingresso perché non è ASCII stampabile.

— orlp

Ah ok. Quindi tutto tranne un termine è un operatore ...

— Ottimizzatore

Quindi sia i termini che gli operatori sono sempre lunghi un personaggio?

— user81655

inserisci qui il gioco di parole obbligatorio relativo alla LISP

— cat

Risposte:

Pyth, 38 byte

L?tbsmmjj@bdk"()"*y<bdy>bhd:1lb2bjy-zd

Provalo online.

Definisce una funzione ricorsiva che:

restituisce l'ingresso se la sua lunghezza è 1
accetta tutti i due split dell'input sugli operatori e per ogni split:
- si chiama ricorsivamente su ciascuna delle metà
- prende il prodotto cartesiano dei risultati di ogni metà
- unisce ogni risultato dall'operatore alla divisione
- tra parentesi il risultato unito
e infine concatena gli array risultanti.

La funzione viene quindi chiamata con la stringa di input con spazi rimossi e i risultati vengono uniti da nuove righe.

— PurkkaKoodari
fonte

JavaScript (ES6), 208 197 byte

s=>((q=x=>x.map((_,i)=>(a=[...x.slice(0,i*=2),p="("+x[i]+x[++i]+x[++i]+")",...x.slice(i+1)],x[i]?a[1]?q(a):r.push(p):0)))([...s.replace(/ /g,o="")],r=[]),r.map((l,i)=>r.indexOf(l)<i?0:o+=l+`
`),o)

Spiegazione

Utilizza una funzione ricorsiva che accetta una matrice di [ t, o, t, o, etc... ]e parentesi ogni coppia consecutiva di due termini insieme come [ (tot), o, etc... ]e ripete questo processo fino a quando non vi è un solo elemento nella matrice, quindi filtra i valori duplicati.

s=>(                                  // s = input string
  (q=x=>                              // q = parenthesise array function
    x.map((_,i)=>(
      a=[                             // a = p with parenthesised pair of terms
        ...x.slice(0,i*=2),
        p="("+x[i]+x[++i]+x[++i]+")", // parenthesise and join 2 terms and an operator
        ...x.slice(i+1)
      ],
      x[i]?a[1]                       // make sure the loop is not over
        ?q(a)                         // check next level of permutations
        :r.push(p)                    // add the permutation to the results
      :0
    ))
  )([...s.replace(/ /g,               // remove spaces and parenthesise all expressions
    o="")],                           // o = output string
    r=[]),                            // r = array of result strings
  r.map(                              // filter out duplicates
    (l,i)=>r.indexOf(l)<i?0:o+=l+`
`
  ),o)                                // return o

Test

Mostra snippet di codice

Input = <input type="text" id="input" value="a * b|c|d" /><button onclick='results.innerHTML=(

s=>((q=x=>x.map((_,i)=>(a=[...x.slice(0,i*=2),p="("+x[i]+x[++i]+x[++i]+")",...x.slice(i+1)],x[i]?a[1]?q(a):r.push(p):0)))([...s.replace(/ /g,o="")],r=[]),r.map((l,i)=>r.indexOf(l)<i?0:o+=l+`
`),o)

)(input.value)'>Go</button><pre id="results"></pre>

Espandi frammento

— user81655
fonte