lubridate Exercises in R: 28 Real Practice Problems

Explanation: ymd() is the right helper because the input is year-month-day. The same vector parsed with as.Date() would also work for this exact shape, but lubridate's parsers tolerate separators ("2024/01/15", "2024.01.15", "20240115") interchangeably without a format string. Sister functions: mdy(), dmy(), ydm(), myd(), dym() cover every component ordering.

Explanation: US partners almost always send month-first dates, so mdy() is the natural choice. The output is normalized to ISO format regardless of the input pattern, which is what makes lubridate parsers safe in pipelines: downstream code sees Date objects, not strings. A common mistake is to use ymd() here: it will silently return NA because "07" is not a valid year prefix in that context.

Explanation: parse_date_time() tries each format string in orders against each input until one parses cleanly. The format tokens are lubridate's own (Y = 4-digit year, b = abbreviated month, I = 12-hour, p = AM/PM marker), not strptime tokens. The result is always UTC unless you pass tz=. When inputs are heterogeneous this is the only parser that scales; calling ymd_hms() on the whole vector would return NA for two of three rows.

Explanation: Coercing inside mutate() is the canonical tidy pattern: the column type changes from <chr> to <dttm> and every downstream date function (filters, groupings, joins) starts working without further coercion. ymd_hms() is strict by default: anything that does not match returns NA with a warning. Pass quiet = TRUE to silence the warning when you have already verified the input shape.

Explanation: Excel counts days from 1899-12-30 (not 1900-01-01) because of a quirky leap-year bug Microsoft preserved for compatibility. Passing the wrong origin is the single most common reason finance data looks two days off. as_date() is the lubridate cousin of base as.Date() and accepts both character inputs and numeric serials. For Excel datetimes (with fractional days for the time portion) use as_datetime(x * 86400, origin = "1899-12-30").

Explanation: year(), month(), and day() each return a numeric vector the same length as the input. They are vectorized, so they work inside mutate() over an entire column with no loop. Pass label = TRUE to month() for ordered factors ("Jan", "Feb"). The numeric form is what you want for joins, sorting, and arithmetic; the labelled form is what you want for plots and tables.

Explanation: wday() defaults to Sunday as day 1 (US convention). Most international and business contexts start the week on Monday: setting week_start = 1 keeps "Sat" and "Sun" together at the end, which matches how staffing schedules read. The label = TRUE flag returns an ordered factor, so plots and tables render in weekday order rather than alphabetical order.

Explanation: ISO weeks live on a different calendar than wall-clock years near boundaries: the last days of December 2024 belong to ISO week 1 of 2025 because that week contains the first Thursday of 2025. Always pair isoweek() with isoyear(); if you group by isoweek() alone you will merge week 52 of two different years. The base format(x, "%V") returns the same number but as character.

Explanation: fiscal_start shifts the quarter boundaries so that the named month becomes the first month of Q1. Without it, lubridate returns calendar quarters (Jan-Mar = Q1). Pass with_year = TRUE to get a "2025.1" style label that encodes both the fiscal year and quarter. A common mistake is to hand-roll this with month() %/% 3, which silently breaks across year boundaries.

Explanation: The component accessors (year(), month(), day(), hour(), etc.) all have a replacement form that mutates in place. This is one of the few cases in R where assignment into a function call is idiomatic. The replacement is element-wise, so the operation vectorizes. A trap: rolling Feb 29 forward by one year produces March 1 because Feb 29 does not exist in non-leap years; use add_with_rollback() to control that behavior explicitly.

Explanation: days(30) is a fixed-length period (always 30 actual days, so Jan 31 plus 30 days is March 1 in 2024 because February has 29 days). months(1) tries to land on Feb 31, which does not exist, so it returns NA. This trip-up costs analysts hours every year. Use %m+% (next exercise) to make the month addition safe by clamping to the last valid day.

Explanation: %m+% rolls invalid landing dates back to the last day of the target month: Jan 31 + 1 month becomes Feb 29 (or Feb 28 in non-leap years), Jan 31 + 4 months becomes April 30 because April has only 30 days. The companion %m-% does the same for subtraction. Always use these operators when computing month-end series, billing dates, or fiscal anchors.

Explanation: Dividing an interval by years(1) gives a fractional age that respects leap years correctly (each year in the interval is 365 or 366 days depending on which calendar years it spans). Naively dividing days by 365.25 is off-by-one for some birthdates near year boundaries. floor() then as.integer() produces the "completed years" most legal and HR contexts require. For age at a vector of reference dates, both inputs vectorize.

Explanation: seq.Date() from start to end - days(1) produces the half-open range (14 days). Filtering by wday() <= 5 keeps Monday through Friday when week_start = 1. April 2024 starts on a Monday, so the 14 days include two full Mon-Fri weeks and contribute 10 business days. For holiday-aware business days use bizdays::bizdays() or RQuantLib::businessDaysBetween(), both of which read a holiday calendar.

Explanation: Subtracting two POSIXct values gives a difftime whose units depend on magnitude; coercing to as.duration() forces a fixed-seconds representation so the division by dweeks(1) (one week of seconds = 604800) is deterministic. Use dweeks() not weeks(): the former is a duration (exact seconds), the latter is a period (variable seconds across DST). For human-readable durations, as.period(t2 - t1) reports months/days/hours/etc.

Explanation: %within% is inclusive on both endpoints, so June 30 returns TRUE. The left operand vectorizes: you can test a long event column against a single campaign interval or against a vector of intervals (one campaign per row). For half-open semantics use event_dts >= int_start(campaign) & event_dts < int_end(campaign) instead.

Explanation: int_overlaps() returns TRUE when two intervals share any point in time, including touching endpoints. Both arguments vectorize, so you can compare every appointment in a calendar against every other appointment by passing column vectors. For finding the overlapping subinterval itself use intersect(appt_a, appt_b), which returns the shared Interval or NA if disjoint.

Explanation: intersect() vectorized over two Interval vectors returns a vector of intersection intervals (or NA when disjoint). Dividing by days(1) converts each to a numeric day count. pmax(0, ..., na.rm = TRUE) clamps any NA (disjoint) to zero so the resulting vector is always non-negative and finite. This pattern generalizes to billable-hour tracking, contract-coverage audits, and any overlap-quantification problem.

Explanation: Using %within% inside filter() is the cleanest way to apply a closed time window because it reads like English and the inclusive-on-both-sides semantics match how non-technical stakeholders describe windows. The row at 12:00:00 sharp is kept because the interval is closed. If the requirement were exclusive on the right, use filter(ts >= int_start(win), ts < int_end(win)).

Explanation: floor_date() always rounds toward the past, so it is the right choice for cohort and reporting-period keys (every date in March maps to "2024-03-01"). Group-bys keyed on this column produce monthly aggregates without any manual format() string handling. The complementary ceiling_date() rounds forward; round_date() rounds to the nearest boundary.

Explanation: Without week_start = 1, lubridate floors to the previous Sunday (US default), which is rarely what business users want outside the United States. April 14, 2024 is a Sunday: the Monday-starting week containing it begins April 8. The unit argument also accepts "2 weeks", "10 minutes", or any multiple, so the same idiom buckets streaming events into arbitrary fixed windows.

Explanation: round_date() rounds to the nearest boundary (so 09:23:30 lands on 09:15 because it is 8:30 minutes past, less than half a bucket). The unit argument is a string that lubridate parses, so "5 minutes", "15 minutes", "30 secs", and "2 hours" all work. For deterministic half-bucket behavior (always rounding 09:22:30 down or always up) use floor_date() or ceiling_date() instead.

Explanation: with_tz() keeps the absolute instant fixed and changes only the displayed wall-clock string and the printed zone abbreviation. The underlying numeric POSIXct value (seconds since 1970-01-01 UTC) does not change. Use it any time the physical event is the same but the audience reads a different clock: NYC trading desk reviewing UTC server logs, mobile analytics rolling up to user local time, audit teams reconciling logs across data centers.

Explanation: with_tz() keeps the instant constant (09:00 UTC is 14:30 in Kolkata because Kolkata is UTC+5:30) and adjusts the displayed clock. force_tz() keeps the displayed clock constant and changes the underlying instant: the same "09:00" is now interpreted as Kolkata local, which is a different real-world moment. Choose force_tz() when a system stamped the wall clock incorrectly as UTC; choose with_tz() when the UTC was correct and you want a local view.

Explanation: A period (hours(1)) is a calendar concept: "the same wall-clock time one hour earlier", so it lands on 02:30, which during a spring-forward day did not actually happen in NYC and lubridate represents as a synthetic EST moment. A duration (dhours(1)) is exactly 3600 seconds of physical time, which on this day actually skips back across the missing 02:00-03:00 hour and lands at 01:30. Always reach for durations when you mean "exactly N seconds" and periods when you mean "the wall clock one hour earlier".

Explanation: The three-step pipe is the standard MoM idiom: floor to a month-anchor for grouping, sum the metric, then lag() the sorted result to access the prior period. lag() returns NA for the first row, which is the correct behavior because there is no prior period. For year-over-year change, swap floor_date(..., "year") and the same pipe works unchanged.

Explanation: seq.Date(min, max, by = "day") builds the spine of every day in range, and the left_join() keeps every spine row while attaching matching revenue. Gaps surface as NA, which downstream code can treat as zero (replace_na(list(revenue = 0))) or leave as missing depending on intent. For multi-key gap filling (e.g., date crossed with product), tidyr::complete(dt, product) is the one-liner version.

Explanation: With week_start = 1, Monday is 1 and Sunday is 7, so the test <= 5 returns TRUE for Mon-Fri. if_else() (typed) is preferred over base ifelse() because it preserves the column type and errors on a type mismatch instead of silently coercing. count() is the one-liner for group_by() |> summarise(n = n()) |> ungroup(), so the final pipe is three readable lines.