Codestin Search App

Maximum Population Year - Problem

You are given a 2D integer array logs where each logs[i] = [birth_i, death_i] represents the birth and death years of the i-th person.

Your task is to find the earliest year that had the maximum population. The population in any year x is the count of people who were alive during that year.

Important: A person is considered alive from their birth year up to (but not including) their death year. For example, if someone was born in 1950 and died in 1961, they contribute to the population count for years 1950-1960, but not 1961.

Goal: Return the earliest year with the maximum population count.

Input & Output

example_1.py — Basic Case

$ Input: logs = [[1993,1999],[2000,2010]]

› Output: 1993

💡 Note: Person 1 lives from 1993-1998, Person 2 lives from 2000-2009. No overlap, so earliest birth year 1993 has population 1, which equals the maximum.

example_2.py — Overlapping Lives

$ Input: logs = [[1950,1961],[1960,1971],[1970,1981]]

› Output: 1960

💡 Note: Person 1: 1950-1960, Person 2: 1960-1970, Person 3: 1970-1980. Year 1960 has 2 people alive (Person 1 still alive, Person 2 just born), which is the maximum.

example_3.py — Multiple Peak Years

$ Input: logs = [[2008,2026],[2004,2008],[2034,2035],[1999,2050]]

› Output: 2004

💡 Note: Multiple years have population 2, but we return the earliest: 2004 (Person 2 + Person 4 alive).

Constraints

1 ≤ logs.length ≤ 100
1950 ≤ birth_i < death_i ≤ 2050
Person dies in death_i year, so not counted in that year's population

Visualization

Tap to expand

Understanding the Visualization

Record Events

Mark all check-ins (+1) and check-outs (-1)

Sort Timeline

Process events in chronological order

Track Running Total

Calculate occupancy at each time point

Find Peak

Identify maximum occupancy and its earliest occurrence

Key Takeaway

🎯 Key Insight: Instead of checking every year individually, we only track population change events and use prefix sums to efficiently calculate the maximum population.

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 12 Apple 8

The optimal approach uses a difference array technique: mark population changes (+1 at birth, -1 at death), then use prefix sums to efficiently find the year with maximum population in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Difference Array (Optimal)	O(n log n)	O(n)	Use difference array to track population changes, then find maximum prefix sum
Brute Force (Check Every Year)	O(n × range)	O(1)	Check population count for every possible year individually

Difference Array (Optimal) — Algorithm Steps

Create a hash map to track population changes
For each person, increment count at birth year, decrement at death year
Sort the years and calculate prefix sum
Find the year with maximum population

Visualization

Tap to expand

Step-by-Step Walkthrough

Mark Changes

Record +1 at birth, -1 at death

Sort Years

Process years in chronological order

Prefix Sum

Calculate running population totals

Code -

solution.c — C

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

typedef struct {
    int year;
    int change;
} Event;

int compare(const void *a, const void *b) {
    return ((Event*)a)->year - ((Event*)b)->year;
}

int maximumPopulation(int** logs, int logsSize, int* logsColSize) {
    Event events[2000]; // Max 1000 people * 2 events each
    int eventCount = 0;
    
    // Record all events
    for (int i = 0; i < logsSize; i++) {
        events[eventCount++] = (Event){logs[i][0], 1};
        events[eventCount++] = (Event){logs[i][1], -1};
    }
    
    // Sort events by year
    qsort(events, eventCount, sizeof(Event), compare);
    
    // Calculate prefix sums
    int currentPopulation = 0;
    int maxPopulation = 0;
    int resultYear = events[0].year;
    
    for (int i = 0; i < eventCount; i++) {
        if (i == 0 || events[i].year != events[i-1].year) {
            if (currentPopulation > maxPopulation) {
                maxPopulation = currentPopulation;
                resultYear = events[i].year;
            }
        }
        currentPopulation += events[i].change;
    }
    
    return resultYear;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to build hash map + O(n log n) to sort unique years

⚡ Linearithmic

Space Complexity

O(n)

Hash map stores up to 2n year entries

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 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

Difference Array (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler