Algorithm Example

Origami Club

Median

• The value that falls in the middle of an ordered sample.

if - else

• if - else - defines both condition under which some code is executed and alternative code to execute

if (<boolean_expression>) {
  <some_code>
} else {
  <some_other_code>
}

a <- c(2, 0, 2, 1)
a <- sort(a)
n <- length(a)
m <- (n + 1) %/% 2
if (n %% 2 == 1) {
  a[m]
} else {
  mean(a[m:(m+1)])
}

[1] 1.5

if - else if - else

• if - else if - ... - else - defines both condition under which some code is executed and several alternatives

if (<boolean_expression>) {
  <some_code>
} else if (<boolean_expression>) {
  <some_other_code>
} else if (<boolean_expression>) {
...
...
} else {
  <some_more_code>
}

mark <- 71
if (mark >= 70) {
  grade <- "I"
} else if (mark >= 60) {
  grade <- "II.1"
} else if (mark >= 50) {
  grade <- "II.2"
} else {
  grade <- "F"
}
grade

[1] "I"

Nesting Conditional Statements

• Conditional statements can be nested within each other
• But consider code legibility 📜, modularity ⚙️ and speed 🏎️

mark <- 65
# Optimising for the most likely condition
if (mark >= 50 && mark < 70) {
  if (mark >= 60) {
    grade <- "II.1"
  } else {
    grade <- "II.2"
  }
} else {
  if (mark >= 70) {
    grade <- "I"
  } else {
    grade <- "F"
  }
}

ifelse() function

• R also provides a vectorized version of if - else construct.
• It takes a vector as an input and returns another vector as an output.
• The 1st argument is an expression that evaluates to a boolean vector.

ifelse(<boolean_expression>, <if_true>, <if_false>)

num <- 1:10
num

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

ifelse(num %% 2 == 0, "even", "odd")

 [1] "odd"  "even" "odd"  "even" "odd"  "even" "odd"  "even" "odd"  "even"

Collections

• Typically, we iterate over existing collections of elements.
• E.g. vectors, lists, data frames, etc.
• But sometimes we need to first create a collection to iterate over.
• Common usecases include generating sequences of indices and preallocating containers.

Generating Sequences with :

• Colon operator : allow to generate sequences of integers.
• We saw those in subsetting, but they are also useful in iteration.

<from>:<to>

1:5

[1] 1 2 3 4 5

# Note that R automatically infers the
# direction of the sequence (increasing or decreasing) 
1:-5

[1]  1  0 -1 -2 -3 -4 -5

Generating Sequences with seq()

• seq() function that we encountered in subsetting can be used in looping.
• It is a generalisation of : that allows to specify the step size.
• As well as its cousins: seq_len() and seq_along()

seq(<from>, <to>, <by>)
seq_len(<length>)
seq_along(<object>)

s <- seq(1, 20, 2)
s

 [1]  1  3  5  7  9 11 13 15 17 19

# seq_len() is equivalent to seq(1, length(<object>))
seq_len(length(s))

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

# seq_along() is equivalent to seq(along.with = <object>)
seq_along(s)

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

# The sequence that you are supplying to seq_along()
# does not have to be numeric
seq_along(letters[1:10])

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

Iteration: break and next

• break - terminates the loop in which it is contained
• next - exits the iteration of a loop in which it is contained

for (i in seq(1, 6)) {
  if (i %% 2 == 0) {
    break
  }
  print(i)
}

[1] 1

for (i in seq(1, 6)) {
  if (i %% 2 == 0) {
    next
  }
  print(i)
}

[1] 1
[1] 3
[1] 5

Infinite Loops

Infinite Loops

• Loops that have no explicit limits for the number of iterations are called infinite.
• They have to be terminated with a break statement (or Ctrl/Cmd-C in interactive session).
• Such loops can be:
  • Unintentional (bug) or
  • Desired (e.g. waiting for user’s input, some event).

i <- 1
while (TRUE) {
  i <- i + 1
  if (i > 10) {
    break
  }
}

i

[1] 11

Iteration: repeat

• repeat - defines code which is executed iteratively until the loop is explicitly terminated
• Is equivalent to while (TRUE).

repeat {
  <some_code>
}

i <- 1
repeat {
  i <- i + 1
  if (i > 10) {
    break
  }
}

i

[1] 11