Min Stack Design in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to push an element onto the stack.

DSA C#

public void Push(int x) {
    stack.[1](x);
}

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

APush

BAdd

CInsert

DAppend

Attempts:

3 left

💡 Hint

Common Mistakes

Using Add or Append which are not stack methods.

Using Insert which is for lists, not stacks.

The correct method to add an element to a stack in C# is Push.

2fill in blank

medium

Complete the code to get the minimum element from the min stack.

DSA C#

public int GetMin() {
    return minStack.[1]();
}

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

APeek

BPop

CTop

DMin

Attempts:

3 left

💡 Hint

Common Mistakes

Using Pop which removes the element.

Using Top which is not a C# Stack method.

Peek returns the top element without removing it, which is the current minimum.

3fill in blank

hard

Fix the error in the pop method to correctly update the min stack.

DSA C#

public void Pop() {
    if(stack.Peek() == minStack.[1]()) {
        minStack.Pop();
    }
    stack.Pop();
}

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

ATop

BPop

CPeek

DMin

Attempts:

3 left

💡 Hint

Common Mistakes

Using Pop which removes the element and causes errors.

Using Top which is not a valid Stack method in C#.

We compare the top elements using Peek, not Pop, to avoid removing them prematurely.

4fill in blank

hard

Fill both blanks to correctly push elements and update the min stack.

DSA C#

public void Push(int x) {
    stack.Push(x);
    if(minStack.Count == 0 || x [1] minStack.[2]()) {
        minStack.Push(x);
    }
}

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

A<=

B>=

CPeek

DPop

Attempts:

3 left

💡 Hint

Common Mistakes

Using >=

Using Pop instead of Peek.

We push x to minStack if x is less than or equal to the current min (Peek).

5fill in blank

hard

Fill all three blanks to implement the MinStack class constructor and initialize stacks.

DSA C#

public MinStack() {
    stack = new Stack<int>();
    minStack = new [1]<int>();
    [2] = 0;
    [3] = 0;
}

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

AStack

Bint

Ccount

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Using int instead of Stack for minStack.

Using size instead of count or vice versa inconsistently.

We initialize minStack as a Stack and set count and size to 0.

Practice

1. What is the main purpose of a Min Stack data structure?

easy

A. To retrieve the minimum element in constant time

B. To sort elements in ascending order

C. To store elements in a queue fashion

D. To reverse the order of elements

Solution

1. Step 1: Understand the Min Stack concept

   A Min Stack is designed to keep track of the minimum element efficiently.

2. Step 2: Identify the main feature

   It allows retrieving the minimum element in constant time, unlike a normal stack.

3. Final Answer:

   To retrieve the minimum element in constant time -> Option A

4. Quick Check:

   Min Stack = fast minimum retrieval [OK]

Hint: Min Stack always tracks minimum for O(1) retrieval [OK]

Common Mistakes:

• Confusing Min Stack with sorting
• Thinking it behaves like a queue
• Assuming it reverses elements

2. Which of the following is the correct C# method signature to push an integer val onto a Min Stack?

easy

A. public void Push(string val)

B. public int Push(int val)

C. void Push()

D. public void Push(int val)

Solution

1. Step 1: Check method return type and parameters

   Push method should not return a value, so return type is void, and it takes an int parameter.

2. Step 2: Match the correct signature

   public void Push(int val) matches: public void Push(int val)

3. Final Answer:

   public void Push(int val) -> Option D

4. Quick Check:

   Push method = void + int parameter [OK]

Hint: Push returns void and takes int parameter [OK]

Common Mistakes:

• Using wrong return type like int
• Missing parameter in method
• Using wrong parameter type like string

3. Given the following operations on a Min Stack:

MinStack minStack = new MinStack();
minStack.Push(3);
minStack.Push(5);
minStack.Push(2);
minStack.Push(1);
minStack.Pop();
int min = minStack.GetMin();
Console.WriteLine(min);

What will be printed?

medium

A. 1

B. 2

C. 3

D. 5

Solution

1. Step 1: Trace the stack after each operation

   Push 3 -> stack: [3], min=3 Push 5 -> stack: [3,5], min=3 Push 2 -> stack: [3,5,2], min=2 Push 1 -> stack: [3,5,2,1], min=1 Pop -> removes 1, stack: [3,5,2], min=2

2. Step 2: GetMin after pop

   Minimum is now 2 after popping 1.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Min after pop = 2 [OK]

Hint: Pop removes min, next min updates correctly [OK]

Common Mistakes:

• Assuming min stays 1 after pop
• Confusing stack top with min
• Ignoring pop effect on min

4. Consider this buggy Min Stack pop method:

public void Pop() {
    if(stack.Count > 0) {
        stack.Pop();
        minStack.Pop();
    }}

What is the main issue with this implementation?

medium

A. It does not check if stack is empty before popping

B. It pushes elements instead of popping

C. It pops from minStack even when the popped element is not the minimum

D. It returns a value but method is void

Solution

1. Step 1: Understand the role of minStack

   minStack should only pop when the popped element equals the current minimum.

2. Step 2: Identify the bug

   This code pops minStack every time, even if the popped element is not minimum, causing incorrect min tracking.

3. Final Answer:

   It pops from minStack even when the popped element is not the minimum -> Option C

4. Quick Check:

   Pop minStack only if popped element == min [OK]

Hint: Pop minStack only if popped element equals current min [OK]

Common Mistakes:

• Always popping minStack blindly
• Not checking stack emptiness (not in this code)
• Confusing push and pop operations

5. You want to design a Min Stack that supports Push, Pop, Top, and GetMin all in O(1) time. Which approach is best?

hard

A. Use two stacks: one for all elements, one for current minimums

B. Use a single stack and sort it after each push

C. Use a queue to track minimum elements

D. Store all elements in a list and scan for min on GetMin

Solution

1. Step 1: Analyze time complexity requirements

   All operations must be O(1), so sorting or scanning is too slow.

2. Step 2: Identify suitable data structure

   Using two stacks, one for elements and one for minimums, allows constant time min retrieval.

3. Final Answer:

   Use two stacks: one for all elements, one for current minimums -> Option A

4. Quick Check:

   Two stacks = O(1) min tracking [OK]

Hint: Two stacks track elements and minimums efficiently [OK]

Common Mistakes:

• Sorting stack after each push (slow)
• Using queue instead of stack
• Scanning list for min on each GetMin