R apply Exercises: 20 Practice Problems on apply, sapply, lapply

Explanation: A data frame is internally a list of columns, so lapply() walks each column and applies mean(). The na.rm = TRUE argument is passed through as the third positional argument to mean() for every column. lapply() always returns a list, which is exactly what a JSON encoder like jsonlite::toJSON() wants. If you used sapply() instead you would get a numeric vector, which can confuse downstream tooling that expects key-value objects.

Explanation: split() returns a named list of data frames keyed by the factor levels of cyl, which is the perfect input for lapply(). The anonymous function lets you parameterize over data without writing a separate helper. The list output is convenient because you can later do lapply(ex_1_2, coef) or lapply(ex_1_2, summary) to dig deeper. A common mistake is passing mtcars to lapply() directly, which iterates over columns, not groups.

Explanation: lapply() preserves the original list's names, which matters here since each key has a meaning (host, port, etc.). Using sapply() would simplify the result into a named character vector of length 4, which loses the list structure that a downstream JSON or YAML writer expects. as.character() knows how to coerce integers, doubles, and logicals, so a single call handles all four element types.

Explanation: Because every column returns a single integer, sapply() simplifies the list of length-1 results into a named integer vector, which is easier to print and easier to index than the lapply list. This is the canonical NA audit pattern. A type-safer variant is vapply(airquality, function(x) sum(is.na(x)), integer(1)), which guarantees the result is integer and fails loudly if any column unexpectedly returns something else.

Explanation: mad() returns one number per column, so sapply() simplifies to a named numeric vector. MAD is preferred over sd() when you suspect outliers; the constant of 1.4826 inside mad() makes it consistent with the standard deviation for normal data. If you want both mad and sd per column you would switch to sapply(USArrests, function(x) c(mad = mad(x), sd = sd(x))), which simplifies to a 2-row matrix.

Explanation: When the function returns a length-N named vector for every column, sapply() stacks the results column-wise into an NxK matrix. The row names come from the names of the returned vector, the column names come from the input. This is the cleanest way to build a small summary table in base R without dplyr. If even one column returned a different-length vector, sapply() would silently fall back to a list, which is a common source of bugs.

Explanation: MARGIN = 1 walks rows; MARGIN = 2 walks columns. For pure row or column sums on numeric matrices, rowSums(scores) and colSums(scores) are faster and clearer, but apply() is the general-purpose tool when the per-row function is anything more complex than a sum or mean. Row names are preserved because the matrix has dimnames.

Explanation: apply() with MARGIN = 2 returns a matrix when each column-wise call returns a vector of equal length. The base R one-liner scale(USArrests) is the canonical way to do this, but the apply() form is worth knowing because it generalizes to non-standard scalers (median centering, robust scaling). The output is a matrix, not a data frame; wrap in as.data.frame() if you need the latter.

Explanation: which.max() returns the index of the first maximum per row, then a vectorized lookup against colnames(scores) translates those indices into subject names. The names()<- assignment restores the student identifiers because indexing dropped them. A common mistake is using max() instead of which.max(), which gives you the score, not the subject. For ties, which.max() returns only the first index, which may or may not be what you want.

Explanation: A two-stage apply pattern: the inner apply() produces a same-shape logical matrix where TRUE marks an outlier cell, and the outer apply() collapses each row with any(). The row with the planted shock (12, -10) in the last position trips equities and fx, so the day is flagged. The 1.5 x IQR rule is Tukey's classic outlier definition; for noisier financial data analysts often widen it to 3 x IQR.

Explanation: mean(is.na(x)) is the cleanest way to compute the NA proportion because is.na() returns a logical vector and mean() of logicals is the fraction TRUE. The template numeric(1) declares the expected return shape: a length-1 double per column. If any column accidentally returned a character or an integer, vapply() would error immediately rather than silently changing the result class, which is exactly the guarantee a production pipeline needs.

Explanation: vapply() with template logical(1) enforces that each column returns a single TRUE or FALSE. all() collapses the named logical vector to a single value. If any column were a factor or character, the result would be FALSE and you could chain to a named printout: names(which(!vapply(mtcars, is.numeric, logical(1)))). Cleaner than sapply() because the type guarantee removes a class assertion step.

Explanation: When the template is numeric(3), vapply() stacks the per-column 3-vectors into a 3xK matrix, with the names of the template becoming row names. The na.rm = TRUE argument keeps the columns with NAs (Ozone, Solar.R) from collapsing to NA. If you changed the template to numeric(2) but the function still returned 3 values, vapply() would error, which is the whole point: shape correctness is enforced.

Explanation: mapply() walks the two vectors in parallel: the first call uses (2, 8), the second (5, 11), and so on. For pure arithmetic on equal-length vectors, the operator form highs - lows + 1 is faster and clearer; the value of mapply() shows up when the per-element operation is non-vectorized (a custom function, a non-vectorized sampler, or a function that needs its own scalar arguments).

Explanation: The arguments to mapply() after the function are matched positionally to rnorm(n, mean, sd). Because each call returns a different-length vector, SIMPLIFY = FALSE is required; otherwise mapply() would try to coerce to a matrix and fall back to a list anyway (but inconsistently). For variable-length parallel iteration, SIMPLIFY = FALSE makes the intent explicit.

Explanation: mapply() zips three input vectors in parallel and applies the per-account compound interest formula. Because the result is a length-1 numeric per call, mapply() simplifies the output to a numeric vector by default. The vectorized equivalent principal * (1 + rate)^years is faster and just as readable here; mapply() becomes essential when the per-account function is more complex (different compounding frequency per account, conditional fee logic, lookup against an external table).

Explanation: tapply() splits the value vector by the factor, applies mean() to each group, and returns a named array. Group order follows the factor levels of Diet (1, 2, 3, 4). For a longer pipeline you would reach for aggregate() or dplyr's summarise(), but tapply() is the most direct base R tool when the output is a single statistic per group.

Explanation: When the per-group function returns a vector longer than 1, tapply() produces a list with one element per group rather than simplifying to an array. The result is easy to bind into a tidy frame with do.call(rbind, ex_6_2) if a 3x3 matrix layout is preferred. This is the base R analogue of dplyr::group_by(Species) |> summarise(...) with multi-value summaries.

Explanation: Passing a list of two factors to tapply() produces a 2-D array; with three factors you would get a 3-D array. Empty combinations (cells with no observations) would come back as NA, which tapply() shows verbatim. This is the fastest way to inspect a factorial design's cell means before fitting an ANOVA with aov(breaks ~ wool * tension, data = warpbreaks).

Explanation: CoV (the ratio of standard deviation to mean) is a unit-free spread measure handy when comparing groups with different means. 5-gear cars have the highest CoV because the group has only 5 observations and a wide mpg range. A common mistake is forgetting to multiply by 100 when reporting CoV as a percentage; the raw ratio is also valid as long as the unit is clearly labeled.