Numpy_Exercise_completed.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Import the numpy package under the name  (★☆☆)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Print the numpy version and the configuration  (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.17.2\n",
      "blas_mkl_info:\n",
      "    libraries = ['mkl_rt', 'pthread']\n",
      "    library_dirs = ['/Users/soumyadeeppaul/opt/anaconda3/lib']\n",
      "    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]\n",
      "    include_dirs = ['/Users/soumyadeeppaul/opt/anaconda3/include']\n",
      "blas_opt_info:\n",
      "    libraries = ['mkl_rt', 'pthread']\n",
      "    library_dirs = ['/Users/soumyadeeppaul/opt/anaconda3/lib']\n",
      "    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]\n",
      "    include_dirs = ['/Users/soumyadeeppaul/opt/anaconda3/include']\n",
      "lapack_mkl_info:\n",
      "    libraries = ['mkl_rt', 'pthread']\n",
      "    library_dirs = ['/Users/soumyadeeppaul/opt/anaconda3/lib']\n",
      "    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]\n",
      "    include_dirs = ['/Users/soumyadeeppaul/opt/anaconda3/include']\n",
      "lapack_opt_info:\n",
      "    libraries = ['mkl_rt', 'pthread']\n",
      "    library_dirs = ['/Users/soumyadeeppaul/opt/anaconda3/lib']\n",
      "    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]\n",
      "    include_dirs = ['/Users/soumyadeeppaul/opt/anaconda3/include']\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print (np.__version__)\n",
    "print (np.show_config())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Create a null vector of size 10 (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.zeros(10)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.  How to find the memory size of any array (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80\n"
     ]
    }
   ],
   "source": [
    "print (arr.size * arr.itemsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.  How to get the documentation of the numpy add function from the command line? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])\n",
      "\n",
      "Add arguments element-wise.\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "x1, x2 : array_like\n",
      "    The arrays to be added. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).\n",
      "out : ndarray, None, or tuple of ndarray and None, optional\n",
      "    A location into which the result is stored. If provided, it must have\n",
      "    a shape that the inputs broadcast to. If not provided or `None`,\n",
      "    a freshly-allocated array is returned. A tuple (possible only as a\n",
      "    keyword argument) must have length equal to the number of outputs.\n",
      "where : array_like, optional\n",
      "    This condition is broadcast over the input. At locations where the\n",
      "    condition is True, the `out` array will be set to the ufunc result.\n",
      "    Elsewhere, the `out` array will retain its original value.\n",
      "    Note that if an uninitialized `out` array is created via the default\n",
      "    ``out=None``, locations within it where the condition is False will\n",
      "    remain uninitialized.\n",
      "**kwargs\n",
      "    For other keyword-only arguments, see the\n",
      "    :ref:`ufunc docs <ufuncs.kwargs>`.\n",
      "\n",
      "Returns\n",
      "-------\n",
      "add : ndarray or scalar\n",
      "    The sum of `x1` and `x2`, element-wise.\n",
      "    This is a scalar if both `x1` and `x2` are scalars.\n",
      "\n",
      "Notes\n",
      "-----\n",
      "Equivalent to `x1` + `x2` in terms of array broadcasting.\n",
      "\n",
      "Examples\n",
      "--------\n",
      ">>> np.add(1.0, 4.0)\n",
      "5.0\n",
      ">>> x1 = np.arange(9.0).reshape((3, 3))\n",
      ">>> x2 = np.arange(3.0)\n",
      ">>> np.add(x1, x2)\n",
      "array([[  0.,   2.,   4.],\n",
      "       [  3.,   5.,   7.],\n",
      "       [  6.,   8.,  10.]])\n"
     ]
    }
   ],
   "source": [
    "np.info(np.add)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.  Create a null vector of size 10 but the fifth value which is 1 (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.zeros(10)\n",
    "arr[4] = 1\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.  Create a vector with values ranging from 10 to 49 (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33\n",
      " 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(10, 50, 1)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 8.  Reverse a vector (first element becomes last) (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26\n",
      " 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10]\n"
     ]
    }
   ],
   "source": [
    "arr = arr[::-1]\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9.  Create a 3x3 matrix with values ranging from 0 to 8 (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(0, 9, 1).reshape(3, 3)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 10. Find indices of non-zero elements from \\[1,2,0,0,4,0\\] (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([0, 1, 4]),)\n"
     ]
    }
   ],
   "source": [
    "ind = np.nonzero([1,2,0,0,4,0])\n",
    "print(ind)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 11. Create a 3x3 identity matrix (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.ones((3, 3))\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 12. Create a 3x3x3 array with random values (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.11084659 0.00144711 0.38756029]\n",
      " [0.76849866 0.58109852 0.25128757]\n",
      " [0.61870671 0.1937111  0.95251094]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random((3, 3))\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 13. Create a 10x10 array with random values and find the minimum and maximum values (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.026920370638992774 0.9887487317515344\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random((10, 10))\n",
    "print (arr.min(), arr.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 14. Create a random vector of size 30 and find the mean value (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.42672190525802584\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random(30)\n",
    "print (arr.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 15. Create a 2d array with 1 on the border and 0 inside (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.ones((10, 10))\n",
    "arr[1:-1, 1:-1] = 0\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 16. How to add a border (filled with 0's) around an existing array? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.         0.         0.         0.         0.         0.\n",
      "  0.         0.         0.         0.         0.         0.        ]\n",
      " [0.         0.12477003 0.18427107 0.51351172 0.61276724 0.52663532\n",
      "  0.61282816 0.74874616 0.74846103 0.66055596 0.1593741  0.        ]\n",
      " [0.         0.05619905 0.40659835 0.4468947  0.53673357 0.04671656\n",
      "  0.49570175 0.89278008 0.68173513 0.67798363 0.99220816 0.        ]\n",
      " [0.         0.81678564 0.05115067 0.31263699 0.31904129 0.14315311\n",
      "  0.00931893 0.71573626 0.89925742 0.28478468 0.2286988  0.        ]\n",
      " [0.         0.18089618 0.35213852 0.69062291 0.65162524 0.90657832\n",
      "  0.34568075 0.76110187 0.18373236 0.21364251 0.17500262 0.        ]\n",
      " [0.         0.54965917 0.72632365 0.4118807  0.8075161  0.89544206\n",
      "  0.34219654 0.54698209 0.9501669  0.57687056 0.94049543 0.        ]\n",
      " [0.         0.02597761 0.86932567 0.90105842 0.03914642 0.51620086\n",
      "  0.17505112 0.50298268 0.18583145 0.90044632 0.08557045 0.        ]\n",
      " [0.         0.25815133 0.08275093 0.96397734 0.301451   0.87397306\n",
      "  0.23612925 0.37638182 0.70909387 0.16227468 0.91101984 0.        ]\n",
      " [0.         0.74990565 0.72742044 0.99700962 0.38996696 0.06918405\n",
      "  0.65332074 0.60274505 0.30546811 0.94405914 0.38445056 0.        ]\n",
      " [0.         0.31871174 0.19083504 0.32508167 0.16705484 0.13877479\n",
      "  0.85146093 0.08704582 0.3859516  0.22468271 0.43794129 0.        ]\n",
      " [0.         0.62403818 0.41592547 0.84355246 0.12317522 0.64169804\n",
      "  0.21340273 0.50571532 0.49586824 0.39635617 0.82256982 0.        ]\n",
      " [0.         0.         0.         0.         0.         0.\n",
      "  0.         0.         0.         0.         0.         0.        ]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random((10, 10))\n",
    "arr = np.pad(arr, pad_width=1, mode='constant', constant_values=0)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 17. What is the result of the following expression? (★☆☆)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "0 * np.nan\n",
    "np.nan == np.nan\n",
    "np.inf > np.nan\n",
    "np.nan - np.nan\n",
    "np.nan in set([np.nan])\n",
    "0.3 == 3 * 0.1\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nan\n",
      "False\n",
      "False\n",
      "nan\n",
      "True\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 (np.nan in set([np.nan]))\n",
    "print (0.3 == 3 * 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 18. Create a 5x5 matrix with values 1,2,3,4 just below the diagonal (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0 0]\n",
      " [0 0 0 0 0]\n",
      " [1 0 0 0 0]\n",
      " [0 2 0 0 0]\n",
      " [0 0 3 0 0]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.diag(np.arange(1,a 5, 1),k=-1)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 19. Create a 8x8 matrix and fill it with a checkerboard pattern (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "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": [
    "arr = np.zeros((8,8))\n",
    "arr.dtype = 'int'\n",
    "arr[1::2,::2] = 1\n",
    "arr[::2,1::2] = 1\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 20. Consider a (6,7,8) shape array, what is the index (x,y,z) of the 100th element?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.unravel_index(99,(6,7,8)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 21. Create a checkerboard 8x8 matrix using the tile function (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "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": [
    "arr = np.tile( np.array([[0,1],[1,0]]), (4,4))\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 22. Normalize a 5x5 random matrix (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.06209312  1.41944467  0.81094879 -0.98049424  1.37279122]\n",
      " [-0.24252071 -0.48320333  1.34079465 -0.84431675 -1.34705626]\n",
      " [ 0.26046325 -1.37180436 -1.36540485  0.12216576 -0.39705845]\n",
      " [-0.32987825  0.55479297 -0.87511408  1.65015725 -0.24507346]\n",
      " [-0.29450579  1.52746736 -1.31289148 -0.4949456   1.5873348 ]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random((5, 5))\n",
    "arr = (arr - np.mean(arr))/np.std(arr)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 23. Create a custom dtype that describes a color as four unsigned bytes (RGBA) (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "color = np.dtype([('r', np.ubyte, (1, )), ('grades', np.ubyte, (1, ))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 24. Multiply a 5x3 matrix by a 3x2 matrix (real matrix product) (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.06944889 0.76584574]\n",
      " [0.98624249 0.66059057]\n",
      " [1.57590073 1.17906808]\n",
      " [0.73539675 0.66016921]\n",
      " [1.25388    0.98742175]]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.random.random((5, 3))\n",
    "arr2 = np.random.random((3, 2))\n",
    "arr = arr1.dot(arr2)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 25. Given a 1D array, negate all elements which are between 3 and 8, in place. (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2 -3 -4 -5 -6 -7 -8  9 10 11 12 13 14 15 16 17 18 19]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 20, 1)\n",
    "arr[(arr>=3) & (arr<=8)] *= -1\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 26. What is the output of the following script? (★☆☆)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(sum(range(5),-1))\n",
    "from numpy import *\n",
    "print(sum(range(5),-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 27. Consider an integer vector Z, which of these expressions are legal? (★☆☆)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "outputs": [],
   "source": [
    "All the expressions are legal except the last one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 28. What are the result of the following expressions?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nan\n",
      "0\n",
      "[-9.22337204e+18]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/soumyadeeppaul/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n",
      "/Users/soumyadeeppaul/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in floor_divide\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "print (np.array(0) / np.array(0))\n",
    "print (np.array(0) // np.array(0))\n",
    "print (np.array([np.nan]).astype(int).astype(float))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 29. How to round away from zero a float array ? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.76363294 -3.44204541 -8.29273306 -2.61802487  2.61912676  0.51325749\n",
      " -9.18460949  6.65043402 -0.77311288  3.65496529]\n",
      "[ 1. -3. -8. -2.  3.  1. -9.  7. -0.  4.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.uniform(-10,+10,10)\n",
    "print (arr)\n",
    "arr = np.ceil(arr)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 30. How to find common values between two arrays? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-4 -8 -9  3  7  9 -9 -7  5  2]\n",
      "[  9   4   6   6   4  -9  -9 -10   9   4]\n",
      "[-9  9]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.random.randint(-10,10,10)\n",
    "print (arr1)\n",
    "arr2 = np.random.randint(-10,10,10)\n",
    "print (arr2)\n",
    "print(np.intersect1d(arr1,arr2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 31. How to ignore all numpy warnings (not recommended)? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "defaults = np.seterr(all=\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 32. Is the following expressions true? (★☆☆)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "np.sqrt(-1) == np.emath.sqrt(-1)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/soumyadeeppaul/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in sqrt\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "print (np.sqrt(-1) == np.emath.sqrt(-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 33. How to get the dates of yesterday, today and tomorrow? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-12-25\n",
      "2019-12-26\n",
      "2019-12-27\n"
     ]
    }
   ],
   "source": [
    "yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D')\n",
    "today     = np.datetime64('today', 'D')\n",
    "tomorrow  = np.datetime64('today', 'D') + np.timedelta64(1, 'D')\n",
    "print (yesterday)\n",
    "print (today)\n",
    "print (tomorrow)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 34. How to get all the dates corresponding to the month of July 2016? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.arange('2016-07', '2016-08', dtype='datetime64[D]')\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 35. How to compute ((A+B)\\*(-A/2)) in place (without copy)? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ -0.  -22.5 -12.    3.5 -13.5 -18.    1.5 -45.   -4.    0. ]\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(-10, 10, 10)\n",
    "b = np.random.randint(-10, 10, 10)\n",
    "c = np.random.randint(-10, 10, 10)\n",
    "print ((a+b)*(-a/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 36. Extract the integer part of a random array using 5 different methods (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2. 5. 3. 1. 8. 8. 7. 6. 8. 5.]\n",
      "[2. 5. 3. 1. 8. 8. 7. 6. 8. 5.]\n",
      "[2. 5. 3. 1. 8. 8. 7. 6. 8. 5.]\n",
      "[2 5 3 1 8 8 7 6 8 5]\n",
      "[2. 5. 3. 1. 8. 8. 7. 6. 8. 5.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.uniform(0,10,10)\n",
    "print (arr - arr%1)\n",
    "print (np.floor(arr))\n",
    "print (np.ceil(arr)-1)\n",
    "print (arr.astype(int))\n",
    "print (np.trunc(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 37. Create a 5x5 matrix with row values ranging from 0 to 4 (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 1. 2. 3. 4.]\n",
      " [0. 1. 2. 3. 4.]\n",
      " [0. 1. 2. 3. 4.]\n",
      " [0. 1. 2. 3. 4.]\n",
      " [0. 1. 2. 3. 4.]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.zeros((5, 5))\n",
    "arr = arr + np.arange(0, 5, 1)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 38. Consider a generator function that generates 10 integers and use it to build an array (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[72 66 20 21 75 35 62 86 86 50]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(0, 100, 10)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 39. Create a vector of size 10 with values ranging from 0 to 1, both excluded (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.41645749 0.89412499 0.34854707 0.53192849 0.06226852 0.48036212\n",
      "  0.5143461  0.89219473 0.83724926 0.64822445]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random((1, 10))\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 40. Create a random vector of size 10 and sort it (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.01625287 0.20446244 0.21328059 0.24376356 0.45450161 0.46872749\n",
      "  0.47718486 0.49035697 0.5751879  0.62495477]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random((1, 10))\n",
    "arr.sort()\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 41. How to sum a small array faster than np.sum? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "np.add.reduce(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 42. Consider two random array A and B, check if they are equal (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.random.randint(-10, 10, 10)\n",
    "arr2 = np.random.randint(-10, 10, 10)\n",
    "print (np.array_equal(arr1, arr2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 43. Make an array immutable (read-only) (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.zeros(10)\n",
    "x.flags.writeable = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 44. Consider a random 10x2 matrix representing cartesian coordinates, convert them to polar coordinates (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.64976836 0.94987616 0.78398072 1.1405037  0.15744863 0.44525311\n",
      " 1.14536783 0.74531428 0.29160317 0.43870532]\n",
      "[0.79752608 1.04254124 0.95188952 0.84437336 0.43514427 0.20751682\n",
      " 0.55179099 0.21221238 0.40205393 0.44793145]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random((10,2))\n",
    "x,y = arr[:,0], arr[:,1]\n",
    "r = np.sqrt(x**2 + y**2)\n",
    "t = np.arctan2(y, x)\n",
    "print (r)\n",
    "print (t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 45. Create random vector of size 10 and replace the maximum value by 0 (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1328128  0.         0.56697697 0.93496671 0.67894637 0.81576881\n",
      " 0.23180362 0.7295918  0.86187116 0.15907251]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random(10)\n",
    "arr[(arr == arr.max())] = 0\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 46. Create a structured array with `x` and `y` coordinates covering the \\[0,1\\]x\\[0,1\\] area (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[(0.  , 0.  ) (0.25, 0.  ) (0.5 , 0.  ) (0.75, 0.  ) (1.  , 0.  )]\n",
      " [(0.  , 0.25) (0.25, 0.25) (0.5 , 0.25) (0.75, 0.25) (1.  , 0.25)]\n",
      " [(0.  , 0.5 ) (0.25, 0.5 ) (0.5 , 0.5 ) (0.75, 0.5 ) (1.  , 0.5 )]\n",
      " [(0.  , 0.75) (0.25, 0.75) (0.5 , 0.75) (0.75, 0.75) (1.  , 0.75)]\n",
      " [(0.  , 1.  ) (0.25, 1.  ) (0.5 , 1.  ) (0.75, 1.  ) (1.  , 1.  )]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.zeros((5,5), [('x', float), ('y', float)])\n",
    "arr['x'], arr['y'] = np.meshgrid(np.linspace(0,1,5), np.linspace(0,1,5))\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  47. Given two arrays, X and Y, construct the Cauchy matrix C (Cij =1/(xi - yj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/soumyadeeppaul/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:3: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "x = np.random.randint(-10, 10, 10)\n",
    "y = np.random.randint(-10, 10, 10)\n",
    "c = 1.0 / np.subtract.outer(x, y)\n",
    "print (np.linalg.det(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 48. Print the minimum and maximum representable value for each numpy scalar type (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-128\n",
      "127\n",
      "-2147483648\n",
      "2147483647\n",
      "-9223372036854775808\n",
      "9223372036854775807\n",
      "-3.4028235e+38\n",
      "3.4028235e+38\n",
      "-1.7976931348623157e+308\n",
      "1.7976931348623157e+308\n"
     ]
    }
   ],
   "source": [
    "for dtype in [np.int8, np.int32, np.int64]:\n",
    "   print(np.iinfo(dtype).min)\n",
    "   print(np.iinfo(dtype).max)\n",
    "for dtype in [np.float32, np.float64]:\n",
    "   print(np.finfo(dtype).min)\n",
    "   print(np.finfo(dtype).max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 49. How to print all the values of an array? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1 -1 -5  0 -9  2  2 -1  3  2]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(-10, 10, 10)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 50. How to find the closest value (to a given scalar) in a vector? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47\n",
      " 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71\n",
      " 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95\n",
      " 96 97 98 99]\n",
      "22.814672287336645\n",
      "[22.81467229 21.81467229 20.81467229 19.81467229 18.81467229 17.81467229\n",
      " 16.81467229 15.81467229 14.81467229 13.81467229 12.81467229 11.81467229\n",
      " 10.81467229  9.81467229  8.81467229  7.81467229  6.81467229  5.81467229\n",
      "  4.81467229  3.81467229  2.81467229  1.81467229  0.81467229  0.18532771\n",
      "  1.18532771  2.18532771  3.18532771  4.18532771  5.18532771  6.18532771\n",
      "  7.18532771  8.18532771  9.18532771 10.18532771 11.18532771 12.18532771\n",
      " 13.18532771 14.18532771 15.18532771 16.18532771 17.18532771 18.18532771\n",
      " 19.18532771 20.18532771 21.18532771 22.18532771 23.18532771 24.18532771\n",
      " 25.18532771 26.18532771 27.18532771 28.18532771 29.18532771 30.18532771\n",
      " 31.18532771 32.18532771 33.18532771 34.18532771 35.18532771 36.18532771\n",
      " 37.18532771 38.18532771 39.18532771 40.18532771 41.18532771 42.18532771\n",
      " 43.18532771 44.18532771 45.18532771 46.18532771 47.18532771 48.18532771\n",
      " 49.18532771 50.18532771 51.18532771 52.18532771 53.18532771 54.18532771\n",
      " 55.18532771 56.18532771 57.18532771 58.18532771 59.18532771 60.18532771\n",
      " 61.18532771 62.18532771 63.18532771 64.18532771 65.18532771 66.18532771\n",
      " 67.18532771 68.18532771 69.18532771 70.18532771 71.18532771 72.18532771\n",
      " 73.18532771 74.18532771 75.18532771 76.18532771]\n",
      "[array([False, False, False, False, False, False, False, False, False,\n",
      "       False, False, False, False, False, False, False, False, False,\n",
      "       False, False, False, False, False,  True, False, False, False,\n",
      "       False, False, False, False, False, False, False, False, False,\n",
      "       False, False, False, False, False, False, False, False, False,\n",
      "       False, False, False, False, False, False, False, False, False,\n",
      "       False, False, False, False, False, False, False, False, False,\n",
      "       False, False, False, False, False, False, False, False, False,\n",
      "       False, False, False, False, False, False, False, False, False,\n",
      "       False, False, False, False, False, False, False, False, False,\n",
      "       False, False, False, False, False, False, False, False, False,\n",
      "       False])]\n",
      "[23]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/soumyadeeppaul/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:10: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  # Remove the CWD from sys.path while we load stuff.\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(0, 100, 1)\n",
    "print (arr)\n",
    "x = np.random.uniform(0, 100)\n",
    "print (x)\n",
    "y = arr-x\n",
    "y = np.abs(y)\n",
    "print (y)\n",
    "index = [y==y.min()]\n",
    "print (index)\n",
    "print (arr[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 51. Create a structured array representing a position (x,y) and a color (r,g,b) (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      "  ((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      "  ((0., 0.), (0., 0., 0.))]\n",
      " [((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      "  ((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      "  ((0., 0.), (0., 0., 0.))]\n",
      " [((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      "  ((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      "  ((0., 0.), (0., 0., 0.))]\n",
      " [((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      "  ((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      "  ((0., 0.), (0., 0., 0.))]\n",
      " [((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      "  ((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      "  ((0., 0.), (0., 0., 0.))]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/soumyadeeppaul/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "arr = np.zeros((5, 5), [('position', [('x', float, 1), ('y', float, 1)]), \n",
    "                        ('color', [('r', float, 1), ('g', float, 1), ('b', float, 1)])])\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 52. Consider a random vector with shape (100,2) representing coordinates, find point by point distances (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.238186825708469\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random((10,2))\n",
    "x, y = (arr[:,0], arr[:,1])\n",
    "d = (x**2 + y**2)\n",
    "print (d.sum()**(1/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 53. How to convert a float (32 bits) array into an integer (32 bits) in place?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[69.30056101 46.01517733 57.14308931 83.91246898 87.54244648 81.67315441\n",
      " 19.70662751  7.02629942 19.74191728 26.01842322 62.51302012 38.95901403\n",
      " 87.55555554 92.27427792  0.2152901  16.4671543  57.30988554 27.49445922\n",
      " 69.61670901 77.34129801]\n",
      "[69 46 57 83 87 81 19  7 19 26 62 38 87 92  0 16 57 27 69 77]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.uniform(0, 100, 20)\n",
    "print (arr)\n",
    "arr = arr.astype(np.int32)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 54. How to read the following file? (★★☆)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "1, 2, 3, 4, 5\n",
    "6,  ,  , 7, 8\n",
    " ,  , 9,10,11\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.genfromtxt(s, delimiter=\",\", dtype=np.int)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 55. What is the equivalent of enumerate for numpy arrays? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0,) 0\n",
      "(1,) 1\n",
      "(2,) 2\n",
      "(3,) 3\n",
      "(4,) 4\n",
      "(5,) 5\n",
      "(6,) 6\n",
      "(7,) 7\n",
      "(8,) 8\n",
      "(9,) 9\n",
      "(10,) 10\n",
      "(11,) 11\n",
      "(12,) 12\n",
      "(13,) 13\n",
      "(14,) 14\n",
      "(15,) 15\n",
      "(16,) 16\n",
      "(17,) 17\n",
      "(18,) 18\n",
      "(19,) 19\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(0, 20, 1)\n",
    "for index, value in np.ndenumerate(arr):\n",
    "    print(index, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 56. Generate a generic 2D Gaussian-like array (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.36787944 0.44822088 0.51979489 0.57375342 0.60279818 0.60279818\n",
      "  0.57375342 0.51979489 0.44822088 0.36787944]\n",
      " [0.44822088 0.54610814 0.63331324 0.69905581 0.73444367 0.73444367\n",
      "  0.69905581 0.63331324 0.54610814 0.44822088]\n",
      " [0.51979489 0.63331324 0.73444367 0.81068432 0.85172308 0.85172308\n",
      "  0.81068432 0.73444367 0.63331324 0.51979489]\n",
      " [0.57375342 0.69905581 0.81068432 0.89483932 0.9401382  0.9401382\n",
      "  0.89483932 0.81068432 0.69905581 0.57375342]\n",
      " [0.60279818 0.73444367 0.85172308 0.9401382  0.98773022 0.98773022\n",
      "  0.9401382  0.85172308 0.73444367 0.60279818]\n",
      " [0.60279818 0.73444367 0.85172308 0.9401382  0.98773022 0.98773022\n",
      "  0.9401382  0.85172308 0.73444367 0.60279818]\n",
      " [0.57375342 0.69905581 0.81068432 0.89483932 0.9401382  0.9401382\n",
      "  0.89483932 0.81068432 0.69905581 0.57375342]\n",
      " [0.51979489 0.63331324 0.73444367 0.81068432 0.85172308 0.85172308\n",
      "  0.81068432 0.73444367 0.63331324 0.51979489]\n",
      " [0.44822088 0.54610814 0.63331324 0.69905581 0.73444367 0.73444367\n",
      "  0.69905581 0.63331324 0.54610814 0.44822088]\n",
      " [0.36787944 0.44822088 0.51979489 0.57375342 0.60279818 0.60279818\n",
      "  0.57375342 0.51979489 0.44822088 0.36787944]]\n"
     ]
    }
   ],
   "source": [
    "x, y = np.meshgrid(np.linspace(-1,1,10), np.linspace(-1,1,10))\n",
    "d = np.sqrt(x*x+y*y)\n",
    "sigma, mu = 1.0, 0.0\n",
    "g = np.exp(-( (d-mu)**2 / ( 2.0 * sigma**2 ) ) )\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 57. How to randomly place p elements in a 2D array? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 5. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 5. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [5. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "p = 3\n",
    "arr = np.zeros((n,n))\n",
    "np.put(arr, np.random.choice(range(n*n), p, replace=False),5)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 58. Subtract the mean of each row of a matrix (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ -8 -36   9  35   0]\n",
      " [-27  69 -28 -14   0]\n",
      " [ 11  15   1  -2 -27]\n",
      " [-16  44   0 -34   6]\n",
      " [-36 -23  39 -25  46]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(0, 100, 25)\n",
    "arr = arr.reshape((5, 5))\n",
    "m = arr.mean(axis=1)\n",
    "for i in range(5):\n",
    "    arr[i] = arr[i] - m[i]\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 59. How to sort an array by the nth column? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 4 1]\n",
      " [1 7 1]\n",
      " [1 4 8]]\n",
      "[[5 4 1]\n",
      " [1 4 8]\n",
      " [1 7 1]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(0,10,(3,3))\n",
    "print(arr)\n",
    "print(arr[arr[:,1].argsort()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 60. How to tell if a given 2D array has null columns? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(0, 100, (10, 10))\n",
    "print (arr.all(axis=0).any())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 61. Find the nearest value from a given value in an array (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[80]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(0, 100, (10, 10))\n",
    "x = np.random.uniform(0, 100, 1)\n",
    "y = arr-x\n",
    "y = np.abs(y)\n",
    "index = y==y.min()\n",
    "print (arr[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 62. Considering two arrays with shape (1,3) and (3,1), how to compute their sum using an iterator? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [1 2 3]\n",
      " [2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(3).reshape(3,1)\n",
    "b = np.arange(3).reshape(1,3)\n",
    "it = np.nditer([a,b,None])\n",
    "for x,y,z in it: z[...] = x + y\n",
    "print(it.operands[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 63. Create an array class that has a name attribute (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range_10\n"
     ]
    }
   ],
   "source": [
    "class NamedArray(np.ndarray):\n",
    "    def __new__(cls, array, name=\"no name\"):\n",
    "        obj = np.asarray(array).view(cls)\n",
    "        obj.name = name\n",
    "        return obj\n",
    "    def __array_finalize__(self, obj):\n",
    "        if obj is None: return\n",
    "        self.info = getattr(obj, 'name', \"no name\")\n",
    "\n",
    "Z = NamedArray(np.arange(10), \"range_10\")\n",
    "print (Z.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 64. Consider a given vector, how to add 1 to each element indexed by a second vector (be careful with repeated indices)? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2. 6. 4. 3. 2. 2. 3. 2. 4. 2.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.ones(10)\n",
    "one = np.random.randint(0,len(Z),20)\n",
    "arr = arr + np.bincount(one, minlength=len(arr))\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 65. How to accumulate elements of a vector (X) to an array (F) based on an index list (I)? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 7. 0. 6. 5. 0. 0. 0. 0. 3.]\n"
     ]
    }
   ],
   "source": [
    "X = [1,2,3,4,5,6]\n",
    "I = [1,3,9,3,4,1]\n",
    "F = np.bincount(I,X)\n",
    "print(F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 66. Considering a (w,h,3) image of (dtype=ubyte), compute the number of unique colors (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 67. Considering a four dimensions array, how to get sum over the last two axis at once? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[21 69 25 76]\n",
      "   [58 64 46 75]]\n",
      "\n",
      "  [[42 79 17 21]\n",
      "   [47 93  6 65]]\n",
      "\n",
      "  [[85 87 36 44]\n",
      "   [ 5  6  9 13]]\n",
      "\n",
      "  [[23 77  1  0]\n",
      "   [14  2 31 33]]]\n",
      "\n",
      "\n",
      " [[[23 80 36 47]\n",
      "   [37 22 64 44]]\n",
      "\n",
      "  [[24  3 19 47]\n",
      "   [ 6 49 98 67]]\n",
      "\n",
      "  [[30 56 11 90]\n",
      "   [21 66 41 56]]\n",
      "\n",
      "  [[ 5 68 75 86]\n",
      "   [46 19 66 83]]]]\n",
      "[[434 370 285 181]\n",
      " [353 313 371 448]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(0, 100, (2, 4, 2, 4))\n",
    "print (arr)\n",
    "s = arr.sum(axis=(-1, -2))\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9.63150479e-01 9.42571510e-01 3.64821603e-01 8.55496237e-01\n",
      " 7.92964822e-01 2.59357713e-01 7.07726375e-01 1.38605498e-01\n",
      " 5.76557368e-01 4.56030083e-01 8.48220051e-01 1.48939894e-01\n",
      " 9.68247290e-01 8.60364337e-01 6.99938587e-01 6.62345793e-01\n",
      " 8.96754753e-01 3.85456042e-01 7.03109245e-01 2.21461451e-01\n",
      " 6.62684697e-02 3.87789563e-01 9.42700651e-01 8.41807871e-01\n",
      " 4.10220992e-01 3.47179396e-01 1.92510431e-01 6.66433140e-01\n",
      " 4.99751373e-01 4.20573009e-01 5.00728244e-01 8.59146401e-01\n",
      " 3.22771721e-01 3.31713041e-01 6.93924204e-01 9.00397072e-01\n",
      " 6.22488188e-01 7.77932319e-01 1.97220405e-01 8.63339318e-01\n",
      " 3.89843714e-01 4.26594282e-01 1.78054228e-01 6.22719226e-01\n",
      " 5.79855993e-01 3.67975018e-01 2.92783463e-01 9.93490004e-01\n",
      " 7.89163768e-01 5.48711202e-03 4.99145319e-01 3.03020837e-01\n",
      " 2.26105889e-01 5.81745476e-01 3.32476789e-01 9.65182664e-01\n",
      " 8.27106593e-01 1.15168742e-02 6.94906139e-01 7.16088091e-01\n",
      " 5.03613534e-01 1.79782668e-01 2.36191731e-01 3.73242800e-04\n",
      " 2.43247146e-01 3.47726706e-01 6.96017150e-01 6.52989833e-01\n",
      " 6.13077150e-01 6.65308030e-01 9.89894452e-01 2.31066490e-01\n",
      " 9.51366672e-01 4.10397409e-01 5.89431564e-01 5.26192717e-02\n",
      " 2.09851629e-01 7.31160069e-01 7.53848698e-01 8.54958105e-02\n",
      " 1.10868279e-01 3.16061540e-01 6.57694699e-01 1.41733229e-01\n",
      " 3.17101467e-01 4.15887991e-01 8.20079211e-01 7.18212084e-02\n",
      " 3.26565874e-02 8.72025359e-01 4.01952343e-01 5.65695536e-01\n",
      " 8.63157022e-01 4.79759743e-01 3.67544459e-01 6.32757737e-02\n",
      " 1.51610834e-01 5.55252279e-01 5.77857325e-01 9.76202912e-01]\n",
      "[4 9 2 4 9 9 9 8 1 2 9 6 7 4 0 7 2 3 5 9 5 9 0 4 6 9 9 6 5 5 0 8 9 8 1 1 3\n",
      " 4 8 1 5 9 2 9 7 2 7 1 0 4 3 2 6 9 1 3 6 3 0 5 7 9 0 5 7 1 5 5 2 6 3 8 8 3\n",
      " 2 2 8 7 9 3 8 2 7 1 5 0 4 9 7 9 8 9 0 4 7 5 2 6 9 6]\n",
      "[5.14267413 4.84964469 4.28945688 3.96957676 5.60407731 4.52539137\n",
      " 4.47556973 5.03914903 3.43179076 9.67464281]\n",
      "[ 8  8 11  8  8 11  8 10  9 19]\n",
      "[0.64283427 0.60620559 0.38995063 0.49619709 0.70050966 0.41139922\n",
      " 0.55944622 0.5039149  0.38131008 0.50919173]\n"
     ]
    }
   ],
   "source": [
    "D = np.random.uniform(0,1,100)\n",
    "print (D)\n",
    "S = np.random.randint(0,10,100)\n",
    "print (S)\n",
    "D_sums = np.bincount(S, weights=D)\n",
    "print (D_sums)\n",
    "D_counts = np.bincount(S)\n",
    "print (D_counts)\n",
    "D_means = D_sums / D_counts\n",
    "print(D_means)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 69. How to get the diagonal of a dot product? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[37 54 58]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.random.randint(0, 10, (3, 3))\n",
    "arr2 = np.random.randint(0, 10, (3, 3))\n",
    "arr = np.dot(arr1, arr2)\n",
    "print (np.diag(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 70. Consider the vector \\[1, 2, 3, 4, 5\\], how to build a new vector with 3 consecutive zeros interleaved between each value? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 0. 0. 0. 2. 0. 0. 0. 3. 0. 0. 0. 4. 0. 0. 0. 5.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.zeros(17)\n",
    "n = 3\n",
    "for i in range(0, 5, 1):\n",
    "    arr[4*i] = i+1\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 71. Consider an array of dimension (5,5,3), how to mulitply it by an array with dimensions (5,5)? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1495 1219  345]\n",
      "  [1650  308  968]\n",
      "  [ 546 1638  168]\n",
      "  [ 912  708  852]\n",
      "  [ 623  672  336]]\n",
      "\n",
      " [[7081 9021 5238]\n",
      "  [1350 1860 2310]\n",
      "  [2340 1482  624]\n",
      "  [1677 2494  989]\n",
      "  [ 120   66  207]]\n",
      "\n",
      " [[ 910  448  462]\n",
      "  [ 969 1020 4233]\n",
      "  [2322 5848 3698]\n",
      "  [ 969  561 2652]\n",
      "  [2494 2320  812]]\n",
      "\n",
      " [[ 360  710  420]\n",
      "  [1881 3036  594]\n",
      "  [2352  196 1176]\n",
      "  [ 305  125   20]\n",
      "  [3000 2800 1160]]\n",
      "\n",
      " [[ 874 3634 2162]\n",
      "  [4860 2214 5346]\n",
      "  [4116 1932  840]\n",
      "  [ 100  560  750]\n",
      "  [5180 4200 5390]]]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.random.randint(0, 100, (5, 5, 3))\n",
    "arr2 = np.random.randint(0, 100, (5, 5))\n",
    "print(arr1 * arr2[:,:,None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 72. How to swap two rows of an array? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[21 72 92 86 91 56 12 21 38 80]\n",
      " [64 11  8 13 35  2 25 35 67 83]\n",
      " [48 94 27 42  2 13 33 94 53 33]\n",
      " [24 74 35 91 79 17 76 25 42 86]\n",
      " [94 84 38 39 36 90 38 60 91 35]\n",
      " [10 35 32 28  1 35 45 35 27 13]\n",
      " [29 82 52 67 60 57 53 61 87 64]\n",
      " [ 0 19 96 43 66 39 99 51 83 95]\n",
      " [93 57 97 14 17 94  1 64 23 91]\n",
      " [65 67 58 71 65 84 34 82 86 36]]\n",
      "[[64 11  8 13 35  2 25 35 67 83]\n",
      " [21 72 92 86 91 56 12 21 38 80]\n",
      " [48 94 27 42  2 13 33 94 53 33]\n",
      " [24 74 35 91 79 17 76 25 42 86]\n",
      " [94 84 38 39 36 90 38 60 91 35]\n",
      " [10 35 32 28  1 35 45 35 27 13]\n",
      " [29 82 52 67 60 57 53 61 87 64]\n",
      " [ 0 19 96 43 66 39 99 51 83 95]\n",
      " [93 57 97 14 17 94  1 64 23 91]\n",
      " [65 67 58 71 65 84 34 82 86 36]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(0, 100, (10, 10))\n",
    "print (arr)\n",
    "arr[[0, 1]] = arr[[1, 0]]\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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 (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[( 5, 19) ( 5, 87) ( 9, 10) ( 9, 15) ( 9, 54) ( 9, 94) (10, 54) (15, 94)\n",
      " (17, 44) (17, 60) (19, 87) (20, 80) (20, 99) (23, 23) (23, 24) (23, 71)\n",
      " (23, 75) (24, 71) (27, 52) (27, 98) (44, 60) (48, 69) (48, 95) (52, 98)\n",
      " (66, 86) (66, 97) (69, 95) (80, 99) (86, 97)]\n"
     ]
    }
   ],
   "source": [
    "faces = np.random.randint(0,100,(10,3))\n",
    "F = np.roll(faces.repeat(2,axis=1),-1,axis=1)\n",
    "F = F.reshape(len(F)*3,2)\n",
    "F = np.sort(F,axis=1)\n",
    "G = F.view( dtype=[('p0',F.dtype),('p1',F.dtype)] )\n",
    "G = np.unique(G)\n",
    "print(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 74. Given an array C that is a bincount, how to produce an array A such that np.bincount(A) == C? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 2 3 4 4 6]\n"
     ]
    }
   ],
   "source": [
    "c = np.bincount([1,1,2,3,4,4,6])\n",
    "arr = np.repeat(np.arange(len(c)), c)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 75. How to compute averages using a sliding window over an array? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17. 18.]\n"
     ]
    }
   ],
   "source": [
    "def moving_average(a, n=3) :\n",
    "    ret = np.cumsum(a, dtype=float)\n",
    "    ret[n:] = ret[n:] - ret[:-n]\n",
    "    return ret[n - 1:] / n\n",
    "Z = np.arange(20)\n",
    "print(moving_average(Z, n=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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\\]) (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[96 30  7]\n",
      " [83 36 97]\n",
      " [39 75 44]\n",
      " [ 7 57 57]\n",
      " [22 64 33]\n",
      " [34 36 30]\n",
      " [50 33 23]\n",
      " [51 86 96]\n",
      " [53 12 20]\n",
      " [30  8 51]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(1, 100, 30)\n",
    "arr = arr.reshape((10, 3))\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 77. How to negate a boolean, or to change the sign of a float inplace? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 8.36616912 63.65121228 46.82048746 41.02223454  7.65163037 14.53585023\n",
      " 81.30355252 37.32049924 56.94155032 88.85443914 71.07452717 98.07895187\n",
      " 70.52307858 68.2821125  44.77074801 49.74004579 88.388803   51.05697493\n",
      " 77.78270162 90.8521199  63.61903294 68.05678205 49.97657312 29.36224318\n",
      " 63.23640586  6.22181105 72.70041186 28.67991044  2.84819979 30.29272754\n",
      " 29.63074934 70.42418813  6.61308345  8.99837022 68.14250661 83.77762741\n",
      " 75.47908664 49.19629485 64.15953636 30.28184918 99.0176     77.77523034\n",
      " 42.02517392 16.77017532 28.718624   17.92540964 59.28053782 14.09230194\n",
      " 41.84322176 29.32186966]\n",
      "[ -8.36616912 -63.65121228 -46.82048746 -41.02223454  -7.65163037\n",
      " -14.53585023 -81.30355252 -37.32049924 -56.94155032 -88.85443914\n",
      " -71.07452717 -98.07895187 -70.52307858 -68.2821125  -44.77074801\n",
      " -49.74004579 -88.388803   -51.05697493 -77.78270162 -90.8521199\n",
      " -63.61903294 -68.05678205 -49.97657312 -29.36224318 -63.23640586\n",
      "  -6.22181105 -72.70041186 -28.67991044  -2.84819979 -30.29272754\n",
      " -29.63074934 -70.42418813  -6.61308345  -8.99837022 -68.14250661\n",
      " -83.77762741 -75.47908664 -49.19629485 -64.15953636 -30.28184918\n",
      " -99.0176     -77.77523034 -42.02517392 -16.77017532 -28.718624\n",
      " -17.92540964 -59.28053782 -14.09230194 -41.84322176 -29.32186966]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.uniform(0, 100, 50)\n",
    "print (arr)\n",
    "arr = np.negative(arr)\n",
    "print (arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 236,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 7.67057275  9.95191688  1.12611566  1.62676346  3.11689248  9.62811197\n",
      " 10.67534741  6.60015172  0.92641162 12.16538448]\n"
     ]
    }
   ],
   "source": [
    "def distance(P0, P1, p):\n",
    "    T = P1 - P0\n",
    "    L = (T**2).sum(axis=1)\n",
    "    U = -((P0[:,0]-p[...,0])*T[:,0] + (P0[:,1]-p[...,1])*T[:,1]) / L\n",
    "    U = U.reshape(len(U),1)\n",
    "    D = P0 + U*T - p\n",
    "    return np.sqrt((D**2).sum(axis=1))\n",
    "\n",
    "P0 = np.random.uniform(-10,10,(10,2))\n",
    "P1 = np.random.uniform(-10,10,(10,2))\n",
    "p  = np.random.uniform(-10,10,( 1,2))\n",
    "print(distance(P0, P1, p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 237,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.07726199  6.74896708  3.22154346  8.46764945  1.85663253  6.43524412\n",
      "   7.16483264  2.86262674  5.66192207  0.737997  ]\n",
      " [ 4.43318109 10.25160234  6.39310435 10.13608676  0.81609396  4.33882429\n",
      "  11.11571201  6.09905219  5.06566576  3.00366943]\n",
      " [11.51691721 17.30339     7.82605687  8.35913596  7.76044405  2.26287204\n",
      "  15.09194482  7.70275587  0.07818901  6.13875784]\n",
      " [ 9.72267284 14.6692616   5.5966908   4.3426142   9.23493192  5.9930529\n",
      "   3.25461028  5.67926325  8.41883234  6.477197  ]\n",
      " [ 4.05197869  9.68365447  3.41342174  7.30868473  1.16102924  3.49340595\n",
      "   8.49470033  3.12884518  3.19917773  0.20752092]\n",
      " [ 0.35010339  4.51623872  9.56984216  3.76505855  0.1604267   2.59361998\n",
      "   4.00453653  9.88276944  2.53372537 12.68724475]\n",
      " [ 7.65982977 13.26337961  3.96067878  6.2198041   4.74308999  0.05554406\n",
      "  10.36845574  3.76424226  0.44452693  1.63900619]\n",
      " [ 8.54452324 14.27083957  6.09183566  7.963832    5.12703873  0.03859979\n",
      "  12.4839612   5.90417122  1.24363424  3.79769717]\n",
      " [10.68938599 15.7686342   3.29088221  2.45998678  9.6601529   6.02105217\n",
      "   5.54723061  3.3637219   7.56256981  4.13912838]\n",
      " [ 3.66803897  1.31552754  8.66609781  1.34673512  3.80300475  6.33725793\n",
      "   4.56090844  9.06913005  1.03853766 12.73004574]]\n"
     ]
    }
   ],
   "source": [
    "P0 = np.random.uniform(-10, 10, (10,2))\n",
    "P1 = np.random.uniform(-10,10,(10,2))\n",
    "p = np.random.uniform(-10, 10, (10,2))\n",
    "print(np.array([distance(P0,P1,p_i) for p_i in p]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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) (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6 2 0 8 2 5 9 9 7 1]\n",
      " [2 8 9 6 4 1 1 7 5 0]\n",
      " [0 0 7 3 2 8 2 6 1 2]\n",
      " [3 8 9 7 6 9 7 5 2 0]\n",
      " [2 5 8 6 3 5 7 2 3 8]\n",
      " [8 1 5 3 2 4 4 0 8 3]\n",
      " [4 0 5 5 4 6 2 4 1 0]\n",
      " [7 1 9 6 3 7 3 5 4 8]\n",
      " [2 3 5 8 9 5 8 9 6 5]\n",
      " [6 1 4 0 2 5 3 8 6 4]]\n",
      "[[0 0 0 0 0]\n",
      " [0 6 2 0 8]\n",
      " [0 2 8 9 6]\n",
      " [0 0 0 7 3]\n",
      " [0 3 8 9 7]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/soumyadeeppaul/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:23: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n"
     ]
    }
   ],
   "source": [
    "Z = np.random.randint(0,10,(10,10))\n",
    "shape = (5,5)\n",
    "fill  = 0\n",
    "position = (1,1)\n",
    "\n",
    "R = np.ones(shape, dtype=Z.dtype)*fill\n",
    "P  = np.array(list(position)).astype(int)\n",
    "Rs = np.array(list(R.shape)).astype(int)\n",
    "Zs = np.array(list(Z.shape)).astype(int)\n",
    "\n",
    "R_start = np.zeros((len(shape),)).astype(int)\n",
    "R_stop  = np.array(list(shape)).astype(int)\n",
    "Z_start = (P-Rs//2)\n",
    "Z_stop  = (P+Rs//2)+Rs%2\n",
    "\n",
    "R_start = (R_start - np.minimum(Z_start,0)).tolist()\n",
    "Z_start = (np.maximum(Z_start,0)).tolist()\n",
    "R_stop = np.maximum(R_start, (R_stop - np.maximum(Z_stop-Zs,0))).tolist()\n",
    "Z_stop = (np.minimum(Z_stop,Zs)).tolist()\n",
    "\n",
    "r = [slice(start,stop) for start,stop in zip(R_start,R_stop)]\n",
    "z = [slice(start,stop) for start,stop in zip(Z_start,Z_stop)]\n",
    "R[r] = Z[z]\n",
    "print(Z)\n",
    "print(R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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\\]\\]? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8], [6, 7, 8, 9], [7, 8, 9, 10], [8, 9, 10, 11], [9, 10, 11, 12], [10, 11, 12, 13], [11, 12, 13, 14]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5,6,7,8,9,10,11,12,13,14])\n",
    "new_arr = []\n",
    "for i in range(len(arr)-3):\n",
    "    x = []\n",
    "    x.append(arr[i])\n",
    "    x.append(arr[i+1])\n",
    "    x.append(arr[i+2])\n",
    "    x.append(arr[i+3])\n",
    "    new_arr.append(x)\n",
    "print (new_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 82. Compute a matrix rank (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/soumyadeeppaul/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:3: VisibleDeprecationWarning: `rank` is deprecated; use the `ndim` attribute or function instead. To find the rank of a matrix see `numpy.linalg.matrix_rank`.\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "from numpy import matrix, rank\n",
    "arr = matrix([[1,3,7],[2,8,3],[7,8,1]])\n",
    "print (rank(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 83. How to find the most frequent value in an array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(1, 100, 500)\n",
    "print (np.bincount(arr).argmax())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 84. Extract all the contiguous 3x3 blocks from a random 10x10 matrix (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[1 1 4]\n",
      "   [1 1 4]\n",
      "   [4 0 0]]\n",
      "\n",
      "  [[1 4 2]\n",
      "   [1 4 0]\n",
      "   [0 0 2]]\n",
      "\n",
      "  [[4 2 2]\n",
      "   [4 0 0]\n",
      "   [0 2 0]]\n",
      "\n",
      "  [[2 2 0]\n",
      "   [0 0 3]\n",
      "   [2 0 3]]\n",
      "\n",
      "  [[2 0 3]\n",
      "   [0 3 2]\n",
      "   [0 3 0]]\n",
      "\n",
      "  [[0 3 0]\n",
      "   [3 2 0]\n",
      "   [3 0 1]]\n",
      "\n",
      "  [[3 0 4]\n",
      "   [2 0 0]\n",
      "   [0 1 0]]\n",
      "\n",
      "  [[0 4 4]\n",
      "   [0 0 4]\n",
      "   [1 0 2]]]\n",
      "\n",
      "\n",
      " [[[1 1 4]\n",
      "   [4 0 0]\n",
      "   [4 3 4]]\n",
      "\n",
      "  [[1 4 0]\n",
      "   [0 0 2]\n",
      "   [3 4 1]]\n",
      "\n",
      "  [[4 0 0]\n",
      "   [0 2 0]\n",
      "   [4 1 3]]\n",
      "\n",
      "  [[0 0 3]\n",
      "   [2 0 3]\n",
      "   [1 3 2]]\n",
      "\n",
      "  [[0 3 2]\n",
      "   [0 3 0]\n",
      "   [3 2 1]]\n",
      "\n",
      "  [[3 2 0]\n",
      "   [3 0 1]\n",
      "   [2 1 4]]\n",
      "\n",
      "  [[2 0 0]\n",
      "   [0 1 0]\n",
      "   [1 4 4]]\n",
      "\n",
      "  [[0 0 4]\n",
      "   [1 0 2]\n",
      "   [4 4 4]]]\n",
      "\n",
      "\n",
      " [[[4 0 0]\n",
      "   [4 3 4]\n",
      "   [1 1 3]]\n",
      "\n",
      "  [[0 0 2]\n",
      "   [3 4 1]\n",
      "   [1 3 4]]\n",
      "\n",
      "  [[0 2 0]\n",
      "   [4 1 3]\n",
      "   [3 4 0]]\n",
      "\n",
      "  [[2 0 3]\n",
      "   [1 3 2]\n",
      "   [4 0 2]]\n",
      "\n",
      "  [[0 3 0]\n",
      "   [3 2 1]\n",
      "   [0 2 4]]\n",
      "\n",
      "  [[3 0 1]\n",
      "   [2 1 4]\n",
      "   [2 4 4]]\n",
      "\n",
      "  [[0 1 0]\n",
      "   [1 4 4]\n",
      "   [4 4 3]]\n",
      "\n",
      "  [[1 0 2]\n",
      "   [4 4 4]\n",
      "   [4 3 1]]]\n",
      "\n",
      "\n",
      " [[[4 3 4]\n",
      "   [1 1 3]\n",
      "   [2 2 3]]\n",
      "\n",
      "  [[3 4 1]\n",
      "   [1 3 4]\n",
      "   [2 3 3]]\n",
      "\n",
      "  [[4 1 3]\n",
      "   [3 4 0]\n",
      "   [3 3 1]]\n",
      "\n",
      "  [[1 3 2]\n",
      "   [4 0 2]\n",
      "   [3 1 3]]\n",
      "\n",
      "  [[3 2 1]\n",
      "   [0 2 4]\n",
      "   [1 3 0]]\n",
      "\n",
      "  [[2 1 4]\n",
      "   [2 4 4]\n",
      "   [3 0 1]]\n",
      "\n",
      "  [[1 4 4]\n",
      "   [4 4 3]\n",
      "   [0 1 3]]\n",
      "\n",
      "  [[4 4 4]\n",
      "   [4 3 1]\n",
      "   [1 3 3]]]\n",
      "\n",
      "\n",
      " [[[1 1 3]\n",
      "   [2 2 3]\n",
      "   [4 2 4]]\n",
      "\n",
      "  [[1 3 4]\n",
      "   [2 3 3]\n",
      "   [2 4 2]]\n",
      "\n",
      "  [[3 4 0]\n",
      "   [3 3 1]\n",
      "   [4 2 0]]\n",
      "\n",
      "  [[4 0 2]\n",
      "   [3 1 3]\n",
      "   [2 0 4]]\n",
      "\n",
      "  [[0 2 4]\n",
      "   [1 3 0]\n",
      "   [0 4 1]]\n",
      "\n",
      "  [[2 4 4]\n",
      "   [3 0 1]\n",
      "   [4 1 1]]\n",
      "\n",
      "  [[4 4 3]\n",
      "   [0 1 3]\n",
      "   [1 1 4]]\n",
      "\n",
      "  [[4 3 1]\n",
      "   [1 3 3]\n",
      "   [1 4 0]]]\n",
      "\n",
      "\n",
      " [[[2 2 3]\n",
      "   [4 2 4]\n",
      "   [1 3 1]]\n",
      "\n",
      "  [[2 3 3]\n",
      "   [2 4 2]\n",
      "   [3 1 2]]\n",
      "\n",
      "  [[3 3 1]\n",
      "   [4 2 0]\n",
      "   [1 2 4]]\n",
      "\n",
      "  [[3 1 3]\n",
      "   [2 0 4]\n",
      "   [2 4 2]]\n",
      "\n",
      "  [[1 3 0]\n",
      "   [0 4 1]\n",
      "   [4 2 0]]\n",
      "\n",
      "  [[3 0 1]\n",
      "   [4 1 1]\n",
      "   [2 0 1]]\n",
      "\n",
      "  [[0 1 3]\n",
      "   [1 1 4]\n",
      "   [0 1 3]]\n",
      "\n",
      "  [[1 3 3]\n",
      "   [1 4 0]\n",
      "   [1 3 1]]]\n",
      "\n",
      "\n",
      " [[[4 2 4]\n",
      "   [1 3 1]\n",
      "   [4 0 0]]\n",
      "\n",
      "  [[2 4 2]\n",
      "   [3 1 2]\n",
      "   [0 0 0]]\n",
      "\n",
      "  [[4 2 0]\n",
      "   [1 2 4]\n",
      "   [0 0 3]]\n",
      "\n",
      "  [[2 0 4]\n",
      "   [2 4 2]\n",
      "   [0 3 0]]\n",
      "\n",
      "  [[0 4 1]\n",
      "   [4 2 0]\n",
      "   [3 0 2]]\n",
      "\n",
      "  [[4 1 1]\n",
      "   [2 0 1]\n",
      "   [0 2 1]]\n",
      "\n",
      "  [[1 1 4]\n",
      "   [0 1 3]\n",
      "   [2 1 0]]\n",
      "\n",
      "  [[1 4 0]\n",
      "   [1 3 1]\n",
      "   [1 0 1]]]\n",
      "\n",
      "\n",
      " [[[1 3 1]\n",
      "   [4 0 0]\n",
      "   [2 0 1]]\n",
      "\n",
      "  [[3 1 2]\n",
      "   [0 0 0]\n",
      "   [0 1 3]]\n",
      "\n",
      "  [[1 2 4]\n",
      "   [0 0 3]\n",
      "   [1 3 2]]\n",
      "\n",
      "  [[2 4 2]\n",
      "   [0 3 0]\n",
      "   [3 2 1]]\n",
      "\n",
      "  [[4 2 0]\n",
      "   [3 0 2]\n",
      "   [2 1 2]]\n",
      "\n",
      "  [[2 0 1]\n",
      "   [0 2 1]\n",
      "   [1 2 0]]\n",
      "\n",
      "  [[0 1 3]\n",
      "   [2 1 0]\n",
      "   [2 0 3]]\n",
      "\n",
      "  [[1 3 1]\n",
      "   [1 0 1]\n",
      "   [0 3 3]]]]\n"
     ]
    }
   ],
   "source": [
    "Z = np.random.randint(0,5,(10,10))\n",
    "n = 3\n",
    "i = 1 + (Z.shape[0]-3)\n",
    "j = 1 + (Z.shape[1]-3)\n",
    "C = np.lib.stride_tricks.as_strided(Z, shape=(i, j, n, n), strides=Z.strides + Z.strides)\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 85. Create a 2D array subclass such that Z\\[i,j\\] == Z\\[j,i\\] (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 8  3  2  8  6]\n",
      " [ 3  0 12 15 13]\n",
      " [ 2 12  5 42 10]\n",
      " [ 8 15 42  1  6]\n",
      " [ 6 13 10  6  6]]\n"
     ]
    }
   ],
   "source": [
    "class Symetric(np.ndarray):\n",
    "    def __setitem__(self, index, value):\n",
    "        i,j = index\n",
    "        super(Symetric, self).__setitem__((i,j), value)\n",
    "        super(Symetric, self).__setitem__((j,i), value)\n",
    "\n",
    "def symetric(Z):\n",
    "    return np.asarray(Z + Z.T - np.diag(Z.diagonal())).view(Symetric)\n",
    "\n",
    "S = symetric(np.random.randint(0,10,(5,5)))\n",
    "S[2,3] = 42\n",
    "print(S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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)) (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]\n",
      " [200.]]\n"
     ]
    }
   ],
   "source": [
    "p, n = 10, 20\n",
    "M = np.ones((p,n,n))\n",
    "V = np.ones((p,n,1))\n",
    "S = np.tensordot(M, V, axes=[[0, 2], [0, 1]])\n",
    "print(S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 87. Consider a 16x16 array, how to get the block-sum (block size is 4x4)? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[16. 16. 16. 16.]\n",
      " [16. 16. 16. 16.]\n",
      " [16. 16. 16. 16.]\n",
      " [16. 16. 16. 16.]]\n"
     ]
    }
   ],
   "source": [
    "Z = np.ones((16,16))\n",
    "k = 4\n",
    "S = np.add.reduceat(np.add.reduceat(Z, np.arange(0, Z.shape[0], k), axis=0), np.arange(0, Z.shape[1], k), axis=1)\n",
    "print(S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 88. How to implement the Game of Life using numpy arrays? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " ...\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "def iterate(Z):\n",
    "    N = (Z[0:-2,0:-2] + Z[0:-2,1:-1] + Z[0:-2,2:] +\n",
    "         Z[1:-1,0:-2]                + Z[1:-1,2:] +\n",
    "         Z[2:  ,0:-2] + Z[2:  ,1:-1] + Z[2:  ,2:])\n",
    "\n",
    "    birth = (N==3) & (Z[1:-1,1:-1]==0)\n",
    "    survive = ((N==2) | (N==3)) & (Z[1:-1,1:-1]==1)\n",
    "    Z[...] = 0\n",
    "    Z[1:-1,1:-1][birth | survive] = 1\n",
    "    return Z\n",
    "\n",
    "Z = np.random.randint(0,2,(50,50))\n",
    "for i in range(100): Z = iterate(Z)\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 89. How to get the n largest values of an array (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[91 92 95 96 96]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(1, 100, 50)\n",
    "n = 5\n",
    "print (arr[np.argsort(arr)[-n:]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 90. Given an arbitrary number of vectors, build the cartesian product (every combinations of every item) (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 4 6]\n",
      " [1 4 7]\n",
      " [1 5 6]\n",
      " [1 5 7]\n",
      " [2 4 6]\n",
      " [2 4 7]\n",
      " [2 5 6]\n",
      " [2 5 7]\n",
      " [3 4 6]\n",
      " [3 4 7]\n",
      " [3 5 6]\n",
      " [3 5 7]]\n"
     ]
    }
   ],
   "source": [
    "def cartesian(arrays):\n",
    "    arrays = [np.asarray(a) for a in arrays]\n",
    "    shape = (len(x) for x in arrays)\n",
    "\n",
    "    ix = np.indices(shape, dtype=int)\n",
    "    ix = ix.reshape(len(arrays), -1).T\n",
    "\n",
    "    for n, arr in enumerate(arrays):\n",
    "        ix[:, n] = arrays[n][ix[:, n]]\n",
    "\n",
    "    return ix\n",
    "\n",
    "print (cartesian(([1, 2, 3], [4, 5], [6, 7])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 91. How to create a record array from a regular array? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(b'Hello', 2.5, 3) (b'World', 3.6, 2)]\n"
     ]
    }
   ],
   "source": [
    "Z = np.array([(\"Hello\", 2.5, 3),(\"World\", 3.6, 2)])\n",
    "R = np.core.records.fromarrays(Z.T,names='col1, col2, col3',formats = 'S8, f8, i8')\n",
    "print(R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 92. Consider a large vector Z, compute Z to the power of 3 using 3 different methods (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[64]\n",
      "[64]\n",
      "[64]\n"
     ]
    }
   ],
   "source": [
    "x = np.random.randint(1, 100, 1)\n",
    "\n",
    "print (np.power(x,3))\n",
    "print (x*x*x)\n",
    "print (np.einsum('i,i,i->i',x,x,x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "A = np.random.randint(0,5,(8,3))\n",
    "B = np.random.randint(0,5,(2,2))\n",
    "\n",
    "C = (A[..., np.newaxis, np.newaxis] == B)\n",
    "rows = np.where(C.any((3,1)).all(1))[0]\n",
    "print(rows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 94. Considering a 10x3 matrix, extract rows with unequal values (e.g. \\[2,2,3\\]) (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 4 0]\n",
      " [4 2 0]\n",
      " [2 3 4]\n",
      " [3 3 2]\n",
      " [2 4 2]\n",
      " [1 4 1]\n",
      " [3 4 1]\n",
      " [4 2 2]\n",
      " [0 3 3]\n",
      " [4 0 3]]\n",
      "[[1 4 0]\n",
      " [4 2 0]\n",
      " [2 3 4]\n",
      " [3 3 2]\n",
      " [2 4 2]\n",
      " [1 4 1]\n",
      " [3 4 1]\n",
      " [4 2 2]\n",
      " [0 3 3]\n",
      " [4 0 3]]\n"
     ]
    }
   ],
   "source": [
    "Z = np.random.randint(0,5,(10,3))\n",
    "print(Z)\n",
    "E = np.all(Z[:,1:] == Z[:,:-1], axis=1)\n",
    "U = Z[~E]\n",
    "U = Z[Z.max(axis=1) != Z.min(axis=1),:]\n",
    "print(U)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 95. Convert a vector of ints into a matrix binary representation (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 1]\n",
      " [0 0 0 0 0 0 1 0]\n",
      " [0 0 0 0 0 0 1 1]\n",
      " [0 0 0 0 1 1 1 1]\n",
      " [0 0 0 1 0 0 0 0]\n",
      " [0 0 1 0 0 0 0 0]\n",
      " [0 1 0 0 0 0 0 0]\n",
      " [1 0 0 0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "I = np.array([0, 1, 2, 3, 15, 16, 32, 64, 128], dtype=np.uint8)\n",
    "print(np.unpackbits(I[:, np.newaxis], axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 96. Given a two dimensional array, how to extract unique rows? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 1]\n",
      " [1 0 1]\n",
      " [1 1 0]\n",
      " [1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(0,2,(6,3))\n",
    "arr = np.unique(arr, axis=0)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 97. Considering 2 vectors A & B, write the einsum equivalent of inner, outer, sum, and mul function (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.03573262, 0.09259094, 0.35611239, 0.1326334 , 0.12927326,\n",
       "        0.04453591, 0.25583484, 0.2171001 , 0.36746121, 0.02756051],\n",
       "       [0.01043676, 0.0270439 , 0.10401306, 0.03873947, 0.03775804,\n",
       "        0.01300802, 0.07472406, 0.06341045, 0.10732781, 0.00804985],\n",
       "       [0.00170104, 0.00440777, 0.01695266, 0.00631399, 0.00615403,\n",
       "        0.00212012, 0.01217896, 0.01033501, 0.01749291, 0.00131201],\n",
       "       [0.04852468, 0.12573792, 0.48359836, 0.18011532, 0.17555226,\n",
       "        0.06047949, 0.34742209, 0.29482056, 0.49900999, 0.03742699],\n",
       "       [0.0675136 , 0.17494233, 0.6728426 , 0.25059898, 0.24425029,\n",
       "        0.08414664, 0.48337712, 0.41019128, 0.69428519, 0.05207312],\n",
       "       [0.01413336, 0.03662259, 0.14085351, 0.05246063, 0.05113159,\n",
       "        0.01761534, 0.10119062, 0.08586983, 0.14534232, 0.01090104],\n",
       "       [0.06085   , 0.1576755 , 0.60643295, 0.22586483, 0.22014275,\n",
       "        0.07584135, 0.43566773, 0.36970535, 0.62575915, 0.04693349],\n",
       "       [0.01515307, 0.03926489, 0.15101598, 0.05624562, 0.05482069,\n",
       "        0.01888627, 0.10849145, 0.09206528, 0.15582866, 0.01168754],\n",
       "       [0.00599878, 0.01554412, 0.05978398, 0.02226643, 0.02170233,\n",
       "        0.00747667, 0.04294943, 0.03644666, 0.06168921, 0.00462684],\n",
       "       [0.05281486, 0.13685472, 0.52635451, 0.19603977, 0.19107328,\n",
       "        0.06582663, 0.37813855, 0.32088639, 0.54312872, 0.04073601]])"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.uniform(0,1,10)\n",
    "B = np.random.uniform(0,1,10)\n",
    "\n",
    "np.einsum('i->', A)\n",
    "np.einsum('i,i->i', A, B)\n",
    "np.einsum('i,i', A, B)\n",
    "np.einsum('i,j->ij', A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 98. Considering a path described by two vectors (X,Y), how to sample it using equidistant samples (★★★)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [],
   "source": [
    "phi = np.arange(0, 10*np.pi, 0.1)\n",
    "a = 1\n",
    "x = a*phi*np.cos(phi)\n",
    "y = a*phi*np.sin(phi)\n",
    "\n",
    "dr = (np.diff(x)**2 + np.diff(y)**2)**.5\n",
    "r = np.zeros_like(x)\n",
    "r[1:] = np.cumsum(dr)\n",
    "r_int = np.linspace(0, r.max(), 200)\n",
    "x_int = np.interp(r_int, r, x)\n",
    "y_int = np.interp(r_int, r, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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. (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2. 0. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "X = np.asarray([[1.0, 0.0, 3.0, 8.0],\n",
    "                [2.0, 0.0, 1.0, 1.0],\n",
    "                [1.5, 2.5, 1.0, 0.0]])\n",
    "n = 4\n",
    "M = np.logical_and.reduce(np.mod(X, 1) == 0, axis=-1)\n",
    "M &= (X.sum(axis=-1) == n)\n",
    "print(X[M])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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). (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.3792783 -0.0207588]\n"
     ]
    }
   ],
   "source": [
    "X = np.random.randn(100)\n",
    "N = 1000\n",
    "idx = np.random.randint(0, X.size, (N, X.size))\n",
    "means = X[idx].mean(axis=1)\n",
    "confint = np.percentile(means, [2.5, 97.5])\n",
    "print(confint)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}