Points That Intersect With Cars

Points That Intersect With Cars - Problem

You are given a 0-indexed 2D integer array nums representing the coordinates of cars parking on a number line. For any index i, nums[i] = [start_i, end_i] where start_i is the starting point of the i^th car and end_i is the ending point of the i^th car.

Return the number of integer points on the line that are covered with any part of a car.

Input & Output

Example 1 — Basic Overlapping Cars

$ Input: nums = [[3,6],[1,5],[4,7]]

› Output: 7

💡 Note: Cars cover points: [3,6] covers 3,4,5,6; [1,5] covers 1,2,3,4,5; [4,7] covers 4,5,6,7. Combined unique points: 1,2,3,4,5,6,7 = 7 total points.

Example 2 — Non-overlapping Cars

$ Input: nums = [[1,3],[5,8]]

› Output: 7

💡 Note: Car [1,3] covers points 1,2,3 (3 points). Car [5,8] covers points 5,6,7,8 (4 points). No overlap, so total is 3 + 4 = 7 points.

Example 3 — Single Car

$ Input: nums = [[2,5]]

› Output: 4

💡 Note: Only one car covering points 2,3,4,5, which gives us 4 integer points total.

Constraints

1 ≤ nums.length ≤ 100
nums[i].length == 2
1 ≤ start_i ≤ end_i ≤ 100

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is that each car covers all integer points from start to end inclusive, and we need to count unique covered points. The hash set approach is most intuitive - collect all covered points and return set size. For optimization, merge intervals eliminates redundant counting. Time: O(n×k) for hash set, O(n log n) for merge intervals, Space: O(p) where p is unique points covered.

Common Approaches

✓ Brute Force - Check All Points

⏱️ Time: O(n × r) Space: O(1)

First find the overall range by getting minimum start and maximum end across all cars. Then for each integer point in this range, check if it's covered by any car interval.

Hash Set - Track Unique Points

⏱️ Time: O(n × k) Space: O(p)

For each car interval, add all integer points from start to end to a hash set. Since sets only store unique values, duplicate points are automatically handled.

Merge Intervals Approach

⏱️ Time: O(n log n) Space: O(1)

Sort the car intervals by start time, merge overlapping intervals to avoid double counting, then sum up the lengths of all merged intervals.

Brute Force - Check All Points — Algorithm Steps

Find the minimum start and maximum end coordinates
For each integer point in [min, max], check all cars
Count points that are covered by at least one car

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Range

Determine min start and max end

Check Points

For each point, check all cars

Count Coverage

Count points covered by at least one car

Code -

solution.c — C

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

int solution(int nums[][2], int numCars) {
    if (numCars == 0) return 0;
    
    // Find the overall range
    int minStart = INT_MAX;
    int maxEnd = INT_MIN;
    for (int i = 0; i < numCars; i++) {
        if (nums[i][0] < minStart) minStart = nums[i][0];
        if (nums[i][1] > maxEnd) maxEnd = nums[i][1];
    }
    
    int count = 0;
    // Check each point in the range
    for (int point = minStart; point <= maxEnd; point++) {
        // Check if this point is covered by any car
        for (int i = 0; i < numCars; i++) {
            if (nums[i][0] <= point && point <= nums[i][1]) {
                count++;
                break;
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [[a,b],[c,d],...] format
    int nums[1000][2];
    int numCars = 0;
    
    char* ptr = line + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            nums[numCars][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++; // Skip comma
            nums[numCars][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            ptr++; // Skip ]
            numCars++;
        }
        ptr++;
    }
    
    printf("%d\n", solution(nums, numCars));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × r)

Where n is number of cars and r is the range (max-min). For each of r points, we check n cars

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track min, max, and count

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

384 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 - Check All Points — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler