Number of Smooth Descent Periods of a Stock

Number of Smooth Descent Periods of a Stock - Problem

Array Math Two Pointers Dynamic Programming Sliding Window Medium

Stock Market Analysis Challenge!

You're a financial analyst tracking stock price movements. Given an array prices where prices[i] represents the stock price on day i, you need to identify all smooth descent periods.

A smooth descent period is a sequence of consecutive days where:
• Each day's price is exactly 1 unit lower than the previous day
• The first day of any period doesn't need to follow this rule
• Even a single day counts as a period of length 1

Goal: Count the total number of smooth descent periods in the stock's price history.

Example: For prices [3, 2, 1, 4], we have periods: [3], [3,2], [3,2,1], [2], [2,1], [1], [4] = 7 periods total.

Input & Output

example_1.py — Basic Descent

$ Input: prices = [3, 2, 1, 4]

› Output: 7

💡 Note: Smooth descent periods: [3] (1), [3,2] (1), [3,2,1] (1), [2] (1), [2,1] (1), [1] (1), [4] (1). Total = 7 periods.

example_2.py — No Descent

$ Input: prices = [1, 2, 3, 4]

› Output: 4

💡 Note: No smooth descents possible. Each single day forms its own period: [1], [2], [3], [4]. Total = 4 periods.

example_3.py — Single Element

$ Input: prices = [4]

› Output: 1

💡 Note: Only one element, which forms exactly one smooth descent period of length 1.

Visualization

Tap to expand

Understanding the Visualization

Track Current Run

Keep track of how long our current smooth descent is

Extend or Reset

If the next price is exactly 1 less, extend the run; otherwise start fresh

Count All Routes

Each time we extend, we create one new ski route ending at this point

Key Takeaway

🎯 Key Insight: Each time we extend a smooth descent by one position, we create exactly one new descent period while preserving all existing ones. This allows us to count efficiently in O(n) time!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track state

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 10⁵
1 ≤ prices[i] ≤ 10⁹
Each price is a positive integer
Array contains at least one element

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 B Bloomberg 25

The optimal solution uses a single pass through the array, tracking the current descent period length. When we can extend the period (price[i] = price[i-1] - 1), we increment the length and add it to our count. This works because extending a period by 1 creates exactly 1 new subarray. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Sliding Window (Optimal)	O(n)	O(1)	Track the length of current descent period and calculate periods efficiently
Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray to see if it forms a smooth descent period

One-Pass Sliding Window (Optimal) — Algorithm Steps

Initialize count = 0 and current_length = 1 (every single element is a period)
For each element from index 1, check if it continues the descent (price[i] = price[i-1] - 1)
If yes, increment current_length and add it to count
If no, reset current_length = 1 and add it to count
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

count = 1, current_length = 1

Check descent

If price[i] = price[i-1] - 1, extend period

Add to count

Add current_length to total count

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

long long getDescentPeriods(int* prices, int n) {
    if (n == 0) return 0;
    
    long long count = 1; // First element forms one period
    int currentLength = 1;
    
    for (int i = 1; i < n; i++) {
        if (prices[i] == prices[i - 1] - 1) {
            // Extend current descent period
            currentLength++;
        } else {
            // Start new period
            currentLength = 1;
        }
        
        count += currentLength;
    }
    
    return count;
}

int main() {
    int prices[100000];
    int n = 0;
    int price;
    while (scanf("%d", &price) == 1) {
        prices[n++] = price;
    }
    printf("%lld\n", getDescentPeriods(prices, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track state

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 10⁵
1 ≤ prices[i] ≤ 10⁹
Each price is a positive integer
Array contains at least one element

42.0K Views

Medium Frequency

~15 min Avg. Time

1.6K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler