Manipulating Vectors

We often want to select part of vector, rather than working with the whole thing. For example, we may want to overwrite some subset of the vector’s values, or extract part of the vector to use in some other calculation. On this page, we’ll cover methods for accessing and modifying subsets of a vector’s elements.

First, we’ll create a character vector, y, to use in the following examples.

(y <- letters[1:10])
 [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"
Note

The letters object is provided by Base R: we don’t need to create it. letters is a length-26 character vector that contains all the lower-case letters in the English alphabet.

Accessing Vector Elements

We can access specific elements in a vector using the square bracket selection operator, []. To select specific elements, provide an integer vector defining the positions of the desired elements.

# Select the third entry in y
y[3]
[1] "c"
# Select the second through fifth elements of y
y[2:5]
[1] "b" "c" "d" "e"
# Select the fourth, sixth, seventh, and eighth elements of y
y[c(4, 6, 8, 7)]
[1] "d" "f" "h" "g"

Predict: What will the following code print?

This command produces the same result as the previous command (i.e., d, f, g, h). Now, we’re just using a different syntax to define the indexing vector: 4, 6, 7, 8.

When selecting vector elements, we must use a single vector to index the target elements.

y[2, 3]
Error in y[2, 3]: incorrect number of dimensions

Specifying multiple arguments inside [] is reserved for multi-dimensional structures like matrices or data frames and will trigger an error with vectors. If this distinction is confusing, don’t worry. We’ll come back this topic when we discuss matrices in the next tutorial.

Convenience Functions

You can use the head() or tail() functions to select the first or last n elements in a vector.

head(y, n = 2)
[1] "a" "b"
tail(y, n = 3)
[1] "h" "i" "j"

When you supply a negative number for the n argument in head() or tail(), the functions do something special. Can you figure out what’s happening?

Do: Run the following code, and use the results to explain what happens when n is negative.

When you specify a negative value for n, head() still select elements from beginning of the vector, but it defines the subset of selected elements by excluding the specified number of elements from the ending of the vector (rather than including that many elements from the beginning of the vector). Naturally, tail() does the same thing for elements at the end of the vector.

So, in this case:

  • head(y, n = -3) excludes the last 3 entries in y and prints the first 7 entries.
  • tail(y, n = -3) excludes the first 3 entries in y and prints the last 7 entries.

Modifying Vector Elements

Above, we used the selection operator, [], to extract vector elements, but you shouldn’t really think about [] as a “subsetting operator”. I prefer to think about the selection operator as designating some part of a vector for further processing. In the above examples, the further processing was simply printing the selected elements to the R console, but we can also use the [] operator to modify the designated vector elements.

We can overwrite vector elements with new values by selecting the target elements using the [] operator and assigning new values with the ordinary assignment operator, <-.

# Replace the first elements of y with "bob"
y[1] <- "bob"
y
 [1] "bob" "b"   "c"   "d"   "e"   "f"   "g"   "h"   "i"   "j"  
# Replace the fourth and sixth elements of y with "foo" and "bar", respectively
y[c(4, 6)] <- c("foo", "bar")
y
 [1] "bob" "b"   "c"   "foo" "e"   "bar" "g"   "h"   "i"   "j"

Predict: What will the following code print?

x <- 10:21
x[seq(3, 12, 3)] <- 0
x[1:7]
[1] 10 11  0 13 14  0 16
  • The first line generates an integer vector called x that comprises the positive integers between 10 and 21 (inclusive).
  • The second line selects every third element of x and overwrites those values with 0.
    • Note that the selection is based on the position of the element, not the element’s value.
  • The third line prints the fist seven entries of the modified vector.

So, we get the following result.

[1] 10 11  0 13 14  0 16

Recycling Strikes Again

Overwriting vector elements uses ordinary recycling to harmonize the lengths of the selected set of elements and the length of the replacement vector.

y[8:10] <- "alice"
y
 [1] "bob"   "b"     "c"     "foo"   "e"     "bar"   "g"     "alice" "alice"
[10] "alice"
y[1:3] <- c("hello", "world")
Warning in y[1:3] <- c("hello", "world"): number of items to replace is not a
multiple of replacement length
y
 [1] "hello" "world" "hello" "foo"   "e"     "bar"   "g"     "alice" "alice"
[10] "alice"

If the replacement vector is longer than the target vector, any extra elements in the replacement vector are dropped with a warning

y[1:4] <- c("It", "was", "the", "best", "of", "times")
Warning in y[1:4] <- c("It", "was", "the", "best", "of", "times"): number of
items to replace is not a multiple of replacement length
y
 [1] "It"    "was"   "the"   "best"  "e"     "bar"   "g"     "alice" "alice"
[10] "alice"
Practice
  1. Create an integer vector called myVec that contains all the whole numbers from 1 to 11 (inclusive).
  2. Use a single command to replace all the even numbers in myVec with 0.
myVec <- 1:11
myVec[seq(2, 10, 2)] <- 0
myVec
 [1]  1  0  3  0  5  0  7  0  9  0 11
Knowledge Check
  • If y is a length-five numeric vector, what would happen if you tried to run y[2, 3]?
  • When modifying vector elements, if you assign a replacement vector that’s shorter than your selection, what rule does R use to make up the difference?
Ready to Continue?

You’re ready to move on to Matrices if you can:

  • Name the six atomic vector modes, and describe what type of data each mode stores.
  • Generate vectors using c(), :, seq(), and rep().
  • Explain, in your own words, what recycling is, when it happens, and why it can be useful.
  • Select and modify specific elements of a vector using [].

Take the Knowledge Quiz to check your learning.

Back to top