R Basic Programming Part 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## R Programming: Basic Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a  program to get the details of the objects in memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"n1\"   \"n2\"   \"name\" \"nums\"\n",
      "[1] \"Details of the objects in memory:\"\n",
      "n1 :  num 10\n",
      "n2 :  num 0.5\n",
      "name :  chr \"R\"\n",
      "nums :  num [1:6] 10 20 30 40 50 60\n"
     ]
    }
   ],
   "source": [
    "name = \"R\"; \n",
    "n1 =  10; \n",
    "n2 =  0.5\n",
    "nums = c(10, 20, 30, 40, 50, 60)\n",
    "print(ls())\n",
    "print(\"Details of the objects in memory:\")\n",
    "print(ls.str())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to create a sequence of numbers from 20 to 50 and find the mean of numbers from 20 to 60 and sum of numbers from 51 to 91."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Sequence of numbers from 20 to 50:\"\n",
      " [1] 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44\n",
      "[26] 45 46 47 48 49 50\n",
      "[1] \"Mean of numbers from 20 to 60:\"\n",
      "[1] 40\n",
      "[1] \"Sum of numbers from 51 to 91:\"\n",
      "[1] 2911\n"
     ]
    }
   ],
   "source": [
    "print(\"Sequence of numbers from 20 to 50:\")\n",
    "print(seq(20,50))\n",
    "print(\"Mean of numbers from 20 to 60:\")\n",
    "print(mean(20:60))\n",
    "print(\"Sum of numbers from 51 to 91:\")\n",
    "print(sum(51:91))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to create a vector which contains 10 random integer values between -50 and +50."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Content of the vector:\"\n",
      "[1] \"10 random integer values between -50 and +50:\"\n",
      " [1]  17 -48 -11 -30  27  13  50 -47  24 -28\n"
     ]
    }
   ],
   "source": [
    "v = sample(-50:50, 10, replace=TRUE)\n",
    "print(\"Content of the vector:\")\n",
    "print(\"10 random integer values between -50 and +50:\")\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to get the first 10 Fibonacci numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"First 10 Fibonacci numbers:\"\n",
      " [1]  1  1  2  3  5  8 13 21 34 55\n"
     ]
    }
   ],
   "source": [
    "Fibonacci <- numeric(10)\n",
    "Fibonacci[1] <- Fibonacci[2] <- 1\n",
    "for (i in 3:10) Fibonacci[i] <- Fibonacci[i - 2] + Fibonacci[i - 1]\n",
    "print(\"First 10 Fibonacci numbers:\")\n",
    "print(Fibonacci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a  program to get all prime numbers up to a given number (based on the sieve of Eratosthenes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "\t<li>5</li>\n",
       "\t<li>7</li>\n",
       "\t<li>11</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 2\n",
       "\\item 3\n",
       "\\item 5\n",
       "\\item 7\n",
       "\\item 11\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 2\n",
       "2. 3\n",
       "3. 5\n",
       "4. 7\n",
       "5. 11\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1]  2  3  5  7 11"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prime_numbers <- function(n) {\n",
    "if (n >= 2) {\n",
    " x = seq(2, n)\n",
    " prime_nums = c()\n",
    " for (i in seq(2, n)) {\n",
    " if (any(x == i)) {\n",
    " prime_nums = c(prime_nums, i)\n",
    " x = c(x[(x %% i) != 0], i)\n",
    " }\n",
    " }\n",
    " return(prime_nums)\n",
    " }\n",
    " else \n",
    " {\n",
    " stop(\"Input number should be at least 2.\")\n",
    " }\n",
    " } \n",
    "prime_numbers(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to print the numbers from 1 to 100 and print \"Fizz\" for multiples of 3, print \"Buzz\" for multiples of 5, and print \"FizzBuzz\" for multiples of both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": [
    "for (n in 1:100) {\n",
    " if (n %% 3 == 0 & n %% 5 == 0) {print(\"FizzBuzz\")}\n",
    " else if (n %% 3 == 0) {print(\"Fizz\")}\n",
    " else if (n %% 5 == 0) {print(\"Buzz\")}\n",
    " else print(n)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to extract first 10 english letter in lower case and last 10 letters in upper case and extract letters between 22nd to 24th letters in upper case\n",
    "\n",
    "Note: Use built-in datasets letters and LETTERS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"First 10 letters in lower case:\"\n",
      " [1] \"a\" \"b\" \"c\" \"d\" \"e\" \"f\" \"g\" \"h\" \"i\" \"j\"\n",
      "[1] \"Last 10 letters in upper case:\"\n",
      " [1] \"Q\" \"R\" \"S\" \"T\" \"U\" \"V\" \"W\" \"X\" \"Y\" \"Z\"\n",
      "[1] \"Letters between 22nd to 24th letters in upper case:\"\n",
      "[1] \"V\" \"W\" \"X\"\n"
     ]
    }
   ],
   "source": [
    "print(\"First 10 letters in lower case:\")\n",
    "t = head(letters, 10)\n",
    "print(t)\n",
    "print(\"Last 10 letters in upper case:\")\n",
    "t = tail(LETTERS, 10)\n",
    "print(t)\n",
    "print(\"Letters between 22nd to 24th letters in upper case:\")\n",
    "e = tail(LETTERS[22:24])\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to find the factors of a given number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"The factors of 4 are:\"\n",
      "[1] 1\n",
      "[1] 2\n",
      "[1] 4\n",
      "[1] \"The factors of 7 are:\"\n",
      "[1] 1\n",
      "[1] 7\n",
      "[1] \"The factors of 12 are:\"\n",
      "[1] 1\n",
      "[1] 2\n",
      "[1] 3\n",
      "[1] 4\n",
      "[1] 6\n",
      "[1] 12\n"
     ]
    }
   ],
   "source": [
    "print_factors = function(n) {\n",
    "print(paste(\"The factors of\",n,\"are:\"))\n",
    "for(i in 1:n) {\n",
    "if((n %% i) == 0) {\n",
    "print(i)\n",
    "}\n",
    "}\n",
    "}\n",
    "print_factors(4)\n",
    "print_factors(7)\n",
    "print_factors(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to find the maximum and the minimum value of a given vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Original vector:\"\n",
      "[1] 10 20 30 40 50 60\n",
      "[1] \"Maximum value of the said vector: 60\"\n",
      "[1] \"Minimum value of the said vector: 10\"\n"
     ]
    }
   ],
   "source": [
    "nums = c(10, 20, 30, 40, 50, 60)\n",
    "print('Original vector:')\n",
    "print(nums)   \n",
    "print(paste(\"Maximum value of the said vector:\",max(nums)))\n",
    "print(paste(\"Minimum value of the said vector:\",min(nums)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a R program to get the unique elements of a given string and unique numbers of vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Original vector(string)\"\n",
      "[1] \"The quick brown fox jumps over the lazy dog.\"\n",
      "[1] \"Unique elements of the said vector:\"\n",
      "[1] \"the quick brown fox jumps over the lazy dog.\"\n",
      "[1] \"Original vector(number)\"\n",
      "[1] 1 2 2 3 4 4 5 6\n",
      "[1] \"Unique elements of the said vector:\"\n",
      "[1] 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "str1 = \"The quick brown fox jumps over the lazy dog.\"\n",
    "print(\"Original vector(string)\")\n",
    "print(str1)\n",
    "print(\"Unique elements of the said vector:\")\n",
    "print(unique(tolower(str1)))\n",
    "nums = c(1, 2, 2, 3, 4, 4, 5, 6)\n",
    "print(\"Original vector(number)\")\n",
    "print(nums)\n",
    "print(\"Unique elements of the said vector:\")\n",
    "print(unique(nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to create three vectors a,b,c with 3 integers. Combine the three vectors to become a 3×3 matrix where each column represents a vector. Print the content of the matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Content of the said matrix:\"\n",
      "     a b c\n",
      "[1,] 1 4 7\n",
      "[2,] 2 5 8\n",
      "[3,] 3 6 9\n"
     ]
    }
   ],
   "source": [
    "a<-c(1,2,3)\n",
    "b<-c(4,5,6)\n",
    "c<-c(7,8,9)\n",
    "m<-cbind(a,b,c)\n",
    "print(\"Content of the said matrix:\")\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to create a list of random numbers in normal distribution and count occurrences of each value.\n",
    "\n",
    "Note: Sample random numbers in normal distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"List of random numbers in normal distribution:\"\n",
      "   [1]   10  -44   61   50  282   60   83 -136 -132  200   29  150  -73  -85\n",
      "  [15]   16   18   32  -43  138  108  -97  197  146   12  146  -60   28   91\n",
      "  [29]  -41   23  150  254   13   35  100  -28   49   43  168   25  101  -71\n",
      "  [43]    9  250  -13  -18  -17 -117  104  131   98   54  -32   46  114  135\n",
      "  [57]  -19   12   -4  -25   -5  -32  -30  -16  -45  145   57   -6   93  139\n",
      "  [71]  -17   24   53  130  -39   53   19   23  184    3  -12 -234   67  -71\n",
      "  [85]  106  141  -15   23   24   20   36  138    6   37  107  151  186   87\n",
      "  [99]  147   97   19  176  130   37  172   68    7   52  179   92 -125  176\n",
      " [113]  124  235   59  188  159   60   69   42   69  -28  -18  -58  -16   99\n",
      " [127]  -17   99  119  114  -80  104   80    5   22   29   33   85  108  165\n",
      " [141]   60   93  225  128    8   82   77    0  196   67   57   58  -53  126\n",
      " [155]  -71   78   -9   53   82    5   48   11  156    7  259  110   50  111\n",
      " [169]  260  121  111 -207  -92  156  -75   17  110   50   39   30   71 -114\n",
      " [183]   18   32  -79   85  -31  306   41  -89  -40 -121  134  187 -134 -159\n",
      " [197]  193   21  131  118   27   35   41  -68   11  -37   74  -95  168   16\n",
      " [211]   25   74  -80   36  -65   28   96  -70  122  -20  196  -36    9  -30\n",
      " [225]  130   68  -80 -125  160  -87   74  195   46  255    0   -8 -115  -17\n",
      " [239]  -55   42   95   64 -119   80  -31  108   81  -58   -7   98  -55  -54\n",
      " [253]  -62  136 -109  -15  -45  -33  136    7  -10  102 -108  -68  -54  175\n",
      " [267]  196  -15  158  113   65    6   67  108   59  173  133  262 -107   53\n",
      " [281]  125   61   35   71  -86  104   58 -107   25   37  111   77 -136  -91\n",
      " [295]  -78   16  -87   29   42  389  185  138  -15  -38  114  126  157  -55\n",
      " [309]  -68   42   93  194   47   99   65   40  -77  111  -77  -90    7   43\n",
      " [323]  191  -45   51  132  185  119   90 -213  -51  123   60   89  166    3\n",
      " [337]   67  223 -275  -50   64   36  -21   95 -113 -160   31    5   71   77\n",
      " [351]  159  -62 -134  184    4    2   -9   16  -72   70   33  173   33  -52\n",
      " [365]  -19  127  183   32  106   73 -135   58  133   56    5  -19  102  241\n",
      " [379]  -30   -4   75 -147   23   89  197  114   51   65  112  247   62   81\n",
      " [393]   25   37  178   13  -51   87 -120  143   14   38  109  111   94 -144\n",
      " [407]   -3   61   11 -116   39  -35  205  106   82   90   82   45  -14  124\n",
      " [421]  -14 -148  174  129   24   71   56  363   10   37   68  131   74   97\n",
      " [435]  -42  104  143  121  121  114   61   -9   88   60 -142  214  115   92\n",
      " [449]  -60   90  140  148   49  -52 -173   35  -19 -122 -168  206 -110   -1\n",
      " [463]  -80   47   71  -33   84  -60  -66   53   34  214  109  195  275  124\n",
      " [477]  146   46   40  135   68   74   37    6  185   22  -47 -209  229  140\n",
      " [491]  146  101  198  145   20  221  -24   54   41  -19  249    0  -32  -19\n",
      " [505]  230   57  -91  129  -17    1  108   56  175   52  -70  -44   33   -8\n",
      " [519]  -13  130  -64   25   87  -11  190   83  117   61  -41  -49  -17  235\n",
      " [533]  233   67  228   45  -43  -12   53  -45  120  115    6  103   39   35\n",
      " [547]  100   -8 -154   93  -27    2   22  132  197   -9   23  133   56   84\n",
      " [561]  150   61  -20  171    0  -36  113  288    8  -76   31  -27   71  -86\n",
      " [575]   78   59   63  -81    8   31  199  -36  116  -47   91  100   93    9\n",
      " [589]   39  124  -10   22   -9    3   68  -88  -36   55  -40   42   44  -46\n",
      " [603] -147  137  132  151  -19  207  167    6  102  -79  159  199   80  -92\n",
      " [617]  193  183  -32   66  135    3   81   39   52   88  152  -47  128  -66\n",
      " [631]   88  213  -52  -32   38  -21  119  292   33  -21   79  140  112  -48\n",
      " [645]    2   23  -26  -33  -60  193   50  156 -151   44  -90   92  -16  181\n",
      " [659]  134   56  115  -19   12  132  117  158  -86   25   28    7  172   47\n",
      " [673]  136  183    1  105   -6    3   80   -4  124  223  125   61  129   39\n",
      " [687]    3  -78   58   10   11   69   74  132   -4  297  109  117  143  185\n",
      " [701]  109  -40  165  137   46  166   98  131  105  154  245 -159  117   46\n",
      " [715]   67  -44   -4 -164   76  -31  -26   79   71   49  123   18  -29  -36\n",
      " [729]   68  -28 -103  -55   -9  -39  -16   93  166   41   23  -94   84    4\n",
      " [743]  -57   85  172   19   39  -50  -52  268 -215  -15  159  -63  167  161\n",
      " [757]   96  -12  292   83  169   15   47   11  -12  -33   71  -52    8  124\n",
      " [771]  189  245  -44  -88  161   27  119  129 -101  302   60  227  -22   37\n",
      " [785]  223  169   96   24  -22  148   99  134   -6   44  -92   35   46  -61\n",
      " [799]  103    1  147  -30 -133  -15  141  -49   43  164  202   71  -28  147\n",
      " [813]   41  126  188  200   66 -133   60  -34   63   20  103  -71  -31  208\n",
      " [827]   67  177  -42  -45  -11  -53   46  143   55   -3    6   15  -16 -107\n",
      " [841]  143   68  150  178   33  -56  -42  111  195   39   43 -105    3  163\n",
      " [855]  -55  -51  -79 -123   87   57  113   24   47  121 -197   10   21  208\n",
      " [869]   -1  -74  202   84  -14  -28  -33  234  261  199 -144  103   13  134\n",
      " [883]   34  100  -16   29   88   51  -38  168  -69   28 -131   72  121   34\n",
      " [897]  -55  -68   55   24  227  -12  104  119   97  -26   42  -34   49   54\n",
      " [911]  130   87  121  -47   14   95   40 -115   48  -37  106  -55  134   49\n",
      " [925]  131   92   70   81   46  139   79    2   28  -57 -140  -46   35  146\n",
      " [939]  135  -52   45   47   51  217   83  186  -38  169   45   76  197 -150\n",
      " [953]  -75  142   20   80  115  -70  -55 -235   24   13 -106  116   90   24\n",
      " [967]   99  -78  139  -33  -24  131  185  114  130   73  -12  118  160   89\n",
      " [981]   -5  -31  -14  126   95  117   86  -54  179   -2    6  237   78  -82\n",
      " [995]  -78   64   49  142 -153   86\n",
      "[1] \"Count occurrences of each value:\"\n",
      "n\n",
      "-275 -235 -234 -215 -213 -209 -207 -197 -173 -168 -164 -160 -159 -154 -153 -151 \n",
      "   1    1    1    1    1    1    1    1    1    1    1    1    2    1    1    1 \n",
      "-150 -148 -147 -144 -142 -140 -136 -135 -134 -133 -132 -131 -125 -123 -122 -121 \n",
      "   1    1    2    2    1    1    2    1    2    2    1    1    2    1    1    1 \n",
      "-120 -119 -117 -116 -115 -114 -113 -110 -109 -108 -107 -106 -105 -103 -101  -97 \n",
      "   1    1    1    1    2    1    1    1    1    1    3    1    1    1    1    1 \n",
      " -95  -94  -92  -91  -90  -89  -88  -87  -86  -85  -82  -81  -80  -79  -78  -77 \n",
      "   1    1    3    2    2    1    2    2    3    1    1    1    4    3    4    2 \n",
      " -76  -75  -74  -73  -72  -71  -70  -69  -68  -66  -65  -64  -63  -62  -61  -60 \n",
      "   1    2    1    1    1    4    3    1    4    2    1    1    1    2    1    4 \n",
      " -58  -57  -56  -55  -54  -53  -52  -51  -50  -49  -48  -47  -46  -45  -44  -43 \n",
      "   2    2    1    8    3    2    6    3    2    2    1    4    2    5    4    2 \n",
      " -42  -41  -40  -39  -38  -37  -36  -35  -34  -33  -32  -31  -30  -29  -28  -27 \n",
      "   3    2    3    2    3    2    5    1    2    6    5    5    4    1    5    2 \n",
      " -26  -25  -24  -22  -21  -20  -19  -18  -17  -16  -15  -14  -13  -12  -11  -10 \n",
      "   3    1    2    2    3    2    8    2    6    6    6    4    2    6    2    2 \n",
      "  -9   -8   -7   -6   -5   -4   -3   -2   -1    0    1    2    3    4    5    6 \n",
      "   6    3    1    3    2    5    2    1    2    4    3    4    7    2    4    7 \n",
      "   7    8    9   10   11   12   13   14   15   16   17   18   19   20   21   22 \n",
      "   5    4    3    4    5    3    4    2    2    4    1    3    3    4    2    4 \n",
      "  23   24   25   27   28   29   30   31   32   33   34   35   36   37   38   39 \n",
      "   7    8    6    2    5    4    1    3    3    6    3    7    3    7    2    8 \n",
      "  40   41   42   43   44   45   46   47   48   49   50   51   52   53   54   55 \n",
      "   3    5    6    4    3    4    8    6    2    6    4    4    3    6    3    3 \n",
      "  56   57   58   59   60   61   62   63   64   65   66   67   68   69   70   71 \n",
      "   5    4    4    3    7    7    1    2    3    3    2    7    7    3    2    9 \n",
      "  72   73   74   75   76   77   78   79   80   81   82   83   84   85   86   87 \n",
      "   1    2    6    1    2    3    3    3    5    4    4    4    4    3    2    5 \n",
      "  88   89   90   91   92   93   94   95   96   97   98   99  100  101  102  103 \n",
      "   4    3    4    2    4    6    1    4    3    3    3    5    4    2    3    4 \n",
      " 104  105  106  107  108  109  110  111  112  113  114  115  116  117  118  119 \n",
      "   5    2    4    1    5    4    2    6    2    3    6    4    2    5    2    5 \n",
      " 120  121  122  123  124  125  126  127  128  129  130  131  132  133  134  135 \n",
      "   1    6    1    2    6    2    4    1    2    4    6    6    5    3    5    4 \n",
      " 136  137  138  139  140  141  142  143  145  146  147  148  150  151  152  154 \n",
      "   3    2    3    3    3    2    2    5    2    5    3    2    4    2    1    1 \n",
      " 156  157  158  159  160  161  163  164  165  166  167  168  169  171  172  173 \n",
      "   3    1    2    4    2    2    1    1    2    3    2    3    3    1    3    2 \n",
      " 174  175  176  177  178  179  181  183  184  185  186  187  188  189  190  191 \n",
      "   1    2    2    1    2    2    1    3    2    5    2    1    2    1    1    1 \n",
      " 193  194  195  196  197  198  199  200  202  205  206  207  208  213  214  217 \n",
      "   3    1    3    3    4    1    3    2    2    1    1    1    2    1    2    1 \n",
      " 221  223  225  227  228  229  230  233  234  235  237  241  245  247  249  250 \n",
      "   1    3    1    2    1    1    1    1    1    2    1    1    2    1    1    1 \n",
      " 254  255  259  260  261  262  268  275  282  288  292  297  302  306  363  389 \n",
      "   1    1    1    1    1    1    1    1    1    1    2    1    1    1    1    1 \n"
     ]
    }
   ],
   "source": [
    "n = floor(rnorm(1000, 50, 100))\n",
    "print('List of random numbers in normal distribution:')\n",
    "print(n)\n",
    "t = table(n)\n",
    "print(\"Count occurrences of each value:\")\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a R program to read the .csv file and display the content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning message in file(file, \"rt\"):\n",
      "“cannot open file 'movies.csv': No such file or directory”"
     ]
    },
    {
     "ename": "ERROR",
     "evalue": "Error in file(file, \"rt\"): cannot open the connection\n",
     "output_type": "error",
     "traceback": [
      "Error in file(file, \"rt\"): cannot open the connection\nTraceback:\n",
      "1. read.csv(file = \"movies.csv\", header = TRUE, sep = \",\")",
      "2. read.table(file = file, header = header, sep = sep, quote = quote, \n .     dec = dec, fill = fill, comment.char = comment.char, ...)",
      "3. file(file, \"rt\")"
     ]
    }
   ],
   "source": [
    "movie_data = read.csv(file=\"movies.csv\", header=TRUE, sep=\",\")\n",
    "print(\"Content of the .csv file:\")\n",
    "print(movie_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to create three vectors numeric data, character data and logical data. Display the content of the vectors and their type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]  1  2  5  3  4  0 -1 -3\n",
      "[1] \"double\"\n",
      "[1] \"Red\"   \"Green\" \"White\"\n",
      "[1] \"character\"\n",
      "[1]  TRUE  TRUE  TRUE FALSE  TRUE FALSE\n",
      "[1] \"logical\"\n"
     ]
    }
   ],
   "source": [
    "a = c(1, 2, 5, 3, 4, 0, -1, -3)\n",
    "b = c(\"Red\", \"Green\", \"White\")\n",
    "c = c(TRUE, TRUE, TRUE, FALSE, TRUE, FALSE)\n",
    "print(a)\n",
    "print(typeof(a))\n",
    "print(b)\n",
    "print(typeof(b))\n",
    "print(c)\n",
    "print(typeof(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a R program to create a 5 × 4 matrix , 3 × 3 matrix with labels and fill the matrix by rows and 2 × 2 matrix with labels and fill the matrix by columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"5 × 4 matrix:\"\n",
      "     [,1] [,2] [,3] [,4]\n",
      "[1,]    1    6   11   16\n",
      "[2,]    2    7   12   17\n",
      "[3,]    3    8   13   18\n",
      "[4,]    4    9   14   19\n",
      "[5,]    5   10   15   20\n",
      "[1] \"3 × 3 matrix with labels, filled by rows: \"\n",
      "     Col1 Col2 Col3\n",
      "Row1    1    3    5\n",
      "Row2    7    8    9\n",
      "Row3   11   12   14\n",
      "[1] \"3 × 3 matrix with labels, filled by columns: \"\n",
      "     Col1 Col2 Col3\n",
      "Row1    1    7   11\n",
      "Row2    3    8   12\n",
      "Row3    5    9   14\n"
     ]
    }
   ],
   "source": [
    "m1 = matrix(1:20, nrow=5, ncol=4)\n",
    "print(\"5 × 4 matrix:\")\n",
    "print(m1)\n",
    "cells = c(1,3,5,7,8,9,11,12,14)\n",
    "rnames = c(\"Row1\", \"Row2\", \"Row3\")\n",
    "cnames = c(\"Col1\", \"Col2\", \"Col3\")\n",
    "m2 = matrix(cells, nrow=3, ncol=3, byrow=TRUE, dimnames=list(rnames, cnames))\n",
    "print(\"3 × 3 matrix with labels, filled by rows: \")\n",
    "print(m2)\n",
    "print(\"3 × 3 matrix with labels, filled by columns: \")\n",
    "m3 = matrix(cells, nrow=3, ncol=3, byrow=FALSE, dimnames=list(rnames, cnames))\n",
    "print(m3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}