ggplot2 Exercises in R: 50 Real-World Practice Problems

Explanation: The two essential pieces of any ggplot call are the data frame and the aesthetic mapping inside aes(). geom_point() consumes those mappings and draws one point per row. You will hit overplotting at 54k points; later exercises fix that with alpha, sampling, or hexbins. Note that wrapping the call in ggplot(...) returns a plot object, so ex_1_1 can be printed, modified with +, or saved.

Explanation: geom_line() connects points in the order they appear on the x-axis, so for time series the x mapping must be a Date, POSIXct, or numeric value, never a character. The economics date column is already Date, so no parsing is needed. If you ever see a "saw-tooth" mess, the cause is usually a string date and you need as.Date() or lubridate::ymd() first.

Explanation: geom_bar() defaults to stat = "count", so passing only an x aesthetic is enough; ggplot tallies rows internally. If you already have a summary table (one row per group with a precomputed count), use geom_col() instead and map both x and y. Mixing them up is the single most common ggplot bug: geom_bar(stat = "identity") is the older equivalent of geom_col().

Explanation: The default bins = 30 is also what ggplot uses if you do not specify it, but it warns you ("Pick better value with binwidth"). Setting it explicitly silences the message and signals intent. For domain-meaningful units use binwidth instead: geom_histogram(binwidth = 2) gives one bar per 2 mpg, which is more interpretable than "30 equal-width bins of unknown size".

Explanation: Mapping Species to color automatically splits the data into groups, computes a separate density for each, and assigns a colour from the discrete palette. If you also wanted shaded fills, map fill = Species and add alpha = 0.4 inside geom_density() so the overlaps remain readable. A common mistake: passing color = "red" inside aes() instead of outside, which creates a fake one-level legend.

Explanation: Boxplots show the 5-number summary plus outliers (points beyond 1.5 * IQR). Class is character here, so ggplot sorts categories alphabetically; if you want them ordered by median, wrap the x mapping in reorder(class, hwy, median). For small samples within a category, a violin (geom_violin()) or strip plot (geom_jitter()) reveals shape better than a box, which only shows quantiles.

Explanation: geom_area() is geom_ribbon() with ymin = 0 baked in; it fills from zero up to y. Use it only when zero is a meaningful baseline (rates, counts, accumulated values). For values that swing positive and negative around an axis, geom_area() distorts perception; switch to geom_line() plus geom_hline(yintercept = 0) instead. Stack multiple series with position = "stack".

Explanation: dose is numeric (0.5, 1, 2), so without factor() ggplot treats it as continuous and tries to draw a single huge violin; wrapping in factor() forces a discrete x scale. Violins beat boxplots when shape matters: bimodality, skew, and gaps are visible in the silhouette but invisible in a 5-number box. Combine the two with geom_violin() + geom_boxplot(width = 0.1) for the best of both.

Explanation: Mappings inside aes() come from columns of the data; constants like color = "blue" belong outside aes(). Petal width and length are the most discriminating iris features, which is why three near-disjoint clusters appear. If clusters overlap heavily, add alpha = 0.6 and try geom_jitter() to nudge points off each other, especially with rounded values.

Explanation: The default position = "stack" stacks bars vertically, which is fine for part-of-whole but hides direct count comparisons between clarities. position = "dodge" (or position_dodge2()) places groups side by side at the cost of taking more horizontal space. With 8 clarities the chart is busy; in practice you would limit to 3 or 4 groups or facet by clarity instead.

Explanation: Size encodes a third numeric variable as area, but human perception of area is weaker than position or length, so reserve size for low-precision context (which car is slowest, not the exact qsec). For values that include zero or negative numbers, scale_size_area() enforces area proportionality. A common cleanup is to widen the range with scale_size(range = c(2, 10)) so small and large bubbles are easier to tell apart.

Explanation: shape only accepts discrete values; mapping a continuous variable triggers the error "A continuous variable can not be mapped to shape". For high-density plots, shape is harder to read than colour because at small sizes a square and a circle look the same. Combine shape with color for accessibility: it stays distinguishable even in print or for colour-blind viewers.

Explanation: scale_color_manual() accepts an unnamed vector (assigned in the order of factor levels) or a named vector like c(Fair = "#999999", ...). Named mappings are safer because reordering the factor will not silently break colours. The values above come from the Okabe-Ito palette, which is colour-blind safe. Always check colour assignment with unique(diamonds$cut) if results look unexpected.

Explanation: ColorBrewer palettes come in three families: qualitative ("Set1", "Dark2", "Paired") for unordered categories, sequential ("Blues", "YlOrRd") for ordered numeric or ordinal, and diverging ("RdBu", "BrBG") for centred values with a meaningful midpoint. Using a sequential palette on unordered categories implies a false ordering; the discrete-vs-ordinal distinction is the most common ColorBrewer mistake.

Explanation: scale_color_gradient() maps a continuous variable to a two-colour ramp; for three colours with a midpoint use scale_color_gradient2(low, mid, high, midpoint = ...). With heavy-tailed values like price the gradient compresses 90% of the data into one end of the ramp. Either log-transform the colour value (color = log(price)) or use scale_color_viridis_c(trans = "log10") so visible variation matches what is interesting.

Explanation: Mapping alpha inside aes() creates a continuous alpha legend, which is rarely what you want. More often you fix alpha for the geom: geom_point(alpha = 0.1) makes all points 10% opaque, so a dense region shows up dark and sparse areas show through, no legend needed. The mapped-vs-fixed distinction applies to every aesthetic and is the most common ggplot beginner trap.

Explanation: Log scales compress the upper end so doubling looks the same anywhere on the axis. They only work for strictly positive data; any zero or negative value drops out with a warning. The default tick spacing on a log scale lands on decades (10, 100, 1000); for finer breaks pass breaks = scales::log_breaks() or use annotation_logticks() for minor ticks between decades.

Explanation: The scales package exposes pre-built label formatters: label_dollar(), label_comma(), label_percent(), label_number(scale = 1e-6, suffix = "M"), label_date(). Pass them as functions, not strings, to the labels argument. The older dollar_format() (without label_) still works but the new API is preferred since scales 1.1. Apply them on the x-axis via scale_x_continuous(labels = ...).

Explanation: scale_x_date() accepts human-readable strings for date_breaks ("1 year", "3 months", "1 week") and strftime format codes for date_labels (%Y 4-digit year, %b abbreviated month, %Y-%m). For datetimes use scale_x_datetime(). Both apply only when the x mapping is already a Date or POSIXct; if your column is character, parse it first with as.Date().

Explanation: Two ways to crop a plot, and they behave differently. xlim() or scale_x_continuous(limits = ...) DROP data outside the range BEFORE statistics are computed, so a histogram's bar heights change. coord_cartesian(xlim = ...) zooms into the rendered space WITHOUT dropping data, so bars keep their full counts. For summaries (smooths, boxplots) the difference is huge; always prefer coord_cartesian() for "I just want to see this range".

Explanation: breaks controls major gridline positions and tick labels; minor_breaks controls the unlabelled lines between them. Pass NULL to remove ticks entirely or use scales::breaks_width(5) for an evenly spaced sequence regardless of range. For dynamic ranges, a function like function(x) seq(floor(x[1]), ceiling(x[2]), by = 5) is more robust than a hard-coded vector.

Explanation: Log-log scales linearise power-law relationships: if y = a * x^b, then log(y) = log(a) + b * log(x) is a straight line with slope b. For diamonds, the slope on log-log is roughly 1.7, telling you that price grows faster than linearly with carat. This is also why per-carat pricing is misleading; doubling size more than doubles cost. Always inspect log-log fits with a geom_smooth(method = "lm") overlay.

Explanation: after_stat() lets you map to a value computed by the stat (here prop, the proportion of each bar). Without group = 1, each cut is in its own group and proportions become 1.0 for every bar (each is 100% of itself). group = 1 tells ggplot to compute proportions relative to the entire dataset. Older versions used ..prop.. syntax which still works but after_stat() is the modern equivalent since ggplot 3.3.

Explanation: Secondary axes in ggplot are NOT independent axes; they are a fixed transformation of the primary axis. The formula ~ (. - 32) * 5/9 converts the primary value (.) to the secondary. Use this for unit conversions (F vs C, USD vs EUR at a fixed rate, raw vs percent of max) but never for two unrelated series, which would mislead readers about correlations. Hadley Wickham notes dual axes in the ggplot book as "a feature of last resort".

Explanation: facet_wrap() arranges panels in a wrappable grid (rows fill first, then wrap to a new column). The formula on the right of ~ is the variable that defines panels. By default scales are shared (scales = "fixed"), so panels are directly comparable. Switch to scales = "free_y" or "free" when ranges differ wildly between groups, but compare with caution: free scales hide differences in absolute level.

Explanation: ncol and nrow control the wrap; specify whichever is more natural for your aspect ratio. With 7 panels and ncol = 4, the last row has only 3 panels and one empty slot. Use as.table = FALSE to flip the panel order (bottom-left first instead of top-left). For dynamic counts where you do not know the layout in advance, leave ncol unset and let ggplot pick a near-square grid.

Explanation: facet_grid() differs from facet_wrap() in two important ways: it always builds a rectangular grid (including empty cells) and the layout is determined by the rows-vs-columns formula rows ~ cols. Use it when both grouping variables matter and you want to compare across rows AND columns; use facet_wrap() when you only have one grouping variable. Pass space = "free_x" to let panel widths vary with x-range so all panels stay readable.

Explanation: The group aesthetic separates lines without colouring them, which keeps the plot clean when there are many lines per facet. scales = "free_y" lets each panel autoscale its y-axis; if you switch to "fixed", the small-weight diets become unreadable because the big-weight diet dominates. Always note the y-axis difference in the caption when using free scales, since visual comparison no longer reflects absolute size.

Explanation: na.rm = TRUE in the geom suppresses the "rows containing missing values" warning, but the rows are still excluded; it is only a message control. Faceting by Month produces strip labels showing the month number; for readable names use factor(Month, labels = month.name[5:9]) in the mapping, or pass a labeller to facet_wrap() (see exercise 4.6). For a year that spans many months, facet_wrap(~ Month, ncol = 3) keeps the layout compact.

Explanation: as_labeller() accepts either a named character vector or a function; the names must match the original factor levels exactly (here as strings since Month is integer). For multi-variable strips use labeller(drv = drive_labs, class = class_labs) with one named vector per variable. The newer label_both() adds both the variable name and value to the strip (e.g. "drv: 4"), which is helpful for self-documenting reports.

Explanation: Small multiples (a 5x7 grid here) are powerful for comparing distributions across two categorical dimensions at once. Watch the panel size: at 35 panels each panel is tiny, so individual bar heights become hard to read. Add theme(axis.text.x = element_text(angle = 90)) to rotate clarity labels, or drop x-axis text entirely with theme(axis.text.x = element_blank()) if the chart is for shape recognition rather than reading.

Explanation: strip.position accepts "top" (default), "bottom", "left", or "right". Side strips ("left", "right") rotate the text 90 degrees by default; control orientation with theme(strip.text.y = element_text(angle = 0)). Bottom strips are useful when the panel title is more meaningful as an x-axis annotation, e.g. when faceting by time period or experimental block.

Explanation: Complete themes wholesale-replace the theme system. The built-ins are theme_grey() (default), theme_bw(), theme_minimal(), theme_classic(), theme_dark(), theme_void(), and theme_light(). Pick one as a base then tweak with theme(...) for individual elements. theme_void() removes everything including axes; useful for treemaps and maps where the axes carry no meaning.

Explanation: angle = 45 rotates the text; hjust = 1 sets horizontal anchor at the END of the string so the label visually attaches to its tick. Without hjust = 1, rotated labels float to the right of their tick and overlap with the next category. For 90-degree rotation use hjust = 1, vjust = 0.5. An alternative for many categories is coord_flip() (or geom_col() + aes(y = manufacturer)) which puts categories on a horizontal axis with no rotation needed.

Explanation: labs() accepts named arguments for every axis title and any plot-level annotation in one call, which is cleaner than chaining ggtitle() + xlab() + ylab(). Aesthetic names also work: labs(color = "Flower species") retitles the legend. Set labs(color = NULL) to drop a legend title entirely. For multi-line titles inside labs(), embed \n: title = "Line 1\nLine 2".

Explanation: annotate() adds a single, hard-coded geom that does NOT inherit from the data; this is the right tool for one-off labels, arrows, or rectangles. Mapping label through aes() would create one label per row, which is rarely what you want. For arrows, use annotate("segment", x, xend, y, yend, arrow = arrow()). For shaded periods use annotate("rect", xmin, xmax, ymin, ymax, alpha = 0.2).

Explanation: vjust = -0.3 pushes labels upward; 0 is "bottom of text on the data point" and negative values move further. For values that risk clipping at the top, add ylim() with extra headroom or use vjust = -0.5 with a coord_cartesian(clip = "off") plus theme margin tweaks. To right-align long labels inside bars instead of above them, swap vjust = -0.3 for vjust = 1.1 so text drops INSIDE the bar at the top.

Explanation: Direct labels remove the need for a legend but suffer from overlap with more than 15-20 points. The ggrepel package's geom_text_repel() (not loaded here) automatically pushes labels apart and adds connector lines, which is the production-grade fix. For static charts where overlap is acceptable, set check_overlap = TRUE inside geom_text() to drop labels that would collide, sacrificing completeness for readability.

Explanation: Pre-ggplot 3.3, titles were positioned relative to the panel (the area inside axes). The new plot.title.position = "plot" option, paired with the same setting for plot.caption.position, anchors them to the whole plotting region. This matches editorial style guides (Economist, FT, New York Times) where titles always start at a consistent left margin regardless of axis label width.

Explanation: Wrapping theme_*() calls in a function is the canonical pattern for organisational style guides; every dashboard imports theme_brand() and the look stays consistent without copy-paste. Always start from a complete theme (theme_minimal, theme_bw) before adding theme(...) tweaks; otherwise you stack overrides on top of theme_grey() and the result fights itself. Document base_size and any font assumptions so downstream users know what dependencies the theme has.

Explanation: legend.position accepts "right" (default), "left", "top", "bottom", or "none". For fine control pass a length-2 numeric vector in [0, 1] coordinates: c(0.8, 0.2) places the legend at 80% across, 20% up the plot. Pair with legend.justification = c(1, 0) to anchor the corner. Multiple legends from different aesthetics stack vertically; use guides(color = guide_legend(nrow = 1)) to keep them on one row.

Explanation: method = "lm" fits a linear model per group; the ribbon is the pointwise 95% confidence interval (not a prediction interval). Drop the ribbon with se = FALSE. For larger datasets the default method = "loess" (or auto-selected "gam" for n > 1000) is more honest because real relationships are rarely linear. Always inspect smooth-line residuals when reading off coefficients from a quick lm overlay.

Explanation: Order matters: draw geom_ribbon() BEFORE geom_line() so the line sits on top of the band. Reversing the order hides the line under the ribbon at the edges. geom_ribbon() needs both ymin and ymax; pass them through aes() so they can come from columns. For forecast charts, the ribbon usually represents predicted standard error from a model object: extract with predict(fit, se.fit = TRUE) and bind to the data before plotting.

Explanation: geom_vline(), geom_hline(), and geom_abline() are special: they accept their position via xintercept/yintercept/slope+intercept outside aes() because they are typically one-off reference lines, not data-driven layers. To draw a vertical line PER GROUP from a data frame, do pass xintercept inside aes() so it maps to a column. For the mean of a grouped variable, pre-compute with group_by() %>% summarise() first.

Explanation: geom_smooth() fits one smoother per group, and faceting creates implicit groups (one per panel). If you want a single shared smoother across all facets, pre-compute predictions and use geom_line() instead. For small panels, the default loess smoothing parameter span = 0.75 is often too wiggly; tighten it with span = 0.9 for a smoother trend or use method = "lm" for straight lines.

Explanation: Lollipops are bar charts with the bar replaced by a thin line and a dot at the tip; they ink less than bars and emphasise the data point itself. The trick is geom_segment() from y = 0 (or any baseline) to yend = avg. Set aes(xend = ..., yend = ...) to give each segment its own endpoints. Cleveland dot plots (geom_point() only, no stem) push this even further by removing the line entirely.

Explanation: Cleveland dot plots are Edward Tufte's recommended replacement for short horizontal bar charts because they use less ink and compare equally well on length. reorder() is the standard idiom for sorting a factor by a numeric value; alternatives include forcats::fct_reorder(class, n) which is more explicit and chainable. Always remove the irrelevant horizontal gridlines so the eye tracks only the dot positions.

Explanation: position = "fill" scales each bar to height 1 so it represents composition rather than count. This is the right tool for "what is the share of X within Y" questions; the absolute counts are hidden by design. To keep counts visible, draw a second geom_bar(position = "stack") plot side by side (the patchwork package handles this) or annotate with geom_text() showing the within-group count.

Explanation: -Inf and Inf as the y bounds tell ggplot to extend to the full plot range whatever it turns out to be; this is the standard trick for full-height annotations that survive zoom and theme changes. Drawing the rectangle BEFORE the line is critical so the line sits on top. Multiple recessions: build a tibble of start/end dates and use geom_rect(data = ..., aes(xmin, xmax), inherit.aes = FALSE) instead of multiple annotate() calls.

Explanation: Dumbbells beat side-by-side bars for two-state comparisons (before vs after, baseline vs treatment) because the connecting segment makes the magnitude of change visible at a glance. The pattern: one geom_segment() for the bar, two geom_point() calls for the endpoints (different colours so direction reads instantly). The ggalt package provides geom_dumbbell() as a one-liner shortcut, but the manual approach gives full control over colours and labels.