Why Stack Exists and What Problems It Solves in DSA Typescript - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do we use a stack data structure?

Which of the following best explains why a stack is useful in programming?

A It organizes data randomly to speed up searching.

B It stores data in a first-in, first-out order, like a queue at a ticket counter.

C It helps manage data in a last-in, first-out order, useful for undo features and function calls.

D It stores data permanently on disk for long-term storage.

💡 Hint

Think about how undo buttons or browser back buttons work.

A stack stores data so the last item added is the first one removed. This is called last-in, first-out (LIFO). It is useful for things like undo actions, backtracking, and managing function calls.

❓ Predict Output

intermediate

Stack Operations Output

What is the printed output after running this TypeScript stack code?

DSA Typescript

class Stack {
  private items: number[] = [];
  push(item: number) { this.items.push(item); }
  pop(): number | undefined { return this.items.pop(); }
  print() { console.log(this.items.join(' -> ') + ' -> null'); }
}

const stack = new Stack();
stack.push(10);
stack.push(20);
stack.pop();
stack.push(30);
stack.print();

A 10 -> 20 -> 30 -> null

B 20 -> 30 -> null

C 30 -> null

D 10 -> 30 -> null

💡 Hint

Remember pop removes the last pushed item.

The stack starts empty. Push 10, stack is [10]. Push 20, stack is [10, 20]. Pop removes 20, stack back to [10]. Push 30, stack is [10, 30]. Printing shows '10 -> 30 -> null'.

🔧 Debug

advanced

Identify the error in stack implementation

What error will this TypeScript stack code cause when running?

DSA Typescript

class Stack {
  private items: number[] = [];
  push(item: number) { this.items.push(item); }
  pop(): number { return this.items.pop()!; }
}

const stack = new Stack();
stack.pop();

A No error, returns undefined safely

B TypeError because pop returns undefined but method expects number

C SyntaxError due to missing return type

D Runtime error because push is not defined

💡 Hint

Check the pop method return type and what happens when popping empty stack.

The pop method is declared to return a number, but when the stack is empty, pop() returns undefined. This mismatch causes a TypeError at runtime.

🚀 Application

advanced

Using stack to check balanced parentheses

What will be the output of this function when called with input '(())()'?

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 matching opening and closing parentheses using a stack.

The function pushes '(' onto the stack and pops when it sees ')'. For '(())()', all parentheses match correctly, so the stack is empty at the end, returning true.

🧠 Conceptual

expert

Why is stack preferred for function call management?

Why do programming languages use a stack to manage function calls?

A Because functions are called and return in a last-in, first-out order, matching stack behavior.

B Because stacks allow random access to any function call in memory.

C Because stacks automatically parallelize function calls for speed.

D Because stacks store function calls permanently for debugging.

💡 Hint

Think about how functions call other functions and then return back.

Function calls happen in a last-in, first-out order: the last function called must finish before the previous one continues. A stack naturally models this behavior.

Practice

1. Why do we use a stack data structure in programming?

easy

A. To sort numbers in ascending order automatically

B. To store data in random order for quick access

C. To keep track of function calls and return in the correct order

D. To store large amounts of data permanently

Solution

1. Step 1: Understand the purpose of a stack

   A stack stores items in Last In First Out (LIFO) order, which is perfect for tracking function calls.

2. Step 2: Relate stack to function calls

   When a function calls another, the current function is paused and saved on the stack. When the called function finishes, the program returns to the last saved function.

3. Final Answer:

   To keep track of function calls and return in the correct order -> Option C

4. Quick Check:

   Stack = function call tracking [OK]

Hint: Stack follows LIFO, perfect for tracking nested calls [OK]

Common Mistakes:

• Thinking stack stores data randomly
• Confusing stack with queue
• Assuming stack sorts data automatically

2. Which of the following is the correct way to push an element '5' onto a stack named myStack in TypeScript?

easy

A. myStack.push(5);

B. myStack.add(5);

C. myStack.insert(5);

D. myStack.enqueue(5);

Solution

1. Step 1: Recall stack method names in TypeScript

   Stacks use push() to add elements on top.

2. Step 2: Identify correct method for adding element

   push() is the standard method; others like add(), insert(), or enqueue() are not used for stacks.

3. Final Answer:

   myStack.push(5); -> Option A

4. Quick Check:

   Push adds element on top [OK]

Hint: Use push() to add on stack top [OK]

Common Mistakes:

• Using enqueue which is for queues
• Using add or insert which are not stack methods
• Confusing push with pop

3. What will be the output of the following TypeScript code?

const stack: number[] = [];
stack.push(10);
stack.push(20);
const popped = stack.pop();
stack.push(30);
console.log(stack);

medium

A. [30]

B. [10, 20, 30]

C. [20, 30]

D. [10, 30]

Solution

1. Step 1: Trace stack operations step-by-step

   Initially stack is empty []. Push 10 -> [10]. Push 20 -> [10, 20]. Pop removes 20 -> [10]. Push 30 -> [10, 30].

2. Step 2: Determine final stack content

   After all operations, stack contains [10, 30].

3. Final Answer:

   [10, 30] -> Option D

4. Quick Check:

   Push/pop changes stack top [OK]

Hint: Pop removes last pushed element [OK]

Common Mistakes:

• Forgetting pop removes top element
• Assuming pop returns stack without removing
• Mixing order of push and pop

4. Find the error in this TypeScript stack usage code:

const stack: number[] = [];
stack.push(1);
stack.push(2);
const top = stack.peek();
console.log(top);

medium

A. Stack does not have a peek() method by default

B. push() method is used incorrectly

C. stack should be declared as Stack<number> not number[]

D. console.log cannot print stack elements

Solution

1. Step 1: Check methods available on array used as stack

   TypeScript arrays have push() and pop(), but no peek() method by default.

2. Step 2: Identify cause of error

   Calling stack.peek() will cause a runtime error because peek() is not defined.

3. Final Answer:

   Stack does not have a peek() method by default -> Option A

4. Quick Check:

   peek() missing in array stack [OK]

Hint: Array stack has pop(), no peek() [OK]

Common Mistakes:

• Assuming peek() exists on arrays
• Thinking push() is wrong
• Confusing type declaration with method error

5. You want to reverse a string using a stack in TypeScript. Which approach correctly uses a stack to reverse the string "hello"?

hard

A. Push characters and pop in same order to keep string unchanged

B. Push each character onto stack, then pop all to build reversed string

C. Use stack to sort characters alphabetically

D. Push entire string onto stack, then pop once to get reversed string

Solution

1. Step 1: Understand stack reversal logic

   Pushing characters one by one stores them in order. Popping them reverses the order because stack is LIFO.

2. Step 2: Apply to string reversal

   Push 'h', 'e', 'l', 'l', 'o' then pop all to get 'o', 'l', 'l', 'e', 'h' which is reversed string.

3. Final Answer:

   Push each character onto stack, then pop all to build reversed string -> Option B

4. Quick Check:

   Stack LIFO reverses order [OK]

Hint: Push chars, pop all to reverse string [OK]

Common Mistakes:

• Pushing entire string at once
• Popping in same order as push
• Using stack for sorting instead of reversing