As I haven’t progressed very much with my WebGL apps due to a variety of reasons/excuses (lack of willpower, a crash course on nuclear reactors engineering since the Fukushima nuclear crisis started, etc.), I decided to make a quick post showing a solution to a simple problem. In other words, the main purpose of this post is just to avoid leaving a month without posts ðŸ˜€

##### The problem

Given an arithmetic expression without parentheses, insert them to get a specified result. For example, if the expression is 2+2/2 and the desired result is 2, there is a single solution: (2+2)/2. On the other hand, if the desired result is 0 there is no solution.

It’s easy to see the answers in simple cases like the last one. But it’s not so easy to see if we can get a result of 18 by adding parentheses to 18-6/2+4-1*2… so let’s write code to do the hard work for us.

##### A solution

The parentheses only change the order in which the different operators apply and the effects of any operation order can be obtained with some parenthesization. So, if we search for a permutation of the order in which the operators are applied that gives us the desired result, we are getting a solution for the original problem.

This new problem is not exactly the same as the original one by two reasons that can be exemplified as follows:

- Given the expression 2+2*2+2, the orders of operation 1-3-2 and 3-1-2 are associated to the same parenthesized expression: (2+2)*(2+2).
- The parenthesizations (2+2)+2, 2+(2+2) and 2+2+2 are equivalent due to the associativity of addition.

But, as this only gives us some redundant solutions that can be easily eliminated with some post-processing, it’s not a problem from the correctness point of view. Being able to remove this redundant solutions without needing to enumerate them would be a great thing performance wise, but it doesn’t seem easy and it’s not required for small expressions (10! < 10^{7}).

###### Permutations in lexicographic order

To avoid accidentally skipping some permutations, it’s useful to follow a specific order when enumerating them. In this section we will see how we can go through all the permutations of an array [0, 1, 2, …, *n* – 1] in lexicographic order.

Given some permutation of the array, that we will call *a*, the next one will probably share some prefix and will differ in the order of the last elements. As we cannot get a lexicographically greater permutation by permuting a suffix that is in reverse order (starting from the greater elements), we need to permute a suffix that is not in reverse order. Then we will make our first step to search for this suffix:

Find the largest index k such that a[k] < a[k + 1].

The specification of the largest index is equivalent to search for the *minimal* suffix to permute, something required to get a permutation that is *lexicographically immediate*. If this suffix cannot be found, we are at the last permutation.

Now we need to decide what to permute. It’s clear that we cannot get a greater permutation just by permuting the suffix *a*[*k*+1 .. *n*-1], as they are in reverse order. So we need to replace *a*[*k*] by some element and the obvious choice is to search for the immediately greater element in the suffix or, as the suffix *a*[*k*+1 .. *n*-1] is in reverse order:

Find the largest index l such that a[k] < a[l].

The lexicographically smallest permutation starting with the original *a*[*l*] can be obtained by appending all the other elements of the original suffix in ascending order. But, as the suffix is in descending order and *l* is the largest index such that a[k] < a[l], we can get the same result in an easier way:

Swap a[k] with a[l].

Reverse the sequence from a[k + 1] up to and including the final element a[n].

The final code in JS can be seen here.

###### Evaluating an arithmetic expression with different orders of operations

I started using an array whose members were alternately numbers and operators. The main problem is that, while it’s easy to go from an operator to the adjacent numbers in an array, this is not what we want to do. The desired behavior is to go from an operator to the operands, and they can be the result of a sequence of previous operations.

To solve this problem in a moderately efficient way, I adapted the parent node concept from the disjoint-set data structure. Each operation adds the result to the operator node and puts this node as the parent node of both operands, allowing efficient access to the value of the whole operand from any node that is included in it. The code that does this operations can be seen at the SVN repository of this blog.

##### Testing the solution

The whole solution can be tested at the same SVN repository, but let’s see some specific examples:

**Input expression:** 3+2*2-1*0.5

**Input result 1:** 3

**Output:** (3+2*2-1)*0.5

**Input result 2:** 6

**Output:** 3+2*(2-1*0.5)

**Input expression:** 18-6/2+4-1*2

**Input result:** 18

**Output 1:** ((18-6)/2+4-1)*2

**Output 2:** 18-(6/(2+4)-1)*2