11_assignment_part_2(1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2_DDEYFXETwS"
   },
   "source": [
    "# NumPy Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "40PhP9a8Esjb"
   },
   "source": [
    "## Importing NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "k0WgPPI5Euol"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a28y9usfEX1r"
   },
   "source": [
    "## Task 1\n",
    "Write a single line of code to extract all numbers from the given NumPy array which are strictly less than a specified number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "sQMhYQklCeV1",
    "outputId": "c03f52f7-ee82-4897-8c03-00994b0fcd2d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.7, 4.9, 1.4, 2.8]\n"
     ]
    }
   ],
   "source": [
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wSj0WtDrFYtB"
   },
   "source": [
    "The task is to write **a single line of code** to print the numbers from the *numbers* array which are strictly less than *n*, that is, the numbers which are strictly less than 5. Write the code inside the print statement given below. The code should work for any array *numbers* and for any value of *n*, so use variables only, and not constants like 5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aHUWHdcsGKtb"
   },
   "source": [
    "The output for the given array should be :\n",
    "\n",
    "\n",
    "```\n",
    "[2.7 4.9 1.4 2.8]\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "id": "_QUQfEFCFQ--"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given array : \n",
      " [[5.  2.7 5.1]\n",
      " [4.9 6.2 8.5]\n",
      " [1.4 2.8 9.5]]\n",
      "[2.7 4.9 1.4 2.8]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "numbers = np.array([[5.0, 2.7, 5.1],\n",
    "                  [4.9, 6.2, 8.5],\n",
    "                  [1.4, 2.8, 9.5]])\n",
    "print(\"Given array : \\n\", numbers)\n",
    "print(numbers[numbers<5]) # Write your 1 line of code inside the print() statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s-SHVjWDRVev"
   },
   "source": [
    "## Task 2\n",
    "Write a single line of code to create an array of 15 sixes. You may only use the numpy.ones() function, and no other function may be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "0jApKxhdSwni"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6 6 6 6 6 6 6 6 6 6 6 6 6 6 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "array_of_sixes = np.ones(15,int) + 5 # Write your code after the assignment operator (=)\n",
    "\n",
    "print(array_of_sixes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YLOhE0g2S-_y"
   },
   "source": [
    "Th output of the above print statement should be :\n",
    "\n",
    "\n",
    "```\n",
    "[6. 6. 6. 6. 6. 6. 6. 6. 6. 6. 6. 6. 6. 6. 6.]\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C0ku9GFsTRa0"
   },
   "source": [
    "## Task 3\n",
    "Compute element-wise reciprocal of the given array. Do not use any functions. Write only 1 line of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "wRp0iF49aZYQ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         0.5        0.28571429 0.10869565]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "orig_Array = np.array([1, 2, 3.5, 9.2])\n",
    "\n",
    "print(1/orig_Array) # Write your 1 line of code inside the print statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WTuKus0cart5"
   },
   "source": [
    "The output of the above print statement should be :\n",
    "\n",
    "\n",
    "```\n",
    "[1.         0.5        0.28571429 0.10869565]\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JoEVPjena2TK"
   },
   "source": [
    "## Task 4\n",
    "Create a 4 x 2 x 3 3D-array of numbers from 4 to 27 (both inclusive). Use exactly two functions of NumPy to accomplish this. Write only one line of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "id": "sHYT9PRKbkk4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 4  5  6]\n",
      "  [ 7  8  9]]\n",
      "\n",
      " [[10 11 12]\n",
      "  [13 14 15]]\n",
      "\n",
      " [[16 17 18]\n",
      "  [19 20 21]]\n",
      "\n",
      " [[22 23 24]\n",
      "  [25 26 27]]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "mat_24 =  np.array(range(4,28))# Write your 1 line of code after the assignment operator (=)\n",
    "mat_24 = mat_24.reshape(4,2,3)\n",
    "print(mat_24)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yxq_d6SncIpU"
   },
   "source": [
    "The output of the above print statement should be :\n",
    "\n",
    "\n",
    "```\n",
    "[[[ 4  5  6]\n",
    "  [ 7  8  9]]\n",
    "\n",
    " [[10 11 12]\n",
    "  [13 14 15]]\n",
    "\n",
    " [[16 17 18]\n",
    "  [19 20 21]]\n",
    "\n",
    " [[22 23 24]\n",
    "  [25 26 27]]]\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "83B1jodtchs5"
   },
   "source": [
    "## Task 5\n",
    "Swap the first and the last, and the second and the third columns from the given 4x4 matrix. Write your code in one line and don't use any functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "SWhoIe6Xc0bE",
    "outputId": "aac670a3-3437-4a6d-9baf-d4e90f042f4c",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix : \n",
      " [[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]]\n",
      "[[ 3  2  1  0]\n",
      " [ 7  6  5  4]\n",
      " [11 10  9  8]\n",
      " [15 14 13 12]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "orig = np.arange(16, dtype='int').reshape(-1, 4)\n",
    "print(\"Original matrix : \\n\", orig)\n",
    "\n",
    "## Write Your code here\n",
    "orig[:,[0,3]],orig[:,[1,2]]  = orig[:,[3,0]],orig[:,[2,1]]\n",
    "print(orig)\n",
    "# Write your 1 line of code inside the print() statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yVVQWpQedTTU"
   },
   "source": [
    "The output of the above print statement should be :\n",
    "\n",
    "\n",
    "```\n",
    "[[ 3  2  1  0]\n",
    " [ 7  6  5  4]\n",
    " [11 10  9  8]\n",
    " [15 14 13 12]]\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bI1nlLuUde5k"
   },
   "source": [
    "## Task 6\n",
    "Create a matrix of dimensions m x n, with 0 being the values on the border, and all the values inside being 1. You may write maximum of 2 lines of code. The matrix name should be *mn_array*. It should work for any values of m and n. You are only allowed to use the numpy.zeros() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "id": "kyKqXyvvev2s"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 1. 1. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 1. 1. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "m = 9\n",
    "n = 7\n",
    "\n",
    "# Write your 2 lines of code here\n",
    "mn_array = np.zeros((m,n))\n",
    "mn_array[1:-1,1:-1]=1\n",
    "\n",
    "####\n",
    "\n",
    "print(mn_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PZQ553p6fZld"
   },
   "source": [
    "The output of the above print() statement should be :\n",
    "\n",
    "\n",
    "```\n",
    "[[0. 0. 0. 0. 0. 0. 0.]\n",
    " [0. 1. 1. 1. 1. 1. 0.]\n",
    " [0. 1. 1. 1. 1. 1. 0.]\n",
    " [0. 1. 1. 1. 1. 1. 0.]\n",
    " [0. 1. 1. 1. 1. 1. 0.]\n",
    " [0. 1. 1. 1. 1. 1. 0.]\n",
    " [0. 1. 1. 1. 1. 1. 0.]\n",
    " [0. 1. 1. 1. 1. 1. 0.]\n",
    " [0. 0. 0. 0. 0. 0. 0.]]\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YOHnL97ef3PT"
   },
   "source": [
    "## Task 7\n",
    "Get the value 78 from the given 3D array by indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "id": "bfZHspSMgIKa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "78"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr = np.array([[[34, 22, 3],\n",
    "                 [41, 25, 23]],\n",
    "                [[67, 28, 91],\n",
    "                 [110, 11, 21]],\n",
    "                [[16, 112, 44],\n",
    "                 [78, 20, 12]]])\n",
    "arr[2][1][0]\n",
    "\n",
    "#print(arr[x]) # Using indexing to get the element 78 from the array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d5rSnQPOhI8l"
   },
   "source": [
    "# The output of the above print() statement should be :\n",
    "\n",
    "\n",
    "```\n",
    "78\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c_KZEXpGhPji"
   },
   "source": [
    "## Task 8\n",
    "Find the weighted average of the given array using only the ndarray.sum() function. Write only 1 line of code. It should work for any weights or array values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "id": "fxeG4lP4i4K-"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14.05"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "orig_a = np.array([11, 12, 13, 14, 15, 16])\n",
    "weights = np.array([-1, 4, 5, 2, 9, 1])\n",
    "print(float(sum(np.multiply(orig_a,weights),)/sum(weights,)))\n",
    "#print(float((np.sum(np.multiply(orig_a,weights)))/len(weights))) # Write 1 line of code inside the print statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gMB5PwVCkCwy"
   },
   "source": [
    "The output of the above print() statement should be :\n",
    "\n",
    "\n",
    "```\n",
    "14.05\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Lxw807EDkLtk"
   },
   "source": [
    "## Task 9\n",
    "Calculate the difference between the maximum and the minimum values of a given array along the third axis. Use only the ndarray.min() and ndarray.max() functions. Write only 1 line of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Q8cqNcBvkt74",
    "outputId": "3da6935d-a116-440a-f03e-2afe85e9ced9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array : \n",
      " [[[ 13  21  12]\n",
      "  [ 76  10  25]\n",
      "  [ 63  17  82]\n",
      "  [ 19 130 115]\n",
      "  [122 134 124]\n",
      "  [159 176 174]]\n",
      "\n",
      " [[ 18 191 202]\n",
      "  [ 21 222  23]\n",
      "  [214  25 246]\n",
      "  [ 27   8  29]\n",
      "  [ 30  31   3]\n",
      "  [  3  34  35]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[  9,  66,  65, 111,  12,  17],\n",
       "       [184, 201, 221,  21,  28,  32]])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "Orig_array = np.array([[[13, 21, 12],\n",
    "                        [76, 10, 25],\n",
    "                        [63, 17, 82],\n",
    "                        [19, 130, 115],\n",
    "                        [122, 134, 124],\n",
    "                        [159, 176, 174]],\n",
    "                       [[18, 191, 202],\n",
    "                        [21, 222, 23],\n",
    "                        [214, 25, 246],\n",
    "                        [27, 8, 29],\n",
    "                        [30, 31, 3],\n",
    "                        [3, 34, 35]]])\n",
    "print(\"Original array : \\n\", Orig_array)\n",
    "np.amax(Orig_array, 2) - np.amin(Orig_array, 2)\n",
    "#print(max(Orig_array) - min(Orig_array)) # Write 1 line of code inside the print() statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wdF1vyuMmwhM"
   },
   "source": [
    "The output of the above print() statement should be :\n",
    "\n",
    "\n",
    "```\n",
    "[[  9  66  65 111  12  17]\n",
    " [184 201 221  21  28  32]]\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F89X69CDm4ar"
   },
   "source": [
    "## Task 10\n",
    "Create a linear scale (arithmetic progression) with n points starting from a, with a common difference of d. Calculate the standard deviation of an array of exponentials of each element of the linear scale. Write only 1 line of code. It should work for any values of n, a, and d."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {
    "id": "SFJMDqC7odhI"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.3820163896209162e+28\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "n = 10\n",
    "a = 3\n",
    "d = 7\n",
    "\n",
    "print(np.std(np.exp(np.linspace(a, a+(9*d), num=n)))) # Write 1 line of code inside the print() statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f6c0DEG7o059"
   },
   "source": [
    "The output of the above print() statement should be :\n",
    "\n",
    "\n",
    "```\n",
    "1.3820163896209162e+28\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lleAQbeapZT2"
   },
   "source": [
    "## Major Task\n",
    "First, create a chessboard of size n x n using NumPy. n can have any value, even or odd. If the square is black, its value should be 1, else, it should be 0. Now, we have an array of locations where some chess pieces are. Print whether the locations are black squares, or white. You will be given an array for score. If the piece is on a white square, print the median of that particular piece's row as the score for that piece. If it is on a black square, print the sum of the square roots of the column of that piece. Add up all the scores obtained and print it as the final score. It should work for any and all values of n, locations, and scores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9BS2Cs5DwHtO",
    "outputId": "b29bf9b4-62e0-463d-c592-5b24b872ef5d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score Table : \n",
      " [[ 0  1  2  3  4  5  6  7  8]\n",
      " [ 9 10 11 12 13 14 15 16 17]\n",
      " [18 19 20 21 22 23 24 25 26]\n",
      " [27 28 29 30 31 32 33 34 35]\n",
      " [36 37 38 39 40 41 42 43 44]\n",
      " [45 46 47 48 49 50 51 52 53]\n",
      " [54 55 56 57 58 59 60 61 62]\n",
      " [63 64 65 66 67 68 69 70 71]\n",
      " [72 73 74 75 76 77 78 79 80]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "n = 9\n",
    "locations = [(1, 2), (3, 2), (7, 6), (2, 4), (8, 8)] # Locations are in format (Row, Column) with indexing starting from 0\n",
    "scores = np.arange(n*n).reshape((n, n))\n",
    "print(\"Score Table : \\n\", scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "id": "7J2vmWs3v5yj"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 0 1 0 1 0 1 0]\n",
      " [1 0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1 0]\n",
      " [1 0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1 0]\n",
      " [1 0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1 0]\n",
      " [1 0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1 0]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "n = 9\n",
    "locations = [(1, 2), (3, 2), (7, 6), (2, 4), (8, 8)] # Locations are in format (Row, Column) with indexing starting from 0\n",
    "scores = np.arange(n*n).reshape((n, n))\n",
    "\n",
    "# Write your code to create the chessboard here. Use variable chessboard to store it.\n",
    "\n",
    "chessboard = np.ones(n*n, dtype=int)\n",
    "chessboard[::2]=0\n",
    "chessboard = chessboard.reshape(n,n)\n",
    "###\n",
    "print(chessboard)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ye4tA95izHmN"
   },
   "source": [
    "The output of the above print() statement should be :\n",
    "\n",
    "\n",
    "```\n",
    "[[0 1 0 1 0 1 0 1 0]\n",
    " [1 0 1 0 1 0 1 0 1]\n",
    " [0 1 0 1 0 1 0 1 0]\n",
    " [1 0 1 0 1 0 1 0 1]\n",
    " [0 1 0 1 0 1 0 1 0]\n",
    " [1 0 1 0 1 0 1 0 1]\n",
    " [0 1 0 1 0 1 0 1 0]\n",
    " [1 0 1 0 1 0 1 0 1]\n",
    " [0 1 0 1 0 1 0 1 0]]\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "id": "51008VuLx0zL"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BLACK\n",
      "BLACK\n",
      "BLACK\n",
      "WHITE\n",
      "WHITE\n"
     ]
    }
   ],
   "source": [
    "# Print whether the locations are on black or white squares\n",
    "for i in range (len(locations)):\n",
    "    if chessboard[locations[i]] == 0:\n",
    "        print('WHITE')\n",
    "    else:\n",
    "        print('BLACK')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tNlicreFzPgG"
   },
   "source": [
    "The output of the above code should be :\n",
    "\n",
    "\n",
    "```\n",
    "BLACK\n",
    "BLACK\n",
    "BLACK\n",
    "WHITE\n",
    "WHITE\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "id": "N6Tz5Z_nzGPq"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "51.75610550712166\n",
      "51.75610550712166\n",
      "55.47253576970644\n",
      "22.0\n",
      "76.0\n",
      "256.98474678394973\n"
     ]
    }
   ],
   "source": [
    "# Write the code to print individual scores, and total score\n",
    "s = np.sqrt(scores)\n",
    "t = np.sum(s , 0)\n",
    "temp = 9\n",
    "sum1 = 0\n",
    "for i in range (len(locations)):\n",
    "    if chessboard[locations[i]] == 0:\n",
    "        sum1+=float(scores[locations[i][0],int(temp/2)])\n",
    "        print(float(scores[locations[i][0],int(temp/2)]))\n",
    "    else:\n",
    "        sum1+=float(t[locations[i][1]])\n",
    "        print(float(t[locations[i][1]]))\n",
    "   \n",
    "print(sum1)       \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8sFPL39Y0-YO"
   },
   "source": [
    "The output of the above code should be :\n",
    "\n",
    "\n",
    "```\n",
    "51.75610550712166\n",
    "51.75610550712166\n",
    "55.47253576970644\n",
    "22.0\n",
    "76.0\n",
    "-------\n",
    "TOTAL Score =  256.98474678394973\n",
    "```\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "NumPy Task.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}