``````#######################################################################
# Given the following parallel vectors answer the questions below
#######################################################################

# The following are parallel vectors

students <- c("joe",    "sue",      "al",     "anne",      "esther", "bob",    "larry",    "carla")
gender   <- c("m",      "f",        "m",      "f",         "f",      "m",      "m",        "f")
year     <- c("senior", "freshman", "senior", "sophomore", "senior", "senior", "freshman", "sophomore")
test1    <- c(85,        82,         70,        95,         93,       100,       39,       90)
test2    <- c(95,        60,         75,        92,         93,       90,        68,       80)
test3    <- c(100,       69,         79,        81,         93,       80,        89,       82)
honors   <- c(TRUE,     FALSE,      FALSE,     TRUE,       FALSE,    FALSE,      FALSE,    TRUE)
homeState<- c("ca",     "nj",       "wa",      "ny",       "ny",     "ca",       "nj",     "wa")
major    <- c("fin",    NA,         "acc",     NA,         "mar",    "acc",      "acc",    "fin")

#-----------------------------------------------------------------------------------
# Answer the questions below by writing R commands to calculate the answers.
# The answers should still be correct even if the actual values in the vectors change.
# You can assume that there are no NA values in the data EXCEPT for in the vector, major
# If a student hasn't declared a major yet, the entry in the major vector is NA.
#-----------------------------------------------------------------------------------``````

## 41.1 QUESTION 1

``````#-----------------------------------------------------------------------------------
# QUESTION 1
# Show the number of grades on test1 that were below 70
#-----------------------------------------------------------------------------------``````
``sum( test1 < 70 )``
``[1] 1``

## 41.2 QUESTION 2

``````#-----------------------------------------------------------------------------------
# QUESTION 2
# Show the number of grades below 70 on any of the tests
#-----------------------------------------------------------------------------------``````
``sum(c ( test1<70, test2<70, test3<70) )``
``[1] 4``

## 41.3 QUESTION 3

``````#-----------------------------------------------------------------------------------
# QUESTION 3
# Show the percent of seniors who are from NY
#-----------------------------------------------------------------------------------``````
``sum(year == "senior" & homeState == "ny") / sum(year == "senior")``
``[1] 0.25``

## 41.4 QUESTION 4

``````#-----------------------------------------------------------------------------------
# QUESTION 4
# Show the number of students who have not yet declared a major (i.e. major is NA)
#-----------------------------------------------------------------------------------``````
``sum ( is.na(major) )``
``[1] 2``

## 41.5 QUESTION 5

``````#-----------------------------------------------------------------------------------
# QUESTION 5
# Show the number of students
#-----------------------------------------------------------------------------------``````
``length (students)   # or length(ANY_OF_THE_VECTORS)``
``[1] 8``

## 41.6 QUESTION 6

``````#-----------------------------------------------------------------------------------
# QUESTION 6
# Show the names of the students who scored at least 5 points above average on test1
# test1
#-----------------------------------------------------------------------------------``````
``students[ test1 >= mean(test1) + 5]``
``[1] "anne"   "esther" "bob"    "carla" ``

## 41.7 QUESTION 7

``````#-----------------------------------------------------------------------------------
# QUESTION 7
# Show the names of the students who scored at least 5 points above average on test1
# and also on test2
#-----------------------------------------------------------------------------------``````
``students[ test1 >= mean(test1) + 5 & test2 >= mean(test2) + 5]``
``[1] "anne"   "esther" "bob"   ``

## 41.8 QUESTION 8

``````#-----------------------------------------------------------------------------------
# QUESTION 8
# Show the names of the students who scored at least 5 points above average
# on either test1 or test2
#-----------------------------------------------------------------------------------``````
``students[ test1 >= mean(test1) + 5 | test2 >= mean(test2) + 5]``
``[1] "joe"    "anne"   "esther" "bob"    "carla" ``

## 41.9 QUESTION 9

``````#-----------------------------------------------------------------------------------
# QUESTION 9
# Show the names of the male students
# who scored at least 5 points above average on either test1 or on test2
#-----------------------------------------------------------------------------------``````
``students[ gender == "m" & (test1 >= mean(test1) + 5 | test2 >= mean(test2) + 5)]``
``[1] "joe" "bob"``

## 41.10 QUESTION 10

``````#-----------------------------------------------------------------------------------
# QUESTION 10
# Show the number of accounting (acc) majors.
#
# NOTE: Be careful - some of the entries in the majors vector are NA.
#-----------------------------------------------------------------------------------``````
``sum( major == "acc" & !is.na(major))``
``[1] 3``

## 41.11 QUESTION 11

``````#-----------------------------------------------------------------------------------
# QUESTION 11
# Show the number of students who have NOT declared that
# they are acc majors (this includes students who have not yet declared a major).
#
# NOTE: Be careful - some of the entries in the majors vector are NA.
#-----------------------------------------------------------------------------------``````
``sum ( major != "acc" | is.na(major))``
``[1] 5``

## 41.12 QUESTION 12

``````#-----------------------------------------------------------------------------------
# QUESTION 12
# Show the percent of the students who have declared that they are acc majors.
#
# NOTE: Be careful - some of the entries in the majors vector are NA.
#-----------------------------------------------------------------------------------``````
``````# ANSWER
mean( major=="acc" & !is.na(major) )``````
``[1] 0.375``
``````# ANOTHER ANSWER
sum(major == "acc" & !is.na(major)) / length(major)``````
``[1] 0.375``

## 41.13 QUESTION 13

``````#-----------------------------------------------------------------------------------
# QUESTION 13
# Show the percent of the seniors who have declared that they are acc majors.
#
#
# NOTE: Be careful - some of the entries in the majors vector are NA.
#-----------------------------------------------------------------------------------``````
``sum(major == "acc" & !is.na(major) & year == "senior") / sum(year == "senior")``
``[1] 0.5``

## 41.14 QUESTION 14

``````#-----------------------------------------------------------------------------------
# QUESTION 14
# Write code to show the names of the students who continually got lower grades.
# ie test1 was the highest and test3 was the lowest grade
#-----------------------------------------------------------------------------------``````
``students [ test1 > test2 & test2 > test3 ]``
``[1] "anne" "bob" ``

## 41.15 QUESTION 15

``````#-----------------------------------------------------------------------------------
# QUESTION 15
# Show the students who got 100 on all three tests
#-----------------------------------------------------------------------------------``````
``````# Note - When you run the command below using the data above, the
# result is "character(0)".  This simply means that R is returning a character vector
# that has zero entries. This is because in the data above, no one got 100 on all
# three tests. R reports this by showing "character(0)" as the result.
#
# The code WOULD produce the name of any student who got 100 on all 3 tests.
# This is the correct answer since the code should work even if the actual
# data is different. If you want to check this you can add a new student whose
# test grades are all 100 or change the test grades for one or more of the students.

students [  test1==100 & test2==100 & test3==100   ]``````
``character(0)``

## 41.16 QUESTION 16

``````#-----------------------------------------------------------------------------------
# QUESTION 16
# Show the students who got the same grade for all three tests
#-----------------------------------------------------------------------------------``````
``students [  test1==test2 & test2==test3 ]``
``[1] "esther"``

## 41.17 QUESTION 17

``````#-----------------------------------------------------------------------------------
# QUESTION 17
# Show the freshemn and sophomores whose highest grade was on the third test
#-----------------------------------------------------------------------------------``````
``students [  (year=="freshman" | year=="sophomore") & test3 > test1 & test3 > test2 ]``
``[1] "larry"``

## 41.18 QUESTION 18

``````#-----------------------------------------------------------------------------------
# QUESTION 18
# Show the average grade on test1 of honors students who are also seniors
#-----------------------------------------------------------------------------------``````
``mean( test1[ honors == TRUE & year == "senior"]  )``
``[1] 85``

## 41.19 QUESTION 19

``````#-----------------------------------------------------------------------------------
# QUESTION 19
# Use a single command to create a vector that contains
# the average grade on test1 the honors students in the first position and
# the average grade on test1 for the non honors students in the 2nd position
#-----------------------------------------------------------------------------------``````
``c(mean(test1[honors == TRUE]) , mean(test1[honors==FALSE]))``
``[1] 90.0 76.8``

## 41.20 QUESTION 20

``````#-----------------------------------------------------------------------------------
# QUESTION 20
# Write a command that shows the names of the honors students who are from NY, NJ or CT
#-----------------------------------------------------------------------------------``````
``students [ honors == TRUE & (homeState == "ny" | homeState == "nj" | homeState == "ct") ]``
``[1] "anne"``

## 41.21 QUESTION 21

``````#-----------------------------------------------------------------------------------
# QUESTION 21
# Answer the previous question without using the | operator.
#-----------------------------------------------------------------------------------``````
``students [ honors == TRUE & homeState %in% c("ny","nj","ct") ]``
``[1] "anne"``

## 41.22 QUESTION 22

``````#-----------------------------------------------------------------------------------
# QUESTION 22
#
# Create a vector that shows the students name, gender and homeState
# for all of the female students in the following format:
#
#     "sue;f;nj"  "anne;f;ny" "esther;f;ny" "carla;f;wa"
#-----------------------------------------------------------------------------------``````
``paste(students[gender=="f"], gender[gender=="f"], homeState[gender=="f"], sep=";")``
``[1] "sue;f;nj"    "anne;f;ny"   "esther;f;ny" "carla;f;wa" ``

## 41.23 QUESTION 23

``````#-----------------------------------------------------------------------------------
# QUESTION 23
#
# Create a single value that has one "m" for each male student and one "f" for
# each female student. The f's should be first before the m's. The f's and m's should
# be separated from each other with dashes (see example below).
# For example, if there would be 5 female and 2 male students your code should show:
#
#   "f-f-f-f-f-m-m"
#
# Remember that your code should work even if the current data changes. (I don't know
# what the data that you get will be.)
#-----------------------------------------------------------------------------------``````
``paste(sort(gender), sep="", collapse="-")``
``[1] "f-f-f-f-m-m-m-m"``

## 41.24 QUESTION 24

``````#-----------------------------------------------------------------------------------
# QUESTION 24
# Write a command that displays the names and majors of the studets who are NOT honors students.
# The output should be in the following format: each student should be on a separate line.
# There should be a tab between the student's name and their major. See example output below.
# (NOTE that the results should be correct even if the actual data changes):
#
#    sue    NA
#    al     acc
#    esther mar
#    bob    acc
#    larry  acc
#-----------------------------------------------------------------------------------``````
``cat( paste( students[!honors] , major[!honors], sep="\t", collapse="\n") )``
``````sue NA
al  acc
esther  mar
bob acc
larry   acc``````

## 41.25 QUESTION 25

``````#-----------------------------------------------------------------------------------
# QUESTION 25
# Write a function named isEven that takes a single argument named nums that is
# expected to be a numeric vector.
# The function should return a logical vector.
# Each entry in the logical vector should be TRUE if the corresponding number is even
# and FALSE if the corresponding number is odd.
#
# EXAMPLE:
# # DEFINE THE FUNCTION isEven HERE
# > isEven ( c(2, 13, 23, 14) )
# [1] TRUE FALSE FALSE TRUE
#-----------------------------------------------------------------------------------``````
``````isEven = function(nums){
nums %% 2 == 0
}``````

## 41.26 QUESTION 26

``````#-----------------------------------------------------------------------------------
# QUESTION 26
# Write a command that uses the function isEven that you created in the
# previous question to display those test1 grades that are even.
#-----------------------------------------------------------------------------------``````
``test1[isEven(test1)]``
``[1]  82  70 100  90``

## 41.27 QUESTION 27

``````#-----------------------------------------------------------------------------------
# QUESTION 27
# Use the isEven function that you created above to create a new function named isOdd.
# isOdd should work similarly to isEvn but isOdd  should return a vector that contains
# TRUE if a number is odd and FALSE if the number is even.
#
# EXAMPLE:
# # DEFINE THE FUNCTION isEven HERE
# > isOdd ( c(2, 13, 23, 14) )
# [1] FALSE TRUE TRUE FALSE
#-----------------------------------------------------------------------------------``````
``````isOdd = function(nums){
!isEven(nums)
}``````

## 41.28 QUESTION 28

``````#-----------------------------------------------------------------------------------
# QUESTION 28
# Use the isOdd function that you described above to display the names
# of the students who got odd numbered grades on test1.
# Show their grades below their names.
#-----------------------------------------------------------------------------------``````
``students [ isOdd(test1) ]``
``[1] "joe"    "anne"   "esther" "larry" ``
``test1 [ isOdd(test1) ]``
``[1] 85 95 93 39``

## 41.29 QUESTION 29

``````#-----------------------------------------------------------------------------------
# QUESTION 29
# Write a single command to display the following. The 2nd and 3rd lines
# should each be indented by one tab. Make sure to get all the 'apostrophes'
# and "quotes" displayed correctly.
#
#    Joe's parrot said:
#        "I want a cracker.
#         I want it now."
#-----------------------------------------------------------------------------------``````
``cat("Joe's parrot said:\n\t\"I want a cracker.\n\t I want it now.\"")``
``````Joe's parrot said:
"I want a cracker.
I want it now."``````

## 41.30 QUESTION 30

``````#-----------------------------------------------------------------------------------
# QUESTION 30
#
# The following "numbers" were entered using "quotes".
# What will be the output from the following line of code?
#
#   > nums = c("2000", "9", "1", "350", "3" )
#   > sort(nums)
#
# Fill in the blank in the following code so that the numbers
# sort in numeric order. Do not change anything else in the code.
# You answer should work no matter what "numbers" are actually in
# the code.
#
#   > nums = c("2000", "9", "1", "350", "3" )
#   > FILL IN YOUR ANSWER HERE SO THAT THE NEXT LINE PRODUCES THE OUTPUT SHOWN BELOW
#   > sort(nums)
#   [1] 1 3 9 350 2000
#-----------------------------------------------------------------------------------``````
``````nums = c("2000", "9", "1", "350", "3" )
nums = as.numeric(nums)
sort(nums)``````
``[1]    1    3    9  350 2000``

## 41.31 QUESTION 31

``````#-----------------------------------------------------------------------------------
# QUESTION 31
#
# The grades vector shown below shows the grades for a test.
# The grades for some students who missed the test were entered as NA.
# Fill in a command to get the average of the grades - not counting the NA grades.
#
#   > grades = c(NA, 75,  NA, 85, 90, 70 )
#   > # COMMAND TO GET AVERAGE - IGNORE THE "missing" or NA grades
#   [1]
#-----------------------------------------------------------------------------------``````
``````# one answer (using na.rm)
grades = c(NA, 75,  NA, 85, 90, 70 )
``[1] 80``
``````# another answer (wihtout na.rm)
grades = c(NA, 75,  NA, 85, 90, 70 )
``[1] 80``

## 41.32 QUESTION 32

``````#-----------------------------------------------------------------------------------
# QUESTION 32
#
# The grades vector shown below shows the grades for a test.
# The numbers were incorrectly entered using "quotes".
# The grades for some students who missed the test were entered as NA
# and for others the grades were entered as "missing".
# Fill in code as shown below so that you generate average.
# Note that a warning may be shown - that is fine.
#
#   > grades = c(NA, "75",  NA, "85", "90", "missing", "70" )
#   > # COMMAND TO GET AVERAGE - IGNORE THE "missing" or NA grades
#   [1] 80
#   Warning message: ..... (some warning messages may be shown)
#-----------------------------------------------------------------------------------``````
``````# one answer
grades = c("NA", "75",  "NA", "85", "90", "missing", "70" )
``Warning in mean(as.numeric(grades), na.rm = TRUE): NAs introduced by coercion``
``[1] 80``
``````# another answer
grades = c("NA", "75",  "NA", "85", "90", "missing", "70" )
``````Warning in mean(as.numeric(grades)[!is.na(as.numeric(grades))]): NAs introduced
by coercion``````
``````Warning in mean(as.numeric(grades)[!is.na(as.numeric(grades))]): NAs introduced
by coercion``````
``[1] 80``

## 41.33 QUESTION 33

``````#-----------------------------------------------------------------------------------
# QUESTION 33
#
# It is VERY important to understand how to use R's debugger.
# This question tests your knowledge of how to use R's debugger.
# You do NOT have to write code to answer this question.
# Rather your job is to write what you see as the debugger runs
# as described in the instructions below.
#
# Refer to the function, strangeFunction, that appears below these instructions.
# This function is written with several advanced R concepts that you did not learn
# about yet. You are not expected to understand all of this code. Keep reading
# to understand what you ARE supposed to do.
#
#
#     strangeFunction = function(){
#       yourName = "John Doe"
#       functionText = paste0(capture.output(strangeFunction),collapse="")
#       functionText = strsplit(functionText,"")[[1]]
#       functionText = functionText[ ! ( functionText %in% c("\n","\t"," ","\r")) ]
#       endOfFunction = max(which (functionText == "}"))
#       functionText = functionText[ 1:endOfFunction ]
#       s = sum(sapply(functionText,function(c)as.numeric(charToRaw(c))))
#       set.seed(s)
#       x = trunc(runif(1) * 10000)
#       message = paste0("Don't pay attention to this return value.",
#                        " What is the value of x as the function runs?",
#                        " Use the debugger to figure it out.",
#                        " By the way, if you change the code in the function AT ALL",
#                        " the answer will be different :). The only way to",
#                        " get the right answer is to use the debugger.")
#       return(message)
#     }
#
# strangeFunction, doesn't seem to do anything useful
# strangeFunction() will always output the following message:
#
#   > strangeFunction()
#   [1] "Don't pay attention to this return value.
#        What is the value of x as the function runs?
#        Use the debugger to figure it out.
#        By the way, if you change the code in the
#        function AT ALL the answer will be different :).
#        The only way to get the right answer is to use the debugger."
#
# To answer this question do the following:
#
#    1. Change the value of the variable yourName to your actual name.
#       The function currently has:
#           yourName = "John Doe"
#
#       Change "John Doe" to your actual name, for example:
#           yourName = "Michael Greenspilzingower"
#
#
#    2. The following line appears in the function:
#
#           x = trunc(runif(1,1,100000))
#
#       Use the debugger to find the value of x as the function runs.
#
#       Note that everyone should have their own name in the variable yourName.
#       This function uses some advanced R concepts to ensure that
#       changing the code of the function will change the value that is
#       assigned to x in unpredictable ways. Therefore since everyone
#       changed the code of the function by adding their own name, everyone should
#       have a different answer to this question.
#
#       Your answer should include a copy of your version of the function as well
#       as the value of x that you got from the debugger.
#       For example, Michael Greenspilzingower should report his answer as follows:
#
#               For my version of the function, the value of x is : 9281
#               My version of the function is below.
#
#                   strangeFunction = function(){
#                      yourName = "Michael Greenspilzingower"
#                      functionText = paste0(capture.output(strangeFunction),collapse="")
#                      functionText = strsplit(functionText,"")[[1]]
#                      functionText = functionText[ ! ( functionText %in% c("\n","\t"," ","\r")) ]
#                      endOfFunction = max(which (functionText == "}"))
#                      functionText = functionText[ 1:endOfFunction ]
#                      s = sum(sapply(functionText,function(c)as.numeric(charToRaw(c))))
#                      set.seed(s)
#                      x = trunc(runif(1) * 10000)
#                      message = paste0("Don't pay attention to this return value.",
#                                       " What is the value of x as the function runs?",
#                                       " Use the debugger to figure it out.",
#                                       " By the way, if you change the code in the function AT ALL",
#                                       " the answer will be different :). The only way to",
#                                       " get the right answer is to use the debugger.")
#                      return(message)
#                   }
#
#       NOTE: If you leave the name as John Doe, then the value of x is 7388.
#       You can use this to check to make sure that you are doing the question
#       correctly before trying your own name.
#-----------------------------------------------------------------------------------``````

## 41.34 QUESTION 34

``````#-----------------------------------------------------------------------------------
# QUESTION 34
#
# create a function named equal values that takes two vectors, v1 and v2,
# and returns a vector of those values that are equal and in the same
# positions in the two vectors.
#
#  EXAMPLE
#    > equal( c(100,200,300,400), c(50, 200, 60, 400))
#    [1] 200 400
#-----------------------------------------------------------------------------------``````
``````equal = function( v1, v2) {
return ( v1 [ v1 == v2])
}

equal( c(100,200,300,400), c(50, 200, 60, 400))``````
``[1] 200 400``

## 41.35 QUESTION 35

``````#-----------------------------------------------------------------------------------
# QUESTION 35
#
# Create a function named mixAndPaste that takes the following arguments and
# returns the value described below.
#
# Arguments
#    x   -   a vector
#    y   -   a vector of the same length as x
#
# Return value
#    A character vector that pastes the values of x and y together.
#    The 1st, 3rd, 5th, etc positions of the return value should have the
#    x value before the y value.
#    The 2nd, 4th, 6th, etc positions of the return value should have the
#    y value before the x value.
#
# EXAMPLE1
#   > mixAndPaste( c("a","b","c","d","e","f"), c("u","v","w","x","y","z"))
#   [1] "au" "vb" "cw" "xd" "ey" "zf"
#
# EXAMPLE2
#   > mixAndPaste(c("apple", "pear", "lemon", "plum"),c("RED", "GREEN", "YELLOW", "PURPLE"))
#   [1] "appleRED"    "GREENpear"   "lemonYELLOW" "PURPLEplum"
#
# HINTS
#   a. You can use more than one line of code in the function definition.
#   b. You can create new "local" variables in the function definition.
#   c. Figure out how to create two new local variables in the function.
#      One of the local variables should contain the first vector to be pasted
#         (e.g. using the values from EXAMPLE1 above, this first vector
#          would contain "a" "v" "c" "x" "e" "z")
#      and another vector should contain the second vector to be pasted
#         (e.g. using the values from EXAMPLE1 above, this second vector
#          would contain "u" "b" "w" "d" y" "f".
#      Then the function should reutrn the values of those vectors pasted together.
#   d. To accomplish c. above, remember that you can assign values to specific
#      locations in a vector, as long as that vector already exists.
#-----------------------------------------------------------------------------------``````
``````# The following is one possible suggested answer.
# There can be many other correct answers.

mixAndPaste = function(x,y) {
# To explain how this code works let's assume for example that
# the function was called as:
#   mixAndPaste(c("apple", "pear", "lemon", "plum"),c("RED", "GREEN", "YELLOW", "PURPLE"))
#
# Therefore
#    x is c("apple", "pear", "lemon", "plum") and
#    y is c("RED", "GREEN", "YELLOW", "PURPLE")
#
# The goal in the code below is to get the vector named left to be
#      c("apple", "GREEN", "lemon", "PURPLE")
#
# and to get the vector named right to be
#      c("RED", "pear", "YELLOW", "plum")
#
# Then if we paste together the vectors left and right, we'll get the
# result we want, i.e.
#      c("appleRED", "GREENpear", "YELLOWlemon", "plumPURPLE")

# set the local variable, left, to x, e.g. left = c("apple", "pear", "lemon", "plum")
left = x

# replace the even positions in left with the even positions from y
# e.g. after this line runs, left will be c("apple", "GREEN", "lemon", "PURPLE")
left[seq(2,length(x),by=2)] = y[seq(2,length(x),by=2)]

# Now set the local variable, right, to y, eg. right = c("RED", "GREEN", "YELLOW", "PURPLE")
right = y

# replace the even positions in right with the even positions from x
# e.g. after this line runs, right will be c("RED", "pear", "YELLOW", "plum")
right[seq(2,length(x),by=2)] = x[seq(2,length(x),by=2)]

return(paste0(left,right))
}

mixAndPaste( c("a","b","c","d","e","f"), c("u","v","w","x","y","z"))``````
``[1] "au" "vb" "cw" "xd" "ey" "zf"``
``mixAndPaste(c("apple", "pear", "lemon", "plum"),c("RED", "GREEN", "YELLOW", "PURPLE"))``
``[1] "appleRED"    "GREENpear"   "lemonYELLOW" "PURPLEplum" ``

## 41.36 QUESTION 36

``````#-----------------------------------------------------------------------------------
# QUESTION 36
#
# The built-in function, which, returns the positions in a logical vector that are TRUE.
# For example
#
#    > which ( c(FALSE, TRUE, FALSE, FALSE, TRUE)) # 2 5 because those positions are TRUE
#    [1] 2 5
#
#    > nums = c(9999,3,950,222,-5)
#    > which(nums > 100)    # 1 3 4   because the 1st, 3rd and 4th values are greater than 100
#    [1] 1 3 4
#
#    > which ( c(FALSE, FALSE) ) # integer(0) ... this means that no values are TRUE
#    integer(0)
#
# Create a function named, myWhich, that does the same thing as the built-in, "which" function.
# Your function should takee a single argument named x.
# Do NOT use the which command in your code.
#
#  EXAMPLE1
#    > myWhich ( c(TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE)) # 1 2 5 because those positions are TRUE
#    [1] 1 2 5
#
#    > nums = c(10,3,950,222,-5)
#    > myWhich(nums > 100)    # 3 4   because the 3rd and 4th position values are greater than 100
#    [1] 3 4
#
#    > myWhich ( c(FALSE, FALSE) ) # integer(0) ... this means that no values are TRUE
#    integer(0)
#
# HINTS
#    - Create a local variable that contains the position numbers from 1 until the last
#      position in x. Return some of the values from that local variable.
#-----------------------------------------------------------------------------------``````
``````myWhich = function(x){
nums = 1:length(x)
return ( nums[x])
}

myWhich( c(TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE))``````
``[1] 1 2 5``

## 41.37 QUESTION 37

``````#-----------------------------------------------------------------------------------
# QUESTION 37
#
# Create a function named nextValue that takes the following arguments:
#
# Arguments:
#      vec   - expected to be a vector
#      position  - is a position in the vector, expected to be between 1 and length(wordVec)
#
# There is obviously a value at the specified position in vec.
# The function should return the value from vec that is alphabetically (if vec is character)
# or numerically (if vec is numeric) right after the specified value. See the examples below.
#
# HINTS
#       - you may create local variables in your function to help you
#         work through the ideas
#
#       - use the sort function to help you
#
#       - realize that positions after the last value in a vector are NA
#
#
#
# EXAMPLE1
#   > # banana is in the 4th position, "car" is alphabetically after "banana"
#   > nextValue (vec = c("fox", "car", "apple", "banana", "deer", "ball", "elephant"),
#                position = 4)
#   [1] "car"
#
# EXAMPLE2 (same words as example1)
#   > # "deer" is in the 5th position, "elephant" is alphabetically after "deer"
#   > nextValue (vec = c("fox", "car", "apple", "banana", "deer", "ball", "elephant"),
#                position = 5)
#   [1] "elephant"
#
# EXAMPLE3 (same words as example1)
#   > # The 1st word is "fox" and it is the last word alphabetically, so return NA
#   > nextValue (vec = c("fox", "car", "apple", "banana", "deer", "ball", "elephant"),
#                position = 1)
#   [1] NA
#
# EXAMPLE4 (this time with a numeric vector)
#   > # In this example, the value in the 2nd position is 425.
#   > # 690 is the next value numerically after 425.
#   > nextValue ( c(100, 425, 50, 400, 690, 800, 200), 2 )    # 690
#   [1] 690
#-----------------------------------------------------------------------------------``````
``````nextValue = function( vec, position ) {
sorted = sort(vec)
nums = 1:length(vec)
newPosition = nums [ sorted == vec[position] ]
return(sorted[newPosition+1])
}

# EXAMPLE1
nextValue (vec = c("fox", "car", "apple", "banana", "deer", "ball", "elephant"),
position = 4)``````
``[1] "car"``
``````#   [1] "car"

# EXAMPLE2
nextValue (vec = c("fox", "car", "apple", "banana", "deer", "ball", "elephant"),
position = 5)``````
``[1] "elephant"``
``````#   [1] "elephant"

# EXAMPLE3 (same words as example1)
nextValue (vec = c("fox", "car", "apple", "banana", "deer", "ball", "elephant"),
position = 1)``````
``[1] NA``
``````#   [1] NA

# EXAMPLE4 (this time with a numeric vector)
nextValue ( c(100, 425, 50, 400, 690, 800, 200), 2 )    # 690``````
``[1] 690``
``#   [1] 690``

## 41.38 QUESTION 38

``````#-----------------------------------------------------------------------------------
# QUESTION 38
#
# Create a function, wordsBetween
# Arguments:
#      wordVec   - expected to be a character vector of words (or any other character data)
#      wordA     - a single word
#      wordB     - another single word
#
# The function should return a vector of the words from wordVec that
# appear in wordsBetween that are alphabetically between wordA and wordB.
#
#   EXAMPLE
#     # DEFINE FUNCTION wordsBetween HERE
#     > words = c("car", "bicycle", "harley", "truck", "boat", "caravan", "minivan", "plane")
#     > wordsBetween(words, "cat", "monkey")
#     [1] "harley" "minivan"
#-----------------------------------------------------------------------------------``````
``````wordsBetween = function(wordVec, wordA, wordB){
wordVec[ wordVec >= wordA & wordVec <= wordB]
}

words = c("car", "bicycle", "harley", "truck", "boat", "caravan", "minivan", "plane")
wordsBetween(words, "cat", "monkey")``````
``[1] "harley"  "minivan"``

## 41.39 QUESTION 39

``````#-----------------------------------------------------------------------------------
# QUESTION 39
#
# Write the number 0.00031 in R's version of scientific notation.
#-----------------------------------------------------------------------------------``````
``3.1e-4   # run this line to see that this is equal to 0.00031``
``[1] 0.00031``

## 41.40 QUESTION 40

``````#-----------------------------------------------------------------------------------
# QUESTION 40
#
# After running an R command R responded with
#    [1] 1.23e+12
# Explain what that means. Write that number in a more familiar form?
#-----------------------------------------------------------------------------------``````
``````# ANSWER
#
# 1.23e+12 is simply a number written using R's version of "scientific notation".
# 1.23e+12 means 1.23 times 10^12.
#
# You can read the letter "e" in 1.23e+12 as "times 10 to the power of" to get
# 1.23 times 10 to the power of +12.
#
# R uses "scientific notation" to concisely write numbers that are very very large,
# and numbers that are very very small.
# eg. 9870000000000 is equivalent 9.87e+12
# and 0.000000000987 is equivalent to 9.87e-10
#
# You can figure out the value of 1.23e+12 as a more familiar looking number by
# moving the decimal point from 1.23 to the right 12 times.
# Moving to the right twice gets 123, but then you need to move to the right 10 more times,
# so simply add 10 more zeros to get 1230000000000.``````