## 640. Solve the Equation

Solve a given equation and return the value of `x` in the form of string "x=#value". The equation contains only '+', '-' operation, the variable `x` and its coefficient.

If there is no solution for the equation, return "No solution".

If there are infinite solutions for the equation, return "Infinite solutions".

If there is exactly one solution for the equation, we ensure that the value of `x` is an integer.

Example 1:

```Input: "x+5-3+x=6+x-2"
Output: "x=2"
```

Example 2:

```Input: "x=x"
Output: "Infinite solutions"
```

Example 3:

```Input: "2x=x"
Output: "x=0"
```

Example 4:

```Input: "2x+3x-6x=x+2"
Output: "x=-1"
```

Example 5:

```Input: "x=x+2"
Output: "No solution"
```

b'
\n\n

## Solution

\n
\n

#### Approach #1 Partioning Coefficients [Accepted]

\n

In the current approach, we start by splitting the given based on `=` sign. This way, we\'ve separated the left and right hand side of this equation. Once this is done, we need to extract the individual elements(i.e. `x`\'s and the numbers) from both sides of the equation. To do so, we make use of `breakIt` function, in which we traverse over the given equation(either left hand side or right hand side), and put the separated parts into an array.

\n

Now, the idea is as follows. We treat the given equation as if we\'re bringing all the `x`\'s on the left hand side and all the rest of the numbers on the right hand side as done below for an example.

\n

`x+5-3+x=6+x-2`

\n

`x+x-x=6-2-5+3`

\n

Thus, every `x` in the left hand side of the given equation is treated as positive, while that on the right hand side is treated as negative, in the current implementation.

\n

Likewise, every number on the left hand side is treated as negative, while that on the right hand side is treated as positive. Thus, by doing so, we obtain all the `x`\'s in the new and all the numbers in the new of the original equation.

\n

Further, in case of an `x`, we also need to find its corresponding coefficients in order to evaluate the final effective coefficient of `x` on the left hand side. We also evaluate the final effective number on the right hand side as well.

\n

Now, in case of a unique solution, the ratio of the effective and gives the required result. In case of infinite solutions, both the effective and turns out to be zero e.g. `x+1=x+1`. In case of no solution, the coefficient of `x`() turns out to be zero, but the effective number on the is non-zero.

\n\n

Complexity Analysis

\n
\n
• \n

Time complexity : . Generating coefficients and findinn and will take .

\n
• \n
• \n

Space complexity : . ArrayList size can grow upto .

\n
• \n
\n
\n

#### Approach #2 Using regex for spliting [Accepted]

\n

Algorithm

\n

In the last approach, we made use of a new function `breakIt` to obtain the individual components of either the left hand side or the right hand side. Instead of doing so, we can also make use of splitting based on `+` or `-` sign, to obtain the individual elements. The rest of the process remains the same as in the last approach.

\n

In order to do the splitting, we make use of an expression derived from regular expressions(regex). Simply speaking, regex is a functionality used to match a target string based on some given criteria. The ?=n quantifier, in regex, matches any string that is followed by a specific string . What it\'s saying is that the captured match must be followed by but the itself isn\'t captured.

\n

By making use of this kind of expression in the `split` functionality, we make sure that the partitions are obtained such that the `+` or `-` sign remains along with the parts(numbers or coefficients) even after the splitting.

\n\n

Complexity Analysis

\n
\n
• \n

Time complexity : . Generating coefficients and finding and will take .

\n
• \n
• \n

Space complexity : . ArrayList size can grow upto .

\n
• \n
\n
\n

Analysis written by: @vinod23

\n
'