sem07_numpy/sem08_209-2012_more-numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Решаем-задачи\" data-toc-modified-id=\"Решаем-задачи-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Решаем задачи</a></span><ul class=\"toc-item\"><li><span><a href=\"#Задачи-с-семинара\" data-toc-modified-id=\"Задачи-с-семинара-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Задачи с семинара</a></span><ul class=\"toc-item\"><li><span><a href=\"#A\" data-toc-modified-id=\"A-1.1.1\"><span class=\"toc-item-num\">1.1.1&nbsp;&nbsp;</span>A</a></span></li><li><span><a href=\"#B\" data-toc-modified-id=\"B-1.1.2\"><span class=\"toc-item-num\">1.1.2&nbsp;&nbsp;</span>B</a></span></li><li><span><a href=\"#C\" data-toc-modified-id=\"C-1.1.3\"><span class=\"toc-item-num\">1.1.3&nbsp;&nbsp;</span>C</a></span></li><li><span><a href=\"#D\" data-toc-modified-id=\"D-1.1.4\"><span class=\"toc-item-num\">1.1.4&nbsp;&nbsp;</span>D</a></span></li></ul></li><li><span><a href=\"#Задачи-с-контеста\" data-toc-modified-id=\"Задачи-с-контеста-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Задачи с контеста</a></span><ul class=\"toc-item\"><li><span><a href=\"#A\" data-toc-modified-id=\"A-1.2.1\"><span class=\"toc-item-num\">1.2.1&nbsp;&nbsp;</span>A</a></span></li><li><span><a href=\"#B\" data-toc-modified-id=\"B-1.2.2\"><span class=\"toc-item-num\">1.2.2&nbsp;&nbsp;</span>B</a></span></li><li><span><a href=\"#C\" data-toc-modified-id=\"C-1.2.3\"><span class=\"toc-item-num\">1.2.3&nbsp;&nbsp;</span>C</a></span></li><li><span><a href=\"#D\" data-toc-modified-id=\"D-1.2.4\"><span class=\"toc-item-num\">1.2.4&nbsp;&nbsp;</span>D</a></span></li><li><span><a href=\"#i(lya)\" data-toc-modified-id=\"i(lya)-1.2.5\"><span class=\"toc-item-num\">1.2.5&nbsp;&nbsp;</span>i(lya)</a></span></li><li><span><a href=\"#E\" data-toc-modified-id=\"E-1.2.6\"><span class=\"toc-item-num\">1.2.6&nbsp;&nbsp;</span>E</a></span></li></ul></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Решаем задачи\n",
    "\n",
    "В будущем вы будете учить анализ данных. Там неожиданно выяснится, что любые данные - это матрица. Там-то вы и увидите впервые всю мощь numpy. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задачи с семинара"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A\n",
    "\n",
    "Реализуйте функцию, возвращающую максимальный элемент в векторе $x$ среди элементов, перед которыми стоит нулевой. \n",
    "\n",
    "Например, для `x = np.array([6, 2, 0, 3, 0, 0, 5, 7, 0])` ответом является `5`. Если нулевых элементов нет, функция должна возвращать `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 2, 0, 3, 0, 0, 5, 7, 0])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Тут должен появиться ваш код\n",
    "x = np.array([6, 2, 0, 3, 0, 0, 5, 7, 0])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True, False,  True,  True, False, False,  True])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zero_mask = x==0\n",
    "zero_mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[zero_mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "boolean index did not match indexed array along dimension 0; dimension is 8 but corresponding boolean dimension is 9",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-a4faead1e29e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mzero_mask\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: boolean index did not match indexed array along dimension 0; dimension is 8 but corresponding boolean dimension is 9"
     ]
    }
   ],
   "source": [
    "x[1:][zero_mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True, False,  True,  True, False, False])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zero_mask[:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 0, 5])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1:][zero_mask[:-1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(x[1:][zero_mask[:-1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(x[1:][(x==0)[:-1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y=[]\n",
    "for i in range(len(x)-1):\n",
    "    if x[i] == 0:\n",
    "        y.append(x[i+1])\n",
    "max(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Зачем?__ \n",
    "\n",
    "К вам в голову тут должна была прийти мысль: \"Зачем? Можно же использовать цикл!\". Да, можно. Но векторные вычисления работают на порядок быстрее. Часто сделать их намного удобнее, чем написать цикл."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### B\n",
    "\n",
    "Есть матрица $X$. Нужно отнормировать её столбцы к отрезку $[0;1]:$\n",
    "\n",
    "$$\n",
    "x^{*} = \\frac{x−min(x)}{max(x)−min(x)}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Тут должен появиться ваш код"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Зачем?__ \n",
    "\n",
    "К вам в голову тут должна была прийти мысль: \"Зачем вообще делать это?\". \n",
    "\n",
    "Обычно в машинном обучении по строчкам записывают наблюдения, по столбцам разные признаки. Часто между объектами надо считать расстояния. Представим, что у нас в выборке два наблюдения. Петя, который весит $50$ кг при росте $1$ метр. И Вася, который вести $75$ кг при росте в $1.5$ метра. То есть Петя описывается вектором $(50, 1)$, а Вася $(75, 1.5)$. \n",
    "\n",
    "Если нам надо вычислить между парнями расстояние, мы будем делать это так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "625\n",
      "0.25\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "625.25"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print((50 - 75) ** 2)\n",
    "print((1 - 1.5) ** 2)\n",
    "(50 - 75) ** 2 + (1 - 1.5) ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Намного больше внимания уделяется весу. Чтобы такого не возникало, надо отнормировать все признаки к одной шкале. Например, отрезку $[0;1]$. \n",
    "\n",
    "> Если хотите узнать о том как линал используется в машинном обучении больше, смотрите небольшой видос про рекомендательные системы [\"От матрицы до больших данных\"](https://www.youtube.com/watch?v=Or119IXozCM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 16.07325656, -22.7440394 ],\n",
       "       [ 29.85056617,  26.46673564],\n",
       "       [-16.90729302,  20.53992559],\n",
       "       [-13.28568007,  55.0808449 ],\n",
       "       [  9.62728055,  11.59104509],\n",
       "       [ -4.27369288, -18.65179728],\n",
       "       [  0.6685228 ,  41.84832384],\n",
       "       [ -9.11114524,  30.22979786],\n",
       "       [-30.83617946,  -6.78378467],\n",
       "       [  6.57437127,  15.96371561]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.normal(loc=10, scale=20, size=(10,2))\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 2)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "minn = A.min(axis=0)\n",
    "maxx = A.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-30.83617946, -22.7440394 ])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([29.85056617, 55.0808449 ])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maxx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2,)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minn.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[46.90943601,  0.        ],\n",
       "       [60.68674562, 49.21077504],\n",
       "       [13.92888644, 43.28396499],\n",
       "       [17.55049939, 77.8248843 ],\n",
       "       [40.46346001, 34.3350845 ],\n",
       "       [26.56248658,  4.09224213],\n",
       "       [31.50470226, 64.59236324],\n",
       "       [21.72503422, 52.97383727],\n",
       "       [ 0.        , 15.96025474],\n",
       "       [37.41055072, 38.70775502]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A-minn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.77297663, 0.        ],\n",
       "       [1.        , 0.63232699],\n",
       "       [0.22952106, 0.55617127],\n",
       "       [0.28919823, 1.        ],\n",
       "       [0.66675943, 0.44118388],\n",
       "       [0.43769832, 0.05258269],\n",
       "       [0.51913646, 0.82997057],\n",
       "       [0.35798648, 0.68067994],\n",
       "       [0.        , 0.20507907],\n",
       "       [0.6164534 , 0.4973699 ]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(A-minn)/(maxx-minn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C\n",
    "\n",
    "Реализуйте функцию, принимающую на вход матрицу $X$ и некоторое число $a$ и возвращающую ближайший к числу элемент матрицы. А потом перепишите её так, чтобы она возвращала самый дальний элемент. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Тут должен появиться ваш код\n",
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8, 2, 6, 3, 4],\n",
       "       [5, 5, 2, 6, 3]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.random.poisson(lam=5, size=(2,5))\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = np.abs(a-X).argmin()\n",
    "X.ravel()[index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.ravel()[np.abs(a-X).argmax()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8, 2, 6, 3, 4, 5, 5, 2, 6, 3])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.ravel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8, 2, 6, 3, 4, 5, 5, 2, 6, 3])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.reshape(1,-1)[0,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.reshape(1,-1)[0,np.abs(a-X).argmax()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### D\n",
    "\n",
    "Усложним предыдущую задачу! Дана матрица $X$ и вектор $v$. Нужно найти в матрице $X$ строку, которая будет ближе всего к вектору $v$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Тут должен появиться ваш код"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  1,  7,  7,  4],\n",
       "       [ 4,  7,  5,  5,  6],\n",
       "       [ 5,  9,  4,  2,  4],\n",
       "       [ 5,  8, 11,  6,  2],\n",
       "       [ 9,  7,  6,  3,  2],\n",
       "       [ 1,  6,  1, 12,  5],\n",
       "       [ 2,  5,  7,  9,  6],\n",
       "       [ 4,  3,  3,  9,  5],\n",
       "       [ 2,  2, 11,  5,  1],\n",
       "       [ 4,  5,  6,  5,  6]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.random.poisson(lam=5, size=(10,5))\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 9, 7, 3, 4])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.random.poisson(lam=5, size=5)\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(X-v).sum(axis=1).argmin()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Зачем?__ \n",
    "\n",
    "Зачем вообще кому-то нужны задания 3 и 4?! В машинном обучения всюду вектора! Например, есть волшебная технология __word2vec__. В ней все слова превращают в вектора так, чтобы в них был закодирован смысл слова. В итоге неожиданно оказывается, что эти вектора можно складывать и вычитать. Если взять вектор _король_, вычесть из него _мужчина_ и добавить _женщина_, внезапно получится вектор, самым близким к которому является _королева_. \n",
    "\n",
    "Все эти вычисления удобно делать в `numpy`, написанными нами функциями. Поиграться с такой моделью и калькулятором слов можно [на сайте resvectores](https://rusvectores.org/ru/calculator/#)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задачи с контеста\n",
    "\n",
    "- Задачи из [необязательного контеста](https://official.contest.yandex.ru/contest/25960/enter/)\n",
    "- вас ждут простые и не очень задачи на numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "0 0 0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "x = np.array(list(map(float, input().split(\" \"))))\n",
    "y = np.array(list(map(float, input().split(\" \"))))\n",
    "\n",
    "\n",
    "print(1 if np.array_equal(x,y) else 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0.])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "65\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "n = int(input())\n",
    "print(np.arange(1,n**2+1).reshape(n,n).diagonal().sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10],\n",
       "       [11, 12, 13, 14, 15],\n",
       "       [16, 17, 18, 19, 20],\n",
       "       [21, 22, 23, 24, 25]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1,n**2+1).reshape(n,n)#.diagonal().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 0 0 4 0\n"
     ]
    }
   ],
   "source": [
    "x = np.array(list((map(float, input().split()))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(np.where(x!=0)[0].sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 -5 3\n"
     ]
    }
   ],
   "source": [
    "x = np.array(list((map(int, input().split()))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -5,  3])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros_like(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1, -5,  3],\n",
       "       [ 0,  0,  0]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([x,np.zeros_like(x)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  0],\n",
       "       [-5,  0],\n",
       "       [ 3,  0]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((x, np.zeros_like(x))).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0 -5 0 3\n"
     ]
    }
   ],
   "source": [
    "print(*np.vstack((x, np.zeros_like(x))).T.ravel()[:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### i(lya)\n",
    "\n",
    "- найти первые элементы ступенчатой матрицы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = '''100500 10 1 15 1\n",
    "0 0 228 222 2\n",
    "0 0 0 0 333'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[100500,     10,      1,     15,      1],\n",
       "       [     0,      0,    228,    222,      2],\n",
       "       [     0,      0,      0,      0,    333]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.array([list(map(int,x.split())) for x in s.split('\\n')])\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100500, 228, 333]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[X[i,np.where(X[i]!=0)[0][0]] for i in range(X.shape[0])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[np.where(X[i]!=0)[0][0] for i in range(X.shape[0])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100500 228 333\n"
     ]
    }
   ],
   "source": [
    "print(*[X[i,np.where(X[i]!=0)[0][0]] for i in range(X.shape[0])])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### E"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- для задачи нужно создать txt-файл в папке Downloads через jupyter как на скриншоте\n",
    "- код ниже прочитает файл оттуда и работа будет с ним\n",
    "\n",
    "<a href=\"https://imgbb.com/\"><img src=\"https://i.ibb.co/MG571X3/Screen-Shot-2021-03-25-at-21-47-13.png\" alt=\"Screen-Shot-2021-03-25-at-21-47-13\" border=\"0\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "file = open('/Users/UOUR_USERNAME/Downloads/input.txt','r') \n",
    "data = file.readlines()\n",
    "\n",
    "\n",
    "n,m = list(map(int,data[0].split()))\n",
    "X = np.array([list(map(int,x.split())) for x in data[1:]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 3)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n,m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 1],\n",
       "       [2, 0, 2],\n",
       "       [3, 0, 3],\n",
       "       [4, 4, 4]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "\n",
    "if all(X.diagonal()==0):\n",
    "    print(-1)\n",
    "else:\n",
    "    print(np.prod(np.where(X.diagonal()==0,1,X.diagonal())))"
   ]
  }
 ],
 "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.6.2"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}