R Beginner Exercises: 30 Hands-on Practice Problems

Explanation: Bare numeric literals default to "numeric" (double precision), even when every value is a whole number. To force the integer type, append L: c(4L, 9L, 16L, 25L, 36L). The distinction matters when you interact with C, Rcpp, or database drivers that care about column types. For most analysis code numeric is the right default.

Explanation: 1:100 produces an integer sequence, ^2 squares each element in place, and sum() collapses the result to a scalar. The whole expression runs in a single C-level loop, which is far faster than an explicit R for loop accumulating into a variable. The closed-form formula n(n+1)(2n+1)/6 confirms the answer: 100 101 201 / 6.

Explanation: %% is the modulo operator; x %% 3 == 0 is a length-50 logical vector that is TRUE on multiples of 3. Combining two such vectors with & gives an element-wise AND, and bracketing keeps the TRUE positions. Use | for OR, and xor() for exclusive OR. This idiom replaces verbose for loops with explicit if checks.

Explanation: sort() returns the values themselves, in this case repeating 410 because there are two ties. If you needed the positions instead, use order(sales, decreasing = TRUE)[1:3], which returns indices. For very large vectors head(sort(...), 3) is no faster than slicing with [1:3]; both still sort the whole vector. A partial sort via sort.int(..., partial = ...) is faster when N is huge.

Explanation: seq_along(x) is safer than 1:length(x) because it returns an empty integer vector when x is empty, whereas 1:length(x) returns c(1, 0) and silently iterates twice. Always prefer seq_along() (or seq_len(n)) inside for loops over 1:length(x). This single substitution prevents the most common off-by-one bug in beginner R code.

Explanation: data.frame() takes named vector arguments; each vector becomes a column. Since R 4.0 character columns are kept as character by default (older R versions auto-converted to factor, which surprised many beginners). All input vectors must share a length or be a length-one recyclable scalar. The tibble equivalent tibble::tibble() skips row names and prints more compactly.

Explanation: dim() returns rows first, columns second, consistent with how R indexes [row, column]. The separate helpers nrow() and ncol() return each piece individually. On a matrix dim() works identically; on a plain vector it returns NULL, so use length() for one-dimensional objects. Always check dimensions before joins or column-wise operations to catch silent shape bugs.

Explanation: Assigning to df$newcol <- value either creates a column or overwrites it in place. The right-hand expression must be either a scalar (which gets recycled) or a vector with the same length as nrow(df). The dplyr equivalent is mutate(mtcars, wt_kg = wt * 453.592), which is friendlier inside a pipe chain. Both produce identical results.

Explanation: rbind() requires that the new row match column names and types. Passing a bare named list or a vector works but is fragile; wrapping in data.frame() is the safest pattern. For repeated appending inside a loop, prefer collecting rows in a list and calling do.call(rbind, list_of_rows) once at the end. dplyr's bind_rows() is more tolerant of missing columns and aligns by name.

Explanation: Factors are stored internally as integer codes with a levels attribute; as.character() looks up each code and returns the label. A common trap is calling as.numeric(factor_var), which returns the underlying integer codes (1, 2, 3), not the original numeric values. To recover the original numbers from a numeric factor, write as.numeric(as.character(factor_var)).

Explanation: Negative integers inside [ , ] mean "exclude these positions". Looking up the position by name with which(names(df) == "carb") is robust if the column order ever changes. A simpler alternative is mtcars[, names(mtcars) != "carb"], which uses a logical vector. dplyr's select(mtcars, -carb) is the cleanest one-liner once you graduate from base R.

Explanation: subset() evaluates its condition in the context of the data frame, so Sepal.Width resolves without iris$. Inside packages and functions this non-standard evaluation can backfire if a column name matches a variable in scope; in those cases prefer iris[iris$Sepal.Width > 3.5, ]. dplyr's filter() is the modern replacement and behaves predictably inside functions when paired with .data$Sepal.Width.

Explanation: %in% returns a logical vector the same length as the left-hand side, with TRUE where the element matches any value in the right-hand set. It is the vector-friendly substitute for chaining == with |: cyl == 4 | cyl == 5 | cyl == 6 becomes cyl %in% c(4, 5, 6). To exclude a set, negate the result with !: !(gear %in% c(4, 5)).

Explanation: Use is.na() to test for NA, never == NA, because any comparison with NA returns NA (not TRUE or FALSE) and the subset silently keeps zero rows. The complement is !is.na(col) for the non-missing rows. For multiple columns, combine with & and | as needed, or use complete.cases(df[, cols]) to check several columns at once.

Explanation: order(x) returns the permutation of indices that would sort x ascending; pass decreasing = TRUE to flip. Multi-key sorting works by passing several vectors: order(cyl, -mpg) sorts by cylinder ascending, breaking ties on descending mpg. sort() sorts the values themselves but does not reorder companion columns, so for tabular data order() is the right tool.

Explanation: sd() in R divides by n minus 1 (sample standard deviation), which is the unbiased estimator. If you actually need the population standard deviation (divide by n), multiply by sqrt((n-1)/n). Naming vector elements with c(name = value, ...) is a fast way to keep labels next to numbers. For multiple columns, sapply(mtcars, function(x) c(mean = mean(x), sd = sd(x))) returns a tidy two-row matrix.

Explanation: Without na.rm = TRUE, even a single NA propagates and the result is NA across the board. The probs argument can take any vector in [0, 1]. R has nine different type options for how interpolation between observed values is done; type = 7 is the default and the only one most users will ever need. For extreme tails on small samples consider a parametric model instead of empirical quantiles.

Explanation: tapply(X, INDEX, FUN) splits X by INDEX and applies FUN to each group. The output is a vector when there is one grouping variable and an array when there are several. The modern equivalent in dplyr is mtcars |> group_by(cyl) |> summarise(mean(mpg)), which returns a tibble instead of a named vector. aggregate() is a halfway alternative that returns a data frame in base R.

Explanation: cor() defaults to Pearson, which measures linear association. For monotonic but non-linear relationships pass method = "spearman". To get a correlation matrix for many columns at once, call cor(mtcars). Correlation does not imply causation, and a correlation near zero only rules out linear association; non-linear dependence can still be strong (think of a parabola, which has Pearson cor ~ 0).

Explanation: Passing two arguments to table() produces a row-by-column matrix; naming each argument labels the dimensions of the output. Wrap the result in prop.table() to convert counts to proportions, and pass margin = 1 (rows) or margin = 2 (columns) to normalize by one axis. For inferential tests, feed the table to chisq.test() or fisher.test() directly.

Explanation: ifelse() is vectorized, evaluating the condition once per element of the input and picking from the matching branch. Nesting it works for three or more buckets but becomes hard to read past three levels. For four or more conditions, dplyr::case_when() is dramatically cleaner because each branch is on its own line, top to bottom, first match wins.

Explanation: Default values are evaluated lazily, only when the parameter is actually used inside the function body. That means a default can reference other parameters: function(x, y = x * 2). Named arguments make calls self-documenting: bmi(weight_kg = 70, height_m = 1.82) is clearer than positional bmi(70, 1.82). Keep the most commonly varied argument first.

Explanation: stop() throws an error and halts execution, which is the right reflex for invalid input that downstream code cannot recover from. Use warning() when the situation is suspicious but the code can continue with sensible defaults, and message() for purely informational text. Catch errors at the call site with tryCatch() if the caller wants to recover; try() is the older, less flexible alternative.

Explanation: repeat has no built-in exit condition, so an explicit break is mandatory. Without one the loop runs forever. repeat is the right choice when the stopping condition depends on values generated inside the body (rejection sampling, retry loops). For known iteration counts use for; for a condition on a quantity computed before each iteration, use while.

Explanation: The inner function "closes over" the count variable from its enclosing environment, preserving state across calls. The double-arrow <<- writes to the parent environment instead of creating a new local binding. Closures are the building block for stateful objects without an OOP system, and they power packages like rlang and purrr. Each call to make_counter() returns an independent counter.

Explanation: Base R turns a factor into its integer codes (1, 2, 3) when you pass it to col, picking colors from the default palette. pch = 19 switches to solid filled circles. Always add a legend() manually because base graphics will not generate one automatically. The ggplot2 alternative aes(color = Species) handles legends automatically and is the right choice when figures need polishing.

Explanation: par(mfrow = c(rows, cols)) splits the plotting region into a grid that fills row by row; par(mfcol = ...) fills column by column instead. Reset to c(1, 1) after the multi-panel block, otherwise subsequent plots inherit the layout and surprise you. For richer arrangements the layout() function supports unequal panel sizes, and patchwork does the same for ggplot2 grobs.

Explanation: pie() accepts a numeric vector of counts and uses its names for labels; passing a table object gives you names for free. Pie charts are notoriously hard for humans to read accurately; for two or more slices a bar chart with barplot() is almost always preferable. Reach for a pie only with two or three slices and when communicating composition is the primary goal.

Explanation: pairs() is the fastest way to spot strong linear relationships and outliers before fitting any model. The function takes either a data frame or a matrix and renders each pair on a separate panel. Coloring by a categorical variable (col = Species) often reveals that an apparent overall correlation is actually a group artifact. GGally::ggpairs() is the ggplot2 cousin with richer panels.

Explanation: matplot() plots each column of a matrix against a common x-axis, perfect for wide-format time series. type = "l" selects lines (use "b" for lines plus points). lty = 1 forces a solid line across all series so they are distinguished only by color, which is usually easier to read than mixing line types. For long-format data, ggplot2::geom_line(aes(group = series, color = series)) is the tidy alternative.