R for Data Science Exercises: 50 R4DS Practice Problems

Explanation: read_csv() happily accepts a string containing newlines as if it were a file connection, which is invaluable for unit tests and reproducible examples. The show_col_types = FALSE argument suppresses the column-spec message that would otherwise clutter the output. For tabs use read_tsv(), and for any other delimiter use read_delim(delim = ...).

Explanation: glimpse() rotates the usual print() view 90 degrees so every column becomes a row, which is the right shape for wide tables. It is the first call most R4DS practitioners reach for after read_csv(). Compare with str(), which has the same goal but a noisier display, and summary(), which gives quantile statistics instead of types.

Explanation: Tibbles are data frames with three behavioural tweaks that matter in production code: they never partial-match column names, they never coerce strings to factors, and they print only the first ten rows by default so a console session does not vanish behind a 10,000-row dump. as_tibble() is the lossless conversion; the reverse trip is as.data.frame().

Explanation: read_csv() quietly converts un-parseable cells to NA rather than failing the whole import. The recovery information lives in a sidecar attribute that problems() surfaces. In a real pipeline you would either widen the column spec (col_character()) and parse downstream, or add a data-quality alert when nrow(problems(x)) > 0. Silent NAs are the bug that haunts R4DS analyses.

Explanation: Leading-zero IDs, phone numbers, postal codes, and ISBNs all break under guess-driven numeric parsing. The cols() helper lets you nail down each column explicitly. The shorthand version is the compact string "cc" meaning "two character columns". Production pipelines should always pin col_types rather than relying on the first 1000-row guess that read_csv() makes by default.

Explanation: across() is the modern replacement for summarise_if() and summarise_at(). The first argument is a tidy-select that picks columns; here where(is.numeric) discards the Species factor automatically. Combined with group_by() this is the workhorse for cohort-style summaries. For multiple statistics pass a named list: across(everything(), list(mu = mean, sd = sd)).

Explanation: Tidy data wants one observation per row, so each quarter-product combination becomes its own row. cols = Q1:Q3 is a tidy-select range; alternatives include starts_with("Q") or -product (everything except). The new column names go in names_to, and the cell values land in values_to. This is the most common reshape in R4DS practice.

Explanation: pivot_wider() is the inverse of pivot_longer(). The names_from column supplies the new column names and values_from supplies the cells. Wide form is rarely the right format for analysis but is exactly what reporting tools and human reviewers expect. If two rows share the same key combination, supply values_fn = list or an aggregator to control collisions.

Explanation: Since tidyr 1.3 the new separate_wider_* family replaced the old separate() because it is louder about parsing failures. Rows that do not match the requested shape now raise an informative error instead of silently producing NA. For fixed-width fields use separate_wider_position(); for regex captures use separate_wider_regex().

Explanation: drop_na() keeps only complete rows for the named columns; omit the argument to drop on any column. Compare with filter(!is.na(Ozone)), which is equivalent for a single column but verbose for many. For imputation rather than deletion you would reach for replace_na() (constant fill) or one of tidyr::fill() / dplyr::coalesce() for forward-fill and fallback chains.

Explanation: fill() is the right tool for the "last observation carried forward" idiom common in reporting tables that visually merge header rows. The .direction = "down" default is what you want most of the time; "up", "downup", and "updown" cover edge cases when the first or last value is missing. Combine with group_by() to fill within groups only.

Explanation: complete() is a tidyr workhorse for time-series and cohort analyses where missing combinations should appear with a sentinel value rather than be absent. Internally it builds the cross-product of the grouping columns and left-joins back. The fill argument distinguishes "structurally absent" from NA; use nesting() inside complete() when only some combinations are valid.

Explanation: unite() is the inverse of separate(): it glues several columns into one. Combined with lubridate::ymd(), this is the canonical idiom for repairing date columns that arrived split. An equally valid one-liner is mutate(date = make_date(year, month, day)), which avoids the string roundtrip entirely; both produce a true Date vector that time-series tooling understands.

Explanation: filter() evaluates its expression for each row and keeps the TRUEs. Multiple conditions chain with commas (interpreted as &) or explicit | for OR. A common pitfall is using = instead of == inside the predicate; the former assigns and triggers a clear error, but logical typos like x = 5 returning a scalar TRUE after coercion can silently drop everything.

Explanation: select() accepts new_name = old_name syntax inline, eliminating a separate rename() step for renames that happen alongside trimming. Tidy-select helpers like starts_with(), ends_with(), contains(), and matches() (regex) work too. To keep all columns but rename a few, use rename() instead; select() keeps only what you name.

Explanation: mutate() adds or modifies columns based on existing ones. New columns appear at the right; use .before = col or .after = col to control placement. A ratio is more interpretable than a raw difference when scales vary across rows. For multiple new columns built from the same intermediate, factor the intermediate into its own mutate() step rather than recomputing it.

Explanation: Group-then-summarise is the most reused pattern in R4DS. The new .by argument in dplyr 1.1 offers a one-line alternative: summarise(..., .by = class). Always pass .groups = "drop" or use .by to avoid the persistent-grouping footgun where a downstream mutate() accidentally operates within the old groups. median() is more robust to outliers than mean().

Explanation: slice_max() keeps the top-n rows per group by the column you pass. It replaces the older top_n(), which had confusing tie-breaking behaviour. arrange() controls the final display order; without it, slice results inherit the original row order. A useful variant: slice_max(price, prop = 0.01) keeps the top 1 percent per group instead of a fixed count.

Explanation: inner_join() keeps only rows whose key appears in both tibbles, dropping Cleo who never ordered. left_join() would keep Cleo with NA order columns; full_join() would also keep any order-only rows. dplyr 1.1 added join_by() for non-equi joins like inequality conditions or rolling joins, which the old by = argument cannot express.

Explanation: anti_join() is a filter, not a merge: it keeps rows of the left tibble whose key does not appear in the right tibble, and never adds columns. It is the most idiomatic way to express "find rows in A that are not in B". The cousin semi_join() is the opposite filter, keeping left rows that have at least one match without duplicating them.

Explanation: case_when() reads top-to-bottom; the first matching branch wins, so the second branch only fires for prices in [1000, 4999]. The trailing TRUE ~ ... is the catch-all default; without it, prices >= 5000 would become NA. Cleaner than nested if_else() once there are three or more buckets, and the case order itself documents the bucketing rule.

Explanation: lag(x) returns the previous row's value; lead(x) returns the next row's. The first lag is NA because there is no prior row, which is correct: a zero delta would misleadingly imply "no change". Always confirm the tibble is sorted in time order before lagging; combine with group_by(series_id) to lag within panel groups rather than across them.

Explanation: The hand-rolled lag() approach works for a fixed small window but does not generalise. For longer windows or different aggregations, the slider package gives proper sliding windows with explicit alignment. The zoo::rollmean() and RcppRoll::roll_mean() are also classic options. The NA head is the trailing-window convention; pass na.rm = TRUE only if you really want partial-window means.

Explanation: Every ggplot starts with ggplot(data, aes(...)), which sets the global mapping, then adds layers with +. With 50,000 points the scatter is mostly black because dots stack; the cure is alpha = 0.05 for transparency or geom_hex() for a 2D density. Save the plot as an object so it can be reused, themed, or printed to file later.

Explanation: Putting colour = cut inside aes() makes the aesthetic data-driven; outside aes() it would be a fixed visual property. The alpha = 0.4 inside geom_point() is fixed, not mapped, which is exactly what you want for an overplotting fix. labs() titles the legend so a non-R user can read the chart without guessing at column names.

Explanation: facet_wrap() is the right tool when you have one categorical splitter and want a 2D grid that wraps automatically. facet_grid(rows ~ cols) is the choice when you have two splitters and want a strict matrix. Faceting is more honest than colouring when categories number more than five or six; the human eye separates panels better than it separates close hues.

Explanation: Histogram shape depends sharply on binwidth. The default 30 bins is a starting point; always test two or three widths because a single setting can hide multimodality or invent it. The spikes at common weights illustrate why visual inspection matters: a summary statistic would smooth them away. For continuous shape, geom_density() is the kernel-smoothed alternative.

Explanation: A boxplot encodes five summary numbers (min, Q1, median, Q3, max) plus outliers as dots. It is the densest possible per-group display and the right first call when comparing a numeric variable across a small number of categories. With many categories, geom_violin() carries shape information that boxes do not, and geom_jitter() overlaid on a boxplot shows raw observations.

Explanation: ggplot draws factor levels in their stored order, which for a character vector is alphabetical. fct_infreq() reorders by descending count so the visual ranking matches the data. The siblings are fct_reorder() for ordering by a summary statistic of another column, fct_rev() to reverse order, and fct_relevel() for manual moves. Always reorder before passing to aes().

Explanation: Converting a ts object to a tibble is the first step toward using any tidyverse tool on time-series data; the trick is as.numeric(time(x)) for the index and as.numeric(x) for the values. geom_line() draws a line in the row order of the tibble, so always sort by time first. Compare with geom_path(), which traces an arbitrary 2D trajectory.

Explanation: geom_smooth() defaults to LOESS for under ~1000 points and to GAM above that; passing method explicitly removes the surprise. The grey band is a 95% confidence interval around the conditional mean; turn it off with se = FALSE for a cleaner deck slide. method = "lm" overlays an OLS line, which is more interpretable when you have a parametric story to tell.

Explanation: Log scales straighten exponential relationships; for diamonds the price-vs-carat plot is famously linear in log-log because price scales roughly with carat to the 1.6 power. scales::label_dollar() formats axis ticks as currency without manual format() gymnastics. theme_minimal() strips the grey ggplot default for a cleaner board-deck look; base_size scales every text element proportionally.

Explanation: lm() is the workhorse for ordinary least-squares regression. The default print method shows only point estimates; for inference (standard errors, t-statistics, p-values, R-squared) call summary(ex_5_1). The slope of -5.34 says: for each extra 1000 lb of vehicle weight, predicted mpg drops by 5.34 miles per gallon. Always look at residual plots before trusting the inference.

Explanation: broom's three core verbs convert model outputs into tibbles: tidy() for coefficients, glance() for one-row model-level statistics (R-squared, AIC), and augment() for per-row fitted values and residuals. This bridges the gap between R's stats objects and tidyverse workflows; without broom you would manually pull pieces from summary(fit)$coefficients.

Explanation: glance() produces a single-row tibble of model fit metrics. The columns vary by model class: for lm you get R-squared and friends; for glm you get null and residual deviance. Because every model returns the same shape (one row), you can bind_rows() glance outputs across many models and rank them by AIC. This is the foundation of model-comparison workflows.

Explanation: augment() attaches model-derived columns to the original data: .fitted (predicted), .resid (observed minus fitted), .hat (leverage), .cooksd (Cook's distance), and .std.resid. This is the tidy way to do residual diagnostics: pipe straight into ggplot() for a plot of fitted versus residuals. The . prefix prevents name clashes with the original columns.

Explanation: Notice how the slope on wt shrank from -5.34 (simple) to -3.17 (multiple). That gap is the classic story of confounding: weight, cylinder count, and horsepower correlate, so the simple model attributed shared variance entirely to weight. The multiple-regression slope is the partial effect holding the others fixed. Always interpret coefficients in context of the included covariates.

Explanation: Logistic regression models the log-odds of a binary outcome as a linear function of predictors. The coefficient 9.00 means each 1cm increase in petal length multiplies the odds of being virginica by exp(9.00), an enormous shift. The intercept alone is hard to interpret; what matters is the predicted probability at meaningful petal lengths. Use predict(fit, type = "response") to convert log-odds to probabilities.

Explanation: The formula interface y ~ group splits y by group and runs the two-sample test. The Welch variant does not assume equal variances, which is almost always the right default. A p-value of 0.0014 strongly rejects the null of equal means; the 95 percent confidence interval (-11.3, -3.2) tells you how much lower automatic mileage is than manual, and is more informative than the p-value alone.

Explanation: ANOVA partitions total variance into between-group (Species) and within-group (Residuals) components. The huge F-statistic 1180 and astronomically small p-value say species explains essentially all the variation in petal length. ANOVA only tells you "some group differs"; for pairwise comparisons, follow up with TukeyHSD(aov_fit) or emmeans::pairs() to control family-wise error rates.

Explanation: Setting a seed makes the split reproducible across sessions and reviewers. The negative indexing iris[-idx, ] is a base-R idiom that drops the selected rows. For stratified splits that preserve class balance, you would group by the outcome before sampling. Cross-validation generalises this idea: instead of one split you make k of them and average performance, which gives a much less noisy estimate.

Explanation: Nearest-mean classifiers (also called Rocchio classifiers) are the linear baseline you compare every fancier model against. They are equivalent to linear discriminant analysis with equal priors and equal isotropic covariances. The rowwise() step is the tidy way to apply a per-row function; vectorising with matrix algebra would be faster for tens of thousands of rows.

Explanation: A confusion matrix counts every (true, predicted) pair. The diagonal is correct predictions; off-diagonals are errors. Accuracy is the simplest aggregate but is misleading under class imbalance; precision, recall, and F1 give a richer per-class picture. For a quick sanity check on a balanced three-class problem like iris, accuracy is fine.

Explanation: k-means minimises within-cluster sum of squared distances to centroids. Always scale() first so columns measured in centimetres do not dominate columns measured in grams. nstart = 25 runs 25 random initialisations and keeps the best; otherwise local minima can produce wildly different solutions. The cross-tab shows clusters align well with species except for the versicolor-virginica overlap, which is expected.

Explanation: Cross-validation breaks the data into k folds; each fold takes a turn as the held-out test set while the others train. Averaging k MAE estimates gives a much lower-variance estimate of out-of-sample error than a single train/test split, especially on small datasets like mtcars. vapply() enforces the numeric scalar return type, which catches subtle bugs that sapply() would silently swallow.

Explanation: kable() is the minimum viable table renderer for R Markdown, Quarto, and most static-site pipelines. It accepts the same format argument as the parent document expects ("markdown", "html", "latex"). For polished tables with merged headers, conditional cell colours, or footnotes, layer on the kableExtra package. For interactive tables, swap in DT::datatable() or reactable.

Explanation: The .id = "model" argument to bind_rows() lifts the list names into a new column, which is the standard way to label per-model rows after a lapply(fits, glance). Use adjusted R-squared, not raw R-squared, when comparing models with different numbers of predictors; AIC penalises complexity more aggressively and is preferred for nested-model selection.

Explanation: stringr provides a coherent family of case converters: str_to_lower(), str_to_upper(), str_to_title() (every word capitalised), and str_to_sentence() (first word only). These respect locale rules, so they handle Turkish dotted-I and similar edge cases that the base toupper() mishandles. For cleaning user-entered names always combine with str_squish() to collapse internal whitespace.

Explanation: rownames_to_column() is the bridge from row-name-indexed data frames to tidy tibbles; the inverse is column_to_rownames(). slice_head(n = 5) is the modern, type-safe replacement for head(5) on grouped tibbles, and slice_max(mpg, n = 5) is even cleaner if you do not need to pre-sort. Selecting only the columns the reader cares about before rendering keeps the final memo readable.

Explanation: ggsave() infers the file format from the extension, so .pdf, .png, .svg, and .jpg all just work. Specify width and height explicitly: the defaults match the current graphics device, which is rarely what you want. PDFs are vector-format and infinitely zoomable, the right choice for slide decks and printed reports; PNGs at 300 dpi (dpi = 300) are the right choice for web embeds.