Evaluate Postfix Expression Using Stack in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to push an integer onto the stack.

DSA Go

stack := []int{}
value := 5
stack = append(stack, [1])

Drag options to blanks, or click blank then click option'

Astack

B5

Cvalue

Dappend

Attempts:

3 left

💡 Hint

Common Mistakes

Using the stack itself instead of the value.

Using the number 5 directly instead of the variable.

We push the variable value onto the stack using append.

2fill in blank

medium

Complete the code to pop the top element from the stack.

DSA Go

stack := []int{2, 3, 4}
top := stack[len(stack)[1]]
stack = stack[:len(stack)-1]

Drag options to blanks, or click blank then click option'

A-1

B+1

C-2

D+2

Attempts:

3 left

💡 Hint

Common Mistakes

Using +1 causes index out of range error.

Using -2 accesses wrong element.

To get the top element, we access the last index which is len(stack)-1.

3fill in blank

hard

Fix the error in the code to correctly convert a string to integer.

DSA Go

import "strconv"

numStr := "7"
num, err := strconv.[1](numStr, 10, 64)
if err != nil {
    panic(err)
}

Drag options to blanks, or click blank then click option'

AParseInt

BAtoi

CItoa

DParseFloat

Attempts:

3 left

💡 Hint

Common Mistakes

Using Atoi when base and bit size are needed.

Using Itoa which converts int to string.

ParseInt converts string to int64 with base and bit size parameters.

4fill in blank

hard

Fill both blanks to perform addition on two popped values.

DSA Go

b := stack[len(stack)-1]
stack = stack[:len(stack)-1]
a := stack[len(stack)-1]
stack = stack[:len(stack)-1]
result := a [1] b
stack = append(stack, [2])

Drag options to blanks, or click blank then click option'

A+

Bresult

C-

Da

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction instead of addition.

Pushing a instead of the result.

We add a and b and push the result back to the stack.

5fill in blank

hard

Fill all three blanks to evaluate a postfix expression with multiplication.

DSA Go

stack := []int{}
for _, token := range tokens {
    if token >= "0" && token <= "9" {
        num, _ := strconv.ParseInt(token, 10, 64)
        stack = append(stack, int(num))
    } else {
        b := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        a := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        result := a [1] b
        stack = append(stack, [2])
    }
}
finalResult := stack[[3]]

Drag options to blanks, or click blank then click option'

A*

Bresult

C0

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition instead of multiplication.

Accessing wrong index for final result.

We multiply a and b, push the result, and get the final result at index 0.

Practice

1. What is the main purpose of using a stack to evaluate a postfix expression?

easy

A. To count the number of operators

B. To store operands and apply operators in correct order

C. To convert postfix to infix expression

D. To reverse the postfix expression

Solution

1. Step 1: Understand postfix evaluation process

   In postfix, operands come before operators. A stack helps store operands until an operator appears.

2. Step 2: Role of stack in evaluation

   When an operator is found, the top two operands are popped from the stack, the operation is performed, and the result is pushed back.

3. Final Answer:

   To store operands and apply operators in correct order -> Option B

4. Quick Check:

   Stack stores operands for operator application [OK]

Hint: Stack holds operands until operators appear [OK]

Common Mistakes:

• Thinking stack reverses the expression
• Confusing postfix with infix conversion
• Ignoring the order of operations

2. Which of the following Go code snippets correctly pushes an integer onto a stack represented by a slice?

easy

A. stack.add(value)

B. stack.push(value)

C. stack.insert(value)

D. stack = append(stack, value)

Solution

1. Step 1: Understand Go slice operations

   In Go, slices use append() to add elements at the end.

2. Step 2: Identify correct push operation

   stack = append(stack, value) correctly adds value to the stack slice.

3. Final Answer:

   stack = append(stack, value) -> Option D

4. Quick Check:

   Use append() to push in Go slices [OK]

Hint: Use append() to add elements to slice stack [OK]

Common Mistakes:

• Using non-existent push() method on slice
• Confusing slice with other data structures
• Trying to use insert() which is not a Go slice method

3. What is the output of the following Go code that evaluates the postfix expression "23+5*"?

func evaluatePostfix(expr string) int {
    stack := []int{}
    for _, ch := range expr {
        if ch >= '0' && ch <= '9' {
            stack = append(stack, int(ch-'0'))
        } else {
            b := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            a := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            switch ch {
            case '+':
                stack = append(stack, a+b)
            case '*':
                stack = append(stack, a*b)
            }
        }
    }
    return stack[0]
}

fmt.Println(evaluatePostfix("23+5*"))

medium

A. 25

B. 15

C. 10

D. Error

Solution

1. Step 1: Evaluate "23+" part

   Push 2, push 3, then '+' pops 3 and 2, adds to 5, pushes 5.

2. Step 2: Evaluate remaining "5*" part

   Push 5, then '*' pops 5 and 5, multiplies to 25, pushes 25.

3. Final Answer:

   25 -> Option A

4. Quick Check:

   (2+3)*5 = 25 [OK]

Hint: Calculate stepwise: operands first, then operator [OK]

Common Mistakes:

• Mixing operand order during pop
• Confusing '+' and '*' precedence
• Forgetting to push intermediate results

4. The following Go code attempts to evaluate a postfix expression but produces a runtime error. What is the error?

func evaluatePostfix(expr string) int {
    stack := []int{}
    for _, ch := range expr {
        if ch >= '0' && ch <= '9' {
            stack = append(stack, int(ch-'0'))
        } else {
            a := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            b := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            switch ch {
            case '+':
                stack = append(stack, a+b)
            case '*':
                stack = append(stack, a*b)
            }
        }
    }
    return stack[0]
}

What causes the error?

medium

A. Stack underflow due to popping before checking stack size

B. Operands are popped in wrong order causing wrong calculation

C. Invalid type conversion from rune to int

D. Missing case for '-' operator

Solution

1. Step 1: Analyze stack pop operations

   The code pops two operands without checking if stack has enough elements, risking empty slice access.

2. Step 2: Identify runtime error cause

   If expression is invalid or incomplete, popping causes stack underflow and runtime panic.

3. Final Answer:

   Stack underflow due to popping before checking stack size -> Option A

4. Quick Check:

   Always check stack size before popping [OK]

Hint: Check stack length before popping operands [OK]

Common Mistakes:

• Assuming stack always has enough operands
• Swapping operand pop order but no error
• Ignoring runtime panic messages

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

hard

A. 8

B. 2

C. 4

D. 6

Solution

1. Step 1: Evaluate "82/" part

   Push 8, push 2, '/' pops 2 and 8, divides 8/2 = 4, push 4.

2. Step 2: Evaluate "3-" part

   Push 3, '-' pops 3 and 4, subtracts 4-3 = 1, push 1.

3. Step 3: Evaluate "4*" part

   Push 4, '*' pops 4 and 1, multiplies 1*4 = 4, push 4.

4. Final Answer:

   4 -> Option C

5. Quick Check:

   (8/2 - 3) * 4 = 4 [OK]

Hint: Evaluate stepwise: divide, subtract, then multiply [OK]

Common Mistakes:

• Incorrect operand order in division or subtraction
• Forgetting operator precedence in postfix
• Mixing up intermediate stack values