dplyr Exercises in R: 50 Real-World Practice Problems

Explanation: Passing two conditions to filter() separated by a comma is equivalent to & (logical AND). rownames_to_column() from tibble lifts the car names out of the row index so they survive the pipeline; base mtcars stores them as rownames(mtcars) which filter() cannot reference directly.

Explanation: %in% returns a logical vector the same length as car, marking each element TRUE if it appears anywhere in target. It is the idiomatic way to filter against a known set, and is far more readable than chaining several car == "..." clauses joined by |. Negate with !(car %in% target).

Explanation: Direct comparison Ozone == NA always returns NA (never TRUE), so filter(Ozone == NA) returns zero rows silently. is.na() is the only correct test for missingness; negating it with ! is the standard dplyr idiom for dropping NAs in one column. For multiple columns, use filter(if_all(c(Ozone, Solar.R), \(x) !is.na(x))).

Explanation: Tidyselect helpers like starts_with(), ends_with(), contains(), and matches() (regex) make column picks robust to schema drift: if a new "Sepal.Area" column appears tomorrow, it joins automatically. Listing Species after the helpers fixes its position at the end, which is useful when the rest of the pipeline expects measurements first.

Explanation: median(price) is evaluated once at the start of filter() because dplyr passes the entire column vector. Strictly greater (>) excludes the median itself, which is why the count is slightly under half of 53,940. Use >= if you want the median row included. Because there is no group_by(), the median is computed across the whole dataset.

Explanation: %in% collapses what would otherwise be class == "pickup" | class == "2seater". As the set of allowed values grows, %in% stays one short line while | chains become unreadable. The vector passed to %in% can be constructed elsewhere (e.g., read from a config file), which makes the pipeline declarative.

Explanation: Negative select with !c(...) (or the older -c(...)) is the right tool when the keep-list is longer than the drop-list. It is also robust to schema drift: any new column appearing in mtcars later automatically passes through, instead of being silently dropped as it would be with a positive select(mpg, cyl, hp, wt, vs, am, gear).

Explanation: if_all() returns TRUE only when the predicate (is.na) holds across every named column in a row. Negating with ! keeps rows where it is NOT true that all three are missing, which is the standard "drop fully empty rows" pattern. Use if_any() for "missing in at least one"; the two read as quantifiers on columns.

Explanation: case_when() reads top to bottom; the first matching condition wins, so the second branch only catches prices in [1000, 4999]. The trailing TRUE ~ ... is the catch-all default; without it, prices at or above 5000 would become NA. This is much cleaner than nested if_else() for three or more buckets.

Explanation: mutate() adds the derived column without dropping existing ones, then select() reshapes to the four columns of interest. arrange(desc(ppc)) puts the most expensive-per-carat stones first; desc() is preferred over -ppc because it works on character and factor columns too. The actual numbers depend on the exact rounding of diamonds.

Explanation: if_else() from dplyr is type-strict (both branches must return the same type) and NA-aware (carries NA through the predicate), unlike base ifelse() which can silently coerce. For binary recodes from 0/1 numerics, this is the standard idiom. For three or more outcomes, switch to case_when().

Explanation: across() applies a function to many columns inside a single mutate(); where(is.numeric) is a tidyselect predicate that picks columns by class. The anonymous-function shorthand \(x) round(x, 2) is preferred over the older ~ round(.x, 2) because it scales to multiple arguments and matches base R syntax.

Explanation: across(c(...), fn) passes the function bare (no anonymous wrapper needed) because as.factor() takes a single vector. This pattern lets you batch-coerce many columns and is the dplyr replacement for mutate_at() (now superseded). Categorical conversion early in the pipeline keeps later models (lm, aov) from treating the codes as continuous.

Explanation: arrange() evaluates its sort keys left to right, so desc(mpg) is primary and hp is the tie-break. Notice the two Honda Civic / Lotus Europa rows both at 30.4 mpg: the one with lower hp (52 vs 113) appears first because of the secondary hp key. Use arrange(across(everything())) to sort on every column at once.

Explanation: coalesce() walks its arguments left to right and returns the first non-NA value per row, much like SQL's COALESCE. It is the cleanest way to express "use A if present, else fall back to B (else C, etc.)" and beats nested if_else() chains. If every input is NA for a row, the result is NA.

Explanation: case_match() is designed for value-to-value mapping, removing the noisy cut == "Ideal" | cut == "Premium" syntax that case_when() would need. The .default argument is the catch-all (replacing TRUE ~ ...). Coercing cut to character avoids surprises with the ordered factor levels that diamonds ships with.

Explanation: group_by() partitions the data; summarise() then collapses each partition to one row, with each named expression becoming a new column. The result is automatically ungrouped at the last grouping variable, which is why downstream code rarely needs an explicit ungroup() after a single group_by().

Explanation: count(col) is shorthand for group_by(col) |> summarise(n = n()). The sort = TRUE argument arranges descending by n, which is exactly what you want for a ranked segment view. For multiple grouping columns, pass them all (count(cut, color)); for weighted counts, pass wt = some_col.

Explanation: across() inside summarise() produces one summary column per input column (here, four numerics give four summary outputs). For multiple summary functions per column, pass a named list: across(where(is.numeric), list(mean = mean, sd = sd)) produces Sepal.Length_mean, Sepal.Length_sd, and so on.

Explanation: summarise() with two grouping columns produces one row per (cut, color) combination. Passing .groups = "drop" strips the residual grouping so the downstream filter() runs on a regular tibble. Without it, filter() would still work, but later operations could be silently scoped to remaining groups.

Explanation: Weighted means matter whenever observations are unequal: heavy cars likely use more fuel and should pull the average down, which is why wmean_mpg is a touch lower than naive_mean for cyl == 4. dplyr does not have a dedicated weighted-mean verb, but weighted.mean() from base R drops straight into summarise().

Explanation: Inline subsetting (cty[class == "suv"]) is dplyr-friendly: each summary expression sees the group's columns as plain vectors, so any base R indexing works. This avoids splitting the pipeline into two filter() branches and joining them back. Numbers depend on the exact mpg shipped with ggplot2.

Explanation: summarise() requires each expression to return a single value, so calling quantile() separately for each probability is the simplest path. The alternative, returning a length-3 vector, used to require reframe() (added in dplyr 1.1) which lets a summary expression produce multiple rows per group. For wide output, the three-call form is more readable.

Explanation: count() returns one row per cut and a column n. Because the resulting tibble has no remaining grouping (count auto-drops one level), sum(n) is the grand total across all cuts, which gives the share-of-whole. To get share within a different parent group, wrap the divisor in a grouped sum(n) via group_by() before the mutate().

Explanation: Wide format is the right shape for side-by-side comparison and exec dashboards. The summary stays long while computing (group_by + summarise), then pivot_wider() reshapes once: names_from becomes the new column headers, values_from becomes their cell values. Use pivot_longer() to go the other way.

Explanation: .by is a per-call grouping argument that does not persist after the verb finishes, so you never need an explicit ungroup(). It is preferable when grouping applies to just one verb. Row order in the output follows the order of first appearance of cyl in the data, not sorted; pass .by = cyl with a downstream arrange(cyl) for a sorted view.

Explanation: inner_join() keeps only rows that match on both sides, so customer 3 (Carol, no order) and order from cust_id 4 (no matching customer) both drop. The named vector c("id" = "cust_id") tells dplyr the left key is id and the right key is cust_id. The newer alternative is join_by(id == cust_id).

Explanation: left_join() keeps every row from the left side regardless of whether a match exists on the right; unmatched rows get NA in the right-side columns. Bob has two orders so he appears twice (left rows can be duplicated by the right). This is the right join when the left table is your "spine" of entities you must report on.

Explanation: Filtering joins (anti_join, semi_join) only return columns from the left table and never duplicate rows. anti_join() keeps rows that have no match on the right, the inverse of semi_join(). It is the cleanest way to ask "who is missing from B?" without a noisy left_join() |> filter(is.na(amount)) pattern.

Explanation: semi_join() is to inner_join() what anti_join() is to left_join() |> filter(is.na(...)): a filtering-only variant. It keeps at most one copy of each left row and never adds right-side columns. Reach for it when you want to subset by membership in another table without materialising extra columns.

Explanation: full_join() is the union of left_join() and right_join() and is invaluable when you suspect both sides have orphan records. The keep = TRUE argument preserves both join keys as separate columns so you can see exactly which side a row came from. Drop keep and the keys merge into one column.

Explanation: Passing a character vector to by joins on multiple columns by name (same name on both sides). If the columns were named differently, you would use by = c("date" = "shift_date", "store" = "shift_store"). Composite keys are how you avoid Cartesian explosions: every (date, store) pair is meant to be unique on at least one side.

Explanation: join_by() (dplyr 1.1+) supports inequalities, rolling joins, and overlap joins that the older by = character syntax could not express. Here each salary is matched to the unique bracket whose min_income <= salary < max_income. Without inequality joins, this would require a manual crossing() followed by filter(), a quadratic blow-up on real data.

Explanation: bind_rows() aligns columns by name, filling missing ones with NA, which is why hp is NA for the mpg rows. The .id argument creates a new column whose values come from the names you passed (here "mtcars" and "mpg"), perfect for tagging row provenance when you union datasets from different sources.

Explanation: row_number() breaks ties by the order of appearance in the data, giving every row a distinct integer rank. Wrapping the input in desc() reverses the direction so 1 is "best". Use min_rank() if you want tied values to share a rank with gaps, or dense_rank() for ties without gaps.

Explanation: lag(x) shifts the vector down by one, so the first row becomes NA (no prior period). Always arrange() before lag()/lead() because they trust the row order they see. Use lag(x, n = 12) for year-over-year on monthly data, or pass default = ... to control how the first n rows fill.

Explanation: cumsum() is a window function: it returns a vector the same length as its input. Inside a group_by(), it restarts at each group, which is the entire point. arrange() before group_by() controls the order within each window; without it, the running sum would follow whatever order the source happened to be in.

Explanation: slice_max(price, n = 3) keeps the top three rows by price within each group. with_ties = FALSE forces exactly three rows even when there is a tie at the cutoff, which is what you want when downstream code expects a fixed count. The sibling slice_min() does the inverse, and slice_sample(n = 3) gives random picks.

Explanation: "Most recent per id" is a window-level filter: rank by ts within id, keep rank 1. The arrange(desc(ts)) puts the newest row first within each group, and slice_head(n = 1) takes it. The same idea generalises to "first event per session", "best score per player", and so on.

Explanation: row_number() always returns a unique integer per row (ties broken by source order). dense_rank() gives equal values the same rank with no gap to the next, so three rows tied at hwy=44 all get dr=1 and the next distinct value (hwy=41) is dr=2. min_rank() is the third flavour: equal values share, but the next rank skips ahead.

Explanation: A centred 3-period average uses one observation on each side of the current row, which is why lag() and lead() appear together. The first and last rows of the series have no neighbour on one side, so ma3 is NA there and the filter() drops them. For longer windows, the slider package offers slide_dbl().

Explanation: first() and last() are dplyr helpers that respect the current row order, so arrange() controls what counts as "first". They are clearer than head(x, 1) and tail(x, 1) inside summarise() because they return a single scalar by design. Use nth(x, n) for arbitrary positions.

Explanation: The pipeline runs in two grouping passes: first collapse each (cohort, user) to a single retention flag with any(), then average the flag within each cohort to get the rate. Doing it in one pass would over-count users with many return visits. mean() of a logical vector is the share that is TRUE.

Explanation: Per-group outlier removal needs per-group thresholds, which is why mutate() (not summarise()) is used: it broadcasts the group quantiles to every row in the group. After the filter, the helper columns are dropped. Tukey's 1.5 * IQR is conservative for skewed data like prices; for log-scale data, do the same logic on log(price).

Explanation: diff() returns the period-over-period gaps; all(diff(value) > 0) is TRUE only when every gap is positive, i.e. the series is strictly increasing. Wrapping this in a per-group summarise() reduces every segment to a single TRUE/FALSE, then a downstream filter() keeps the qualifying ones. >= instead of > would allow plateaus.

Explanation: The combined pattern of lag() for differences and slice_max() for extremes is one of dplyr's most useful idioms for time series anomaly detection. arrange(date) is essential before lag(). with_ties = FALSE keeps the output to exactly one row when several months happen to share the maximum jump.

Explanation: The Pareto cut is "biggest first until cumulative share crosses 80%", which requires including the row that crosses, not just the rows below it. The lag(cum_share, default = 0) <= 0.80 clause adds back the boundary-crosser. The exact count depends on price distribution but typically the top 20% to 60% of rows hold 80% of value.

Explanation: Group-wise standardisation puts each hp on a comparable scale per cylinder class, which matters because a 175-hp 6-cylinder is unusual but a 175-hp 8-cylinder is not. The threshold 1.5 (sigma) is a soft outlier rule; 2 or 3 is stricter. Keep mutate() (not summarise()) so the original rows are preserved.

Explanation: A two-way summary table is the canonical use of summarise() + pivot_wider(). The result has one row per cut and one column per color, with cell values from mean_price. If a (cut, color) combination had no rows, the cell would default to NA; pass values_fill = 0 to override.

Explanation: add_count() is count() followed by a join: it adds a column with the group size to every original row, so you can filter by it without losing the original columns. Filtering on dup_n > 1 keeps only rows that belong to a duplicate group. For exact whole-row duplicates use distinct() (drop) or janitor::get_dupes() (inspect).