Aujourd'hui, votre défi est de produire toutes les parenthèses complètes possibles d'une expression.

Votre entrée est une seule ligne ASCII imprimable contenant un ou plusieurs termes séparés par des opérateurs. L'entrée peut également contenir des espaces - vous devez les ignorer. Un terme est [a-zA-Z0-9], un opérateur est [^ ()a-zA-Z0-9]. Vous pouvez supposer que l'entrée est toujours valide.

Afficher toutes les façons possibles de mettre complètement l'expression entre parenthèses, séparées par des retours à la ligne avec un retour à la ligne facultatif.

Ne pas :

• Termes entre parenthèses - entre parenthèses uniquement autour des opérateurs.
• Réorganisez les conditions.
• Sortez tous les espaces.

Exemple d'entrée / sortie:

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)

Le plus petit code en octets gagne.

Pyth, 38 octets

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

Essayez-le en ligne.

Il définit une fonction récursive qui:

• renvoie l'entrée si sa longueur est 1
• prend toutes les deux divisions de l'entrée sur les opérateurs, et pour chaque division:
  • s'appelle récursivement sur chacune des moitiés
  • prend le produit cartésien des résultats de chaque moitié
  • joint chaque résultat par l'opérateur à la division
  • entre parenthèses le résultat joint
• et enfin concatène les tableaux résultants.

La fonction est ensuite appelée avec la chaîne d'entrée avec des espaces supprimés et les résultats sont joints par des retours à la ligne.

JavaScript (ES6), 208 197 octets

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)

Explication

Utilise une fonction récursive qui prend un tableau de [ t, o, t, o, etc... ]et parenthèses chaque paire consécutive de deux termes ensemble comme [ (tot), o, etc... ]et répète ce processus jusqu'à ce qu'il n'y ait qu'un seul élément dans le tableau, puis filtre les valeurs en double.

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

Tester

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>