Maximum Linear Stock Score - Practice Coding Problems

Maximum Linear Stock Score - Problem

Maximum Linear Stock Score

You're a stock analyst looking for linear patterns in stock prices over time. Given stock prices for consecutive days, your goal is to find the maximum sum of prices from a subsequence that follows a perfectly linear trend.

What makes a selection "linear"?
A selection of days is linear if the price changes at exactly the same rate as time passes. Mathematically, for any three consecutive selected days i, j, k: (price[j] - price[i]) / (j - i) = (price[k] - j) / (k - j)

Your Task: Find the subsequence of days with maximum total price sum that maintains this linear relationship.

Input: Array prices where prices[i] is the stock price on day i+1
Output: Maximum possible sum of prices from any linear subsequence

Input & Output

example_1.py — Basic Linear Sequence

$ Input: prices = [1, 3, 5, 7, 9]

› Output: 25

💡 Note: The entire array forms a perfect linear sequence with slope 2. All prices sum to 1+3+5+7+9 = 25.

example_2.py — Multiple Linear Subsequences

$ Input: prices = [1, 5, 3, 7, 9]

› Output: 16

💡 Note: Best linear subsequence is [1, 5, 9] with slope 4. Sum = 1+5+9 = 15. Or [3, 7] with sum 10. Actually [5, 7, 9] gives slope 2 and sum 21... Wait, let me recalculate: [5,7,9] has indices [1,3,4], slopes are (7-5)/(3-1)=1 and (9-7)/(4-3)=2, not linear. [1,5,9] has indices [0,1,4], slopes (5-1)/(1-0)=4 and (9-5)/(4-1)=4/3, not linear either. The maximum is taking the best 2-element sequence or single element.

example_3.py — Single Element Edge Case

$ Input: prices = [42]

› Output: 42

💡 Note: With only one element, the maximum score is that single element value.

Constraints

1 ≤ prices.length ≤ 1000
1 ≤ prices[i] ≤ 10⁵
All prices are positive integers
Array is 0-indexed but problem description uses 1-indexed terminology

Visualization

Tap to expand

Understanding the Visualization

Identify Slopes

For each pair of days, calculate the rate of price change (slope)

Group by Pattern

Group sequences that maintain the same rate of change

Build Incrementally

Extend existing patterns or start new ones at each position

Track Maximum

Keep track of the highest total value among all valid patterns

Key Takeaway

🎯 Key Insight: Every pair of points defines exactly one possible linear pattern. Use dynamic programming to efficiently build and compare all possible patterns while tracking the maximum sum.

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses dynamic programming with hash tables to track the maximum sum of linear sequences ending at each position. The key insight is that for any two points, there's exactly one slope they can belong to, so we can group sequences by their slope patterns and build them incrementally in O(n²) time.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table (Dynamic Programming)	O(n²)	O(n²)	First pass: build DP table for all pairs. Second pass: extend sequences
Brute Force (Try All Subsequences)	O(2^n × n)	O(n)	Check every possible subsequence to see if it's linear, keep track of maximum sum
One-Pass Hash Table (Optimal DP)	O(n²)	O(n²)	Single pass dynamic programming building sequences incrementally

Two-Pass Hash Table (Dynamic Programming) — Algorithm Steps

First pass: For each pair of points, calculate slope and store in DP table
Initialize DP[i][slope] = sum of prices for best sequence ending at i with given slope
Second pass: For each position, try to extend existing sequences
Return maximum value from all DP entries

Visualization

Tap to expand

Step-by-Step Walkthrough

Pass 1: Initialize Pairs

For every pair of points, calculate slope and store sum in DP table

Pass 2: Extend Sequences

Try to extend existing sequences by adding compatible points

Track Maximum

Keep track of maximum sum across all DP entries

Code -

solution.c — C

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

#define MAX_SLOPES 1000

typedef struct {
    double slope;
    int maxSum;
} SlopeEntry;

typedef struct {
    SlopeEntry entries[MAX_SLOPES];
    int count;
} SlopeMap;

int findSlope(SlopeMap* map, double slope) {
    for (int i = 0; i < map->count; i++) {
        if (abs(map->entries[i].slope - slope) < 1e-9) {
            return i;
        }
    }
    return -1;
}

void updateSlope(SlopeMap* map, double slope, int value) {
    int idx = findSlope(map, slope);
    if (idx >= 0) {
        if (value > map->entries[idx].maxSum) {
            map->entries[idx].maxSum = value;
        }
    } else {
        map->entries[map->count].slope = slope;
        map->entries[map->count].maxSum = value;
        map->count++;
    }
}

int getSlope(SlopeMap* map, double slope) {
    int idx = findSlope(map, slope);
    return idx >= 0 ? map->entries[idx].maxSum : 0;
}

int maxLinearStockScore(int* prices, int n) {
    if (n <= 1) {
        int sum = 0;
        for (int i = 0; i < n; i++) sum += prices[i];
        return sum;
    }
    
    SlopeMap* dp = (SlopeMap*)calloc(n, sizeof(SlopeMap));
    int maxScore = prices[0];
    for (int i = 1; i < n; i++) {
        if (prices[i] > maxScore) maxScore = prices[i];
    }
    
    // First pass: initialize pairs
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            double slope = (double)(prices[j] - prices[i]) / (j - i);
            int currentSum = prices[i] + prices[j];
            
            updateSlope(&dp[j], slope, currentSum);
            if (currentSum > maxScore) {
                maxScore = currentSum;
            }
        }
    }
    
    // Second pass: extend sequences
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            double slope = (double)(prices[j] - prices[i]) / (j - i);
            int existing = getSlope(&dp[i], slope);
            
            if (existing > 0) {
                int newSum = existing + prices[j];
                updateSlope(&dp[j], slope, newSum);
                if (getSlope(&dp[j], slope) > maxScore) {
                    maxScore = getSlope(&dp[j], slope);
                }
            }
        }
    }
    
    free(dp);
    return maxScore;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int prices[20];
    int n = 0;
    char* token = strtok(input, "[],");
    while (token != NULL && n < 20) {
        prices[n++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%d\n", maxLinearStockScore(prices, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops to consider all pairs, each operation is O(1) with hash table

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table stores up to O(n²) different slope-position combinations

⚠ Quadratic Space

28.5K Views

Medium-High Frequency

~25 min Avg. Time

856 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

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Hash Table (Dynamic Programming) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler