Algorithms: interval problems
These are 3 interval problems that I have been asked by different companies in my programming interviews. I’ll present the problem, a possible candidateinterviewer exchange, and naive and efficient solutions with test cases.
1. First nonoverlapping interval
The question goes this way:
You have a list of licenses for a product. Find the earliest year which is not covered by an unexpired license.
Clarifying:

Candidate: Is there a minimum of licenses? And isn’t MIN_INT always correct?
Interviewer: What do you think?
Candidate: Well, if there are no licenses, it is trivially possible to return MIN_INT. And I suppose you meant the earliest year past the earliest start date.
Interviewer: Right.

Candidate: How are dates represented? And are intervals inclusive?
Interviewer: What do you think?
Candidate:
How about (start, end)
? And for simplicity let’s say intervals are indeed inclusive, so(2000,2000)
covers exactly one year.Interviewer: Sounds good.

Candidate: How about an example? Say we have:
[(2011, 2015), (2021, 2022), (2014, 2018), (2030, 2035), (2019, 2019)] Result: 2020
Interviewer: Sounds good.
Naive solution
Go over each interval (start, end)
, and insert each of the end  start
elements between start
and end
in a list. Then, sort that list in increasing order. Finally, iterate that list and
return the first number n
not preceded by n1
. Complexity can be O(2^n * log(2^n)) = O(2^n * n)
to sort the resulting list in the worst case, as intervals get larger and sparser.
Efficient solution
In a similar spirit to the naive solution but acting directly on the intervals, sort the list of intervals by increasing start
, then iterate over it. If at any point current.start > previous.end + 1
we may
return previous.end + 1
as the solution.
A quick Java solution with test cases may look like this:
1 
public class MinNoOverlap{ 
Complexity is O(n*log(n)) (sort) + O(n) (iterations)
, so O(n*log(n))
.
Easy optimization
If looking for an optimization, you can remark that, since we sort the intervals based on limited integer values, we can use baseN radix sort and decrease the complexity down to a minimum of O(n)
amortized linear time. In
fact, your JVM’s implementation of Arrays.sort
is probably already doing just that.
For reference, this SO question talks about it.
2. Maximum sum of concurrent overlaps
The question goes this way:
You are a critical TV cable service, with various qualities and formats for different channels. These channels only run at certain times of the day. You need to talk to a PHY cable provider service to get a guarantee for sufficient bandwidth for your customers at all times. How would you determine the necessary bandwidth?
Clarifying

Candidate: Let me write an example to see if I have the requirements down. I will be organizing the data in a list of 3tuples in the format
(start_time, end_time, bandwidth)
, with bandwidth in, say, Mbps, and times in hours between 0 and 24. So an example would be:[(2, 16, 10), (1, 5, 20), (10, 12, 25), (20, 22, 30)]
… where the first tuple indicates 10Mbps between 02:00AM and 4:00PM.
In this instance, we reach a peak of
10 + 25 = 35 Mbps
between 10AM and 12PM.Interviewer: Sounds fine.
Naive solution
Let’s start at the most basic solution: Get an array of hours [0, ..., 24]
, and for each of them scan the intervals and get the total bandwidth being consumed at that time.
This doesn’t work for infinite time precision and is very inefficient for high precision. But from here we can guess better solutions.
Intervaloriented solution
In many intervals problems, we can think in terms of breaking down intervals into smaller ones. So we can start with one interval [(0, 24, 0)]
(0 Mbps between 00:00 and 23:59), then iterate over the input, integrating each
new interval:
[(0, 24, 0)]
> (2, 16, 10) => [(0,2,0), (2,16,10), (16,24,0)]
> (1, 5, 20) => [(0,1,0), (1,2,20), (2,5,30), (5,16,10), (16,24,0))]
> (10, 12, 25) => [(0,1,0), (1,2,20), (2,5,30), (5,10,10), (10,12,35), (12,16,10), (16,24,0)]
> (20, 22, 30) => [(0,1,0), (1,2,20), (2,5,30), (5,10,10), (10,12,35), (12,16,10), (16,20,0), (20,22,30), (22,24,0)]
This is tricky to implement efficiently, however, because every time we integrate another interval from the input, we have to find which interval we should break into two or more. We can either order the input list, or binary search the output list for intervals to break, but for that effort, we can only get to O(n * log(n)), whether .
Efficient solution: eventdriven
We can see that what we really need is some variable that iterates over the input and keeps track of the maximum concurrent bandwidth so far. In order to do that, it would be a good idea to process increases and decreases separately, and modify the current concurrent bandwidth accordingly.
So we will rearrange each interval (start_time, end_time, bandwidth)
into two events (start_time, bandwidth)
and (end_time, 1 * bandwidth)
. Then we will sort the events by increasing start_time
.
Now we are ready to iterate over the input, keeping track of both the current and maximum values of the concurrent bandwidth.
A quick Java solution with test cases may look like this:
1 
public class MaxConcurrentSum { 
The complexity here is O(n * log(n))
due to the event sorting.
This Geeks for geeks article talks about this problem and proposes the use of an auxiliary array with a value for
each number between the minimum and maximum times. This array stores the value of every event, which we then iterate with the current and max bandwidth variables. This replaces the need for sorting, but does not support high precision.
So this is in principle
O(n)
complexity, but potentially
O(2^n)
for very large intervals.
Another solution could involve using an interval tree (a tree that holds intervals), which takes O(n * log(n))
to build, but only O(log(n))
to query for overlaps. This offers the same complexity but may provide shorter actual run time.
3. Variant: Overlap history
A variant of the previous problem, which I was also asked, goes this way:
You are the maintainer of a phone service. You have a log of calls including, for each call a tuple of
(start_time, end_time)
. How do you process this log to fetch a history of the number of concurrent calls?
The previous problem’s solution can also work here, but instead of updating the maximum number of overlaps, we write the current number every time it changes.