Imagine you need to create a function in R that checks if a number is prime. How would you do this?

  • is_prime <- function(n) { if (n <= 1) { return(FALSE) } for (i in 2:sqrt(n)) { if (n %% i == 0) { return(FALSE) } } return(TRUE) }
  • is_prime <- function(n) { if (n <= 1) { return(TRUE) } for (i in 2:sqrt(n)) { if (n %% i == 0) { return(TRUE) } } return(FALSE) }
  • is_prime <- function(n) { if (n <= 1) { return(FALSE) } for (i in 2:sqrt(n)) { if (n %% i != 0) { return(TRUE) } } return(FALSE) }
  • All of the above
To create a function in R that checks if a number is prime, you can use the following code: is_prime <- function(n) { if (n <= 1) { return(FALSE) } for (i in 2:sqrt(n)) { if (n %% i == 0) { return(FALSE) } } return(TRUE) }. The function takes a number n as input and iterates from 2 to the square root of n, checking if any of these numbers divides n. If a divisor is found, the function returns FALSE; otherwise, it returns TRUE.

Can you describe a situation where you would need to use logical operations in R?

  • Checking conditions in control flow statements
  • Filtering data based on specific criteria
  • Creating boolean variables for flagging
  • All of the above
Logical operations in R are commonly used in situations such as checking conditions in control flow statements, filtering data based on specific criteria, and creating boolean variables for flagging or indicating certain conditions.

The ________ function in R can be used to concatenate strings without any separator.

  • None of the above
  • concat()
  • paste()
  • paste0()
The 'paste0()' function in R can be used to concatenate strings without any separator. For example, 'paste0("Hello", "World")' would return "HelloWorld".

Suppose you're asked to optimize a piece of R code that operates on large lists. What are some strategies you could use to improve its performance?

  • Minimize unnecessary copying of large lists
  • Utilize parallel processing or vectorized operations
  • Preallocate memory for the resulting list
  • All of the above
Some strategies to improve the performance of R code operating on large lists include minimizing unnecessary copying of large lists to reduce memory usage and computational overhead, utilizing parallel processing or vectorized operations to leverage multiple cores and optimize computation, and preallocating memory for the resulting list to avoid dynamic resizing. These strategies can help optimize memory management and computation efficiency.

Suppose you're given a numeric vector in R and asked to calculate its mean. How would you do it?

  • Use the mean() function with the vector as an argument
  • Use the median() function with the vector as an argument
  • Use the sum() function with the vector as an argument
  • Use the mode() function with the vector as an argument
To calculate the mean of a numeric vector in R, you would use the mean() function with the vector as an argument. The mean() function returns the arithmetic average of the values in the vector.

Suppose you're working with a dataset in R and you want to check the data type of a certain variable. How would you do it?

  • Either of the above
  • None of the above
  • Use the class() function
  • Use the typeof() function
Both typeof() and class() functions in R can be used to check the data type of a variable. While typeof() returns the internal storage mode, class() returns the attributes of the object as how it should be treated in context of object-oriented programming.

In R, the _________ function is used to print the output.

  • echo()
  • output()
  • print()
  • show()
The 'print()' function is used in R to print the output to the console. This can be used to display the value of a variable, a message, or the output of a function.

Which data type in R is used to store true/false values?

  • Boolean
  • Character
  • Logical
  • Numeric
In R, true/false values are stored as logical data type. This data type only has two possible values: TRUE and FALSE.

In R, to prematurely exit a while loop, you can use the ______ keyword.

  • break
  • stop
  • exit
  • quit
In R, to prematurely exit a while loop, you can use the 'break' keyword. When the 'break' statement is encountered within the loop's code block, it immediately terminates the loop execution, and the program continues with the next statement after the loop. This allows for early termination of the loop based on certain conditions.

Can you describe a scenario where you would need to use a nested if statement in R?

  • When you have multiple conditions to evaluate and perform different actions based on each condition
  • When you want to optimize performance by avoiding multiple if statements
  • When you need to perform complex calculations with multiple if statements
  • All of the above
A scenario where you would need to use a nested if statement in R is when you have multiple conditions to evaluate and need to perform different actions based on each condition. Nested if statements allow for more complex branching logic and the ability to handle intricate sets of conditions.