Vector Indexing and Slicing in R Programming

Understanding Indexing

• Accessing Elements: Indexing is the process of retrieving specific elements from a vector based on their position (index). In R, indexing starts from 1 (not 0 like in some other languages).

• Square Brackets []: You use square brackets to access elements by their index:
  Code snippet
  my_vector <- c("apple", "banana", "orange", "kiwi")
  
  my_vector[2]       # Accesses "banana" (the second element)
  my_vector[c(1, 3)] # Accesses "apple" and "orange"
  
  

Types of Indexing

1. Positive Indexing: Using positive numbers directly as the index to access elements.

2. Negative Indexing: Using negative numbers to exclude elements. Indexing with '-1' removes the first element, '-2' removes the second, and so on.
   Code snippet
   my_vector[-1]   # Returns all elements except "apple"
   my_vector[-c(1,3)]  # Returns "banana" and "kiwi"
   
   

3. Logical Indexing: Using logical vectors (TRUE/FALSE) to select elements based on conditions.
   Code snippet
   my_numbers <- c(15, 3, 8, 22, 6)
   my_numbers[my_numbers > 10]  # Returns numbers greater than 10
   
   

Slicing

• Extracting Subsets: Slicing allows you to extract a range of consecutive elements from a vector.

• Colon Operator :: The colon operator is used to specify the starting and ending index.
  Code snippet
  my_vector[1:3]  # Returns the first three elements
  
  # Extract last two elements (handy when you don't know vector length)
  my_vector[(length(my_vector) - 1):length(my_vector)]
  
  

Additional Notes

• Modifying Values: You can use indexing to modify values within a vector:
  Code snippet
  my_numbers[2] <- 10   # Replace the second element
  
  

• Vector Recycling: R will recycle shorter vectors when performing operations or comparisons with longer vectors. This means the shorter vector is repeated to match the length of the longer vector.

• Out-of-Bounds Indexing: Be careful of accessing indices outside of the vector's bounds. Attempting to do so will result in an error.

Example

Code snippet

my_vector <- c(10, 20, 5, 30, 15, 8)

# Positive indexing
my_vector[4]             # Access the fourth element (30)

# Negative Indexing
my_vector[-c(2, 5)]      # Returns all elements except the 2nd and 5th

# Logical Indexing
my_vector[my_vector %% 2 != 0]   # Returns odd numbers

# Slicing
my_vector[2:5]           # Returns elements from index 2 to 5

If you have any specific scenarios or additional questions related to indexing and slicing, feel free to ask!

Vector Indexing and Slicing in R Programming¶

In [15]:

my_vector <- c("apple", "banana", "orange", "kiwi")

In [16]:

my_vector

1. 'apple'
2. 'banana'
3. 'orange'
4. 'kiwi'

In [17]:

my_vector[3]

'orange'

In [18]:

my_vector[6]

NA

In [19]:

my_vector[c(1,3)]

1. 'apple'
2. 'orange'

In [20]:

my_vector[-2]

1. 'apple'
2. 'orange'
3. 'kiwi'

In [21]:

my_vector[-c(1,3)]

1. 'banana'
2. 'kiwi'

In [22]:

my_numbers <- c(15, 3, 8, 22, 6)

In [24]:

my_numbers[my_numbers > 10]

1. 15
2. 22

In [25]:

my_numbers[1:3]

1. 15
2. 3
3. 8

In [26]:

my_numbers[3:4]

1. 8
2. 22

In [27]:

my_numbers[- 3:4]

Error in my_numbers[-3:4]: only 0's may be mixed with negative subscripts
Traceback:

In [28]:

length(my_numbers)

5

In [29]:

my_numbers[length(my_numbers)]

6

In [31]:

my_numbers[(length(my_numbers)-1):(length(my_numbers))]

1. 22
2. 6

In [32]:

my_numbers[(length(my_numbers)-2):(length(my_numbers))]

1. 8
2. 22
3. 6

In [33]:

my_numbers

1. 15
2. 3
3. 8
4. 22
5. 6

In [34]:

my_numbers[3]

8

In [35]:

my_numbers[3] =23

In [36]:

my_numbers

1. 15
2. 3
3. 23
4. 22
5. 6

In [37]:

my_numbers[3] -> 23

Error in 23 <- my_numbers[3]: invalid (do_set) left-hand side to assignment
Traceback:

In [39]:

my_numbers[3] <- 25

In [40]:

my_numbers

1. 15
2. 3
3. 25
4. 22
5. 6

In [ ]: