Data Wrangling Exercises in R: 50 Practice Problems

Explanation: Wrapping shape and a sample in a named list keeps the artefact reproducible: a downstream notebook or test can introspect it without re-reading mtcars. Prefer nrow()/ncol() over dim() when you want the parts separately; head(df, 3) is more deterministic than df[1:3, ] because it survives row reordering.

Explanation: glimpse() is the analyst-friendly counterpart to str(): one row per column with type and head values. Capturing its console output gives you a programmable artefact, which is handy for snapshot tests or for posting an overview to a chat channel. str() is older and prints class hierarchies, useful for S4 objects but noisier for flat data frames.

Explanation: is.na() returns a logical matrix the same shape as the data; colSums() collapses it to per-column counts. Filtering with na_counts > 0 removes clean columns so the report stays compact. The same idiom generalises to other quality checks: replace is.na with is.infinite or a custom predicate for similar audits.

Explanation: A typed schema is the foundation of every data dictionary. sapply(iris, class) walks columns and returns a named character vector. Coercing the first row to character with as.character keeps mixed types in one vector. For richer audits, swap sapply with vapply(iris, class, character(1)) for stricter type safety.

Explanation: Counting distinct values per column is the cheapest way to find binary flags (vs, am) and small-domain categoricals (cyl, gear). Sorting ascending makes the suspects appear first. For very wide tables, prefer dplyr::summarise(across(everything(), n_distinct)) so the result stays a tibble you can join back to a feature catalogue.

Explanation: across() plus a named list of functions builds wide stat columns; .names = "{.col}__{.fn}" encodes both pieces so pivot_longer() can split them apart. The .value token in names_to makes the stat names become column headers instead of values. Rounding at the end keeps the table presentable without losing precision in intermediate computations.

Explanation: Taking class(x)[1] keeps the fingerprint stable when a column has multiple classes (an ordered factor reports c("ordered","factor")). Comparing two fingerprints with identical() gives you a fast schema-drift check between pipeline runs. For deeper drift detection, hash the fingerprint plus row counts, which catches both schema and volume changes.

Explanation: select() keeps columns in the order you name them, which differs from subset() and [, c(...)] only in that it preserves the tibble class. Piping into head(5) after selection is cheaper than slicing first because the projection runs only on the kept columns. For programmatic column lists, use all_of(my_cols) to avoid the data-mask warning.

Explanation: Base-R subsetting with [row, col] is the right tool here because mtcars is a data frame whose row names carry the model. dplyr::filter() would drop those row names since tibbles do not support them. The trailing comma after the row condition is required: omit it and you ask R for columns, which throws a confusing error.

Explanation: Multiple conditions inside filter() are joined with logical AND, the same as filter(cut == "Ideal" & carat >= 1) but slightly more readable. Putting filter before select keeps the column count high only while it matters, but the optimiser fuses the two steps regardless. For complex multi-clause predicates, if_all() and if_any() make the intent explicit.

Explanation: Sorting after filtering is the conventional order: the optimiser will not push arrange ahead of filter because that would sort more rows than necessary. The 71 rows surfaced are mostly Fair-cut J-color stones, hinting that price anomalies cluster in low-quality grade combinations rather than being random data errors.

Explanation: slice_max() is a tidy alternative to arrange(desc(price)) |> head(5) and supports multi-column ordering by passing a tibble to order_by. Without with_ties = FALSE (the default in 1.1+), tied rows beyond n are dropped silently; if you need to keep every tie, set with_ties = TRUE.

Explanation: distinct() keeps the columns you name; without an arrange() the order is whichever rows appeared first in the source. For dashboards, sorting before caching avoids an O(n log n) sort on every page render. If you need the unique combinations of two columns (manufacturer plus model), pass both to distinct() and the deduplication considers the pair.

Explanation: cut is an ordered factor so arrange(cut) follows the factor levels (Fair < Good < Very Good < Premium < Ideal) rather than alphabetical order. Mixing ascending and descending in one arrange is just a matter of wrapping the descending key with desc(). The trick generalises to any number of keys with mixed directions.

Explanation: if_any() returns TRUE when at least one of the selected columns satisfies the predicate; the lambda ~ .x > mean(.x) is evaluated per column so each comparison uses that column's own mean. Use if_all() when you want every selected column to pass. Combined with across() over where(is.numeric), this pattern scales to wide tables without rewriting the predicate.

Explanation: mutate() appends new columns to the right while keeping every existing column. Wrapping the calculation in round(.., 1) keeps the display tidy without losing usable precision: downstream models will round implicitly if they care. To replace hp in place rather than adding a new column, write mutate(hp = round(hp / cyl, 1)).

Explanation: case_when() reads top-to-bottom, so the second branch implicitly handles 1000-4999. The trailing TRUE ~ "premium" is the catch-all default; without it, prices above 5000 would become NA. For three or more buckets, case_when() is cleaner than nested if_else() and clearer than findInterval() because the labels are visible inline.

Explanation: if_else() is the tidyverse equivalent of base ifelse() but strict about return types: a numeric branch cannot pair with a character branch without coercion. Petal.Length > 5 already evaluates to a logical, so you could skip if_else() entirely and write large_petal = Petal.Length > 5. The explicit form documents the intent for a reader who is new to vectorised logic.

Explanation: A z-score expresses how many standard deviations a value sits from the mean. Implementing it by hand makes the formula transparent; scale(mpg) from base R does the same but returns a matrix with attributes that often surprise people downstream. Standardising before clustering, PCA, or distance-based models prevents columns with large absolute ranges from dominating.

Explanation: across(where(is.numeric), ...) applies the same transformation to every column matching a predicate, which scales to tables of any width without naming columns. The tilde-and-dot syntax (~ ... .x ...) is the dplyr shorthand for an anonymous function. After dplyr 1.1, you can also write \(x) round((x - mean(x))/sd(x), 2) using the base-R lambda.

Explanation: With three exhaustive branches and no TRUE ~ default, any unexpected code becomes NA, which is the desirable behaviour during data validation. If mpg later gains a new code (say "e" for electric), you would see NAs surface in downstream counts. dplyr::recode() does the same job in fewer characters but is being soft-deprecated in favour of case_when().

Explanation: A right-aligned rolling window of size 7 needs the previous 6 rows, so the first valid value lands on row 7. The na.rm = TRUE inside mean() lets one missing day not blank out the entire window. Production code typically uses slider::slide_dbl() or zoo::rollmean(), but rolling your own is a useful sanity check for window semantics.

Explanation: Feature engineering in one mutate() keeps the intermediate state out of memory and reads as a single transform. Log-pricing tames the heavy right tail of price, which is the variable a linear regression benefits from most. price_per_carat normalises across stone sizes so two diamonds of different carats are comparable. Storing the indicator as logical (not character) keeps it model-ready.

Explanation: Long form is the canonical shape for ggplot2 and most modelling functions because each variable lives in its own column. pivot_longer(cols = Q1:Q4) selects the columns to stack; names_to gives the destination column for the old column names. The output keeps the within-row order of original columns, so Q1 < Q2 < Q3 < Q4 holds naturally.

Explanation: pivot_wider() is the inverse of pivot_longer(): it spreads a key column into multiple new columns. The names_from argument supplies the new column names; values_from supplies the cells. If duplicate (channel, metric) pairs existed, you would need values_fn = sum (or mean, etc.) to disambiguate; otherwise the values would land in list-columns.

Explanation: cols = -Species is the negative-selector shortcut for "every column except Species". The resulting long shape is ideal for ggplot2 faceting on measurement to compare distributions side by side. Pivoting at the very end of a wrangling pipeline (not in the middle) keeps your operations on the more efficient wide form for as long as possible.

Explanation: left_join() preserves every row of the left table and fills NAs for unmatched keys. Pick the left side deliberately: it should be the table whose row count you want to keep. If a customer has multiple orders, the row count grows on the left because each match duplicates the customer row. Use multiple = "first" or "last" in dplyr 1.1+ to control that behaviour.

Explanation: inner_join() drops rows whose key has no match on either side. The "Mystery" product with cat_id 9 disappears because there is no matching category row. This is the right join when you only care about rows that exist in both tables, but be aware it silently filters: print row counts before and after to catch unintended data loss.

Explanation: anti_join() keeps rows in the left table whose key does NOT appear in the right table, and it never adds columns from the right side. It is the cleanest way to find referential-integrity violations. The mirror operation, semi_join(), keeps only rows that DO have a match without adding columns either. Both are filtering joins, useful for boolean lookups.

Explanation: bind_rows() matches columns by name, not position, which is safer than rbind() when column orders differ. Passing the inputs as named arguments and setting .id = "source_day" adds a provenance column free of charge. This is the canonical pattern for stacking partition files (one CSV per day) into a single analysis-ready frame.

Explanation: The named-vector form c("left_col" = "right_col") tells dplyr how to map keys without renaming columns ahead of time. The result keeps the left-side column name. For multi-column joins, extend the vector: by = c("a" = "x", "b" = "y"). In dplyr 1.1+, the new join_by(prod_code == code) syntax is the preferred long-form replacement.

Explanation: separate_wider_delim() (tidyr 1.3+) is the modern replacement for separate(), with strict handling of unexpected row shapes via too_few and too_many arguments. If a row had more than one dash, the default behaviour throws an error rather than silently truncating. For regex-based splits, use separate_wider_regex() with a named character vector of capture groups.

Explanation: group_by() partitions the data, summarise() collapses each partition to a single row per group. In dplyr 1.1+, you can skip the explicit group_by with summarise(.by = cyl, mean_mpg = mean(mpg)), which returns ungrouped output by default and avoids a common foot-gun where downstream code still sees the data as grouped.

Explanation: n() is a special dplyr helper that returns the row count of the current group; it only works inside dplyr verbs. Reporting n alongside means and sds is a habit worth keeping: a group of size 5 with a low standard deviation tells a very different story than a group of size 500 with the same value. Reviewers can ignore noisy small groups easily.

Explanation: Premium cuts costing more on average than Ideal cuts is a classic Simpson's paradox setup: bigger stones tend to receive Premium rather than Ideal grading, and size dominates the price. Reporting both n and mean_price is what lets a reader spot that the lower-priced groups are also numerically dominant.

Explanation: count(x, sort = TRUE) is the most concise way to produce a frequency table sorted descending. The output column is always named n, and the input columns are preserved as the grouping keys. For weighted counts (sum of a numeric column rather than row count), pass wt = some_column; this is handy when each row already carries a frequency.

Explanation: slice_max() after group_by() produces a within-group top-N rather than an overall top-N. Setting with_ties = FALSE keeps the row count deterministic at exactly 2 per group, which matters for reporting. Forgetting to ungroup() is a common pitfall: downstream mutates will quietly run per-group, sometimes giving surprising results.

Explanation: across(where(is.numeric), fn) is the wide-summary idiom: it touches every column matching the predicate without naming any of them. For multiple summary functions, pass a named list: across(where(is.numeric), list(mean = mean, sd = sd)), which produces columns like Sepal.Length_mean, Sepal.Length_sd, and so on.

Explanation: mutate() inside group_by() runs the calculation per group, which is what makes cumsum() restart at each account. The .by_group = TRUE flag on arrange() is essential: without it, arrange reorders the whole frame and the cumulative sum will follow the wrong order within accounts. Always remember to ungroup() afterward.

Explanation: The pattern count() |> group_by() |> mutate(share = n / sum(n)) is the canonical way to express "what fraction of each group does this subgroup represent". Because mutate() is grouped, sum(n) resolves to the within-group total, not the global total. Drop the group_by() if you want global shares instead.

Explanation: drop_na() with no arguments drops rows where any column is NA; pass column names to restrict the check. Base R equivalent is na.omit() or df[complete.cases(df), ]. Always print the row count before and after dropping so you know how much data you spent: losing 42 rows out of 153 is significant and might warrant imputation instead.

Explanation: Median imputation is robust to outliers but biases distributions: it inflates the median frequency. The as.numeric(Ozone) cast guards against if_else's strict type matching, since Ozone is integer but the median is numeric. For modelling, prefer multiple imputation (mice package) over single-value imputation when more than a few percent of rows are missing.

Explanation: str_trim() removes leading and trailing whitespace, and str_to_title() capitalises the first letter of each word. Doing both in one step is essential before deduplication or joins: " red apple " and "Red Apple" are different strings to R until they are normalised. For locale-aware casing (Turkish, German), supply the locale argument.

Explanation: Wrapping the pattern in regex(..., ignore_case = TRUE) handles mixed capitalisation without lower-casing the source column, which would lose information. For exact-match (non-regex) substring search, fixed("holiday") is much faster and avoids regex pitfalls with metacharacters like . and *. Save the regex flag at the pattern, not the column.

Explanation: Parsing dates eagerly (right after import) prevents string-comparison bugs where "2026-01-15" is "less than" "2026-9-1" lexicographically. lubridate::ymd() is a more forgiving alternative to as.Date() because it can auto-detect minor format variations like "20260115". Once you have a Date object, every part-extraction function (year, month, wday, yday) just works.

Explanation: separate_wider_delim() is strict: a row with no space, or with more than one space, would error by default. Control that with too_few = "align_start" or too_many = "merge". For multi-part names ("Mary Jane Smith"), prefer regex with separate_wider_regex() to keep the middle part with the first or last name based on a rule.

Explanation: Cleaning before pivoting matters: if you pivot first, "East " and "East" become two separate columns. The drop_na(sales) step removes the unmatched April row that had no value; otherwise pivot_wider would emit an extra row of NAs. Stacking small transformations in a clear order is the heart of every reliable wrangling pipeline.

Explanation: Feature engineering then aggregation is the bread-and-butter analyst pipeline. Median values are reported instead of means because price distributions are right-skewed; the median resists outliers. arrange(med_log_price) keeps tiers in price order regardless of the (alphabetical) tier labels, which makes the output unambiguous.

Explanation: This is the classic "top-N per group" idiom: aggregate to the level you care about, then slice_max() within group. The double group_by() is intentional: the first groups for the sum, the second isolates each region before ranking. .groups = "drop" is good hygiene; it ungroups before the next operation so you do not have to remember.

Explanation: count() |> pivot_wider() is the idiom for turning a long event log into a wide feature matrix. values_fill = 0 ensures missing combinations become 0 rather than NA, which matters when you add columns afterwards. dense_rank(desc(total)) ranks descending without gaps in tie cases; switch to min_rank() if you want ties to skip ranks.