Introduction

The FizzBuzz problem is a classic programming exercise that tests a developer’s ability to think logically and solve a simple but often misunderstood challenge. I have written previously about the FizzBuzz challenge here and here. In this article, we will explore ten creative solutions to the FizzBuzz problem using the R programming language. These solutions will demonstrate different approaches, from basic conditional statements to more advanced techniques, showcasing the versatility and power of R.

Solution 1: Traditional Approach with Conditional Statements:

This solution follows the traditional FizzBuzz approach, utilizing conditional statements to check divisibility and printing the appropriate output.

# Solution 1: Traditional Approach with Conditional Statements
for (i in 1:100) {
  if (i %% 3 == 0 & i %% 5 == 0)
    print("FizzBuzz")
  else if (i %% 3 == 0)
    print("Fizz")
  else if (i %% 5 == 0)
    print("Buzz")
  else
    print(i)
}

[1] 1
[1] 2
[1] "Fizz"
[1] 4
[1] "Buzz"
[1] "Fizz"
[1] 7
[1] 8
[1] "Fizz"
[1] "Buzz"
[1] 11
[1] "Fizz"
[1] 13
[1] 14
[1] "FizzBuzz"
[1] 16
[1] 17
[1] "Fizz"
[1] 19
[1] "Buzz"
[1] "Fizz"
[1] 22
[1] 23
[1] "Fizz"
[1] "Buzz"
[1] 26
[1] "Fizz"
[1] 28
[1] 29
[1] "FizzBuzz"
[1] 31
[1] 32
[1] "Fizz"
[1] 34
[1] "Buzz"
[1] "Fizz"
[1] 37
[1] 38
[1] "Fizz"
[1] "Buzz"
[1] 41
[1] "Fizz"
[1] 43
[1] 44
[1] "FizzBuzz"
[1] 46
[1] 47
[1] "Fizz"
[1] 49
[1] "Buzz"
[1] "Fizz"
[1] 52
[1] 53
[1] "Fizz"
[1] "Buzz"
[1] 56
[1] "Fizz"
[1] 58
[1] 59
[1] "FizzBuzz"
[1] 61
[1] 62
[1] "Fizz"
[1] 64
[1] "Buzz"
[1] "Fizz"
[1] 67
[1] 68
[1] "Fizz"
[1] "Buzz"
[1] 71
[1] "Fizz"
[1] 73
[1] 74
[1] "FizzBuzz"
[1] 76
[1] 77
[1] "Fizz"
[1] 79
[1] "Buzz"
[1] "Fizz"
[1] 82
[1] 83
[1] "Fizz"
[1] "Buzz"
[1] 86
[1] "Fizz"
[1] 88
[1] 89
[1] "FizzBuzz"
[1] 91
[1] 92
[1] "Fizz"
[1] 94
[1] "Buzz"
[1] "Fizz"
[1] 97
[1] 98
[1] "Fizz"
[1] "Buzz"

Solution 2: Vectorized Solution using Modulo Operator:

Leveraging the vectorized capabilities of R, this solution employs the modulo operator to check divisibility for multiple inputs simultaneously, resulting in efficient code.

# Solution 2: Vectorized Solution using Modulo Operator
numbers <- 1:100
result <- ifelse(numbers %% 15 == 0, "FizzBuzz",
         ifelse(numbers %% 3 == 0, "Fizz",
           ifelse(numbers %% 5 == 0, "Buzz", numbers)))
print(result)

  [1] "1"        "2"        "Fizz"     "4"        "Buzz"     "Fizz"    
  [7] "7"        "8"        "Fizz"     "Buzz"     "11"       "Fizz"    
 [13] "13"       "14"       "FizzBuzz" "16"       "17"       "Fizz"    
 [19] "19"       "Buzz"     "Fizz"     "22"       "23"       "Fizz"    
 [25] "Buzz"     "26"       "Fizz"     "28"       "29"       "FizzBuzz"
 [31] "31"       "32"       "Fizz"     "34"       "Buzz"     "Fizz"    
 [37] "37"       "38"       "Fizz"     "Buzz"     "41"       "Fizz"    
 [43] "43"       "44"       "FizzBuzz" "46"       "47"       "Fizz"    
 [49] "49"       "Buzz"     "Fizz"     "52"       "53"       "Fizz"    
 [55] "Buzz"     "56"       "Fizz"     "58"       "59"       "FizzBuzz"
 [61] "61"       "62"       "Fizz"     "64"       "Buzz"     "Fizz"    
 [67] "67"       "68"       "Fizz"     "Buzz"     "71"       "Fizz"    
 [73] "73"       "74"       "FizzBuzz" "76"       "77"       "Fizz"    
 [79] "79"       "Buzz"     "Fizz"     "82"       "83"       "Fizz"    
 [85] "Buzz"     "86"       "Fizz"     "88"       "89"       "FizzBuzz"
 [91] "91"       "92"       "Fizz"     "94"       "Buzz"     "Fizz"    
 [97] "97"       "98"       "Fizz"     "Buzz"

Solution 3: Recursive Function Approach

This solution showcases the elegance of recursion by defining a recursive function that outputs the FizzBuzz sequence.

# Solution 3: Recursive Function Approach
fizzbuzz <- function(n) {
  if (n == 0)
    return()
  fizzbuzz(n - 1)
  if (n %% 3 == 0 & n %% 5 == 0)
    print("FizzBuzz")
  else if (n %% 3 == 0)
    print("Fizz")
  else if (n %% 5 == 0)
    print("Buzz")
  else
    print(n)
}
fizzbuzz(100)

[1] 1
[1] 2
[1] "Fizz"
[1] 4
[1] "Buzz"
[1] "Fizz"
[1] 7
[1] 8
[1] "Fizz"
[1] "Buzz"
[1] 11
[1] "Fizz"
[1] 13
[1] 14
[1] "FizzBuzz"
[1] 16
[1] 17
[1] "Fizz"
[1] 19
[1] "Buzz"
[1] "Fizz"
[1] 22
[1] 23
[1] "Fizz"
[1] "Buzz"
[1] 26
[1] "Fizz"
[1] 28
[1] 29
[1] "FizzBuzz"
[1] 31
[1] 32
[1] "Fizz"
[1] 34
[1] "Buzz"
[1] "Fizz"
[1] 37
[1] 38
[1] "Fizz"
[1] "Buzz"
[1] 41
[1] "Fizz"
[1] 43
[1] 44
[1] "FizzBuzz"
[1] 46
[1] 47
[1] "Fizz"
[1] 49
[1] "Buzz"
[1] "Fizz"
[1] 52
[1] 53
[1] "Fizz"
[1] "Buzz"
[1] 56
[1] "Fizz"
[1] 58
[1] 59
[1] "FizzBuzz"
[1] 61
[1] 62
[1] "Fizz"
[1] 64
[1] "Buzz"
[1] "Fizz"
[1] 67
[1] 68
[1] "Fizz"
[1] "Buzz"
[1] 71
[1] "Fizz"
[1] 73
[1] 74
[1] "FizzBuzz"
[1] 76
[1] 77
[1] "Fizz"
[1] 79
[1] "Buzz"
[1] "Fizz"
[1] 82
[1] 83
[1] "Fizz"
[1] "Buzz"
[1] 86
[1] "Fizz"
[1] 88
[1] 89
[1] "FizzBuzz"
[1] 91
[1] 92
[1] "Fizz"
[1] 94
[1] "Buzz"
[1] "Fizz"
[1] 97
[1] 98
[1] "Fizz"
[1] "Buzz"

Solution 4: Ternary Operators for Concise Code:

By employing the ternary operator, this solution achieves concise code by condensing conditional statements into a single line.

# Solution 4: Ternary Operators for Concise Code
for (i in 1:100)
  print(ifelse(i %% 3 == 0 & i %% 5 == 0, "FizzBuzz",
         ifelse(i %% 3 == 0, "Fizz",
           ifelse(i %% 5 == 0, "Buzz", i))))

[1] 1
[1] 2
[1] "Fizz"
[1] 4
[1] "Buzz"
[1] "Fizz"
[1] 7
[1] 8
[1] "Fizz"
[1] "Buzz"
[1] 11
[1] "Fizz"
[1] 13
[1] 14
[1] "FizzBuzz"
[1] 16
[1] 17
[1] "Fizz"
[1] 19
[1] "Buzz"
[1] "Fizz"
[1] 22
[1] 23
[1] "Fizz"
[1] "Buzz"
[1] 26
[1] "Fizz"
[1] 28
[1] 29
[1] "FizzBuzz"
[1] 31
[1] 32
[1] "Fizz"
[1] 34
[1] "Buzz"
[1] "Fizz"
[1] 37
[1] 38
[1] "Fizz"
[1] "Buzz"
[1] 41
[1] "Fizz"
[1] 43
[1] 44
[1] "FizzBuzz"
[1] 46
[1] 47
[1] "Fizz"
[1] 49
[1] "Buzz"
[1] "Fizz"
[1] 52
[1] 53
[1] "Fizz"
[1] "Buzz"
[1] 56
[1] "Fizz"
[1] 58
[1] 59
[1] "FizzBuzz"
[1] 61
[1] 62
[1] "Fizz"
[1] 64
[1] "Buzz"
[1] "Fizz"
[1] 67
[1] 68
[1] "Fizz"
[1] "Buzz"
[1] 71
[1] "Fizz"
[1] 73
[1] 74
[1] "FizzBuzz"
[1] 76
[1] 77
[1] "Fizz"
[1] 79
[1] "Buzz"
[1] "Fizz"
[1] 82
[1] 83
[1] "Fizz"
[1] "Buzz"
[1] 86
[1] "Fizz"
[1] 88
[1] 89
[1] "FizzBuzz"
[1] 91
[1] 92
[1] "Fizz"
[1] 94
[1] "Buzz"
[1] "Fizz"
[1] 97
[1] 98
[1] "Fizz"
[1] "Buzz"

Solution 5: Utilizing the ifelse() Function:

The ifelse() function in R allows for concise and efficient conditional statements. This solution demonstrates its use to solve the FizzBuzz problem.

# Solution 5: Utilizing the `ifelse()` Function
for (i in 1:100) {
  result <- ifelse(i %% 15 == 0, "FizzBuzz",
              ifelse(i %% 3 == 0, "Fizz",
                ifelse(i %% 5 == 0, "Buzz", i)))
  print(result)
}

[1] 1
[1] 2
[1] "Fizz"
[1] 4
[1] "Buzz"
[1] "Fizz"
[1] 7
[1] 8
[1] "Fizz"
[1] "Buzz"
[1] 11
[1] "Fizz"
[1] 13
[1] 14
[1] "FizzBuzz"
[1] 16
[1] 17
[1] "Fizz"
[1] 19
[1] "Buzz"
[1] "Fizz"
[1] 22
[1] 23
[1] "Fizz"
[1] "Buzz"
[1] 26
[1] "Fizz"
[1] 28
[1] 29
[1] "FizzBuzz"
[1] 31
[1] 32
[1] "Fizz"
[1] 34
[1] "Buzz"
[1] "Fizz"
[1] 37
[1] 38
[1] "Fizz"
[1] "Buzz"
[1] 41
[1] "Fizz"
[1] 43
[1] 44
[1] "FizzBuzz"
[1] 46
[1] 47
[1] "Fizz"
[1] 49
[1] "Buzz"
[1] "Fizz"
[1] 52
[1] 53
[1] "Fizz"
[1] "Buzz"
[1] 56
[1] "Fizz"
[1] 58
[1] 59
[1] "FizzBuzz"
[1] 61
[1] 62
[1] "Fizz"
[1] 64
[1] "Buzz"
[1] "Fizz"
[1] 67
[1] 68
[1] "Fizz"
[1] "Buzz"
[1] 71
[1] "Fizz"
[1] 73
[1] 74
[1] "FizzBuzz"
[1] 76
[1] 77
[1] "Fizz"
[1] 79
[1] "Buzz"
[1] "Fizz"
[1] 82
[1] 83
[1] "Fizz"
[1] "Buzz"
[1] 86
[1] "Fizz"
[1] 88
[1] 89
[1] "FizzBuzz"
[1] 91
[1] 92
[1] "Fizz"
[1] 94
[1] "Buzz"
[1] "Fizz"
[1] 97
[1] 98
[1] "Fizz"
[1] "Buzz"

Solution 6: Functional Programming Approach with purrr Package

Leveraging the power of functional programming, this solution utilizes the map() function from the purrr package to solve the FizzBuzz problem.

# Solution 6: Functional Programming Approach with `purrr` Package
library(purrr)
map(1:100, function(i) {
  if (i %% 3 == 0 & i %% 5 == 0)
    return("FizzBuzz")
  else if (i %% 3 == 0)
    return("Fizz")
  else if (i %% 5 == 0)
    return("Buzz")
  else
    return(i)
})

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] "Fizz"

[[4]]
[1] 4

[[5]]
[1] "Buzz"

[[6]]
[1] "Fizz"

[[7]]
[1] 7

[[8]]
[1] 8

[[9]]
[1] "Fizz"

[[10]]
[1] "Buzz"

[[11]]
[1] 11

[[12]]
[1] "Fizz"

[[13]]
[1] 13

[[14]]
[1] 14

[[15]]
[1] "FizzBuzz"

[[16]]
[1] 16

[[17]]
[1] 17

[[18]]
[1] "Fizz"

[[19]]
[1] 19

[[20]]
[1] "Buzz"

[[21]]
[1] "Fizz"

[[22]]
[1] 22

[[23]]
[1] 23

[[24]]
[1] "Fizz"

[[25]]
[1] "Buzz"

[[26]]
[1] 26

[[27]]
[1] "Fizz"

[[28]]
[1] 28

[[29]]
[1] 29

[[30]]
[1] "FizzBuzz"

[[31]]
[1] 31

[[32]]
[1] 32

[[33]]
[1] "Fizz"

[[34]]
[1] 34

[[35]]
[1] "Buzz"

[[36]]
[1] "Fizz"

[[37]]
[1] 37

[[38]]
[1] 38

[[39]]
[1] "Fizz"

[[40]]
[1] "Buzz"

[[41]]
[1] 41

[[42]]
[1] "Fizz"

[[43]]
[1] 43

[[44]]
[1] 44

[[45]]
[1] "FizzBuzz"

[[46]]
[1] 46

[[47]]
[1] 47

[[48]]
[1] "Fizz"

[[49]]
[1] 49

[[50]]
[1] "Buzz"

[[51]]
[1] "Fizz"

[[52]]
[1] 52

[[53]]
[1] 53

[[54]]
[1] "Fizz"

[[55]]
[1] "Buzz"

[[56]]
[1] 56

[[57]]
[1] "Fizz"

[[58]]
[1] 58

[[59]]
[1] 59

[[60]]
[1] "FizzBuzz"

[[61]]
[1] 61

[[62]]
[1] 62

[[63]]
[1] "Fizz"

[[64]]
[1] 64

[[65]]
[1] "Buzz"

[[66]]
[1] "Fizz"

[[67]]
[1] 67

[[68]]
[1] 68

[[69]]
[1] "Fizz"

[[70]]
[1] "Buzz"

[[71]]
[1] 71

[[72]]
[1] "Fizz"

[[73]]
[1] 73

[[74]]
[1] 74

[[75]]
[1] "FizzBuzz"

[[76]]
[1] 76

[[77]]
[1] 77

[[78]]
[1] "Fizz"

[[79]]
[1] 79

[[80]]
[1] "Buzz"

[[81]]
[1] "Fizz"

[[82]]
[1] 82

[[83]]
[1] 83

[[84]]
[1] "Fizz"

[[85]]
[1] "Buzz"

[[86]]
[1] 86

[[87]]
[1] "Fizz"

[[88]]
[1] 88

[[89]]
[1] 89

[[90]]
[1] "FizzBuzz"

[[91]]
[1] 91

[[92]]
[1] 92

[[93]]
[1] "Fizz"

[[94]]
[1] 94

[[95]]
[1] "Buzz"

[[96]]
[1] "Fizz"

[[97]]
[1] 97

[[98]]
[1] 98

[[99]]
[1] "Fizz"

[[100]]
[1] "Buzz"

Solution 7: Creating a Lookup Table

By creating a lookup table using a data frame or a named vector, this solution simplifies the FizzBuzz logic and enhances code readability.

# Solution 7: Creating a Lookup Table
lookup_table <- data.frame(number = 1:100, result = as.character(1:100))
lookup_table$result[lookup_table$number %% 3 == 0] <- "Fizz"
lookup_table$result[lookup_table$number %% 5 == 0] <- "Buzz"
lookup_table$result[lookup_table$number %% 15 == 0] <- "FizzBuzz"
print(lookup_table$result)

  [1] "1"        "2"        "Fizz"     "4"        "Buzz"     "Fizz"    
  [7] "7"        "8"        "Fizz"     "Buzz"     "11"       "Fizz"    
 [13] "13"       "14"       "FizzBuzz" "16"       "17"       "Fizz"    
 [19] "19"       "Buzz"     "Fizz"     "22"       "23"       "Fizz"    
 [25] "Buzz"     "26"       "Fizz"     "28"       "29"       "FizzBuzz"
 [31] "31"       "32"       "Fizz"     "34"       "Buzz"     "Fizz"    
 [37] "37"       "38"       "Fizz"     "Buzz"     "41"       "Fizz"    
 [43] "43"       "44"       "FizzBuzz" "46"       "47"       "Fizz"    
 [49] "49"       "Buzz"     "Fizz"     "52"       "53"       "Fizz"    
 [55] "Buzz"     "56"       "Fizz"     "58"       "59"       "FizzBuzz"
 [61] "61"       "62"       "Fizz"     "64"       "Buzz"     "Fizz"    
 [67] "67"       "68"       "Fizz"     "Buzz"     "71"       "Fizz"    
 [73] "73"       "74"       "FizzBuzz" "76"       "77"       "Fizz"    
 [79] "79"       "Buzz"     "Fizz"     "82"       "83"       "Fizz"    
 [85] "Buzz"     "86"       "Fizz"     "88"       "89"       "FizzBuzz"
 [91] "91"       "92"       "Fizz"     "94"       "Buzz"     "Fizz"    
 [97] "97"       "98"       "Fizz"     "Buzz"

Solution 8: Functional Reactive Programming with Shiny

This solution showcases the power of Shiny, an R package for web application development, by building an interactive FizzBuzz generator.

# Solution 8: Functional Reactive Programmming with Shiny
library(shiny)

ui <- fluidPage(
  numericInput("n", "Enter a number:", min = 1, max = 100, value = 1),
  verbatimTextOutput("result")
)

server <- function(input, output) {
  output$result <- renderPrint({
    if (input$n %% 3 == 0 & input$n %% 5 == 0)
      return("FizzBuzz")
    else if (input$n %% 3 == 0)
      return("Fizz")
    else if (input$n %% 5 == 0)
      return("Buzz")
    else
      return(input$n)
  })
}

shinyApp(ui, server)

Conclusion:

The FizzBuzz problem provides an excellent opportunity to explore various programming techniques in R, ranging from basic conditional statements to advanced functional programming concepts. By presenting eight diverse solutions, this article aimed to demonstrate the flexibility and creativity that R offers when solving coding challenges. Each approach offers a unique perspective and highlights different aspects of the R language, allowing developers to expand their knowledge and problem-solving skills. Whether you are a beginner or an experienced R programmer, these solutions provide valuable insights into the multiple ways to tackle the FizzBuzz problem in R.