fall-2021/lectures/lecture07_set.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "celltoolbar": "Slideshow",
    "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.9"
    },
    "colab": {
      "name": "lecture07_set.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/svdcvt/math_python_hse/blob/master/fall-2021/lectures/lecture07_set.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CFP1XIzSOqm3"
      },
      "source": [
        "# Занятие №7: множества, алгоритмическая сложность.\n",
        "\n",
        "---\n",
        "\n",
        "[МИНИКОНТЕСТ](https://contest.yandex.ru/contest/30000/)\n",
        "\n",
        "---\n",
        "\n",
        "\"https://replit.com - можете сразу воспроизводить код и решать задачи используя онлайн интерпретатор Питона (\\\\\\\"Create Repl\\\\\\\" -> \\\\\\\"Select Language - Python\\\\\\\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xX6n7LCwOqon"
      },
      "source": [
        "#  Множества   [DOCS1](https://docs.python.org/3/tutorial/datastructures.html#sets) [DOCS2](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset)\n",
        "\n",
        "Множество в языке Питон — это **изменяемая** структура данных, эквивалентная множествам в математике. Множество состоит из **различных** элементов, **порядок** которых **не определен**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nyn2CY15Oqoo"
      },
      "source": [
        "Главная особенность множеств это отсутствие порядка. Элементы множества хранятся не подряд, а при помощи хитрых алгоритмов (об этом будем говорить на следующем занятии!). Это позволяет выполнять проверку на принадлежность элемента множеству **быстрее**, чем просто перебирая все элементы (как это происходит в списке, строках и т.д.)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BOoL9ol9Oqop"
      },
      "source": [
        "Элементами множества может быть любой **неизменяемый** тип данных: числа, строки, кортежи. \n",
        "\n",
        "Изменяемые типы данных не могут быть элементами множества, т.е. нельзя сделать элементом множества список (но можно сделать кортеж) или другое множество. Требование неизменяемости элементов множества накладывается особенностями представления множества в памяти компьютера."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bVIxPCTBOqop"
      },
      "source": [
        "##  Создание множества \n",
        "\n",
        "Множество задается перечислением всех его элементов в фигурных скобках `{}` через запятую."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Ti4S8XHOqoq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9949079c-b031-4efa-cf61-87054f1d96c6"
      },
      "source": [
        "A = {1, 2, 3}\n",
        "print(A, type(A))"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3} <class 'set'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gMZz_0rdOqor"
      },
      "source": [
        "Пустое множество можно создать **только** при помощи функции `set()`. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rKa_uic9Oqos",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea2fe631-c24b-4ccd-edfe-b5041396f3f3"
      },
      "source": [
        "print(type(set()), type({}))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'set'> <class 'dict'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S0Kd8R8XOqou"
      },
      "source": [
        "Если функции `set` передать в качестве параметра список, строку или кортеж, то она вернёт множество, составленное из элементов списка, строки, кортежа. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iNcCqzegOqov",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73acc6bb-c448-4941-8a9f-42611496bd2a"
      },
      "source": [
        "print(set([1, 2, 4, 3, 2, 3, 1]))\n",
        "print(set('qwertqwertabc'))\n",
        "print(set(['10', '11', '9', 12, '100', 10, 11]))"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4}\n",
            "{'w', 'e', 'q', 'b', 'a', 't', 'c', 'r'}\n",
            "{'9', 10, 12, 11, '10', '11', '100'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5DCVMpjJaK6k"
      },
      "source": [
        "Заметьте в дальнейшем примере, что абсолютно так же заданные множества уже имеют другой порядок элементов, что говорит нам о том, что в множество действительно не определен порядок и про это необходимо помнить. Кроме того, сам порядок не особо поддается логике."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cZ-WEussYjLg",
        "outputId": "c4e3c587-67a3-4781-c3e1-d21711a1f380"
      },
      "source": [
        "print(set('qwertqwertabc'))"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'c', 'q', 'w', 'e', 'r', 'b', 'a', 't'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2JgAIfq8Zt9O",
        "outputId": "3de488d6-437c-43e2-c0bc-25aa82acb9ec"
      },
      "source": [
        "print(set(['10', '11', '9', 12, '100', 10, 11]))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'100', '11', 10, 11, 12, '9', '10'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2RjQOz3SqugE"
      },
      "source": [
        "Решите задачу: https://contest.yandex.ru/contest/30000/problems/A/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F55RpBQcOqow"
      },
      "source": [
        "Как и для списков, есть __генератор множества__, который выглядит как и известный нам генератор, но скобки должны быть фигурными. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CWs8VJweOqox",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "95f882da-639d-4be2-be9c-b5d9d971f4e4"
      },
      "source": [
        "a = {x for x in 'abracadabra' if x not in 'ac'}\n",
        "print(a, type(a))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'r', 'd', 'b'} <class 'set'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TgJlvn50Oqoy"
      },
      "source": [
        "Каждый элемент может входить в множество **только один раз**, порядок задания элементов неважен. Например, программа выведет `True`, так как A и B — равные множества."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bUEe9-3nOqoz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5914666e-2554-4ea0-fa0f-4c29e23f0b9a"
      },
      "source": [
        "A = {10, 2, 3}\n",
        "B = {3, 2, 3, 10}\n",
        "print(A == B)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bCy2gFmYOqo6"
      },
      "source": [
        "### Работа с элементами множеств "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Mn_tXQ7Oqo9"
      },
      "source": [
        "Из множества можно сделать список при помощи функции `list` или отсортированный список с помощью `sorted`. Узнать число элементов в множестве можно при помощи функции `len`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "27McG_PLOqo-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "79b6ef74-9f5c-4712-862a-578499a507c1"
      },
      "source": [
        "print(list(B), sorted(B), len(B), len(set()), sep='\\n')"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 2, 3]\n",
            "[2, 3, 10]\n",
            "3\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uBXrpPmrrCrS"
      },
      "source": [
        "Решите задачи:\n",
        "- https://contest.yandex.ru/contest/30000/problems/D/\n",
        "- https://contest.yandex.ru/contest/30000/problems/F/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xeRhx8aiOqpA"
      },
      "source": [
        "`s.copy()` - возвращает копию множества;\n",
        "\n",
        "`s.clear()` - удаляет все элементы множества"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wFw0i9QMOqpF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac6aac91-541a-425d-e711-3156b90b297a"
      },
      "source": [
        "B2 = B.copy()\n",
        "B.clear()\n",
        "print(B2, B, sep='\\n')"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{10, 2, 3}\n",
            "set()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zrxse6JEOqpH"
      },
      "source": [
        "Проверить, принадлежит ли элемент множеству можно при помощи операции `in`, возвращающей значение типа `bool`. Аналогично есть противоположная операция `not in`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cESV0ohKOqpI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7cb5817d-dab2-4fa3-b297-5b6e389a4512"
      },
      "source": [
        "A = {1, 2, 3}\n",
        "print(1 in A, 4 not in A)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uDCooAFcOqpM"
      },
      "source": [
        "Для добавления элемента в множество есть метод `add`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y3DQfACROqpN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9a0d9b0d-b353-4012-ddcd-e9b183b6522e"
      },
      "source": [
        "A.add(4)\n",
        "print(A)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "06G9Grc5q2vA"
      },
      "source": [
        "Решите задачу: https://contest.yandex.ru/contest/30000/problems/B/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lhAKrdQ2e0xh"
      },
      "source": [
        "Также можно объединить два множества методом `update`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9-JS_85te0VV",
        "outputId": "a115662a-faa1-4a08-cdc0-19b4c780e568"
      },
      "source": [
        "A.update([5, 6, 7])\n",
        "print(A)\n",
        "A.update('89')\n",
        "print(A)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4, 5, 6, 7}\n",
            "{1, 2, 3, 4, 5, 6, 7, '9', '8'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ijGn1PH3Oqpe"
      },
      "source": [
        "Для удаления элемента `x` из множества есть два метода: `discard` и `remove`. Их поведение различается только в случае, когда удаляемый элемент отсутствует в множестве. В этом случае метод `discard` не делает ничего, а метод `remove` генерирует исключение KeyError."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "96sSUEoVOqpg"
      },
      "source": [
        "A.discard(10)"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "id": "6uOKIEDDeway",
        "outputId": "3276a43d-6c00-4896-9e58-a4ea2d164b7f"
      },
      "source": [
        "A.remove(10)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-33-a20b082beaa1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mA\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 10"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hWm_TmBMOqpj"
      },
      "source": [
        "Метод `pop` удаляет из множества один **случайный элемент** и возвращает его значение. Если же множество пусто, то генерируется исключение `KeyError`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ObZLOUCgOqpl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "70b94576-50a0-4aab-a604-650779d54eb3"
      },
      "source": [
        "b = A.pop()\n",
        "print(b)\n",
        "print(A)\n",
        "c = A.pop()\n",
        "print(c)\n",
        "print(A)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "{2, 3, 4, 5, 6, 7, '9', '8'}\n",
            "2\n",
            "{3, 4, 5, 6, 7, '9', '8'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7eqfOHCjOqpm"
      },
      "source": [
        "Перебрать все элементы множества (в неопределенном порядке!) циклом `for` можно как и обычно:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qRbYuezxOqpo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a6283439-2eb5-44e3-8a88-a75450d57fd4"
      },
      "source": [
        "for el in A:\n",
        "    print(el, end=' ')"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3 4 5 6 7 9 8 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G-Jr_DilOqpq"
      },
      "source": [
        "###  Операции с множествами  \n",
        "\n",
        "С множествами в Питоне можно выполнять обычные для математики операции над множествами.\n",
        "\n",
        "| Операция | Метод | Что делает |\n",
        "| ---      | ---   | ---        |\n",
        "| A \\| B |A.union(B) |Возвращает множество, являющееся объединением множеств A и B.|\n",
        "|A \\|= B |A.update(B)|Добавляет в множество A все элементы из множества B.|\n",
        "|A & B |A.intersection(B)|Возвращает множество, являющееся пересечением множеств A и B.|\n",
        "|A &= B|A.intersection_update(B)|Оставляет в множестве A только те элементы, которые есть в множестве B.|\n",
        "|A - B|A.difference(B)|Возвращает разность множеств A и B (элементы, входящие в A, но не входящие в B).|\n",
        "|A -= B|A.difference_update(B)|Удаляет из множества A все элементы, входящие в B.|\n",
        "|A ^ B|A.symmetric_difference(B)|Возвращает симметрическую разность множеств A и B (элементы, входящие в A или в B, но не в оба из них одновременно).|\n",
        "|A ^= B|A.symmetric_difference_update(B)|Записывает в A симметрическую разность множеств A и B.|\n",
        "|A <= B|A.issubset(B)|Возвращает true, если A является подмножеством B.|\n",
        "|A >= B|A.issuperset(B)|Возвращает true, если B является подмножеством A.|\n",
        "|A < B||Эквивалентно A <= B and A != B|\n",
        "|A > B||Эквивалентно A >= B and A != B|\n",
        "||A.isdisjoint(B)| Эквивалентно пустому A.intersection(B) |"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xh3SaCG6q8K_"
      },
      "source": [
        "Решите задачи: \n",
        "- https://contest.yandex.ru/contest/30000/problems/C/\n",
        "- https://contest.yandex.ru/contest/30000/problems/E/\n",
        "- https://contest.yandex.ru/contest/30000/problems/G/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nz6uYucQOqps"
      },
      "source": [
        "###  Frozen set  \n",
        "\n",
        "Тип `frozenset` - множество, которое является неизменяемым, а поэтому может использоваться как ключ словаря или как элемент множества. Его элементы нельзя изменить, поэтому методов `add`, `remove` и др. у него нет."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2vp_saJmOqpu"
      },
      "source": [
        "froze = frozenset([1, 2, 2])"
      ],
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "id": "FxehlrU9kwri",
        "outputId": "93d5a08f-cff8-4c32-9994-f5aea60076b9"
      },
      "source": [
        "froze.add('3')"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-38-e47ef61cd7c0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfroze\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'3'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'frozenset' object has no attribute 'add'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "id": "vQlq_5akky8v",
        "outputId": "19469faf-c3ce-40ac-9772-f201f7156b2a"
      },
      "source": [
        "froze.pop()"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-39-5cd8f4855069>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfroze\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'frozenset' object has no attribute 'pop'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NCYiLo9BmQpR",
        "outputId": "2318235e-9f99-43c1-f47b-52a7681335ac"
      },
      "source": [
        "a = {froze, 1, (3, 4)}\n",
        "print(a)"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, (3, 4), frozenset({1, 2})}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZJ9jEO-POtBp"
      },
      "source": [
        "# Алгоритмическая сложность\n",
        "\n",
        "##  О-символика   \n",
        "\n",
        "Сегодня мы поговорим о том, как сравнивать скорость различных алгоритмов. Конечно, скорость выполнения программы зависит от многих факторов - процессор компьютера, его загруженность, архитектура, устройство памяти, сам язык программирования - поэтому хочется уметь сравнивать алгоритмы вне зависимости от них. Определить, какой алгоритм работает в общем случае быстрее другого, можно, например, с помощью О-символики. Начнем с определения."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WM8uuu6nOtBs"
      },
      "source": [
        "###  Определение  \n",
        "\n",
        ">Пусть $f,g$ - функции. Говорим, что $f$ растет **не быстрее** $g$ и пишем $f(n) = O(g(n))$ или $f \\preceq g$, если существует такая константа $c>0$, что $f(n) \\leq c \\cdot g(n)$ для любого $n \\in \\mathbb N$.\n",
        "\n",
        "Связанные понятия:\n",
        "> $f(n) = \\Omega(g(n)),\\ f \\succeq g \\iff \\exists c>0: f(n) \\geq c\\cdot g(n)$ (не медленнее)\n",
        "> $f(n) = \\Theta(g(n)),\\ f \\asymp g \\iff f(n) = O(g(n)) = \\Omega(g(n))$ (не быстрее и не медленнее, т.е. одинаково) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C0bnpmAfOtBv"
      },
      "source": [
        "###  Пример  \n",
        "\n",
        "$$3n^2 + 5n + 2 = O(n^2)$$\n",
        "<img src='https://github.com/svdcvt/math_python_hse/blob/master/fall-2020/lectures/frac.png?raw=1'>\n",
        "\n",
        "Видно что наш полином в асимтотике отличен от простого квадратичного монома на константу 3."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q2MBkafnOtBx"
      },
      "source": [
        "###  Общие правила  \n",
        "\n",
        "1. Постоянные множители можно опускать:\n",
        "$$ 7n^3 = \\Theta(n^3), \\quad \\frac{n^2}{3} = \\Theta(n^2)$$\n",
        "2. Многочлен более высокой степени растёт быстрее:\n",
        "$$ n^a \\prec n^b \\iff a < b, \\quad n = O(n^2)$$\n",
        "3. Экспонента растёт быстрее многочлена:\n",
        "$$n^a \\prec b^n\\ (\\forall a>0, b>1), \\quad n^2 = O(3^n), \\quad n^{1000} = O(1.1^n)$$\n",
        "4. Многочлен растет быстрее логарифма:\n",
        "$$(\\log n)^a \\prec n^b\\ (\\forall a, b > 0), \\quad (\\log n)^{10} = O(\\sqrt{n}), \\quad n\\cdot\\log n = O(n^2)$$\n",
        "5. Медленно растущие слагаемые можно опускать:\n",
        "$$f + g = O(\\max(f,g)), \\quad n^2 + n = O(n^2) $$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bxSyTDECOtB0"
      },
      "source": [
        "###  Часто используемые функции  \n",
        "$$\\log n \\prec \\sqrt{n} \\prec n \\prec n\\log n \\prec n^2 \\prec 2^n$$\n",
        "<img src='https://github.com/svdcvt/math_python_hse/blob/master/fall-2020/lectures/all.png?raw=1' width='500px'>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y_DRWX5uOtB2"
      },
      "source": [
        "Такой способ позволяет оценить скорость алгоритма в первом приближении, опуская детали, но иногда эти \"детали\" могут быть очень значимыми, а О-символика их игнорирует. Однако, в программировании постоянно используют этот способ, часто можно увидеть выражения \"алгоритм за квадрат\" - $O(n^2)$, \"алгоритм за линию\" - $O(n)$, \"константа\" - $O(1)$. Везде за $n$ берется **размер входных данных** (число строк, число символов, длина массива, количество запросов и т.д.)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f_TG8NSpOtB4"
      },
      "source": [
        "##  Скорость роста времени работы кода на практике  \n",
        "\n",
        "Зная какие операции различных структур данных сколько занимают \"времени\", мы можем писать более оптимальный код. Подробнее можно посмотреть, например, [тут](https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt) и [тут](https://www.bigocheatsheet.com)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eKh5nkc4OtB6"
      },
      "source": [
        "###  Циклы и список  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x7L9a8ZsOtB9"
      },
      "source": [
        "**Пример 1**\n",
        "\n",
        "Пусть дан список $A$ длины $N$, тогда какова алгоритмическая сложность следующего кода?\n",
        "\n",
        "    for i in range(len(A)):\n",
        "        print(i)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "843GVxhpOtB_"
      },
      "source": [
        "Цикл делает столько итераций, сколько составляет длина списка, и выполняет лишь одну простую (константную) операцию. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cSuKWOpbOtCB"
      },
      "source": [
        "Поэтому сложность: $\\Theta(N) \\cdot \\Theta(1) = O(N)$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yqCrUMKSOtCC"
      },
      "source": [
        "**Пример 2**\n",
        "    \n",
        "    s = 0\n",
        "    for i in range(5):\n",
        "        for x in A:\n",
        "            s += A"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dUjMeCTvOtCE"
      },
      "source": [
        "Задание переменной это простая операция. Далее цикл фиксированной длины, в котором есть внутренний цикл зависящий от длины списка. Внутренний цикл выполняет простую операцию обновления переменной."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fHjphwtxOtCF"
      },
      "source": [
        "Итого: $\\Theta(1) + \\Theta(1) \\cdot \\Theta(N) \\cdot \\Theta(1) = O(N)$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZktOH68rOtCG"
      },
      "source": [
        "**Пример 3**\n",
        "\n",
        "    s = 0\n",
        "    for i in range(len(A)):\n",
        "        for j in range(len(A)):\n",
        "            print(A[i] + A[j])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b6aUx_jiOtCH"
      },
      "source": [
        "Сначала простая операция задания переменной. Далее двойной цикл по массиву. Внутри операция доступа к элементу массива и простая операция печати."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rXMG-eQkOtCI"
      },
      "source": [
        "Итого: $\\Theta(1) + \\Theta(N) \\cdot \\Theta(N) \\cdot (\\Theta(1) + \\Theta(1)) = O(N^2)$ "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9JYd1HVpOtCK"
      },
      "source": [
        "**Пример 4**\n",
        "\n",
        "    for i in range(len(A)):\n",
        "        A[i] = A[i] * i"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1qaVCHVvOtCL"
      },
      "source": [
        "Цикл по всему массиву, внутри цикла проста операция доступа к элементу списка, простая арифметическая операция, простая операция замены (задания) значения элемента списка."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e5wgyxMDOtCM"
      },
      "source": [
        "Итого: $\\Theta(N) \\cdot (\\Theta(1) + \\Theta(1) + \\Theta(1)) = O(N)$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c_wLxUlhOtCN"
      },
      "source": [
        "**Пример 5**\n",
        "\n",
        "    B = []\n",
        "    for x in A:\n",
        "        B.append(x * 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hMwJvR_WOtCO"
      },
      "source": [
        "Сначала простая операция задания переменной пустым массивом. Далее цикл по элементам массива А. Внутри цикла простая арифметическая операция и добавление элемента в конец массива*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JeUZxEpXOtCO"
      },
      "source": [
        "Итого: $\\Theta(1) + \\Theta(N) \\cdot (\\Theta(1) + \\Theta(1)^*) = O(N)$\n",
        "\n",
        "\\* - вообще говоря, в Питоне эта операция в худшем случае выполняется за линейное время, и [вот почему](https://ru.wikipedia.org/wiki/Динамический_массив). Даже скорее не в лучшем случае, а есть такое понятие \"амортизированная сложность\". \n",
        "\n",
        "- Во время создания списка, под него выделяется какое-то количество памяти, например, $N$. \n",
        "- Потом мы в свободные \"ячейки\" памяти кладем за константное время новые элементы в конец списка, пока память не заполнится. \n",
        "- Когда память заполнилась, мы выделяем $2\\cdot N$ памяти, _копируем $N$ элементов_ и далее можем добавить еще $N$ элементов в конец списка. \n",
        "\n",
        "Получается, что само добавление элемента это константная операция, т.к. выделение памяти занимает $O(N)$, куда мы добавим максимум $N$ элементов, тогда в среднем получаем $O(N)/N = O(1)$. Это и называют _амортизированной сложностью_."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9hpYTRLNOtCQ"
      },
      "source": [
        "###  Сложность операций списка  \n",
        " [(источник)](https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt)\n",
        "\n",
        "Operation     | Example      | Complexity Class         | Notes\n",
        "---           |---           |---            |-------\n",
        "**Append**        | `l.append(5)  `| **O(1)**\t     | O(N) in worst case\n",
        "**Containment**   | `x in/not in l`| **O(N)**\t     | linearly searches list \n",
        "**Insert/Delete**||**O(N)**|\n",
        "|||\n",
        "Index         | `l[i]         `| O(1)\t     |\n",
        "Store         |` l[i] = 0     `| O(1)\t     |\n",
        "Length        | `len(l)       `| O(1)\t     |\n",
        "Pop\t          | `l.pop()      `| O(1)\t     | \n",
        "Clear         | `l.clear()    `| O(1)\t     | similar to l = []\n",
        "Slice         | `l[a:b]       `| O(N)\t     | O(b-a): l[0:-1]:O(N)\n",
        "Construction  | `list(...)    `| O(len(...))   | depends on length of ... iterable\n",
        "Extend        | `l.extend(...)`| O(len(...))   | depends only on len of extension\n",
        "check ==, !=  | `l1 == l2     `| O(N)          |\n",
        "Insert        | `l[a:b] = ... `| O(N)\t     | \n",
        "Delete        | `del l[i]     `| O(N)\t     | depends on i; O(N) in worst case\n",
        "Copy          | `l.copy()     `| O(N)\t     | Same as l[:] which is O(N)\n",
        "Remove        | `l.remove(...)`| O(N)\t     | \n",
        "Pop\t          | `l.pop(i)     `| O(N)\t     | O(N-i): l.pop(0):O(N) (see above)\n",
        "Extreme value | `min(l)/max(l)`| O(N)\t     | linearly searches list for value\n",
        "Reverse\t      | `l.reverse()`  | O(N)\t     |\n",
        "Iteration     | `for v in l: ` | O(N)          | \n",
        "Find | `l.index(x)`| O(N)|linearly searches list for value"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "93Sa0I7nOtCT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c8c17c1-5d42-48b3-dc6e-cb00c1b86d07"
      },
      "source": [
        "def copy(A):\n",
        "    B = []\n",
        "    for i in range(len(A)):\n",
        "        B.append(A[i])\n",
        "    return B\n",
        "\n",
        "def copy2(A):\n",
        "#     B = A.copy()\n",
        "#     return B\n",
        "    return A.copy()\n",
        "\n",
        "N = 1000\n",
        "A = [i for i in range(N)]\n",
        "\n",
        "%timeit copy(A)\n",
        "%timeit copy2(A)"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10000 loops, best of 5: 108 µs per loop\n",
            "The slowest run took 6.27 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "100000 loops, best of 5: 2.81 µs per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-gVeZ4oNOtCa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c42b910-a29e-42a5-adda-3952a3da6271"
      },
      "source": [
        "import random\n",
        "\n",
        "def sort(iterable):\n",
        "    l = list(iterable)\n",
        "    s = sorted(l)\n",
        "    return s\n",
        "\n",
        "def sort2(iterable):\n",
        "    return sorted(iterable)\n",
        "\n",
        "N = 10000\n",
        "A = [i for i in range(N)]\n",
        "random.shuffle(A)\n",
        "\n",
        "iterableA = map(str, A)\n",
        "print(type(sort(iterableA)), type(sort2(iterableA)))\n",
        "\n",
        "%timeit sort(iterableA)\n",
        "%timeit sort2(iterableA)"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'> <class 'list'>\n",
            "The slowest run took 17.35 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "1000000 loops, best of 5: 477 ns per loop\n",
            "The slowest run took 17.45 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "1000000 loops, best of 5: 329 ns per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nBMccQQWOtCc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "203b27ac-37f6-404f-908d-dc622ca3df64"
      },
      "source": [
        "def scale(A):\n",
        "#     X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))\n",
        "    B = A.copy()\n",
        "    for i in range(len(A)):\n",
        "        B[i] = (A[i] - min(A)) / (max(A) - min(A))\n",
        "    return B\n",
        "\n",
        "def scale2(A):\n",
        "    B = A.copy()\n",
        "    amin, amax = min(A), max(A)\n",
        "    for i in range(len(A)):\n",
        "        B[i] = (A[i] - amin) / (amax - amin)\n",
        "    return B\n",
        "\n",
        "N = 1000\n",
        "A = [i for i in range(N)]\n",
        "\n",
        "%timeit scale(A)\n",
        "%timeit scale2(A)"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10 loops, best of 5: 58.5 ms per loop\n",
            "1000 loops, best of 5: 218 µs per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vDiswyqyOtCe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "db6a548a-236c-4672-fd21-6eaa76c85549"
      },
      "source": [
        "def find_all(A, x):\n",
        "    i = 0\n",
        "    idx = []\n",
        "    while x in A[i:]:\n",
        "        i += A[i:].index(x) + 1 # +1 для того чтобы потом искать с места после найденного х\n",
        "        idx.append(i - 1) # -1 чтобы корректно добавить нужный индекс\n",
        "    return idx\n",
        "\n",
        "def find_all2(A, x):\n",
        "    idx = []\n",
        "    for i in range(len(A)):\n",
        "        if x == A[i]:\n",
        "            idx.append(i)\n",
        "    return idx\n",
        "\n",
        "N = 1000\n",
        "n = 3 # try 100\n",
        "A = [i % n for i in range(N)]\n",
        "print(find_all(A, 2) == find_all2(A, 2))\n",
        "\n",
        "%timeit find_all(A, 2)\n",
        "%timeit find_all2(A, 2)"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "1000 loops, best of 5: 828 µs per loop\n",
            "10000 loops, best of 5: 94.5 µs per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y_xCPOZYOtCp"
      },
      "source": [
        "###  Сложность операций множеств  \n",
        "\n",
        "На следующем занятии мы поговорим про хитрый алгоритм, на котором основаны множества, а пока, можете изучить алгоритмические сложности операций.\n",
        "\n",
        "\n",
        "Operation     | Example      | Complexity Class         | Notes\n",
        "--------------|--------------|---------------|-------------------------------\n",
        "Add           | `s.add(5); s.update(k)`| O(1); O(len(k))\t     | O(N) worst case\n",
        "Containment   | `x in/not in s`| O(1)\t     | \n",
        "Delete        | `s.remove(..); s.discard(..); s.pop(..)`| O(1)\t     | \n",
        "||||\n",
        "check ==, !=  | `s != t`       | O(len(s))     | False in O(1) if the lengths are different\n",
        "<= or < , \\>= or >         | `s <= t; s >= t`    | O(len(s)), O(len(t))     | \n",
        "Sets operations | `s \\| t; s & t; s - t; s ^ t`| O(len(s)+len(t))"
      ]
    }
  ]
}