Tidyverse Exercises in R: 50 Real-World Practice Problems

Explanation: Passing multiple conditions to filter() separated by commas is equivalent to combining them with & (logical AND). The comma style reads more naturally and is the idiomatic dplyr form. A common mistake is writing class = "compact" with a single equals sign, which is assignment and triggers an error inside filter(). Always use == for equality tests.

Explanation: starts_with() is one of the tidyselect helpers (ends_with(), contains(), matches(), where()). Naming price first then starts_with("c") controls column order: position in the call equals position in the output. Because starts_with() skips columns already listed by name, price never gets duplicated even if it had started with "c" itself.

Explanation: arrange() sorts ascending by default; wrap a column in desc() for descending. Passing two columns means the second is a tiebreaker for the first. Note that arrange() ignores grouping; to sort within groups, either arrange(group, key) or use .by_group = TRUE. Sorting is non-destructive: it returns a new tibble with row order changed but no data removed.

Explanation: case_when() reads top-to-bottom and the first matching condition wins. Because the second branch implicitly handles 1000-4999, you do not need price >= 1000 & price < 5000. The trailing TRUE ~ ... is the catch-all default; without it, prices of 5000 or above would become NA. Cleaner than nested if_else() once you reach three or more buckets.

Explanation: summarise() collapses many rows to one and is the right verb whenever you need a one-row report. quantile() returns a named numeric; summarise() strips the name and stores it under the column name you assigned. To compute the same statistics by group, the only change is prepending group_by(); the summarise() call stays identical. That symmetry is why pipelines stay short.

Explanation: Without .keep_all = TRUE, distinct() returns only the columns you list. With it, dplyr keeps the first encountered row in full whenever a duplicate of the key columns appears. This is faster than group_by() |> slice(1) and reads more clearly when the intent is dedup-on-key. To choose a specific row instead of the first, switch to slice_min() or slice_max() on a tiebreaker column.

Explanation: slice_max() keeps the n highest values; slice_min() is the symmetric verb. The with_ties = TRUE default returns extra rows when the nth row is tied, which is usually what audits want. ungroup() at the end prevents the grouping from leaking into downstream operations; a frequent source of confusing dplyr bugs. Always ungroup once group-aware work is done.

Explanation: rename() takes pairs in new = old order; the opposite of mutate(), which is new = expression. relocate() is the dedicated verb for column reordering; the columns you name move to the front by default, and unlisted columns keep their relative order. You could chain select() to reorder but select() drops anything not listed, which is risky for wide tables. Prefer relocate().

Explanation: across() applies a function to many columns at once. everything() is the selector here; for numeric-only safety on mixed-type tables, use where(is.numeric). The backslash lambda \(x) ... is base R 4.1+ shorthand for function(x) .... An alternative is scale(), but it returns a matrix; mutate(across()) keeps the result as a tibble, which is usually what you want for downstream piping.

Explanation: n() is a dplyr counter that works only inside summarise() and similar verbs; it knows the current group size. The arrange(desc()) after summarising sorts the one-row-per-group output by the computed mean. Since dplyr 1.1, you could also write summarise(..., .by = class) and skip the explicit group_by(); both styles are valid, but the explicit form remains easier for newcomers to read.

Explanation: count(cut, sort = TRUE) is shorthand for group_by(cut) |> summarise(n = n()) |> arrange(desc(n)). After counting, the data is no longer grouped, so sum(n) in mutate() totals across all rows; which is what we want for an overall percent. If we had stayed grouped, sum(n) would have just returned each group's own count and every pct would have been 100.

Explanation: inner_join() keeps only rows whose join key exists in both tables. The order of arguments determines column order in the output, not the join semantics; orders |> inner_join(customers) and customers |> inner_join(orders) return the same rows but with columns in different positions. dplyr 1.1 also accepts join_by(customer_id) as the modern alternative to by = "customer_id".

Explanation: A left join keeps every row of the left table and adds matching columns from the right; non-matches become NA. coalesce() is the tidyverse "first non-NA" function and is the idiomatic replacement for ifelse(is.na(x), 0, x). Notice that Eve still shows NA for order_id; only amount was patched, because the order id of a non-existent order is genuinely undefined.

Explanation: anti_join() keeps rows of the left table whose key has NO match in the right table; the inverse of semi_join(). The right table contributes no columns; it acts purely as a filter. This is the cleanest way to find referential-integrity violations in joined data. Functionally equivalent to filter(!customer_id %in% customers$customer_id) but reads better and is faster on large data.

Explanation: semi_join() filters the left table by membership in the right table's key; it never duplicates rows even if the right table has multiple matches. Compare with inner_join(), which would broadcast: if keep had setosa listed twice, inner_join() would double every setosa row, but semi_join() would not. Use semi-join whenever you need filter-by-membership semantics without column merging.

Explanation: full_join() returns the union of keys from both tables, inserting NA where a key is missing on either side. coalesce() accepts any number of arguments and returns the first non-NA per row, making it perfect for prioritised feed reconciliation. If you wanted the maximum or mean of the two prices instead, swap coalesce() for pmax(..., na.rm = TRUE) or rowMeans(..., na.rm = TRUE).

Explanation: bind_rows() accepts a list of tibbles and stacks them. The magic argument is .id: it adds a new column whose values are the list-element names. This is the cleanest way to preserve a "source" label when combining many similar tables. If you instead had separate variables q1, q2, q3, you would call bind_rows(Q1 = q1, Q2 = q2, Q3 = q3, .id = "quarter") with explicit naming.

Explanation: lag() shifts a vector down by one, padding the top with NA; lead() is its mirror. Always arrange() before lagging or you will compute deltas between rows that are not actually adjacent in time. For groupwise lags (per ticker), wrap in group_by() first; lag() respects grouping inside a dplyr pipeline. Use lag(close, n = 5) for a 5-day lag.

Explanation: pivot_longer() takes the columns named in cols, stacks them into one new column whose values come from old cell entries, and adds a key column listing the old column names. cols = Q1:Q4 uses tidyselect range syntax; you could equivalently write cols = starts_with("Q"). Long form is the format ggplot, dplyr summarisation, and most modelling functions expect, so reshaping wide-to-long is usually the first step.

Explanation: pivot_wider() is the inverse of pivot_longer(). names_from says which column's values become new column names; values_from says which column's values fill the cells. If the (region, quarter) combination is not unique, you must supply values_fn = mean (or sum, list, etc.) to tell pivot how to aggregate duplicates. Without that, pivot_wider() warns and stores list-columns.

Explanation: separate_wider_delim() is the modern tidyr replacement for the deprecated separate(). It splits on a delimiter and creates the named columns. If you had three-word names like "Mary Jane Watson", you would need too_many = "merge" or too_many = "drop" to handle the extra parts; otherwise tidyr errors loudly, which is usually safer than silently truncating.

Explanation: separate_wider_regex() accepts a vector of named (kept) and unnamed (dropped) patterns. Unnamed strings like "EVT-" and "-" act as separators and disappear from the result. Named entries become columns. This pattern is far cleaner than a single mega-regex with capture groups because each field is documented inline and missing pieces fail loudly with row indices, easing debugging.

Explanation: nest() turns each group of rows into a one-row entry in a list-column called data. You can pass nest(.by = manufacturer) since tidyr 1.3 to avoid the explicit group_by(). Always ungroup afterwards or downstream pipelines may behave unexpectedly. Nested tibbles are the foundation of split-apply-combine modelling: you nest, model, extract, then unnest.

Explanation: unnest() is the inverse of nest(). It takes a list-column of tibbles and stacks them, repeating the non-list columns to match each row. If the list-column held atomic vectors instead of tibbles, you would need unnest_longer() (each element becomes a row) or unnest_wider() (each element becomes a column). Match the verb to the shape of the list-column content.

Explanation: complete() takes one or more columns and ensures every combination of their unique values appears as a row. Missing rows are added with NA in other columns; fill = list(col = value) provides defaults. This is exactly the operation needed before time-series joins or aggregations where missing observations represent zero, not unknown. Skipping complete() here would make a downstream group_by(day) give wrong averages.

Explanation: fill() propagates the last non-NA value into subsequent NAs. .direction = "down" is the default and matches the spreadsheet "merged cell" pattern. Use "up" for backward fill or "downup" to fill from both directions in one pass. fill() respects grouping, so prepending group_by(account_id) prevents one account's branch from leaking into another's.

Explanation: str_detect() returns a logical vector indicating which strings contain the pattern, perfect for use inside filter(). Wrapping the pattern in regex(..., ignore_case = TRUE) makes the match case-insensitive without modifying the source data. For a literal substring match without regex semantics, use fixed("Audi") to disable special characters; faster and safer when the pattern is user input.

Explanation: str_remove() deletes the first regex match; str_remove_all() deletes every match. The anchor ^ ties the pattern to the start of the string, and 0+ matches one or more zeros. Without the anchor, 0+ would also remove zeros in the middle, turning "10500" into "15". A trap: str_remove("00000", "^0+") yields "" not "0"; guard against all-zero inputs separately if you need to preserve a single zero.

Explanation: str_extract_all() returns a list-column where each element holds every match for one row. unnest_longer() turns that list-column into one row per match, repeating note_id as needed. If you only wanted the first match per row, str_extract() (without _all) returns a character vector directly and no unnest is needed. Pick the verb based on whether rows can have multiple matches.

Explanation: parse_date_time() accepts a vector of candidate orders and tries them in turn for each value, returning the first that parses. The output is a POSIXct; as.Date() strips the time component. If you knew every row was the same format, the single-format functions ymd(), mdy(), or dmy() are faster. For heterogeneous CSVs, parse_date_time() is the workhorse; lock the candidate set tightly to avoid ambiguous matches.

Explanation: year() and month() from lubridate return integer components from a Date or POSIXct. The .groups = "drop" argument is the cleanest way to silence dplyr's grouping warning and return an ungrouped result. Writing this idiom on a daily series automatically becomes a monthly rollup; the same pattern works whether the input is daily, hourly, or already monthly.

Explanation: Subtracting two Date objects returns a difftime; as.numeric() strips the unit and gives a plain number of days. A lubridate alternative is interval(signup_date, ymd("2026-05-12")) / days(1), which is more explicit about the unit but more verbose. For days-only arithmetic, the base R subtraction is usually the simplest correct answer.

Explanation: separate_longer_delim() is tidyr's row-multiplying split; one tag per row, with id repeated. Then count() does the tabulation. The rename tag = tags inside count() makes the output column read like a singular noun. This is the canonical way to summarise "many-valued" columns and avoids the trap of writing a regex-based count, which would miss whitespace edge cases.

Explanation: ymd_hms() parses the timestamp and you must pass tz = "UTC" because the trailing "Z" is not auto-detected. with_tz() shifts the displayed timezone without changing the underlying instant; the moment in time is identical, only the wall-clock representation differs. Contrast with force_tz(), which RE-LABELS the timezone and produces a different instant; that is almost never what you want.

Explanation: map_dbl() is the type-stable variant of map() that guarantees a double vector output; map_chr(), map_int(), map_lgl() work the same way. If any column produced a non-numeric result, map_dbl() would error rather than silently coerce; that strictness is the whole point. For mixed-result situations, fall back to map() (returns a list) and inspect element types before deciding the next verb.

Explanation: map2() walks two parallel inputs simultaneously, passing one element from each to the function. The type-stable suffixes _dbl, _int, _chr apply here too. For element-wise addition specifically, plain vectorisation (a + b) is faster and more idiomatic. But for arbitrary two-argument functions that are NOT vectorised (e.g. fitting one model per parameter pair), map2() is the right tool.

Explanation: pmap() takes a list of equal-length inputs and a function whose argument names match. By naming the lambda arguments start, ratio, n, the call reads like a row-wise function. Putting the result inside mutate() creates a list-column, which you can later unnest_longer() if you need one row per series element. pmap is the n-argument generalisation of map2; learn it once and you rarely need mapply().

Explanation: The nest-model-extract pattern is the tidyverse alternative to by() and dlply(). Each step is independently testable: you can print ex_5_4$model to inspect individual fits. broom::tidy(m) is an even cleaner extractor if you want all coefficients with standard errors and p-values in long form; drop it in and unnest() to expand.

Explanation: keep() retains elements for which the predicate returns TRUE; discard() is the inverse. The predicate can be a named function (is.numeric) or a lambda (\(x) length(x) > 1). Both verbs preserve list names, unlike Filter() in base R, which also works but has less consistent naming. For tibbles specifically, select(where(is.numeric)) is the column-wise analogue.

Explanation: reduce() applies a binary function cumulatively along a list: f(f(t1, t2), t3). For joins, this is the cleanest way to merge an arbitrary number of tables without writing N-1 explicit left_join() calls. The first list element is the seed; each subsequent element gets joined in. reduce() is also the right verb for repeated bind_rows(), intersect(), union(), etc.

Explanation: safely() is a function adverb: it wraps a function so the wrapped version never errors, returning a list of result and error instead. The companion possibly() returns a fallback value on error (simpler, less information). quietly() captures messages and warnings. For a production pipeline that must continue past bad rows, safely() |> map() plus a transpose() to pull out the two halves is the canonical pattern.