# LeetCode Valid Parentheses

The JavaScript Way

Given a string `s` containing just the characters `'('`, `')'`, `'{'`, `'}'`, `'['` and `']'`, determine if the input string is valid.

An input string is valid if:

1. Open brackets must be closed by the same type of brackets.
2. Open brackets must be closed in the correct order.
3. Every close bracket has a corresponding open bracket of the same type.

Example 1:

`Input: s = "()"Output: true`

Example 2:

`Input: s = "()[]{}"Output: true`

Example 3:

`Input: s = "(]"Output: false`

## Solution

`explain this code:/** * @param {string} s * @return {boolean} */class Stack {  constructor() {    this.count = 0;    this.items = {};  }  isEmpty() {    return this.count == 0;  }  push(element) {    this.items[this.count] = element;    this.count++;  }  pop() {    if (this.isEmpty()) {      return "";    }    this.count--;    const result = this.items[this.count];    delete this.items[this.count];    return result;  }  peek() {    if (this.isEmpty()) {      return undefined;    }    return this.items[this.count - 1];  }  size() {    return this.count;  }  clear() {    this.items = {};    this.count = 0;  }  toString() {    if (this.isEmpty()) {      return "";    }    let objString = `\${this.items}`;    for (let i = 1; i < this.count; i++) {      objString = `\${objString},\${this.items[i]}`;    }    return objString;  }}`

This is our main stack:

The code defines a class called `Stack` that implements a stack data structure using an object. The `Stack` class has the following methods:

• `constructor()`: initializes an empty object to store the stack and sets the count to zero.
• `isEmpty()`: returns true if the stack is empty and false otherwise.
• `push(element)`: adds an element to the top of the stack and increments the count.
• `pop()`: removes the top element from the stack and returns it. If the stack is empty, it returns an empty string.
• `peek()`: returns the top element of the stack without removing it. If the stack is empty, it returns `undefined`.
• `size()`: returns the number of elements in the stack.
• `clear()`: removes all the elements from the stack and resets the count to zero.
• `toString()`: returns a string representation of the stack.

Now lets look into the actual solution

`var isValid = function(s) {checkValidPair=(a)=>{    // console.log(first)    if(stack.peek()=="(" && a==")"){        return true    }    if(stack.peek()=="{" && a=="}"){        return true    }    if(stack.peek()=="[" && a=="]"){        return true    }    else return false}`
`   let n = s.length;    // console.log(n);    const stack = new Stack();    for (let i = 0; i <=n ; i++) {      if (s[i] == "(" || s[i] == "{" || s[i] == "[") {        stack.push(s[i]);        console.log(stack.peek())      } else if (s[i] == ")" || s[i] == "}" || s[i] == "]") {        if (stack.isEmpty() || !checkValidPair(s[i])) {          return false;        } else {          stack.pop();        }      }    }    // console.log("stack", stack.toString());    return stack.isEmpty() ? true : false;};`

The `isValid` function checks whether a given string `s` is balanced or not. It creates a new instance of the `Stack` class and iterates over the string using a for loop. For each character in the string, if it is an opening parentheses, bracket, or curly brace, it is pushed onto the stack. If it is a closing parentheses, bracket, or curly brace, it is checked against the top element of the stack to see if they form a valid pair. If they do, the top element is removed from the stack; otherwise, the function returns `false`. After the loop ends, if the stack is empty, it returns `true`; otherwise, it returns `false`.

I will be trying to solve all the other LeetCode problems. Follow Adarsh gupta for more.