Parenthesis Checker (DSA)

Problem Statement:(👈click here for GFG)

Given an expression string x. Examine whether the pairs and the orders of {,},(,),[,] are correct in exp.

For example, the function should return 'true' for exp = [()]{}{[()()]()} and 'false' for exp = [(]).

Note: The drive code prints "balanced" if function return true, otherwise it prints "not balanced".

Example 1:

Input:
{([])}
Output: 
true
Explanation: 
{ ( [ ] ) }. Same colored brackets can form 
balanced pairs, with 0 number of 
unbalanced bracket.

Example 2:

Input: 
()
Output: 
true
Explanation: 
(). Same bracket can form balanced pairs, 
and here only 1 type of bracket is 
present and in balanced way.

Example 3:

Input: 
([]
Output: 
false
Explanation: 
([]. Here square bracket is balanced but 
the small bracket is not balanced and 
Hence , the output will be unbalanced.

Your Task:
This is a function problem. You only need to complete the function ispar() that takes a string as a parameter and returns a boolean value true if brackets are balanced else returns false. The printing is done automatically by the driver code.

Expected Time Complexity: O(|x|)
Expected Auixilliary Space: O(|x|)

Constraints:
1 ≤ |x| ≤ 32000

Solution:

This code is checking whether a string x containing only brackets is balanced or not. A balanced string contains only matching pairs of opening and closing brackets, and every opening bracket must have a corresponding closing bracket of the same type.

The approach used in this code is to iterate over each character in the string x, and maintain a stack of opening brackets. When an opening bracket is encountered, it is pushed onto the stack. When a closing bracket is encountered, the stack is popped to retrieve the topmost opening bracket, and then the type of the opening bracket is checked against the type of the closing bracket. If they are of the same type, the string is balanced so far, and the algorithm continues to the next character. If they are not of the same type, the string is unbalanced and the algorithm returns false. If the iteration completes and the stack is empty, then the string is balanced.

function isBalanced(x) {

    let stack = [];

    let openingBrackets = ['(', '{', '['];

    let closingBrackets = [')', '}', ']'];

    for (let i = 0; i < x.length; i++) {

        let char = x[i];

        if (openingBrackets.includes(char)) {

            stack.push(char);

        } else if (closingBrackets.includes(char)) {

            if (stack.length == 0) {

                return false;

            }

            let topChar = stack.pop();

            if (openingBrackets.indexOf(topChar) != closingBrackets.indexOf(char)) {

                return false;

            }

        }

    }

    return stack.length == 0;

}

console.log(isBalanced("(){}[]")); // true

console.log(isBalanced("(()){}")); // true

console.log(isBalanced("{[()]}")); // true

console.log(isBalanced("{[(])}")); // false

console.log(isBalanced("{{[[(())]]}}")); // true

Thank you,

Learning is a never-ending process, and every day is an opportunity to learn something new. Keep exploring, keep pushing your limits, and keep striving towards your goals. Remember that every small step counts, and even the smallest progress is worth celebrating. Don't be afraid to ask questions, seek guidance, and learn from others. With dedication and hard work, you can achieve anything you set your mind to. So keep learning, keep growing, and keep shining!