Distance Between Bus Stops - Practice Coding Problems

Distance Between Bus Stops - Problem

Array Easy

Imagine you're planning your commute on a circular bus route that connects several stops in a perfect loop. The bus operates in both directions - you can go clockwise or counterclockwise to reach your destination!

You're given:

A circular bus route with n stops numbered from 0 to n-1
An array distance where distance[i] represents the distance between stop i and stop (i+1) % n
A start stop and a destination stop

Your goal is to find the shortest distance between the start and destination stops. Since it's a circular route, you can travel in either direction, so you need to calculate both paths and return the minimum distance.

Example: If you have stops [0,1,2,3] in a circle with distances [1,2,3,4], going from stop 0 to stop 2 could be done clockwise (1+2=3) or counterclockwise (4+3=7), so the answer would be 3.

Input & Output

example_1.py — Basic circular route

$ Input: distance = [1,2,3,4], start = 0, destination = 1

› Output: 1

💡 Note: Going clockwise from stop 0 to stop 1 takes distance[0] = 1. Going counterclockwise would be 2+3+4 = 9. So the minimum is 1.

example_2.py — Longer clockwise path

$ Input: distance = [1,2,3,4], start = 0, destination = 2

› Output: 3

💡 Note: Clockwise: distance[0] + distance[1] = 1 + 2 = 3. Counterclockwise: distance[3] + distance[2] = 4 + 3 = 7. Minimum is 3.

example_3.py — Equal distances

$ Input: distance = [1,2,3,4], start = 0, destination = 3

› Output: 4

💡 Note: Clockwise: 1 + 2 + 3 = 6. Counterclockwise: 4. The shorter path is counterclockwise with distance 4.

Constraints

1 ≤ n ≤ 10⁴
0 ≤ start, destination < n
0 ≤ distance[i] ≤ 10⁴
start != destination

Visualization

Tap to expand

Understanding the Visualization

Set Up the Circle

Visualize all bus stops arranged in a perfect circle with distances marked between adjacent stops

Calculate Clockwise

Sum up distances going clockwise from start to destination

Calculate Counterclockwise

Use total perimeter minus clockwise to get counterclockwise distance

Choose Optimal Path

Return the minimum distance between the two possible routes

Key Takeaway

🎯 Key Insight: On a circular route, there are exactly two paths between any two stops. Calculate one path by direct summation, then use the fact that both paths together equal the total perimeter to find the other path instantly!

Asked in

a Amazon 15 G Google 8 f Meta 5 ⊞ Microsoft 3

The optimal approach calculates distances in both directions on the circular route. We compute the clockwise distance by summing array elements, then get the counterclockwise distance by subtracting from the total perimeter. The key insight is that on a circle, there are only two paths between any two points, and we can calculate both efficiently in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Calculation (Optimal)	O(n)	O(1)	Calculate both clockwise and counterclockwise distances directly

Direct Calculation (Optimal) — Algorithm Steps

Ensure start <= destination for easier calculation
Calculate clockwise distance by summing distance[start] to distance[destination-1]
Calculate total perimeter by summing all distances
Counterclockwise distance = total - clockwise
Return the minimum of both distances

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Place stops in a circle with given distances between adjacent stops

Clockwise Path

Calculate distance going from start to destination in clockwise direction

Counterclockwise Path

Calculate the counterclockwise distance using total - clockwise

Choose Minimum

Return the shorter of the two distances

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int distanceBetweenBusStops(int* distance, int distanceSize, int start, int destination) {
    // Ensure start is less than destination
    if (start > destination) {
        swap(&start, &destination);
    }
    
    // Calculate clockwise distance
    int clockwise = 0;
    for (int i = start; i < destination; i++) {
        clockwise += distance[i];
    }
    
    // Calculate total distance
    int total = 0;
    for (int i = 0; i < distanceSize; i++) {
        total += distance[i];
    }
    
    int counterclockwise = total - clockwise;
    return min(clockwise, counterclockwise);
}

int main() {
    int distance[1000];
    int size = 0;
    char ch;
    int num = 0;
    int reading_num = 0;
    
    // Simple parser for [1,2,3] format
    while ((ch = getchar()) != '\n') {
        if (ch >= '0' && ch <= '9') {
            num = num * 10 + (ch - '0');
            reading_num = 1;
        } else if (reading_num) {
            distance[size++] = num;
            num = 0;
            reading_num = 0;
        }
    }
    if (reading_num) {
        distance[size++] = num;
    }
    
    int start, destination;
    scanf("%d %d", &start, &destination);
    
    printf("%d\n", distanceBetweenBusStops(distance, size, start, destination));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the distance array once to calculate sums

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store distances

✓ Linear Space

28.5K Views

Medium Frequency

~8 min Avg. Time

892 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

Direct Calculation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler