Car Fleet - Practice Coding Problems

Car Fleet - Problem

Imagine cars racing on a highway toward a finish line! 🏁

There are n cars positioned at different miles from the start (mile 0), all heading toward a target destination. Each car has its own starting position[i] and travels at a constant speed[i] miles per hour.

Here's the twist: Cars cannot overtake each other! If a faster car catches up to a slower one, it must slow down and form a car fleet - traveling together at the speed of the slowest car in the group.

Your mission: Determine how many separate car fleets will arrive at the destination. A fleet can be a single car or multiple cars traveling together.

Key rules:

Cars maintain their lanes (no passing)
When cars meet, they form a fleet at the slower speed
Even if cars meet exactly at the target, they're considered one fleet

Input & Output

example_1.py — Basic Fleet Formation

$ Input: target = 12 position = [10,8,0,5,3] speed = [2,4,1,1,3]

› Output: 3

💡 Note: Car at position 10 (speed 2): time = (12-10)/2 = 1. Car at position 8 (speed 4): time = (12-8)/4 = 1. These form one fleet. Car at position 5 (speed 1): time = (12-5)/1 = 7. Car at position 3 (speed 3): time = (12-3)/3 = 3. Car at position 0 (speed 1): time = (12-0)/1 = 12. Cars at positions 5,3,0 each form separate fleets since faster cars behind cannot catch up.

example_2.py — Single Fleet

$ Input: target = 10 position = [3] speed = [3]

› Output: 1

💡 Note: Only one car exists, so it forms exactly one fleet by itself.

example_3.py — No Fleet Formation

$ Input: target = 100 position = [0,2,4] speed = [4,2,1]

› Output: 1

💡 Note: Car at 0 (speed 4): time = 100/4 = 25. Car at 2 (speed 2): time = 98/2 = 49. Car at 4 (speed 1): time = 96/1 = 96. The fastest car catches up to all others, forming one large fleet.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Cars start at different positions with different speeds, all heading to the same target

Calculate Arrival Times

Each car has a predicted arrival time based on distance and speed

Process from Front

Starting from cars closest to target, check if cars behind can catch up

Fleet Formation

Cars that arrive at same time or later form fleets with slower cars ahead

Key Takeaway

🎯 Key Insight: Sort cars by position and process from closest to target. Cars that take longer to arrive than previous fleets cannot be caught up to, forming new fleets!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting cars by position, O(n) for stack operations

⚡ Linearithmic

Space Complexity

O(n)

O(n) for storing sorted cars and stack of fleet times

⚡ Linearithmic Space

Constraints

n == position.length == speed.length
1 ≤ n ≤ 10⁵
0 < target ≤ 10⁶
0 ≤ position[i] < target
All values of position are unique
0 < speed[i] ≤ 10⁶

Asked in

A Amazon 45 G Google 38 ⊞ Microsoft 28 f Meta 22

The optimal approach uses sorting and stack-based thinking. Sort cars by position (closest to target first), then process each car by calculating its arrival time. If a car takes longer to reach the target than the previous fleet, it forms a new fleet since faster cars behind cannot catch up. This gives us O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Stack (Optimal)	O(n log n)	O(n)	Sort cars by position, then use stack to track fleets from closest to target
Brute Force (Check All Pairs)	O(n²)	O(n)	For each car, check if it catches up to every other car before reaching target

Sorting + Stack (Optimal) — Algorithm Steps

Sort cars by position (closest to target first)
Calculate time to reach target for each car
Use a stack to track fleet arrival times
For each car, if it arrives faster than the previous fleet, it forms a new fleet

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Cars

Sort cars by position, closest to target first

Calculate Times

For each car, calculate time to reach target

Stack Processing

If car takes longer than previous, it forms new fleet

Count Fleets

Each time we add to stack represents a new fleet

Code -

solution.c — C

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

typedef struct {
    int pos, speed;
} Car;

int compareCars(const void* a, const void* b) {
    Car* carA = (Car*)a;
    Car* carB = (Car*)b;
    return carB->pos - carA->pos; // descending order
}

int carFleet(int target, int* position, int* speed, int n) {
    // Edge case: 0 or 1 car
    if (n <= 1) {
        return n;
    }
    
    // Create pairs of (position, speed) and sort by position (descending)
    Car* cars = (Car*)malloc(n * sizeof(Car));
    for (int i = 0; i < n; i++) {
        cars[i].pos = position[i];
        cars[i].speed = speed[i];
    }
    qsort(cars, n, sizeof(Car), compareCars);
    
    int fleets = 0;
    double prevTime = 0;
    
    // Process cars from closest to target to farthest
    for (int i = 0; i < n; i++) {
        // Calculate time to reach target
        double time = (double)(target - cars[i].pos) / cars[i].speed;
        
        // If this car takes longer than previous fleet,
        // it won't catch up and forms a new fleet
        if (time > prevTime) {
            fleets++;
            prevTime = time;
        }
    }
    
    free(cars);
    return fleets;
}

int main() {
    int target;
    scanf("%d", &target);
    
    // Read position array
    char line[1000];
    scanf(" %[^\n]", line);
    int position[100], speed[100], n = 0;
    
    char* token = strtok(line, " ");
    while (token) {
        position[n++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    // Read speed array
    scanf(" %[^\n]", line);
    token = strtok(line, " ");
    for (int i = 0; i < n; i++) {
        speed[i] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    printf("%d\n", carFleet(target, position, speed, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting cars by position, O(n) for stack operations

⚡ Linearithmic

Space Complexity

O(n)

O(n) for storing sorted cars and stack of fleet times

⚡ Linearithmic Space

Constraints

n == position.length == speed.length
1 ≤ n ≤ 10⁵
0 < target ≤ 10⁶
0 ≤ position[i] < target
All values of position are unique
0 < speed[i] ≤ 10⁶

42.0K Views

High Frequency

~25 min Avg. Time

1.9K 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

Sorting + Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler