Base R Speed Round: 50 Rapid Drills

Explanation: seq() with by fixes the step size and lets the length fall out of the range. Passing length.out = 5 instead would give the same vector by fixing the count rather than the gap. For plain integer runs the from:to colon operator is shorter, but by is the tool whenever the increment is not 1.

Explanation: The two-element vector recycles to c(10, 100, 10, 100, 10, 100) before the elementwise addition. Recycling is silent only when the longer length is an exact multiple of the shorter; otherwise R still recycles but warns about the partial reuse. Leaning on recycling deliberately is idiomatic, but an accidental length mismatch is a classic silent bug.

Explanation: each = 3 repeats every element three times before moving on, giving blocks; times = 3 would instead cycle the whole vector three times, giving lo hi lo hi lo hi. Knowing which argument produces which layout is the whole point, and rep() also accepts a vector for times to repeat each element a different number of times.

Explanation: The multiplier c(1, -1) recycles across all six positions, so every even index is multiplied by minus one. This pattern-multiplication trick is a compact way to build alternating series without a loop or an ifelse(). The same idea powers alternating-row shading and sign-flipping in series expansions where a (-1)^k term appears.

Explanation: length.out guarantees the vector length and divides the range into equal gaps, here 22.5 apart. This is the counterpart to Exercise 1.1: use by when the step matters and length.out when the number of points matters. It is the standard way to build an evenly spaced grid for plotting a curve or defining axis breaks.

Explanation: Passing a vector of positive positions returns those elements in the order you list them, so x[c(4, 2)] would return 20 10 instead. Positional indexing is the most basic of R's four subsetting styles (positive, negative, logical, and by name), and the others in this section build on it.

Explanation: Negative indices exclude the named positions, and using length(x) for the last one keeps the code general instead of hard-coding 10. You cannot mix positive and negative indices in the same bracket; R raises an error if you try. This trim-the-ends pattern is common when stripping header and footer rows from a raw import.

Explanation: The comparison v > mean(v) (the mean is 5.2 here) returns a logical vector, and subsetting keeps every position that is TRUE. Logical subsetting is the workhorse of base R filtering and scales to data frames as df[df$col > k, ]. Beware that any NA in v produces an NA in the mask, which selects an unwanted NA row unless you guard with !is.na().

Explanation: Name-based indexing returns elements in the order requested and carries the names along, which makes it safer than positions when the underlying order might change. A name that does not exist returns NA with an NA name rather than an error, so a typo fails quietly. This is the vector version of selecting columns by name from a data frame.

Explanation: Subset assignment writes only into the positions the mask selects, so the single scalar 0 recycles across every negative slot. This is the base R way to clip or winsorize values without rebuilding the vector, and it modifies v in place. The vectorized alternative ifelse(v < 0, 0, v) returns a new vector instead of mutating the original.

Explanation: sort() returns the values themselves in order, and decreasing = TRUE avoids the clumsier rev(sort(x)). A key detail is that sort() drops NA values by default; pass na.last = TRUE to keep them. When you need the positions that would sort the vector rather than the sorted values, reach for order() instead, as the next drill shows.

Explanation: order() returns the positions in the order they should be visited, so x[order(x)] reproduces sort(x). Its real power is reordering one object by another: you can sort a whole data frame by a column with df[order(df$col), ]. It also accepts multiple vectors for tie-breaking, sorting by the first then the second, which sort() cannot do.

Explanation: The two thirties would take ranks 3 and 4, so the default ties.method = "average" gives both 3.5. This averaged rank is exactly what a Spearman correlation or a Wilcoxon test uses under the hood. If you need distinct integer ranks instead, pass ties.method = "first" to break ties by original position, or "min" for competition-style ranking.

Explanation: order() returns the row positions in sorted order and the comma in df[rows, ] applies them to every column at once, keeping each row intact. The original row names (2, 1, 3) travel with the rows, which is a useful trace of where each came from; add row.names = NULL or reset them if you want a clean 1-to-n index. This is the base R equivalent of dplyr::arrange().

Explanation: Ordering descending then slicing the first three is the base R "top-n" idiom, and it generalizes to data frames by ordering the rows and taking [1:n, ]. For very large vectors where you only need a few extremes, sort(x, decreasing = TRUE)[1:3] or the partial-sort argument sort(x, partial = ...) avoids fully sorting everything and runs faster.

Explanation: sapply() is the simplifying cousin of lapply(): it walks each element, applies the function, and collapses the results to a vector or matrix when it can, carrying the names through. The convenience comes at a cost: if the per-element results have inconsistent shapes, sapply() silently falls back to a list, which is the pitfall the type-safe vapply() in Exercise 4.3 was built to fix.

Explanation: lapply() always returns a list of the same length as its input, which is exactly what you want when the results might be data frames, models, or vectors of differing lengths that should not be forced into a matrix. It is the safe default for iteration; wrap it in sapply() or unlist() only when you are sure the pieces will simplify cleanly.

Explanation: vapply() behaves like sapply() but demands a FUN.VALUE template, here numeric(1), and throws an error the moment a call returns the wrong type or length. That fail-fast contract makes it the right choice inside functions and pipelines, where sapply() silently returning a list instead of a vector could break downstream code in confusing ways.

Explanation: tapply() splits the first argument by the grouping factor and applies the function to each piece, returning a named result indexed by the group labels. It is the base R workhorse for group-wise summaries, the equivalent of a dplyr::group_by() plus summarise(). For summaries across several grouping variables at once you get a multi-dimensional array, and aggregate() offers a data-frame-shaped alternative.

Explanation: mapply() is the multivariate apply: it iterates over its vector arguments in lockstep, supplying one element from each to the function on every step. Here plain 1:4 * 5:8 would do the same job faster, but mapply() earns its place when the per-pair operation is not itself vectorized, such as calling a function that takes two scalars and returns a computed object.

Explanation: paste0() is paste() with sep = "", and it recycles the scalar "file" and ".txt" against the length-three number vector to produce three strings. This vectorized gluing is how you generate batches of file paths, column names, or labels. When you instead want to collapse a vector into one string, use the collapse argument, as in paste(x, collapse = ", ").

Explanation: sprintf() applies a C-style format template to each element, so %.2f forces two decimal places (padding 1.5 to 1.50 and rounding 23.456 to 23.46) and %% escapes the percent sign. It is the tool of choice when you need aligned, fixed-width, or zero-padded output that paste() and round() cannot produce, such as sprintf("%03d", 7) giving "007".

Explanation: substr() extracts characters between the given start and stop positions and is vectorized, so it applies to every string at once. It also works on the left of an assignment to overwrite that slice in place, as in substr(x, 1, 1) <- "X". When the number of pieces varies by string, reach for strsplit() or regmatches() instead of fixed positions.

Explanation: nchar() returns the length of each string and toupper() maps letters to their capitals, both vectorized character utilities. setNames() is a compact way to attach names to a vector in one expression without a separate names(x) <- line. Its lowercase partner tolower(), and trimws() for stripping surrounding whitespace, round out the everyday base R string toolkit.

Explanation: gsub() with fixed = TRUE treats the pattern as a literal string rather than a regular expression, which is safer and faster when you are matching plain characters like a space. strsplit() returns a list with one character vector per input string, so a single string yields a length-one list; add [[1]] to pull the vector straight out. Using fixed = TRUE throughout sidesteps every regex metacharacter surprise.

Explanation: factor() records the distinct values as levels in alphabetical order by default, which is why the result is a b c rather than the first-seen order b a c. Levels drive how models build contrasts and how plots order categories, so controlling them with the levels argument matters. nlevels() counts them and levels(f) <- ... renames them in place.

Explanation: table() builds a contingency count of each unique value, and the blank first line is the empty name of the (unnamed) dimension. The result is not a plain vector but a table object, which you can feed to prop.table() for proportions or barplot() to chart. Passing two vectors produces a cross-tabulation, the two-way version explored in the next drill.

Explanation: A factor stores integer codes pointing into its levels, so setting the level order deliberately makes as.integer() return meaningful ranks: low is 1, med is 2, high is 3. The classic trap is as.numeric(factor_of_numbers), which returns the codes rather than the original numbers; the safe route there is as.numeric(as.character(f)). Add ordered = TRUE when the levels have a true ranking you want comparisons to respect.

Explanation: Naming the arguments cyl and am labels the table's dimensions, turning a bare grid into a readable cross-tab: rows are cylinder counts, columns are transmission types. This joint count is the starting point for a chi-squared test of association via chisq.test(), and addmargins() appends row and column totals. It reads far better than the unnamed version, whose dimensions print blank.

Explanation: Filtering a factor with f[f != "c"] removes the rows but leaves "c" in the level set, which can produce empty groups in tables, ghost categories in legends, and phantom contrast columns in models. droplevels() rebuilds the factor keeping only the levels that still appear. This cleanup is a routine step after subsetting a data frame that carried more categories than the subset actually uses.

Explanation: The $ operator returns the single element itself, the same as lst[["b"]], whereas single brackets lst["b"] would return a one-element list instead of the value. That distinction (double bracket to drill in, single bracket to keep the list wrapper) is one of the most important habits in base R. Lists are the general container that holds elements of any type and length.

Explanation: unlist() recursively flattens a list into an atomic vector, applying the usual coercion rules if the pieces have different types. It is the natural way to turn an lapply() result back into a plain vector when every element is a scalar. Watch out that it also flattens names into a concatenated form, so pass use.names = FALSE when you want a clean unnamed vector.

Explanation: Because a vector is atomic, c() coerces to the most general type present, and the hierarchy runs logical to integer to double to character. A single string drags the whole vector to character, turning 1 into "1" and TRUE into "TRUE". This silent promotion is a frequent source of bugs when a stray text value sneaks into a numeric column; use a list if you genuinely need to keep mixed types.

Explanation: Taking the mean of a logical vector coerces TRUE to 1 and FALSE to 0, so the average is exactly the proportion of TRUE values, here three out of four. This is the idiomatic base R way to get a rate, as in mean(x > 0) for the share of positive values, while sum() on the same vector would return the raw count of TRUEs instead.

Explanation: Each [["name"]] descends one level, so chaining three of them walks down the nested structure to the leaf value. A shortcut is the recursive form lst[[c("x", "y", "z")]], where a vector of names drills straight through. Nested lists are exactly the shape you get from parsed JSON, so this navigation pattern is essential when working with API responses in base R.

Explanation: matrix() fills down columns by default, so two rows and six values imply three columns, and dim() reports rows then columns. Set byrow = TRUE to fill across rows instead, a frequent need when transcribing a table as written. nrow() and ncol() return the two counts individually if you only want one.

Explanation: With column-first filling, row 1 holds 1, 3, 5 (summing to 9) and row 2 holds 2, 4, 6 (summing to 12). rowSums() and its siblings colSums(), rowMeans(), and colMeans() are compiled C routines, so they run much faster than apply(m, 1, sum) and should be your default for these four common aggregations.

Explanation: t() transposes a matrix, turning rows into columns so a 2-by-3 becomes a 3-by-2. Transposition is fundamental in linear algebra and shows up whenever you need to align dimensions before a matrix product. Applied to a data frame t() coerces it to a matrix first, which silently forces every column to a common type, so use it carefully on mixed-type frames.

Explanation: %*% performs matrix multiplication, taking the dot product of each row with the vector: row 1 gives 1(1) + 3(0) + 5(2) = 11 and row 2 gives 2(1) + 4(0) + 6(2) = 14. The inner dimensions must match (three columns against a length-three vector) or R errors. This operation is the computational core of linear regression, where fitted values are a design matrix times a coefficient vector.

Explanation: apply() iterates over a chosen margin of a matrix, with 1 for rows and 2 for columns, applying the function to each slice. Here the column-wise maxima are 2, 4, and 6. Unlike the specialized rowSums() family, apply() works with any function, which is its strength; the trade-off is that it is slower, so prefer the dedicated helpers when they exist.

Explanation: as.Date() parses the ISO strings into Date objects, and subtracting two dates returns a difftime that prints its units, here 60 days (January's 31 plus February's 29 in the 2024 leap year). Wrap it in as.numeric() to get a bare number for arithmetic. The ISO YYYY-MM-DD format is parsed without a format argument because it is the base R default.

Explanation: A Date is internally the number of days since 1970-01-01, so adding an integer shifts it by that many days and handles month and year boundaries automatically. Thirty days after January 1st is January 31st. This is simpler than string surgery on the date parts, and it means you can build a whole run of dates with as.Date("2024-01-01") + 0:29.

Explanation: weekdays() extracts the day name from a Date, and its companion months() returns the month name. These are handy for grouping a time series by day of week or month without manually formatting strings. The exact spelling follows the session locale, so a non-English locale would return the localized name; format(d, "%A") is the equivalent via a format code.

Explanation: seq() dispatches on the Date class and accepts calendar-aware steps such as "day", "week", "month", and "year", so it advances by whole months even though months differ in length. This is the base R way to build a regular date axis for a report. Using to = instead of length.out = lets you run the sequence to a fixed end date.

Explanation: difftime() computes the gap between two dates in whatever unit you name, so units = "weeks" divides the 365-day span (2024 is a leap year, but December 31st is one day short of a full year from January 1st) by seven to report 52.14286 weeks. Plain date subtraction always returns days, so difftime() is how you switch to weeks, hours, or minutes; wrap it in floor(as.numeric(...)) when you want only the count of whole completed weeks.

Explanation: which.max() returns the position of the first maximum, and because the input is named it carries that name along, so the answer reports wed at position 3. Its partner which.min() finds the smallest. Both are cleaner and faster than which(x == max(x))[1], and they ignore NA by default, which the naive comparison version does not.

Explanation: cumsum() returns a vector of the same length where each element is the sum so far, ideal for running totals, cumulative revenue, or empirical distribution curves. The family includes cumprod() for running products, and cummax() and cummin() for running extremes. Each does in one compiled pass what a manual loop with an accumulator would do far more slowly.

Explanation: ifelse() evaluates the condition for every element and returns the matching value from the yes or no vector, so it recodes a whole vector at once without a loop. It differs from the scalar if () else, which handles a single condition. Watch that ifelse() propagates NA in the test straight to the output, and that it drops attributes like names, which a bracket assignment would preserve.

Explanation: %in% returns a logical vector marking which elements of the left operand occur in the right one, so it is the natural tool for filtering rows whose category is in an allowed set. It is a readable wrapper around match() that returns TRUE or FALSE instead of positions. Unlike ==, it handles many candidate values at once and never triggers surprise recycling.

Explanation: rle() scans for consecutive runs and returns an object with parallel lengths and values vectors, so the "a a b a a a" input becomes runs of 2, 1, and 3. It is invaluable for detecting streaks, gaps, or state changes in a sequence, such as consecutive up-days in a price series. The reverse function inverse.rle() reconstructs the original vector from the encoding.