Stack Concept and LIFO Principle in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this stack operation sequence?

Consider a stack initially empty. We perform these operations in order:

push(5), push(10), pop(), push(7), pop(), push(3), push(8), pop()

What is the content of the stack from top to bottom after these operations?

DSA Python

stack = []
stack.append(5)
stack.append(10)
stack.pop()
stack.append(7)
stack.pop()
stack.append(3)
stack.append(8)
stack.pop()
print(stack)

A [5, 3]

B [5, 7]

C [5, 3, 8]

D [10, 7]

💡 Hint

Remember pop removes the top element of the stack.

The stack evolves as follows: push 5 -> [5], push 10 -> [5,10], pop -> removes 10 -> [5], push 7 -> [5,7], pop -> removes 7 -> [5], push 3 -> [5,3], push 8 -> [5,3,8], pop -> removes 8 -> [5,3].

🧠 Conceptual

intermediate

Which statement best describes the LIFO principle in stacks?

Choose the option that correctly explains the Last In First Out (LIFO) principle used in stacks.

A The first element added is the first one to be removed.

B Elements are removed in random order regardless of insertion.

C Elements are removed in the same order they were added.

D The last element added is the first one to be removed.

💡 Hint

Think about which element is on top of the stack.

LIFO means the last element pushed onto the stack is the first one to be popped off.

🔧 Debug

advanced

What error does this stack code produce?

Consider this Python code using a list as a stack:

stack = [1, 2, 3]
stack.pop(3)

What error will this code raise when run?

DSA Python

stack = [1, 2, 3]
stack.pop(3)

A IndexError: pop index out of range

B TypeError: pop() takes no arguments

C No error, outputs 3

D AttributeError: 'list' object has no attribute 'pop'

💡 Hint

Check the valid indices for pop in a list of length 3.

pop(3) tries to remove element at index 3, but valid indices are 0,1,2. This causes IndexError.

❓ Predict Output

advanced

What is the printed output after these stack operations?

Given this code:

stack = []
for i in range(1, 5):
    if i % 2 == 0:
        stack.append(i)
    else:
        stack.pop() if stack else None
print(stack)

What is the final content of the stack?

DSA Python

stack = []
for i in range(1, 5):
    if i % 2 == 0:
        stack.append(i)
    else:
        stack.pop() if stack else None
print(stack)

A []

B [4]

C [2, 4]

D [1, 3]

💡 Hint

Trace each iteration carefully, noting when pop happens.

i=1 (odd): stack empty, pop skipped -> [] i=2 (even): append 2 -> [2] i=3 (odd): pop top (2) -> [] i=4 (even): append 4 -> [4]

🚀 Application

expert

How many items remain in the stack after this sequence?

A stack starts empty. We perform these operations:

push(1), push(2), push(3), pop(), push(4), pop(), pop(), push(5), push(6), pop()

How many items are left in the stack at the end?

DSA Python

stack = []
stack.append(1)
stack.append(2)
stack.append(3)
stack.pop()
stack.append(4)
stack.pop()
stack.pop()
stack.append(5)
stack.append(6)
stack.pop()
print(len(stack))

A 0

B 3

C 2

D 1

💡 Hint

Count pushes and pops carefully step by step.

Operations stepwise:
push 1 -> [1]
push 2 -> [1,2]
push 3 -> [1,2,3]
pop -> removes 3 -> [1,2]
push 4 -> [1,2,4]
pop -> removes 4 -> [1,2]
pop -> removes 2 -> [1]
push 5 -> [1,5]
push 6 -> [1,5,6]
pop -> removes 6 -> [1,5]
Stack size is 2.

Practice

1. What does the LIFO principle mean in the context of a stack?

easy

A. Last In, First Out - the first item added is the first to be removed

B. Last In, First Out - the last item added is the first to be removed

C. First In, First Out - the first item added is the first to be removed

D. First In, Last Out - the first item added is the last to be removed

Solution

1. Step 1: Understand LIFO meaning

   LIFO means the last element added to the stack is the first one to be removed.

2. Step 2: Match with options

   Last In, First Out - the last item added is the first to be removed correctly describes this behavior as "Last In, First Out".

3. Final Answer:

   Last In, First Out - the last item added is the first to be removed -> Option B

4. Quick Check:

   LIFO = Last In, First Out [OK]

Hint: Remember stack removes newest item first [OK]

Common Mistakes:

• Confusing LIFO with FIFO
• Thinking first added is removed first
• Mixing order of insertion and removal

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

easy

A. stack.append(5)

B. stack.add(5)

C. stack.push(5)

D. stack.insert(5)

Solution

1. Step 1: Recall Python list methods for stack

   Python uses list's append() method to add elements to the top of the stack.

2. Step 2: Check options for correct method

   Only stack.append(5) uses append(5), which is correct for pushing onto a stack.

3. Final Answer:

   stack.append(5) -> Option A

4. Quick Check:

   Push in Python stack = append() [OK]

Hint: Use append() to push in Python stack [OK]

Common Mistakes:

• Using push() which is not a Python list method
• Using add() which is for sets
• Using insert() which inserts at specific index

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

stack = []
stack.append(10)
stack.append(20)
stack.append(30)
print(stack.pop())
print(stack.pop())
print(stack)

medium

A. 30
10
[20]

B. 10
20
[30]

C. 20
30
[10]

D. 30
20
[10]

Solution

1. Step 1: Trace stack after each append

   After append(10): [10], append(20): [10, 20], append(30): [10, 20, 30]

2. Step 2: Trace pop operations

   pop() removes last element: first pop() returns 30, second pop() returns 20, stack left is [10]

3. Final Answer:

   30 20 [10] -> Option D

4. Quick Check:

   Stack pops last in first out [OK]

Hint: Pop removes last pushed element first [OK]

Common Mistakes:

• Thinking pop removes first element
• Confusing order of popped elements
• Not updating stack after pop

4. Identify the error in the following code that implements a stack using a Python list:

stack = []
stack.push(1)
stack.push(2)
print(stack.pop())

medium

A. Using push() method which does not exist for Python lists

B. Using pop() method incorrectly

C. Stack should be initialized as a tuple, not list

D. Missing import statement for stack

Solution

1. Step 1: Check methods used on list

   Python lists do not have a push() method; append() is used to add elements.

2. Step 2: Verify pop() usage

   pop() is valid for lists and correctly used here.

3. Final Answer:

   Using push() method which does not exist for Python lists -> Option A

4. Quick Check:

   Python list push() does not exist [OK]

Hint: Use append(), not push(), to add in Python list [OK]

Common Mistakes:

• Assuming push() is valid for Python lists
• Thinking pop() needs arguments
• Confusing list with stack module

5. Given a stack implemented as a Python list, which sequence of operations will reverse the order of elements in the stack?
Assume initial stack is [1, 2, 3] where 3 is the top.
Choose the correct sequence:

hard

A. Append elements to the stack again without popping

B. Use pop() repeatedly and append to the same stack without extra storage

C. Pop all elements into a new stack

D. Sort the stack list in ascending order

Solution

1. Step 1: Understand reversing stack by popping

   Pop elements from original stack and push them into a new stack reverses order.

2. Step 2: Confirm other options

   Appending without popping or sorting does not reverse stack order correctly.

3. Final Answer:

   Pop all elements into a new stack -> Option C

4. Quick Check:

   Two stacks pop/push reverses order [OK]

Hint: Use two stacks to reverse order [OK]

Common Mistakes:

• Trying to reverse by sorting
• Appending without popping
• Using one stack without extra storage