Why Logical indexing in R Programming? - Purpose & Use Cases

The Big Idea

What if you could instantly grab only the data you want with a simple true or false question?

The Scenario

Imagine you have a long list of numbers and you want to find only the numbers that are bigger than 10. Doing this by checking each number one by one and writing down the ones you want is tiring and slow.

The Problem

Manually checking each item takes a lot of time and you might make mistakes by missing some numbers or writing down wrong ones. It is hard to keep track and update your list if the data changes.

The Solution

Logical indexing lets you quickly pick out the numbers you want by using a simple true or false check. You tell the computer the rule, and it automatically grabs all the numbers that match, saving time and avoiding errors.

Before vs After

✗ Before

result <- c()
for (x in numbers) {
  if (x > 10) {
    result <- c(result, x)
  }
}

✓ After

result <- numbers[numbers > 10]

What It Enables

Logical indexing makes it easy to filter and work with just the data you need, instantly and accurately.

Real Life Example

Think about a teacher who wants to find all students who scored above 80 on a test. Instead of checking each score by hand, logical indexing helps quickly list all those students.

Key Takeaways

Manual checking is slow and error-prone.

Logical indexing uses true/false rules to pick data fast.

This method saves time and reduces mistakes.

Practice

1. What does logical indexing in R do when applied to a vector like v[c(TRUE, FALSE, TRUE)]?

easy

A. Selects elements of v where the index is TRUE

B. Selects elements of v where the index is FALSE

C. Returns the length of v

D. Returns an error because logical vectors cannot index

Solution

1. Step 1: Understand logical indexing

   Logical indexing uses a TRUE/FALSE vector to pick elements from the original vector where TRUE is present.

2. Step 2: Apply logical vector to v

   Elements at positions with TRUE in the logical vector are selected; others are skipped.

3. Final Answer:

   Selects elements of v where the index is TRUE -> Option A

4. Quick Check:

   TRUE picks elements [OK]

Hint: TRUE means pick element, FALSE means skip [OK]

Common Mistakes:

• Thinking FALSE picks elements
• Confusing logical indexing with numeric indexing
• Assuming logical vector length doesn't matter

2. Which of the following is the correct syntax to select elements of vector x where values are greater than 5 using logical indexing?

easy

A. x[> 5]

B. x > 5[x]

C. x[x > 5]

D. x[5 > x]

Solution

1. Step 1: Understand logical condition syntax

   The condition x > 5 creates a logical vector TRUE where elements are greater than 5.

2. Step 2: Use logical vector to index x

   Using x[x > 5] selects elements of x where the condition is TRUE.

3. Final Answer:

   x[x > 5] -> Option C

4. Quick Check:

   Correct logical indexing syntax [OK]

Hint: Put condition inside square brackets after vector [OK]

Common Mistakes:

• Placing condition outside brackets
• Using invalid syntax like x[> 5]
• Swapping operands in condition

3. What is the output of the following R code?

v <- c(10, 3, 7, 2, 9)
v[v >= 7]

medium

A. [1] 10 3 7 2 9

B. [1] 3 2

C. Error: invalid logical indexing

D. [1] 10 7 9

Solution

1. Step 1: Evaluate the logical condition v >= 7

   This creates a logical vector: TRUE, FALSE, TRUE, FALSE, TRUE for elements 10, 3, 7, 2, 9 respectively.

2. Step 2: Select elements where condition is TRUE

   Elements at TRUE positions are 10, 7, and 9.

3. Final Answer:

   [1] 10 7 9 -> Option D

4. Quick Check:

   Only values >= 7 selected [OK]

Hint: Check which elements satisfy condition, pick those [OK]

Common Mistakes:

• Including elements less than 7
• Confusing >= with >
• Expecting an error due to indexing

4. Identify the error in this R code snippet:

nums <- c(4, 8, 15, 16, 23, 42)
nums[nums > 10 & TRUE]

medium

A. No error, code runs correctly

B. Logical vector length mismatch

C. Incorrect use of & with TRUE

D. Syntax error due to missing parentheses

Solution

1. Step 1: Analyze logical condition nums > 10 & TRUE

   The expression nums > 10 returns a logical vector; AND with TRUE keeps it unchanged.

2. Step 2: Check for errors

   The logical vector length matches nums, and syntax is correct, so no error occurs.

3. Final Answer:

   No error, code runs correctly -> Option A

4. Quick Check:

   Logical AND with TRUE keeps vector same [OK]

Hint: AND with TRUE keeps condition unchanged [OK]

Common Mistakes:

• Thinking & TRUE causes error
• Expecting length mismatch error
• Missing that & works element-wise

5. Given a vector temps <- c(23, NA, 19, 25, NA, 21), how can you use logical indexing to select only the non-missing values?

hard

A. temps[is.na(temps)]

B. temps[!is.na(temps)]

C. temps[temps != NA]

D. temps[temps > NA]

Solution

1. Step 1: Understand how to detect missing values

   The function is.na(temps) returns TRUE for missing values (NA) and FALSE otherwise.

2. Step 2: Use logical NOT to select non-missing

   Using !is.na(temps) creates a logical vector TRUE where values are not missing.

3. Step 3: Index temps with this logical vector

   This selects only the non-NA values from temps.

4. Final Answer:

   temps[!is.na(temps)] -> Option B

5. Quick Check:

   Use !is.na() to filter out NA [OK]

Hint: Use !is.na() to pick non-missing values [OK]

Common Mistakes:

• Using temps != NA which is invalid
• Selecting is.na(temps) to get missing values
• Trying to compare with NA using > or <