# The Valid Parenthesis Problem in Go

🛑️ This won't make any sense unless you're familiar with the problem explanation on LeetCode: https://leetcode.com/problems/valid-parentheses

## Simplified Problem

For the simplest case of a string with length 2 and only `(` or `)`, there are four options:

``````(), )(, ((, ))
``````

How can we decide that the first one is the only valid one? I think about this problem as trying to find when it is invalid rather than valid. So we need to consider the ways a string could be invalid, and if it passes all those checks, we can consider it valid.

There are exactly two ways a string can be invalid:

1. We reach a closing bracket that hasn't yet been opened (second and fourth cases above)
2. We reach the end of the string with open brackets that aren't closed (third case above)

So, the solution here is to use a stack that we add to whenever we encounter an open bracket. To check the above conditions:

1. When we reach a closing bracket, if it doesn't match the top of the stack, the string is invalid.
2. If we've processed the whole string and there are elements left in our stack, the string is invalid.

## Example With Valid String

This is how we will process a string.

``````stack: empty
string: (([]){}[])
current: empty
``````

We then look at the first element of the string. In this case, it's an opening bracket, so we can put it onto the stack and continue.

``````stack: (
string: (([]){}[])
^
``````

We encounter a few opening brackets, so let's fast-forward through them.

We just add to stack every time:

``````stack: (([
string: (([]){}[])
^
``````

Now, we've hit our first closing bracket. So we look at the top of the stack and see if it matches:

``````stack: (([
string: (([]){}[])
^
``````

It does, so we can continue. Remove the match from the stack and step forward. We're on another closing bracket, so we again compare to the stack:

``````stack: ((
string: (([]){}[])
^
``````

Hopefully you can see that this will work for the rest of the string. At the end, we can confidently `return true` because the stack is empty and we didn't encounter any issues.

## Example With Invalid String

Let's look at what would happen with a bad string. I've skipped the first few elements (you can see they're already on the stack):

``````stack: ((
string: ((]){}[])
^
``````

In this case, we've encountered a closing bracket that doesn't match the top of the stack. Therefore, we can `return false`.

What about the second way we can fail, where there are too many opening brackets? Here's what it would look like when we reach the end of the string:

``````stack: ({
string: ((){
``````

In that case, we can `return false` at the end of the function if `len(stack) > 0` and `true` otherwise. Therefore we can simply `return len(stack) == 0`.

## Final Solution

I hope my code is simple and clear after that explanation. The only thing I do differently is instead of storing the open brackets on the stack, I store the matches that we're looking for. Please let me know if you have any questions about how it works.

``````func isValid(s string) bool {
// if the string isn't of even length,
// it can't be valid so we can return early
if len(s)%2 != 0 {
return false
}

// set up stack and map
st := []rune{}
open := map[rune]rune{
'(': ')',
'[': ']',
'{': '}',
}

// loop over string
for _, r := range s {

// if the current character is in the open map,
// put its closer into the stack and continue
if closer, ok := open[r]; ok {
st = append(st, closer)
continue
}

// otherwise, we're dealing with a closer
// check to make sure the stack isn't empty
// and whether the top of the stack matches
// the current character
l := len(st) - 1
if l < 0 || r != st[l] {
return false
}

// take the last element off the stack
st = st[:l]
}

// if the stack is empty, return true, otherwise false
return len(st) == 0
}
``````