Numpy_HW1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Sinrez/pyCoursera/blob/master/Numpy_HW1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TrP9QeNw91bd"
      },
      "source": [
        "## Внимание! Необходимо использовать функции numpy по-максимуму! И практически никаких циклов! Это практика, просто пытаемся сделать все, что можем.=)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5Gp7m7fo91bh"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import random\n",
        "import scipy.stats as spst"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WJlg5-Sg91bi"
      },
      "source": [
        "### 1. Отсортируйте все столбцы по нулевому столбцу:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kEaQljtv91bj",
        "outputId": "e2f68bdd-9457-4457-d5be-98ce332d0c33",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[9 8 4]\n",
            " [0 0 8]\n",
            " [3 2 1]\n",
            " [8 9 6]\n",
            " [0 4 6]]\n"
          ]
        }
      ],
      "source": [
        "np.random.seed(21)\n",
        "a = np.random.randint(0, 10, (5, 3))\n",
        "print(a)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1arE0xmj91bj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5830bd09-6579-4954-e1f6-2b22807c2f5c"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[4, 8, 9],\n",
              "       [0, 0, 8],\n",
              "       [1, 2, 3],\n",
              "       [6, 8, 9],\n",
              "       [0, 4, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "np.sort(a)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.sort(a, axis= 0) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N3VLDl58d9iU",
        "outputId": "7310f4e7-b5ff-45ee-e515-c9927f3daf95"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 0, 1],\n",
              "       [0, 2, 4],\n",
              "       [3, 4, 6],\n",
              "       [8, 8, 6],\n",
              "       [9, 9, 8]])"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KWvVHoz991bk"
      },
      "source": [
        "### 2. Найти наиболее частое значение в массиве"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VWBWxhVk91bk",
        "outputId": "8f6359f8-ca3f-4408-b7e1-a148a950747a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([14, 19, 10, 19, 14, 19, 10, 11, 13, 18])"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "lt = np.random.randint(10, 20, size = 10)\n",
        "lt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.argmax(np.bincount(lt))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z-WwwyB-SD4b",
        "outputId": "da453233-73cf-4525-811c-7bdc1617d950"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "19"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "puj31_EC91bl"
      },
      "source": [
        "### 3. Даны наборы точек x (`X`) и y (`Y`). Каждый набор описывает прямую i (X[i], Y[i]). Найти расстояние от точки `р` до каждой прямой."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V6ELB4IV91bm"
      },
      "outputs": [],
      "source": [
        "def distance(P0, P1, p):\n",
        "    # Дописать код здесь\n",
        "    T = P1 - P0\n",
        "    L = (T**2).sum(axis=1)\n",
        "    U = -((P0[:,0] - p[...,0]) * T[:,0] + (P0[:,1] - p[...,1]) * T[:,1]) / L\n",
        "    U = U.reshape(len(U),1)\n",
        "    D = P0 + U * T - p\n",
        "    return np.sqrt((D**2).sum(axis=1))\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "v7AVTxQu91bm",
        "outputId": "8c53fcf0-3a74-4341-ae94-0a21179cf89c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3.17492359 5.34157116 4.3954823  4.44992119 1.36240759 9.62023067\n",
            " 4.33456319 7.98682002 0.30570239 6.34123228]\n"
          ]
        }
      ],
      "source": [
        "P0 = np.random.uniform(-10,10,(10,2))\n",
        "P1 = np.random.uniform(-10,10,(10,2))\n",
        "p  = np.random.uniform(-10,10,( 1,2))\n",
        "print(distance(P0, P1, p))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8eXIawrF91bn"
      },
      "source": [
        "### 4. Найти n наибольших значений в массиве"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e0bj5RVu91bn",
        "outputId": "e2910d1e-ac00-44f6-8e78-ba6f20483388",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9999"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ],
      "source": [
        "Z = np.arange(10000)\n",
        "np.random.shuffle(Z)\n",
        "n = 5\n",
        "Z.max()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wztItIjI91bo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "88add502-aa1e-4945-b9e7-24fab1e46101"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([9995, 9996, 9997, 9998, 9999])"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "def n_max(a,n):\n",
        "  return a[a.argsort()[-n:]]\n",
        "\n",
        "n_max(Z,n)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zZ07oEmz91bo"
      },
      "source": [
        "### 5. Дан двумерный массив. Найти все различные строки"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5j4CGnSp91bo",
        "outputId": "803d5def-e88c-4539-df4a-a3dcc2ff87cc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0 0 1]\n",
            " [1 0 0]\n",
            " [0 0 1]\n",
            " [1 0 0]\n",
            " [1 0 0]\n",
            " [0 1 0]]\n"
          ]
        }
      ],
      "source": [
        "Z = np.random.randint(0, 2, (6,3))\n",
        "print(Z)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f1WV2z0s91bo",
        "outputId": "99e209f9-83e4-4115-b7f7-c1f8a8c6725d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 0, 1],\n",
              "       [0, 1, 0],\n",
              "       [1, 0, 0]])"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "# unique_rows = \n",
        "np.unique(Z, axis=0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YP2xeQw991bp"
      },
      "source": [
        "### 6. Разбить массив на убывающие подмассивы.  \n",
        "Подсказка: np.diff()  \n",
        "Используйте библиотеку `numpy`, не используйте циклы."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hUnx6fJh91bp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d6bceafc-8c09-48eb-8b17-5787f06b3a07"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[array([], dtype=int64),\n",
              " array([942]),\n",
              " array([675,  33]),\n",
              " array([765, 113]),\n",
              " array([478, 125]),\n",
              " array([548, 271]),\n",
              " array([929, 416]),\n",
              " array([855, 106, 549]),\n",
              " array([772, 241, 613]),\n",
              " array([783, 318, 640]),\n",
              " array([947]),\n",
              " array([606]),\n",
              " array([366,  40, 108]),\n",
              " array([798]),\n",
              " array([378, 324]),\n",
              " array([981]),\n",
              " array([866,  88]),\n",
              " array([845]),\n",
              " array([730,  32, 301]),\n",
              " array([723]),\n",
              " array([591, 332, 434]),\n",
              " array([917, 746]),\n",
              " array([826, 351, 904]),\n",
              " array([993, 540]),\n",
              " array([906,   7]),\n",
              " array([990,  52]),\n",
              " array([553]),\n",
              " array([515, 385]),\n",
              " array([956, 682]),\n",
              " array([923]),\n",
              " array([558, 225]),\n",
              " array([865, 261, 882]),\n",
              " array([893,  63]),\n",
              " array([751, 359]),\n",
              " array([894]),\n",
              " array([390]),\n",
              " array([337,  77, 624, 707]),\n",
              " array([972]),\n",
              " array([186,  57, 107, 174]),\n",
              " array([985, 381]),\n",
              " array([410, 206, 660]),\n",
              " array([844, 242]),\n",
              " array([969]),\n",
              " array([215, 100]),\n",
              " array([547]),\n",
              " array([421, 295, 637]),\n",
              " array([857, 618]),\n",
              " array([699, 569]),\n",
              " array([818, 380]),\n",
              " array([978]),\n",
              " array([711, 459]),\n",
              " array([583, 134, 384]),\n",
              " array([667, 303]),\n",
              " array([654]),\n",
              " array([564, 149, 344, 440]),\n",
              " array([812]),\n",
              " array([678]),\n",
              " array([551, 456]),\n",
              " array([816, 479]),\n",
              " array([838]),\n",
              " array([182]),\n",
              " array([136, 112, 214, 323, 645, 683, 914]),\n",
              " array([928,  93, 377]),\n",
              " array([912, 329]),\n",
              " array([679, 138, 589]),\n",
              " array([616]),\n",
              " array([155,  24]),\n",
              " array([596, 319, 527]),\n",
              " array([663,  69]),\n",
              " array([545]),\n",
              " array([347, 101]),\n",
              " array([946, 370, 466, 691]),\n",
              " array([767, 420, 796]),\n",
              " array([828, 827]),\n",
              " array([889, 117]),\n",
              " array([769, 146, 457]),\n",
              " array([988,   4]),\n",
              " array([848, 246]),\n",
              " array([363, 263]),\n",
              " array([266,  48]),\n",
              " array([868]),\n",
              " array([762,  50, 552]),\n",
              " array([652, 268, 689]),\n",
              " array([891, 139, 718]),\n",
              " array([968]),\n",
              " array([805]),\n",
              " array([750, 177]),\n",
              " array([994]),\n",
              " array([614,  91]),\n",
              " array([499, 204, 207]),\n",
              " array([688]),\n",
              " array([643]),\n",
              " array([283,  31]),\n",
              " array([653,  51]),\n",
              " array([778]),\n",
              " array([493, 389, 726]),\n",
              " array([911]),\n",
              " array([580]),\n",
              " array([327, 237]),\n",
              " array([680, 429]),\n",
              " array([869, 484]),\n",
              " array([704]),\n",
              " array([462,  47]),\n",
              " array([400, 296]),\n",
              " array([831, 284]),\n",
              " array([820, 299]),\n",
              " array([386, 343]),\n",
              " array([665,  54]),\n",
              " array([859, 137, 336]),\n",
              " array([791]),\n",
              " array([180,  36]),\n",
              " array([945, 693, 731]),\n",
              " array([921]),\n",
              " array([666]),\n",
              " array([590]),\n",
              " array([326, 162]),\n",
              " array([892]),\n",
              " array([822, 130, 170]),\n",
              " array([821,   1]),\n",
              " array([963]),\n",
              " array([875, 521]),\n",
              " array([760, 256, 461]),\n",
              " array([582,  39, 269]),\n",
              " array([939,  74]),\n",
              " array([523, 498, 788]),\n",
              " array([932]),\n",
              " array([133,  62, 567]),\n",
              " array([841, 627, 685]),\n",
              " array([789]),\n",
              " array([776, 194, 426]),\n",
              " array([439, 259, 494]),\n",
              " array([973, 819]),\n",
              " array([886,  83, 341]),\n",
              " array([559, 220]),\n",
              " array([815]),\n",
              " array([340,  70, 320]),\n",
              " array([563, 322]),\n",
              " array([495, 118]),\n",
              " array([708, 668]),\n",
              " array([873]),\n",
              " array([768]),\n",
              " array([209,  29, 152, 278, 709, 787, 793, 801]),\n",
              " array([983, 165]),\n",
              " array([483]),\n",
              " array([307,  16]),\n",
              " array([745, 129, 388]),\n",
              " array([781, 418]),\n",
              " array([485]),\n",
              " array([89]),\n",
              " array([67, 18]),\n",
              " array([454, 193]),\n",
              " array([836]),\n",
              " array([309]),\n",
              " array([305, 121, 348]),\n",
              " array([867, 179]),\n",
              " array([644,  19, 358]),\n",
              " array([799, 289]),\n",
              " array([925]),\n",
              " array([629, 158]),\n",
              " array([774,   8]),\n",
              " array([565, 405, 506, 800]),\n",
              " array([864,  42]),\n",
              " array([843]),\n",
              " array([424,  99]),\n",
              " array([706]),\n",
              " array([500, 352]),\n",
              " array([379,  95, 311]),\n",
              " array([676, 310, 829, 924]),\n",
              " array([995]),\n",
              " array([55, 14]),\n",
              " array([671,  26]),\n",
              " array([975, 260, 460, 936]),\n",
              " array([954]),\n",
              " array([601, 419, 871]),\n",
              " array([926]),\n",
              " array([375, 298]),\n",
              " array([849,  60]),\n",
              " array([984]),\n",
              " array([719, 411]),\n",
              " array([901, 524]),\n",
              " array([850]),\n",
              " array([623, 465]),\n",
              " array([919]),\n",
              " array([650, 188]),\n",
              " array([809, 254]),\n",
              " array([291, 184]),\n",
              " array([566, 267]),\n",
              " array([943]),\n",
              " array([692]),\n",
              " array([355, 126, 451]),\n",
              " array([561, 228]),\n",
              " array([712, 490]),\n",
              " array([662, 342, 369, 759]),\n",
              " array([965, 279, 702]),\n",
              " array([884,  22]),\n",
              " array([447]),\n",
              " array([445, 367]),\n",
              " array([452, 102, 205, 413]),\n",
              " array([982,  90]),\n",
              " array([952]),\n",
              " array([576, 395]),\n",
              " array([455, 240, 903]),\n",
              " array([970]),\n",
              " array([792, 612, 940]),\n",
              " array([944]),\n",
              " array([394, 144]),\n",
              " array([728,  30,  49,  79]),\n",
              " array([577, 526]),\n",
              " array([810]),\n",
              " array([409, 111, 187]),\n",
              " array([840,  73, 353]),\n",
              " array([987, 175]),\n",
              " array([999]),\n",
              " array([646, 218]),\n",
              " array([958, 131]),\n",
              " array([694]),\n",
              " array([597, 302]),\n",
              " array([560, 417]),\n",
              " array([435, 270, 415]),\n",
              " array([853]),\n",
              " array([710, 603]),\n",
              " array([749, 280, 542]),\n",
              " array([631, 123]),\n",
              " array([236, 140]),\n",
              " array([670]),\n",
              " array([512, 397]),\n",
              " array([487,  13, 657]),\n",
              " array([811, 773]),\n",
              " array([880]),\n",
              " array([300, 292]),\n",
              " array([621]),\n",
              " array([345,  97, 150]),\n",
              " array([854]),\n",
              " array([839, 396]),\n",
              " array([775, 406]),\n",
              " array([554]),\n",
              " array([399, 148, 507]),\n",
              " array([938,  45, 316]),\n",
              " array([638, 233]),\n",
              " array([716]),\n",
              " array([571]),\n",
              " array([441, 226, 346, 517]),\n",
              " array([918]),\n",
              " array([733, 274]),\n",
              " array([957]),\n",
              " array([608]),\n",
              " array([588, 281, 509, 782]),\n",
              " array([794,  68]),\n",
              " array([519, 250]),\n",
              " array([960, 537]),\n",
              " array([610, 208]),\n",
              " array([402, 115]),\n",
              " array([916]),\n",
              " array([230, 224]),\n",
              " array([777, 619]),\n",
              " array([714, 109]),\n",
              " array([444, 222]),\n",
              " array([964, 325]),\n",
              " array([664]),\n",
              " array([600]),\n",
              " array([143,  56]),\n",
              " array([232, 156, 277]),\n",
              " array([896]),\n",
              " array([823]),\n",
              " array([471, 119, 229]),\n",
              " array([615, 497, 686]),\n",
              " array([872, 473, 568, 594]),\n",
              " array([876]),\n",
              " array([721]),\n",
              " array([387,  20, 356]),\n",
              " array([885, 371]),\n",
              " array([834]),\n",
              " array([361]),\n",
              " array([213,  44, 748]),\n",
              " array([847]),\n",
              " array([349, 244]),\n",
              " array([780, 581, 592]),\n",
              " array([713]),\n",
              " array([290]),\n",
              " array([211, 171]),\n",
              " array([393, 357, 480]),\n",
              " array([858]),\n",
              " array([763, 401]),\n",
              " array([757]),\n",
              " array([231, 132, 962]),\n",
              " array([967, 223, 555]),\n",
              " array([851, 265]),\n",
              " array([607]),\n",
              " array([448, 173]),\n",
              " array([258, 190]),\n",
              " array([797]),\n",
              " array([328, 272, 511]),\n",
              " array([974]),\n",
              " array([922, 330]),\n",
              " array([739, 486]),\n",
              " array([910]),\n",
              " array([315]),\n",
              " array([168,  66]),\n",
              " array([754, 423, 427, 681]),\n",
              " array([837,   5]),\n",
              " array([949]),\n",
              " array([846, 602]),\n",
              " array([898, 464]),\n",
              " array([877, 481]),\n",
              " array([907,   6, 442, 541, 955]),\n",
              " array([998, 333, 446]),\n",
              " array([915]),\n",
              " array([807, 795]),\n",
              " array([966]),\n",
              " array([703, 243]),\n",
              " array([525,  53, 201, 255, 407]),\n",
              " array([870]),\n",
              " array([251]),\n",
              " array([145, 122]),\n",
              " array([647]),\n",
              " array([338]),\n",
              " array([275, 164]),\n",
              " array([934, 504, 695]),\n",
              " array([900]),\n",
              " array([740, 505]),\n",
              " array([833, 157]),\n",
              " array([574]),\n",
              " array([475]),\n",
              " array([37, 34]),\n",
              " array([992]),\n",
              " array([655,  96, 503]),\n",
              " array([630, 334]),\n",
              " array([632,   3, 502]),\n",
              " array([535,  65]),\n",
              " array([687]),\n",
              " array([520, 432]),\n",
              " array([449, 262]),\n",
              " array([937]),\n",
              " array([720]),\n",
              " array([562]),\n",
              " array([468,  98]),\n",
              " array([895,  23, 543]),\n",
              " array([659, 488, 761]),\n",
              " array([887]),\n",
              " array([758, 105, 285]),\n",
              " array([364, 234]),\n",
              " array([673]),\n",
              " array([287, 199]),\n",
              " array([297, 110, 477]),\n",
              " array([908]),\n",
              " array([897, 496]),\n",
              " array([863]),\n",
              " array([609]),\n",
              " array([605, 463]),\n",
              " array([980, 587]),\n",
              " array([684, 546]),\n",
              " array([959,  92, 382, 604]),\n",
              " array([808, 404, 529]),\n",
              " array([961]),\n",
              " array([166, 160, 735]),\n",
              " array([989, 557]),\n",
              " array([813, 433]),\n",
              " array([953, 247]),\n",
              " array([437, 167]),\n",
              " array([492, 276]),\n",
              " array([510,  87]),\n",
              " array([856]),\n",
              " array([422,  46]),\n",
              " array([317, 178, 625]),\n",
              " array([913]),\n",
              " array([538]),\n",
              " array([264, 189, 518]),\n",
              " array([661, 185]),\n",
              " array([941, 294]),\n",
              " array([690,  58]),\n",
              " array([883, 408, 550, 617]),\n",
              " array([633, 570]),\n",
              " array([902]),\n",
              " array([530, 306]),\n",
              " array([933, 635]),\n",
              " array([824, 648]),\n",
              " array([770]),\n",
              " array([696, 513]),\n",
              " array([888, 335]),\n",
              " array([950]),\n",
              " array([622,  11, 245, 443]),\n",
              " array([698,  80]),\n",
              " array([715]),\n",
              " array([626, 403]),\n",
              " array([755, 476]),\n",
              " array([930, 198]),\n",
              " array([948, 360]),\n",
              " array([705]),\n",
              " array([425, 304]),\n",
              " array([997]),\n",
              " array([221, 191]),\n",
              " array([725,   9]),\n",
              " array([649]),\n",
              " array([516, 203]),\n",
              " array([737, 372]),\n",
              " array([736, 321]),\n",
              " array([825]),\n",
              " array([469]),\n",
              " array([453,  15, 248, 398]),\n",
              " array([764]),\n",
              " array([522, 176, 804]),\n",
              " array([806, 532]),\n",
              " array([677, 181]),\n",
              " array([528]),\n",
              " array([195,   0, 212]),\n",
              " array([431, 163]),\n",
              " array([861, 428]),\n",
              " array([470, 202]),\n",
              " array([732]),\n",
              " array([556,  21,  35,  84, 314]),\n",
              " array([599, 153]),\n",
              " array([368,  10]),\n",
              " array([722]),\n",
              " array([436,  81]),\n",
              " array([438, 159]),\n",
              " array([391]),\n",
              " array([169]),\n",
              " array([154,  85, 842]),\n",
              " array([996, 192]),\n",
              " array([674]),\n",
              " array([593]),\n",
              " array([252, 124]),\n",
              " array([879]),\n",
              " array([273, 253]),\n",
              " array([738]),\n",
              " array([595, 514, 579]),\n",
              " array([878]),\n",
              " array([860]),\n",
              " array([729, 200]),\n",
              " array([313, 288, 293]),\n",
              " array([927, 235, 472, 573]),\n",
              " array([817]),\n",
              " array([135, 120]),\n",
              " array([634,  61,  94, 744]),\n",
              " array([835,  71, 103]),\n",
              " array([374, 127]),\n",
              " array([790, 700]),\n",
              " array([977, 785]),\n",
              " array([852]),\n",
              " array([489,   2,  72,  78]),\n",
              " array([430]),\n",
              " array([249,  64, 458]),\n",
              " array([753]),\n",
              " array([697,  17, 116, 128]),\n",
              " array([786, 196]),\n",
              " array([450, 216]),\n",
              " array([354,  25, 238]),\n",
              " array([771]),\n",
              " array([339,  12, 636]),\n",
              " array([651]),\n",
              " array([227, 151, 373]),\n",
              " array([584, 219, 639]),\n",
              " array([766,  41]),\n",
              " array([414, 141]),\n",
              " array([658, 575]),\n",
              " array([909]),\n",
              " array([312, 257]),\n",
              " array([331,  43]),\n",
              " array([971]),\n",
              " array([482, 142]),\n",
              " array([832, 474]),\n",
              " array([986]),\n",
              " array([935,  59]),\n",
              " array([899, 586]),\n",
              " array([802, 376]),\n",
              " array([976, 350, 533, 724]),\n",
              " array([862]),\n",
              " array([365, 183, 282]),\n",
              " array([743]),\n",
              " array([412, 210]),\n",
              " array([741, 501]),\n",
              " array([534, 467]),\n",
              " array([642, 172]),\n",
              " array([830, 197]),\n",
              " array([931]),\n",
              " array([803, 286]),\n",
              " array([784, 598]),\n",
              " array([905]),\n",
              " array([308,  38]),\n",
              " array([727, 362]),\n",
              " array([572, 383, 539]),\n",
              " array([701]),\n",
              " array([585, 508]),\n",
              " array([578,  82]),\n",
              " array([611]),\n",
              " array([491, 239, 717]),\n",
              " array([890]),\n",
              " array([752]),\n",
              " array([747, 392]),\n",
              " array([672, 620]),\n",
              " array([669, 531]),\n",
              " array([881]),\n",
              " array([742]),\n",
              " array([86, 75]),\n",
              " array([756]),\n",
              " array([161, 114]),\n",
              " array([217, 104]),\n",
              " array([656,  27]),\n",
              " array([76, 28]),\n",
              " array([991]),\n",
              " array([641, 628]),\n",
              " array([874]),\n",
              " array([734, 544, 920]),\n",
              " array([951]),\n",
              " array([779]),\n",
              " array([536, 147, 814, 979])]"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "import numpy as np\n",
        "Z = np.arange(1000)\n",
        "np.random.shuffle(Z)\n",
        "a = np.diff(Z)\n",
        "c = np.where(a < 0)\n",
        "np.split(Z, c[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A2OM4bvI91bp"
      },
      "source": [
        "### 7. Дан массив arr, необходимо найти среднее значение внутри групп, группа определена массивом g. \n",
        "Например, для  \n",
        "`arr = [4, 2, 1, 5, 2, 5, 1, 3]` и   \n",
        "`g =   [0, 1, 1, 0, 1, 0, 1, 0]` (4 относится к группе 0, 2 к группе 1 и т. д.)   \n",
        "Средние по группам: `[4.25, 1.5]`  \n",
        "Подсказка: `np.bincount()`   \n",
        "Используйте библиотеку `numpy`, не используйте циклы."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "p8gvdueg91bq"
      },
      "outputs": [],
      "source": [
        "# Дописать код здесь\n",
        "# непонятно как решать, в сети не нашел понятных примеров"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q47pZyg791bq"
      },
      "source": [
        "### 8. Перемножить две квадратные матрицы двумя способами -- без использования пакета numpy и с ним. Сравнить время вычислений\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bdINXPFs91bq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b0114433-26b6-4844-83d4-302c631e9550"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[9 8 4]\n",
            " [0 0 8]\n",
            " [3 2 1]]\n",
            "------\n",
            "[[8 9 6]\n",
            " [0 4 6]\n",
            " [4 4 7]]\n"
          ]
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "np.random.seed(21)\n",
        "a = np.random.randint(0, 10, (3, 3))\n",
        "b = np.random.randint(0, 10, (3, 3))\n",
        "print(a)\n",
        "print('-' * 6)\n",
        "print(b)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# без np\n",
        "def matrixmult (A, B):\n",
        "    C = [[0 for row in range(len(A))] for col in range(len(B[0]))]\n",
        "    for i in range(len(A)):\n",
        "        for j in range(len(B[0])):\n",
        "            for k in range(len(B)):\n",
        "                C[i][j] += A[i][k]*B[k][j]\n",
        "    return C\n",
        "\n",
        "print(*matrixmult (a, b))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nQu5j0S80hN5",
        "outputId": "76a01d62-dab8-4553-dc8f-c2cc388eeef6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[88, 129, 130] [32, 32, 56] [28, 39, 37]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%timeit matrixmult (a, b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bMl7Bd5Y0rVU",
        "outputId": "b8484aab-2dfa-49ee-ea18-87ee8f8eb67a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10000 loops, best of 5: 37.9 µs per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# с np\n",
        "np.matmul(a, b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9Ifexz380uj_",
        "outputId": "e8c39385-56a5-41ed-dd46-ceb0ed8e7320"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 88, 129, 130],\n",
              "       [ 32,  32,  56],\n",
              "       [ 28,  39,  37]])"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%timeit np.matmul(a, b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d-vJJmSV0y2Z",
        "outputId": "aa0b97b1-1895-4b03-9eaf-11d3bc20ea55"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The slowest run took 71.78 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "1000000 loops, best of 5: 1.26 µs per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X4y-SIFl91bq"
      },
      "source": [
        "### 9. Написать функцию, которая по данной последовательности $\\{A_i\\}_{i=1}^n$ строит последовательность $S_n$, где $S_k = \\frac{A_1 + ... + A_k}{k}$.  \n",
        "Аналогично -- с помощью библиотеки **NumPy** и без нее. Сравните скорость."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TtBQ-04h91bq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "59a381b0-1d36-4936-f3a5-9a6ef4ede257"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.99836916 0.95266175 0.71172888 0.74290655 0.72772514 0.76102491\n",
            " 0.69756471 0.6664818  0.63662104 0.64421187 0.59968561 0.59431494\n",
            " 0.62378052 0.59166022 0.56394979 0.57868368 0.57693167 0.58426863\n",
            " 0.5951988  0.5828909  0.57460519 0.57527598 0.57850965 0.56943829\n",
            " 0.56681898 0.55744571 0.54431103 0.53821585 0.55269255 0.5415581\n",
            " 0.53656993 0.5203656  0.53437766 0.52053836 0.51603879 0.50496012\n",
            " 0.4965276  0.50524275 0.5069306  0.49849983 0.51069629 0.50721232\n",
            " 0.51640753 0.50945493 0.5139372  0.51596087 0.50999434 0.50438879\n",
            " 0.51201318 0.51841825 0.51390382 0.5168556  0.52109014 0.52786195\n",
            " 0.52158534 0.52918548 0.52064021 0.51240832 0.51585461 0.52103068\n",
            " 0.52817581 0.52331719 0.5193216  0.51390427 0.51028875 0.51698293\n",
            " 0.5136381  0.51303138 0.50907323 0.50707482 0.51137616 0.51223069\n",
            " 0.51267024 0.5179836  0.51849146 0.5214648  0.52320015 0.52867977\n",
            " 0.52355025 0.51964593 0.51929487 0.51445017 0.51869459 0.52359174\n",
            " 0.52509934 0.52787826 0.53065614 0.53504924 0.5340913  0.53313083\n",
            " 0.53701548 0.53243178 0.53298098 0.52780182 0.52658301 0.52132598\n",
            " 0.52214651 0.51711574 0.51594323 0.51456546]\n"
          ]
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "import random\n",
        "lst_a_np = np.random.rand(100)\n",
        "\n",
        "def seq_a(A):\n",
        "    S = np.cumsum(A)/(np.arange(A.shape[0])+1) \n",
        "    return S\n",
        "\n",
        "print(seq_a(lst_a_np))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# функция без NumPy\n",
        "def nonnp_seq_a(A):\n",
        "    S = [0 for i in range(len(A))]\n",
        "    for i in range(len(A)):\n",
        "        S[i] = sum(A[:i+1]) / (i+1)\n",
        "\n",
        "    return S\n",
        "\n",
        "\n",
        "print(nonnp_seq_a(lst_a_np))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yDftxZWqEG_V",
        "outputId": "c1ee827e-cdf2-4a1f-9ad1-0d554eb62d55"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.9983691559607862, 0.9526617528089363, 0.7117288774635516, 0.7429065469211665, 0.7277251385791658, 0.7610249148455076, 0.6975647148452636, 0.6664817977105326, 0.6366210426395514, 0.6442118735897667, 0.5996856075063891, 0.594314942101927, 0.623780520017022, 0.5916602235520979, 0.5639497930604135, 0.5786836768191814, 0.576931668954568, 0.5842686326929704, 0.5951987972264392, 0.582890898899133, 0.5746051942485146, 0.5752759778167983, 0.5785096458162288, 0.5694382884854182, 0.5668189822921644, 0.5574457117756207, 0.544311032521463, 0.5382158500652804, 0.5526925480822856, 0.5415581006875254, 0.5365699326216912, 0.5203656029646793, 0.5343776578266209, 0.5205383607292973, 0.5160387948826051, 0.5049601202466346, 0.49652759937960805, 0.5052427494456732, 0.5069306034266085, 0.4984998250802489, 0.5106962931681321, 0.5072123234782057, 0.5164075262952549, 0.5094549295475312, 0.5139371985789819, 0.515960873824118, 0.5099943370030614, 0.5043887854644505, 0.5120131764391821, 0.5184182493614928, 0.5139038222223298, 0.5168555971878399, 0.521090138512133, 0.5278619486700633, 0.5215853351477635, 0.5291854761730787, 0.5206402067554314, 0.5124083214640254, 0.515854607642646, 0.5210306801858856, 0.5281758094788579, 0.5233171872257302, 0.5193215987332972, 0.5139042650957338, 0.510288746633087, 0.5169829294467087, 0.5136381032133808, 0.5130313750198959, 0.509073228121785, 0.5070748162800107, 0.5113761618009517, 0.5122306864940197, 0.5126702386920117, 0.5179835963950028, 0.5184914592055488, 0.5214647975795812, 0.5232001483571327, 0.5286797703924141, 0.523550253526467, 0.5196459252553205, 0.5192948731959578, 0.5144501697023445, 0.518694591030606, 0.523591735244399, 0.5250993385828193, 0.5278782566125314, 0.5306561427087217, 0.5350492385712786, 0.5340912950612813, 0.5331308343822377, 0.5370154776314943, 0.5324317825615367, 0.5329809799245379, 0.5278018215490402, 0.5265830143100514, 0.521325976386637, 0.5221465058228737, 0.5171157353828308, 0.5159432298699171, 0.5145654618756619]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%timeit seq_a(lst_a_np)\n",
        "%timeit nonnp_seq_a(lst_a_np)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jCB6ZfWhFBAQ",
        "outputId": "864f7bb6-bb1f-4678-dfca-da7f7a35de5a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The slowest run took 133.92 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "100000 loops, best of 5: 7.84 µs per loop\n",
            "1000 loops, best of 5: 1.03 ms per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "idl3FTk391br"
      },
      "source": [
        "### 10. Пусть задан некоторый массив  𝑋 . Заменить все элементы с нечетными индексами на число  𝑎  (если оно не указано, то на 1), четные - возвести в куб и записать в обратном порядке на те же позиции. Массив  𝑋  при этом должен остаться без изменений. В конце требуется слить массив X с преобразованным X.\n",
        "\n",
        "Пример:\n",
        "X = [100, 200, 300, 400, 500] -> [100, a, 300, a, 500] -> [500^3, a, 300^3, a, 100^3] -> склеиваем -> [100, 200, 300, 400, 500, 500^3, a, 300^3, a, 100^3]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Z6JBOD8091br",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5a37ce68-725b-474f-c1aa-bca0de52608a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1.25e+08, 1.00e+00, 2.70e+07, 1.00e+00, 1.00e+06])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "def trans(X, a=1):\n",
        "  \n",
        "    Y = np.zeros(X.shape[0])\n",
        "    Y[1::2] = a\n",
        "    Y[::2] = np.flip(X[::2]) ** 3\n",
        "\n",
        "    return Y\n",
        "\n",
        "X = np.array([100, 200, 300, 400, 500])\n",
        "\n",
        "trans(X)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7JNrhzxM91br"
      },
      "source": [
        "### 11. Вам подаются на вход два вектора `a` и `b` в трехмерном пространстве.Заполните их случайными числами. Реализуйте их скалярное произведение с помощью  `NumPy` и без. Засеките время работы, как это показано в заданиях выше."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "w86Pxses91br",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "24bec732-6b79-45a6-877d-e4e26b102143"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.34805809, 0.18220709, 0.47916503])"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "c = 3\n",
        "a = spst.uniform.rvs(size=c) \n",
        "b = spst.uniform.rvs(size=c)\n",
        "a"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b"
      ],
      "metadata": {
        "id": "rLlRblJHFiny"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "%timeit spst.uniform.rvs(size=c) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uh2Xx-iZFw19",
        "outputId": "6c7a4123-bee1-4782-ef73-621dabdc23e8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The slowest run took 18.66 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "10000 loops, best of 5: 71.3 µs per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def numpy_scalar_product(a,b):\n",
        "    \n",
        "    #тут ваш код\n",
        "    \n",
        "    if a.shape[0] == b.shape[0]:\n",
        "        \n",
        "        c = np.dot(a, b)\n",
        "        \n",
        "    else:\n",
        "        \n",
        "        c = 0\n",
        "    \n",
        "    return c\n",
        "\n",
        "numpy_scalar_product(a,b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zzh9HfX4F9z_",
        "outputId": "ee5d4241-3aa3-4e91-e2cb-ff3988a5e139"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.723223248379628"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%timeit numpy_scalar_product(a,b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X6JxT9Ck2OR5",
        "outputId": "1ab8dd29-bdfb-44a3-9c36-8b3f773d45dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The slowest run took 25.69 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "1000000 loops, best of 5: 1.51 µs per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def simple_scalar_product(a,b):\n",
        "\n",
        "    if a.shape[0] == b.shape[0]:\n",
        "        \n",
        "        c = []\n",
        "        \n",
        "        for i in range(a.shape[0]):\n",
        "            \n",
        "            c.append(a[i]*b[i])\n",
        "            \n",
        "        c = sum(c)\n",
        "        \n",
        "    else:\n",
        "        \n",
        "        c = 0\n",
        "    \n",
        "    return c\n",
        "\n",
        "simple_scalar_product(a,b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QH0MisoN2T3X",
        "outputId": "e90364bd-aced-4ab8-a569-0cca88233c6f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7232232483796279"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%timeit simple_scalar_product(a,b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FA-o7JGd6qpo",
        "outputId": "ad10c5f9-2885-4098-9377-ec51719eb970"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The slowest run took 12.59 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "100000 loops, best of 5: 2.7 µs per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rt9hWAmO91br"
      },
      "source": [
        "### 12. Написать решето Эратосфена с Numpy. Минимум циклов!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wjw7gPxr91br",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d58fd0a7-c430-4c2a-ff5b-092218852114"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 2,  3,  5,  7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,\n",
              "       61, 67, 71, 73, 79, 83, 89, 97])"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "def ersf(n):\n",
        "    m = int(np.sqrt(n))\n",
        "    is_prime = np.ones(n, dtype=bool)\n",
        "    is_prime[:2] = False  # 0 and 1 are not primes\n",
        "\n",
        "    for i in range(2, m):\n",
        "        if is_prime[i] == False:\n",
        "            continue\n",
        "        is_prime[i*i::i] = False\n",
        "\n",
        "    return np.nonzero(is_prime)[0]\n",
        "\n",
        "n = 100\n",
        "\n",
        "ersf(100)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EM2f4mpF91br"
      },
      "source": [
        "###  13. Реализовать кодирование длин серий (Run-length encoding). Дан вектор x. Необходимо вернуть кортеж из двух векторов одинаковой длины. Первый содержит числа, а второй - сколько раз их нужно повторить.\n",
        "Пример: x = np.array([2, 2, 2, 3, 3, 3, 5]). Ответ: (np.array([2, 3, 5]), np.array([3, 3, 1]))."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lmCZ5Izy91br",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f6211d7-9ab0-45f9-d528-e799e714bd14"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([2, 3, 5]), array([3, 3, 1]))"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "import numpy as np\n",
        "\n",
        "def encode(a):\n",
        "    elements=[]\n",
        "    counts=[]\n",
        "    count=1\n",
        "    for i in range(len(a)):\n",
        "        if(i==len(a)-1):\n",
        "            elements.append(a[i])\n",
        "            counts.append(count)\n",
        "            break\n",
        "            \n",
        "        \n",
        "        if(a[i]==a[i+1]):\n",
        "            count+=1\n",
        "        else:\n",
        "                elements.append(a[i])\n",
        "                counts.append(count)\n",
        "                count=1\n",
        "    x=np.array(elements)\n",
        "    s=np.array(counts)\n",
        "\n",
        "    result = (x,s)\n",
        "    return result\n",
        "\n",
        "x = np.array([2, 2, 2, 3, 3, 3, 5])\n",
        "encode(x)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KyciSX8R91bs"
      },
      "source": [
        "### 14. Найти максимальный элемент в векторе x среди элементов, перед которыми стоит нулевой. \n",
        "Для x = np.array([6, 2, 0, 3, 0, 0, 5, 7, 0]) ответ 5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KyJoF5qi91bs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8c5d6e7a-45e7-43a9-91b3-c75a3a91bcc2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "x = np.array([6, 2, 0, 3, 0, 0, 5, 7, 0])\n",
        "zero = x==0\n",
        "x[1:][zero[:-1]].max()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OTgsHTCA91bs"
      },
      "source": [
        "### 15. Перетасовать колоду карт, вычислить вероятность выпадения: красной карты; туза; черного валета или шестерки (все - в Python). Подкрепить это экспериментами, сделать выводы"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SrBnqjCz91bs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "54baf9fc-0f5b-4a08-b092-f1ba9848a082"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Вероятность вытащить красную карту: 72%\n",
            "Вытащили карту масти Пики, номиналом 5\n",
            "Вероятность черного валета или черной шестерки: 3%\n"
          ]
        }
      ],
      "source": [
        "\n",
        "def take_card():\n",
        "  \"\"\"\n",
        "  вытаскивание произвольной карты\n",
        "  \"\"\"\n",
        "  suits = np.array([\"Черви\", \"Бубны\", \"Пики\", \"Трефы\"])\n",
        "  faces = np.array([\"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"10\", \"J\", \"Q\", \"K\", \"A\"])\n",
        "  np.random.shuffle(faces)\n",
        "  np.random.shuffle(suits)\n",
        "  deck = []\n",
        "  for f,s in zip(faces,suits):\n",
        "    deck.append((s,f))\n",
        "  return deck[0]\n",
        "\n",
        "\n",
        "\n",
        "def card_prob():\n",
        "  cards_count = 36\n",
        "  # cards = np.arange(36)+1\n",
        "  red_cards = 26\n",
        "  print(f'Вероятность вытащить красную карту: {\"{:.0%}\".format(red_cards /cards_count)}')\n",
        "  suit, face = take_card()\n",
        "  print(f'Вытащили карту масти {suit}, номиналом {face}')\n",
        "  print(f'Вероятность черного валета или черной шестерки: {\"{:.0%}\".format(1 /cards_count)}')\n",
        "\n",
        "card_prob()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gxL0ONFl91bs"
      },
      "source": [
        "### 16. Дана матрица X и два вектора одинаковой длины i и j. Построить вектор np.array([X[i[0], j[0]], X[i[1], j[1]], . . . , X[i[N-1], j[N-1]]])."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i2nQyymK91bs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "851dec7f-ebf8-4b17-b4be-64e6ae5c40c2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 6, 6, 5, 4, 2, 7, 2, 3, 4]\n",
            "[4, 9, 5, 1, 9, 3, 6, 3, 5, 6]\n",
            "--------------------------------------------------------------------------------\n",
            "[[7, 0, 6, 7, 4, 5, 5, 3, 9, 4], [9, 9, 5, 8, 9, 2, 4, 8, 3, 6], [3, 2, 2, 2, 1, 6, 5, 9, 9, 1], [7, 3, 1, 2, 7, 0, 0, 0, 2, 6], [9, 4, 3, 3, 7, 4, 5, 1, 0, 4], [9, 2, 8, 0, 4, 0, 8, 0, 3, 9], [6, 8, 1, 0, 1, 4, 5, 1, 7, 3], [5, 7, 2, 9, 2, 8, 6, 4, 0, 6], [5, 0, 2, 6, 9, 2, 8, 6, 5, 6], [9, 2, 6, 2, 4, 8, 6, 4, 9, 2]]\n",
            "================================================================================\n",
            "[4, 3, 4, 2, 4, 2, 6, 2, 0, 5]\n"
          ]
        }
      ],
      "source": [
        "# Дописать код здесь\n",
        "from random import randint\n",
        "i = [randint(0,9) for indx in range(10)]\n",
        "j = [randint(0,9) for indx in range(10)]\n",
        "x = [[randint(0,9) for indx in range(10)] for jndx in range(10)]\n",
        "print(i)\n",
        "print(j)\n",
        "print('-' * 80)\n",
        "print(x)\n",
        "print('=' * 80)\n",
        "\n",
        "np = []\n",
        "for indx in range(10):\n",
        "    np.append(x[i[indx]][j[indx]])\n",
        "print(np)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L_eZJjaE91bs"
      },
      "source": [
        "### 17. Алгоритм Дейкстры на numpy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "h6Y4RFSZ91bt"
      },
      "outputs": [],
      "source": [
        "# Дописать код здесь\n",
        "# аналогично - непонятно"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "colab": {
      "name": "Numpy-HW1.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}