Codility Passing Car Problem in Java

The Codility Passing Cars problem is just one of the many typical algorithmic problems in which the actual goal is to determine the total number of valid pairs of cars that are traveling in opposite directions on the same road.

More specifically, the problem requires calculating the number of intersections of the east-moving car (indicated by 0) with a west-moving car (indicated by 1).

The difficulty is in doing this most efficiently; that is, in O(N) t, time complexity is best if possible, where N I is the total number of elements of the array.

Problem Statement

Given an array A consisting of N integers, each element represents the direction of a car:

'0' represents a car moving in the east direction.
1 means a car moving towards the west.

Your goal is to define (how many) pairs (P, Q) exist, where P is less than Q, the element in position P = 0 or A[P] = 0, and the element in position Q = 1 or A[Q] = 1. In other words, you want to know a way of quantifying the probability that a car coming from the east will overtake another vehicle coming from the west.

Solution to The Problem

The solution takes advantage of the fact that for every '1' on the westbound car, there are all the '0's' ahead of it for the eastbound cars. It enables us to count passing pairs in a single scanning of the array, and hence, the time complexity would be O(N).

We maintain two counters:

num_east: Records the number of cars moving in the east direction characterized by a value of zero.
num_pass: Keeps record of passing pairs in which an eastbound car overtakes a westbound car.

For every iteration through the array, if the eastbound counter (car) is 0, the num_east counter is increased by one. For each of the westbound car (1), we increment the current value of the num_east to the num_pass variable as all the eastbound cars will pass this westbound car.

File Name: CodilityProblem.java

 
public class CodilityProblem {
    public static void main(String[] args) {
        Solution solution = new Solution();
        // Example array where 0 represents eastbound cars and 1 represents westbound cars
        int[] A = {0, 1, 0, 1, 1};
        // Call the solution method and print the result
        int result = solution.solution(A);
        System.out.println("Number of passing cars: " + result);
    }
}
class Solution {
    public int solution(int[] A) {
        int num_east = 0; // Tracks the number of eastbound cars (0)
        int num_pass = 0; // Tracks the number of passing pairs
        for (int i = 0; i < A.length; i++) {
            if (A[i] == 0) {
                // Increment eastbound car counter when we encounter a 0
                num_east++;
            } else if (A[i] == 1) {
                // Add the number of eastbound cars to the passing pairs count
                num_pass += num_east;
            }
        }
        // Handle overflow cases and return the result
        if (num_pass > 1_000_000_000 || num_pass < 0) {
            return -1;
        } else {
            return num_pass;
        }
    }
}   

Output:

 
Number of passing cars: 5

Considerations and Edge Cases

Overflow Handling: After the operation's structure of changing the num_pass counter, the code contains an overflow check. It is essential because the number of passing pairs can increase tremendously to the extent of going beyond the value of 1, 000, 000, 000. If this occurs, the function returns -1 and this will show that an overflow situation has occurred.

Edge Cases: It also does a great job of handling such edge cases as:

An array of numbers filled with 0s or 1s without pairs will return 0, as is the correct result.
An array with no cars or only one car will also equal 0 as there is nothing to compare or pair.

Efficiency and Performance

Thus, the time is proportional to the size of the input, and for more significant inputs, the given solution is optimal: the time complexity is O(N). It goes through the whole array just once, making it efficient in terms of the size of the input array. The time complexity of the solution is O(1) as a few integer variables are used, hence making the solution memory efficient as well.

Conclusion

A good practice of using arrays and an efficient algorithm to solve the Codility Passing Cars problem. The given solution can be considered optimal and relatively stable because it allows precisely implementing of a single-pass counting of passing pairs.

It has, therefore, been able to accommodate significant inputs as well as other unknown values while keeping an eye on the correctness of its results and the amount of time it takes to run within the limits set.

Next TopicCover-manhattan-skyline-using-the-minimum-number-of-rectangles

← prev next →