2016-17/docs/wyklady/js-python_w05.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "# Języki skryptowe - Python\n",
    "## Wykład 5\n",
    "\n",
    "---\n",
    "\n",
    "* *timeit*, czyli pythonowy stoper\n",
    "* złożoność algorytmów + przykłady\n",
    "* notacja \"dużego &Omicron;\" (Omicron)\n",
    "* algorytmy sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dygresja o *__main__*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__main__\n",
      "math\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print(__name__)      # nazwa skryptu\n",
    "print(math.__name__) # nazwa zaimportowanego modułu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "# instrukcje z main\n",
    "# z zaimportowanych modułów\n",
    "# nie zostaną wywołane\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *timeit*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def silnia(n):\n",
    "    \"\"\"Zwraca silnię liczby n.\"\"\"\n",
    "    if n < 2:\n",
    "        return 1 # 0! = 1, 1! = 1\n",
    "    return n*silnia(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.7365999560279306e-05"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from timeit import timeit\n",
    "\n",
    "# timeit(funkcja, setup, number) -> czas wykonania funkcji w s\n",
    "# funkcja - funkcja do wykonania\n",
    "# setup - konfiguracja\n",
    "# number - liczba powtórzeń\n",
    "timeit(\"silnia(10)\", setup=\"from __main__ import silnia\", number=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0004746449994854629"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timeit(\"silnia(100)\", setup=\"from __main__ import silnia\", number=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *timeit* z linii komend\n",
    "\n",
    "---\n",
    "\n",
    "```py\n",
    "# silnia.py\n",
    "\n",
    "def silnia(n):\n",
    "    \"\"\"Zwraca silnię liczby n.\"\"\"\n",
    "    if n < 2:\n",
    "        return 1 # 0! = 1, 1! = 1\n",
    "    return n*silnia(n - 1)\n",
    "```\n",
    "\n",
    "* możemy przetestować naszą funkcję z linii komend\n",
    "\n",
    "```\n",
    "$ python -m timeit -n10 'from silnia import silnia; silnia(10)'\n",
    "10 loops, best of 3: 9.11 usec per loop\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *timeit* w Jupyter Notebook\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def silnia(n):\n",
    "    \"\"\"Zwraca silnię liczby n.\"\"\"\n",
    "    if n < 2:\n",
    "        return 1 # 0! = 1, 1! = 1\n",
    "    return n*silnia(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 loops, best of 3: 3.44 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n10 silnia(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Algorytm** - *ciąg instrukcji prowadzących do rozwiązania zadania*\n",
    "\n",
    "---\n",
    "\n",
    "![Algorytm: egzamin](src/algorytm_egzamin.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Koty Ali\n",
    "\n",
    "---\n",
    "\n",
    "* Pierwszego dnia Ala dostała jednego kota. Każdego kolejnego dnia dostaje o jednego więcej niż dnia poprzedniego. Ile kotów ma Ala po *n* dniach?\n",
    "    * pierwszy dzień: 1\n",
    "    * drugi dzień: 1 + 1\n",
    "    * trzeci dzień: 1 + 1 + 1\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Koty Ali - algorytm I\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def licz_koty_v1(n):\n",
    "    \"\"\"Zwraca liczbę kotów po n dniach.\"\"\"\n",
    "    n_cats = 0                     # Ala nie ma kota\n",
    "    for dzien in range(1, n + 1):  # pętla po dniach\n",
    "        for koty in range(dzien):  # liczba kotów = nr dnia\n",
    "            n_cats += 1            # dodaj kota\n",
    "    return n_cats                  # dwie pętle -> n*n operacji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 4.43 s per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 licz_koty_v1(10000) # liczba kotów po 10 dniach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Koty Ali - algorytm II\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def licz_koty_v2(n):\n",
    "    \"\"\"Zwraca liczbę kotów po n dniach.\"\"\"\n",
    "    n_cats = 0                     # Ala nie ma kota\n",
    "    for dzien in range(1, n + 1):  # pętla po dniach\n",
    "        n_cats += dzien            # dodaj koty (= nr dnia)\n",
    "    return n_cats                  # jedna pętla -> n operacji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 904 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 licz_koty_v2(10000) # liczba kotów po 10 dniach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Koty Ali - algorytm III\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def licz_koty_v3(n):\n",
    "    \"\"\"Zwraca liczbę kotów po n dniach.\"\"\"\n",
    "    return n * (n + 1) // 2 # jedna operacja"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 535 ns per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 licz_koty_v3(10000) # liczba kotów po 10 dniach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Koty Ali - algorytm IV\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def licz_koty_v4(n):\n",
    "    \"\"\"Zwraca liczbę kotów po n dniach.\"\"\"\n",
    "    koty = list(range(n + 1)) # n zmiennych w pamięci\n",
    "    return sum(koty)          # jedna pętla -> n operacji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 411 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 licz_koty_v4(10000) # liczba kotów po 10 dniach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *range* vs *list(range)*\n",
    "\n",
    "---\n",
    "\n",
    "```\n",
    "$ python -m timeit -n10 'range(1000000)'\n",
    "10 loops, best of 3: 0.684 usec per loop\n",
    "\n",
    "$ python -m timeit -n10 'list(range(1000000))'\n",
    "10 loops, best of 3: 52.3 msec per loop\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Koty Ali - algorytm V\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def licz_koty_v5(n):\n",
    "    \"\"\"Zwraca liczbę kotów po n dniach.\"\"\"\n",
    "    return sum(range(n + 1)) # jedna pętla -> n operacji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 471 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 licz_koty_v5(10000) # liczba kotów po 10 dniach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Złożoność algorytmu\n",
    "\n",
    "---\n",
    "\n",
    "* złożoność czasowa -> liczba operacji\n",
    "* złożoność pamięciowa -> ilość potrzebnej pamięci\n",
    "\n",
    "|          | Alg I | Alg II     | Alg III | Alg IV     | Alg V      |\n",
    "|:--------:|:-----:|:----------:|:-------:|:----------:|:----------:|\n",
    "| operacje | $n^2$ | $n$        | $1$     | $n$        | n          |\n",
    "| pamięć   | $1$   | $1$        | $1$     | $n$        | 1          |\n",
    "| czas     | 4.6 s | 973 $\\mu$s | 768 ns  | 661 $\\mu$s | 475 $\\mu$s |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Wartość wielomianu\n",
    "\n",
    "---\n",
    "\n",
    "* Dany jest wielomian:\n",
    "\n",
    "$$ W(x) = a_0 + a_1\\cdot x + a_2 \\cdot x^2 + ... + a_n \\cdot x^n$$\n",
    "\n",
    "* Korzystając bezpośrednio z powyższgo wzoru należy wykonać $n$ dodawań oraz $1 + 2 + ... + n  = \\frac{n\\cdot(n+1)}{2}$ mnożeń"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Metoda naiwna\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def naive(a, x):\n",
    "    \"\"\"Zwraca wartość wielomianu o współczynnikach a w punkcie x.\"\"\"\n",
    "    result = 0\n",
    "    for i, ai in enumerate(a): # i - indeks, ai - współczynnik a_i\n",
    "        result += ai * x**i    # W(x) += a_i * x^i\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.1569220024001972e+274"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = range(500)\n",
    "x = 3.5\n",
    "\n",
    "naive(a, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 259 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 naive(a, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Schemat Hornera\n",
    "\n",
    "---\n",
    "\n",
    "* Zapisując wielomian w postaci:\n",
    "\n",
    "$$W(x) = a_0 + x\\cdot(a_1 + x\\cdot(a_2 + ... + x\\cdot(a_{n-1} + a_n\\cdot x)...)$$\n",
    "\n",
    "* organiczamy się do $n$ dodań i $n$ mnożeń"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Algorytm Hornera\n",
    "\n",
    "---\n",
    "\n",
    "$$W(x) = a_0 + x\\cdot(a_1 + x\\cdot(a_2 + ... + x\\cdot(a_{n-1} + a_n\\cdot x)...)$$\n",
    "\n",
    "* Niech\n",
    "\n",
    "$$b_n = a_n$$\n",
    "$$b_{n-1} = b_n\\cdot x + a_{n-1}$$\n",
    "$$b_{n-2} = n_{n-1}\\cdot x + a_{n-2}$$\n",
    "$$...$$\n",
    "$$b_1 = b_2\\cdot x + a_1$$\n",
    "$$b_0 = b_1\\cdot x + a_0$$\n",
    "\n",
    "* $b_0$ - wartość wielomianu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Horner vs Naive\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def horner(a, x):\n",
    "    \"\"\"Zwraca wartość wielomianu o współczynnikach a w punkcie x.\"\"\"\n",
    "    result = 0\n",
    "    for w in a[-1::-1]:         # \"reverse\"\n",
    "        result = result * x + w # b_i = b_{i-1} * x + a_i\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.156922002400198e+274"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = range(500)\n",
    "x = 3.5\n",
    "\n",
    "horner(a, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 98.1 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 horner(a, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 257 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 naive(a, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Złożoność algorytmów\n",
    "\n",
    "---\n",
    "\n",
    "* czas w zależności od rozmiaru danych (N)\n",
    "* zajęta pamięć (pomijając dane wejściowe)\n",
    "* najczęściej interesuje nas złożoność asymptotyczna (dla dużych N)\n",
    "* np. które człony $$f(n) = n^3 +10\\cdot n^2 + 100\\cdot n + 1000\\cdot\\ln(n)$$ są znaczące?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wkłady od różnych członów\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def terms(f):\n",
    "    \"\"\"Zwraca kolejne człony funkcji f (oddzielone +).\"\"\"    \n",
    "    return [term.strip() for term in f.split('+')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['n**2', '10*n']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "terms(\"n**2 + 10*n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def eval_f(f, n = 1):\n",
    "    \"\"\"Zwraca wartość funkcji f w punkcie n.\"\"\"\n",
    "    return eval(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "75"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval_f(\"n**2 + 10*n\", n = 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wkłady od różnych członów\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def eval_terms(*terms, n = 1):\n",
    "    \"\"\"Zwraca wartości kolejnych członów w punkcie n.\"\"\"\n",
    "    return [eval_f(term, n) for term in terms]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25, 50)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval_f(\"n**2\", n = 5), eval_f(\"10*n\", n = 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[25, 50]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval_terms(*terms(\"n**2 + 10*n\"), n = 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wkłady od różnych członów\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def print_cell(cell, width=10):\n",
    "    \"\"\"Drukuje pojedynczą komórkę w tabeli.\"\"\"\n",
    "    print(str(cell).rjust(width), end=' |')\n",
    "\n",
    "def table_head(f, width=10):\n",
    "    \"\"\"Drukuje pierwsze rząd tabeli.\"\"\"\n",
    "    print_cell(\"n\", width)\n",
    "    for term in terms(f):\n",
    "        print_cell(term, width)\n",
    "    print(\"\\n\" + \"-\" * width * (len(terms(f)) + 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         n |      n**2 |      10*n |\n",
      "----------------------------------------\n"
     ]
    }
   ],
   "source": [
    "table_head(\"n**2 + 10*n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wkłady od różnych członów\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def f_as_table(f, *args, width=10):\n",
    "    \"\"\"Drukuje tabelę z procentowym wkładem każdego członu.\"\"\"\n",
    "    table_head(f, width)\n",
    "    for n in args:\n",
    "        print_cell(n, width)\n",
    "        f_val = eval_f(f, n)\n",
    "        for term in eval_terms(*terms(f), n = n):\n",
    "            print_cell(round(term / f_val * 100), width)\n",
    "        print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    n | n**2 | 10*n |\n",
      "--------------------\n",
      "    1 |    9 |   91 |\n",
      "   10 |   50 |   50 |\n",
      "  100 |   91 |    9 |\n"
     ]
    }
   ],
   "source": [
    "f_as_table(\"n**2 + 10*n\", 1, 10, 100, width=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wkłady od różnych członów\n",
    "\n",
    "---\n",
    "\n",
    "$$f(n) = n^3 +10\\cdot n^2 + 100\\cdot n + 1000\\cdot\\ln(n)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           n |        n**3 |     10*n**2 |       100*n | 1000*log(n) |\n",
      "------------------------------------------------------------------------\n",
      "           1 |           1 |           9 |          90 |           0 |\n",
      "          10 |          19 |          19 |          19 |          43 |\n",
      "         100 |          90 |           9 |           1 |           0 |\n",
      "        1000 |          99 |           1 |           0 |           0 |\n",
      "       10000 |         100 |           0 |           0 |           0 |\n"
     ]
    }
   ],
   "source": [
    "from math import log\n",
    "\n",
    "n = [10**i for i in range(5)]\n",
    "f_as_table(\"n**3 + 10*n**2 + 100*n + 1000*log(n)\", *n, width=12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Notacja dużego &Omicron;\n",
    "\n",
    "---\n",
    "\n",
    "* Funkcja $f(n)$ jest $O(g(n))$, jeśli istnieją liczby dodatnie $c$ i $n_0$, takie że:\n",
    "\n",
    "$$\\forall_{n>n_0} ~~~~~ f(n) < c\\cdot g(n)$$\n",
    "\n",
    "* Jeśli $f_1(n) \\in O(g(n))$ i $f_2(n) \\in O(g(n))$, to:\n",
    "\n",
    "$$f_1(n) + f_2(n) \\in O(g(n))$$\n",
    "$$f_1(n) \\cdot f_2(n) \\in O(g^2(n))$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Notacja dużego &Omicron; - przykład\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from math import log\n",
    "\n",
    "n = np.arange(1, 50, 1) # kolejne liczby naturalne\n",
    "f = [n**3 + 10*n**2 + 100*n + 1000*log(n) for n in n] # wartości f(n)\n",
    "g = [2*n**3 for n in n] # wartości g(n)\n",
    "\n",
    "f_plot, = plt.plot(n, f, 'rs', label=\"$f(n) = n^3 + 10\\cdot n^2 + 100\\cdot n + 1000\\cdot\\ln(n)$\")\n",
    "g_plot, = plt.plot(n, g, 'bo', label=\"$g(n) = 2\\cdot n^3$\")\n",
    "\n",
    "legend = plt.legend(handles=[f_plot, g_plot], loc=2)\n",
    "\n",
    "line = plt.plot((22, 22), (0, 150000), 'k--')\n",
    "\n",
    "label = plt.text(52, 75000, \"$\\\\forall_{n\\geq 22}$   $g(n) > f(n)$ \\n\\n\"\n",
    "                            \"$f(n) \\in O(n^3)$\", fontsize=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxwAAAFkCAYAAACq6T2NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f44113154a8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Przykłady rzędów złożoności - $O(1)$\n",
    "\n",
    "---\n",
    "\n",
    "* Proste operacje: arytmetyczne, logiczne, porównania, przypisania, dostęp do struktury danych"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def constant(n):\n",
    "    return n*n # jedna operacja -> O(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Przykłady rzędów złożoności - $O(n)$\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def linear(n):\n",
    "    result = 0 # 1 * operacja\n",
    "    for element in n:     # n * operacja\n",
    "        result += element # n * operacja\n",
    "        result *= 0.1     # n * operacja\n",
    "    return suma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* ostatecznie mamy $3n + 1$ operacji, więc złożoność asymptotyczna -> $O(n)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Przykłady rzędów złożoności - $O(n)$\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def linear(n):\n",
    "    for element in n:\n",
    "        if element == 0:\n",
    "            return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* złożoność asymptotyczna -> $O(n)$\n",
    "* może być lepsza (nawet $O(1)$), ale w najgorszym wypadku będzie *n* operacji"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Przykłady rzędów złożoności - $O(n + m)$\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def linear(n, m):\n",
    "    result = 0\n",
    "    \n",
    "    for element in n:\n",
    "        result += element\n",
    "    \n",
    "    for element in n:\n",
    "        result += element\n",
    "        \n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* dwie pętle: $O(n)$ i $O(m)$\n",
    "* złożoność asymptotyczna $O(n+m)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Przykłady rzędów złożoności - $O(n^2)$\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def quadratic(n):\n",
    "    result = 0\n",
    "    for i in range(n):\n",
    "        for j in range(i, n):\n",
    "            result += 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* pętla zewnętrzna -> $n$ razy\n",
    "* pętla wewnętrzna -> $(n-i)$ razy\n",
    "* w sumie $1 + 2 + ... + n = \\frac{n\\cdot(n + 1)}{2} = \\frac{1}{2}n^2 + \\frac{1}{2}n$\n",
    "* złożoność asymptotyczna: $O(n^2) + O(n) = O(n^2)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Przykłady rzędów złożności - $O(\\log n)$\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def logarithmic(n):\n",
    "    result = 0\n",
    "    while n > 1:\n",
    "        n //= 2\n",
    "        result += 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* w każdej iteracji zmniejszamy $n$ dwukrotnie\n",
    "* jeśli $n = 2^x$, to wykonamy $\\log n$ operacji\n",
    "* algorytm jest $O(\\log n)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Porównanie złożoności\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from math import log\n",
    "\n",
    "n = np.arange(1, 100, 1)  # kolejne liczby naturalne\n",
    "f = [n for n in n]        # zależność liniowa\n",
    "g = [n**2 for n in n]     # zależność kwadratowa\n",
    "h = [log(n) for n in n]   # zależność logarytmiczna\n",
    "i = [n*log(n) for n in n] # zależność liniowo-logarytmiczna\n",
    "\n",
    "g_plot, = plt.plot(n, g, 'b.', label=\"$n^2$\")\n",
    "i_plot, = plt.plot(n, i, 'k.', label=\"$n\\log n$\")\n",
    "f_plot, = plt.plot(n, f, 'r.', label=\"$n$\")\n",
    "h_plot, = plt.plot(n, h, 'g.', label=\"$\\log n$\")\n",
    "\n",
    "plt.yscale(\"log\")\n",
    "\n",
    "legend = plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoUAAAFnCAYAAADQTTPAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f43dff85dd8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# na wszelki wypadek do testów sortowania dużych tablic\n",
    "import sys\n",
    "sys.setrecursionlimit(10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sortowanie bąbelkowe (*bubble sort*)\n",
    "\n",
    "---\n",
    "\n",
    "1. porównuj cyklicznie dwa sąsiadujące elementy\n",
    "2. zmień kolejność jeśli zaburzają porządek\n",
    "3. przerwij, jeśli nie ma co zmieniać"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sortowanie bąbelkowe - przykład\n",
    "\n",
    "---\n",
    "\n",
    "[<b style='color:red'>3</b>, <b style='color:red'>6</b>, 4, 2] --> [3, <b style='color:blue'>6</b>, <b style='color:blue'>4</b>, 2] --> [3, 4, <b style='color:blue'>6</b>, <b style='color:blue'>2</b>] --> [3, 4, 2, 6]\n",
    "\n",
    "[<b style='color:red'>3</b>, <b style='color:red'>4</b>, 2, 6] --> [3, <b style='color:blue'>4</b>, <b style='color:blue'>2</b>, 6] --> [3, 2, <b style='color:red'>4</b>, <b style='color:red'>6</b>] --> [3, 2, 4, 6]\n",
    "\n",
    "[<b style='color:blue'>3</b>, <b style='color:blue'>2</b>, 4, 6] --> [2, <b style='color:red'>3</b>, <b style='color:red'>4</b>, 6] --> [2, 3, <b style='color:red'>4</b>, <b style='color:red'>6</b>] --> [2, 3, 4, 6]\n",
    "\n",
    "[<b style='color:red'>2</b>, <b style='color:red'>3</b>, 4, 6] --> [2, <b style='color:red'>3</b>, <b style='color:red'>4</b>, 6] --> [2, 3, <b style='color:red'>4</b>, <b style='color:red'>6</b>] --> [2, 3, 4, 6]\n",
    "\n",
    "*(brak zmian -> koniec)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Implementacja\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def bubblesort(lst):\n",
    "    \"\"\"Sortuje podaną listę.\"\"\"\n",
    "    n = len(lst) # liczba elementów\n",
    "    while True:  # powtarzaj do break\n",
    "        swapped = False # ustaw flagę na fałsz\n",
    "        for i in range(n-1): # pętla od 0 do n-2\n",
    "            if lst[i] > lst[i+1]: # porządek zaburzony\n",
    "                lst[i], lst[i+1] = lst[i+1], lst[i] # podmień\n",
    "                swapped = True # ustaw flagę na prawdę\n",
    "        if not swapped: # przerwij jeśli nie było zmian\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "x = [3, 6, 4, 2]\n",
    "\n",
    "bubblesort(x)\n",
    "     \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Krok po kroku\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def bubblesort_v1(lst):\n",
    "    \"\"\"Sortuje podaną listę.\"\"\"\n",
    "    n = len(lst) # liczba elementów\n",
    "    while True:  # powtarzaj do break\n",
    "        swapped = False # ustaw flagę na fałsz\n",
    "        print(lst, end=' ')\n",
    "        for i in range(n-1): # pętla od 0 do n-2\n",
    "            if lst[i] > lst[i+1]: # porządek zaburzony\n",
    "                lst[i], lst[i+1] = lst[i+1], lst[i] # podmień\n",
    "                swapped = True # ustaw flagę na prawdę\n",
    "            print(\"->\", lst, end=' ')\n",
    "        print()\n",
    "        if not swapped: # przerwij jeśli nie było zmian\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 4, 2] -> [3, 6, 4, 2] -> [3, 4, 6, 2] -> [3, 4, 2, 6] \n",
      "[3, 4, 2, 6] -> [3, 4, 2, 6] -> [3, 2, 4, 6] -> [3, 2, 4, 6] \n",
      "[3, 2, 4, 6] -> [2, 3, 4, 6] -> [2, 3, 4, 6] -> [2, 3, 4, 6] \n",
      "[2, 3, 4, 6] -> [2, 3, 4, 6] -> [2, 3, 4, 6] -> [2, 3, 4, 6] \n"
     ]
    }
   ],
   "source": [
    "bubblesort_v1([3, 6, 4, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Optymalizacja I\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def bubblesort_v2(lst):\n",
    "    \"\"\"Sortuje podaną listę.\"\"\"\n",
    "    n = len(lst) # liczba elementów\n",
    "    while True:  # powtarzaj do break\n",
    "        swapped = False # ustaw flagę na fałsz\n",
    "        print(lst, end=' ')\n",
    "        for i in range(n-1): # pętla od 0 do n-2\n",
    "            if lst[i] > lst[i+1]: # porządek zaburzony\n",
    "                lst[i], lst[i+1] = lst[i+1], lst[i] # podmień\n",
    "                swapped = True # ustaw flagę na prawdę\n",
    "            print(\"->\", lst, end=' ')\n",
    "        print()\n",
    "        if not swapped: # przerwij jeśli nie było zmian\n",
    "            break\n",
    "        n -= 1 # n-te przejście -> n-ty największy na miejscu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 4, 2] -> [3, 6, 4, 2] -> [3, 4, 6, 2] -> [3, 4, 2, 6] \n",
      "[3, 4, 2, 6] -> [3, 4, 2, 6] -> [3, 2, 4, 6] \n",
      "[3, 2, 4, 6] -> [2, 3, 4, 6] \n",
      "[2, 3, 4, 6] \n"
     ]
    }
   ],
   "source": [
    "bubblesort_v2([3, 6, 4, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Optymalizacja II\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def bubblesort_v3(lst):\n",
    "    \"\"\"Sortuje podaną listę.\"\"\"\n",
    "    n = len(lst) # liczba elementów\n",
    "    while n > 0:\n",
    "        new_n = 0 # miejsce ostatniej zmiany\n",
    "        print(lst, end=' ')\n",
    "        for i in range(n-1): # pętla od 0 do n-2\n",
    "            if lst[i] > lst[i+1]: # porządek zaburzony\n",
    "                lst[i], lst[i+1] = lst[i+1], lst[i] # podmień\n",
    "                new_n = i + 1 # indeks ostatniej zmiany\n",
    "            print(\"->\", lst, end=' ')\n",
    "        print(\"new_n =\", new_n)\n",
    "        n = new_n # ostatnie przejście -> reszta musi być na miejscu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 4, 2] -> [3, 6, 4, 2] -> [3, 4, 6, 2] -> [3, 4, 2, 6] new_n = 3\n",
      "[3, 4, 2, 6] -> [3, 4, 2, 6] -> [3, 2, 4, 6] new_n = 2\n",
      "[3, 2, 4, 6] -> [2, 3, 4, 6] new_n = 1\n",
      "[2, 3, 4, 6] new_n = 0\n"
     ]
    }
   ],
   "source": [
    "bubblesort_v3([3, 6, 4, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Złożoność *bubblesort*\n",
    "\n",
    "---\n",
    "\n",
    "* $n$ operacji -> co najmniej ostatni na swoim miejscu\n",
    "* $(n-1)$ operacji -> dwa ostatnie na swoim miejscu\n",
    "* $(n-2)$ operacji -> trzy na swoim miejscu itd...\n",
    "* $n + (n-1) + (n-2) + ... = O(n^2)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sortowanie przez scalanie (*mergesort*)\n",
    "\n",
    "---\n",
    "\n",
    "* podziel nieposortowaną listę na $n$ \"podlist\" zawierających po jednym elemencie\n",
    "* cyklicznie *scalaj* \"podlisty\" w posortowane \"podlisty\", aż zostanie jedna\n",
    "\n",
    "Start: [3, 6, 4, 2]\n",
    "\n",
    "Split: [3] [6] [4] [2]\n",
    "\n",
    "Merge: [3, 6] [2, 4]\n",
    "\n",
    "Merge: [2, 3, 4, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Algorytm scalania\n",
    "\n",
    "---\n",
    "\n",
    "* mając dwie uporządkowane listy\n",
    "* porównaj skrajne elementy i mniejszy zapisz w liście wyjściowej\n",
    "* powtarzaj dopóki jedna z list się nie skończy\n",
    "* resztę dopisz na koniec wyjściowej listy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Algorytm scalania - przykład\n",
    "\n",
    "---\n",
    "\n",
    "[<b style='color:blue'>1</b>, 6, 7] + [<b style='color:red'>2</b>, 3, 4, 5, 8, 9] --> [1]\n",
    "\n",
    "[<b style='color:red'>6</b>, 7] + [<b style='color:blue'>2</b>, 4, 5, 8, 9] --> [1, 2]\n",
    "\n",
    "[<b style='color:red'>6</b>, 7] + [<b style='color:blue'>3</b>, 4, 5, 8, 9] --> [1, 2, 3]\n",
    "\n",
    "[<b style='color:red'>6</b>, 7] + [<b style='color:blue'>4</b>, 5, 8, 9] --> [1, 2, 3, 4]\n",
    "\n",
    "[<b style='color:red'>6</b>, 7] + [<b style='color:blue'>5</b>, 8, 9] --> [1, 2, 3, 4, 5]\n",
    "\n",
    "[<b style='color:red'>6</b>, 7] + [<b style='color:blue'>8</b>, 9] --> [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "[<b style='color:blue'>7</b>] + [<b style='color:red'>8</b>, 9] --> [1, 2, 3, 4, 5, 6, 7]\n",
    "\n",
    "[] + [8, 9] --> [1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Algorytm scalania - implementacja\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def merge(A, B):\n",
    "    \"\"\"Scala posortowane listy zachowując porządek elementów.\"\"\"\n",
    "    result = [] # scalona lista\n",
    "    while len(A) and len(B): # dopoki obie mają elementy\n",
    "        # dodaj mniejszy element (usuwając go jednocześnie z listy)\n",
    "        if A[0] < B[0]:\n",
    "            result.append(A.pop(0))\n",
    "        else:\n",
    "            result.append(B.pop(0))\n",
    "    \n",
    "    result.extend(A) # dodaj resztę \n",
    "    result.extend(B) # (jeśli została)\n",
    "        \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merge([1, 6, 7], [2, 3, 4, 5, 8, 9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sortowanie przez scalanie - przykład\n",
    "\n",
    "---\n",
    "\n",
    "Start: [1, 4, 2, 5, 6, 3, 9, 7, 8]\n",
    "\n",
    "Split: [1] [4] [2] [5] [6] [3] [9] [7] [8]\n",
    "\n",
    "Merge: [1, 4] [2, 5] [3, 6] [7, 9] [8]\n",
    "\n",
    "Merge: [1, 2, 4, 5] [3, 6, 7, 9] [8]\n",
    "\n",
    "Merge: [1, 2, 3, 4, 5, 6, 7, 9] [8]\n",
    "\n",
    "Merge: [1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sortowanie przez scalanie - implementacja\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def mergesort(lst):\n",
    "    \"\"\"Sortuje podaną listę.\"\"\"\n",
    "    if len(lst) < 2: # lista jednoelementowa\n",
    "        return lst   # nie wymaga sortowania\n",
    "    \n",
    "    middle = len(lst) // 2 # środek listy\n",
    "    \n",
    "    left = mergesort(lst[:middle])  # dziel na dwie części\n",
    "    right = mergesort(lst[middle:]) # i wywołaj merge_sort (rekurencja)\n",
    "    \n",
    "    return merge(left, right) # scal dwie listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mergesort([1, 4, 2, 5, 6, 3, 9, 7, 8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Krok po kroku\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def mergesort_p(lst):\n",
    "    \"\"\"Sortuje podaną listę.\"\"\"\n",
    "    if len(lst) < 2: # lista jednoelementowa\n",
    "        return lst   # nie wymaga sortowania\n",
    "    \n",
    "    middle = len(lst) // 2 # środek listy\n",
    "    \n",
    "    left = mergesort_p(lst[:middle])  # dziel na dwie części\n",
    "    right = mergesort_p(lst[middle:]) # i wywołaj merge_sort (rekurencja)\n",
    "    \n",
    "    # drukuj obecny stan\n",
    "    # użyj kopii, żeby nie modyfikowac tablic\n",
    "    print(\"left =\", left, \"\\tright =\", right,\n",
    "          \"\\t-->\", merge(left.copy(), right.copy()))\n",
    "    \n",
    "    return merge(left, right) # scal dwie listy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Krok po kroku\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "left = [1] \tright = [4] \t--> [1, 4]\n",
      "left = [2] \tright = [5] \t--> [2, 5]\n",
      "left = [1, 4] \tright = [2, 5] \t--> [1, 2, 4, 5]\n",
      "left = [6] \tright = [3] \t--> [3, 6]\n",
      "left = [7] \tright = [8] \t--> [7, 8]\n",
      "left = [9] \tright = [7, 8] \t--> [7, 8, 9]\n",
      "left = [3, 6] \tright = [7, 8, 9] \t--> [3, 6, 7, 8, 9]\n",
      "left = [1, 2, 4, 5] \tright = [3, 6, 7, 8, 9] \t--> [1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mergesort_p([1, 4, 2, 5, 6, 3, 9, 7, 8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Złożoność *mergesort*\n",
    "\n",
    "---\n",
    "\n",
    "* $\\log_2 n + 1$ *poziomów*\n",
    "* na każdym $n$ operacji\n",
    "* złożoność czasowa -> $O(n\\cdot\\log n)$\n",
    "* złożoność pamięciowa -> $O(n)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sortowanie szybkie (*quicksort*)\n",
    "\n",
    "---\n",
    "\n",
    "* wybierz element rozdzielający (*pivot*)\n",
    "* elementy nie większe przenieś \"na lewo\", resztę \"na prawo\"\n",
    "* powtórz rekurencyjnie dla części \"lewej\" i \"prawej\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sortowanie szybkie - przykład\n",
    "\n",
    "---\n",
    "\n",
    "[1, 4, 2, 5, **6**, 3, 9, 7, 8] -> [<font style='color:blue'>1, 4, 2, 5, 3</font>, **6**, <font style='color:green'>9, 7, 8</font>]\n",
    "\n",
    "<font style='color:blue'>[1, 4, **2**, 5, 3]</font> -> [1, **2**, <font style='color:red'>4, 5, 3</font>]\n",
    "\n",
    "<font style='color:red'>[4, **5**, 3]</font> -> [<font style='color:purple'>4, 3</font>, **5**]\n",
    "\n",
    "<font style='color:purple'>[4, **3**]</font> -> [**3**, 4]\n",
    "\n",
    "<font style='color:green'>[9, **7**, 8]</font> -> [**7**, <font style='color:orange'>9, 8</font>]\n",
    "\n",
    "<font style='color:orange'>[**9**, 8]</font> -> [8, **9**]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sortowanie szybkie - *pivot*\n",
    "\n",
    "---\n",
    "\n",
    "* kluczowy jest wybór elementu rozdzielającego \n",
    "* przeciętnie, złożoność algorytmu $O(n\\cdot\\log n)$, gdy dzielimy dane na mniej więcej dwa równe podzbiory\n",
    "* gdy *pivot* jest wartością skrajną, to mamy jeden podzbiór $1$-elementowy i drugi $(n-1)$-elementowy; wtedy złożoność algorytmu $O(n^2)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *pivot* - wybór\n",
    "\n",
    "---\n",
    "\n",
    "* stały element: brzeg lub środek -> kiepski wybór\n",
    "* losowy -> teoretycznie kiepski, ale w praktyce się sprawdza\n",
    "* mediana -> dobry wybór, ale kosztowny\n",
    "* *mediana z trzech* -> mediana z pierwszego, ostatniego i środkowego"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Implementacja *quicksort*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# \"jednolinijkowy if\"- niezalecany (na potrzeby slajdu)\n",
    "def quicksort(lst):\n",
    "    \"\"\"Sortuje podaną listę.\"\"\"\n",
    "    if not len(lst): return lst # nie ma co sortować\n",
    "    \n",
    "    left, middle, right = [], [], [] # mniejsze, równe, większe\n",
    "    \n",
    "    pivot = lst[0] # kiepski wybór\n",
    "    \n",
    "    for x in lst:\n",
    "        if x < pivot: left.append(x)\n",
    "        elif x > pivot: right.append(x)\n",
    "        else: middle.append(x)\n",
    "            \n",
    "    # wywołaj rekurencyjnie dla \"lewej\" i \"prawej\" części\n",
    "    return quicksort(left) + middle + quicksort(right)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quicksort([1, 4, 2, 5, 6, 3, 9, 7, 8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## *mergesort* vs *quicksort*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "# 1000 losowych liczb od 0 do 999\n",
    "x = random.sample(range(10000), 10000) \n",
    "y = x.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 44.7 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 quicksort(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 114 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 mergesort(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 97.1 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 quicksort(list(range(1000)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 5.73 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 mergesort(list(range(1000)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *bubblesort* vs *mergesort* vs *quicksort*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def bubblesort(lst):\n",
    "    \"\"\"Sortuje podaną listę.\"\"\"\n",
    "    n = len(lst) # liczba elementów\n",
    "    while n > 0:\n",
    "        new_n = 0 # miejsce ostatniej zmiany\n",
    "        for i in range(n-1): # pętla od 0 do n-2\n",
    "            if lst[i] > lst[i+1]: # porządek zaburzony\n",
    "                lst[i], lst[i+1] = lst[i+1], lst[i] # podmień\n",
    "                new_n = i + 1 # indeks ostatniej zmiany\n",
    "        n = new_n # ostatnie przejście -> reszta musi być na miejscu\n",
    "        \n",
    "def merge(A, B):\n",
    "    \"\"\"Scala posortowane listy zachowując porządek elementów.\"\"\"\n",
    "    result = [] # scalona lista\n",
    "    while len(A) and len(B): # dopoki obie mają elementy\n",
    "        # dodaj mniejszy element (usuwając go jednocześnie z listy)\n",
    "        if A[0] < B[0]:\n",
    "            result.append(A.pop(0))\n",
    "        else:\n",
    "            result.append(B.pop(0))\n",
    "    \n",
    "    result.extend(A) # dodaj resztę \n",
    "    result.extend(B) # (jeśli została)\n",
    "        \n",
    "    return result\n",
    "\n",
    "def mergesort(lst):\n",
    "    \"\"\"Sortuje podaną listę.\"\"\"\n",
    "    if len(lst) < 2: # lista jednoelementowa\n",
    "        return lst   # nie wymaga sortowania\n",
    "    \n",
    "    middle = len(lst) // 2 # środek listy\n",
    "    \n",
    "    left = mergesort(lst[:middle])  # dziel na dwie części\n",
    "    right = mergesort(lst[middle:]) # i wywołaj merge_sort (rekurencja)\n",
    "    \n",
    "    return merge(left, right) # scal dwie listy\n",
    "\n",
    "def quicksort(lst):\n",
    "    \"\"\"Sortuje podaną listę.\"\"\"\n",
    "    if not len(lst): # nie ma co sortować\n",
    "        return lst\n",
    "    \n",
    "    left = []   # elementy mniejsze\n",
    "    middle = [] # elementy równe\n",
    "    right = []  # elementy większe\n",
    "    \n",
    "    pivot = lst[0] # kiepski wybór\n",
    "    \n",
    "    for x in lst:\n",
    "        if x < pivot: left.append(x)\n",
    "        elif x > pivot: right.append(x)\n",
    "        else: middle.append(x)\n",
    "            \n",
    "    # wywołaj rekurencyjnie dla \"lewej\" i \"prawej\" części\n",
    "    return quicksort(left) + middle + quicksort(right)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from timeit import timeit\n",
    "import random\n",
    "\n",
    "sizes = [10, 50, 100, 500, 1000, 5000, 10000]\n",
    "bsort, msort, qsort = [], [], [] # wyniki timeit\n",
    "         \n",
    "for size in sizes:\n",
    "    x = random.sample(range(size), size)\n",
    "    y = x.copy()\n",
    "    z = x.copy()\n",
    "    \n",
    "    bs = timeit(\"bubblesort(x)\", number=1,\n",
    "                setup=\"from __main__ import bubblesort, x\")\n",
    "\n",
    "    ms = timeit(\"mergesort(y)\", number=1,\n",
    "                setup=\"from __main__ import mergesort, y\")\n",
    "\n",
    "    qs = timeit(\"quicksort(z)\", number=1,\n",
    "                setup=\"from __main__ import quicksort, z\")\n",
    "\n",
    "    bsort.append(bs)\n",
    "    msort.append(ms)\n",
    "    qsort.append(qs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *bubblesort* vs *mergesort* vs *quicksort*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAFsCAYAAABy5inVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\noQQAYBFKAACWABYOykVUGbSEAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f44040c8668>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "bs = plt.plot(sizes, bsort, 'bo', label=\"bubble\")\n",
    "ms = plt.plot(sizes, msort, 'ro', label=\"merge\")\n",
    "qs = plt.plot(sizes, qsort, 'go', label=\"quick\")\n",
    "\n",
    "plt.xscale(\"log\")\n",
    "plt.yscale(\"log\")\n",
    "\n",
    "legend = plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "\n",
       "<style>\n",
       "\n",
       ".rendered_html code {\n",
       "  font-size: 75%;\n",
       "}\n",
       "\n",
       "</style>\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# css prezentacji\n",
    "\n",
    "from IPython.display import display, HTML\n",
    "\n",
    "s = \"\"\"\n",
    "\n",
    "<style>\n",
    "\n",
    ".rendered_html code {\n",
    "  font-size: 75%;\n",
    "}\n",
    "\n",
    "</style>\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "display(HTML(s))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}