index.qmd

---
title: "Homework: Fizzbuzz"
author: "Dhanushka Sanjeewa"
format: html
---

Instructions:

-   You can answer the questions below in either R or Python. I will give you 50% extra credit if you provide answers in both languages. Otherwise, please feel free to delete the code chunks corresponding to the language you don't wish to work in.

-   Once you have finished this assignment, render the document (Ctrl/Cmd-Shift-K or the Render button).

-   Commit the qmd file and any other files you have changed to the repository and push your changes.

-   In Canvas, submit a link to your github repository containing the updated files.

# Introduction to Fizzbuzz

The "FizzBuzz Test" is a famous programming interview question.

> Write a program that prints the numbers from 1 to 30. But for multiples of three print "Fizz" instead of the number and for the multiples of five print "Buzz". For numbers which are multiples of both three and five print "FizzBuzz"

Start by filling in the following table for the numbers 1:30 manually, to get a feel for the task.

| Input |     Output    |
|-------|---------------|
| 1     |     1         |
| 2     |     2         |
| 3     |    Fizz       |
| 4     |     4         |
| 5     |    Buzz       |
| 6     |     6         |
| 7     |     7         |
| 8     |     8         |
| 9     |    Fizz       |
| 10    |    Buzz       |
| 11    |     11        |
| 12    |    Fizz       |
| 13    |     13        |
| 14    |     14        |
| 15    | FIzz - Buzz   |
| 16    |     16        |
| 17    |     17        |
| 18    |    Fizz       |
| 19    |     19        |
| 20    |    Buzz       |
| 21    |    Fizz       |
| 22    |     22        |
| 23    |     23        |
| 24    |    Fizz       |
| 25    |    Buzz       |
| 26    |     26        |
| 27    |    Fizz       |
| 28    |     28        |
| 29    |     29        |
| 30    | FIzz - Buzz   |


On paper or using a tool such as <https://excalidraw.com>, create a program flow map for the sequence of if-statements you need to evaluate for fizzbuzz. Add the picture to the folder containing this file, and name the picture flowchart.png. Add the picture to Git and commit/push your changes.

!["Program Flow map for FizzBuzz"](Image/Diagram 01.png)

In the chunk below, write code which will solve this problem for a single value `x`. You should be able to change the value of x at the top of the chunk and still get the correct answer.

**Using R **

```{r solo-fizzbuzz-r, echo = T}
x <- 3

# FizzBuzz code goes here

if (x %% 3 == 0 & x  %% 5 != 0){
  print("Fizz")
}else if (x  %% 3 != 0 & x %% 5 == 0){
  print("Buzz")
}else if (x %% 3 == 0 & x %% 5 ==0){
  print("fizz-buzz")
}else{
  print(x)
}


```
Lets do it in **python** now. 

```{python solo-fizzbuzz-py, echo = T}
x = 3

# FizzBuzz code goes here

if x % 3 == 0 and x % 5 != 0:
  print ("Fizz")
elif x % 3 != 0 and x % 5 == 0:
  print("Buzz")
elif x  % 3 == 0 and x  % 5 == 0:
  print("Fizz-Buzz")
else:
  print( x )

```

Modify the code above so that the result is stored in a value `y`.

**Using R **

```{r solo-fizzbuzz-stored-r, echo = T}
x <- 3
y <- NA
# FizzBuzz code goes here

if (x  %% 3 == 0 & x %% 5 != 0){
  y <- "Fizz"
}else if (x  %% 3 != 0 & x %% 5 ==0){
  y <- "Buzz"
}else if (x %% 3 == 0 & x %% 5 ==0){
  y <- "fizz-buzz"
}else{
  y <- x
}


print(paste("For x = ", x, " my code produces ", y, sep = ""))
```
Lets do it in **python** now. 

```{python solo-fizzbuzz-stored-py, echo = T}
import numpy as np
x = 3
y = np.nan
# FizzBuzz code goes here

if x % 3 == 0 and x % 5 != 0:
  y = "Fizz"
elif x % 3 != 0 and x % 5 == 0:
  y = "Buzz"
elif x % 3 == 0 and x % 5 == 0:
  y = "Fizz-Buzz"
else:
  y = x



print("For x = "+ str(x)+ " my code produces "+ str(y))
```

# A vector of FizzBuzz

The code in the previous problem only solves FizzBuzz for a single value of `x`. Extend your code using a loop so that it will work for all values in a vector `xx`, storing values in a corresponding vector `yy`.

You can copy/paste code from previous chunks to make this chunk easier.

**Using R**

```{r vector-fizzbuzz-r, echo = T}
xx <- 1:30
yy <- rep(NA, times = 30) # create a vector of "NA" with length of xx.

# FizzBuzz code goes here
for (i in 1:length(xx)){
  if (xx[i] %% 3 == 0 & xx[i] %% 5 != 0){
    yy <- replace(yy, i, "Fizz")
  }
  else if (xx[i] %% 5 == 0 & xx[i] %% 3 != 0){
    yy <- replace(yy, i, "Buzz")
  }
  else if (xx[i] %% 3 == 0 & xx[i] %% 5 ==0){
    yy <- replace(yy, i,  "Fizz buzz")
  }
  else{
    z <- xx[i]
    yy <- replace(yy, i, z)
  }
}


# Printing the results in a data frame
res <- cbind(x = xx, result = yy)
res
```
Lets do it in **python** now. 

```{python vector-fizzbuzz-py, echo = T}
import pandas as pd
import numpy as np
xx = np.array(range(30)) + 1
yy = [np.nan]*30 ### create an array of "NA" with length of xx.

# FizzBuzz code goes here

for i in range(0,len(xx)):
    if xx[i] % 3 == 0 and xx[i] % 5 != 0:
        yy[i] = "Fizz"
    elif xx[i] % 5 == 0 and xx[i] % 3 != 0:
        yy[i] = "Buzz"
    elif xx[i] % 5 == 0 and xx[i] % 3 == 0:
        yy[i] = "Fizz-Buzz"
    else:
        yy[i] = xx[i]


# Printing the results in a data frame
res = pd.DataFrame({"x": xx, "result": yy})
res
```

# Functions and FizzBuzz

In the previous question, you extended your fizzbuzz code to iterate through a vector `xx` and produce a result `yy`. Can you generalize this, writing a function `fizzbuzz` that takes a variable `x` and returns a corresponding fizzbuzzified variable? Your function should be able to handle `x` that is a vector or a scalar value, and should store your solution in `yy`.

**Using R**

```{r function-fizzbuzz-r}
xx <- sample(1:100, 10) # get a random xx
yy <- rep(NA, 10)

fizzbuzz <- function(x) {
  # code goes here
  yy = rep(NA, length(x)) # create a vector that has same length as x
  
  for (i in 1:length(x)){
    if (x[i] %% 3 == 0 & x[i] %% 5 != 0){
      yy <- replace(yy, i, "Fizz")
    }
    else if (x[i] %% 5 == 0 & x[i] %% 3 != 0){
      yy <- replace(yy, i, "Buzz")
    }
    else if (x[i] %% 3 == 0 & x[i] %% 5 ==0){
      yy <- replace(yy, i,  "Fizz buzz")
    }
    else{
      z <- x[i]
      yy <- replace(yy, i, z)
    }
  }
  return (yy)
}


yy <- fizzbuzz(x = xx)
yy
# Printing the results in a data frame
res <- cbind(x = xx, result = yy)
res
```
Lets do it in **python** now. 

```{python function-fizzbuzz-py}
import pandas as pd
from random import choices
xx = np.array(choices(range(100), k = 10)) + 1
xx

def fizzbuzz(x):
  y = [np.nan]*len(x) # create a vector with the same length as  input, x
  # code goes here
  for i in range(0,len(x)):
    if x[i] % 3 == 0 and x[i] % 5 != 0:
        y[i] = "Fizz"
    elif x[i] % 5 == 0 and x[i] % 3 != 0:
        y[i] = "Buzz"
    elif x[i] % 5 == 0 and x[i] % 3 == 0:
        y[i] = "Fizz-Buzz"
    else:
        y[i] = x[i]
        
  return y



yy = fizzbuzz(x = xx)

# Printing the results in a data frame
res = pd.DataFrame({"x": xx, "result": yy})
res
```

# Defensive Programming

You cannot always assume that the person using your functions knows what they're doing. Add a check to the function you wrote in the last question so that it will handle non-numeric input by issuing an error message.

In R, you can use the function [`stopifnot()` to halt function execution if there is an error](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/stopifnot); this will give you a basic error message.

```{r stopifnotdemo, error = T}
stopifnot(2 > 3)
```

In Python, you can use a [`try:` statement with a `except:` clause](https://docs.python.org/3/tutorial/errors.html#handling-exceptions). This functions like an if-else statement, where if no error occurs, the except statement is never executed.

```{python tryexceptdemo, error = T}
try: 
  int("hello")
except ValueError: 
  print("Error: could not turn value into an integer")

```

See more examples of this in the [Input Validation](https://srvanderplas.github.io/stat-computing-r-python/part-gen-prog/05-functions.html#input-validation) section of the textbook.

**Using R**

```{r function-error-fizzbuzz-r}
xx <- sample(1:100, 10) # get a random xx
yy <- rep(NA, 10)

fizzbuzz <- function(x) {
  if (is.numeric(x)==FALSE){
    print (" !!! Use integer values in the input vector !!!")
  }
  else {
    x <- round(abs(x))
    # code goes here
    yy <- rep(NA, length(x)) # create a vector that has same length as x
    
    for (i in 1:length(x)){
      if (x[i] %% 3 == 0 & x[i] %% 5 != 0){
        yy <- replace(yy, i, "Fizz")
      }
      else if (x[i] %% 5 == 0 & x[i] %% 3 != 0){
        yy <- replace(yy, i, "Buzz")
      }
      else if (x[i] %% 3 == 0 & x[i] %% 5 ==0){
        yy <- replace(yy, i,  "Fizz buzz")
      }
      else{
        z <- x[i]
        yy <- replace(yy, i, z)
      }
    }
    if ( typeof(x) == "double"){
      cat("Warning : all non-integer numbers were rounded to the nearest integer. \n")
      return(yy)
      
      
    }else {
      
      return(yy)
    }
    
    }
      
}
 

fizzbuzz(x = c(12.0,23,44.0,-15)) ## works for "doubles" if sb accidentally input any. eg: 23.0 will be identified as double

## Lets try to use string input,
x1 = c("12",4, 23,56,27)
fizzbuzz(x =x1) ##  you will get an error msg here. 
cat("\n") # get a new line.

# Printing the results in a data frame
yy <- fizzbuzz(x = xx)
res <- cbind(x = xx, result = yy)
res
```
Lets do it in **python** now. 

```{python function-error-fizzbuzz-py}
## load the relevant packages
import numpy as np
import pandas as pd
from random import choices

# Create an array of 10 random values from 0 to 100
xx = np.array(choices(range(100), k=10)) + 1

def fizzbuzz(x):
    # Check if the data type of x is either float or int
    if x.dtype == "float" or x.dtype == "int":
        x1 = np.round(x).astype(int)
        # Create a list with the same length as input x
        y = [np.nan] * len(x1)
        
        # Apply the Fizz-Buzz logic
        
        for i in range(len(x)):
            if x1[i] % 3 == 0 and x1[i] % 5 != 0:
                y[i] = "Fizz"
            elif x1[i] % 5 == 0 and x1[i] % 3 != 0:
                y[i] = "Buzz"
            elif x1[i] % 5 == 0 and x1[i] % 3 == 0:
                y[i] = "Fizz-Buzz"
            else:
                y[i] = x1[i]
        
        if x.dtype == "float":
            print("Warning : all non-integer numbers were rounded to the nearest integer. \n")
        return y       
        
    else:
        print("All elements in the input array must be numbers.", "\n")
        return None



## try to use the function using a string input.

x1 = np.array(["12",3,54,23])
fizzbuzz(x = x1)

x2 = np.array([12, 34.5,23.6]) ## works for floats too
fizzbuzz(x2)

# Printing the results in a data frame
yy = fizzbuzz(x = xx)
res = pd.DataFrame({"x": xx, "result": yy})
res


```