if (condition) { code_if_true } else code_if_false

if (condition) { code_if_true } else { code_if_false }

if condition { code_if_true } else code_if_false

if (condition) code_if_true else { code_if_false }

ifelse() or case_when()

for()

switch()

repeat()

To define a function in R.

To declare variables in R.

To create a loop in R.

The purpose of the switch statement in R is to select and execute code based on the value of an expression.

For loop is used for conditional execution; while loop is for fixed iterations.

For loop requires a condition to start; while loop does not need any condition.

For loop can only iterate over vectors; while loop can iterate over any data type.

For loop iterates a fixed number of times; while loop continues based on a condition.

foreach (i in my_vector) { print(i) }

for (i in my_vector) { print(i) }

for (i = 1; i <= length(my_vector); i++) { print(my_vector[i]) }

for (i in 1:length(my_vector)) { print(i) }

-1

1 2 3 4 5

6

0

Use the 'continue' statement to exit a loop in R.

Use the 'stop' command to terminate a loop in R.

Use the 'exit' function to break out of a loop in R.

Use the 'break' statement to exit a loop in R.

To end the loop immediately.

To repeat the current iteration of the loop.

To skip the current iteration of the loop.

To execute the next statement in the loop.

Use the 'define' keyword followed by the function name and parameters.

Functions are defined using the 'create' command and a list of arguments.

You can define a function by writing 'my_function = function(x) { x^2 }' without the return statement.

Use the 'function' keyword followed by the function name and parameters, e.g., my_function <- function(x) { return(x^2) }.

Scope limited to the entire package.

Global scope accessible anywhere in the script.

Local scope within the function.

Scope only within the same file.

Use a list to return multiple values from a function in R.

Use a data frame to return multiple values from a function in R.

Return values as separate variables without any structure.

Use a vector to return multiple values from a function in R.

Vectorized operations are slower than traditional methods in R.

Vectorized operations require explicit loops for each element.

Vectorized operations in R are operations that apply to entire vectors or arrays simultaneously, improving efficiency and code simplicity.

Vectorized operations only work on single numbers in R.

Vectorized operations are only applicable to numeric data types in R.

They require more memory and increase overhead significantly.

Vectorized operations improve performance in R by allowing simultaneous processing of data, reducing overhead, and leveraging optimized low-level implementations.

Vectorized operations slow down processing by handling data sequentially.

To visualize data in a plot.

To create a new matrix from scratch.

To sort elements in a vector.

To apply a function to rows or columns of a matrix or to elements of a list/data frame.

lapply returns a list, while sapply returns a simplified vector or matrix if possible.

sapply can only be used with data frames, while lapply can be used with any object.

lapply is faster than sapply for large datasets.

lapply and sapply are identical functions in R.

mapply is a function for plotting graphs in R.

mapply applies a function to multiple arguments in a vectorized way.

mapply generates random numbers in a specified range.

mapply is used to create data frames from lists.

Use ifelse(condition, value_if_true, value_if_false) for vectorized conditional operations.

Apply ifelse only to data frames, not vectors.

Use ifelse with only one argument for default values.

Use ifelse(condition) for single value operations.

The return statement ends the function execution and specifies the value to be returned.

The return statement allows for infinite loops within the function.

The return statement is used to print output to the console.

The return statement pauses the function until it is called again.

Ignore errors and continue execution

Use tryCatch(expression, error = function(e) { handle error }, warning = function(w) { handle warning }, finally = { cleanup code })

Use if-else statements to handle errors

Log errors to a file without handling them