Iteration

.leftcol30[
<center>
<img src="https://github.com/emse-p4a-gwu/emse-p4a-gwu.github.io/raw/master/images/p4a_hex_sticker.png" width=250>
</center>
]

### <svg aria-hidden="true" role="img" viewBox="0 0 512 512" style="height:1em;width:1em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:white;overflow:visible;position:relative;"><path d="M496 128v16a8 8 0 0 1-8 8h-24v12c0 6.627-5.373 12-12 12H60c-6.627 0-12-5.373-12-12v-12H24a8 8 0 0 1-8-8v-16a8 8 0 0 1 4.941-7.392l232-88a7.996 7.996 0 0 1 6.118 0l232 88A8 8 0 0 1 496 128zm-24 304H40c-13.255 0-24 10.745-24 24v16a8 8 0 0 0 8 8h464a8 8 0 0 0 8-8v-16c0-13.255-10.745-24-24-24zM96 192v192H60c-6.627 0-12 5.373-12 12v20h416v-20c0-6.627-5.373-12-12-12h-36V192h-64v192h-64V192h-64v192h-64V192H96z"/></svg> EMSE 4571: Intro to Programming for Analytics
### <svg aria-hidden="true" role="img" viewBox="0 0 448 512" style="height:1em;width:0.88em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:white;overflow:visible;position:relative;"><path d="M224 256c70.7 0 128-57.3 128-128S294.7 0 224 0 96 57.3 96 128s57.3 128 128 128zm89.6 32h-16.7c-22.2 10.2-46.9 16-72.9 16s-50.6-5.8-72.9-16h-16.7C60.2 288 0 348.2 0 422.4V464c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48v-41.6c0-74.2-60.2-134.4-134.4-134.4z"/></svg> John Paul Helveston
### <svg aria-hidden="true" role="img" viewBox="0 0 448 512" style="height:1em;width:0.88em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:white;overflow:visible;position:relative;"><path d="M0 464c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48V192H0v272zm320-196c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zm0 128c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zM192 268c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zm0 128c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zM64 268c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12H76c-6.6 0-12-5.4-12-12v-40zm0 128c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12H76c-6.6 0-12-5.4-12-12v-40zM400 64h-48V16c0-8.8-7.2-16-16-16h-32c-8.8 0-16 7.2-16 16v48H160V16c0-8.8-7.2-16-16-16h-32c-8.8 0-16 7.2-16 16v48H48C21.5 64 0 85.5 0 112v48h448v-48c0-26.5-21.5-48-48-48z"/></svg> February 10, 2022
]

---

# Quiz 3

## Open RStudio first!

## Rules:

- You may use your notes and RStudio
- You may **not** use any other resources (e.g. the internet, your classmates, etc.)
]

.rightcol[
<br>
<center>
<img src="https://github.com/emse-p4a-gwu/2022-Spring/raw/main/images/quiz_doge.png" width="400">
</center>
]

---

# Notes on common problems in homeworks

### Use `almostEqual()` in test cases with numbers

This could fail on you:

```r
stopifnot(getTheCents(2.45) == 45)
```

Instead, use:

```r
stopifnot(almostEqual(getTheCents(2.45), 45))
```

---

# Notes on common problems in homeworks

<br>

### Check your full script for errors

- Restart R and run your whole code from the top
- **Sequence matters**: Have you called a function before defining it?

---

## Reconsidering productivity

---

# Week 5: .fancy[Iteration]

### 1. for loops
### 2. breaking and skipping

### BREAK

### 3. while loops

---

# Week 5: .fancy[Iteration]

### 1. .orange[for loops]
### 2. breaking and skipping

### BREAK

### 3. while loops

---

# "Flow Control"

### Code that alters the otherwise linear flow of operations in a program.

### Last week:

- `if` statements
- `else` statements

]

### This week:

- `for` loops
- `while` loops
- `break` statements
- `next` statements

]

---

# The `for` loop

### Basic format:

```r
for (item in sequence) {
    # Do stuff with item

# Loop stops after last item
}
```

]]

<img src="images/loop_for.png" width="420">
]

---

# Making a sequence

### (Side note: these are vectors...that's next week - read ahead!)

### Two ways to make a sequence:

### 1. Use the `seq()` function

```r
seq(1, 10)
```

```
#>  [1]  1  2  3  4  5  6  7  8  9 10
```

```r
seq(1, 10, by = 2)
```

```
#> [1] 1 3 5 7 9
```

]]

### 2. Use the `:` operator (step size = 1)

```r
1:10
```

```
#>  [1]  1  2  3  4  5  6  7  8  9 10
```

]]

---

# Quick code tracing

```r
for (i in 1:5) {
    if ((i %% 2) == 0) {
        cat('--')
    } else if ((i %% 3) == 0) {
        cat('----')
    }
    cat(i, '\n')
}
```
]]

---

# Quick code tracing

```r
n <- 6
for (i in seq(n)) {
    cat('|')
    for (j in seq(1, n, 2)) {
        cat('*')
    }
    cat('|', '\n')
}
```
]]

---

## Your turn

1) `sumFromMToN(m, n)`: Write a function that sums the total of the integers between `m` and `n`.<br>**Challenge**: Try solving this without a loop!

- `sumFromMToN(5, 10) == (5 + 6 + 7 + 8 + 9 + 10)`
- `sumFromMToN(1, 1) == 1`

2) `sumOfOddsFromMToN(m, n)`: Write a function that sums every _odd_ integer between `m` and `n`.

- `sumOfOddsFromMToN(4, 10) == (5 + 7 + 9)`
- `sumOfOddsFromMToN(5, 9) == (5 + 7 + 9)`

]

---

# Week 5: .fancy[Iteration]

### BREAK

### 3. while loops
]

---

# Breaking out of a loop

Force a loop to stop with `break`

```r
for (val in 1:5) {
    if (val == 3) {
        break
    }
    cat(val, '\n')
}
```

```
1
2
```
]]

---

# Quick code tracing

What will this code print?

```r
for (i in 1:3) {
    cat('|')
    for (j in 1:5) {
        if (j == 3) {
            break
        }
        cat('*')
    }
    cat('|', '\n')
}
```

]]

---

# Skipping iterations

Skip to the next iteration in a loop with `next`

**Note**: `next` doesn't require `()`

```r
for (val in 1:5) {
    if (val == 3) {
        next
    }
    cat(val, '\n')
}
```

```
1
2
4
5
```
]]

---

# Quick code tracing

What will this code print?

```r
for (i in 1:3) {
    cat('|')
    for (j in 1:5) {
        if (j == 3) {
            next
        }
        cat('*')
    }
    cat('|', '\n')
}
```

]]

---

## Your turn

`sumOfOddsFromMToNMax(m, n, max)`: Write a function that sums every _odd_ integer from `m` to `n` up until the sum is less than or equal to the value `max`. Your solution should use both `break` and `next` statements.

- `sumOfOddsFromMToNMax(1, 5, 4) == (1 + 3)`
- `sumOfOddsFromMToNMax(1, 5, 3) == (1)`
- `sumOfOddsFromMToNMax(1, 5, 10) == (1 + 3 + 5)`

---

# .fancy[Break]

---

# Week 5: .fancy[Iteration]

### BREAK

### 3. .orange[while loops]
]

A friend calls her programmer roommate and said, "while you're out, buy some milk"...

...and she never returned home.

<img src="images/laugh_emoji.png" width="100">
]

---

# The `while` loop

### Basic format:

```r
while (CONDITION) {
    # Do stuff here

# Update condition
}
```

]]

Here's the general idea:

]

---

# Quick code tracing

Consider this function:

```r
f <- function(x) {
    n <- 1
    while (n < x) {
        cat(n, '\n')
        n <- 2*n
    }
}
```

]]

What will this code print?

```r
f(5)
f(10)
f(50)
f(60)
f(64)
```

]]

---

## `for` vs. `while`

### Use `for` loops when the number of iterations is **_known_**.

1. Build the sequence
2. Iterate over it

```r
*for (i in 1:5) { # Define the sequence
    cat(i, '\n')
}
```

```
#> 1 
#> 2 
#> 3 
#> 4 
#> 5
```

]

### Use `while` loops when the number of iterations is **_unknown_**.

1. Define stopping condition
2. Iterate until condition is met

```r
i <- 1
*while (i <= 5) { # Define stopping condition
    cat(i, '\n')
*   i <- i + 1 # Update condition
}
```

```
#> 1 
#> 2 
#> 3 
#> 4 
#> 5
```

]

---

## Your turn: Write functions

1) `isMultipleOf4Or7(n)`

Write a function that returns `TRUE` if `n` is a multiple of 4 or 7 and `FALSE` otherwise.

- `isMultipleOf4Or7(0) == FALSE`
- `isMultipleOf4Or7(1) == FALSE`
- `isMultipleOf4Or7(4) == TRUE`
- `isMultipleOf4Or7(7) == TRUE`
- `isMultipleOf4Or7(28) == TRUE`

]

2) `nthMultipleOf4Or7(n)`

Write a function that returns the nth positive integer that is a multiple of either 4 or 7.

- `nthMultipleOf4Or7(1) == 4`
- `nthMultipleOf4Or7(2) == 7`
- `nthMultipleOf4Or7(3) == 8`
- `nthMultipleOf4Or7(4) == 12`
- `nthMultipleOf4Or7(5) == 14`
- `nthMultipleOf4Or7(6) == 16`

]

---

## Your turn

`isPrime(n)`: Write a function that takes a non-negative integer, `n`, and returns `TRUE` if it is a prime number and `FALSE` otherwise. Here's some test cases:

- `isPrime(1) == FALSE`
- `isPrime(2) == TRUE`
- `isPrime(7) == TRUE`
- `isPrime(13) == TRUE`
- `isPrime(14) == FALSE`

]

`nthPrime(n)`: Write a function that takes a non-negative integer, `n`, and returns the nth prime number, where `nthPrime(1)` returns the first prime number (2). Hint: use the function `isPrime(n)` as a helper function!

- `nthPrime(1) == 2`
- `nthPrime(2) == 3`
- `nthPrime(3) == 5`
- `nthPrime(4) == 7`
- `nthPrime(7) == 17`

]

---

# [HW 5](https://p4a.seas.gwu.edu/2022-Spring/hw5-iteration.html)

- ## Trickier turtles

- ## Read about [Happy Numbers](https://en.wikipedia.org/wiki/Happy_number)