100 Numpy exercises no solution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 100 numpy exercises\n",
    "\n",
    "This is a collection of exercises that have been collected in the numpy mailing list, on stack overflow and in the numpy documentation. The goal of this collection is to offer a quick reference for both old and new users but also to provide a set of exercices for those who teach.\n",
    "\n",
    "\n",
    "If you find an error or think you've a better way to solve some of them, feel free to open an issue at <https://github.com/rougier/numpy-100>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Import the numpy package under the name `np` (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Print the numpy version and the configuration (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.11.3\n",
      "atlas_3_10_blas_threads_info:\n",
      "    libraries = ['numpy-atlas']\n",
      "    library_dirs = ['C:\\\\projects\\\\numpy-wheels\\\\windows-wheel-builder\\\\atlas-builds\\\\atlas-3.11.38-sse2-64\\\\lib']\n",
      "    define_macros = [('HAVE_CBLAS', None), ('ATLAS_INFO', '\"\\\\\"None\\\\\"\"')]\n",
      "    language = c\n",
      "lapack_opt_info:\n",
      "    libraries = ['numpy-atlas', 'numpy-atlas']\n",
      "    library_dirs = ['C:\\\\projects\\\\numpy-wheels\\\\windows-wheel-builder\\\\atlas-builds\\\\atlas-3.11.38-sse2-64\\\\lib']\n",
      "    define_macros = [('ATLAS_INFO', '\"\\\\\"None\\\\\"\"')]\n",
      "    language = f77\n",
      "blas_opt_info:\n",
      "    libraries = ['numpy-atlas']\n",
      "    library_dirs = ['C:\\\\projects\\\\numpy-wheels\\\\windows-wheel-builder\\\\atlas-builds\\\\atlas-3.11.38-sse2-64\\\\lib']\n",
      "    define_macros = [('HAVE_CBLAS', None), ('ATLAS_INFO', '\"\\\\\"None\\\\\"\"')]\n",
      "    language = c\n",
      "openblas_info:\n",
      "  NOT AVAILABLE\n",
      "openblas_lapack_info:\n",
      "  NOT AVAILABLE\n",
      "atlas_3_10_threads_info:\n",
      "    libraries = ['numpy-atlas', 'numpy-atlas']\n",
      "    library_dirs = ['C:\\\\projects\\\\numpy-wheels\\\\windows-wheel-builder\\\\atlas-builds\\\\atlas-3.11.38-sse2-64\\\\lib']\n",
      "    define_macros = [('ATLAS_INFO', '\"\\\\\"None\\\\\"\"')]\n",
      "    language = f77\n",
      "lapack_mkl_info:\n",
      "  NOT AVAILABLE\n",
      "blas_mkl_info:\n",
      "  NOT AVAILABLE\n"
     ]
    }
   ],
   "source": [
    "print(np.__version__)\n",
    "np.show_config()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Create a null vector of size 10 (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n"
     ]
    }
   ],
   "source": [
    "z = np.zeros([10])\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.  How to find the memory size of any array (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "160 bytes\n"
     ]
    }
   ],
   "source": [
    "z = np.zeros([10,2])\n",
    "print(\"%d bytes\" % (z.size * z.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": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add(x1, x2[, out])\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\n",
      "    broadcastable to a common shape (which may be the shape of one or\n",
      "    the other).\n",
      "\n",
      "Returns\n",
      "-------\n",
      "add : ndarray or scalar\n",
      "    The sum of `x1` and `x2`, element-wise.  Returns a scalar if\n",
      "    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": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  0.  0.  0.  1.  0.  0.  0.  0.  0.]\n"
     ]
    }
   ],
   "source": [
    "z = np.zeros(10)\n",
    "z[4] = 1\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.  Create a vector with values ranging from 10 to 49 (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "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 34\n",
      " 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49]\n"
     ]
    }
   ],
   "source": [
    "z = np.arange(10,50)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 8.  Reverse a vector (first element becomes last) (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "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 25\n",
      " 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10]\n"
     ]
    }
   ],
   "source": [
    "print(z[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9.  Create a 3x3 matrix with values ranging from 0 to 8 (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.arange(9)\n",
    "z = np.reshape(z,[3,3])\n",
    "print(z)\n",
    "z.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 10. Find indices of non-zero elements from \\[1,2,0,0,4,0\\] (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([0, 1, 4], dtype=int64),)\n"
     ]
    }
   ],
   "source": [
    "nz = np.nonzero([1,2,0,0,4,0])\n",
    "print(nz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 11. Create a 3x3 identity matrix (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  0.  0.]\n",
      " [ 0.  1.  0.]\n",
      " [ 0.  0.  1.]]\n",
      " eye(N, M=None, k=0, dtype=<type 'float'>)\n",
      "\n",
      "Return a 2-D array with ones on the diagonal and zeros elsewhere.\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "N : int\n",
      "  Number of rows in the output.\n",
      "M : int, optional\n",
      "  Number of columns in the output. If None, defaults to `N`.\n",
      "k : int, optional\n",
      "  Index of the diagonal: 0 (the default) refers to the main diagonal,\n",
      "  a positive value refers to an upper diagonal, and a negative value\n",
      "  to a lower diagonal.\n",
      "dtype : data-type, optional\n",
      "  Data-type of the returned array.\n",
      "\n",
      "Returns\n",
      "-------\n",
      "I : ndarray of shape (N,M)\n",
      "  An array where all elements are equal to zero, except for the `k`-th\n",
      "  diagonal, whose values are equal to one.\n",
      "\n",
      "See Also\n",
      "--------\n",
      "identity : (almost) equivalent function\n",
      "diag : diagonal 2-D array from a 1-D array specified by the user.\n",
      "\n",
      "Examples\n",
      "--------\n",
      ">>> np.eye(2, dtype=int)\n",
      "array([[1, 0],\n",
      "       [0, 1]])\n",
      ">>> np.eye(3, k=1)\n",
      "array([[ 0.,  1.,  0.],\n",
      "       [ 0.,  0.,  1.],\n",
      "       [ 0.,  0.,  0.]])\n"
     ]
    }
   ],
   "source": [
    "id3 = np.eye(3)\n",
    "print(id3)\n",
    "np.info(np.eye)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 12. Create a 3x3x3 array with random values (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0.33805568  0.47769214  0.20176595]\n",
      "  [ 0.69912171  0.0549863   0.94271994]\n",
      "  [ 0.14926725  0.59581579  0.53923268]]\n",
      "\n",
      " [[ 0.871663    0.26813532  0.96527777]\n",
      "  [ 0.93738873  0.45133554  0.329108  ]\n",
      "  [ 0.32836953  0.25513215  0.85282384]]\n",
      "\n",
      " [[ 0.95413576  0.99137933  0.42350171]\n",
      "  [ 0.15299422  0.52396155  0.25816316]\n",
      "  [ 0.22707988  0.25270551  0.20761079]]]\n",
      "========================\n",
      "Random Number Generation\n",
      "========================\n",
      "\n",
      "==================== =========================================================\n",
      "Utility functions\n",
      "==============================================================================\n",
      "random_sample        Uniformly distributed floats over ``[0, 1)``.\n",
      "random               Alias for `random_sample`.\n",
      "bytes                Uniformly distributed random bytes.\n",
      "random_integers      Uniformly distributed integers in a given range.\n",
      "permutation          Randomly permute a sequence / generate a random sequence.\n",
      "shuffle              Randomly permute a sequence in place.\n",
      "seed                 Seed the random number generator.\n",
      "choice               Random sample from 1-D array.\n",
      "\n",
      "==================== =========================================================\n",
      "\n",
      "==================== =========================================================\n",
      "Compatibility functions\n",
      "==============================================================================\n",
      "rand                 Uniformly distributed values.\n",
      "randn                Normally distributed values.\n",
      "ranf                 Uniformly distributed floating point numbers.\n",
      "randint              Uniformly distributed integers in a given range.\n",
      "==================== =========================================================\n",
      "\n",
      "==================== =========================================================\n",
      "Univariate distributions\n",
      "==============================================================================\n",
      "beta                 Beta distribution over ``[0, 1]``.\n",
      "binomial             Binomial distribution.\n",
      "chisquare            :math:`\\chi^2` distribution.\n",
      "exponential          Exponential distribution.\n",
      "f                    F (Fisher-Snedecor) distribution.\n",
      "gamma                Gamma distribution.\n",
      "geometric            Geometric distribution.\n",
      "gumbel               Gumbel distribution.\n",
      "hypergeometric       Hypergeometric distribution.\n",
      "laplace              Laplace distribution.\n",
      "logistic             Logistic distribution.\n",
      "lognormal            Log-normal distribution.\n",
      "logseries            Logarithmic series distribution.\n",
      "negative_binomial    Negative binomial distribution.\n",
      "noncentral_chisquare Non-central chi-square distribution.\n",
      "noncentral_f         Non-central F distribution.\n",
      "normal               Normal / Gaussian distribution.\n",
      "pareto               Pareto distribution.\n",
      "poisson              Poisson distribution.\n",
      "power                Power distribution.\n",
      "rayleigh             Rayleigh distribution.\n",
      "triangular           Triangular distribution.\n",
      "uniform              Uniform distribution.\n",
      "vonmises             Von Mises circular distribution.\n",
      "wald                 Wald (inverse Gaussian) distribution.\n",
      "weibull              Weibull distribution.\n",
      "zipf                 Zipf's distribution over ranked data.\n",
      "==================== =========================================================\n",
      "\n",
      "==================== =========================================================\n",
      "Multivariate distributions\n",
      "==============================================================================\n",
      "dirichlet            Multivariate generalization of Beta distribution.\n",
      "multinomial          Multivariate generalization of the binomial distribution.\n",
      "multivariate_normal  Multivariate generalization of the normal distribution.\n",
      "==================== =========================================================\n",
      "\n",
      "==================== =========================================================\n",
      "Standard distributions\n",
      "==============================================================================\n",
      "standard_cauchy      Standard Cauchy-Lorentz distribution.\n",
      "standard_exponential Standard exponential distribution.\n",
      "standard_gamma       Standard Gamma distribution.\n",
      "standard_normal      Standard normal distribution.\n",
      "standard_t           Standard Student's t-distribution.\n",
      "==================== =========================================================\n",
      "\n",
      "==================== =========================================================\n",
      "Internal functions\n",
      "==============================================================================\n",
      "get_state            Get tuple representing internal state of generator.\n",
      "set_state            Set state of generator.\n",
      "==================== =========================================================\n",
      "rand(d0, d1, ..., dn)\n",
      "\n",
      "Random values in a given shape.\n",
      "\n",
      "Create an array of the given shape and populate it with\n",
      "random samples from a uniform distribution\n",
      "over ``[0, 1)``.\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "d0, d1, ..., dn : int, optional\n",
      "    The dimensions of the returned array, should all be positive.\n",
      "    If no argument is given a single Python float is returned.\n",
      "\n",
      "Returns\n",
      "-------\n",
      "out : ndarray, shape ``(d0, d1, ..., dn)``\n",
      "    Random values.\n",
      "\n",
      "See Also\n",
      "--------\n",
      "random\n",
      "\n",
      "Notes\n",
      "-----\n",
      "This is a convenience function. If you want an interface that\n",
      "takes a shape-tuple as the first argument, refer to\n",
      "np.random.random_sample .\n",
      "\n",
      "Examples\n",
      "--------\n",
      ">>> np.random.rand(3,2)\n",
      "array([[ 0.14022471,  0.96360618],  #random\n",
      "       [ 0.37601032,  0.25528411],  #random\n",
      "       [ 0.49313049,  0.94909878]]) #random\n",
      "random_sample(size=None)\n",
      "\n",
      "Return random floats in the half-open interval [0.0, 1.0).\n",
      "\n",
      "Results are from the \"continuous uniform\" distribution over the\n",
      "stated interval.  To sample :math:`Unif[a, b), b > a` multiply\n",
      "the output of `random_sample` by `(b-a)` and add `a`::\n",
      "\n",
      "  (b - a) * random_sample() + a\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "size : int or tuple of ints, optional\n",
      "    Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "    ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "    single value is returned.\n",
      "\n",
      "Returns\n",
      "-------\n",
      "out : float or ndarray of floats\n",
      "    Array of random floats of shape `size` (unless ``size=None``, in which\n",
      "    case a single float is returned).\n",
      "\n",
      "Examples\n",
      "--------\n",
      ">>> np.random.random_sample()\n",
      "0.47108547995356098\n",
      ">>> type(np.random.random_sample())\n",
      "<type 'float'>\n",
      ">>> np.random.random_sample((5,))\n",
      "array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428])\n",
      "\n",
      "Three-by-two array of random numbers from [-5, 0):\n",
      "\n",
      ">>> 5 * np.random.random_sample((3, 2)) - 5\n",
      "array([[-3.99149989, -0.52338984],\n",
      "       [-2.99091858, -0.79479508],\n",
      "       [-1.23204345, -1.75224494]])\n"
     ]
    }
   ],
   "source": [
    "z = np.random.random([3,3,3])\n",
    "print(z)\n",
    "np.info(np.random)\n",
    "np.info(np.random.rand)\n",
    "np.info(np.random.random_sample)"
   ]
  },
  {
   "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": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('z: ', array([[ 0.30905209,  0.75143095,  0.78540338,  0.95575177,  0.33649288,\n",
      "         0.40200448,  0.09555055,  0.79801648,  0.28535205,  0.47896843],\n",
      "       [ 0.72730027,  0.1562882 ,  0.65965355,  0.39432331,  0.56839709,\n",
      "         0.58836819,  0.5169082 ,  0.539898  ,  0.68983125,  0.70716533],\n",
      "       [ 0.20228778,  0.69094769,  0.66053524,  0.8025117 ,  0.72239856,\n",
      "         0.64101164,  0.56434239,  0.94489339,  0.5034549 ,  0.6502329 ],\n",
      "       [ 0.75872013,  0.5302351 ,  0.52148456,  0.31146522,  0.25189181,\n",
      "         0.11973705,  0.61037754,  0.49294026,  0.60602511,  0.55511444],\n",
      "       [ 0.17090228,  0.02127334,  0.42095061,  0.51472644,  0.51841711,\n",
      "         0.72485106,  0.68713616,  0.20927446,  0.12714228,  0.0551561 ],\n",
      "       [ 0.84288658,  0.38637666,  0.78653864,  0.44900267,  0.86956555,\n",
      "         0.09107505,  0.09965943,  0.90647947,  0.54967741,  0.24543669],\n",
      "       [ 0.15432767,  0.05253356,  0.22596315,  0.65557727,  0.31710225,\n",
      "         0.8767481 ,  0.10102561,  0.04393759,  0.87959192,  0.54168799],\n",
      "       [ 0.5879966 ,  0.68580014,  0.63367696,  0.80138583,  0.87640318,\n",
      "         0.38702995,  0.9064236 ,  0.19323392,  0.61395577,  0.39350409],\n",
      "       [ 0.76583181,  0.41213426,  0.67263555,  0.64246205,  0.43953354,\n",
      "         0.01601112,  0.37578989,  0.28808087,  0.35348495,  0.96781877],\n",
      "       [ 0.82023752,  0.43111935,  0.56480779,  0.33816974,  0.54159261,\n",
      "         0.04307104,  0.11584514,  0.12340358,  0.05687003,  0.56877324]]))\n",
      "(0.016011124782901232, 0.96781876633602315)\n",
      "(0.016011124782901232, 0.96781876633602315)\n",
      "Search results for 'min'\n",
      "------------------------\n",
      "numpy.amin\n",
      "    Return the minimum of an array or minimum along an axis.\n",
      "numpy.fmin\n",
      "    Element-wise minimum of array elements.\n",
      "numpy.argmin\n",
      "    Returns the indices of the minimum values along an axis.\n",
      "numpy.nanmin\n",
      "    Return minimum of an array or minimum along an axis, ignoring any NaNs.\n",
      "numpy.hamming\n",
      "    Return the Hamming window.\n",
      "numpy.minimum\n",
      "    Element-wise minimum of array elements.\n",
      "numpy.nanargmin\n",
      "    Return the indices of the minimum values in the specified axis ignoring\n",
      "numpy.ptp\n",
      "    Range of values (maximum - minimum) along an axis.\n",
      "numpy.array\n",
      "    Create an array.\n",
      "numpy.ma.min\n",
      "    Return the minimum along a given axis.\n",
      "numpy.mintypecode\n",
      "    Return the character for the minimum-size type to which given types can\n",
      "numpy.ma.argmin\n",
      "    Return array of indices to the minimum values along the given axis.\n",
      "numpy.bincount\n",
      "    Count number of occurrences of each value in array of non-negative ints.\n",
      "numpy.issctype\n",
      "    Determines whether the given object represents a scalar data-type.\n",
      "numpy.ma.minimum\n",
      "    Object to calculate minima\n",
      "numpy.matrix.min\n",
      "    Return the minimum value along an axis.\n",
      "numpy.min_scalar_type\n",
      "    min_scalar_type(a)\n",
      "numpy.chararray.min\n",
      "    Return the minimum along a given axis.\n",
      "numpy.binary_repr\n",
      "    Return the binary representation of the input number as a string.\n",
      "numpy.ma.ptp\n",
      "    Return (maximum - minimum) along the the given dimension\n",
      "numpy.issubclass_\n",
      "    Determine if a class is a subclass of a second class.\n",
      "numpy.issubsctype\n",
      "    Determine if the first argument is a subclass of the second argument.\n",
      "numpy.matrix.argmin\n",
      "    Indexes of the minimum values along an axis.\n",
      "numpy.shares_memory\n",
      "    Determine if two arrays share memory\n",
      "numpy.chararray.argmin\n",
      "    Return indices of the minimum values along the given axis of `a`.\n",
      "numpy.linalg.det\n",
      "    Compute the determinant of an array.\n",
      "numpy.matrix.ptp\n",
      "    Peak-to-peak (maximum - minimum) value along the given axis.\n",
      "numpy.find_common_type\n",
      "    Determine common type following standard coercion rules.\n",
      "numpy.may_share_memory\n",
      "    Determine if two arrays might share memory\n",
      "numpy.ma.mvoid.min\n",
      "    Return the minimum along a given axis.\n",
      "numpy.set_printoptions\n",
      "    Set printing options.\n",
      "numpy.linalg.solve\n",
      "    Solve a linear matrix equation, or system of linear scalar equations.\n",
      "numpy.chararray.ptp\n",
      "    Peak to peak (maximum - minimum) value along a given axis.\n",
      "numpy.ma.is_masked\n",
      "    Determine whether input has masked values.\n",
      "numpy.ma.mvoid.mini\n",
      "    Return the array minimum along the specified axis.\n",
      "numpy.chararray.clip\n",
      "    Return an array whose values are limited to ``[min, max]``.\n",
      "numpy.linalg.slogdet\n",
      "    Compute the sign and (natural) logarithm of the determinant of an array.\n",
      "numpy.ma.mvoid.argmin\n",
      "    Return array of indices to the minimum values along the given axis.\n",
      "numpy.ma.MaskedArray.min\n",
      "    Return the minimum along a given axis.\n",
      "numpy.ma.mvoid.ptp\n",
      "    Return (maximum - minimum) along the the given dimension\n",
      "numpy.ma.MaskedArray.mini\n",
      "    Return the array minimum along the specified axis.\n",
      "numpy.ma.mvoid.clip\n",
      "    Return an array whose values are limited to ``[min, max]``.\n",
      "numpy.ma.maximum_fill_value\n",
      "    Return the minimum value that can be represented by the dtype of an object.\n",
      "numpy.ma.MaskedArray.ptp\n",
      "    Return (maximum - minimum) along the the given dimension\n",
      "numpy.distutils.misc_util.mingw32\n",
      "    Return true when using mingw32 environment.\n",
      "numpy.ma.mvoid.harden_mask\n",
      "    Force the mask to hard.\n",
      "numpy.ma.mvoid.soften_mask\n",
      "    Force the mask to soft.\n",
      "numpy.f2py.capi_maps.getctype\n",
      "    Determines C type\n",
      "numpy.ma.MaskedArray.soften_mask\n",
      "    Force the mask to soft.\n",
      "numpy.f2py.crackfortran.postcrack\n",
      "    TODO:\n",
      "numpy.lib._iotools.StringConverter\n",
      "    Factory class for function transforming a string into another object\n",
      "numpy.distutils.misc_util.get_language\n",
      "    Determine language value (c,f77,f90) from sources\n",
      "numpy.cov\n",
      "    Estimate a covariance matrix, given data and weights.\n",
      "numpy.irr\n",
      "    Return the Internal Rate of Return (IRR).\n",
      "numpy.log\n",
      "    Natural logarithm, element-wise.\n",
      "numpy.pad\n",
      "    Pads an array.\n",
      "numpy.amax\n",
      "    Return the maximum of an array or maximum along an axis.\n",
      "numpy.clip\n",
      "    Clip (limit) the values in an array.\n",
      "numpy.fmax\n",
      "    Element-wise maximum of array elements.\n",
      "numpy.in1d\n",
      "    Test whether each element of a 1-D array is also present in a second array.\n",
      "numpy.log2\n",
      "    Base-2 logarithm of `x`.\n",
      "numpy.poly\n",
      "    Find the coefficients of a polynomial with the given sequence of roots.\n",
      "numpy.sort\n",
      "    Return a sorted copy of an array.\n",
      "numpy.expm1\n",
      "    Calculate ``exp(x) - 1`` for all elements in the array.\n",
      "numpy.finfo\n",
      "    finfo(dtype)\n",
      "numpy.iinfo\n",
      "    iinfo(type)\n",
      "numpy.log10\n",
      "    Return the base 10 logarithm of the input array, element-wise.\n",
      "numpy.log1p\n",
      "    Return the natural logarithm of one plus the input array, element-wise.\n",
      "numpy.trace\n",
      "    Return the sum along diagonals of the array.\n",
      "numpy.distutils.mingw32ccompiler.Mingw32CCompiler\n",
      "    A modified MingW32 compiler compatible with an MSVC built Python.\n",
      "numpy.MachAr\n",
      "    Diagnosing machine parameters.\n",
      "numpy.argmax\n",
      "    Returns the indices of the maximum values along an axis.\n",
      "numpy.around\n",
      "    Evenly round to the given number of decimals.\n",
      "numpy.choose\n",
      "    Construct an array from an index array and a set of arrays to choose from.\n",
      "numpy.einsum\n",
      "    Evaluates the Einstein summation convention on the operands.\n",
      "numpy.kaiser\n",
      "    Return the Kaiser window.\n",
      "numpy.matmul\n",
      "    Matrix product of two arrays.\n",
      "numpy.matrix\n",
      "    Returns a matrix from an array-like object, or from a string of data.\n",
      "numpy.memmap\n",
      "    Create a memory-map to an array stored in a *binary* file on disk.\n",
      "numpy.nanmax\n",
      "    Return the maximum of an array or maximum along an axis, ignoring any\n",
      "numpy.nditer\n",
      "    Efficient multi-dimensional iterator object to iterate over arrays.\n",
      "numpy.testing.nosetester.get_package_name\n",
      "    Given a path where a package is installed, determine its name.\n",
      "numpy.select\n",
      "    Return an array drawn from elements in choicelist, depending on conditions.\n",
      "numpy.unique\n",
      "    Find the unique elements of an array.\n",
      "numpy.distutils.mingw32ccompiler.msvc_manifest_xml\n",
      "    Given a major and minor version of the MSVCR, returns the\n",
      "numpy.vander\n",
      "    Generate a Vandermonde matrix.\n",
      "numpy.arctan2\n",
      "    Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.\n",
      "numpy.hanning\n",
      "    Return the Hanning window.\n",
      "numpy.loadtxt\n",
      "    Load data from a text file.\n",
      "numpy.lookfor\n",
      "    Do a keyword search on docstrings.\n",
      "numpy.maximum\n",
      "    Element-wise maximum of array elements.\n",
      "numpy.ndarray\n",
      "    ndarray(shape, dtype=float, buffer=None, offset=0,\n",
      "numpy.polydiv\n",
      "    Returns the quotient and remainder of polynomial division.\n",
      "numpy.polyfit\n",
      "    Least squares polynomial fit.\n",
      "numpy.polyint\n",
      "    Return an antiderivative (indefinite integral) of a polynomial.\n",
      "numpy.polysub\n",
      "    Difference (subtraction) of two polynomials.\n",
      "numpy.savetxt\n",
      "    Save an array to a text file.\n",
      "numpy.union1d\n",
      "    Find the union of two arrays.\n",
      "numpy.bartlett\n",
      "    Return the Bartlett window.\n",
      "numpy.blackman\n",
      "    Return the Blackman window.\n",
      "numpy.convolve\n",
      "    Returns the discrete, linear convolution of two one-dimensional sequences.\n",
      "numpy.diagonal\n",
      "    Return specified diagonals.\n",
      "numpy.fromfile\n",
      "    Construct an array from data in a text or binary file.\n",
      "numpy.recarray\n",
      "    Construct an ndarray that allows field access using attributes.\n",
      "numpy.histogram\n",
      "    Compute the histogram of a set of data.\n",
      "numpy.nanargmax\n",
      "    Return the indices of the maximum values in the specified axis ignoring\n",
      "numpy.partition\n",
      "    Return a partitioned copy of an array.\n",
      "numpy.setdiff1d\n",
      "    Find the set difference of two arrays.\n",
      "numpy.vectorize\n",
      "    Generalized function class.\n",
      "numpy.fromstring\n",
      "    A new 1-D array initialized from raw binary or text data in a string.\n",
      "numpy.genfromtxt\n",
      "    Load data from a text file, with missing values handled as specified.\n",
      "numpy.obj2sctype\n",
      "    Return the scalar dtype or NumPy equivalent of Python type of an object.\n",
      "numpy.percentile\n",
      "    Compute the qth percentile of the data along the specified axis.\n",
      "numpy.recfromcsv\n",
      "    Load ASCII data stored in a comma-separated file.\n",
      "numpy.recfromtxt\n",
      "    Load ASCII data from a file and return it in a record array.\n",
      "numpy.trim_zeros\n",
      "    Trim the leading and/or trailing zeros from a 1-D array or sequence.\n",
      "numpy.common_type\n",
      "    Return a scalar type which is common to the input arrays.\n",
      "numpy.ma.log\n",
      "    Natural logarithm, element-wise.\n",
      "numpy.histogram2d\n",
      "    Compute the bi-dimensional histogram of two data samples.\n",
      "numpy.histogramdd\n",
      "    Compute the multidimensional histogram of some data.\n",
      "numpy.intersect1d\n",
      "    Find the intersection of two arrays.\n",
      "numpy.logical_xor\n",
      "    Compute the truth value of x1 XOR x2, element-wise.\n",
      "numpy.result_type\n",
      "    result_type(*arrays_and_dtypes)\n",
      "numpy.sctype2char\n",
      "    Return the string representation of a scalar dtype.\n",
      "numpy.ma.log2\n",
      "    Base-2 logarithm of `x`.\n",
      "numpy.floor_divide\n",
      "    Return the largest integer smaller or equal to the division of the inputs.\n",
      "numpy.fromfunction\n",
      "    Construct an array by executing a function over each coordinate.\n",
      "numpy.fft.hfft\n",
      "    Compute the FFT of a signal which has Hermitian symmetry (real spectrum).\n",
      "numpy.ma.array\n",
      "    An array class with possibly masked values.\n",
      "numpy.ma.log10\n",
      "    Return the base 10 logarithm of the input array, element-wise.\n",
      "numpy.fft.irfft\n",
      "    Compute the inverse of the n-point DFT for real input.\n",
      "numpy.nanpercentile\n",
      "    Compute the qth percentile of the data along the specified axis,\n",
      "numpy.linalg.qr\n",
      "    Compute the qr factorization of a matrix.\n",
      "numpy.unravel_index\n",
      "    Converts a flat index or array of flat indices into a tuple\n",
      "numpy.ma.vander\n",
      "    Generate a Vandermonde matrix.\n",
      "numpy.maximum_sctype\n",
      "    Return the scalar type of highest precision of the same kind as the input.\n",
      "numpy.distutils.mingw32ccompiler._build_import_library_x86\n",
      "    Build the import libraries for Mingw32-gcc on Windows\n",
      "numpy.linalg.svd\n",
      "    Singular Value Decomposition.\n",
      "numpy.ma.arctan2\n",
      "    Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.\n",
      "numpy.ma.polyfit\n",
      "    Least squares polynomial fit.\n",
      "numpy.linalg.cond\n",
      "    Compute the condition number of a matrix.\n",
      "numpy.linalg.norm\n",
      "    Matrix or vector norm.\n",
      "numpy.linalg.lstsq\n",
      "    Return the least-squares solution to a linear matrix equation.\n",
      "numpy.ravel_multi_index\n",
      "    Converts a tuple of index arrays into an array of flat\n",
      "numpy.chararray.dump\n",
      "    a.dump(file)\n",
      "numpy.ma.MaskedArray\n",
      "    An array class with possibly masked values.\n",
      "numpy.ma.harden_mask\n",
      "    harden_mask(self)\n",
      "numpy.ma.logical_xor\n",
      "    Compute the truth value of x1 XOR x2, element-wise.\n",
      "numpy.ma.soften_mask\n",
      "    soften_mask(self)\n",
      "numpy.DataSource.exists\n",
      "    Test if path exists.\n",
      "numpy.ma.floor_divide\n",
      "    Return the largest integer smaller or equal to the division of the inputs.\n",
      "numpy.ma.fromfunction\n",
      "    Construct an array by executing a function over each coordinate.\n",
      "numpy.ma.minimum_fill_value\n",
      "    Return the maximum value that can be represented by the dtype of an object.\n",
      "numpy.lib._version.NumpyVersion._compare_version\n",
      "    Compare major.minor.bugfix\n",
      "numpy.testing.measure\n",
      "    Return elapsed time for executing code in the namespace of the caller.\n",
      "numpy.chararray.getfield\n",
      "    Returns a field of the given array as a certain type.\n",
      "numpy.chararray.setflags\n",
      "    Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively.\n",
      "numpy.double.__setformat__\n",
      "    You probably don't want to use this function.  It exists mainly to be\n",
      "numpy.ma.mvoid.toflex\n",
      "    Transforms a masked array into a flexible-type array.\n",
      "numpy.lib.format.magic\n",
      "    Return the magic string for the given file format version.\n",
      "numpy.ma.mvoid.reshape\n",
      "    Give a new shape to the array without changing its data.\n",
      "numpy.double.as_integer_ratio\n",
      "    Return a pair of integers, whose ratio is exactly equal to the original\n",
      "numpy.distutils.command.sdist.sdist.get_sub_commands\n",
      "    Determine the sub-commands that are relevant in the current\n",
      "numpy.ma.mvoid.torecords\n",
      "    Transforms a masked array into a flexible-type array.\n",
      "numpy.lib.format.read_magic\n",
      "    Read the magic string to get the version of the file format.\n",
      "numpy.distutils.command.develop.develop.get_sub_commands\n",
      "    Determine the sub-commands that are relevant in the current\n",
      "numpy.ma.MaskedArray.toflex\n",
      "    Transforms a masked array into a flexible-type array.\n",
      "numpy.distutils.command.install.install.get_sub_commands\n",
      "    Determine the sub-commands that are relevant in the current\n",
      "numpy.lib.format.open_memmap\n",
      "    Open a .npy file as a memory-mapped array.\n",
      "numpy.ma.MaskedArray.reshape\n",
      "    Give a new shape to the array without changing its data.\n",
      "numpy.polynomial.Hermite.fit\n",
      "    Least squares fit to data.\n",
      "numpy.distutils.command.egg_info.egg_info.get_sub_commands\n",
      "    Determine the sub-commands that are relevant in the current\n",
      "numpy.polynomial.Hermite._der\n",
      "    Differentiate a Hermite series.\n",
      "numpy.polynomial.Hermite._fit\n",
      "    Least squares fit of Hermite series to data.\n",
      "numpy.polynomial.Hermite._int\n",
      "    Integrate a Hermite series.\n",
      "numpy.polynomial.HermiteE.fit\n",
      "    Least squares fit to data.\n",
      "numpy.polynomial.Laguerre.fit\n",
      "    Least squares fit to data.\n",
      "numpy.polynomial.Legendre.fit\n",
      "    Least squares fit to data.\n",
      "numpy.distutils.command.egg_info.egg_info.save_version_info\n",
      "    Materialize the values of svn_revision and date into the\n",
      "numpy.ma.MaskedArray.torecords\n",
      "    Transforms a masked array into a flexible-type array.\n",
      "numpy.polynomial.HermiteE._fit\n",
      "    Least squares fit of Hermite series to data.\n",
      "numpy.polynomial.Laguerre._fit\n",
      "    Least squares fit of Laguerre series to data.\n",
      "numpy.polynomial.Legendre._fit\n",
      "    Least squares fit of Legendre series to data.\n",
      "numpy.polynomial.Chebyshev._fit\n",
      "    Least squares fit of Chebyshev series to data.\n",
      "numpy.polynomial.Polynomial.fit\n",
      "    Least squares fit to data.\n",
      "numpy.polynomial.Polynomial._fit\n",
      "    Least-squares fit of a polynomial to data.\n",
      "numpy.linalg._umath_linalg.slogdet\n",
      "    slogdet on the last two dimensions and broadcast on the rest.\n",
      "numpy.polynomial.hermite.hermgauss\n",
      "    Gauss-Hermite quadrature.\n",
      "numpy.polynomial.laguerre.laggauss\n",
      "    Gauss-Laguerre quadrature.\n",
      "numpy.polynomial.legendre.leggauss\n",
      "    Gauss-Legendre quadrature.\n",
      "numpy.distutils.command.config_compiler.config_cc.get_sub_commands\n",
      "    Determine the sub-commands that are relevant in the current\n",
      "numpy.distutils.command.config_compiler.config_fc.get_sub_commands\n",
      "    Determine the sub-commands that are relevant in the current\n",
      "numpy.distutils.command.install_clib.install_clib.get_sub_commands\n",
      "    Determine the sub-commands that are relevant in the current\n",
      "numpy.distutils.command.install_data.install_data.get_sub_commands\n",
      "    Determine the sub-commands that are relevant in the current\n",
      "numpy.polynomial.polyutils.getdomain\n",
      "    Return a domain suitable for given abscissae.\n",
      "numpy.polynomial.polyutils.mapdomain\n",
      "    Apply linear map to input points.\n",
      "numpy.polynomial.hermite_e.hermegauss\n",
      "    Gauss-HermiteE quadrature.\n",
      "numpy.distutils.command.build_scripts.build_scripts.get_sub_commands\n",
      "    Determine the sub-commands that are relevant in the current\n",
      "numpy.polynomial.Polynomial._fromroots\n",
      "    Generate a monic polynomial with given roots.\n",
      "numpy.distutils.command.install_headers.install_headers.get_sub_commands\n",
      "    Determine the sub-commands that are relevant in the current\n",
      "numpy.distutils.ccompiler.CCompiler_get_version\n",
      "    Return compiler version, or None if compiler is not available.\n",
      "numpy.lib._datasource.Repository.exists\n",
      "    Test if path exists prepending Repository base URL to path.\n",
      "numpy.lib._iotools.StringConverter.upgrade\n",
      "    Find the best converter for a given string, and return the result.\n",
      "numpy.distutils.msvccompiler.MSVCCompiler.get_version\n",
      "    Return compiler version, or None if compiler is not available.\n",
      "numpy.distutils.msvc9compiler.MSVCCompiler.get_version\n",
      "    Return compiler version, or None if compiler is not available.\n",
      "numpy.distutils.mingw32ccompiler.Mingw32CCompiler.get_version\n",
      "    Return compiler version, or None if compiler is not available.\n",
      "numpy.distutils.intelccompiler.IntelCCompiler.get_version\n",
      "    Return compiler version, or None if compiler is not available.\n",
      "numpy.distutils.intelccompiler.IntelCCompilerW.get_version\n",
      "    Return compiler version, or None if compiler is not available.\n",
      "numpy.distutils.misc_util.Configuration.add_npy_pkg_config\n",
      "    Generate and install a npy-pkg config file from a template.\n",
      "numpy.distutils.pathccompiler.PathScaleCCompiler.get_version\n",
      "    Return compiler version, or None if compiler is not available.\n",
      "numpy.distutils.intelccompiler.IntelEM64TCCompiler.get_version\n",
      "    Return compiler version, or None if compiler is not available.\n",
      "numpy.distutils.intelccompiler.IntelEM64TCCompilerW.get_version\n",
      "    Return compiler version, or None if compiler is not available.\n",
      "numpy.distutils.intelccompiler.IntelItaniumCCompiler.get_version\n",
      "    Return compiler version, or None if compiler is not available.\n",
      "numpy.distutils.numpy_distribution.NumpyDistribution.parse_command_line\n",
      "    Parse the setup script's command line, taken from the"
     ]
    }
   ],
   "source": [
    "z = np.random.random([10,10])\n",
    "print(\"z: \",z)\n",
    "print(np.min(z), np.max(z))\n",
    "zmin, zmax = z.min(), z.max()\n",
    "print(zmin,zmax)\n",
    "#np.info(np)\n",
    "#np.lookfor('min')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 14. Create a random vector of size 30 and find the mean value (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.87131907  0.52812403  0.03690621  0.10468752  0.90932666  0.53350117\n",
      "  0.23641994  0.76542064  0.37976455  0.49526945  0.66781125  0.25780206\n",
      "  0.02431297  0.13850757  0.57380289  0.40361028  0.06611629  0.41731806\n",
      "  0.18666186  0.74990096  0.63372911  0.6144356   0.37945078  0.27245057\n",
      "  0.91329837  0.83730127  0.19942378  0.16017709  0.90552318  0.75269637]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.46716898514752242"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.random.random(30)\n",
    "print(z)\n",
    "z.size\n",
    "#z.shape\n",
    "z.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 15. Create a 2d array with 1 on the border and 0 inside (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  0.]\n",
      " [ 0.  0.  0.]\n",
      " [ 0.  0.  0.]]\n",
      "[[ 1.  1.  1.]\n",
      " [ 0.  0.  0.]\n",
      " [ 1.  1.  1.]]\n",
      "[[ 1.  1.  1.]\n",
      " [ 1.  0.  1.]\n",
      " [ 1.  1.  1.]]\n",
      "[[ 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": [
    "z = np.zeros((3,3))\n",
    "print(z)\n",
    "z[0] = 1\n",
    "z[2] = 1\n",
    "print(z)\n",
    "z[:,0] = 1\n",
    "z[:,2] = 1\n",
    "print(z)\n",
    "\n",
    "z = np.ones((10,10))\n",
    "z[1:-1,1:-1] = 0\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 16. How to add a border (filled with 0's) around an existing array? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "[[ 0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
      " [ 0.  0.  1.  1.  1.  1.  1.  0.  0.]\n",
      " [ 0.  0.  1.  1.  1.  1.  1.  0.  0.]\n",
      " [ 0.  0.  1.  1.  1.  1.  1.  0.  0.]\n",
      " [ 0.  0.  1.  1.  1.  1.  1.  0.  0.]\n",
      " [ 0.  0.  1.  1.  1.  1.  1.  0.  0.]\n",
      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.]]\n",
      "[[ 0.  0.  0.  0.  0.  0.  0.]\n",
      " [ 0.  1.  1.  1.  1.  1.  0.]\n",
      " [ 0.  1.  1.  1.  1.  1.  0.]\n",
      " [ 0.  1.  1.  1.  1.  1.  0.]\n",
      " [ 0.  1.  1.  1.  1.  1.  0.]\n",
      " [ 0.  1.  1.  1.  1.  1.  0.]\n",
      " [ 0.  0.  0.  0.  0.  0.  0.]]\n",
      " pad(array, pad_width, mode, **kwargs)\n",
      "\n",
      "Pads an array.\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "array : array_like of rank N\n",
      "    Input array\n",
      "pad_width : {sequence, array_like, int}\n",
      "    Number of values padded to the edges of each axis.\n",
      "    ((before_1, after_1), ... (before_N, after_N)) unique pad widths\n",
      "    for each axis.\n",
      "    ((before, after),) yields same before and after pad for each axis.\n",
      "    (pad,) or int is a shortcut for before = after = pad width for all\n",
      "    axes.\n",
      "mode : str or function\n",
      "    One of the following string values or a user supplied function.\n",
      "\n",
      "    'constant'\n",
      "        Pads with a constant value.\n",
      "    'edge'\n",
      "        Pads with the edge values of array.\n",
      "    'linear_ramp'\n",
      "        Pads with the linear ramp between end_value and the\n",
      "        array edge value.\n",
      "    'maximum'\n",
      "        Pads with the maximum value of all or part of the\n",
      "        vector along each axis.\n",
      "    'mean'\n",
      "        Pads with the mean value of all or part of the\n",
      "        vector along each axis.\n",
      "    'median'\n",
      "        Pads with the median value of all or part of the\n",
      "        vector along each axis.\n",
      "    'minimum'\n",
      "        Pads with the minimum value of all or part of the\n",
      "        vector along each axis.\n",
      "    'reflect'\n",
      "        Pads with the reflection of the vector mirrored on\n",
      "        the first and last values of the vector along each\n",
      "        axis.\n",
      "    'symmetric'\n",
      "        Pads with the reflection of the vector mirrored\n",
      "        along the edge of the array.\n",
      "    'wrap'\n",
      "        Pads with the wrap of the vector along the axis.\n",
      "        The first values are used to pad the end and the\n",
      "        end values are used to pad the beginning.\n",
      "    <function>\n",
      "        Padding function, see Notes.\n",
      "stat_length : sequence or int, optional\n",
      "    Used in 'maximum', 'mean', 'median', and 'minimum'.  Number of\n",
      "    values at edge of each axis used to calculate the statistic value.\n",
      "\n",
      "    ((before_1, after_1), ... (before_N, after_N)) unique statistic\n",
      "    lengths for each axis.\n",
      "\n",
      "    ((before, after),) yields same before and after statistic lengths\n",
      "    for each axis.\n",
      "\n",
      "    (stat_length,) or int is a shortcut for before = after = statistic\n",
      "    length for all axes.\n",
      "\n",
      "    Default is ``None``, to use the entire axis.\n",
      "constant_values : sequence or int, optional\n",
      "    Used in 'constant'.  The values to set the padded values for each\n",
      "    axis.\n",
      "\n",
      "    ((before_1, after_1), ... (before_N, after_N)) unique pad constants\n",
      "    for each axis.\n",
      "\n",
      "    ((before, after),) yields same before and after constants for each\n",
      "    axis.\n",
      "\n",
      "    (constant,) or int is a shortcut for before = after = constant for\n",
      "    all axes.\n",
      "\n",
      "    Default is 0.\n",
      "end_values : sequence or int, optional\n",
      "    Used in 'linear_ramp'.  The values used for the ending value of the\n",
      "    linear_ramp and that will form the edge of the padded array.\n",
      "\n",
      "    ((before_1, after_1), ... (before_N, after_N)) unique end values\n",
      "    for each axis.\n",
      "\n",
      "    ((before, after),) yields same before and after end values for each\n",
      "    axis.\n",
      "\n",
      "    (constant,) or int is a shortcut for before = after = end value for\n",
      "    all axes.\n",
      "\n",
      "    Default is 0.\n",
      "reflect_type : {'even', 'odd'}, optional\n",
      "    Used in 'reflect', and 'symmetric'.  The 'even' style is the\n",
      "    default with an unaltered reflection around the edge value.  For\n",
      "    the 'odd' style, the extented part of the array is created by\n",
      "    subtracting the reflected values from two times the edge value.\n",
      "\n",
      "Returns\n",
      "-------\n",
      "pad : ndarray\n",
      "    Padded array of rank equal to `array` with shape increased\n",
      "    according to `pad_width`.\n",
      "\n",
      "Notes\n",
      "-----\n",
      ".. versionadded:: 1.7.0\n",
      "\n",
      "For an array with rank greater than 1, some of the padding of later\n",
      "axes is calculated from padding of previous axes.  This is easiest to\n",
      "think about with a rank 2 array where the corners of the padded array\n",
      "are calculated by using padded values from the first axis.\n",
      "\n",
      "The padding function, if used, should return a rank 1 array equal in\n",
      "length to the vector argument with padded values replaced. It has the\n",
      "following signature::\n",
      "\n",
      "    padding_func(vector, iaxis_pad_width, iaxis, **kwargs)\n",
      "\n",
      "where\n",
      "\n",
      "    vector : ndarray\n",
      "        A rank 1 array already padded with zeros.  Padded values are\n",
      "        vector[:pad_tuple[0]] and vector[-pad_tuple[1]:].\n",
      "    iaxis_pad_width : tuple\n",
      "        A 2-tuple of ints, iaxis_pad_width[0] represents the number of\n",
      "        values padded at the beginning of vector where\n",
      "        iaxis_pad_width[1] represents the number of values padded at\n",
      "        the end of vector.\n",
      "    iaxis : int\n",
      "        The axis currently being calculated.\n",
      "    kwargs : misc\n",
      "        Any keyword arguments the function requires.\n",
      "\n",
      "Examples\n",
      "--------\n",
      ">>> a = [1, 2, 3, 4, 5]\n",
      ">>> np.lib.pad(a, (2,3), 'constant', constant_values=(4, 6))\n",
      "array([4, 4, 1, 2, 3, 4, 5, 6, 6, 6])\n",
      "\n",
      ">>> np.lib.pad(a, (2, 3), 'edge')\n",
      "array([1, 1, 1, 2, 3, 4, 5, 5, 5, 5])\n",
      "\n",
      ">>> np.lib.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))\n",
      "array([ 5,  3,  1,  2,  3,  4,  5,  2, -1, -4])\n",
      "\n",
      ">>> np.lib.pad(a, (2,), 'maximum')\n",
      "array([5, 5, 1, 2, 3, 4, 5, 5, 5])\n",
      "\n",
      ">>> np.lib.pad(a, (2,), 'mean')\n",
      "array([3, 3, 1, 2, 3, 4, 5, 3, 3])\n",
      "\n",
      ">>> np.lib.pad(a, (2,), 'median')\n",
      "array([3, 3, 1, 2, 3, 4, 5, 3, 3])\n",
      "\n",
      ">>> a = [[1, 2], [3, 4]]\n",
      ">>> np.lib.pad(a, ((3, 2), (2, 3)), 'minimum')\n",
      "array([[1, 1, 1, 2, 1, 1, 1],\n",
      "       [1, 1, 1, 2, 1, 1, 1],\n",
      "       [1, 1, 1, 2, 1, 1, 1],\n",
      "       [1, 1, 1, 2, 1, 1, 1],\n",
      "       [3, 3, 3, 4, 3, 3, 3],\n",
      "       [1, 1, 1, 2, 1, 1, 1],\n",
      "       [1, 1, 1, 2, 1, 1, 1]])\n",
      "\n",
      ">>> a = [1, 2, 3, 4, 5]\n",
      ">>> np.lib.pad(a, (2, 3), 'reflect')\n",
      "array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])\n",
      "\n",
      ">>> np.lib.pad(a, (2, 3), 'reflect', reflect_type='odd')\n",
      "array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8])\n",
      "\n",
      ">>> np.lib.pad(a, (2, 3), 'symmetric')\n",
      "array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])\n",
      "\n",
      ">>> np.lib.pad(a, (2, 3), 'symmetric', reflect_type='odd')\n",
      "array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])\n",
      "\n",
      ">>> np.lib.pad(a, (2, 3), 'wrap')\n",
      "array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])\n",
      "\n",
      ">>> def padwithtens(vector, pad_width, iaxis, kwargs):\n",
      "...     vector[:pad_width[0]] = 10\n",
      "...     vector[-pad_width[1]:] = 10\n",
      "...     return vector\n",
      "\n",
      ">>> a = np.arange(6)\n",
      ">>> a = a.reshape((2, 3))\n",
      "\n",
      ">>> np.lib.pad(a, 2, padwithtens)\n",
      "array([[10, 10, 10, 10, 10, 10, 10],\n",
      "       [10, 10, 10, 10, 10, 10, 10],\n",
      "       [10, 10,  0,  1,  2, 10, 10],\n",
      "       [10, 10,  3,  4,  5, 10, 10],\n",
      "       [10, 10, 10, 10, 10, 10, 10],\n",
      "       [10, 10, 10, 10, 10, 10, 10]])\n"
     ]
    }
   ],
   "source": [
    "ndim = len(z)\n",
    "print(ndim)\n",
    "az = np.zeros((ndim+2,ndim+2))\n",
    "az[1:-1,1:-1] = z\n",
    "print(az)\n",
    "\n",
    "z = np.ones((5,5))\n",
    "z = np.pad(z, pad_width = 1, mode=\"constant\", constant_values = 0)\n",
    "print(z)\n",
    "np.info(np.pad)"
   ]
  },
  {
   "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",
    "0.3 == 3 * 0.1\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 19. Create a 8x8 matrix and fill it with a checkerboard pattern (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 21. Create a checkerboard 8x8 matrix using the tile function (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 22. Normalize a 5x5 random matrix (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 23. Create a custom dtype that describes a color as four unisgned bytes (RGBA) (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 24. Multiply a 5x3 matrix by a 3x2 matrix (real matrix product) (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 29. How to round away from zero a float array ? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 30. How to find common values between two arrays? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 31. How to ignore all numpy warnings (not recommended)? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 33. How to get the dates of yesterday, today and tomorrow? (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "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": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 35. How to compute ((A+B)\\*(-A/2)) in place (without copy)? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 36. Extract the integer part of a random array using 5 different methods (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 37. Create a 5x5 matrix with row values ranging from 0 to 4 (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 40. Create a random vector of size 10 and sort it (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 41. How to sum a small array faster than np.sum? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 42. Consider two random array A anb B, check if they are equal (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 43. Make an array immutable (read-only) (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 44. Consider a random 10x2 matrix representing cartesian coordinates, convert them to polar coordinates (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 45. Create random vector of size 10 and replace the maximum value by 0 (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 48. Print the minimum and maximum representable value for each numpy scalar type (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 49. How to print all the values of an array? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 50. How to find the closest value (to a given scalar) in an array? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 55. What is the equivalent of enumerate for numpy arrays? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 56. Generate a generic 2D Gaussian-like array (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 57. How to randomly place p elements in a 2D array? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 58. Subtract the mean of each row of a matrix (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 59. How to I sort an array by the nth column? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 60. How to tell if a given 2D array has null columns? (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 61. Find the nearest value from a given value in an array (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 63. Create an array class that has a name attribute (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": {
    "collapsed": false
   },
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 69. How to get the diagonal of a dot product? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 72. How to swap two rows of an array? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 75. How to compute averages using a sliding window over an array? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 82. Compute a matrix rank (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 83. How to find the most frequent value in an array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 84. Extract all the contiguous 3x3 blocks from a random 10x10 matrix (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 85. Create a 2D array subclass such that Z\\[i,j\\] == Z\\[j,i\\] (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 88. How to implement the Game of Life using numpy arrays? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 89. How to get the n largest values of an array (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 91. How to create a record array from a regular array? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 95. Convert a vector of ints into a matrix binary representation (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 96. Given a two dimensional array, how to extract unique rows? (★★★)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}