The Stock Span Problem

Try it on GfG Practice

The stock span problem is a financial problem where we have a series of daily price quotes for a stock denoted by an array arr[] and the task is to calculate the span of the stock's price for all days. 

The span of the stock's price on i^th day represents the maximum number of consecutive days leading up to i^th day (including the current day) where the stock's price was less than or equal to its price on day i.

Examples:

Input: arr[] = [100, 80, 60, 70, 60, 75, 85]
Output: [1, 1, 1, 2, 1, 4, 6]
Explanation: Traversing the given input span 100 is greater than equal to 100 and there are no more elements behind it so the span is 1, 80 is greater than equal to 80 and smaller than 100 so the span is 1, 60 is greater than equal to 60 and smaller than 80 so the span is 1, 70 is greater than equal to 60,70 and smaller than 80 so the span is 2 and so on. Hence the output will be 1 1 1 2 1 4 6.

Input: arr[] = [10, 4, 5, 90, 120, 80]
Output: [1, 1, 2, 4, 5, 1]
Explanation: Traversing the given input span 10 is greater than equal to 10 and there are no more elements behind it so the span is 1, 4 is greater than equal to 4 and smaller than 10 so the span is 1, 5 is greater than equal to 4,5 and smaller than 10 so the span is 2, and so on. Hence the output will be 1 1 2 4 5 1.

[Naive Approach] Using Nested Loop - O(n^2) Time and O(1) Space

The idea is to use nested loops, where the outer loop iterates through the array to process each stock price. For each day, the inner loop moves leftward in the array, comparing previous prices and increasing the span count until a higher price is found or the beginning of the array is reached.

// C++ program to calculate stock 
// span values
#include <iostream>
#include <vector>
using namespace std;

// Function to calculate stock span values
vector<int> calculateSpan(vector<int>& arr) {

    int n = arr.size(); 
    vector<int> span(n, 1);
    
    // Calculate span for each day
    for (int i = 1; i < n; i++) {
        
        // Traverse left while the next element
        // on the left is smaller than arr[i]
        for (int j = i - 1; (j >= 0)
                      && (arr[i] >= arr[j]); j--) {
            span[i]++;
        }
    }

    return span;
}


int main() {
  
    vector<int> arr = {10, 4, 5, 90, 120, 80};
    vector<int> span = calculateSpan(arr);
    for (int x : span) {
        cout << x << " ";
    }
    return 0;
}

// Java program to calculate stock span values
import java.util.*;

class GfG {

    // Method to calculate stock span values
    static ArrayList<Integer> calculateSpan(int[] arr) {

        int n = arr.length;
        ArrayList<Integer> span = new ArrayList<>();

        // Initialize span list with 1s
        for (int i = 0; i < n; i++) {
            span.add(1);
        }

        // Calculate span for each day
        for (int i = 1; i < n; i++) {

            // Traverse left while arr[i] >= arr[j]
            for (int j = i - 1; j >= 0 
                  && arr[i] >= arr[j]; j--) {
              
                span.set(i, span.get(i) + 1);
            }
        }

        return span;
    }

    public static void main(String[] args) {

        int[] arr = {10, 4, 5, 90, 120, 80};
      
        ArrayList<Integer> span = calculateSpan(arr);
        for (int x : span) {
            System.out.print(x + " ");
        }
    }
}

# Python program to calculate stock span values

# Function to calculate stock span values
def calculateSpan(arr):
    n = len(arr)
    span = [1] * n  

    # Calculate span for each day
    for i in range(1, n):
      
        # Traverse left while arr[i] >= arr[j]
        j = i - 1
        while j >= 0 and arr[i] >= arr[j]:
            span[i] += 1
            j -= 1

    return span

if __name__ == "__main__":
  
    arr = [10, 4, 5, 90, 120, 80]
    span = calculateSpan(arr)
    print(' '.join(map(str, span)))
    

// C# program to calculate stock span values
using System;
using System.Collections.Generic;

class GfG {

    // Method to calculate stock span values
   	static List<int> calculateSpan(int[] arr) {

        int n = arr.Length;
        List<int> span = new List<int>();

        // Initialize span list with 1s
        for (int i = 0; i < n; i++) {
            span.Add(1);
        }

        // Calculate span for each day
        for (int i = 1; i < n; i++) {

            // Traverse left while arr[i] >= arr[j]
            for (int j = i - 1; j >= 0 
                       && arr[i] >= arr[j]; j--) {
              
                span[i]++;
            }
        }

        return span;
    }
  
    static void Main() {

        int[] arr = { 10, 4, 5, 90, 120, 80 };

        List<int> span = calculateSpan(arr);

        foreach (int x in span) {
            Console.Write(x + " ");
        }
    }
}

// Javascript implementation to calculate
// stock span values

// Function to calculate stock span values
function calculateSpan(arr) {
    let n = arr.length;
    let span = new Array(n).fill(1); 

    // Calculate span for each day
    for (let i = 1; i < n; i++) {
    
        // Traverse left while arr[i] >= arr[j]
        let j = i - 1;
        while (j >= 0 && arr[i] >= arr[j]) {
            span[i]++;
            j--;
        }
    }

    return span;
}

// Driver Code
let arr = [10, 4, 5, 90, 120, 80];
let span = calculateSpan(arr);

console.log(span.join(" "));

1 1 2 4 5 1 

[Expected Approach] Using Stack - O(n) Time and O(n) Space

If we take a closer look at the problem, we can notice that we need to mainly find index of the previous greater element for every element. Let us understand in details.

We see that span[i] on the day i can be easily computed if we know the closest day preceding i, such that the price is greater than on that day than the price on the day i. If such a day exists, let’s call it greater(i), otherwise, we define greater(i) = -1
The span is now computed as span[i] = i - greater(i). See the following diagram

To implement this logic, we use a stack as an abstract data type to store the days i, greater(i), greater(greater(i)), and so on. The idea is to use a stack to find the span of stock prices. For each day, we remove indices from the stack while the current price is greater than or equal to the price at the top of the stack, as those day's prices cannot influence the span.

• If the stack becomes empty, it means all previous prices are smaller, and the span is the current day index plus one.
• Otherwise, the span is the difference between the current index and the top of the stack, which represents the last higher price's index.

// C++ program to calculate stock span 
// values using a stack
#include <iostream>
#include <vector>
#include <stack>
using namespace std;

// Function to calculate stock span values
vector<int> calculateSpan(vector<int>& arr) {

    int n = arr.size(); 
    vector<int> span(n);  
    stack<int> stk;  

    // Process each day's price
    for (int i = 0; i < n; i++) {
        
        // Remove elements from the stack while the current
        // price is greater than or equal to stack's top price
        while (!stk.empty() && arr[stk.top()] <= arr[i]) {
            stk.pop();
        }

        // If stack is empty, all elements to the left are smaller
        // Else, top of the stack is the last greater element's index
        if (stk.empty()) {
            span[i] = (i + 1);
        }
        else {
            span[i] = (i - stk.top());
        }

        // Push the current index to the stack
        stk.push(i);
    }

    return span;
}

int main() {
    vector<int> arr = {10, 4, 5, 90, 120, 80};
    vector<int> span = calculateSpan(arr);
     for (int x : span) {
        cout << x << " ";
    }
    return 0;
}

// Java program to calculate stock span 
// values using a stack
import java.util.*;

class GfG {

    // Function to calculate stock span values
    static ArrayList<Integer> calculateSpan(int[] arr) {

        int n = arr.length; 
        ArrayList<Integer> span = new ArrayList<>(
                              Collections.nCopies(n, 0));  
        Stack<Integer> stk = new Stack<>();  

        // Process each day's price
        for (int i = 0; i < n; i++) {

            // Remove elements from the stack while the current price 
            // is greater than or equal to stack's top price
            while (!stk.isEmpty() && arr[stk.peek()] <=
                                        arr[i]) {
                stk.pop();
            }

            // If stack is empty, all elements to the left are smaller
            // Else, top of the stack is the last greater element's index
            if (stk.isEmpty()) {
                span.set(i, (i + 1));
            } else {
                span.set(i, (i - stk.peek()));
            }

            // Push the current index to the stack
            stk.push(i);
        }

        return span;
    }
  
    public static void main(String[] args) {

        int[] arr = {10, 4, 5, 90, 120, 80};

        ArrayList<Integer> span = calculateSpan(arr);

        for (int x : span) {
            System.out.print(x + " ");
        }
    }
}

# Python program to calculate stock span
# values using a stack

# Function to calculate stock span values
def calculateSpan(arr):

    n = len(arr)
    span = [0] * n  
    stk = []

    # Process each day's price
    for i in range(n):

        # Remove elements from the stack while the current
        # price is greater than or equal to stack's top price
        while stk and arr[stk[-1]] <= arr[i]:
            stk.pop()

        # If stack is empty, all elements to the left are smaller
        # Else, top of the stack is the last greater element's index
        if not stk:
            span[i] = (i + 1)
        else:
            span[i] = (i - stk[-1])

        # Push the current index to the stack
        stk.append(i)

    return span


if __name__ == "__main__":

    arr = [10, 4, 5, 90, 120, 80]
    span = calculateSpan(arr)
    
    for x in span:
        print(x, end=" ")

// C# program to calculate stock span 
// values using a stack
using System;
using System.Collections.Generic;

class GfG {

    // Function to calculate stock span values
    static List<int> CalculateSpan(int[] arr) {

        int n = arr.Length; 
        List<int> span = new List<int>(new int[n]); 
        Stack<int> stk = new Stack<int>();

        // Process each day's price
        for (int i = 0; i < n; i++) {

            // Remove elements from the stack while the 
            // current price is greater than or equal to
            // stack's top price
            while (stk.Count > 0 && arr[stk.Peek()] 
                <= arr[i]) {
                stk.Pop();
            }

            // If stack is empty, all elements to the left are smaller
            // Else, top of the stack is the last greater element's index
            if (stk.Count == 0) {
                span[i] = (i + 1);
            } 
            else {
                span[i] = (i - stk.Peek());
            }

            // Push the current index to the stack
            stk.Push(i);
        }

        return span;
    }

  	static void Main(string[] args) {

        int[] arr = { 10, 4, 5, 90, 120, 80 };

        List<int> span = CalculateSpan(arr);

        foreach (int x in span) {
            Console.Write(x + " ");
        }
    }
}

// JavaScript program to calculate stock span
// values using a stack

// Function to calculate stock span values
function calculateSpan(arr) {

    let n = arr.length;
    let span = new Array(n);
    let stk = [];

    // Process each day's price
    for (let i = 0; i < n; i++) {

        // Remove elements from the stack while the current
        // price is greater than or equal to stack's top price
        while (stk.length > 0
               && arr[stk[stk.length - 1]] <= arr[i]) {

            stk.pop();
        }

        // If stack is empty, all elements to the left are smaller
        // Else, top of the stack is the last greater element's index
        if (stk.length === 0) {
            span[i] = (i + 1);
        }
        else {
            span[i] = (i - stk[stk.length - 1]);
        }

        // Push the current index to the stack
        stk.push(i);
    }

    return span;
}

// Driver Code
let arr = [ 10, 4, 5, 90, 120, 80 ];
let span = calculateSpan(arr);

console.log(span.join(" "));

1 1 2 4 5 1 

Time Complexity : O(n). It seems more than O(n) at first look. If we take a closer look, we can observe that every element of array is added and removed from stack at most once. So there are total 2n operations at most. Assuming that a stack operation takes O(1) time, we can say that the time complexity is O(n).

Auxiliary Space : O(n) in worst case when all elements are sorted in decreasing order.