Number of Flowers in Full Bloom - Practice Coding Problems

Number of Flowers in Full Bloom - Problem

Array Hash Table Binary Search Sorting Prefix Sum Ordered Set Hard

Imagine you're organizing a beautiful flower garden tour! 🌸 You have a garden where different flowers bloom at different times throughout the year, and visitors arrive at various times to see the spectacle.

You're given a flowers array where flowers[i] = [start_i, end_i] represents the i-th flower's blooming period from day start_i to day end_i (both days inclusive). You're also given a people array where people[i] is the day when the i-th person arrives to visit your garden.

Your mission: For each visitor, determine exactly how many flowers they'll see in full bloom when they arrive! Return an array where answer[i] is the number of flowers blooming when person i visits.

Example: If flowers bloom during periods [[1,6],[3,7],[9,12],[4,13]] and people arrive on days [2,3,7,11], then visitors will see [1,2,2,2] flowers respectively.

Input & Output

example_1.py — Basic Garden Tour

$ Input: flowers = [[1,6],[3,7],[9,12],[4,13]] people = [2,3,7,11]

› Output: [1,2,2,2]

💡 Note: Person at day 2: Only flower [1,6] is blooming (1 flower). Person at day 3: Flowers [1,6] and [3,7] are blooming (2 flowers). Person at day 7: Flowers [3,7] and [4,13] are blooming (2 flowers). Person at day 11: Flowers [9,12] and [4,13] are blooming (2 flowers).

example_2.py — Single Flower

$ Input: flowers = [[1,10]] people = [3,3,2]

› Output: [1,1,1]

💡 Note: There's only one flower blooming from day 1 to 10. All three people arrive during this period, so each person sees exactly 1 flower in bloom.

example_3.py — No Overlapping Blooms

$ Input: flowers = [[1,3],[4,6],[7,9]] people = [2,5,8,10]

› Output: [1,1,1,0]

💡 Note: Each person arrives during different non-overlapping bloom periods. The last person arrives after all flowers have finished blooming, so they see 0 flowers.

Constraints

1 ≤ flowers.length ≤ 5 × 10⁴
flowers[i].length == 2
1 ≤ start_i ≤ end_i ≤ 10⁹
1 ≤ people.length ≤ 5 × 10⁴
1 ≤ people[i] ≤ 10⁹
Time limit: 2 seconds

Visualization

Tap to expand

Understanding the Visualization

Timeline Setup

Create a timeline showing all flower blooming periods

Event Extraction

Extract start and end events from flower intervals

Binary Search Magic

Use binary search to instantly count active blooms for any query time

Efficient Queries

Answer all visitor queries in O(log n) time each

Key Takeaway

🎯 Key Insight: By converting flower intervals into sorted start/end events and using binary search, we can answer bloom count queries in O(log n) time instead of checking every flower individually.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses an event-based approach with binary search. Instead of checking each flower individually, we extract all bloom start and end times, sort them, then use binary search to efficiently count how many flowers are blooming at any given time. This reduces time complexity from O(n×m) to O(n log m), making it suitable for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Event-Based + Binary Search (Optimal)	O(n log n)	O(m)	Convert flowers to start/end events, then use binary search to count active blooms
Brute Force (Check Every Flower)	O(n*m)	O(1)	For each person, iterate through all flowers to count how many are blooming

Event-Based + Binary Search (Optimal) — Algorithm Steps

Extract all start times and end times from flowers
Sort both start times and end times arrays
For each person's arrival time:
Use binary search to count how many flowers started by this time
Use binary search to count how many flowers ended before this time
The difference is the number of flowers currently blooming

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Events

Separate flower blooming into start and end events

Sort Events

Sort start times and end times independently

Binary Search

For each person, binary search to count started and ended blooms

Calculate Difference

Active blooms = flowers_started - flowers_ended

Code -

solution.c — C

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

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

int bisectRight(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] <= target) left = mid + 1;
        else right = mid;
    }
    return left;
}

int bisectLeft(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] < target) left = mid + 1;
        else right = mid;
    }
    return left;
}

int* fullBloomFlowers(int** flowers, int flowersSize, int* flowersColSize, int* people, int peopleSize, int* returnSize) {
    int* starts = (int*)malloc(flowersSize * sizeof(int));
    int* ends = (int*)malloc(flowersSize * sizeof(int));
    int* result = (int*)malloc(peopleSize * sizeof(int));
    *returnSize = peopleSize;
    
    for (int i = 0; i < flowersSize; i++) {
        starts[i] = flowers[i][0];
        ends[i] = flowers[i][1];
    }
    
    qsort(starts, flowersSize, sizeof(int), compare);
    qsort(ends, flowersSize, sizeof(int), compare);
    
    for (int i = 0; i < peopleSize; i++) {
        int started = bisectRight(starts, flowersSize, people[i]);
        int ended = bisectLeft(ends, flowersSize, people[i]);
        result[i] = started - ended;
    }
    
    free(starts);
    free(ends);
    return result;
}

int main() {
    int flowers_data[][2] = {{1,6},{3,7},{9,12},{4,13}};
    int* flowers[4];
    for (int i = 0; i < 4; i++) flowers[i] = flowers_data[i];
    int flowersColSize[] = {2,2,2,2};
    int people[] = {2,3,7,11};
    int returnSize;
    
    int* result = fullBloomFlowers(flowers, 4, flowersColSize, people, 4, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(m log m), and for each person we do binary search in O(log m), total O(m log m + n log m)

⚡ Linearithmic

Space Complexity

O(m)

We store start and end times in separate arrays, each of size m (number of flowers)

✓ Linear Space

58.0K Views

High Frequency

~25 min Avg. Time

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

Event-Based + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler