Conditional execution

suppressPackageStartupMessages(library("tidyverse"))

package 㤼㸱tidyverse㤼㸲 was built under R version 3.6.3

suppressPackageStartupMessages(library("lubridate"))

1. What’s the difference between if and ifelse()? Carefully read the help and construct three examples that illustrate the key differences.

The keyword if tests a single condition, while ifelse() tests each element.

2. Write a greeting function that says “good morning”, “good afternoon”, or “good evening”, depending on the time of day. (Hint: use a time argument that defaults to lubridate::now(). That will make it easier to test your function.)

greet <- function(time = lubridate::now()) {
  hr <- lubridate::hour(time)
  # I don't know what to do about times after midnight,
  # are they evening or morning?
  if (hr < 12) {
    print("good morning")
  } else if (hr < 17) {
    print("good afternoon")
  } else {
    print("good evening")
  }
}
greet()

[1] "good afternoon"

greet(ymd_h("2017-01-08:05"))

[1] "good morning"

greet(ymd_h("2018-01-08:13"))

[1] "good afternoon"

greet(ymd_h("2019-01-08:20"))

[1] "good evening"

3. Implement a fizzbuzz() function. It takes a single number as input. If the number is divisible by three, it returns “fizz”. If it’s divisible by five it returns “buzz”. If it’s divisible by three and five, it returns “fizzbuzz”. Otherwise, it returns the number. Make sure you first write working code before you create the function.

We can use modulo operator, %%, to check divisibility. The expression x %% y returns 0 if y divides x.

1:10 %% 3 == 0

 [1] FALSE FALSE  TRUE FALSE FALSE  TRUE FALSE FALSE  TRUE FALSE

A more concise way of checking for divisibility is to note that the not operator will return TRUE for 0, and FALSE for all non-zero numbers. Thus, !(x %% y), will check whether y divides x.

!(1:10 %% 3)

 [1] FALSE FALSE  TRUE FALSE FALSE  TRUE FALSE FALSE  TRUE FALSE

There are four cases to consider:

1. If x is divisible by 3 and 5, then return “fizzbuzz”.
2. If x is divisible by 3 and not 5, then return “fizz”.
3. If x is divisible by 5 and not 3, then return “buzz”.
4. Otherwise, which is the case in which x is not divisible by either 3 or 5, return x.

The key to answering this question correctly, is to first check whether x is divisible by both 3 and 5. If the function checks whether x is divisible by 3 or 5 before considering the case that the number is divisible by both, then the function will never return “fizzbuzz”.

fizzbuzz <- function(x) {
  # these two lines check that x is a valid input
  stopifnot(length(x) == 1)
  stopifnot(is.numeric(x))
  if (!(x %% 3) && !(x %% 5)) {
    "fizzbuzz"
  } else if (!(x %% 3)) {
    "fizz"
  } else if (!(x %% 5)) {
    "buzz"
  } else {
    # ensure that the function returns a character vector
    as.character(x)
  }
}
fizzbuzz(6)

[1] "fizz"

fizzbuzz(10)

[1] "buzz"

fizzbuzz(15)

[1] "fizzbuzz"

fizzbuzz(2)

[1] "2"

This function can be slightly improved by combining the first two lines conditions so we only check whether x is divisible by 3 once.

fizzbuzz2 <- function(x) {
  # these two lines check that x is a valid input
  stopifnot(length(x) == 1)
  stopifnot(is.numeric(x))
  if (!(x %% 3)) {
    if (!(x %% 5)) {
      "fizzbuzz"
    } else {
      "fizz"
    }
  } else if (!(x %% 5)) {
    "buzz"
  } else {
    # ensure that the function returns a character vector
    as.character(x)
  }
}
fizzbuzz2(6)

[1] "fizz"

fizzbuzz2(10)

[1] "buzz"

fizzbuzz2(15)

[1] "fizzbuzz"

fizzbuzz2(2)

[1] "2"

Instead of only accepting one number as an input, we could a FizzBuzz function that works on a vector. The case_when() function vectorizes multiple if-else conditions, so is perfect for this task. In fact, fizz-buzz is used in the examples in the documentation of case_when().

fizzbuzz_vec <- function(x) {
  case_when(
    !(x %% 3) & !(x %% 5) ~ "fizzbuzz",
    !(x %% 3) ~ "fizz",
    !(x %% 5) ~ "buzz",
    TRUE ~ as.character(x)
  )
}
fizzbuzz_vec(c(0, 1, 2, 3, 5, 9, 10, 12, 15))

[1] "fizzbuzz" "1"        "2"        "fizz"     "buzz"     "fizz"     "buzz"     "fizz"    
[9] "fizzbuzz"

The following function is an example of a vectorized FizzBuzz function that only uses bracket assignment.

fizzbuzz_vec2 <- function(x) {
  y <- as.character(x)
  # put the individual cases first - any elements divisible by both 3 and 5
  # will be overwritten with fizzbuzz later
  y[!(x %% 3)] <- "fizz"
  y[!(x %% 3)] <- "buzz"
  y[!(x %% 3) & !(x %% 5)] <- "fizzbuzz"
  y
}
fizzbuzz_vec2(c(0, 1, 2, 3, 5, 9, 10, 12, 15))

[1] "fizzbuzz" "1"        "2"        "buzz"     "5"        "buzz"     "10"       "buzz"    
[9] "fizzbuzz"

This question, called the “Fizz Buzz” question, is a common programming interview question used for screening out programmers who can’t program.

4. How could you use cut() to simplify this set of nested if-else statements?

if (temp <= 0) {
  "freezing"
} else if (temp <= 10) {
  "cold"
} else if (temp <= 20) {
  "cool"
} else if (temp <= 30) {
  "warm"
} else {
  "hot"
}

How would you change the call to cut() if I’d used < instead of <=? What is the other chief advantage of cut() for this problem? (Hint: what happens if you have many values in temp?)

temp <- seq(-10, 50, by = 5)
cut(temp, c(-Inf, 0, 10, 20, 30, Inf),
  right = TRUE,
  labels = c("freezing", "cold", "cool", "warm", "hot")
)

 [1] freezing freezing freezing cold     cold     cool     cool     warm     warm     hot     
[11] hot      hot      hot     
Levels: freezing cold cool warm hot

To have intervals open on the left (using <), I change the argument to right = FALSE,

temp <- seq(-10, 50, by = 5)
cut(temp, c(-Inf, 0, 10, 20, 30, Inf),
  right = FALSE,
  labels = c("freezing", "cold", "cool", "warm", "hot")
)

 [1] freezing freezing cold     cold     cool     cool     warm     warm     hot      hot     
[11] hot      hot      hot     
Levels: freezing cold cool warm hot

Two advantages of using cut is that it works on vectors, whereas if only works on a single value, and that to change comparisons I only needed to change the argument to right, but I would have had to change four operators in the if expression.

5. What happens if you use switch() with numeric values?

In switch(n, ...), if n is numeric, it will return the nth argument from .... This means that if n = 1, switch() will return the first argument in ..., if n = 2, the second, and so on. For example,

switch(1, "apple", "banana", "cantaloupe")

[1] "apple"

switch(2, "apple", "banana", "cantaloupe")

[1] "banana"

If you use a non-integer number for the first argument of switch(), it will ignore the non-integer part.

switch(1.2, "apple", "banana", "cantaloupe")

[1] "apple"

switch(2.8, "apple", "banana", "cantaloupe")

[1] "banana"

Note that switch() truncates the numeric value, it does not round to the nearest integer. While it is possible to use non-integer numbers with switch(), you should avoid it

6. What does this switch() call do? What happens if x is "e"?

x <- "e"
switch(x,
  a = ,
  b = "ab",
  c = ,
  d = "cd"
)

Experiment, then carefully read the documentation.

First, let’s write a function switcheroo(), and see what it returns for different values of x.

switcheroo <- function(x) {
  switch(x,
    a = ,
    b = "ab",
    c = ,
    d = "cd"
  )
}
switcheroo("a")

[1] "ab"

switcheroo("b")

[1] "ab"

switcheroo("c")

[1] "cd"

switcheroo("d")

[1] "cd"

switcheroo("e")
switcheroo("f")

The switcheroo() function returns "ab" for x = "a" or x = "b", "cd" for x = "c" or x = "d", and NULL for x = "e" or any other value of x not in c("a", "b", "c", "d").

How does this work? The switch() function returns the first non-missing argument value for the first name it matches. Thus, when switch() encounters an argument with a missing value, like a = ,, it will return the value of the next argument with a non missing value, which in this case is b = "ab". If object in switch(object=) is not equal to the names of any of its arguments, switch() will return either the last (unnamed) argument if one is present or NULL. Since "e" is not one of the named arguments in switch() (a, b, c, d), and no other unnamed default value is present, this code will return NULL.

The code in the question is shorter way of writing the following.

switch(x,
  a = "ab",
  b = "ab",
  c = "cd",
  d = "cd",
  NULL # value to return if x not matched
)

NULL