Task-2-Numpy_tasks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uUkbYoy9jWv9"
   },
   "source": [
    "# Numpy\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IHc0Z_fSjWwE"
   },
   "source": [
    "#### 1. Import the numpy package under the name `np` (★☆☆) \n",
    "(**hint**: import … as …)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "wbc5hQDkjWwF"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ybwDcMiyjWwG"
   },
   "source": [
    "#### 2. Print the numpy version and the configuration (★☆☆) \n",
    "(**hint**: np.\\_\\_version\\_\\_, np.show\\_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "id": "9c1JodWEjWwH",
    "outputId": "da7b484d-6683-4c54-c5ef-30e1f322e287"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.23.3'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vShelaJfjWwH"
   },
   "source": [
    "#### 3. Create a null vector of size 10 (★☆☆) \n",
    "(**hint**: np.zeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bp5DsinTjWwI",
    "outputId": "f36eddf9-abcc-4473-f9b4-907dd40b5b60"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zGpzyn_bjWwL"
   },
   "source": [
    "#### 4.  How to find the memory size of any array (★☆☆) \n",
    "(**hint**: size, itemsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Y3-x2C1YjWwM",
    "outputId": "ff4e58c7-584d-453d-9b55-b47cd1692286"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "x = np.zeros(10)\n",
    "print(x.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ToN6cyKnjWwN"
   },
   "source": [
    "#### 5.  How to get the documentation of the numpy add function from the command line? (★☆☆) \n",
    "(**hint**: np.info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LJEfQRK7jWwO",
    "outputId": "c6f22eec-6d99-4ca5-85e6-4935d04fd5ec"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function numpy.info(object=None, maxwidth=76, output=None, toplevel='numpy')>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OjiljkfbjWwO"
   },
   "source": [
    "#### 6.  Create a null vector of size 10 but the fifth value which is 1 (★☆☆) \n",
    "(**hint**: array\\[4\\])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 171
    },
    "id": "CBVlBb8FjWwP",
    "outputId": "c3f652eb-c64d-4943-a267-014646f42a51"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "a=np.zeros(10)\n",
    "a[4]=1\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "goWR3kmBjWwP"
   },
   "source": [
    "#### 7.  Create a vector with values ranging from 10 to 49 (★☆☆) \n",
    "(**hint**: np.arange)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2xQMx8Q0jWwQ",
    "outputId": "bfa15c51-0523-4d76-8431-d4131aa603e3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n",
       "       27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,\n",
       "       44, 45, 46, 47, 48])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(10,49)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m9-ApmPtjWwQ"
   },
   "source": [
    "#### 8.  Reverse a vector (first element becomes last) (★☆☆) \n",
    "(**hint**: array\\[::-1\\])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "80845k5zjWwR",
    "outputId": "454fef99-4fe7-46f8-8182-5d8b1a950f87"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "print(a)\n",
    "a[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d1smkiYpjWwR"
   },
   "source": [
    "#### 9.  Create a 3x3 matrix with values ranging from 0 to 8 (★☆☆) \n",
    "(**hint**: reshape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Bn582pYCjWwS",
    "outputId": "6bb72957-6927-43f2-ad84-5a42eb34edd5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "x=np.arange(9)\n",
    "c=x.reshape(3,3)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c_KPxsPwjWwS"
   },
   "source": [
    "#### 10. Find indices of non-zero elements from \\[1,2,0,0,4,0\\] (★☆☆) \n",
    "(**hint**: np.nonzero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WiysjRocjWwT"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4rSj_ZuYjWwU"
   },
   "source": [
    "#### 11. Create a 3x3 identity matrix (★☆☆) \n",
    "(**hint**: np.eye)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "W1FyBZyPjWwU",
    "outputId": "d34ab3c5-6e2a-47fa-b473-381fd6b0f097"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YqCsKbHcjWwV"
   },
   "source": [
    "#### 12. Create a 3x3x3 array with random values (★☆☆) \n",
    "(**hint**: np.random.random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UTewTWuYjWwV",
    "outputId": "a82c4e07-d96e-4988-9523-6587895b5552"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.8177175 , 0.84025906, 0.91793868],\n",
       "        [0.08865188, 0.83486674, 0.30955459],\n",
       "        [0.99888358, 0.70833781, 0.27246129]],\n",
       "\n",
       "       [[0.49292973, 0.15886862, 0.66155746],\n",
       "        [0.61660402, 0.99011204, 0.65614944],\n",
       "        [0.84530506, 0.22552471, 0.40244833]],\n",
       "\n",
       "       [[0.35644772, 0.4665257 , 0.55009698],\n",
       "        [0.39326956, 0.71116998, 0.62452395],\n",
       "        [0.65936654, 0.64296719, 0.28811855]]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random((3,3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Crz2KzewjWwV"
   },
   "source": [
    "#### 13. Create a 10x10 array with random values and find the minimum and maximum values (★☆☆) \n",
    "(**hint**: min, max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "j2HIj-BkjWwW",
    "outputId": "e9ad02c0-d48c-4356-b519-9d893bca6319"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.40874491 0.26238834 0.37399045 0.02867749 0.67707791 0.41949753\n",
      "  0.51831319 0.69078208 0.188901   0.33032758]\n",
      " [0.4946251  0.00720568 0.71561649 0.97298611 0.5632399  0.29667273\n",
      "  0.13842956 0.74564214 0.56453079 0.60317009]\n",
      " [0.58655751 0.52405264 0.2915422  0.46327169 0.62483284 0.37855061\n",
      "  0.21651429 0.0019815  0.88483152 0.1013008 ]\n",
      " [0.41936127 0.64948452 0.42104939 0.27107587 0.09907204 0.69516884\n",
      "  0.44106394 0.51851205 0.70298265 0.08537282]\n",
      " [0.20778923 0.593175   0.11395465 0.42005231 0.19352248 0.10990421\n",
      "  0.74450871 0.79872533 0.75968252 0.45151963]\n",
      " [0.01491287 0.15862781 0.77044787 0.75275117 0.86397131 0.93429584\n",
      "  0.64967852 0.07252376 0.90783295 0.59754863]\n",
      " [0.65804119 0.32977108 0.73947932 0.10863471 0.38104781 0.90694615\n",
      "  0.03692386 0.49003909 0.89470417 0.43234138]\n",
      " [0.01101091 0.17775979 0.52155049 0.71939151 0.62372082 0.69748749\n",
      "  0.20156002 0.87229185 0.21591755 0.41753064]\n",
      " [0.57963734 0.2528227  0.9220298  0.66559982 0.20653139 0.18738325\n",
      "  0.49080334 0.76564297 0.94138848 0.46083934]\n",
      " [0.33676398 0.64768691 0.23992536 0.71099385 0.12255068 0.60382244\n",
      "  0.3862415  0.97598934 0.45979663 0.73015445]]\n",
      "Minimum Value:  0.0019815001130603083\n",
      "Maximum Value: 0.9759893421099738\n"
     ]
    }
   ],
   "source": [
    "a = np.random.random((10,10))\n",
    "print(a)\n",
    "print(\"Minimum Value: \", a.min())\n",
    "print(\"Maximum Value:\", a.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b7GjbNrxjWwW"
   },
   "source": [
    "#### 14. Create a random vector of size 30 and find the mean value (★☆☆) \n",
    "(**hint**: mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "AtEEIFhLjWwW",
    "outputId": "a1ca919c-5ab8-4b1c-dbfb-41278be22714"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.54607627 0.76857978 0.19888776 0.86053992 0.53574321 0.05629876\n",
      " 0.53399745 0.66935772 0.53798205 0.23945419 0.28552368 0.72146995\n",
      " 0.33760436 0.48964992 0.11978504 0.61756206 0.92323852 0.78520105\n",
      " 0.89050635 0.39321686 0.30300121 0.35939118 0.96556175 0.75504454\n",
      " 0.10845123 0.18964294 0.24616637 0.38208654 0.2599231  0.00589696]\n",
      "Mean Value: 0.46952802372050695\n"
     ]
    }
   ],
   "source": [
    "a = np.random.random(30)\n",
    "print(a)\n",
    "print(\"Mean Value:\",a.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C8mNEGdbjWwX"
   },
   "source": [
    "#### 15. Create a 2d array with 1 on the border and 0 inside (★☆☆) \n",
    "(**hint**: array\\[1:-1, 1:-1\\])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FFQMbsFHjWwX",
    "outputId": "df1519d2-a4f4-44d8-fa63-aaf5bcbc4990"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[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.]]\n"
     ]
    }
   ],
   "source": [
    "Z = np.ones((5,5))\n",
    "Z[1:-1,1:-1]=0\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hDpZFFbPjWwX"
   },
   "source": [
    "#### 16. How to add a border (filled with 0's) around an existing array? (★☆☆) \n",
    "(**hint**: np.pad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "fX8cCjpHjWwY"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0.]\n",
      " [0. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "Z = np.zeros((5,5))\n",
    "Z[1:-1,1:-1]=1\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2zyahyhJjWwY"
   },
   "source": [
    "#### 17. What is the result of the following expression? (★☆☆) \n",
    "(**hint**: NaN = not a number, inf = infinity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1pYBeuSvjWwZ"
   },
   "source": [
    "```python\n",
    "0 * np.nan\n",
    "np.nan == np.nan\n",
    "np.inf > np.nan\n",
    "np.nan - np.nan\n",
    "0.3 == 3 * 0.1\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "ONQOJsJFjWwb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nan\n",
      "False\n",
      "False\n",
      "nan\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(0 * np.nan)\n",
    "print(np.nan == np.nan)\n",
    "print(np.inf > np.nan)\n",
    "print(np.nan - np.nan)\n",
    "print(0.3 == 3 * 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O0dwmd9ejWwc"
   },
   "source": [
    "#### 18. Create a 5x5 matrix with values 1,2,3,4 just below the diagonal (★☆☆) \n",
    "(**hint**: np.diag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "2LOzA8PLjWwc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0 0]\n",
      " [1 0 0 0 0]\n",
      " [0 2 0 0 0]\n",
      " [0 0 3 0 0]\n",
      " [0 0 0 4 0]]\n"
     ]
    }
   ],
   "source": [
    "d = np.diag(1+np.arange(4), k = -1)\n",
    "print (d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "grQYNrn-jWwd"
   },
   "source": [
    "#### 19. Create a 8x8 matrix and fill it with a checkerboard pattern (★☆☆) \n",
    "(**hint**: array\\[::2\\])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "kTSNbwuLjWwd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]]\n"
     ]
    }
   ],
   "source": [
    "e = np.zeros ((8,8), dtype=int)\n",
    "e[1::2, ::2]= 1\n",
    "e[::2, 1::2] = 1\n",
    "print (e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EpX2VK_3jWwd"
   },
   "source": [
    "#### 20. Consider a (6,7,8) shape array, what is the index (x,y,z) of the 100th element? \n",
    "(**hint**: np.unravel_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "-fHI2eVojWwe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 5, 4)\n"
     ]
    }
   ],
   "source": [
    "print (np.unravel_index(100, (6,7,8)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wFdzQsZWjWwe"
   },
   "source": [
    "#### 21. Create a checkerboard 8x8 matrix using the tile function (★☆☆) \n",
    "(**hint**: np.tile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "ZK4EOrpLjWwe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [0 1 0 1 0 1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([0,1])\n",
    "print(np.tile(A,(8,4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "no8X8HLrjWwe"
   },
   "source": [
    "#### 22. Normalize a 5x5 random matrix (★☆☆) \n",
    "(**hint**: (x - min) / (max - min))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5C6RwVk3jWwe"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yUEqJaL9jWwf"
   },
   "source": [
    "#### 23. Create a custom dtype that describes a color as four unsigned bytes (RGBA) (★☆☆) \n",
    "(**hint**: np.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aAaewvUkjWwf"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h-uMnHeLjWwf"
   },
   "source": [
    "#### 24. Multiply a 5x3 matrix by a 3x2 matrix (real matrix product) (★☆☆) \n",
    "(**hint**: np.dot | @)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Jbn8-0zqjWwf"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0H67qNB8jWwf"
   },
   "source": [
    "#### 25. Given a 1D array, negate all elements which are between 3 and 8, in place. (★☆☆) \n",
    "(**hint**: >, <=)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uWtp8DtAjWwg"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "efYc-1PyjWwg"
   },
   "source": [
    "#### 26. What is the output of the following script? (★☆☆) \n",
    "(**hint**: np.sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f4F7KYgcjWwg"
   },
   "source": [
    "```python\n",
    "# Author: Jake VanderPlas\n",
    "\n",
    "print(sum(range(5),-1))\n",
    "from numpy import *\n",
    "print(sum(range(5),-1))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nnvacSHVjWwg"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3qXroMVGjWwg"
   },
   "source": [
    "#### 27. Consider an integer vector Z, which of these expressions are legal? (★☆☆)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dZGuyphpjWwh"
   },
   "source": [
    "```python\n",
    "Z**Z\n",
    "2 << Z >> 2\n",
    "Z <- Z\n",
    "1j*Z\n",
    "Z/1/1\n",
    "Z<Z>Z\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OlaXrjW9jWwh"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9cz7WHiZjWwh"
   },
   "source": [
    "#### 28. What are the result of the following expressions?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EVV0moIHjWwh"
   },
   "source": [
    "```python\n",
    "np.array(0) / np.array(0)\n",
    "np.array(0) // np.array(0)\n",
    "np.array([np.nan]).astype(int).astype(float)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-fvS7d-yjWwh"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gYrJX9FajWwi"
   },
   "source": [
    "#### 29. How to round away from zero a float array ? (★☆☆) \n",
    "(**hint**: np.uniform, np.copysign, np.ceil, np.abs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VvgT07kJjWwi"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xvc_gCb8jWwi"
   },
   "source": [
    "#### 30. How to find common values between two arrays? (★☆☆) \n",
    "(**hint**: np.intersect1d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7x9102UJjWwi"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KTVAegkyjWwi"
   },
   "source": [
    "#### 31. How to ignore all numpy warnings (not recommended)? (★☆☆) \n",
    "(**hint**: np.seterr, np.errstate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bCAAMNKSjWwi"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nAYFyBvcjWwi"
   },
   "source": [
    "#### 32. Is the following expressions true? (★☆☆) \n",
    "(**hint**: imaginary number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Sh_KVCD8jWwj"
   },
   "source": [
    "```python\n",
    "np.sqrt(-1) == np.emath.sqrt(-1)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5utX9JCNjWwj"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oJslBkIJjWwj"
   },
   "source": [
    "#### 33. How to get the dates of yesterday, today and tomorrow? (★☆☆) \n",
    "(**hint**: np.datetime64, np.timedelta64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "k-doH0nmjWwj"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iwi4h_XDjWwj"
   },
   "source": [
    "#### 34. How to get all the dates corresponding to the month of July 2016? (★★☆) \n",
    "(**hint**: np.arange(dtype=datetime64\\['D'\\]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "e3wcw9IijWwk"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0qXXCFGOjWwk"
   },
   "source": [
    "#### 35. How to compute ((A+B)\\*(-A/2)) in place (without copy)? (★★☆) \n",
    "(**hint**: np.add(out=), np.negative(out=), np.multiply(out=), np.divide(out=))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mEfY-DoMjWwk"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q-GGA5EsjWwk"
   },
   "source": [
    "#### 36. Extract the integer part of a random array using 5 different methods (★★☆) \n",
    "(**hint**: %, np.floor, np.ceil, astype, np.trunc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ptivyRpRjWwk"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5A8KA-mwjWwl"
   },
   "source": [
    "#### 37. Create a 5x5 matrix with row values ranging from 0 to 4 (★★☆) \n",
    "(**hint**: np.arange)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "U6JrTPs-jWwl"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FIKeDVBOjWwl"
   },
   "source": [
    "#### 38. Consider a generator function that generates 10 integers and use it to build an array (★☆☆) \n",
    "(**hint**: np.fromiter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "a-uaI0TnjWwm"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "STPmYenWjWwm"
   },
   "source": [
    "#### 39. Create a vector of size 10 with values ranging from 0 to 1, both excluded (★★☆) \n",
    "(**hint**: np.linspace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RkGl2LFvjWwm"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XA3dUvh8jWwn"
   },
   "source": [
    "#### 40. Create a random vector of size 10 and sort it (★★☆) \n",
    "(**hint**: sort)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XgR2RT9RjWwn"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7szOuWVYjWwn"
   },
   "source": [
    "#### 41. How to sum a small array faster than np.sum? (★★☆) \n",
    "(**hint**: np.add.reduce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1TU247qojWwn"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n-6wVY3bjWwn"
   },
   "source": [
    "#### 42. Consider two random array A and B, check if they are equal (★★☆) \n",
    "(**hint**: np.allclose, np.array\\_equal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jD9HQT8ujWwn"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M2N7LVPsjWwo"
   },
   "source": [
    "#### 43. Make an array immutable (read-only) (★★☆) \n",
    "(**hint**: flags.writeable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "THMsnZr2jWwo"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JmG-tN9bjWwo"
   },
   "source": [
    "#### 44. Consider a random 10x2 matrix representing cartesian coordinates, convert them to polar coordinates (★★☆) \n",
    "(**hint**: np.sqrt, np.arctan2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "iD0CxbzrjWwo"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oBMZDzwCjWwo"
   },
   "source": [
    "#### 45. Create random vector of size 10 and replace the maximum value by 0 (★★☆) \n",
    "(**hint**: argmax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5ODuS60_jWwo"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CRzesdRKjWwo"
   },
   "source": [
    "#### 46. Create a structured array with `x` and `y` coordinates covering the \\[0,1\\]x\\[0,1\\] area (★★☆) \n",
    "(**hint**: np.meshgrid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "iVpdKUdwjWwp"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G52DQcW6jWwp"
   },
   "source": [
    "####  47. Given two arrays, X and Y, construct the Cauchy matrix C (Cij =1/(xi - yj)) \n",
    "(**hint**: np.subtract.outer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_IZJgvoKjWwp"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "E6BTVvS5jWwp"
   },
   "source": [
    "#### 48. Print the minimum and maximum representable value for each numpy scalar type (★★☆) \n",
    "(**hint**: np.iinfo, np.finfo, eps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fN7dQAA1jWwp"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ePSxLA0yjWwp"
   },
   "source": [
    "#### 49. How to print all the values of an array? (★★☆) \n",
    "(**hint**: np.set\\_printoptions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8cnUivZYjWwp"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G9W7271ajWwq"
   },
   "source": [
    "#### 50. How to find the closest value (to a given scalar) in a vector? (★★☆) \n",
    "(**hint**: argmin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SL6n2kavjWwq"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_-zGG2F5jWwr"
   },
   "source": [
    "#### 51. Create a structured array representing a position (x,y) and a color (r,g,b) (★★☆) \n",
    "(**hint**: dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Rtwia0ucjWwr"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L_F-DyPTjWwr"
   },
   "source": [
    "#### 52. Consider a random vector with shape (100,2) representing coordinates, find point by point distances (★★☆) \n",
    "(**hint**: np.atleast\\_2d, T, np.sqrt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NSWdbil_jWws"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5Vgb1a1CjWws"
   },
   "source": [
    "#### 53. How to convert a float (32 bits) array into an integer (32 bits) in place? \n",
    "(**hint**: astype(copy=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VUqbt1SqjWws"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JgDitnZTjWws"
   },
   "source": [
    "#### 54. How to read the following file? (★★☆) \n",
    "(**hint**: np.genfromtxt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q01M3T2fjWwt"
   },
   "source": [
    "```\n",
    "1, 2, 3, 4, 5\n",
    "6,  ,  , 7, 8\n",
    " ,  , 9,10,11\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KWov4xctjWwt"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w7LuOSITjWwt"
   },
   "source": [
    "#### 55. What is the equivalent of enumerate for numpy arrays? (★★☆) \n",
    "(**hint**: np.ndenumerate, np.ndindex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "urs5sE3wjWwt"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CwQ_PDWUjWwt"
   },
   "source": [
    "#### 56. Generate a generic 2D Gaussian-like array (★★☆) \n",
    "(**hint**: np.meshgrid, np.exp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EbuvDGo3jWwu"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n9mDtIL1jWwu"
   },
   "source": [
    "#### 57. How to randomly place p elements in a 2D array? (★★☆) \n",
    "(**hint**: np.put, np.random.choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NuovXAOnjWwu"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KU8_IqCrjWwu"
   },
   "source": [
    "#### 58. Subtract the mean of each row of a matrix (★★☆) \n",
    "(**hint**: mean(axis=,keepdims=))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OLjoSFOVjWwu"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UFlEm5dXjWwv"
   },
   "source": [
    "#### 59. How to sort an array by the nth column? (★★☆) \n",
    "(**hint**: argsort)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "H9Xdq5FijWwv"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iBGJ2eGVjWwv"
   },
   "source": [
    "#### 60. How to tell if a given 2D array has null columns? (★★☆) \n",
    "(**hint**: any, ~)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gBl42_HJjWwv"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bpD-qaobjWwv"
   },
   "source": [
    "#### 61. Find the nearest value from a given value in an array (★★☆) \n",
    "(**hint**: np.abs, argmin, flat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nGD9DRaYjWwv"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vsamsrx2jWww"
   },
   "source": [
    "#### 62. Considering two arrays with shape (1,3) and (3,1), how to compute their sum using an iterator? (★★☆) \n",
    "(**hint**: np.nditer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eO7IVYaHjWww"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JidQyyFHjWww"
   },
   "source": [
    "#### 63. Create an array class that has a name attribute (★★☆) \n",
    "(**hint**: class method)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rWGER7vGjWww"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_LK4puGXjWww"
   },
   "source": [
    "#### 64. Consider a given vector, how to add 1 to each element indexed by a second vector (be careful with repeated indices)? (★★★) \n",
    "(**hint**: np.bincount | np.add.at)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pvKzeWnDjWwx"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sLTTVtIfjWwx"
   },
   "source": [
    "#### 65. How to accumulate elements of a vector (X) to an array (F) based on an index list (I)? (★★★) \n",
    "(**hint**: np.bincount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "t_iDiXZQjWwx"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W-nqA8-3jWwx"
   },
   "source": [
    "#### 66. Considering a (w,h,3) image of (dtype=ubyte), compute the number of unique colors (★★★) \n",
    "(**hint**: np.unique)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9ylcKfF0jWwx"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gM00xsjnjWwy"
   },
   "source": [
    "#### 67. Considering a four dimensions array, how to get sum over the last two axis at once? (★★★) \n",
    "(**hint**: sum(axis=(-2,-1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rMKnikRRjWwy"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1hGdNzb1jWwy"
   },
   "source": [
    "#### 68. Considering a one-dimensional vector D, how to compute means of subsets of D using a vector S of same size describing subset  indices? (★★★) \n",
    "(**hint**: np.bincount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DVjCi5ELjWwz"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m4L1qfMVjWwz"
   },
   "source": [
    "#### 69. How to get the diagonal of a dot product? (★★★) \n",
    "(**hint**: np.diag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kIDeyr0zjWwz"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mHyz7hVFjWwz"
   },
   "source": [
    "#### 70. Consider the vector \\[1, 2, 3, 4, 5\\], how to build a new vector with 3 consecutive zeros interleaved between each value? (★★★) \n",
    "(**hint**: array\\[::4\\])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cGCXx2IyjWw0"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q23mPIqijWw0"
   },
   "source": [
    "#### 71. Consider an array of dimension (5,5,3), how to mulitply it by an array with dimensions (5,5)? (★★★) \n",
    "(**hint**: array\\[:, :, None\\])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "80Zf5iNzjWw0"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O7F-lxprjWw1"
   },
   "source": [
    "#### 72. How to swap two rows of an array? (★★★) \n",
    "(**hint**: array\\[\\[\\]\\] = array\\[\\[\\]\\])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zjNRc85pjWw1"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OfYgdmjXjWw1"
   },
   "source": [
    "#### 73. Consider a set of 10 triplets describing 10 triangles (with shared vertices), find the set of unique line segments composing all the  triangles (★★★) \n",
    "(**hint**: repeat, np.roll, np.sort, view, np.unique)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "134iw2wQjWw2"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n6ERk1hpjWw4"
   },
   "source": [
    "#### 74. Given an array C that is a bincount, how to produce an array A such that np.bincount(A) == C? (★★★) \n",
    "(**hint**: np.repeat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XU4bvjBDjWw4"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Pg1Hzgv1jWw5"
   },
   "source": [
    "#### 75. How to compute averages using a sliding window over an array? (★★★) \n",
    "(**hint**: np.cumsum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7kL_ELKwjWw5"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hNFFwlGMjWw6"
   },
   "source": [
    "#### 76. Consider a one-dimensional array Z, build a two-dimensional array whose first row is (Z\\[0\\],Z\\[1\\],Z\\[2\\]) and each subsequent row is  shifted by 1 (last row should be (Z\\[-3\\],Z\\[-2\\],Z\\[-1\\]) (★★★) \n",
    "(**hint**: from numpy.lib import stride_tricks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0wsYbc6ljWw6"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F1WiHzQyjWw7"
   },
   "source": [
    "#### 77. How to negate a boolean, or to change the sign of a float inplace? (★★★) \n",
    "(**hint**: np.logical_not, np.negative)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "volQBBGJjWw7"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XMCgUJ7IjWw8"
   },
   "source": [
    "#### 78. Consider 2 sets of points P0,P1 describing lines (2d) and a point p, how to compute distance from p to each line i  (P0\\[i\\],P1\\[i\\])? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3MPG4eIijWw9"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-mZTawPfjWw9"
   },
   "source": [
    "#### 79. Consider 2 sets of points P0,P1 describing lines (2d) and a set of points P, how to compute distance from each point j (P\\[j\\]) to each line i (P0\\[i\\],P1\\[i\\])? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UlNZQ3a6jWw_"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iguSCD4-jWw_"
   },
   "source": [
    "#### 80. Consider an arbitrary array, write a function that extract a subpart with a fixed shape and centered on a given element (pad with a `fill` value when necessary) (★★★) \n",
    "(**hint**: minimum, maximum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MzEw8jBYjWw_"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vpJ54pSqjWw_"
   },
   "source": [
    "#### 81. Consider an array Z = \\[1,2,3,4,5,6,7,8,9,10,11,12,13,14\\], how to generate an array R = \\[\\[1,2,3,4\\], \\[2,3,4,5\\], \\[3,4,5,6\\], ..., \\[11,12,13,14\\]\\]? (★★★) \n",
    "(**hint**: stride\\_tricks.as\\_strided)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "alz6AVmXjWw_"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JcsO3KF_jWxA"
   },
   "source": [
    "#### 82. Compute a matrix rank (★★★) \n",
    "(**hint**: np.linalg.svd) (suggestion: np.linalg.svd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "N5OnAO8kjWxA"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RnFvE0S7jWxA"
   },
   "source": [
    "#### 83. How to find the most frequent value in an array? \n",
    "(**hint**: np.bincount, argmax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_SQn_oVojWxA"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tT1JlKTsjWxA"
   },
   "source": [
    "#### 84. Extract all the contiguous 3x3 blocks from a random 10x10 matrix (★★★) \n",
    "(**hint**: stride\\_tricks.as\\_strided)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3e7t3PtwjWxA"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DCZT7vMcjWxB"
   },
   "source": [
    "#### 85. Create a 2D array subclass such that Z\\[i,j\\] == Z\\[j,i\\] (★★★) \n",
    "(**hint**: class method)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "v93GK8jsjWxB"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4l5oPqbUjWxB"
   },
   "source": [
    "#### 86. Consider a set of p matrices wich shape (n,n) and a set of p vectors with shape (n,1). How to compute the sum of of the p matrix products at once? (result has shape (n,1)) (★★★) \n",
    "(**hint**: np.tensordot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7AU6tEanjWxB"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0bDrpSWsjWxB"
   },
   "source": [
    "#### 87. Consider a 16x16 array, how to get the block-sum (block size is 4x4)? (★★★) \n",
    "(**hint**: np.add.reduceat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uouUL3gdjWxB"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mloG8wABjWxB"
   },
   "source": [
    "#### 88. How to implement the Game of Life using numpy arrays? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1s4SoM-njWxB"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aFZ3Nbq1jWxC"
   },
   "source": [
    "#### 89. How to get the n largest values of an array (★★★) \n",
    "(**hint**: np.argsort | np.argpartition)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZowHvxhzjWxC"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M8mAYafpjWxC"
   },
   "source": [
    "#### 90. Given an arbitrary number of vectors, build the cartesian product (every combinations of every item) (★★★) \n",
    "(**hint**: np.indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UDzSRu6PjWxC",
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sqhk4RZBjWxC"
   },
   "source": [
    "#### 91. How to create a record array from a regular array? (★★★) \n",
    "(**hint**: np.core.records.fromarrays)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bjG_1ONRjWxC"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4_udbxL_jWxC"
   },
   "source": [
    "#### 92. Consider a large vector Z, compute Z to the power of 3 using 3 different methods (★★★) \n",
    "(**hint**: np.power, \\*, np.einsum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sSowTzYRjWxC"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WYASkbNyjWxC"
   },
   "source": [
    "#### 93. Consider two arrays A and B of shape (8,3) and (2,2). How to find rows of A that contain elements of each row of B regardless of the order of the elements in B? (★★★) \n",
    "(**hint**: np.where)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "t9jTeSgAjWxD"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IgYtAwfRjWxD"
   },
   "source": [
    "#### 94. Considering a 10x3 matrix, extract rows with unequal values (e.g. \\[2,2,3\\]) (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2pRUyQDJjWxD"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PhK4Ew3tjWxD"
   },
   "source": [
    "#### 95. Convert a vector of ints into a matrix binary representation (★★★) \n",
    "(**hint**: np.unpackbits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ml9P59L9jWxD"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I1zMZIkUjWxD"
   },
   "source": [
    "#### 96. Given a two dimensional array, how to extract unique rows? (★★★) \n",
    "(**hint**: np.ascontiguousarray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uD3zovB3jWxD"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LVtp_-0UjWxD"
   },
   "source": [
    "#### 97. Considering 2 vectors A & B, write the einsum equivalent of inner, outer, sum, and mul function (★★★) \n",
    "(**hint**: np.einsum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4vMY58t9jWxE"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QaCu2j3PjWxE"
   },
   "source": [
    "#### 98. Considering a path described by two vectors (X,Y), how to sample it using equidistant samples (★★★)? \n",
    "(**hint**: np.cumsum, np.interp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7h_nF26njWxE"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Gfx1_9WhjWxE"
   },
   "source": [
    "#### 99. Given an integer n and a 2D array X, select from X the rows which can be interpreted as draws from a multinomial distribution with n degrees, i.e., the rows which only contain integers and which sum to n. (★★★) \n",
    "(**hint**: np.logical\\_and.reduce, np.mod)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cak9j7B0jWxE"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WeSK2n06jWxE"
   },
   "source": [
    "#### 100. Compute bootstrapped 95% confidence intervals for the mean of a 1D array X (i.e., resample the elements of an array with replacement N times, compute the mean of each sample, and then compute percentiles over the means). (★★★) \n",
    "(**hint**: np.percentile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "y1s7NXcejWxE"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}