**For loop in R**

# Example 1 # print 1, 2, 3...10 for(i in 1:10) { print(i) } # Example 2 # print a, b, c, d x <- c("a", "b", "c", "d") for(i in 1:4) { print(x[i]) }

**Nested for loop
**It is defined as a set of for loops within for loops.

#Example M<- matrix(1:9, ncol=0) Sum<- 0 for (i in seq(nrow(M))) { for (j in seq(ncol(M))) { sum<- sum + M[i,j] print sum } }

**While loop**

Loop runs with condition.

#Example: i<- 1 # When i > =8, loop terminates while ( i< 8) { print i i<- i+1 }

**If statement
**This structure allows you to test a condition and act on it depending on whether

it’s true or false.

#Example # if random number is greater than 3, it will print 10. Otherwise print 0. x <- runif(1, 0, 10) print(x) if(x > 3) { print(10) } else { print(0) }

**Ifelse statement
**This structure is an equivalent form of if else condition but this statement is applied to each element of vector individually.

#Example # Ifelse statement checks each elements of vector and if it's odd, prints are odd number otherwise prints as even. X<- 1:8 Ifelse (x%%2, paste0(x, “ : odd number”), paste0 (x, “ : even number”)

**Next statement
**Next statement is used to skip some iterations.

#Example 1 # next statement skip the first 20 iterations for(i in 1:100) { if(i <= 20) { next } x[i]=i }

**Break statement**

Break is used to exit a loop immediately, regardless of what iteration the loop may be on.

#Example 2 # stop loop after 20 iterations for(i in 1:100) { print(i) if(i > 20) { break } }

**Repeat
**It’s infinite loop and break statement is used to terminate from loop.

**apply
**Returns a vector or array or list of values obtained by applying a function to margins of an array or matrix.

**Lapply**

apply returns a list of the same length as X, each element of which is the result of applying FUN to the corresponding element of X.

**Writing functions in R
**Functions are defined using the function() directive and are stored as R objects just like anythingelse. In particular, they are R objects of class “function”.

#Example 1 func1 <- function() { print("Hello, world!") } f() func1() #Example 2 func2 <- function(num) { for(i in seq_len(num)) { print("Hello, world!") } } f(4)

**Function with return
**return() functions to return a value immediately from a function.

#Example #counting odd numbers from a vector oddcount <- function(x) { return(length(which(x%%2==1))) }

**R Programming Environment
**Environment is a collection of objects.

**Global variables
**Global variables are those variables which exists throughout the execution of a program. It can be changed and accessed from any part of the program.

**Local variables
**Local variables are those variables which exist only within a certain part of a program like a function, and is released when the function call ends.

**Taking input from user**

#Example my.age <- readline(prompt="Enter age: ") # Convert to integer my.age <- as.integer(my.age)

**Recursion
**A function that calls itself.

#Example 1 #Finding factorial - n! = n*(n-1)! recursive.factorial <- function(x) { if (x == 0) return (1) else return (x * recursive.factorial(x-1)) } #Example 2 #The Fibonacci sequenceThe Fibonacci sequence is a series of numbers #where a number is found by adding up the two numbers before it. #Starting with 1, the sequence goes 1, 1, 2, 3, 5, 8, 13, 21, 34. recurse_fibonacci <- function(n) { if(n <= 1) return(n) else return(recurse_fibonacci(n-1) + recurse_fibonacci(n-2)) } for(i in 0:(12-1)) { print(recurse_fibonacci(i)) }

**Algorithm analysis
**An algorithm is evaluated based on following attributes:

◙ Shorter running time

◙ Lesser memory utilization

**Memory management in R
**R allocates memory differently to different objects in its environment. Memory allocation can be determined using the object_size function from the pryr package.

**System runtime in R
**System runtime helps to compare the different algorithms and pick the best algorithm. The microbenchmark package on CRAN is used to evaluate the runtime of any expression/function/code at an accuracy of a sub-millisecond.

**Algorithm asymptotic analysis
**Asymptotic notations are commonly used to determine the complexity in calculating the runtime of an algorithm. Big O (upper bound), Big Omega (lower bound), and Big Theta (average) are the simplest forms offunctional equations, which represent an algorithm’s growth rate or its system runtime.

**Assignment operator
**Assigning an element (numeric, character, complex, or logical) to an object requires a constant amount of time. The asymptote (Big Theta notation) of the assignment operation is θ(1).

**Simple for loop
**The total cost of this for loop is θ(n).

**Nested loop
**The total cost of nested loop is θ(n

^{2}).

**Writing sorting algorithms in R**

**Bubble sort**

Bubble sort is a simple sorting algorithm. This sorting algorithm is comparison-based algorithm in which each pair of adjacent elements is compared and the elements are swapped if they are not in order.

bubblesort <- function(x) { if (length(x) < 2) return (x) # last is the last element to compare with for(last in length(x):2) { for(first in 1:(last - 1)) { if(x[first] > x[first + 1]) { # swap the pair save <- x[first] x[first] <- x[first + 1] x[first + 1] <- save } } } return (x) }

**Quick sort**

Quick sort involves following steps:

◙ Pick an element, called a pivot, from the array.

◙ Partitioning: reorder the array so that all elements with values less than the pivot come before the pivot, while all elements with values greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot is in its final position. This is called the partition operation.

◙ Recursively apply the above steps to the sub-array of elements with smaller values and separately to the sub-array of elements with greater values.

quickSort <- function(vect) { if (length(vect) <= 1) { return(vect) } # Pick an element from the vector element <- vect[1] partition <- vect[-1] # Reorder vector so that integers less than element # come before, and all integers greater come after. v1 <- partition[partition < element] v2 <- partition[partition >= element] # Recursively apply steps to smaller vectors. v1 <- quickSort(v1) v2 <- quickSort(v2) return(c(v1, element, v2)) }