Numpy Practice Assignments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b2e4197a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6781d2d",
   "metadata": {},
   "source": [
    "ref :\n",
    "    from https://www.interviewbit.com/numpy-interview-questions/\n",
    "    \n",
    "and scaler.com"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6235b6f3",
   "metadata": {},
   "source": [
    "#### 1. What is NumPy? Why should we use it?\n",
    "\n",
    "- NumPy (also called Numerical Python) is a highly flexible, optimized, open-source package meant for array processing. It provides tools for delivering high-end performance while dealing with N-dimensional powerful array objects. It is also beneficial for performing scientific computations, mathematical, and logical operations, sorting operations, I/O functions, basic statistical and linear algebra-based operations along with random simulation and broadcasting functionalities. Due to the vast range of capabilities, NumPy has become very popular and is the most preferred package. The following image represents the uses of NumPy.\n",
    "\n",
    "\n",
    "#### 2. Why is NumPy preferred over Matlab, Octave, Idl or Yorick?\n",
    "\n",
    "- NumPy is an open-source, high-performing library that allows complex mathematical and scientific computational capabilities. It makes use of Python language which is a high-level, easy-to-learn, general-purpose programming language. It supports the following:\n",
    "\n",
    "- Powerful functions for performing complex mathematical operations on multi-dimensional matrices and arrays. The operations on ndarrays of NumPy are approximately up to 50% faster when compared to operations on native lists using loops. This efficiency is very much useful when the arrays have millions of elements.\n",
    "- Provides indexing syntax to access portions of data easily in a large array.\n",
    "- Provides built-in functions which help to easily perform operations related to linear algebra and statistics.\n",
    "- It takes only a few lines of code to achieve complex computations using NumPy.\n",
    "\n",
    "#### 3. How are NumPy arrays better than Python’s lists?\n",
    "\n",
    "- Python lists support storing heterogeneous data types whereas NumPy arrays can store datatypes of one nature itself. NumPy provides extra functional capabilities that make operating on its arrays easier which makes NumPy array advantageous in comparison to Python lists as those functions cannot be operated on heterogeneous data.\n",
    "- NumPy arrays are treated as objects which results in minimal memory usage. Since Python keeps track of objects by creating or deleting them based on the requirements, NumPy objects are also treated the same way. This results in lesser memory wastage.\n",
    "- NumPy arrays support multi-dimensional arrays.\n",
    "- NumPy provides various powerful and efficient functions for complex computations on the arrays.\n",
    "- NumPy also provides various range of functions for BitWise Operations, String Operations, Linear Algebraic operations, Arithmetic operations etc. These are not provided on Python’s default lists.\n",
    "\n",
    "#### 4. What are ndarrays in NumPy?\n",
    "\n",
    "- ndarray object is the core of the NumPy package. It consists of n-dimensional arrays storing elements of the same data types and also has many operations that are done in compiled code for optimised performance. These arrays have fixed sizes defined at the time of creation. Following are some of the properties of ndarrays:\n",
    "\n",
    "- When the size of ndarrays is changed, it results in a new array and the original array is deleted.\n",
    "The ndarrays are bound to store homogeneous data.\n",
    "They provide functions to perform advanced mathematical operations in an efficient manner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb91d594",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "822ae118",
   "metadata": {},
   "source": [
    "#### What are ways of creating 1D, 2D and 3D arrays in NumPy?\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "id": "c507e1f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 359,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "arr = [1,2,3,4]        #python list\n",
    "numpy_arr = np.array(arr)    #numpy array\n",
    "numpy_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 361,
   "id": "963803f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [4, 5, 6, 7]])"
      ]
     },
     "execution_count": 361,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "arr = [[1,2,3,4],[4,5,6,7]]\n",
    "numpy_arr = np.array(arr)\n",
    "numpy_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "id": "0498e2d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2,  3,  4],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 7,  8,  9, 10]]])"
      ]
     },
     "execution_count": 362,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = [[[1,2,3,4],[4,5,6,7],[7,8,9,10]]]\n",
    "numpy_arr = np.array(arr)\n",
    "numpy_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09dad722",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d33fc9d3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82a4671d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "62f724c1",
   "metadata": {},
   "source": [
    "#### How do you find the data type of the elements stored in the NumPy arrays?\n",
    "\n",
    "> NumPy supports the following datatypes:\n",
    "\n",
    "    i - integer\n",
    "    S - string\n",
    "    b - boolean\n",
    "    f - float\n",
    "    u - unsigned integer\n",
    "    c - complex float\n",
    "    m - timedelta\n",
    "    M - datetime\n",
    "    O - object\n",
    "    U - unicode string\n",
    "    V - fixed memory chunk for types such as void\n",
    "\n",
    "- We can make use of the dtype property that returns the type of the elements stored in the NumPy array. Let us consider the below code snippet. We create some sample arrays and we see what the data types of these arrays are.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "id": "47ae2da1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n",
      "<U12\n",
      "|S1\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr1 = np.array([1, 2, 3, 4])\n",
    "arr2 = np.array(['I', 'love', 'Interviewbit'])    # Stored as Unicode characters with length of characters ranging from 1 to 12\n",
    "arr3 = np.array([1, 2, 3, 4], dtype='S')        # Creating numpy array of defined type string\n",
    "\n",
    "print(arr1.dtype)\n",
    "print(arr2.dtype)\n",
    "print(arr3.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1217c57",
   "metadata": {},
   "source": [
    "#### how can you reverse a NumPy array?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "id": "479782d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6 4 2 1]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 4, 6])\n",
    "\n",
    "# To reverse array\n",
    "reverse_arr = arr[::-1]\n",
    "print(reverse_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "id": "4e3fad77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 4, 6])"
      ]
     },
     "execution_count": 366,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "id": "a83a0a8b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 4, 2, 1])"
      ]
     },
     "execution_count": 367,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.flipud(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8607069e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6f9e383a",
   "metadata": {},
   "source": [
    " #### How is np.mean() different from np.average() in NumPy?\n",
    "\n",
    "- np.mean() method calculates the arithmetic mean and provides additional options for input and results. For example, it has the option to specify what data types have to be taken, where the result has to be placed etc.\n",
    "\n",
    "\n",
    "- np.average() computes the weighted average if the weights parameter is specified. In the case of weighted average, instead of considering that each data point is contributing equally to the final average, it considers that some data points have more weightage than the others (unequal contribution)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0d742c9",
   "metadata": {},
   "source": [
    "Expected value of a fair dice : "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b7cfe96",
   "metadata": {},
   "source": [
    "E(x) = sum of {x*p(x)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "id": "13dfb35e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5000000000000004"
      ]
     },
     "execution_count": 368,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.average(a = np.array([1,2,3,4,5,6]),weights = [1/6,1/6,1/6,1/6,1/6,1/6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0979e0cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "Expected Variance of a fair dice L "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c371b90",
   "metadata": {},
   "source": [
    "E(x^2) - (E(x))^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "id": "de2b147e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.9166666666666625"
      ]
     },
     "execution_count": 373,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum((np.array([1,2,3,4,5,6])**2)*(1/6))-((np.average(a = np.array([1,2,3,4,5,6]),weights = [1/6,1/6,1/6,1/6,1/6,1/6]))**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95e0193c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6017375c",
   "metadata": {},
   "source": [
    "#### How do you count the frequency of a given positive value appearing in the NumPy array?\n",
    "\n",
    "- We can make use of the bincount() function to compute the number of times a given value is there in the array. This function accepts only positive integers and boolean expressions as the arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "id": "0093de45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([16, 12, 18, 16, 12, 18, 24, 17, 13, 19, 21, 10, 14, 13, 24, 12, 18,\n",
       "       20, 19, 23, 11, 13, 15, 11, 10, 19, 19, 11, 18, 19, 10, 15, 13, 21,\n",
       "       14, 17, 23, 24, 18, 23, 19, 14, 23, 23, 23, 12, 10, 24, 13, 24])"
      ]
     },
     "execution_count": 374,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.random.randint(10,25,size=50)\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "id": "d31ffd52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 3, 4, 5, 3, 2, 2, 2, 5, 6, 1, 2,\n",
       "       0, 6, 5], dtype=int64)"
      ]
     },
     "execution_count": 375,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bincount(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6de43422",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4ca2f968",
   "metadata": {},
   "source": [
    "#### How do we check for an empty array (or zero elements array)?\n",
    "\n",
    "- We can check for the emptiness of a NumPy array by making use of the size attribute.\n",
    "- Let us consider the below example. We have NumPy array arr filled with zeros. If the size element returns zero, that means the array is empty or it only consists of zeros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "id": "ce3defd8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([], shape=(1, 0), dtype=float64)"
      ]
     },
     "execution_count": 377,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.zeros((1,0))\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "id": "491276be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(X.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7de084ab",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "754ba92a",
   "metadata": {},
   "source": [
    "#### How is arr[:,0] different from arr[:,[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 385,
   "id": "bbaf500d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 385,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([[1,2,3,4],[5,6,7,8]])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "id": "2a58961c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 5])"
      ]
     },
     "execution_count": 386,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 387,
   "id": "6c7bfa00",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [5]])"
      ]
     },
     "execution_count": 387,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:,[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18808ac6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b8398c5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ed326e39",
   "metadata": {},
   "source": [
    "####  How do you multiply 2 NumPy array matrices?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "id": "e7271c64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A: \n",
      " [[15 16 17]\n",
      " [18 19 20]\n",
      " [21 22 23]]\n",
      "B: \n",
      " [[20 21 22]\n",
      " [23 24 25]\n",
      " [26 27 28]]\n",
      "\n",
      "Result:\n",
      " [[1110 1158 1206]\n",
      " [1317 1374 1431]\n",
      " [1524 1590 1656]]\n"
     ]
    }
   ],
   "source": [
    "A = np.arange(15,24).reshape(3,3)\n",
    "B = np.arange(20,29).reshape(3,3)\n",
    "print(\"A: \\n\",A)\n",
    "print(\"B: \\n\",B)\n",
    "print()\n",
    "result = A.dot(B)\n",
    "print(\"Result:\\n\", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05c6a473",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f0bc88e6",
   "metadata": {},
   "source": [
    "#### How do you concatenate 2 NumPy arrays?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "id": "03e656be",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "id": "da5882b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 394,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "id": "eb290ff6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 397,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a,b),axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "id": "2b5d2242",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2],\n",
       "       [3, 4, 3, 4]])"
      ]
     },
     "execution_count": 399,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a,a),axis =1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 402,
   "id": "06d11de8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 402,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a,a,b),axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 404,
   "id": "fc306bd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aefbe563",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b765a88c",
   "metadata": {},
   "source": [
    "#### How do you convert Pandas DataFrame to a NumPy array?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "id": "7e7083db",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(data={'A': [3, 2, 1], 'B': [6,5,4], 'C': [9, 8, 7]}, \n",
    "                  index=['i', 'j', 'k'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "id": "9f42444d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>i</th>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>j</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>k</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A  B  C\n",
       "i  3  6  9\n",
       "j  2  5  8\n",
       "k  1  4  7"
      ]
     },
     "execution_count": 406,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "id": "be99e548",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 6, 9],\n",
       "       [2, 5, 8],\n",
       "       [1, 4, 7]], dtype=int64)"
      ]
     },
     "execution_count": 407,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "454ce6f0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f42af062",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2489ab3f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9260a3e9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ab5171ed",
   "metadata": {},
   "source": [
    "### What do you understand by Vectorization in NumPy?\n",
    "\n",
    "- Function Vectorization technically means that the function is applied to all elements in the array. Typically, certain python functionalities on arrays (such as loops) are slower in nature because python arrays can contain elements of different data types. Since the C program expects a specific datatype, there are chances of compiler optimisation which makes C code run faster. Since NumPy arrays support storing elements of a single datatype, most of the implementations of the functions written in NumPy meant for arithmetic, logical operations etc have optimised C program code under their hood. Additionally, NumPy also helps developers create their own vectorised functions by following the below steps:\n",
    "\n",
    "- Write your required function that takes array elements as parameters.\n",
    "- Vectorize the function by making use of the vectorize() method of the NumPy package.\n",
    "- Give array inputs to the vectorized function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 408,
   "id": "56a40f9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 409,
   "id": "02b76ce8",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([1,2,3,4,5])"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "22dd97da",
   "metadata": {},
   "source": [
    "    math.log(arr)\n",
    "   ![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "id": "a9fb9028",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 411,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 415,
   "id": "384194a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "vect_log = np.vectorize(math.log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 416,
   "id": "2bd317ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791])"
      ]
     },
     "execution_count": 416,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vect_log(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 417,
   "id": "063030d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791])"
      ]
     },
     "execution_count": 417,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76ba7adf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8994bbd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5109aef7",
   "metadata": {},
   "source": [
    "### How is vstack() different from hstack() in NumPy?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "id": "ce000fc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1,2,3])\n",
    "b = np.array([4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "id": "f6a79c07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 420,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 421,
   "id": "e3ccac7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 421,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43f107df",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bf0772d6",
   "metadata": {},
   "source": [
    "### How is Vectorization related to Broadcasting in NumPy?\n",
    "\n",
    "- Vectorization involves delegating NumPy operations internally to optimized C language functions to result in faster Python code. Whereas Broadcasting refers to the methods that allow NumPy to perform array-related arithmetic operations. The size or shape of the arrays does not matter in this case. Broadcasting solves the problem of mismatched shaped arrays by replicating the smaller array along the larger array to ensure both arrays are having compatible shapes for NumPy operations. Performing Broadcasting before Vectorization helps to vectorize operations which support arrays of different dimensions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bb39f93",
   "metadata": {},
   "source": [
    "#### broadcasting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 422,
   "id": "f97271ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30])"
      ]
     },
     "execution_count": 422,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([10,20,30])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 423,
   "id": "173dab8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([[1],\n",
    "              [2],\n",
    "              [3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "id": "9f7b048e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 424,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "id": "09fbb9ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 21, 31],\n",
       "       [12, 22, 32],\n",
       "       [13, 23, 33]])"
      ]
     },
     "execution_count": 425,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "id": "3dcfbbaa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 20, 30],\n",
       "       [20, 40, 60],\n",
       "       [30, 60, 90]])"
      ]
     },
     "execution_count": 426,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c3d7c68",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "311f868c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f2efe1c0",
   "metadata": {},
   "source": [
    "### What happens when the split() method is used for splitting NumPy arrays?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5981602f",
   "metadata": {},
   "source": [
    "- np.split() : Equally splits arrays into multiple sub-arrays. It raises Value Error when the split cannot be equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 427,
   "id": "39a333f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7])"
      ]
     },
     "execution_count": 427,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr= np.arange(8)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 429,
   "id": "228e1927",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 2, 3]), array([4, 5, 6, 7])]"
      ]
     },
     "execution_count": 429,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(arr,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 431,
   "id": "c6a38a37",
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.split(arr,3) # error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 432,
   "id": "16860240",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0]), array([1]), array([2, 3, 4]), array([5, 6, 7])]"
      ]
     },
     "execution_count": 432,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(arr,[1,2,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 435,
   "id": "9d15acaa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 435,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1,11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 434,
   "id": "bf6f6eaa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([1, 2]), array([3, 4, 5]), array([ 6,  7,  8,  9, 10])]"
      ]
     },
     "execution_count": 434,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(np.arange(1,11),[2,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cee6d883",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 436,
   "id": "fca728e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8]), array([ 9, 10, 11])]"
      ]
     },
     "execution_count": 436,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(np.arange(12),4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2092085",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a7d9eb98",
   "metadata": {},
   "source": [
    "### What happens when we use the arrays_split() method for splitting the NumPy array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "id": "6a2c2005",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([1, 2]), array([3, 4]), array([5])]"
      ]
     },
     "execution_count": 443,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(1,6)\n",
    "split_arrs = np.array_split(arr, 3)\n",
    "split_arrs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "id": "09b1a71f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([1, 2, 3, 4, 5]),\n",
       " array([ 6,  7,  8,  9, 10]),\n",
       " array([11, 12, 13, 14, 15])]"
      ]
     },
     "execution_count": 442,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(1,16)\n",
    "split_arrs = np.array_split(arr, 3)\n",
    "split_arrs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 441,
   "id": "861ae01c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([1, 2, 3, 4, 5]), array([6, 7, 8, 9]), array([10, 11, 12, 13])]"
      ]
     },
     "execution_count": 441,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(1,14)\n",
    "split_arrs = np.array_split(arr, 3)\n",
    "split_arrs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f02b6632",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0237a80f",
   "metadata": {},
   "source": [
    "#### How will you implement the moving average for the 1D array in NumPy?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 444,
   "id": "236de845",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 8, 9, 3, 2, 4, 2, 0, 2])"
      ]
     },
     "execution_count": 444,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([4,5,8,9,3,2,4,2,0,2])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 453,
   "id": "ba2743c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4] 4.0\n",
      "[4 5] 4.5\n",
      "[4 5 8] 5.67\n",
      "[4 5 8 9] 6.5\n",
      "[4 5 8 9 3] 5.8\n",
      "[4 5 8 9 3 2] 5.17\n",
      "[4 5 8 9 3 2 4] 5.0\n",
      "[4 5 8 9 3 2 4 2] 4.62\n",
      "[4 5 8 9 3 2 4 2 0] 4.11\n",
      "[4 5 8 9 3 2 4 2 0 2] 3.9\n"
     ]
    }
   ],
   "source": [
    "ans = []\n",
    "\n",
    "for i in range(1,len(arr)+1):\n",
    "    templengh = i\n",
    "    array = arr[:i]\n",
    "    print(array,np.round(np.mean(array),2))\n",
    "    ans.append(np.round(np.mean(array),2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49b27fad",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 452,
   "id": "beabef5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4.0, 4.5, 5.67, 6.5, 5.8, 5.17, 5.0, 4.62, 4.11, 3.9]"
      ]
     },
     "execution_count": 452,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f2325eb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "955cc2a8",
   "metadata": {},
   "source": [
    "### How is fliplr different from flipud methods in NumPy?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "id": "e87ffd7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.arange(1,13).reshape(4,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "id": "02acd677",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [ 4,  5,  6],\n",
       "       [ 7,  8,  9],\n",
       "       [10, 11, 12]])"
      ]
     },
     "execution_count": 462,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 463,
   "id": "9c0ac90e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3,  2,  1],\n",
       "       [ 6,  5,  4],\n",
       "       [ 9,  8,  7],\n",
       "       [12, 11, 10]])"
      ]
     },
     "execution_count": 463,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.fliplr(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf735797",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 470,
   "id": "82616cdc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0, 0],\n",
       "       [0, 2, 0, 0, 0],\n",
       "       [0, 0, 3, 0, 0],\n",
       "       [0, 0, 0, 4, 0],\n",
       "       [0, 0, 0, 0, 5]])"
      ]
     },
     "execution_count": 470,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.diag(np.arange(1,6))\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 472,
   "id": "7a0acc5f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 1],\n",
       "       [0, 0, 0, 2, 0],\n",
       "       [0, 0, 3, 0, 0],\n",
       "       [0, 4, 0, 0, 0],\n",
       "       [5, 0, 0, 0, 0]])"
      ]
     },
     "execution_count": 472,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.fliplr(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e3dc46b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3348e7bc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3c29b04c",
   "metadata": {},
   "source": [
    "### Gunjan is working on a swap of drones that can perform light shows.\n",
    "### For that, she is maintaining a list of the height of each drone and is updating that for each step.\n",
    "    Height = [h1,h2,h3………hn] # height of each drone\n",
    "    Delta_h = [d1,d2,d3……dn] # change in height of each drone\n",
    "\n",
    "#### For each second she updates the Height array by adding the corresponding change to the height.\n",
    "\n",
    "### For that, she tried out 2 methods as listed below. Help her in arranging them in ascending order of time.\n",
    "\n",
    "\n",
    "    (A) Numpy operator\n",
    "\n",
    "    import numpy as np\n",
    "\n",
    "    def update_height(height,delta):\n",
    "\n",
    "       height = np.array(height)\n",
    "\n",
    "       delta = np.array(delta)\n",
    "\n",
    "       new_height = height+delta \n",
    "\n",
    "       return new_height\n",
    "\n",
    "    (B) Python operation\n",
    "\n",
    "\n",
    "    def update_height(height, delta):\n",
    "\n",
    "        new_height=[]\n",
    "\n",
    "        for i in range(len(height)):\n",
    "\n",
    "            new_height.append(height[i]+delta[i])\n",
    "\n",
    "        return new_height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "45eebc31",
   "metadata": {},
   "outputs": [],
   "source": [
    "H = list(range(50,50000000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c3593364",
   "metadata": {},
   "outputs": [],
   "source": [
    "dH = [5 for x in range(50,50000000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed12f5e7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cc52869",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "767f8720",
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_height(height,delta):\n",
    "    height = np.array(height)\n",
    "    delta = np.array(delta)\n",
    "    new_height = height + delta\n",
    "    return new_height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3ea71e4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 0 ns\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([      55,       56,       57, ..., 50000002, 50000003, 50000004])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%time\n",
    "update_height(H,dH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c4b4f055",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def update_height_py(height, delta):\n",
    "    new_height=[]\n",
    "    for i in range(len(height)):\n",
    "        new_height.append(height[i]+delta[i])\n",
    "        \n",
    "    return new_height\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c2aafe4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "44eceff7",
   "metadata": {},
   "source": [
    "### Which option is right about the output of the following code snippet?\n",
    "\n",
    "    x = np.array([-5, 9 , 20 , 25, -3, 5, 16, 10])\n",
    "    x[(x >= -5) & (x <= 15)] *= -1 \n",
    "    Note: Recall the masking with assignment question discussed in class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0fb473fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([-5, 9 , 20 , 25, -3, 5, 16, 10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "00a5a354",
   "metadata": {},
   "outputs": [],
   "source": [
    "x[(x >= -5) & (x <= 15)] *= -1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c30492d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  5,  -9,  20,  25,   3,  -5,  16, -10])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e36b7fa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "96ab33b1",
   "metadata": {},
   "source": [
    "### a. What is the last element of the output?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "15765de1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Astha' 'Raghavendra' 'Ram']\n"
     ]
    }
   ],
   "source": [
    "print(np.sort(np.array(['Ram','Astha','Raghavendra'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8816a304",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.array(['Ram','Astha','Brahat'])\n",
    "arr2 = np.array(['Shyam','Kalyan','Naveen'])\n",
    "arr1 > arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d779d3a6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "140f68ea",
   "metadata": {},
   "source": [
    "### You are given NumPy arrays A, B, and C, where:\n",
    "\n",
    "    A.shape = (m,)\n",
    "\n",
    "    B.shape = (n, 1)\n",
    "\n",
    "    C.shape = (n, m)\n",
    "\n",
    "#### Which of the following operations can be performed on A, B, and C?\n",
    "##### Note: np is the alias for NumPy in the options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3ef69334",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([1,2,3])\n",
    "A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "52ea3aa1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 1)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = np.array([[1],[2],[3],[4]])\n",
    "B.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5a420c96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 3)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = np.array([[1,2,4],\n",
    "             [7,8,9],\n",
    "             [9,5,1],\n",
    "              [7,5,3]])\n",
    "C.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f7a701c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "cfe03049",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b1393e92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 4],\n",
       "       [7, 8, 9],\n",
       "       [9, 5, 1],\n",
       "       [7, 5, 3]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "26e68fbf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 7, 9, 7],\n",
       "       [2, 8, 5, 5],\n",
       "       [4, 9, 1, 3]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f2fd9282",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.reshape(3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "57201250",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 7, 9, 7, 1],\n",
       "       [2, 8, 5, 5, 2],\n",
       "       [4, 9, 1, 3, 3]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((C.T,A.reshape(3,1)),axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8410802",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6d6f3d65",
   "metadata": {},
   "source": [
    "#### Given the 2-D array X,\n",
    "\n",
    "\n",
    "    X = np.arange(12).reshape(3,4)\n",
    "    So, X is\n",
    "\n",
    "    [[ 0 1 2 3] \n",
    "     [ 4 5 6 7]\n",
    "     [ 8 9 10 11]]\n",
    "    Which of the following is/are true statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "25c7d69f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "X = np.arange(12).reshape(3,4)\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "c81f0b90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  7, 11])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.max(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "bf6fcef4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  7, 11])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.T.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "e1789871",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 8]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i.min() for i in X]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3eef31b1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "909cb09e",
   "metadata": {},
   "source": [
    "### For the arrays a and b:\n",
    "\n",
    "    import numpy as np\n",
    "    a = np.zeros(27).reshape(3, 3, 3)\n",
    "    b = np.arange(9).reshape(3, 3) \n",
    "    Which option will give the same output as a+b?\n",
    "\n",
    "    Note: np.newaxis is used to create a new axis in the mentioned dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "0b06feb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.zeros(27).reshape(3, 3, 3)\n",
    "b = np.arange(9).reshape(3, 3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e6c1f948",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "dc2a7392",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "53ba1cc4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 1., 2.],\n",
       "        [3., 4., 5.],\n",
       "        [6., 7., 8.]],\n",
       "\n",
       "       [[0., 1., 2.],\n",
       "        [3., 4., 5.],\n",
       "        [6., 7., 8.]],\n",
       "\n",
       "       [[0., 1., 2.],\n",
       "        [3., 4., 5.],\n",
       "        [6., 7., 8.]]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[np.newaxis,:,:]+a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9a71e51",
   "metadata": {},
   "source": [
    "### Given the NumPy array arr, which of the following line of code will return the expected output?\n",
    "\n",
    "    import numpy as np\n",
    "    arr= np.array([[2,3,4,5],[1,7,3,5],[2,8,6,9],[11,23,12,19]])\n",
    "\n",
    "    a.\n",
    "\n",
    "    arr1 = np.array([[2,2,2,2]])\n",
    "    def func(x, y):\n",
    "        return x * y\n",
    "    vec = np.vectorize(func)\n",
    "    vec(arr,arr1)\n",
    "\n",
    "    b.\n",
    "\n",
    "    arr1 = np.array([[2],[2],[2],[2]])\n",
    "    def func(x, y):\n",
    "        return x * y\n",
    "    vec = np.vectorize(func)\n",
    "    vec(arr, arr1)\n",
    "\n",
    "\n",
    "    c.\n",
    "\n",
    "    arr1 = 2\n",
    "    def func(x, y):\n",
    "        return x * y\n",
    "    vec = np.vectorize(func)\n",
    "    vec(arr, arr1)\n",
    "\n",
    "    Expected output:\n",
    "\n",
    "    array ([[4,6,8,10],\n",
    "            [2,14,6,10],\n",
    "            [4,16,12,18],\n",
    "            [22,46,24,38]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "be409bbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr= np.array([[2,3,4,5],[1,7,3,5],[2,8,6,9],[11,23,12,19]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "6fdd9034",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  6,  8, 10],\n",
       "       [ 2, 14,  6, 10],\n",
       "       [ 4, 16, 12, 18],\n",
       "       [22, 46, 24, 38]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.array([[2,2,2,2]])\n",
    "def func(x, y):\n",
    "    return x * y\n",
    "vec = np.vectorize(func)\n",
    "vec(arr,arr1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "3623d4ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  6,  8, 10],\n",
       "       [ 2, 14,  6, 10],\n",
       "       [ 4, 16, 12, 18],\n",
       "       [22, 46, 24, 38]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.array([[2],[2],[2],[2]])\n",
    "def func(x, y):\n",
    "    return x * y\n",
    "vec = np.vectorize(func)\n",
    "vec(arr, arr1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "a7a6d811",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  6,  8, 10],\n",
       "       [ 2, 14,  6, 10],\n",
       "       [ 4, 16, 12, 18],\n",
       "       [22, 46, 24, 38]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = 2\n",
    "def func(x, y):\n",
    "    return x * y\n",
    "vec = np.vectorize(func)\n",
    "vec(arr, arr1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d5bc9d5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f2fb0d8f",
   "metadata": {},
   "source": [
    "### Which of the following option(s) can add 1 to each element of array A?\n",
    "\n",
    "    A = np.array([2, 0, 1, 9, 1, 1, 1, 0, 3, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "1fc6f07a",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([2, 0, 1, 9, 1, 1, 1, 0, 3, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "ae1fde71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  1,  2, 10,  2,  2,  2,  1,  4,  6])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "2e1b4aa2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 1, 2, 10, 2, 2, 2, 1, 4, 6]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x+1 for x in A]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "0d273790",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 1, 2, 10, 2, 2, 2, 1, 4, 6]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x:x+1,A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c242684",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7c16be0e",
   "metadata": {},
   "source": [
    "### What will be the outcome of the following code snippet ?\n",
    "\n",
    "    x = np.ones((5,5))\n",
    "    x[1:-1,1:-1] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "06b4be70",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.ones((5,5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "928ccafb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "faf3c404",
   "metadata": {},
   "outputs": [],
   "source": [
    "x[1:-1,1:-1] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "553ab836",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa12ac4f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "30650a0d",
   "metadata": {},
   "source": [
    "### Given a Numpy array of integers as an input to the function binary(), complete the given function to convert each element in the array into its binary representation.\n",
    "\n",
    "    For example: In binary, 5 => 101, 7 => 111, 10 => 1010.\n",
    "\n",
    "    Note: You are not allowed to use the inbuilt bin() function and both input and output array have elements of datatype 'int'.\n",
    "\n",
    "    Input Format:\n",
    "\n",
    "    A list is taken as input which is then typecasted to a NumPy array.\n",
    "    Output Format:\n",
    "\n",
    "    A NumPy array is printed.\n",
    "    Sample Input:\n",
    "\n",
    "    [[2,3,4], [5,6,7]]\n",
    "    Sample Output:\n",
    "\n",
    "    [[ 10  11 100]\n",
    "     [101 110 111]]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "f5c3a972",
   "metadata": {},
   "outputs": [],
   "source": [
    "def binary(arr):\n",
    "    def con_bin(n):\n",
    "        s = \"\"\n",
    "        while n>0:\n",
    "            s = s+str(n%2)\n",
    "            n = n//2\n",
    "        return int(s[::-1])\n",
    "    return np.vectorize(con_bin)(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "88f3607d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 10,  11, 100],\n",
       "       [101, 110, 111]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary([[2,3,4],\n",
    "        [5,6,7]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "169b64d9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a86cfb75",
   "metadata": {},
   "source": [
    "### You are a Teaching Assistant of the DSML course. You have access to every student’s marks in every quiz. The marks are stored in a matrix where matrix[i][j] represents the marks of the ith student in the jth quiz.\n",
    "\n",
    "    The course instructor wants you to sort the marks of students according to jth quiz in increasing order so that he can evaluate the performance of students in that particular quiz.\n",
    "\n",
    "    Here, you have to create a python program using which the instructor can sort the data on the basis of a given column(quiz). The program will return the matrix with the marks sorted in jth quiz.\n",
    "\n",
    "    The dimension of the input matrix is mxn, the output is expected to be a 2d numpy matrix of dimension mxn, but in the output the jth column must be arranged in the ascending order.\n",
    "\n",
    "    Note: The input will be 2D list not array. First convert it to array.\n",
    "\n",
    "    Input Format:\n",
    "\n",
    "    Number of test cases\n",
    "    For each test case, number of rows for matrix and the column to be sorted in a new line.\n",
    "    For each row in matrix, space separated integers are taken as input in a new line.\n",
    "    Output Format:\n",
    "\n",
    "    The 2D matrix, or each row in matrix space separated integers\n",
    "    Sample Input:\n",
    "\n",
    "    1\n",
    "    3 2 \n",
    "    5 3 9\n",
    "    2 1 4\n",
    "    7 6 8\n",
    "    Sample Output:\n",
    "\n",
    "    [[2 1 4]\n",
    "     [5 3 9]\n",
    "     [7 6 8]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "1fd50489",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[5, 3, 9],\n",
    "            [2 ,1, 4],\n",
    "            [7 ,6 ,8]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "afa8f6dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 3, 9],\n",
       "       [2, 1, 4],\n",
       "       [7, 6, 8]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "909bc7d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "j = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "43fbe07b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 1, 6])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "9b67efef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 1, 6])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:,j-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "57c66c94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 2], dtype=int64)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:,j-1].argsort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "e950af63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 1, 4],\n",
       "       [5, 3, 9],\n",
       "       [7, 6, 8]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[A[:,j-1].argsort()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45d2b3f7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77237f75",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f2a4ba8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecd8a918",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b813c317",
   "metadata": {},
   "source": [
    "### You are a developer for Scalar, and are tasked to write a program that can find the number of times a student has accessed a particular question.\n",
    "\n",
    "    For this, you proposed that every time a student opens a question, the question’s id will be appended to the row representing the student’s id in a matrix. For example, if student i opens question j, j will be appended to ith row of the matrix.\n",
    "    For the prototype, we have limited the number of questions to 10 for consideration. So id of questions <=10. Return the matrix with the same number of rows(m) as that of the input matrix, but this time matrix[i][j] should represent the number of times student i accessed question j. The output matrix is a 2d-numpy matrix of dimension (m*10).\n",
    "\n",
    "    Input Format:\n",
    "\n",
    "    number of test cases\n",
    "    for each test case (number of rows for matrix, number of columns for the matrix)\n",
    "    for each row in matrix space separated integers\n",
    "    Output Format:\n",
    "\n",
    "    Return the 2d numpy array.\n",
    "    Sample input:\n",
    "\n",
    "    1\n",
    "    5\n",
    "    1 1 2 5 7 6 7 7 6 3 \n",
    "    8 5 4 7 5 2 6 10 1 7 \n",
    "    4 3 10 4 4 4 3 1 4 3 \n",
    "    1 4 1 1 8 4 9 8 5 5 \n",
    "    1 1 4 4 2 10 5 6 8 1 \n",
    "\n",
    "    Sample output:\n",
    "\n",
    "    [[2 1 1 0 1 2 3 0 0 0]\n",
    "     [1 1 0 1 2 1 2 1 0 1]\n",
    "     [1 0 3 5 0 0 0 0 0 1]\n",
    "     [3 0 0 2 2 0 0 2 1 0]\n",
    "     [3 1 0 2 1 1 0 1 0 1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "12221412",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1, 1, 2, 5, 7, 6, 7, 7, 6, 3], \n",
    "[8, 5, 4 ,7 ,5 ,2 ,6 ,10, 1, 7], \n",
    "[4, 3, 10, 4, 4, 4, 3, 1, 4, 3], \n",
    "[1, 4, 1, 1, 8, 4, 9, 8, 5, 5], \n",
    "[1, 1, 4, 4, 2, 10, 5, 6, 8, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "65de2da0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  1,  2,  5,  7,  6,  7,  7,  6,  3],\n",
       "       [ 8,  5,  4,  7,  5,  2,  6, 10,  1,  7],\n",
       "       [ 4,  3, 10,  4,  4,  4,  3,  1,  4,  3],\n",
       "       [ 1,  4,  1,  1,  8,  4,  9,  8,  5,  5],\n",
       "       [ 1,  1,  4,  4,  2, 10,  5,  6,  8,  1]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "ee5b8a98",
   "metadata": {},
   "outputs": [],
   "source": [
    "r = arr[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "476e6b7a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1, 2, 3, 5, 6, 7]), array([2, 1, 1, 1, 2, 3], dtype=int64))"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique,freq = np.unique(r,return_counts = True)\n",
    "unique,freq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "8c787903",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros = np.zeros(len(r),dtype=\"int\")\n",
    "zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "0d9f91bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "zeros[unique-1] = freq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "75378ffb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 1, 1, 0, 1, 2, 3, 0, 0, 0])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "9a3db3ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "def countfreq(arr2d):\n",
    "    \n",
    "    def asdasd(row):\n",
    "        row  = np.array(row)\n",
    "        uniq, freq = np.unique(row,return_counts=True)\n",
    "        zeros = np.zeros(len(row),dtype=\"int\")\n",
    "        zeros[uniq-1] = freq\n",
    "        return zeros\n",
    "    \n",
    "    ans = []\n",
    "\n",
    "    for i in arr2d:\n",
    "        ans.append(asdasd(i))\n",
    "    return np.array(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "80e4c0f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 1, 1, 0, 1, 2, 3, 0, 0, 0],\n",
       "       [1, 1, 0, 1, 2, 1, 2, 1, 0, 1],\n",
       "       [1, 0, 3, 5, 0, 0, 0, 0, 0, 1],\n",
       "       [3, 0, 0, 2, 2, 0, 0, 2, 1, 0],\n",
       "       [3, 1, 0, 2, 1, 1, 0, 1, 0, 1]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "countfreq(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a158369",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4febb127",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "686eff11",
   "metadata": {},
   "source": [
    "### Mark the options which are true about the outputs for code snippets a and b.\n",
    "\n",
    "    Code Snippet a:\n",
    "\n",
    "    import numpy as np\n",
    "    x = np.array([[200,200,200],[300,300,300],[400,400,400]])\n",
    "    v = np.array([200,300,400])\n",
    "    print((x / v[:,None])[1][1]) \n",
    "    Code Snippet b:\n",
    "\n",
    "    p = np.array([[0], [10], [20]])\n",
    "    q = np.array([10, 11, 12]) \n",
    "    print((p + q)[1][1]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "c582fa8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([[200,200,200],[300,300,300],[400,400,400]])\n",
    "v = np.array([200,300,400])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "7017b992",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[200, 200, 200],\n",
       "        [300, 300, 300],\n",
       "        [400, 400, 400]]),\n",
       " array([200, 300, 400]))"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x,v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "cbdc4965",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[200],\n",
       "       [300],\n",
       "       [400]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v[:,None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "24b04256",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x/v[:,None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b13dccba",
   "metadata": {},
   "outputs": [],
   "source": [
    "print((x / v[:,None])[1][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fe1caeb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "fa15067c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "p = np.array([[0], [10], [20]])\n",
    "q = np.array([10, 11, 12]) \n",
    "print((p + q)[1][1]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "b258dc10",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0],\n",
       "       [10],\n",
       "       [20]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "1d27b6c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 11, 12])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "aeb43ed6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 11, 12],\n",
       "       [20, 21, 22],\n",
       "       [30, 31, 32]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p+q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba077edb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "45b1629c",
   "metadata": {},
   "source": [
    "### Fancy Indexing\n",
    "    X = np.arange(12).reshape((3, 4))\n",
    "    row = np.array([0, 1, 2])\n",
    "    mask = np.array([1, 0, 1, 0], dtype=bool)\n",
    "    print(X[row[:, np.newaxis], mask])\n",
    "    What is the output of the above coding which is using indexing combined with filtering (masking)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "a4eff67e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.arange(12).reshape((3, 4))\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "d5ff69b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "row = np.array([0, 1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "3e41e3be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "7806d30f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True, False])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = np.array([1,0,1,0],dtype=bool)\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "1f01fb9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "7011d591",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  2]\n",
      " [ 4  6]\n",
      " [ 8 10]]\n"
     ]
    }
   ],
   "source": [
    "print(X[row[:, np.newaxis], mask])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "f89ca1dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  6]\n",
      " [ 8 10]]\n"
     ]
    }
   ],
   "source": [
    "X = np.arange(12).reshape((3, 4))\n",
    "row = np.array([1, 2])\n",
    "mask = np.array([1, 0, 1, 0], dtype=bool)\n",
    "print(X[row[:, np.newaxis], mask])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3eded70",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21534d00",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d82c0eb6",
   "metadata": {},
   "source": [
    "### Which of the following options is false regarding splitting the matrix into 2 buckets in this question to find the median of means of individual buckets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf54b2cb",
   "metadata": {},
   "source": [
    "    m = 11\n",
    "    n = 10\n",
    "    X = np.random.uniform(low=0.0, high=1.0, size=(m,n)).astype(np.float64)\n",
    "    b=2  #no. of buckets\n",
    "    buckets = np.vsplit(X, [(m//b)*i for i in range(1,b)])\n",
    "    # Compute the mean within each bucket\n",
    "    b_means = [np.mean(x, axis=0) for x in buckets]\n",
    "    # Compute the median-of-means\n",
    "    median = np.median(np.array(b_means), axis=0)\n",
    "    print(median) #(n,) shaped array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "53d28104",
   "metadata": {},
   "outputs": [],
   "source": [
    "m = 11\n",
    "n = 10\n",
    "X = np.random.uniform(low=0.0, high=1.0, size=(m,n)).astype(np.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "2d7f8d14",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.29814799, 0.68566831, 0.28158878, 0.48387714, 0.44797536,\n",
       "        0.8147836 , 0.70595668, 0.49041122, 0.228319  , 0.45701251],\n",
       "       [0.11771583, 0.60475756, 0.67379933, 0.5717891 , 0.40363953,\n",
       "        0.71574999, 0.19985795, 0.95777691, 0.16452697, 0.40745897],\n",
       "       [0.85345619, 0.5219556 , 0.90878822, 0.8179838 , 0.89286682,\n",
       "        0.84553023, 0.34758401, 0.82136705, 0.6803742 , 0.11627066],\n",
       "       [0.75919555, 0.58948248, 0.36966944, 0.25261164, 0.16208382,\n",
       "        0.98945697, 0.19398403, 0.62019226, 0.62101583, 0.24807031],\n",
       "       [0.36895206, 0.35021009, 0.76920464, 0.84683894, 0.88484075,\n",
       "        0.68025443, 0.85788384, 0.0957975 , 0.45317142, 0.13728417],\n",
       "       [0.28721881, 0.92792446, 0.30636758, 0.7812861 , 0.15102097,\n",
       "        0.49536864, 0.20510847, 0.35852394, 0.6105915 , 0.42610319],\n",
       "       [0.46836788, 0.3095189 , 0.58604034, 0.10500353, 0.74454858,\n",
       "        0.9665578 , 0.39176048, 0.10292584, 0.0349162 , 0.82501185],\n",
       "       [0.35829315, 0.78444071, 0.27790091, 0.55609495, 0.38370435,\n",
       "        0.59061427, 0.88525522, 0.01236342, 0.8812629 , 0.31463655],\n",
       "       [0.18579343, 0.46540483, 0.86635173, 0.12516076, 0.80074272,\n",
       "        0.41030568, 0.03369344, 0.71694189, 0.92262802, 0.17823837],\n",
       "       [0.55957893, 0.92915508, 0.18864224, 0.10901607, 0.99741151,\n",
       "        0.08973233, 0.39249593, 0.05477406, 0.68312906, 0.18154066],\n",
       "       [0.17083381, 0.91579893, 0.84334953, 0.82507544, 0.88305929,\n",
       "        0.42143965, 0.15995088, 0.01763099, 0.98441652, 0.81141012]])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "b6624310",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[0.29814799, 0.68566831, 0.28158878, 0.48387714, 0.44797536,\n",
       "         0.8147836 , 0.70595668, 0.49041122, 0.228319  , 0.45701251],\n",
       "        [0.11771583, 0.60475756, 0.67379933, 0.5717891 , 0.40363953,\n",
       "         0.71574999, 0.19985795, 0.95777691, 0.16452697, 0.40745897],\n",
       "        [0.85345619, 0.5219556 , 0.90878822, 0.8179838 , 0.89286682,\n",
       "         0.84553023, 0.34758401, 0.82136705, 0.6803742 , 0.11627066],\n",
       "        [0.75919555, 0.58948248, 0.36966944, 0.25261164, 0.16208382,\n",
       "         0.98945697, 0.19398403, 0.62019226, 0.62101583, 0.24807031],\n",
       "        [0.36895206, 0.35021009, 0.76920464, 0.84683894, 0.88484075,\n",
       "         0.68025443, 0.85788384, 0.0957975 , 0.45317142, 0.13728417]]),\n",
       " array([[0.28721881, 0.92792446, 0.30636758, 0.7812861 , 0.15102097,\n",
       "         0.49536864, 0.20510847, 0.35852394, 0.6105915 , 0.42610319],\n",
       "        [0.46836788, 0.3095189 , 0.58604034, 0.10500353, 0.74454858,\n",
       "         0.9665578 , 0.39176048, 0.10292584, 0.0349162 , 0.82501185],\n",
       "        [0.35829315, 0.78444071, 0.27790091, 0.55609495, 0.38370435,\n",
       "         0.59061427, 0.88525522, 0.01236342, 0.8812629 , 0.31463655],\n",
       "        [0.18579343, 0.46540483, 0.86635173, 0.12516076, 0.80074272,\n",
       "         0.41030568, 0.03369344, 0.71694189, 0.92262802, 0.17823837],\n",
       "        [0.55957893, 0.92915508, 0.18864224, 0.10901607, 0.99741151,\n",
       "         0.08973233, 0.39249593, 0.05477406, 0.68312906, 0.18154066],\n",
       "        [0.17083381, 0.91579893, 0.84334953, 0.82507544, 0.88305929,\n",
       "         0.42143965, 0.15995088, 0.01763099, 0.98441652, 0.81141012]])]"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=2  #no. of buckets\n",
    "buckets = np.vsplit(X, [(m//b)*i for i in range(1,b)])\n",
    "buckets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "f4b15d09",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0.47949352, 0.55041481, 0.60061008, 0.59462012, 0.55828126,\n",
       "        0.80915504, 0.4610533 , 0.59710899, 0.42948148, 0.27321933]),\n",
       " array([0.33834767, 0.72204049, 0.51144205, 0.41693948, 0.66008124,\n",
       "        0.49566973, 0.34471074, 0.21052669, 0.68615737, 0.45615679])]"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute the mean within each bucket\n",
    "b_means = [np.mean(x, axis=0) for x in buckets]\n",
    "b_means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "a9335e4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.4089206  0.63622765 0.55602607 0.5057798  0.60918125 0.65241239\n",
      " 0.40288202 0.40381784 0.55781942 0.36468806]\n"
     ]
    }
   ],
   "source": [
    "# Compute the median-of-means\n",
    "median = np.median(np.array(b_means), axis=0)\n",
    "print(median) #(n,) shaped array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7416f170",
   "metadata": {},
   "source": [
    "    The above code is actually first dividing the m array rows into b buckets using np.vsplit(), then calculating the mean of rows for each of b buckets individually and in the end median of all the buckets (row-wise) is calculated.\n",
    "\n",
    "    Which of the following options is false regarding splitting the matrix into 2 buckets in this question to find the median of means of individual buckets?\n",
    "    \n",
    "    - If np.vsplit(X,2) will be used for the buckets it will throw ValueError.\n",
    "    - ans : If np.array_split(X,2,axis=0) will be used for buckets it will throw ValueError.\n",
    "    - If np.split(X,2,axis=0) will be used for the buckets it will throw ValueError.\n",
    "    - np.hsplit() can not be used for this splitting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42fb876d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "720b27dc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8083b821",
   "metadata": {},
   "source": [
    "### Coin flip implementation\n",
    "    n_all_heads=0\n",
    "    for _ in range(10000):\n",
    "        heads = np.random.[?](size=4)<0.5\n",
    "        n_heads=np.sum(heads)\n",
    "        if n_heads==4:\n",
    "          n_all_heads+=1\n",
    "    print(n_all_heads/10000)\n",
    "    \n",
    "    For the above implementation of the coin flip experiment, to find the probability of getting 4 heads if four flips of the coin are repeated 10,000 times. The line which has the gap (i.e. [?]) actually wants to create an array heads with four elements (float) which are in the range 0 and 1 and all the float values should have equal probability. Choose the option which is correct to fill the gap in the code snippet which actually represents the function name.\n",
    "\n",
    "    Note: Try to run the above code snippet after filling the gaps, you'll get the probability of getting 4 heads if four flips are repeated 10,000 times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "id": "dc1e6d3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0628"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_all_heads = 0\n",
    "for _ in range(10000):\n",
    "    heads = np.random.random(size=4)<0.5\n",
    "    n_heads = np.sum(heads)\n",
    "    if n_heads == 4:\n",
    "        n_all_heads += 1\n",
    "n_all_heads/10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "e6abdd9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(np.random.random(size=4)<0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "5fa7f018",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "id": "63597b3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0644"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_all_heads = 0\n",
    "\n",
    "for _ in range(10000):\n",
    "    freq = {}\n",
    "    ans = []\n",
    "    for i in range(4):\n",
    "\n",
    "        toss= np.random.choice([\"H\",\"T\"])\n",
    "        ans.append(toss)\n",
    "    freq = Counter(ans)\n",
    "    if freq[\"H\"] == 4:\n",
    "        n_all_heads+=1\n",
    "n_all_heads/10000\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "028b6005",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51ab4342",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4b9f690b",
   "metadata": {},
   "source": [
    "### What about code?\n",
    "\n",
    "    import numpy as np\n",
    "    arr = 2*np.arange(0,2,0.5)\n",
    "    if arr <= 0.6:\n",
    "        print (\"condition satisfies\")\n",
    "    else:\n",
    "        print (\"condition doesn't satisfy\") "
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "753931ab",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "id": "3f836a1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "condition doesn't satisfy\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = 2*np.arange(0,2,0.5)\n",
    "if np.any(arr) <= 0.6:\n",
    "    print (\"condition satisfies\")\n",
    "else:\n",
    "    print (\"condition doesn't satisfy\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "id": "4225a60c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3.])"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d464a7e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ab360dbb",
   "metadata": {},
   "source": [
    "### Given the following array:\n",
    "\n",
    "    import numpy as np\n",
    "    arr = np.array([[1,2,3],\n",
    "                   [4,5,6],\n",
    "                   [7,8,9]])\n",
    "    Which options are correct?\n",
    "\n",
    "    Note: np is the alias for NumPy in the options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "id": "7190a17a",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1,2,3],\n",
    "               [4,5,6],\n",
    "               [7,8,9]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "e2ab65ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 7])"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "id": "2a57418e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 1],\n",
       "       [4, 5, 6, 4],\n",
       "       [7, 8, 9, 7]])"
      ]
     },
     "execution_count": 259,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((arr,arr[:,[0]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "id": "344fb875",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.hstack((arr, arr[:, [0]])).shape= (3, 4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00e2e87a",
   "metadata": {},
   "source": [
    "    np.hstack((arr, arr[:, [0]])).shape= (3, 4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc314ff8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1e2cb7e6",
   "metadata": {},
   "source": [
    "###  Changing Dimension\n",
    "\n",
    "    Given two Numpy array A and B such that, A.shape = (3,3,1) and B.shape =(3,3)\n",
    "\n",
    "    a) A = A.squeeze(axis=2) \n",
    "\n",
    "    b) B = np.expand_dims( B, axis=2)  \n",
    "    After performing the above lines of code, the shape of arrays A and B will be?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "id": "7e0268be",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.arange(1,10).reshape(3,3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "10eee9c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1],\n",
       "        [2],\n",
       "        [3]],\n",
       "\n",
       "       [[4],\n",
       "        [5],\n",
       "        [6]],\n",
       "\n",
       "       [[7],\n",
       "        [8],\n",
       "        [9]]])"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "id": "bcb951d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.arange(1,10).reshape(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "id": "f3c58e89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "33cf966d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.squeeze(axis = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "id": "986fc331",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1],\n",
       "        [2],\n",
       "        [3]],\n",
       "\n",
       "       [[4],\n",
       "        [5],\n",
       "        [6]],\n",
       "\n",
       "       [[7],\n",
       "        [8],\n",
       "        [9]]])"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.expand_dims( B, axis=2) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20fe1aad",
   "metadata": {},
   "source": [
    "    A.shape= (3,3) , B.shape= (3,3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "540ce11e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a24ab27",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "136492e2",
   "metadata": {},
   "source": [
    "### np.all()\n",
    "\n",
    "\n",
    "    a = np.array([[[ 0, 0, 0],\n",
    "     [ 0, 0, 0],\n",
    "     [ 0, 0, 0],\n",
    "     [ 0, 0, 0]],\n",
    "    [[ 0, 0, 255],\n",
    "     [255, 255, 255],\n",
    "     [ 0, 0, 0],\n",
    "     [255, 0, 0]]])\n",
    "    b = np.array([255, 0, 255])\n",
    "    c = np.all(a == b, axis = 1) \n",
    "    For the above code, what's the output for c?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "id": "693434eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[  [ 0, 0, 0],\n",
    "                 [ 0, 0, 0],\n",
    "                 [ 0, 0, 0],\n",
    "                 [ 0, 0, 0]   ],\n",
    "            [    [ 0, 0, 255],\n",
    "                 [255, 255, 255],\n",
    "                 [ 0, 0, 0],\n",
    "                 [255, 0, 0]   ]])\n",
    "b = np.array([255, 0, 255])\n",
    "c = np.all(a == b, axis = 1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "id": "72b97e49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[  0,   0,   0],\n",
       "        [  0,   0,   0],\n",
       "        [  0,   0,   0],\n",
       "        [  0,   0,   0]],\n",
       "\n",
       "       [[  0,   0, 255],\n",
       "        [255, 255, 255],\n",
       "        [  0,   0,   0],\n",
       "        [255,   0,   0]]])"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "id": "63b7ce98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([255,   0, 255])"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "id": "da927d7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[False,  True, False],\n",
       "        [False,  True, False],\n",
       "        [False,  True, False],\n",
       "        [False,  True, False]],\n",
       "\n",
       "       [[False,  True,  True],\n",
       "        [ True, False,  True],\n",
       "        [False,  True, False],\n",
       "        [ True,  True, False]]])"
      ]
     },
     "execution_count": 276,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a==b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "id": "b69f5403",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True, False],\n",
       "       [False, False, False]])"
      ]
     },
     "execution_count": 275,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ca7f518",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad0dccde",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "446e5d12",
   "metadata": {},
   "source": [
    "Diagonals of 2D array\n",
    "\n",
    "    Given a 2D array arr, Find which of the following codes are true.\n",
    "\n",
    "    import numpy as np\n",
    "\n",
    "    arr= np.array([[2,3,4,5],[1,7,3,5],[2,8,6,9],[11,23,12,19]])\n",
    "\n",
    "    a.  np.triu(arr) = array([[2,3,4,5],[0,7,3,5],[0,0,6,9],[0,0,0,19]])\n",
    "\n",
    "    b.  np.tril(arr) = array([[2,0,0,0],[1,7,0,0],[2,8,6,0],[11,23,12,19]])\n",
    "\n",
    "    c.  np.diag(arr, k=1) = array([3,3,9])\n",
    "\n",
    "    d.  arr*np.eye(arr.shape[1], dtype=int) = array([[2,0,0,0],[0,7,0,0],[0,0,6,0],[0,0,0,19]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "id": "8072b023",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr= np.array([[2,3,4,5],[1,7,3,5],[2,8,6,9],[11,23,12,19]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "id": "b8976059",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4,  5],\n",
       "       [ 1,  7,  3,  5],\n",
       "       [ 2,  8,  6,  9],\n",
       "       [11, 23, 12, 19]])"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "id": "efa99524",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4,  5],\n",
       "       [ 0,  7,  3,  5],\n",
       "       [ 0,  0,  6,  9],\n",
       "       [ 0,  0,  0, 19]])"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.triu(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "id": "868e6e20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  0,  0,  0],\n",
       "       [ 1,  7,  0,  0],\n",
       "       [ 2,  8,  6,  0],\n",
       "       [11, 23, 12, 19]])"
      ]
     },
     "execution_count": 281,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tril(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "id": "7629abf0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 3, 9])"
      ]
     },
     "execution_count": 282,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(arr,k=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "id": "5c8aa164",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 283,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(arr,k=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "id": "873b2f6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  7,  6, 19])"
      ]
     },
     "execution_count": 284,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(arr,k=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "id": "775a506d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 285,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "id": "33c14091",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0],\n",
       "       [0, 1, 0, 0],\n",
       "       [0, 0, 1, 0],\n",
       "       [0, 0, 0, 1]])"
      ]
     },
     "execution_count": 287,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(arr.shape[1],dtype=\"int\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "id": "df7b8c1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  0,  0,  0],\n",
       "       [ 0,  7,  0,  0],\n",
       "       [ 0,  0,  6,  0],\n",
       "       [ 0,  0,  0, 19]])"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr * np.eye(arr.shape[1],dtype=\"int\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb820975",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ab8607b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4da10613",
   "metadata": {},
   "source": [
    "### One Hot Encoding\n",
    "\n",
    "    Given a 1D NumPy array containing integers, convert each integral value into one-hot encoded values.\n",
    "\n",
    "    Note: Input and output arrays are of dtype 'int'.\n",
    "\n",
    "    Input Format :\n",
    "\n",
    "    Number of testcases  \n",
    "    Space separated numbers representing elements of array for each testcases  \n",
    "\n",
    "    Output Format:\n",
    "\n",
    "    Return the one-hot encoded numpy array   \n",
    "\n",
    "    Sample Input :\n",
    "\n",
    "\n",
    "    array [1,3,4,1,2]  \n",
    "    Sample Output :\n",
    "\n",
    "    array [[0,1,0,0,0],  \n",
    "           [0,0,0,1,0],  \n",
    "           [0,0,0,0,1],  \n",
    "           [0,1,0,0,0],  \n",
    "           [0,0,1,0,0]]  \n",
    "    Output an array of dimension (inputarray.size, max(inputarray)+1)\n",
    "\n",
    "    Explaination :\n",
    "\n",
    "    Each row is the one hot encoded representation of the elements in input array.\n",
    "    Example: 3 is represented by [0,0,0,1,0] at index=3 its 1 else all are 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "id": "8783bba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "inputA = np.array([1,3,4,1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75a428ac",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "id": "0d862ae0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0]])"
      ]
     },
     "execution_count": 307,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ans = np.zeros((len(inputA),np.max(inputA)+1),dtype = \"int\")\n",
    "ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "id": "b9359232",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 0, 0],\n",
       "       [0, 0, 0, 1, 0],\n",
       "       [0, 0, 0, 0, 1],\n",
       "       [0, 1, 0, 0, 0],\n",
       "       [0, 0, 1, 0, 0]])"
      ]
     },
     "execution_count": 315,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(len(inputA)):\n",
    "    ans[i,inputA[i]] = 1\n",
    "ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "id": "abbda6cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# another method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "id": "3bd28f97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0]])"
      ]
     },
     "execution_count": 310,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp = np.zeros((len(inputA),np.max(inputA)+1),dtype = \"int\")\n",
    "temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "id": "3fd9b5f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 318,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputA.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "id": "88fce390",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 319,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(inputA.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "id": "732ec070",
   "metadata": {},
   "outputs": [],
   "source": [
    "temp[np.arange(inputA.size),inputA] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "id": "52941653",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 0, 0],\n",
       "       [0, 0, 0, 1, 0],\n",
       "       [0, 0, 0, 0, 1],\n",
       "       [0, 1, 0, 0, 0],\n",
       "       [0, 0, 1, 0, 0]])"
      ]
     },
     "execution_count": 321,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1be9622d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "525b0f35",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0f2ac157",
   "metadata": {},
   "source": [
    "### Original Matrix Retrieval\n",
    "\n",
    "    John and Edo have been childhood friends. Both love playing with numbers, especially with matrices. One day, John comes up with an interesting problem for Edo. He takes a 4 x 4 matrix, and breaks it down into 4 parts, top left, top right, bottom left, and bottom right, and now wants Edo to retrieve the original matrix from some hints about the 4 parts. In detail,\n",
    "\n",
    "    1. For each part, Edo will be given 2 numbers, and he has to generate 4 spaced equal numbers between these 2 numbers (both numbers included).\n",
    "\n",
    "    2. After generating this 4 length array, convert it into a 2x2 matrix, and merge them as per requirement (according to their positions).\n",
    "\n",
    "    Help Edo with this task. You can refer to the sample input-output explanation to understand the problem properly.\n",
    "\n",
    "    For a particular part's hint (i.e. a and b), it can be assumed that all the 4 numbers present in the even space length [a,b], will be whole numbers and not fractions.\n",
    "\n",
    "    Input Format\n",
    "\n",
    "    Number of testcases.\n",
    "    For each testcase, there will be total of 4 lines of input, each line containing 2 numbers separated by space, denoting each part's range, in order of top left, top right, bottom left, and bottom right.\n",
    "    A list is given as an argument for the function which consists of tuples indicating these range boundaries for each part in the mentioned order.\n",
    "    Output Format\n",
    "\n",
    "    Return the 4x4 matrix consisting float elements upto 1 decimal point, after processing the inputs for each testcase.\n",
    "    Sample Input\n",
    "\n",
    "    1\n",
    "    0 2\n",
    "    5 7\n",
    "    1 3\n",
    "    6 9\n",
    "    Sample Output\n",
    "\n",
    "    Return the 4x4 matrix. It should look like:\n",
    "\n",
    "    [[0.  0.7 5.  5.7] \n",
    "     [1.3 2.  6.3 7. ] \n",
    "     [1.  1.7 6.  7. ] \n",
    "     [2.3 3.  8.  9. ]]\n",
    "    Explanation\n",
    "\n",
    "    For top left, [0, 2], the matrix is 2x2 of [0., 0.7, 1.3, 2.], which is\n",
    "    [[0. 0.7]\n",
    "\n",
    "    [1.3 2.]]\n",
    "\n",
    "    Similarly top right, for [5, 7], it will be\n",
    "    [[5. 5.7]\n",
    "\n",
    "    [6.3 7.]]\n",
    "\n",
    "    The bottom left will be:\n",
    "    [[1. 1.7]\n",
    "\n",
    "    [2.3 3.]]\n",
    "\n",
    "    and Bottom right will be:\n",
    "    [[6. 7.]\n",
    "\n",
    "    [8. 9.]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "id": "7f2ae3f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "inputc = np.array([[0,2],\n",
    "                  [5,7],\n",
    "                  [1,3],\n",
    "                  [6,9]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "id": "27e7825a",
   "metadata": {},
   "outputs": [],
   "source": [
    "a1,b1 = inputc[0]\n",
    "a2,b2 = inputc[1]\n",
    "a3,b3 = inputc[2]\n",
    "a4,b4 = inputc[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "id": "aff4d7bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 2, 5, 7, 1, 3, 6, 9)"
      ]
     },
     "execution_count": 338,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1,b1,a2,b2,a3,b3,a4,b4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "id": "0312c8dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 0.7],\n",
       "       [1.3, 2. ]])"
      ]
     },
     "execution_count": 343,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.round(np.linspace(a1,b1,4),1).reshape(2,2)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "id": "e10fe4d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.round(np.linspace(a2,b2,4),1).reshape(2,2)\n",
    "C = np.round(np.linspace(a3,b3,4),1).reshape(2,2)\n",
    "D = np.round(np.linspace(a4,b4,4),1).reshape(2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 347,
   "id": "53213b5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 0.7, 5. , 5.7],\n",
       "       [1.3, 2. , 6.3, 7. ]])"
      ]
     },
     "execution_count": 347,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.hstack((A,B))\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "id": "36866e9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 1.7, 6. , 7. ],\n",
       "       [2.3, 3. , 8. , 9. ]])"
      ]
     },
     "execution_count": 348,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y = np.hstack((C,D))\n",
    "Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 350,
   "id": "1c9aa0ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 0.7, 5. , 5.7],\n",
       "       [1.3, 2. , 6.3, 7. ],\n",
       "       [1. , 1.7, 6. , 7. ],\n",
       "       [2.3, 3. , 8. , 9. ]])"
      ]
     },
     "execution_count": 350,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((X,Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d26215d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2af30fda",
   "metadata": {},
   "source": [
    "### Trial softmax\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "5b5d761f",
   "metadata": {},
   "source": [
    "   ![image.png](attachment:image.png)\n",
    "    The formula for getting softmax score is:\n",
    "\n",
    "\n",
    "\n",
    "    ,here Zi is the observations[i] and k is the total number of observations.\n",
    "\n",
    "    The softmax function is used in machine learning algorithms for classification applications. What it basically does is that it takes input as an array and converts it into a probability distribution where the sum of each elements' probability will be 1.\n",
    "\n",
    "    Write a function that could take a list as an input and can return a NumPy array that would have the softmax scores of each element as a member.\n",
    "\n",
    "    Input format:\n",
    "\n",
    "    number of testcases\n",
    "    space separating numbers representing elements of list for each testcases\n",
    "    Output format:\n",
    "\n",
    "    Return the numpy array simply consisting the scores for each element of the list\n",
    "    Sample input:\n",
    "\n",
    "    1\n",
    "    6 2 4 3 1\n",
    "    Sample output:\n",
    "\n",
    "    [0.826 0.015 0.112 0.041 0.006]\n",
    "    Explanation:\n",
    "\n",
    "    denominator = (e6 + e2 + e4 + e3 +e1)\n",
    "\n",
    "    softmax(6) = e6/(e6 + e2 + e4 + e3 +e1) = e6/denominator = 0.826\n",
    "\n",
    "    softmax(2) = e2/denominator = 0.015\n",
    "\n",
    "    And similarly, the softmax score of the remaining elements can be calculated.\n",
    "\n",
    "    Take care that the test case outputs are made using np.round function for estimating up to 3 decimal places. The code for taking input is already taken care of and make sure to print the numpy array inside the function only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 351,
   "id": "261f6817",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [6,2,4,3,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "id": "65e2117c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 2, 4, 3, 1])"
      ]
     },
     "execution_count": 352,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.array(data)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 353,
   "id": "c78e0a76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([403.42879349,   7.3890561 ,  54.59815003,  20.08553692,\n",
       "         2.71828183])"
      ]
     },
     "execution_count": 353,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.e**data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "id": "1acdd28b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "488.2198183764566"
      ]
     },
     "execution_count": 354,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(np.e**data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 356,
   "id": "5d7efd37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.826, 0.015, 0.112, 0.041, 0.006])"
      ]
     },
     "execution_count": 356,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round(np.e**data/(np.sum(np.e**data)),3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0672990",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05471ab2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7fb53ea",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9b046907",
   "metadata": {},
   "source": [
    "## Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad4ae5fe",
   "metadata": {},
   "source": [
    "#### np.tile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a43a2f56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.arange(1,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "979bcaf3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1cf9fd74",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([1, 2, 1, 2, 1, 2, 1, 2])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(x,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fb023fde",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([1, 2, 1, 2, 1, 2, 1, 2])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(x,(4,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0605d0f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2, 1, 2]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(x,(1,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f4fe07d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [1, 2],\n",
       "       [1, 2],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(x,(4,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "37d8cbcf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2],\n",
       "       [1, 2, 1, 2],\n",
       "       [1, 2, 1, 2],\n",
       "       [1, 2, 1, 2]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(x,(4,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "48a63608",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[[1, 2],\n",
       "        [1, 2],\n",
       "        [1, 2]],\n",
       "\n",
       "       [[1, 2],\n",
       "        [1, 2],\n",
       "        [1, 2]],\n",
       "\n",
       "       [[1, 2],\n",
       "        [1, 2],\n",
       "        [1, 2]],\n",
       "\n",
       "       [[1, 2],\n",
       "        [1, 2],\n",
       "        [1, 2]]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(x,(4,3,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "256feaa9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "626015a1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "bcd256c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.arange(0,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "d6749849",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "d36d8f5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Y = X[:,np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "2a0b89d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4],\n",
       "       [5]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "824295fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Z = np.ones((5)).astype(\"int\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "7d053a6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "36b89b0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[[1]],\n",
       "\n",
       "       [[1]],\n",
       "\n",
       "       [[1]],\n",
       "\n",
       "       [[1]],\n",
       "\n",
       "       [[1]]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z[:,np.newaxis][:,np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "fb6fffec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [ 1,  2,  3,  4,  5,  6],\n",
       "       [ 2,  3,  4,  5,  6,  7],\n",
       "       [ 3,  4,  5,  6,  7,  8],\n",
       "       [ 4,  5,  6,  7,  8,  9],\n",
       "       [ 5,  6,  7,  8,  9, 10]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X+Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "e6be7bd2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2,  3,  4,  5,  6],\n",
       "        [ 2,  3,  4,  5,  6,  7],\n",
       "        [ 3,  4,  5,  6,  7,  8],\n",
       "        [ 4,  5,  6,  7,  8,  9],\n",
       "        [ 5,  6,  7,  8,  9, 10],\n",
       "        [ 6,  7,  8,  9, 10, 11]],\n",
       "\n",
       "       [[ 1,  2,  3,  4,  5,  6],\n",
       "        [ 2,  3,  4,  5,  6,  7],\n",
       "        [ 3,  4,  5,  6,  7,  8],\n",
       "        [ 4,  5,  6,  7,  8,  9],\n",
       "        [ 5,  6,  7,  8,  9, 10],\n",
       "        [ 6,  7,  8,  9, 10, 11]],\n",
       "\n",
       "       [[ 1,  2,  3,  4,  5,  6],\n",
       "        [ 2,  3,  4,  5,  6,  7],\n",
       "        [ 3,  4,  5,  6,  7,  8],\n",
       "        [ 4,  5,  6,  7,  8,  9],\n",
       "        [ 5,  6,  7,  8,  9, 10],\n",
       "        [ 6,  7,  8,  9, 10, 11]],\n",
       "\n",
       "       [[ 1,  2,  3,  4,  5,  6],\n",
       "        [ 2,  3,  4,  5,  6,  7],\n",
       "        [ 3,  4,  5,  6,  7,  8],\n",
       "        [ 4,  5,  6,  7,  8,  9],\n",
       "        [ 5,  6,  7,  8,  9, 10],\n",
       "        [ 6,  7,  8,  9, 10, 11]],\n",
       "\n",
       "       [[ 1,  2,  3,  4,  5,  6],\n",
       "        [ 2,  3,  4,  5,  6,  7],\n",
       "        [ 3,  4,  5,  6,  7,  8],\n",
       "        [ 4,  5,  6,  7,  8,  9],\n",
       "        [ 5,  6,  7,  8,  9, 10],\n",
       "        [ 6,  7,  8,  9, 10, 11]]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X+Y+Z[:,np.newaxis][:,np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "c745d0ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4, 5],\n",
       "       [0, 1, 2, 3, 4, 5],\n",
       "       [0, 1, 2, 3, 4, 5],\n",
       "       [0, 1, 2, 3, 4, 5]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(X,(4,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82b859da",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8178c51f",
   "metadata": {},
   "source": [
    "#### Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "9fdc9500",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.arange(1,17).reshape(4,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "33ccaaa5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8],\n",
       "       [ 9, 10, 11, 12],\n",
       "       [13, 14, 15, 16]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "fb367751",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[array([[1, 2, 3, 4],\n",
       "        [5, 6, 7, 8]]),\n",
       " array([[ 9, 10, 11, 12],\n",
       "        [13, 14, 15, 16]])]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(X,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "9eb4997e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[array([[1, 2, 3, 4],\n",
       "        [5, 6, 7, 8]]),\n",
       " array([[ 9, 10, 11, 12],\n",
       "        [13, 14, 15, 16]])]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(X,2,axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "6b6f6ffa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8],\n",
       "       [ 9, 10, 11, 12],\n",
       "       [13, 14, 15, 16]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "675ca1de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[array([[ 1,  2],\n",
       "        [ 5,  6],\n",
       "        [ 9, 10],\n",
       "        [13, 14]]),\n",
       " array([[ 3,  4],\n",
       "        [ 7,  8],\n",
       "        [11, 12],\n",
       "        [15, 16]])]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(X,2,axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c9a4f1d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "417eb40f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa7fba1a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "5bb556a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.arange(1,49).reshape(6,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "1db7057c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5,  6,  7,  8],\n",
       "       [ 9, 10, 11, 12, 13, 14, 15, 16],\n",
       "       [17, 18, 19, 20, 21, 22, 23, 24],\n",
       "       [25, 26, 27, 28, 29, 30, 31, 32],\n",
       "       [33, 34, 35, 36, 37, 38, 39, 40],\n",
       "       [41, 42, 43, 44, 45, 46, 47, 48]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "193fccf3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[array([[ 1,  2,  3,  4,  5,  6,  7,  8],\n",
       "        [ 9, 10, 11, 12, 13, 14, 15, 16]]),\n",
       " array([[17, 18, 19, 20, 21, 22, 23, 24],\n",
       "        [25, 26, 27, 28, 29, 30, 31, 32],\n",
       "        [33, 34, 35, 36, 37, 38, 39, 40]]),\n",
       " array([[41, 42, 43, 44, 45, 46, 47, 48]])]"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(X,[2,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "874e91ee",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[array([[ 1,  2,  3,  4,  5,  6,  7,  8],\n",
       "        [ 9, 10, 11, 12, 13, 14, 15, 16]]),\n",
       " array([[17, 18, 19, 20, 21, 22, 23, 24],\n",
       "        [25, 26, 27, 28, 29, 30, 31, 32],\n",
       "        [33, 34, 35, 36, 37, 38, 39, 40]]),\n",
       " array([[41, 42, 43, 44, 45, 46, 47, 48]])]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(X,[2,5],axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "52f69053",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5,  6,  7,  8],\n",
       "       [ 9, 10, 11, 12, 13, 14, 15, 16],\n",
       "       [17, 18, 19, 20, 21, 22, 23, 24],\n",
       "       [25, 26, 27, 28, 29, 30, 31, 32],\n",
       "       [33, 34, 35, 36, 37, 38, 39, 40],\n",
       "       [41, 42, 43, 44, 45, 46, 47, 48]])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "77df49bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[array([[ 1,  2],\n",
       "        [ 9, 10],\n",
       "        [17, 18],\n",
       "        [25, 26],\n",
       "        [33, 34],\n",
       "        [41, 42]]),\n",
       " array([[ 3,  4,  5],\n",
       "        [11, 12, 13],\n",
       "        [19, 20, 21],\n",
       "        [27, 28, 29],\n",
       "        [35, 36, 37],\n",
       "        [43, 44, 45]]),\n",
       " array([[ 6,  7,  8],\n",
       "        [14, 15, 16],\n",
       "        [22, 23, 24],\n",
       "        [30, 31, 32],\n",
       "        [38, 39, 40],\n",
       "        [46, 47, 48]])]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(X,[2,5],axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b85605e6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "d0780078",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5,  6,  7,  8],\n",
       "       [ 9, 10, 11, 12, 13, 14, 15, 16],\n",
       "       [17, 18, 19, 20, 21, 22, 23, 24],\n",
       "       [25, 26, 27, 28, 29, 30, 31, 32],\n",
       "       [33, 34, 35, 36, 37, 38, 39, 40],\n",
       "       [41, 42, 43, 44, 45, 46, 47, 48]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "b6906e42",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[array([[ 1,  2,  3,  4],\n",
       "        [ 9, 10, 11, 12],\n",
       "        [17, 18, 19, 20],\n",
       "        [25, 26, 27, 28],\n",
       "        [33, 34, 35, 36],\n",
       "        [41, 42, 43, 44]]),\n",
       " array([[ 5,  6,  7,  8],\n",
       "        [13, 14, 15, 16],\n",
       "        [21, 22, 23, 24],\n",
       "        [29, 30, 31, 32],\n",
       "        [37, 38, 39, 40],\n",
       "        [45, 46, 47, 48]])]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hsplit(X,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "f9bf7776",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[array([[ 1,  2,  3,  4,  5,  6,  7,  8],\n",
       "        [ 9, 10, 11, 12, 13, 14, 15, 16],\n",
       "        [17, 18, 19, 20, 21, 22, 23, 24]]),\n",
       " array([[25, 26, 27, 28, 29, 30, 31, 32],\n",
       "        [33, 34, 35, 36, 37, 38, 39, 40],\n",
       "        [41, 42, 43, 44, 45, 46, 47, 48]])]"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vsplit(X,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "823a9b3b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "26e2dc4b",
   "metadata": {},
   "source": [
    "### Merging "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "65db1d25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.arange(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "de6353f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Y = np.arange(5,9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "ae64dbef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((X,X,X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "1af3da76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [1, 2, 3, 4],\n",
       "       [1, 2, 3, 4]])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((X,X,X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "f2931805",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((X,X,Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d028972",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "f4ecc297",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4],\n",
       "       [5],\n",
       "       [6]])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1], [2], [3]])\n",
    "b = np.array([[4], [5], [6]])\n",
    "np.vstack((a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46f4f220",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f51a8bc6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "603aacf6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcd7d101",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8d3ff9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#######################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "a5cd259a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.arange(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "c4370ea9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "e80d5e7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "S = X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "07b74a0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "T = X.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "6f7c7c02",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "83d6ffb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "X[-1] = -99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "4d3af008",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   2,   3, -99])"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "6ade1b24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   2,   3, -99])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "919ead1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "289072e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1994506491536, 1994506491536, 1994506493168)"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(X),id(S),id(T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9abd823b",
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "85f89c68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = np.array([0,1,2,3,4,5])\n",
    "b = a[a%1 == 0]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "17348f93",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[a%1 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "ffad47f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "b[0] = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "f81b8eba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "a30e4852",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  1,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "133b6f13",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28dd48f1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c713841",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f90482d4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1cbbf658",
   "metadata": {},
   "source": [
    "### 3D arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "4de9d101",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2,  3,  4,  5,  6],\n",
       "        [ 7,  8,  9, 10, 11, 12]],\n",
       "\n",
       "       [[13, 14, 15, 16, 17, 18],\n",
       "        [19, 20, 21, 22, 23, 24]],\n",
       "\n",
       "       [[25, 26, 27, 28, 29, 30],\n",
       "        [31, 32, 33, 34, 35, 36]],\n",
       "\n",
       "       [[37, 38, 39, 40, 41, 42],\n",
       "        [43, 44, 45, 46, 47, 48]]])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.arange(1,49).reshape(4,2,6)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "4fce2801",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3,  9],\n",
       "       [15, 21],\n",
       "       [27, 33],\n",
       "       [39, 45]])"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:,:,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "4b832ce1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 3],\n",
       "        [ 9]],\n",
       "\n",
       "       [[15],\n",
       "        [21]],\n",
       "\n",
       "       [[27],\n",
       "        [33]],\n",
       "\n",
       "       [[39],\n",
       "        [45]]])"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:,:,[2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "3e9f6f04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5,  6],\n",
       "       [13, 14, 15, 16, 17, 18],\n",
       "       [25, 26, 27, 28, 29, 30],\n",
       "       [37, 38, 39, 40, 41, 42]])"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:,0,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "db7b3dbd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5,  6],\n",
       "       [ 7,  8,  9, 10, 11, 12]])"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[0,:,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64a6dd05",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "11e8c9cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "#gcd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89f1d0db",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "ebda9a43",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gcd(a,b):\n",
    "    while a != 0:\n",
    "        a,b = b%a,a\n",
    "    return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "57294547",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gcd(gcd(24,18),36)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "3f8c20a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0101\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "650"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def nth_magic_number( n):\n",
    "\n",
    "    s = bin(n)[2:][::-1]\n",
    "    print(s)\n",
    "    p = 1\n",
    "    ans = 0\n",
    "    for i in s:\n",
    "        ans += int(i)*(5**p)\n",
    "        p += 1\n",
    "\n",
    "    return ans\n",
    "nth_magic_number(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1b7cc3d",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}