Evaluate Postfix Expression Using Stack in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Postfix Expression Evaluation

What is the output of the following TypeScript code that evaluates a postfix expression using a stack?

DSA Typescript

function evaluatePostfix(expression: string): number {
  const stack: number[] = [];
  for (const char of expression) {
    if (!isNaN(Number(char))) {
      stack.push(Number(char));
    } else {
      const b = stack.pop()!;
      const a = stack.pop()!;
      switch (char) {
        case '+': stack.push(a + b); break;
        case '-': stack.push(a - b); break;
        case '*': stack.push(a * b); break;
        case '/': stack.push(Math.floor(a / b)); break;
      }
    }
  }
  return stack.pop()!;
}

console.log(evaluatePostfix("231*+9-"));

A −1

B −3

C −2

D −4

💡 Hint

Trace the stack operations step-by-step for each character in the expression.

The postfix expression is evaluated by pushing numbers onto the stack and applying operators to the top two numbers. For "231*+9-":

• Push 2
• Push 3
• Push 1
• Operator '*': pop 1 and 3, multiply 3*1=3, push 3
• Operator '+': pop 3 and 2, add 2+3=5, push 5
• Push 9
• Operator '-': pop 9 and 5, subtract 5-9=-4, push -4

Result is -4 (option D).

❓ Predict Output

intermediate

Result of Postfix Expression with Division

What is the output of this TypeScript code evaluating the postfix expression "82/3-"?

DSA Typescript

function evaluatePostfix(expression: string): number {
  const stack: number[] = [];
  for (const char of expression) {
    if (!isNaN(Number(char))) {
      stack.push(Number(char));
    } else {
      const b = stack.pop()!;
      const a = stack.pop()!;
      switch (char) {
        case '+': stack.push(a + b); break;
        case '-': stack.push(a - b); break;
        case '*': stack.push(a * b); break;
        case '/': stack.push(Math.floor(a / b)); break;
      }
    }
  }
  return stack.pop()!;
}

console.log(evaluatePostfix("82/3-"));

A -1

B 1

C 0

D 2

💡 Hint

Remember that division uses Math.floor for integer division.

Step-by-step evaluation:

• Push 8
• Push 2
• Operator '/': pop 2 and 8, compute Math.floor(8/2) = 4, push 4
• Push 3
• Operator '-': pop 3 and 4, compute 4 - 3 = 1, push 1

Final result is 1 (option B).

❓ Predict Output

advanced

Output of Postfix Expression with Multiple Operators

What is the output of the following TypeScript code evaluating the postfix expression "562+*84/-"?

DSA Typescript

function evaluatePostfix(expression: string): number {
  const stack: number[] = [];
  for (const char of expression) {
    if (!isNaN(Number(char))) {
      stack.push(Number(char));
    } else {
      const b = stack.pop()!;
      const a = stack.pop()!;
      switch (char) {
        case '+': stack.push(a + b); break;
        case '-': stack.push(a - b); break;
        case '*': stack.push(a * b); break;
        case '/': stack.push(Math.floor(a / b)); break;
      }
    }
  }
  return stack.pop()!;
}

console.log(evaluatePostfix("562+*84/-"));

A 38

B 14

C 18

D 26

💡 Hint

Evaluate each operator carefully and track the stack after each step.

Step-by-step:

• Push 5
• Push 6
• Push 2
• Operator '+': pop 2 and 6, 6+2=8, push 8
• Operator '*': pop 8 and 5, 5*8=40, push 40
• Push 8
• Push 4
• Operator '/': pop 4 and 8, Math.floor(8/4)=2, push 2
• Operator '-': pop 2 and 40, 40-2=38, push 38

Final result is 38 (option A).

❓ Predict Output

advanced

Output of Postfix Expression with Negative Result

What is the output of this TypeScript code evaluating the postfix expression "93-5*"?

DSA Typescript

function evaluatePostfix(expression: string): number {
  const stack: number[] = [];
  for (const char of expression) {
    if (!isNaN(Number(char))) {
      stack.push(Number(char));
    } else {
      const b = stack.pop()!;
      const a = stack.pop()!;
      switch (char) {
        case '+': stack.push(a + b); break;
        case '-': stack.push(a - b); break;
        case '*': stack.push(a * b); break;
        case '/': stack.push(Math.floor(a / b)); break;
      }
    }
  }
  return stack.pop()!;
}

console.log(evaluatePostfix("93-5*"));

A -15

B 15

C 30

D -30

💡 Hint

Calculate subtraction before multiplication.

Step-by-step:

• Push 9
• Push 3
• Operator '-': 9 - 3 = 6, push 6
• Push 5
• Operator '*': 6 * 5 = 30, push 30

Output is 30 (option C).

🧠 Conceptual

expert

Stack Size During Postfix Evaluation

During the evaluation of the postfix expression "345*+62/-", what is the maximum size of the stack at any point?

A 3

B 4

C 5

D 6

💡 Hint

Track the stack size after each push and pop operation.

Step-by-step stack size:

• Push 3 (size 1)
• Push 4 (size 2)
• Push 5 (size 3)
• Operator '*': pop 5 and 4, push 20 (size 2)
• Operator '+': pop 20 and 3, push 23 (size 1)
• Push 6 (size 2)
• Push 2 (size 3)
• Operator '/': pop 2 and 6, push 3 (size 2)
• Operator '-': pop 3 and 23, push 20 (size 1)

Maximum stack size reached is 3 (option A).

Practice

1. What is the main data structure used to evaluate a postfix expression?

easy

A. Linked List

B. Queue

C. Array

D. Stack

Solution

1. Step 1: Understand postfix evaluation process

   Postfix expressions are evaluated by scanning from left to right and using a data structure to store operands temporarily.

2. Step 2: Identify the suitable data structure

   A stack allows pushing operands and popping them when an operator is encountered, making it ideal for postfix evaluation.

3. Final Answer:

   Stack -> Option D

4. Quick Check:

   Postfix evaluation uses Stack [OK]

Hint: Remember: postfix needs LIFO structure, so use stack [OK]

Common Mistakes:

• Confusing stack with queue
• Thinking array alone can manage operations
• Using linked list without stack behavior

2. Which of the following is the correct way to push a number onto a stack in TypeScript?

easy

A. stack.push(number);

B. stack.add(number);

C. stack.insert(number);

D. stack.enqueue(number);

Solution

1. Step 1: Recall stack methods in TypeScript

   Stacks in TypeScript are usually arrays, and pushing an element uses the push() method.

2. Step 2: Identify correct method

   push() adds an element to the end of the array, simulating stack push operation.

3. Final Answer:

   stack.push(number); -> Option A

4. Quick Check:

   Use push() to add to stack [OK]

Hint: Use push() to add elements to stack in TypeScript [OK]

Common Mistakes:

• Using add() or insert() which are not array methods
• Confusing enqueue() with queue operation
• Trying to use non-existent stack methods

3. What is the output of evaluating the postfix expression "6 2 3 + - 3 8 2 / + *" using a stack?

medium

A. 7

B. 36

C. 24

D. 30

Solution

1. Step 1: Evaluate postfix step-by-step

   Expression: 6 2 3 + - 3 8 2 / + *
   Push 6 -> [6]
   Push 2 -> [6, 2]
   Push 3 -> [6, 2, 3]
   + : pop 3 (right), pop 2 (left) -> 2 + 3 = 5 -> [6, 5]
   - : pop 5 (r), pop 6 (l) -> 6 - 5 = 1 -> [1]
   Push 3 -> [1, 3]
   Push 8 -> [1, 3, 8]
   Push 2 -> [1, 3, 8, 2]
   / : pop 2 (r), 8 (l) -> 8 / 2 = 4 -> [1, 3, 4]
   + : pop 4 (r), 3 (l) -> 3 + 4 = 7 -> [1, 7]
   * : pop 7 (r), 1 (l) -> 1 * 7 = 7 -> [7]

2. Step 2: Confirm final stack value

   Final result: 7

3. Final Answer:

   7 -> Option A

4. Quick Check:

   Postfix evaluation result = 7 [OK]

Hint: Evaluate stepwise, push numbers, pop two for operators [OK]

Common Mistakes:

• Mixing operand order in subtraction/division
• Not popping two operands for each operator
• Assuming division is integer without checking

4. Identify the error in this TypeScript code snippet for postfix evaluation:

function evalPostfix(expr: string): number {
  const stack: number[] = [];
  for (const ch of expr.split(' ')) {
    if (!isNaN(Number(ch))) {
      stack.push(Number(ch));
    } else {
      const a = stack.pop();
      const b = stack.pop();
      switch (ch) {
        case '+': stack.push(a + b); break;
        case '-': stack.push(b - a); break;
        case '*': stack.push(a * b); break;
        case '/': stack.push(b / a); break;
      }
    }
  }
  return stack.pop()!;
}

medium

A. Operands are popped in wrong order for addition and multiplication

B. Missing check for empty stack before popping

C. Operands are popped in wrong order for subtraction and division

D. Using Number() instead of parseInt() causes errors

Solution

1. Step 1: Check for potential runtime errors

   The code pops from the stack without verifying if there are enough elements. For operators, it needs at least 2 elements; at the end, at least 1.

2. Step 2: Identify the issue

   Missing check for empty stack (or insufficient elements) before popping can cause runtime crashes.

3. Final Answer:

   Missing check for empty stack before popping -> Option B

4. Quick Check:

   Always validate stack size before pop [OK]

Hint: Check stack.length before every pop() to avoid errors [OK]

Common Mistakes:

• Swapping operand order for subtraction/division
• Not checking stack empty before pop
• Confusing Number() and parseInt() usage

5. Given the postfix expression "5 1 2 + 4 * + 3 -", what is the final result after evaluation using a stack?

hard

A. 17

B. 13

C. 14

D. 10

Solution

1. Step 1: Evaluate inner expressions stepwise

   Push 5, 1, 2
   '+' pops 2 and 1, sums 3; stack: [5,3]
   Push 4
   '*' pops 4 and 3, multiplies 12; stack: [5,12]
   '+' pops 12 and 5, sums 17; stack: [17]
   Push 3
   '-' pops 3 and 17, computes 17-3=14; stack: [14]

2. Step 2: Confirm final stack value

   Only one value remains: 14, which is the final result.

3. Final Answer:

   14 -> Option C

4. Quick Check:

   Postfix evaluation result = 14 [OK]

Hint: Evaluate operators stepwise, watch operand order carefully [OK]

Common Mistakes:

• Adding instead of subtracting last step
• Mixing operand order in subtraction
• Skipping multiplication step