Solving alphabetical expression to obtain sentences using Binary Tree - algorithm

Question

I'm trying to solve alphabetical expressions to obtain valid sentences.
Example of input and output would be:-
Input
Actual:
(((​"​one​"​ . ​"​two​"​) | ​"​twelve​"​) . (​"​zero​"​ | ​"​o​"​) . ​"​six​"​)
Tokenized:
['(', '(', '(', 'one', '.', 'two', ')', '|', 'twelve', ')', '.',
'(', 'zero', '|', 'o', ')', '.', 'six', ')']
Output
one two zero six
one two o six
twelve o six
Operators
() - required grouping operator
[] - optional grouping operator
. - concatenate connecting operator
| - OR connecting operator
The . operator does have a higher precedence than the | operator.
I am not able to understand how should I go about it. (I want to write the code in Python)

Answer 1

I assume you already managed to tokenise the input. I would then suggest as a second step to build a tree from the tokens, so that the following input:
(((​"​one​"​ . ​"​two​"​) | ​"​twelve​"​) . (​"​zero​"​ | ​"​o​"​) . ​"​six​"​)
...would become the following tree:
Note that you could implement the optional words (wrapped in [...]) re-using the OR operator in combination with a None element (which would produce nothing in a final string). For instance ["six"] would be interpreted as if it were (None|"six"), which in the tree would be:
With the tree you can use recursion to find the possible strings. Each recursive call would return a list of possible strings (maybe just one). In case the children belong to a . (AND) operation, then all lists of strings found for the children must be combined as a Cartesian product. In case they belong to a | (OR) operation, these lists should be just concatenated (since all possible strings for any of the children are possible for the parent).
Here is some code that could be useful:
import itertools
import re
# subclass list just to distinguish between arguments of a "." or "|" operator
class OrList(list): # for "|" operator arguments
pass
class AndList(list): # for "." operator arguments
pass
def parse(tokens):
# helper function to conditionally either append-to or extend a list
def add(lst, factor):
if type(factor) == type(lst):
lst.extend(factor)
else:
lst.append(factor)
return lst
# helper function to conditionally return the given list or its only element
def simplify(lst):
if isinstance(lst, OrList): # remove duplicates
for i in range(len(lst)-1,-1,-1):
if lst.index(lst[i]) < i:
del lst[i]
return lst if len(lst) > 1 else lst[0]
it = iter(tokens + [""])
def recur(end):
terms = OrList()
factors = AndList()
token = None
while token != end:
token = next(it)
if token[0] == '"':
add(factors, token[1:-1]) # remove the quotes
elif token == "(":
add(factors, recur(")"))
elif token == "[": # encode [expr] as if it were: (|expr)
add(factors, add(OrList([None]), recur("]")))
else:
raise ValueError("Expected expression, got {}".format(token))
token = next(it)
if token != end and token not in ".|":
raise ValueError("Expected operator, got {}".format(token))
if token == "|" or token == end:
add(terms, simplify(factors))
factors = AndList()
return simplify(terms)
return recur("")
def validPhrases(node): # returns list of strings
if isinstance(node, list):
results = [validPhrases(child) for child in node]
if isinstance(node, OrList):
# flatten
results = list(itertools.chain.from_iterable(results))
else: # instance of AndList
# all combinations
results = [" ".join([s for s in combi if s != None])
for combi in itertools.product(*results)]
return list(set(results)) # remove duplicates
else: # str
return [node]
def generate(expr):
# tokenize
tokens = re.findall(r'"[^"]*"|\S', expr) # don't throw away the quotes yet
# make a tree in line with precedence rules
tree = parse(tokens)
# finally build all possible strings from this tree
return validPhrases(tree)
expr = '((("one" . "two" | "twelve") . ("zero" | "o")) . "six")'
print(generate(expr))
See it run on repl.it