Expressions entre parenthèses

11

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.

code-golf balanced-string orlp
la source
Vous devez répertorier les opérateurs exacts que nous devons considérer. Est !un opérateur? Et alors ↑?
Optimizer
@Optimizer J'ai répertorié l'expression régulière exacte de ce qui est considéré comme un opérateur. !s'adapte à l'expression régulière, ne le fait pas ↑, cependant, ne ↑peut pas faire partie de l'entrée car elle n'est pas imprimable en ASCII.
orlp
Ah ok. Donc, tout sauf un terme est un opérateur ...
Optimizer
Les termes et les opérateurs sont donc toujours composés d'un seul caractère?
user81655
1
insérez ici le jeu de mots obligatoire lié au LISP
cat

Réponses:

2

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.

PurkkaKoodari
la source
3

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

Afficher l'extrait de code

user81655
la source