Stock Span Problem Using Stack in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to push the current index onto the stack.

DSA Typescript

stack.[1](i);

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

Apop

Bshift

Cpush

Dpeek

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop instead of push removes elements instead of adding.

Using peek is not a method in JavaScript arrays.

Using shift removes the first element, not adds.

The push method adds the current index i to the top of the stack.

2fill in blank

medium

Complete the condition to pop from the stack while the current price is higher than the price at the top index of the stack.

DSA Typescript

while (stack.length > 0 && prices[i] [1] prices[stack[stack.length - 1]]) {
  stack.pop();
}

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

A>

B<

C==

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using less than operator reverses the logic.

Using equality operator does not remove smaller prices.

Using less than or equal includes equal prices incorrectly.

We pop from the stack while the current price is greater than the price at the top of the stack.

3fill in blank

hard

Fix the error in calculating the span when the stack is empty.

DSA Typescript

spans[i] = stack.length === 0 ? [1] : i - stack[stack.length - 1];

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

A0

Bi + 1

Ci

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 results in zero span incorrectly.

Using i misses counting the current day.

Using 1 undercounts span for days beyond the first.

If the stack is empty, the span is the entire length from day 0 to current day, which is i + 1.

4fill in blank

hard

Fill both blanks to complete the loop that calculates spans for all days.

DSA Typescript

for (let [1] = 0; [2] < prices.length; [2]++) {
  // loop body
}

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

Ai

Bj

Ck

Dindex

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names in initialization and condition causes errors.

Using uncommon variable names may confuse readers.

The loop variable is i, used consistently in initialization, condition, and increment.

5fill in blank

hard

Fill all three blanks to complete the function that returns the stock spans.

DSA Typescript

function calculateSpan(prices: number[]): number[] {
  const spans: number[] = new Array(prices.length).fill(0);
  const stack: number[] = [];
  for (let [1] = 0; [2] < prices.length; [2]++) {
    while (stack.length > 0 && prices[[3]] > prices[stack[stack.length - 1]]) {
      stack.pop();
    }
    spans[[2]] = stack.length === 0 ? [2] + 1 : [2] - stack[stack.length - 1];
    stack.push([2]);
  }
  return spans;
}

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

Ai

Dj

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names causes reference errors.

Using j inside the while condition when loop uses i causes bugs.

The loop variable i is used consistently for indexing in the loop, condition, and inside the while condition.

Practice

1. What does the Stock Span Problem calculate for each day in a list of stock prices?

easy

A. The average stock price over all days

B. The maximum stock price in the entire list

C. The number of consecutive days before the current day with a price less than or equal to the current day's price

D. The difference between the highest and lowest stock price

Solution

1. Step 1: Understand the problem definition

   The Stock Span Problem finds how many days in a row before today had prices less than or equal to today's price.

2. Step 2: Identify what is calculated for each day

   For each day, it counts consecutive previous days with prices not higher than current day.

3. Final Answer:

   The number of consecutive days before the current day with a price less than or equal to the current day's price -> Option C

4. Quick Check:

   Stock span = consecutive days with price ≤ current day price [OK]

Hint: Span counts days with price ≤ today's price backward [OK]

Common Mistakes:

• Thinking it finds max price overall
• Confusing span with price difference
• Calculating average price instead

2. Which TypeScript data structure is best suited to efficiently solve the Stock Span Problem?

easy

A. Stack

B. Array

C. Queue

D. Set

Solution

1. Step 1: Recall the problem needs to track previous prices efficiently

   We need to quickly find previous days with prices less or equal to current day.

2. Step 2: Identify the data structure that supports last-in-first-out access

   A stack allows pushing and popping previous prices to compare efficiently.

3. Final Answer:

   Stack -> Option A

4. Quick Check:

   Stack is used for last-in-first-out access [OK]

Hint: Use stack to track previous prices for quick comparison [OK]

Common Mistakes:

• Using queue which is FIFO, not suitable
• Using set which does not maintain order
• Using array without stack logic

3. What is the output of the stock span array for prices [100, 80, 60, 70, 60, 75, 85]?

medium

A. [1, 1, 1, 2, 1, 3, 4]

B. [1, 1, 1, 1, 1, 1, 1]

C. [1, 2, 3, 4, 5, 6, 7]

D. [1, 1, 1, 2, 1, 4, 6]

Solution

1. Step 1: Calculate span for each day

   Day 0: 100 -> span 1 (no previous)
   Day 1: 80 ≤ 100 -> span 1
   Day 2: 60 ≤ 80 -> span 1
   Day 3: 70 > 60 -> span 2 (days 2 and 3)
   Day 4: 60 ≤ 70 -> span 1
   Day 5: 75 > 60, 70 -> span 4 (days 2,3,4,5)
   Day 6: 85 > 75, 70, 80 -> span 6 (days 1 to 6)

2. Step 2: Confirm final span array

   The spans are [1, 1, 1, 2, 1, 4, 6].

3. Final Answer:

   [1, 1, 1, 2, 1, 4, 6] -> Option D

4. Quick Check:

   Span array matches calculated values [OK]

Hint: Count consecutive previous days with price ≤ current day [OK]

Common Mistakes:

• Counting all previous days regardless of price
• Confusing span with cumulative sum
• Miscounting days when price increases

4. Identify the error in this TypeScript snippet for Stock Span calculation:

function calculateSpan(prices: number[]): number[] {
  const stack: number[] = [];
  const span: number[] = [];
  for (let i = 0; i < prices.length; i++) {
    while (stack.length > 0 && prices[stack[stack.length - 1]] <= prices[i]) {
      stack.pop();
    }
    span[i] = stack.length === 0 ? i + 1 : i - stack[stack.length - 1];
    stack.push(i);
  }
  return span;
}

medium

A. The stack should store prices, not indices

B. The comparison operator should be <= instead of < in while condition

C. The span array is not initialized with zeros

D. The loop should start from i = 1, not 0

Solution

1. Step 1: Analyze the while loop condition

   The condition uses < to pop smaller prices, but equal prices should also be popped to count span correctly.

2. Step 2: Correct the comparison operator

   Change < to <= so that prices equal to current price are popped, ensuring correct span calculation.

3. Final Answer:

   The comparison operator should be <= instead of < in while condition -> Option B

4. Quick Check:

   Use <= to include equal prices in span [OK]

Hint: Use <= in while to pop equal or smaller prices [OK]

Common Mistakes:

• Using < misses equal prices in span
• Storing prices instead of indices in stack
• Starting loop from 1 misses first day

5. Given stock prices [10, 4, 5, 90, 120, 80], how would you modify the standard Stock Span algorithm to also return the day index of the last higher price before each day? What is the output for the last higher price indices array?

hard

A. [-1, 0, 0, -1, -1, 4]

B. [-1, 0, 1, -1, -1, 4]

C. [-1, 0, 0, 2, 3, 3]

D. [-1, -1, 1, 0, 1, 2]

Solution

1. Step 1: Modify algorithm to track last higher price index

   Along with span, store index from stack top before popping. If stack empty, store -1.

2. Step 2: Calculate last higher price indices for each day

   Day 0 (10): no previous higher -> -1
   Day 1 (4): previous higher 10 at index 0 -> 0
   Day 2 (5): previous higher 10 at index 0 -> 0
   Day 3 (90): no previous higher -> -1
   Day 4 (120): no previous higher -> -1
   Day 5 (80): previous higher 120 at index 4 -> 4

3. Final Answer:

   [-1, 0, 0, -1, -1, 4] -> Option A

4. Quick Check:

   Last higher price indices match calculated values [OK]

Hint: Store stack top index before popping for last higher price [OK]

Common Mistakes:

• Returning span instead of last higher price indices
• Using price values instead of indices
• Assigning wrong indices when stack is empty