Date Range Generator - Practice Coding Problems

Date Range Generator - Problem

JavaScript Medium

Create a Date Range Generator

You're tasked with building a generator function that produces a sequence of dates within a specified range. Given a start date, an end date (inclusive), and a step value representing days, your generator should yield dates in chronological order.

Key Requirements:

Return a generator object (not an array)
Include both start and end dates if they align with the step pattern
All dates must be in YYYY-MM-DD format
Handle month/year transitions correctly

This problem tests your understanding of JavaScript generators, date manipulation, and iterator patterns.

Input & Output

example_1.py — Basic Date Range

$ Input: start = "2024-01-01", end = "2024-01-10", step = 3

› Output: ["2024-01-01", "2024-01-04", "2024-01-07", "2024-01-10"]

💡 Note: Starting from 2024-01-01, we add 3 days each time: Jan 1 → Jan 4 → Jan 7 → Jan 10. Since Jan 10 equals our end date, it's included.

example_2.py — Cross-Month Range

$ Input: start = "2024-01-29", end = "2024-02-05", step = 2

› Output: ["2024-01-29", "2024-01-31", "2024-02-02", "2024-02-04"]

💡 Note: The generator correctly handles month transitions: Jan 29 → Jan 31 → Feb 2 → Feb 4. Feb 6 would exceed the end date, so it's excluded.

example_3.py — Single Day Range

$ Input: start = "2024-12-25", end = "2024-12-25", step = 1

› Output: ["2024-12-25"]

💡 Note: When start equals end, the generator yields exactly one date (the start/end date) regardless of step size.

Constraints

Start date will always be ≤ end date
Dates are in valid YYYY-MM-DD format
step is a positive integer (1 ≤ step ≤ 10³)
Date range will not exceed 10⁴ days
Years will be between 1900 and 2100

Visualization

Tap to expand

Memory Efficient: O(1) space - only current date stored• Lazy Evaluation: Dates computed only when requested• Scalable: Works efficiently for any range size

Understanding the Visualization

Set Starting Position

Place marker on start date

Check Boundary

Verify current date hasn't exceeded end date

Yield Current Date

Return current date in required format

Jump Forward

Move marker forward by step days

Repeat

Continue until past end date

Key Takeaway

🎯 Key Insight: Generators provide the perfect balance of memory efficiency and ease of use for sequence generation problems.

Asked in

G Google 23 ⊞ Microsoft 18 a Amazon 15 f Meta 12

The optimal solution uses a generator with lazy evaluation that calculates dates on-demand by adding the step interval to the current date. This achieves O(1) space complexity and O(n/step) time complexity, making it perfect for large date ranges while maintaining true generator semantics.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Dates)	O(n)	O(n/step)	Generate all dates in range, filter by step, then yield from array
Optimal Generator (Lazy Evaluation)	O(n/step)	O(1)	Calculate each date on-demand using step-based date arithmetic

Brute Force (Generate All Dates) — Algorithm Steps

Calculate total days between start and end dates
Generate array of all dates in the range
Filter the array to keep only dates that match the step pattern
Create generator function that yields from the filtered array

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Dates

Convert string dates to date objects

Generate All

Create every single date in the range

Filter by Step

Keep only dates that match step pattern

Store in Array

Save all valid dates in memory

Yield from Array

Create generator that iterates the stored array

Code -

solution.c — C

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

typedef struct {
    char dates[100][11]; // Max 100 dates, each YYYY-MM-DD + null terminator
    int count;
    int index;
} DateRangeGenerator;

time_t parseDate(const char* dateStr) {
    struct tm tm = {0};
    sscanf(dateStr, "%d-%d-%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday);
    tm.tm_year -= 1900;
    tm.tm_mon -= 1;
    return mktime(&tm);
}

void formatDate(time_t time, char* buffer) {
    struct tm* tm = localtime(&time);
    strftime(buffer, 11, "%Y-%m-%d", tm);
}

DateRangeGenerator* createGenerator(const char* start, const char* end, int step) {
    DateRangeGenerator* gen = malloc(sizeof(DateRangeGenerator));
    gen->count = 0;
    gen->index = 0;
    
    time_t startTime = parseDate(start);
    time_t endTime = parseDate(end);
    
    // Generate all dates first (brute force)
    time_t current = startTime;
    int dateCount = 0;
    
    while (current <= endTime && gen->count < 100) {
        if (dateCount % step == 0) {
            formatDate(current, gen->dates[gen->count]);
            gen->count++;
        }
        current += 24 * 60 * 60; // Add one day
        dateCount++;
    }
    
    return gen;
}

int hasNext(DateRangeGenerator* gen) {
    return gen->index < gen->count;
}

char* next(DateRangeGenerator* gen) {
    if (!hasNext(gen)) return NULL;
    return gen->dates[gen->index++];
}

int main() {
    DateRangeGenerator* gen = createGenerator("2024-01-01", "2024-01-10", 3);
    while (hasNext(gen)) {
        printf("%s\n", next(gen));
    }
    free(gen);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the number of days in the range - we generate all dates upfront

✓ Linear Growth

Space Complexity

O(n/step)

Stores all valid dates in an array before yielding

⚡ Linearithmic Space

42.3K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force (Generate All Dates) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler