DS102-Statistical-Programming-in-R/DS102-L4-Vectors-and-Sample-Statistics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50e6ddbb-52d3-4a02-9b69-100a4181e3b0",
   "metadata": {},
   "source": [
    "# DS102 Statistical Programming in R  : Lesson Four - Vectors and Sample Statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bd4bfc-9b15-4b80-87b4-b8b60eb56371",
   "metadata": {},
   "source": [
    "### Table of Contents <a class=\"anchor\" id=\"DS102L4_toc\"></a>\n",
    "\n",
    "* [Table of Contents](#DS102L4_toc)\n",
    "    * [Page 1 - Introduction](#DS102L4_page_1)\n",
    "    * [Page 2 - Creating and Accessing Vectors](#DS102L4_page_2)\n",
    "    * [Page 3 - Vector Arithmetic and Functions](#DS102L4_page_3)\n",
    "    * [Page 4 - Logical Variables](#DS102L4_page_4)\n",
    "    * [Page 5 - Logical Operations on Vectors](#DS102L4_page_5)\n",
    "    * [Page 6 - Sample Statistics](#DS102L4_page_6)\n",
    "    * [Page 7 - Key Terms](#DS102L4_page_7)\n",
    "    * [Page 8 - Hands-On](#DS102L4_page_8)\n",
    "    * [Page 9 - Solution](#DS102L4_page_9)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5a8c65-ed48-4354-a257-e01b0fd733d4",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 1 - Introduction<a class=\"anchor\" id=\"DS102L4_page_1\"></a>\n",
    "\n",
    "[Back to Top](#DS102L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "08255193-affd-4e74-90a6-63d41035addf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/247057914\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x278ea5908b0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('247057914', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5ef13fb-7af0-4b02-862d-73f7625db726",
   "metadata": {},
   "source": [
    "You recently learned how to do simple computations with individual numbers. This is a useful skill. But data science and statistics deal with samples; a sample is a collection of numbers or some other type of data. Samples consisting of only one number are generally not that useful. So R has several powerful ways to allow you to work with samples. The simplest of these ways is a vector.\n",
    "\n",
    "Previously, you were briefly introduced to vectors. However, vectors are useful in many ways, and R can compute arithmetic on vectors. Much of what you did with for loops can be done directly with vectors.\n",
    "\n",
    "You will also learn how to compute sample statistics for a sample stored in a vector. R has functions to compute most common sample statistics.\n",
    "\n",
    "In this lesson, you will: \n",
    "\n",
    "* Create vectors\n",
    "* Call functions on vectors\n",
    "* Learn about logical variables\n",
    "* Apply logical variables to vectors\n",
    "* Compute sample statistics on vectors\n",
    "\n",
    "This lesson will culminate in a hands on where you analyze vector data from Old Faithful, the geyser in Yellowstone.\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Before you start working in R too heavily, it's a good idea to watch <a href=\"https://vimeo.com/410435344\"> this recorded live workshop on how to address common errors in R. It will save you lots of headaches later! </a></p>\n",
    "    </div>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7990ac7a-5a2f-4744-af14-1b7e385ea484",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 2 - Creating and Accessing Vectors<a class=\"anchor\" id=\"DS102L4_page_2\"></a>\n",
    "\n",
    "[Back to Top](#DS102L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6431b805-9011-46a2-ae1b-17634dee05fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/327137068\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x278ea590940>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('327137068', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612429df-e4ef-4d85-8460-5bc8914079c3",
   "metadata": {},
   "source": [
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L04-pg2tutorial.zip)**.\n",
    "\n",
    "As you learned previously, a numerical vector is an ordered collection of numbers. Ordered means that there is a first number, a second number, and so on to the last number. Each number in the vector is called an element. You can create a vector of the following measured heights in centimeters of six people: 171, 192, 183, 177, 154, and 176.\n",
    "\n",
    "```{r}\n",
    "heights <- c(171, 192, 183, 177, 154, 176)\n",
    "```\n",
    "\n",
    "You can access specific elements of the vector ```heights``` as follows:\n",
    "\n",
    "```{r}\n",
    "heights[1]\n",
    "```\n",
    "\n",
    "[1] 171\n",
    "\n",
    "This gives you the first element in the vector. You can access the second element of ```heights``` with\n",
    "\n",
    "```{r}\n",
    "heights[2]\n",
    "```\n",
    "\n",
    "[1] 192\n",
    "\n",
    "In general, to get a particular element of a vector, you follow the variable name with square brackets containing the index of the variable element you want; the index of an element is just the number describing its location in the vector. R is \"1 indexed\" meaning that the indexing numbers start with the number 1, as opposed to the number 0.  You will encounter other programming languages, like Python, later than are \"0 indexed\" meaning that the indexing numbers start at 0.\n",
    "\n",
    "---\n",
    "\n",
    "## Sequences\n",
    "\n",
    "As you previously learned, you can make sequences of numbers using the ```:``` operator:\n",
    "\n",
    "```{r}\n",
    "1:10\n",
    "```\n",
    "\n",
    "[1] 1 2 3 4 5 6 7 8 9 10\n",
    "\n",
    "You are now at a point where you can explain the mysterious [1] that appears before almost everything R outputs. You will make a long sequence of numbers going backward:\n",
    "\n",
    "```{r}\n",
    "100:1\n",
    "```\n",
    "\n",
    "[1] 100 99 98 97 96 95 94 93 92 91 90 89 88\n",
    "\n",
    "[14] 87 86 85 84 83 82 81 80 79 78 77 76 75\n",
    "\n",
    "[27] 74 73 72 71 70 69 68 67 66 65 64 63 62\n",
    "\n",
    "[40] 61 60 59 58 57 56 55 54 53 52 51 50 49\n",
    "\n",
    "[53] 48 47 46 45 44 43 42 41 40 39 38 37 36\n",
    "\n",
    "[66] 35 34 33 32 31 30 29 28 27 26 25 24 23\n",
    "\n",
    "[79] 22 21 20 19 18 17 16 15 14 13 12 11 10\n",
    "\n",
    "[92] 9 8 7 6 5 4 3 2 1\n",
    "\n",
    "Your output in the Console pane will probably be different than the output above unless your Console pane is the same width as the one in which this output was generated. The command ```100:1``` generates a vector with 100 elements. Element 1 is 100, element 2 is 99, and so on.\n",
    "\n",
    "The number in the square bracket at the beginning of each line is the index of the first element displayed on that line. So element 14 is 87; you know this because the line that begins with [14] has the first value of 87. Element 15 is 86.\n",
    "\n",
    "When R displays a single number, it places a [1] in front of it because R actually treats all single numbers as vectors with only one element. So every single number that is displayed is the first element in a vector with only one number.\n",
    "\n",
    "The ```:``` operator creates sequences of integers. You can also create sequences of arbitrarily spaced values using the ```seq()``` function.\n",
    "\n",
    "For example, you can create a sequence of numbers starting at 0 and ending at 1 and going up by 0.1 between numbers:\n",
    "\n",
    "```{r}\n",
    "seq(0, 1, by = 0.1)\n",
    "```\n",
    "\n",
    "[1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n",
    "\n",
    "The first argument to ```seq()``` is the starting number of the sequence; the second argument to ```seq()``` is the ending number; ```by = 0.1``` means that each element of the sequence should be 0.1 larger than the previous element.\n",
    "\n",
    "A sequence with a specified length starting and ending at given values is created with the ```length.out``` argument to ```seq()```. So if you want a sequence starting at 3 and ending at 5 with 7 elements, you would use the following form of ```seq()```:\n",
    "\n",
    "```{r}\n",
    "seq(3, 5, length.out = 7)\n",
    "```\n",
    "\n",
    "[1] 3.000000 3.333333 3.666667 4.000000 4.333333 4.666667 5.000000\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "12724e15-3605-4291-add6-ad0d3eadbba6",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from DS_Students import MultipleChoice\n",
    "    from ipynb.fs.full.DS102Questions import *\n",
    "except:\n",
    "    !pip install DS_Students\n",
    "    from DS_Students import MultipleChoice\n",
    "    from ipynb.fs.full.DS102Questions import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "303a6958-55c2-4589-95b2-afcb30757677",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "521110eaba1e4433addc4f3e6672d027",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Which of the following commands would create thi…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2acb16d1baab48e2aca8ce381482f6b6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. What does the \\x1b[31;1mseq()\\x1b[0m function do…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "39b4499fa069421281fd0942a9d1ca75",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. Which of the following is NOT an argument for th…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L4P2Q1, L4P2Q2, L4P2Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832358fd-55fa-420a-8aa2-46fbf2097986",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 3 - Vector Arithmetic and Functions<a class=\"anchor\" id=\"DS102L4_page_3\"></a>\n",
    "\n",
    "[Back to Top](#DS102L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e290bc75-cc4c-4b99-8924-e6dc7f610f93",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/327137118\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x278ea590af0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('327137118', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f564e3e7-3a7f-4936-b3a3-2e0a9ab78512",
   "metadata": {},
   "source": [
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L04-pg3tutorial.zip)**.\n",
    "\n",
    "# Vector Arithmetic\n",
    "\n",
    "R can do arithmetic on vectors of numbers. For an example, you will use ```heights```, the vector of heights defined previously. To convert the heights in the vector ```h``` from centimeters to inches, you could divide each height by 2.54 (which is the number of centimeters in an inch). Because the heights are stored in the vector ```heights```, R can do this in a single statement:\n",
    "\n",
    "```{r}\n",
    "heights / 2.54\n",
    "```\n",
    "\n",
    "[1] 67.32283 75.59055 72.04724 69.68504 60.62992 69.29134\n",
    "\n",
    "You can verify that the first element in this vector is the quotient of 171 divided by 2.54, the second is the quotient of 192 divided by 2.54, and so on. The expression ```h / 2.54``` divides each element in R by 2.54. You could store the heights in inches in a variable ```h.inch```:\n",
    "\n",
    "```{r}\n",
    "h.inch <- heights / 2.54\n",
    "```\n",
    "\n",
    "Suppose that each person whose height you measured was wearing shoes at the time of the measurement, and the soles of their shoes had the following different thicknesses (in centimeters): 4, 1, 2, 6, 3, and 5. You can make a vector of shoe sole thicknesses:\n",
    "\n",
    "```{r}\n",
    "soles <- c(4, 1, 2, 6, 3, 5)\n",
    "```\n",
    "\n",
    "Now you can find the height of each person without their shoes by subtracting the thickness of their shoe soles from their measured height. You do this by subtracting the vector ```soles``` from ```heights```. R computes the difference of each element of ```heights``` and the corresponding element of ```soles```:\n",
    "\n",
    "```{r}\n",
    "heights - soles\n",
    "```\n",
    "\n",
    "[1] 167 191 181 171 151 171\n",
    "\n",
    "Arithmetic operations on vectors are done element by element. An operation on two vectors of different sizes is done by recycling the elements of the shorter vector. In the following code that subtracts the vector ```x``` from the vector ```y```, ```x``` has only two elements, while ```y``` has six. The elements of the shorter vector ```x``` will be used three times each while the elements of ```y``` will be used only once:\n",
    "\n",
    "```{r}\n",
    "x <- c(1, 2)\n",
    "y <- c(4, 5, 6, 7, 8, 9)\n",
    "y - x\n",
    "```\n",
    "\n",
    "[1] 3 3 5 5 7 7\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>The above can be problematic if you want the operation to only happen once per element, but have missing data! Make sure both vectors are the same size if you want to go line by line. </p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "# Functions on Vectors\n",
    "\n",
    "Most of the R functions that do computations on numbers can also do computations on vectors, as you saw previously.  As a reminder, if you wanted to compute the square roots of the integers between 1 and 10, you could create a vector of these integers and call ```sqrt()``` with this vector as its argument:\n",
    "\n",
    "```{r}\n",
    "n = 1:10\n",
    "sqrt(n)\n",
    "```\n",
    "\n",
    "[1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751\n",
    "\n",
    "[8] 2.828427 3.000000 3.162278\n",
    "\n",
    "The first number output is the square root of 1, the second is the square root of 2, and so on.\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "95b8cb40-cef8-4a47-a921-a35cb87d1191",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f687ebdbdfc74085a6afbefec42bdc72",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Suppose you create the following two vectors: \\n…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ddec17bdcb1b4cd6ad2b4f574f918769",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. Can functions be performed on vectors?\\n', 'outp…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L4P3Q1, L4P3Q2)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1aade2-59af-4cbc-b5ed-da31e39f266d",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 4 - Logical Variables<a class=\"anchor\" id=\"DS102L4_page_4\"></a>\n",
    "\n",
    "[Back to Top](#DS102L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f2421b31-482c-412b-958e-e0a32c23f956",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/327137105\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x278ea590dc0>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('327137105', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba2ed6e-98dd-43f7-8761-6ecc9a13af08",
   "metadata": {},
   "source": [
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L04-pg4tutorial.zip)**.\n",
    "\n",
    "# Logical Variables\n",
    "\n",
    "In R, logical variables and expressions are often used to select certain components of a vector or data table. This is very helpful when doing exploratory data analysis. In this section, you will learn the basics of logical values and logical operators and apply them to select elements in a vector. \n",
    "\n",
    "A logical value is ```TRUE``` or ```FALSE```. You can assign a logical value to a variable:\n",
    "\n",
    "```{r}\n",
    "Logic <- TRUE\n",
    "Logic\n",
    "```\n",
    "\n",
    "[1] TRUE\n",
    "\n",
    "However, it is usually more useful to create logical values using a condition; an example of a condition is ```3 < 5```. Since 3 is less than 5, this condition has a value of TRUE:\n",
    "\n",
    "```{r}\n",
    "3 < 5\n",
    "```\n",
    "\n",
    "[1] TRUE\n",
    "\n",
    "If you change the condition to be 3 > 5, you get\n",
    "\n",
    "```{r}\n",
    "3 > 5\n",
    "```\n",
    "\n",
    "[1] FALSE\n",
    "\n",
    "A condition uses a logical operator to compare two values; in the examples above, you used the logical operators ```>``` and ```<``` to do the comparison.\n",
    "\n",
    "The logical operators in R are the following:\n",
    "\n",
    "* **```<``` :** Less than\n",
    "* **```<=``` :** Less than or equal to\n",
    "* **```>``` :** Greater than\n",
    "* **```>=``` :** Greater than or equal to\n",
    "* **```==``` :** Equal to\n",
    "* **```!=``` :** Not equal to\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Since the equals sign ( = ) is used for variable assignment, it cannot be used as a logical operator.  Thus the double equals ( == ) is used instead.  This is common in programming.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f95286ce-873e-4038-bb9c-98abb4138812",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "86caf0848d474b82a5e686a45e230ffd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. What is the value of the condition 4 < 6?\\n', 'o…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a9cdb125210e42ccbf8b85e58c8f24cd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. What is the value of the condition 4 == 6?\\n', '…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "25a7d26c23264c8382a7e5b18c8e623e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. What is the value of the condition 4 != 6?\\n', '…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L4P4Q1, L4P4Q2, L4P4Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead4ad3c-2fe6-457e-8924-1410e951bebd",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 5 - Logical Operations on Vectors<a class=\"anchor\" id=\"DS102L4_page_5\"></a>\n",
    "\n",
    "[Back to Top](#DS102L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "84dfbc61-5c88-4979-805c-4ffe6d86ca55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/327137089\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x278ea5908e0>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('327137089', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbc06a2-e702-47a1-942f-cbcbe31221a7",
   "metadata": {},
   "source": [
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L04-pg5tutorial.zip)**.\n",
    "\n",
    "---\n",
    "\n",
    "## Using Logical Operators with Vectors\n",
    "\n",
    "You can use logical operators with vectors as well. For example, using the vector ```heights```, you can find which heights are less than 180 as follows:\n",
    "\n",
    "```{r}\n",
    "heights < 180\n",
    "```\n",
    "\n",
    "[1] TRUE FALSE FALSE TRUE TRUE TRUE\n",
    "\n",
    "This condition returns a vector whose elements are ```TRUE``` when the corresponding element of ```heights``` is less than 180 and ```FALSE``` when the corresponding element of ```heights``` is greater than or equal to 180. This kind of vector is called a *logical vector*.\n",
    "\n",
    "You can use a logical vector to select elements of ```heights``` that meet a given condition. This is a very powerful capability when doing data analysis, where it can be advantageous to focus on values that meet a given condition.\n",
    "\n",
    "As an example, suppose you want to separate ```heights``` into two vectors: one with the heights of the \"tall\" people, and one with the heights of the \"short\" people, with the dividing line between short and tall arbitrarily set at 180. To create a vector short that contains the values of ```heights``` which are less than 180, do the following:\n",
    "\n",
    "```{r}\n",
    "short <- heights[heights < 180]\n",
    "short\n",
    "```\n",
    "\n",
    "[1] 171 177 154 176\n",
    "\n",
    "This statement works as follows. From above, you know that the condition ```heights < 180``` creates a logical vector of ```TRUE``` and ```FALSE``` values.\n",
    "\n",
    "The first element of this vector is ```TRUE```, since the first element of ```heights``` has a value of 171.\n",
    "\n",
    "This means that the first element of `heights` is in the ```short``` vector.\n",
    "\n",
    "The second element of the logical vector created by the condition is ```FALSE```, since the second element of ```heights``` is 192.\n",
    "\n",
    "This means that ```short``` does not include the second element of ```heights```.\n",
    "\n",
    "This process is repeated for every element in ```heights```; only the elements less than 180 are included in ```short```.\n",
    "\n",
    "You can create a ```tall``` vector as follows:\n",
    "\n",
    "```{r}\n",
    "tall <- heights[heights >= 180]\n",
    "tall\n",
    "```\n",
    "\n",
    "[1] 192 183\n",
    "\n",
    "You can remove a specific value from ```heights``` as follows. You can take out the value 177 with this command:\n",
    "\n",
    "```{r}\n",
    "new.heights <- heights[heights != 177]\n",
    "new.heights\n",
    "```\n",
    "\n",
    "[1] 171 192 183 154 176\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "71ec8122-2371-4dbb-a69e-9f1b425d843a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ff17097623d44e229d22f474bdaa2517",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Suppose you have two vectors x and y that are de…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "54b07f781b5d4f2b945e495c2c892a91",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': \"2. Suppose that you have a data vector that has bee…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L4P5Q1, L4P5Q2)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9e3b8a-9224-447f-8cf7-5035cae86421",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 6 - Sample Statistics<a class=\"anchor\" id=\"DS102L4_page_6\"></a>\n",
    "\n",
    "[Back to Top](#DS102L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "eb9d9330-22a3-417b-b20b-ed19512db975",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/327137138\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x278ea590d60>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('327137138', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81e2098-28ef-4ff5-a155-afe824de4323",
   "metadata": {},
   "source": [
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L04-pg6tutorial.zip)**.\n",
    "\n",
    "# Sample Statistics\n",
    "\n",
    "R has many functions to compute every commonly used and many less commonly used sample statistics. In this section, you will illustrate computing the statistics of a sample stored in a vector.\n",
    "\n",
    "R has many built in data sets that can be used to learn about features of R. Most of these data sets are stored as data frames. You will go through a more extensive introduction to data frames later, but for now will learn just enough about data frames to get numerical data from them into a vector,  from which you can compute sample statistics.\n",
    "\n",
    "![The old faithful geyser erupting in Yellowstone National Park in the U S.](Media/L04-OldFaithful.jpg)\n",
    "\n",
    "One set of data is the ```faithful``` dataset, which has the length in minutes of 272 eruptions of the Old Faithful geyser as well as the waiting time in minutes to the next eruption. You can get access to this data frame using the following command:\n",
    "\n",
    "```{r}\n",
    "library(datasets)\n",
    "```\n",
    "\n",
    "This command makes several data sets available to you, including the faithful data set. You can see this set as follows:\n",
    "\n",
    "```{r}\n",
    "faithful\n",
    "```\n",
    "\n",
    "```text\n",
    "eruptions waiting\n",
    "\n",
    "1 3.600 79\n",
    "\n",
    "2 1.800 54\n",
    "\n",
    "3 3.333 74\n",
    "\n",
    "4 2.283 62\n",
    "```\n",
    "\n",
    "Notice that this data set has two columns; one column is labeled ```eruptions``` and the other is labeled ```waiting```. There are 272 rows of data.\n",
    "\n",
    "You can create a vector of eruption times and store it in the variable ```eruption.times``` with the command\n",
    "\n",
    "```{r}\n",
    "eruption.times <- faithful$eruptions\n",
    "```\n",
    "\n",
    "R has many useful functions that can be used to understand a numerical sample stored as a vector. They include functions to find maximum and minimum values, as well as commonly used sample statistics. Here is a list of some commonly used functions:\n",
    "\n",
    "* **max() :** Returns the largest element of the vector.\n",
    "* **min() :** Returns the smallest element of the vector.\n",
    "* **length() :** Returns the number of elements in the vector.\n",
    "* **sort() :** Returns a vector with the elements arranged from smallest to largest.\n",
    "* **mean() :** Computes the average of the values in the vector.\n",
    "* **median() :** Computes the median of the values in the vector.\n",
    "* **var() :** Computes the variance of the values in the vector.\n",
    "* **sd() :** Computes the sample standard deviation of the values in the vector.\n",
    "* **summary() :** Shows the following values for a vector:\n",
    "    * Minimum.\n",
    "    * 1st quartile (the value that has 25% of the sample values below it).\n",
    "    * Median.\n",
    "    * Mean.\n",
    "    * 3rd quartile (the value with 75% of the sample values below it).\n",
    "    * Maximum.\n",
    "\n",
    "Using these functions, you can learn about the sample in ```eruption.times```. The number of values in the sample is given by:\n",
    "\n",
    "```{r}\n",
    "length(eruption.times)\n",
    "```\n",
    "\n",
    "[1] 272\n",
    "\n",
    "There are 272 samples. The largest and smallest values in the sample are given by:\n",
    "\n",
    "```{r}\n",
    "max(eruption.times)\n",
    "min(eruption.times)\n",
    "```\n",
    "\n",
    "[1] 5.1\n",
    "[1] 1.6\n",
    "\n",
    "So the longest eruption time is 5.1 minutes, and the shortest eruption time is 1.6 minutes. The mean and median are given by: \n",
    "\n",
    "```{r}\n",
    "mean(eruption.times)\n",
    "median(eruption.times)\n",
    "```\n",
    "\n",
    "[1] 3.487783\n",
    "[1] 4\n",
    "\n",
    "The variance and standard deviation are given by:\n",
    "\n",
    "```{r}\n",
    "var(eruption.times)\n",
    "sd(eruption.times)\n",
    "```\n",
    "\n",
    "[1] 1.302728\n",
    "[1] 1.141371\n",
    "\n",
    "You can get a summary of the sample statistics using the ```summary()``` function:\n",
    "\n",
    "```{r}\n",
    "summary(eruption.times)\n",
    "```\n",
    "\n",
    "Min. 1st Qu. Median Mean 3rd Qu. Max.\n",
    "\n",
    "1.600 2.163 4.000 3.488 4.454 5.100\n",
    "\n",
    "Note that these values agree with the values that you computed using individual functions above. Huzzah!\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b279f1ee-d60c-4def-b1d5-525db2d5ad14",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "daf706137e2e43f4bab4b00a9161a4ba",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Create a vector of wait times (times between eru…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9fa2bb33b1c54ef58aa12cb688818445",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. Create a vector of wait times (times between eru…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "27b5e143283643a5b48145dcc01f3c3c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. Create a vector of wait times (times between eru…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ca0615715840425da9dc9fcc0288ecfb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '4. Create a vector of wait times (times between eru…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e0d2860103d34c80b016f6228a7bfc23",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '5. Which statement would product quartiles?\\n', 'ou…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L4P6Q1, L4P6Q2, L4P6Q3, L4P6Q4, L4P6Q5)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42cb7d8a-aced-42e5-ac24-32acf8c95473",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 7 - Key Terms<a class=\"anchor\" id=\"DS102L4_page_7\"></a>\n",
    "\n",
    "[Back to Top](#DS102L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0debaf-5fae-4035-8e7d-ae62e62456cb",
   "metadata": {},
   "source": [
    "Below is a list and short description of the important keywords learned in this lesson. Please read through and go back and review any concepts you do not fully understand. Great Work!\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Logical Variable</td>\n",
    "        <td>A variable that has a value of either TRUE or FALSE.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Logical Value</td>\n",
    "        <td>TRUE or FALSE.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Logical Operators</td>\n",
    "        <td>Something you use to compare data. Can be less than <, greater than >, less than or equal to <=, greater than or equal to >=, equal to ==, or not equal to != .</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Subset</td>\n",
    "        <td>To isolate certain information from a dataset.</td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "# Key R Functions\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>seq()</td>\n",
    "        <td>Creates a vector using the arguments of a start number and end number.  Can include the arguments by= to increment or length.out to specify how long the vector should be. </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>max()</td>\n",
    "        <td>Finds the maximum value in a vector.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>min() </td>\n",
    "        <td>Returns the minimum value in a vector. </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>length()</td>\n",
    "        <td>Provides the number of elements in a vector.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>sort()</td>\n",
    "        <td>Sorts the vector from smallest to largest.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>mean()</td>\n",
    "        <td>Finds the average of values in a vector.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>median()</td>\n",
    "        <td>Finds the median of values in a vector.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>var()</td>\n",
    "        <td>Finds the variance for values in a vector.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>sd()</td>\n",
    "        <td>Finds the standard deviation for values in a vector.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>summary()</td>\n",
    "        <td>Provides minimum, maximum, first quartile, median, mean, third quartile, and maximum for values in a vector.</td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b3f800-0a14-4d13-8c32-390965c537ca",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 8 - Hands-On<a class=\"anchor\" id=\"DS102L4_page_8\"></a>\n",
    "\n",
    "[Back to Top](#DS102L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4597e4b4-ce22-448d-843e-eab5ba74a9c4",
   "metadata": {},
   "source": [
    "For your Lesson 4 Practice Hands-On, you will be calculating the answer to several questions. This Hands-On will not be graded, but you are encouraged to complete it. The best way to become a great data scientist is to practice! Once you have submitted your project, you will be able to access the solution on the next page. Please write your answers within one Word Document (or an equivalent) and submit this file, along with your R file, in area below. \n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>You may want to watch <a href=\"https://vimeo.com/438392224\">this recorded live workshop </a> before beginning the hands-on, which goes over a similar example.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "## Requirements\n",
    "\n",
    "The eruption times for Old Faithful are clustered into two different groups. One group is short eruptions, and the other group is long eruptions. Short eruptions last three minutes or less, while long eruptions last more than three minutes. As below, define the vector ```eruptions.times``` as:\n",
    "\n",
    "```eruptions.times <- faithful$eruptions```\n",
    "\n",
    "Split the vector ```eruptions.times``` into two vectors: a vector ```short``` that contains the times less than or equal to three minutes, and a vector ```long``` that contains the times greater than three minutes. Answer the following questions:\n",
    "\n",
    "1. How many elements are in the vector ```short```?\n",
    "\n",
    "2. How many elements are in the vector ```long```?\n",
    "\n",
    "3. What is the mean erruption time of the short eruptions?\n",
    "\n",
    "4. What is the mean erruption time of the long eruptions?\n",
    "\n",
    "5. What is the standard deviation of the short eruption times?\n",
    "\n",
    "6. What is the standard deviation of the long eruption times?\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Be sure to zip and submit your entire document when finished!</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>To zip your file on <b>Windows</b>, right click on the file and select \"Send to\", then select \"Compressed (zipped) folder\". For <b>Mac</b> users, right click on the file and select \"Compress\", then select your file from the options.</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36943bcd-7e16-4af1-97d3-c09e81ae5e99",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 9 - Solution<a class=\"anchor\" id=\"DS102L4_page_9\"></a>\n",
    "\n",
    "[Back to Top](#DS102L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdf2cdde-9447-49b5-8936-17d80f46b45e",
   "metadata": {},
   "source": [
    "\n",
    "Below is the solution to your Lesson 4 Practice Hands-On\n",
    "\n",
    "1.  How many elements are in the vector short?\n",
    "\n",
    "    * 97\n",
    "\n",
    "2)  How many elements are in the vector long?\n",
    "\n",
    "    * 175\n",
    "    \n",
    "3)  Which of the following is the mean eruption time of the short eruptions?\n",
    "\n",
    "    * 2.038134\n",
    "\n",
    "4.  Which of the following is the mean eruption time of the long eruptions?\n",
    "\n",
    "    * 4.291303\n",
    "\n",
    "5.  Which of the following is the standard deviation of the short eruption times?\n",
    "\n",
    "    * 0.2668655\n",
    "\n",
    "6.  Which of the following is the standard deviation of the long eruption times?\n",
    "\n",
    "    * 0.4108516\n",
    "\n",
    "---\n",
    "\n",
    "## Code to Achieve Solution\n",
    "\n",
    "\n",
    "# This splits it into a short and long vector\n",
    "\n",
    "short <- eruptions.times[eruptions.times <= 3]\n",
    "long <- eruptions.times[eruptions.times > 3]\n",
    "\n",
    "### Question 1 - How many elements are in the short vector?\n",
    "\n",
    "length(short)\n",
    "\n",
    "### Question 2 - How many elements are in the long vector?\n",
    "\n",
    "length(long)\n",
    "\n",
    "### Question 3 - Mean wait time of short? \n",
    "\n",
    "mean(short)\n",
    "\n",
    "### Question 4 - Mean wait time of long?\n",
    "\n",
    "mean(long)\n",
    "\n",
    "### Question 5 - Standard deviation of short?\n",
    "\n",
    "sd(short)\n",
    "\n",
    "### Question 6 - Standard deviation of long?\n",
    "\n",
    "sd(long)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14364896-ed6d-4e0e-a998-6c5eddb263dc",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}