Minimum Lines to Represent a Line Chart - Practice Coding Problems

Minimum Lines to Represent a Line Chart - Problem

Array Math Geometry Sorting Number Theory Medium

You are given a 2D integer array stockPrices where stockPrices[i] = [day_i, price_i] represents the price of a stock on day day_i.

To create a line chart, you plot these points on an XY plane where:

X-axis represents the day
Y-axis represents the price

You then connect adjacent points (sorted by day) with straight line segments. Your task is to find the minimum number of lines needed to represent this line chart.

Two consecutive line segments can be merged into one if they have the same slope.

Example: If you have points representing days [1,2,3,4] with prices [1,2,3,2], you would need 2 lines: one from day 1-3 (slope = 1) and another from day 3-4 (slope = -1).

Input & Output

example_1.py — Basic Case

$ Input: stockPrices = [[1,7],[2,6],[3,5],[4,4],[5,4],[6,3],[7,2],[8,1]]

› Output: 3

💡 Note: The chart needs 3 lines: from day 1-4 (slope=-1), day 4-5 (slope=0), and day 5-8 (slope=-1). The slope changes at day 4 and day 5, creating 3 distinct line segments.

example_2.py — Single Line

$ Input: stockPrices = [[3,4],[1,2],[7,8],[2,3]]

› Output: 1

💡 Note: After sorting by day: [(1,2), (2,3), (3,4), (7,8)]. All consecutive segments have the same slope of 1, so only 1 line is needed.

example_3.py — Minimum Case

$ Input: stockPrices = [[1,1],[500,500000]]

› Output: 1

💡 Note: Only two points, so exactly 1 line is needed to connect them.

Constraints

1 ≤ stockPrices.length ≤ 10⁵
stockPrices[i].length == 2
1 ≤ day_i, price_i ≤ 10⁹
All day_i are distinct

Visualization

Tap to expand

Understanding the Visualization

Sort by Time

Arrange all stock price points chronologically by day

Track Slope Changes

Compare slopes between consecutive point pairs using cross multiplication

Count Line Segments

Each slope change indicates the need for a new line segment

Key Takeaway

🎯 Key Insight: Use cross multiplication (dy1×dx2 ≟ dy2×dx1) instead of division to compare slopes and avoid floating point precision errors

Asked in

⊞ Microsoft 35 G Google 28 a Amazon 22 f Meta 18

The optimal solution uses slope comparison with cross multiplication to avoid floating point precision issues. Sort points by day, then compare consecutive line segments using cross products. Time complexity: O(n log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Calculate All Slopes)	O(n log n)	O(1)	Calculate slope between every consecutive pair and count direction changes

Brute Force (Calculate All Slopes) — Algorithm Steps

Sort the stock prices by day
Calculate slope between each consecutive pair of points
Compare consecutive slopes to detect changes
Count the number of slope changes plus 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Points

Sort all points by day (x-coordinate)

Calculate Slopes

Calculate slope between each consecutive pair

Compare Slopes

Count slope changes to determine number of lines

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    int *arr1 = *(int**)a;
    int *arr2 = *(int**)b;
    return arr1[0] - arr2[0];
}

int minimumLines(int** stockPrices, int stockPricesSize, int* stockPricesColSize) {
    if (stockPricesSize <= 1) return 0;
    
    // Sort by day
    qsort(stockPrices, stockPricesSize, sizeof(int*), compare);
    
    if (stockPricesSize == 2) return 1;
    
    int lines = 1;
    
    for (int i = 2; i < stockPricesSize; i++) {
        // Use cross multiplication
        long long dy1 = stockPrices[i-1][1] - stockPrices[i-2][1];
        long long dx1 = stockPrices[i-1][0] - stockPrices[i-2][0];
        long long dy2 = stockPrices[i][1] - stockPrices[i-1][1];
        long long dx2 = stockPrices[i][0] - stockPrices[i-1][0];
        
        if (dy1 * dx2 != dy2 * dx1) {
            lines++;
        }
    }
    
    return lines;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting plus O(n) for slope calculations

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for slope comparisons

✓ Linear Space

23.9K Views

Medium Frequency

~25 min Avg. Time

756 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

Brute Force (Calculate All Slopes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler