R Subsetting Exercises: 20 Practice Problems for Vectors, Lists, and Data Frames

Explanation: Position indexing with c(2, 4) and name indexing with c("science", "history") return the same named numeric vector here. Names survive every subsetting step, which is what makes the second form safer: if anyone reorders scores later, the position call grabs the wrong students while the name call still finds science and history.

Explanation: scores > 85 produces a logical vector aligned with scores, and [ ] keeps only positions where it evaluates TRUE. Negative indexing with -3 drops the third element, and -c(1, 3) drops several at once. Mixing positive and negative indices inside one call is an error in R.

Explanation: The left-hand side of <- accepts the same indexing syntax as the right-hand side, so R rewrites the call as "replace the selected positions with NA". The vector is modified in place rather than rebuilt. This idiom scales to data-cleaning steps where you want to mark bad values without dropping rows.

Explanation: ids %in% c("C103", "C107") returns a logical vector marking matches. Wrapping it in which() converts those TRUE positions to integer indices, which is what you actually need to subset other parallel vectors (transaction amounts, timestamps) that sit alongside ids. Without which() you would still have a logical mask, useful for slicing the same vector but awkward for cross-referencing positions.

Explanation: prefs["theme"] keeps the list wrapper, so the result is still a list of length 1. prefs[["theme"]] unwraps and returns the underlying character vector. If you called nchar() on the first form you would hit an error; on the second it works cleanly. This is the single rule that catches the most beginners with R lists.

Explanation: $name is shorthand for [["name"]] with one extra feature: it does partial matching on names (prefs$font would still work, which is dangerous). Unlike [[]], you cannot pass a variable holding the name to $; you must literally type the field. For programmatic code use [[]]; for quick interactive work, $ is fine.

Explanation: When you pass a length-n vector to [[]], R drills one level per element, so [[c("metrics", "monthly", 3)]] is equivalent to report[["metrics"]][["monthly"]][[3]]. This is the cleanest way to fetch deeply nested data, but it errors hard if any intermediate name is missing. Reach for purrr::pluck() when paths might fail and you want a safe default.

Explanation: $ quietly partial-matches item against items and returns the value, which can mask bugs where a typo in the key would otherwise be caught. [[]] requires exact match by default and returns NULL for a missing key, surfacing the mistake immediately. Set options(warnPartialMatchDollar = TRUE) to get a warning, and prefer [[]] inside package code.

Explanation: A data frame is internally a list of equal-length columns, so all three forms reach the same vector. Use $ for interactive work, [["mpg"]] when the column name lives in a variable, and [, "mpg"] when you want consistent matrix-like notation. For tibbles (not base data frames), [, "mpg"] keeps the tibble wrapper, so the three forms diverge.

Explanation: The first argument inside [ , ] selects rows; the second selects columns. A logical vector for rows must be the same length as nrow(df). A character vector for columns is order-preserving, so output columns appear in the order you listed them, not the original column order. Rownames carry through into the subset by default.

Explanation: Base data frames have drop = TRUE as the default when you ask for a single column, which collapses the result to a bare vector and surprises pipelines that expect a data frame. Setting drop = FALSE preserves the column structure. Tibbles invert this default (a single-column tibble slice stays a tibble), which is one of the main reasons people migrate to tibbles.

Explanation: & is the vectorised AND operator that returns a logical vector the same length as its inputs; && short-circuits and returns a single value, so it would error inside [ , ]. Save the mask to a name when the expression is long: it makes the subset call short and easy to read, and lets you reuse the same mask for parallel slicing of other objects.

Explanation: A matrix is indexed with two arguments inside [ , ]: row first, column second. Leaving an argument empty returns the full dimension. Both numeric and character (when dimnames exist) indexing work, so m["Q2", "East"] returns the same scalar. A single-cell extraction drops the matrix attribute and returns a bare numeric.

Explanation: The default drop = TRUE collapses any dimension of size 1, so a single-column slice becomes a vector and a single-row slice becomes a vector. Setting drop = FALSE keeps the dimension attribute intact. This matters most inside machine-learning pipelines or apply() callbacks where downstream code does dim(x)[1] or solve(x) and silently fails on a bare vector.

Explanation: m[, "North"] returns the North column as a vector; comparing it to 150 produces a logical vector aligned with the rows. Passing that vector as the row index keeps only matching rows. The number of TRUE entries determines nrow() of the result. The same pattern flips for columns: m[, m["Q1", ] > 100] filters columns by the Q1 row.

Explanation: When you pass an n by 2 integer matrix to m[ ] (no comma inside the brackets), R reads each row as an (i, j) pair and returns the value at that cell. This is the canonical way to pull a scattered set of cells in a single call, far cleaner than a loop. The same trick generalises: an n by k index matrix works on a k-dimensional array.

Explanation: $ chaining reads top-down and is fine when every key exists. The recursive [[c(...)]] form does the same drill in a single call and is easier to parameterise: store the path in a character vector and you can extract any field without touching code. Both forms throw a hard error if an intermediate name is missing, so wrap them in tryCatch() if paths might fail.

Explanation: Subset assignment with a name vector recycles the right-hand side across all selected positions. Pass a list on the right to assign different values per slot, like record[...] <- list("X", "Y", "Z"). Use [<- (not [[<-) when writing to multiple slots in one shot. This pattern is the cleanest way to bulk-update a config or redact a record.

Explanation: Assigning NULL via [[<- is the documented way to drop a list element. The list shrinks by one and the surviving names are renumbered. To keep a slot that literally holds NULL (instead of removing it), wrap the value in list(NULL) on the right-hand side. The behaviour of [<- NULL is different and inconsistent, so always use [[<- for deletion.

Explanation: row(mm) and col(mm) return matrices the same shape as mm filled with row and column indices respectively. The comparison row(mm) == col(mm) is a logical matrix that is TRUE only on the main diagonal. Indexing mm with that mask pulls out those cells. diag() is the shortcut; the mask form generalises to off-diagonals (e.g., row(mm) - col(mm) == 1) or any geometric pattern.