29 R Functions Exercises .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# R Functions Exercises\n",
    "\n",
    "Let's test your knowledge of the functions in R! For these exercises, you'll be given instructions to create functions that take in certain inputs and give certain outputs.\n",
    "\n",
    "#### 1) Create a function that takes in a name as a string argument, and prints out \"Hello 'name' \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Hello Mike\"\n"
     ]
    }
   ],
   "source": [
    "hello(\"Mike\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2) Create a function that takes in a name as a string argument and returns a string of the form - \"Hello name\". Assign \"Hello name\" to a variable and print it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Hello Andrew\"\n"
     ]
    }
   ],
   "source": [
    "a.friendly.greeting <- hello2(\"Andrew\")\n",
    "print(a.friendly.greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3) Create a function that will return the product of two integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "12"
      ],
      "text/latex": [
       "12"
      ],
      "text/markdown": [
       "12"
      ],
      "text/plain": [
       "[1] 12"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "multiply(4,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4) Create a function that accepts two arguments, an integer and a vector of integers. It returns TRUE if the integer is present in the vector, otherwise it will return FALSE.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "TRUE"
      ],
      "text/latex": [
       "TRUE"
      ],
      "text/markdown": [
       "TRUE"
      ],
      "text/plain": [
       "[1] TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "number.check(3,c(1,2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "FALSE"
      ],
      "text/latex": [
       "FALSE"
      ],
      "text/markdown": [
       "FALSE"
      ],
      "text/plain": [
       "[1] FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "number.check(55,c(1,2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5) Create a function that accepts two arguments, an integer and a vector of integers. It returns the count of the number of occurences of the integer in the input vector. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "5"
      ],
      "text/latex": [
       "5"
      ],
      "text/markdown": [
       "5"
      ],
      "text/plain": [
       "[1] 5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "number.counter(2,c(2,2,2,2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3"
      ],
      "text/latex": [
       "3"
      ],
      "text/markdown": [
       "3"
      ],
      "text/plain": [
       "[1] 3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "number.counter(2,c(2,1,2,1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "0"
      ],
      "text/latex": [
       "0"
      ],
      "text/markdown": [
       "0"
      ],
      "text/plain": [
       "[1] 0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "number.counter(2,c(3,1,3,1,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5) Create a function that takes in a vector of numbers. For every number is divisible by 3, write \"fizz\". Every number that is divisible by 5, write \"buzz\", and every number that is divisible by 15, write \"fizzbuzz\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 1\n",
      "[1] 2\n",
      "[1] \"fizz\"\n",
      "[1] 4\n",
      "[1] \"buzz\"\n",
      "[1] \"fizz\"\n",
      "[1] 7\n",
      "[1] 8\n",
      "[1] \"fizz\"\n",
      "[1] \"buzz\"\n",
      "[1] 11\n",
      "[1] \"fizz\"\n",
      "[1] 13\n",
      "[1] 14\n",
      "[1] \"fizzbuzz\"\n",
      "[1] 16\n",
      "[1] 17\n",
      "[1] \"fizz\"\n",
      "[1] 19\n",
      "[1] \"buzz\"\n",
      "[1] \"fizz\"\n",
      "[1] 22\n",
      "[1] 23\n",
      "[1] \"fizz\"\n",
      "[1] \"buzz\"\n",
      "[1] 26\n",
      "[1] \"fizz\"\n",
      "[1] 28\n",
      "[1] 29\n",
      "[1] \"fizzbuzz\"\n",
      "[1] 31\n",
      "[1] 32\n",
      "[1] \"fizz\"\n",
      "[1] 34\n",
      "[1] \"buzz\"\n",
      "[1] \"fizz\"\n",
      "[1] 37\n",
      "[1] 38\n",
      "[1] \"fizz\"\n",
      "[1] \"buzz\"\n",
      "[1] 41\n",
      "[1] \"fizz\"\n",
      "[1] 43\n",
      "[1] 44\n",
      "[1] \"fizzbuzz\"\n",
      "[1] 46\n",
      "[1] 47\n",
      "[1] \"fizz\"\n",
      "[1] 49\n",
      "[1] \"buzz\"\n",
      "[1] \"fizz\"\n",
      "[1] 52\n",
      "[1] 53\n",
      "[1] \"fizz\"\n",
      "[1] \"buzz\"\n",
      "[1] 56\n",
      "[1] \"fizz\"\n",
      "[1] 58\n",
      "[1] 59\n",
      "[1] \"fizzbuzz\"\n",
      "[1] 61\n",
      "[1] 62\n",
      "[1] \"fizz\"\n",
      "[1] 64\n",
      "[1] \"buzz\"\n",
      "[1] \"fizz\"\n",
      "[1] 67\n",
      "[1] 68\n",
      "[1] \"fizz\"\n",
      "[1] \"buzz\"\n",
      "[1] 71\n",
      "[1] \"fizz\"\n",
      "[1] 73\n",
      "[1] 74\n",
      "[1] \"fizzbuzz\"\n",
      "[1] 76\n",
      "[1] 77\n",
      "[1] \"fizz\"\n",
      "[1] 79\n",
      "[1] \"buzz\"\n",
      "[1] \"fizz\"\n",
      "[1] 82\n",
      "[1] 83\n",
      "[1] \"fizz\"\n",
      "[1] \"buzz\"\n",
      "[1] 86\n",
      "[1] \"fizz\"\n",
      "[1] 88\n",
      "[1] 89\n",
      "[1] \"fizzbuzz\"\n",
      "[1] 91\n",
      "[1] 92\n",
      "[1] \"fizz\"\n",
      "[1] 94\n",
      "[1] \"buzz\"\n",
      "[1] \"fizz\"\n",
      "[1] 97\n",
      "[1] 98\n",
      "[1] \"fizz\"\n",
      "[1] \"buzz\"\n"
     ]
    }
   ],
   "source": [
    "vector <- c(1:100)\n",
    "fizzbuzz(vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6)  We want to ship bars of aluminum. We will create a function that accepts an integer representing the requested kilograms of aluminum for the package to be shipped. To fullfill these order, we have small bars (1 kilogram each) and big bars (5 kilograms each). Return the least number of bars needed.\n",
    "\n",
    "#### For example, a load of 6 kg requires a minimum of two bars (1 5kg bars and 1 1kg bars). A load of 17 kg requires a minimum of 5 bars (3 5kg bars and 2 1kg bars)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'14 bars'"
      ],
      "text/latex": [
       "'14 bars'"
      ],
      "text/markdown": [
       "'14 bars'"
      ],
      "text/plain": [
       "[1] \"14 bars\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bar_count(54)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'5 bars'"
      ],
      "text/latex": [
       "'5 bars'"
      ],
      "text/markdown": [
       "'5 bars'"
      ],
      "text/plain": [
       "[1] \"5 bars\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bar_count(17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7) Create a function that accepts 3 integer values and returns their sum. However, if an integer value is evenly divisible by 3, then it does not count towards the sum. Return zero if all numbers are evenly divisible by 3. Hint: You may want to use the append() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "9"
      ],
      "text/latex": [
       "9"
      ],
      "text/markdown": [
       "9"
      ],
      "text/plain": [
       "[1] 9"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sum.but.3(7,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "0"
      ],
      "text/latex": [
       "0"
      ],
      "text/markdown": [
       "0"
      ],
      "text/plain": [
       "[1] 0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sum.but.3(3,6,9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "11"
      ],
      "text/latex": [
       "11"
      ],
      "text/markdown": [
       "11"
      ],
      "text/plain": [
       "[1] 11"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sum.but.3(9,11,12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 8) Create a function that will return TRUE if an input integer is prime. Otherwise, return FALSE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "TRUE"
      ],
      "text/latex": [
       "TRUE"
      ],
      "text/markdown": [
       "TRUE"
      ],
      "text/plain": [
       "[1] TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prime_check(31)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "FALSE"
      ],
      "text/latex": [
       "FALSE"
      ],
      "text/markdown": [
       "FALSE"
      ],
      "text/plain": [
       "[1] FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prime_check(22)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "TRUE"
      ],
      "text/latex": [
       "TRUE"
      ],
      "text/markdown": [
       "TRUE"
      ],
      "text/plain": [
       "[1] TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prime_check(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "FALSE"
      ],
      "text/latex": [
       "FALSE"
      ],
      "text/markdown": [
       "FALSE"
      ],
      "text/plain": [
       "[1] FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prime_check(889091929) # 11 x 47 x 197 x 10007"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "TRUE"
      ],
      "text/latex": [
       "TRUE"
      ],
      "text/markdown": [
       "TRUE"
      ],
      "text/plain": [
       "[1] TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prime_check(904265051) # real prime (this may take several minutes to run)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}