Balanced Parentheses Problem Using Stack in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Balanced Parentheses Check

What is the output of the following TypeScript code that checks if the parentheses in the string are balanced?

DSA Typescript

function isBalanced(s: string): boolean {
  const stack: string[] = [];
  for (const char of s) {
    if (char === '(') {
      stack.push(char);
    } else if (char === ')') {
      if (stack.length === 0) return false;
      stack.pop();
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('(()())'));

A true

B false

C SyntaxError

D undefined

💡 Hint

Think about how the stack is used to track opening parentheses and matched with closing ones.

The function pushes '(' onto the stack and pops when it finds ')'. The string '(()())' is balanced, so the stack ends empty and returns true.

❓ Predict Output

intermediate

Output for Unbalanced Parentheses

What will the following TypeScript code print when checking the string '(())())' for balanced parentheses?

DSA Typescript

function isBalanced(s: string): boolean {
  const stack: string[] = [];
  for (const char of s) {
    if (char === '(') {
      stack.push(char);
    } else if (char === ')') {
      if (stack.length === 0) return false;
      stack.pop();
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('(())())'));

A true

B false

C TypeError

D null

💡 Hint

Count the number of opening and closing parentheses carefully.

The string has one extra closing parenthesis without a matching opening one, so the function returns false.

🔧 Debug

advanced

Identify the Error in Parentheses Checking Code

What error will this TypeScript code produce when checking balanced parentheses?

DSA Typescript

function isBalanced(s: string): boolean {
  const stack: string[] = [];
  for (const char of s) {
    if (char === '(') {
      stack.push(char);
    } else if (char === ')') {
      if (stack.length === 0) return false;
      stack.pop();
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('()'));

A true

B TypeError

C undefined

D false

💡 Hint

Look carefully at how the pop method is called.

The original code used stack.pop without parentheses, so the pop method was not called. The fixed code calls stack.pop() correctly, so it returns the correct boolean result.

🧠 Conceptual

advanced

Stack Usage in Balanced Parentheses Problem

Why is a stack the best data structure to check for balanced parentheses in a string?

A Because a stack allows checking the last opened parenthesis first, matching the last-in, first-out order needed.

B Because a stack stores all parentheses in sorted order automatically.

C Because a stack can count the total number of parentheses quickly.

D Because a stack can reverse the string to check parentheses from the end.

💡 Hint

Think about how parentheses must close in the reverse order they open.

A stack follows last-in, first-out order, which matches how parentheses must be closed in reverse order of opening.

🚀 Application

expert

Output of Balanced Parentheses with Multiple Types

What is the output of this TypeScript code that checks balanced parentheses including (), {}, and []?

DSA Typescript

function isBalanced(s: string): boolean {
  const stack: string[] = [];
  const pairs: {[key: string]: string} = {')': '(', '}': '{', ']': '['};
  for (const char of s) {
    if (['(', '{', '['].includes(char)) {
      stack.push(char);
    } else if ([')', '}', ']'].includes(char)) {
      if (stack.length === 0 || stack.pop() !== pairs[char]) return false;
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('{[()]}'));

A TypeError

B SyntaxError

C true

D false

💡 Hint

Check if all types of brackets are matched correctly in order.

The string '{[()]}' is balanced with matching pairs in correct order, so the function returns true.

Practice

1. What is the core idea behind using a stack to validate balanced parentheses?

easy

A. Count total opening and closing brackets and compare

B. Push opening brackets onto the stack; when a closing bracket appears, check if the top matches

C. Sort the string and compare first and last characters

D. Use a counter that increments for '(' and decrements for ')'

Solution

1. Step 1: Stack tracks unmatched opens

   Opening brackets are pushed onto the stack. Each closing bracket must match the most recent unmatched opening bracket - the stack top.

2. Step 2: Why stack, not counter

   A counter works for a single bracket type but fails for mixed types: '([)]' has equal counts but is invalid. Stack tracks TYPE and ORDER.

3. Final Answer:

   Push open, match against stack top on close. -> Option B

4. Quick Check:

   Stack: push '(' '[' '{'. On close, pop and verify match. [OK]

Hint: Stack: push opens, pop+match on close. Counter alone fails for mixed bracket types. [OK]

Common Mistakes:

• Using a counter which fails for '([)]'
• Not checking bracket TYPE when matching
• Forgetting to check stack is empty at the end

2. What should be returned when a closing bracket is encountered but the stack is empty?

easy

A. true - the string might still be balanced

B. false - there is no matching opening bracket

C. Push the closing bracket and continue

D. Skip it and continue scanning

Solution

1. Step 1: Empty stack on close

   If we see ')' but the stack is empty, there is no unmatched opening bracket to pair with it. The string is invalid.

2. Step 2: Return false immediately

   No need to continue scanning - return false right away.

3. Final Answer:

   Return false - unmatched closing bracket. -> Option B

4. Quick Check:

   Close on empty stack = unmatched = false. [OK]

Hint: Empty stack + closing bracket = instant false. No match possible. [OK]

Common Mistakes:

• Continuing to scan (wastes time, wrong)
• Pushing closing bracket (corrupts the stack)
• Returning true (incorrect)

3. Is '([)]' a valid balanced parentheses string?

medium

A. Yes - it has equal counts of each bracket type

B. No - the brackets are nested incorrectly

C. Yes - all brackets are closed

D. Yes - opening and closing counts match

Solution

1. Step 1: Trace the stack

   Push '(': stack=['(']. Push '[': stack=['(','[']. See ')': stack top is '[' ≠ ')' - MISMATCH. Return false.

2. Step 2: Why counting fails

   Count approach: 1 '(', 1 '[', 1 ')', 1 ']' - all equal. But stack reveals the TYPE mismatch.

3. Final Answer:

   Invalid - '[' is at top when ')' arrives. -> Option B

4. Quick Check:

   Stack trace: push '(' push '[' → ')' arrives → top='[' ≠ ')' → false. [OK]

Hint: Trace stack: '([)]' → push '(' push '[' → ')' mismatches '[' → false. [OK]

Common Mistakes:

• Counting brackets and saying valid
• Not checking bracket type on pop
• Thinking equal counts = balanced

4. What is the time and space complexity of the stack-based balanced parentheses solution?

medium

A. Time O(n²), Space O(1)

B. Time O(n log n), Space O(n)

C. Time O(n), Space O(n)

D. Time O(n), Space O(1)

Solution

1. Step 1: Time

   Single pass through string: O(n). Each character: one push or one pop - O(1) each. Total: O(n).

2. Step 2: Space

   Stack can hold up to n/2 characters in worst case '((((...)))'. Space: O(n).

3. Final Answer:

   Time O(n), Space O(n). -> Option C

4. Quick Check:

   One pass = O(n). Stack = O(n) worst case. [OK]

Hint: Balanced parentheses: O(n) time (one pass), O(n) space (stack). [OK]

Common Mistakes:

• Saying O(1) space - stack can grow to O(n)
• Saying O(n²) - only one pass needed
• Confusing with sorting-based approaches

5. Which TypeScript code correctly implements the balanced parentheses check?

hard

A. return s.split('').filter(c => '({['.includes(c)).length === s.split('').filter(c => ')}]'.includes(c)).length;

B. const stack: string[] = []; const map: Record = {')':'(', ']':'[', '}':'{'}; for (const c of s) { if ('([{'.includes(c)) stack.push(c); else if (stack.pop() !== map[c]) return false; } return stack.length === 0;

C. let count = 0; for (const c of s) { if (c === '(') count++; else count--; if (count < 0) return false; } return count === 0;

D. return s.length % 2 === 0;

Solution

1. Step 1: Map for bracket pairs

   map pairs each closing bracket to its expected opening. On close: pop stack and check it matches map[c].

2. Step 2: Final check

   stack.length === 0 ensures no unmatched opening brackets remain.

3. Why A fails

   Only counts, doesn't check types or order.

4. Why C fails

   Counter only works for '()' - fails for '([)]' or mixed types.

5. Final Answer:

   Option B - map + stack with type checking. -> Option B

6. Quick Check:

   Map + stack + empty check at end = correct solution. [OK]

Hint: Use map {')':'(', ']':'[', '}':'{'} + stack. Pop on close, check match. Return stack.length===0. [OK]

Common Mistakes:

• Using count only (fails mixed brackets)
• Not checking stack empty at end (unmatched opens)
• Not using a map for bracket pairs