Laboratorium_3.ipynb

{
 "metadata": {
  "language": "ruby",
  "name": "",
  "signature": "sha256:541e730b07b69b0e1eba1b627181d7158522db92e6f27b3f63dcf491376a7e0d"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Liczby"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "W Rubim wyst\u0119puj\u0105 trzy podstawowe typu s\u0142u\u017c\u0105ce do reprezentacji liczb\n",
      "* `Fixnum`\n",
      "* `Bignum`\n",
      "* `Float`\n",
      "\n",
      "Pierwsze dwa typy s\u0142u\u017c\u0105 do reprezentacji liczba ca\u0142kowitych, a trzeci do reprezentacji liczb zmiennopozycyjnych. R\u00f3\u017cnica pomi\u0119dzy dwoma pierwszymi typami polega na tym, \u017ce w typie `Bignum` s\u0105 reprezentowane liczby, kt\u00f3re nie mog\u0105 by\u0107 przechowywane natywnie na wykorzystywanej architekturze sprz\u0119towej. O ile zatem nie reprezentujesz bardzo du\u017cych liczb, nie musisz za bardzo przejmowa\u0107 si\u0119 tym rozr\u00f3\u017cnieniem.\n",
      "\n",
      "Wa\u017cniejsze s\u0105 r\u00f3\u017cnice mi\u0119dzy typami `Fixnum` oraz `Float`.\n",
      "\n",
      "Aby stworzy\u0107 liczb\u0119 typu `Fixnum` po prostu wpisujemy jej warto\u015b\u0107 w reprezentacji dziesi\u0119tnej, np.\n",
      "\n",
      "```ruby\n",
      "5\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 2,
       "text": [
        "5"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Typ dowolnej zmiennej mo\u017cna pozna\u0107 za pomoc\u0105 wywo\u0142ania `class`\n",
      "\n",
      "```ruby\n",
      "5.class\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5.class"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "Fixnum"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Aby stworzy\u0107 liczb\u0119 typu `Float`, warto\u015b\u0107 liczby musi zawiera\u0107 kropk\u0119, np.\n",
      "\n",
      "```ruby\n",
      "5.0\n",
      "5.0.class\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5.0\n",
      "5.0.class"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "Float"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Mo\u017cliwe jest dodawanie liczb r\u00f3\u017cnych typ\u00f3w - nast\u0119puje wtedy automatyczna kowersja\n",
      "```ruby\n",
      "a = 5\n",
      "b = 10.0\n",
      "c = a + b\n",
      "c.class\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 5\n",
      "b = 10.0\n",
      "c = a + b\n",
      "#c.class"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 6,
       "text": [
        "15.0"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Na obu typach liczb mo\u017cna wykonywa\u0107 nast\u0119puj\u0105ce operacje arytmetyczne:\n",
      "\n",
      "|  Operator   | Dzia\u0142anie        |\n",
      "|-------------|------------------|\n",
      "| `+`         | dodawanie        |\n",
      "| `-`         | odejmowanie      |\n",
      "| `*`         | mno\u017cenie         |\n",
      "| `/`         | dzielenie        |\n",
      "| `%`         | dzielenie modulo |\n",
      "| `**`        | pot\u0119gowanie      |\n",
      "\n",
      "Przyk\u0142adowo\n",
      "\n",
      "```ruby\n",
      "(10**2 + 2 * 3) % 6\n",
      "```\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(10**2 + 2 * 3) % 6"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 7,
       "text": [
        "4"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Mo\u017cliwe jest r\u00f3wnie\u017c wykonywanie bardziej z\u0142o\u017conych operacji. Znajduj\u0105 si\u0119 one w module `Math`. \n",
      "Je\u015bli chcemy np. wyci\u0105gn\u0105\u0107 pierwiastek kwadratowy z liczby to piszemy\n",
      "```ruby\n",
      "Math.sqrt(2)\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Math.sqrt(2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "1.4142135623730951"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A logarytm naturalny to `Math.log`\n",
      "```ruby\n",
      "Math.log(2)\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Math.log(2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 9,
       "text": [
        "0.6931471805599453"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Wa\u017cne zastrze\u017cenie dotyczy operatora dzielenia - dzia\u0142a o inaczej dla liczb ca\u0142kowitych, a inaczej dla zmiennopozycyjnych.\n",
      "W przypadku tych pierwszych wynik jest liczb\u0105 ca\u0142kowit\u0105, wi\u0119c mamy do czynienia z dzieleniem modulo:\n",
      "```ruby\n",
      "10 / 3\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "10 / 3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 10,
       "text": [
        "3"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "W przypadku tych drugich mamy do czynienia z dzieleniem zwyk\u0142yw - wystarczy aby tylko jeden argument by\u0142 liczb\u0105 zmiennopozycyjn\u0105, aby ca\u0142e wyra\u017cenie by\u0142o traktowane jak dzielenie zwyk\u0142e\n",
      "```ruby\n",
      "10.0 / 3\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "10.0 / 3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 11,
       "text": [
        "3.3333333333333335"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Mo\u017cliwe jest r\u00f3wnie\u017c\u00a0dokonywanie kowersji pomi\u0119dzy tymi typami:\n",
      "```ruby\n",
      "5.5.to_i\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5.5.to_i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "5"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "```ruby\n",
      "5.to_f\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5.to_f"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 13,
       "text": [
        "5.0"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Warto zwr\u00f3ci\u0107 uwag\u0119, \u017ce zamiana na liczb\u0119 ca\u0142kowit\u0105 powoduje obci\u0119cie warto\u015bci u\u0142amkowej, bez zaokr\u0105glenia:\n",
      "```ruby\n",
      "5.6.to_i\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5.6.to_i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 14,
       "text": [
        "5"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Je\u015bli chcemy zaokr\u0105gli\u0107 warto\u015b\u0107, musimy najpierw u\u017cy\u0107 wywo\u0142ania `round`\n",
      "```ruby\n",
      "5.6.round.to_i\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5.6.round.to_i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 16,
       "text": [
        "6"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Cho\u0107 wydawa\u0107 si\u0119 mo\u017ce, \u017ce operacja na liczbach nie s\u0105 wywo\u0142aniami metod, to w rzeczywisto\u015bci nie jest to prawda. Ka\u017cde wyra\u017cenie artymetyczne mo\u017ce by\u0107 zamienione na swoj\u0105 posta\u0107 obiektow\u0105:\n",
      "```ruby\n",
      "5 + 2 * 3\n",
      "```\n",
      "to to samo co\n",
      "```ruby\n",
      "5.+(2.*(3))\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5.+(2.*(3))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 17,
       "text": [
        "11"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Wa\u017cne jest jednak to, \u017ce operatory artymetyczne maj\u0105\u00a0swoje naturalne priorytety, dlatego nie musimy obawia\u0107 si\u0119, \u017ce wszystkie wyra\u017cenia b\u0119d\u0105 ewaluowane od lewej do prawej, jak to ma miejsce w przypadku zwyk\u0142ego wywo\u0142ywania metod."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Poza najprostszymi operacjami arytmetycznymi, na liczbach mo\u017cna wywo\u0142ywa\u0107 wiele metod. Wcze\u015bniej widzieli\u015bmy ju\u017c metody `round`, `to_i` oraz `to_f`. Inne ciekawe metody to `zero?`\n",
      "```ruby\n",
      "0.zero?\n",
      "1.zero?\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "0.zero?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 18,
       "text": [
        "true"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "`between?`\n",
      "```ruby\n",
      "15.between(10,20)\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "15.between?(10,20)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 22,
       "text": [
        "true"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "`abs`\n",
      "```ruby\n",
      "-1.abs\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-10.abs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 30,
       "text": [
        "10"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "`succ`\n",
      "```ruby\n",
      "7.succ\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "687.succ"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 32,
       "text": [
        "688"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Oraz `times`\n",
      "```ruby\n",
      "3.times{ print \"Jestem komet\u0105. \" }\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "3.times{ print \"Jestem komet\u0105. \" }"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Jestem komet\u0105. "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Jestem komet\u0105. "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Jestem komet\u0105. "
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 23,
       "text": [
        "3"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Istniej\u0105 biblioteki, kt\u00f3re dodaj\u0105 bardziej zaawansowane metody do obiekt\u00f3w liczbowych. Np. biblioteka u\u017cywana `ActiveSupport` w Railsach pozwala na wykonywanie dzia\u0142a\u0144 arytmetycznych na datach\n",
      "```ruby\n",
      "require 'active_support/time'\n",
      "3.days.ago\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "require 'active_support/time'\n",
      "3.days.ago"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 24,
       "text": [
        "2015-10-18 15:45:43 +0200"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Zadanie 1"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Oblicz pierwsiatek trzeciego stopnia z 10. Wynik przedstaw w zaokr\u0105gleniu do dw\u00f3ch miejsc po przecinku."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(Math.cbrt(10)).round(2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 73,
       "text": [
        "2.15"
       ]
      }
     ],
     "prompt_number": 73
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Symbole"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Symbole w Rubim reprezentuj\u0105 *nazwy*. Symbole tworzone s\u0105 poprzez umieszczenie dwukropka na pocz\u0105tku nazwy:\n",
      "```ruby\n",
      ":name\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      ":name"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 33,
       "text": [
        ":name"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Symboli nie nale\u017cy myli\u0107 z napisami. Te drugie wykorzystywane s\u0105 do reprezentowania danych tekstowych, np. pochodz\u0105cych od u\u017cytkownika. Napisy mog\u0105 by\u0107 konkatenowane, mo\u017cna sprawdza\u0107 ich d\u0142ugo\u015b\u0107, etc. Tych operacji nie mo\u017cna wykonywa\u0107 na symbolach.\n",
      "Ponadto napisy s\u0105 modyfikowalne a symbole nie.\n",
      "\n",
      "\n",
      "Symbole s\u0105 nazwami wykorzystywanymi *wewn\u0105trz* programu. Z tego wzgl\u0119du, w przeciwie\u0144stwie do napis\u00f3w, dwa symbole, kt\u00f3re wygl\u0105daj\u0105 identycznie s\u0105 zawsze tym samym symbolem (maj\u0105 ten sam identyfikator).\n",
      "```ruby\n",
      ":name.equal?(:name)\n",
      "\"name\".equal?(\"name\")\n",
      "```\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"name\".equal?(\"name\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 35,
       "text": [
        "false"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Zakresy"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Zakresy to inny ciekawy element j\u0119zyka Ruby. Stosowane s\u0105 one do reprezentowania przedzia\u0142\u00f3w warto\u015bci. Wyr\u00f3\u017cnia si\u0119 dwa typy zakres\u00f3w - obustronnie domkni\u0119te, w kt\u00f3rych wyst\u0119puj\u0105 dwie kropki:\n",
      "```ruby\n",
      "(1..5)\n",
      "```\n",
      "oraz lewostronnie domkni\u0119te, w kt\u00f3rych wyst\u0119puj\u0105 3 kropki:\n",
      "```ruby\n",
      "(1...5)\n",
      "```\n",
      "\n",
      "R\u00f3\u017cnica pomi\u0119dzy nimi polega na tym, \u017ce pierwszy zakres obejmuje wszystkie wymienione warto\u015bci, a drugi zakres nie obejmuje warto\u015bci stoj\u0105cej po prawej stronie. Naj\u0142atwiej mo\u017cna si\u0119 o tym przekona\u0107, sprawdzaj\u0105c, czy jaka\u015b warto\u015b\u0107 nale\u017cy do zakresu za pomoc\u0105 metody `include?`:\n",
      "```ruby\n",
      "(1..5).include?(5)\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(1..5).include?(5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 36,
       "text": [
        "true"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "```ruby\n",
      "(1...5).include?(5)\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(1...5).include?(5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 37,
       "text": [
        "false"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Istniej\u0105 dwie podstawowe metody pozwalaj\u0105ce na sprawdzenie kres\u00f3w zakresu: `min` oraz `max`:\n",
      "```ruby\n",
      "(1..5).min\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(1..5).min"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 38,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 38
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "```ruby\n",
      "(1..5).max\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(1..5).max"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 39,
       "text": [
        "5"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "```ruby\n",
      "(1...5).max\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(1...5).max"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 40,
       "text": [
        "4"
       ]
      }
     ],
     "prompt_number": 40
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Zakresy s\u0105 cz\u0119sto wykorzystywane w r\u00f3\u017cnych wywo\u0142aniach, w szczeg\u00f3lno\u015bci tych zwi\u0105zanych ze strukturami sekwencyjnymi, np. napisami. Wywo\u0142uj\u0105c na napisie metod\u0119 `[]` w istocie korzystali\u015bmy z zakres\u00f3w:\n",
      "```ruby\n",
      "\"Ala ma kota\"[0..3]\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"Ala ma kota\"[0..3]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 41,
       "text": [
        "\"Ala \""
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Wa\u017cn\u0105 cech\u0105 zakres\u00f3w jest to, \u017ce zajmuj\u0105 one znacznie mniej pami\u0119ci ni\u017c np. tablice zawieraj\u0105ce wszystkie elementy nale\u017c\u0105ce do zakresu. Mo\u017cliwe jest jednak jawne przekszta\u0142cenie zakres\u00f3w w tablice, za pomoc\u0105 wywo\u0142ania `to_a`:\n",
      "```ruby\n",
      "(1..5).to_a\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(1..5).to_a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 43,
       "text": [
        "[1, 2, 3, 4, 5]"
       ]
      }
     ],
     "prompt_number": 43
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Ostatni\u0105 wa\u017cn\u0105 cech\u0105 zakres\u00f3w jest to, jak definiuj\u0105 one operator `===`. Operator ten zwr\u00f3ci warto\u015b\u0107 prawdy, je\u015bli warto\u015bc po prawej stronie nale\u017cy do zakresu. \n",
      "```ruby\n",
      "(1..5) === 3\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(1..5) === 3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 48,
       "text": [
        "true"
       ]
      }
     ],
     "prompt_number": 48
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "```ruby\n",
      "(1..5) === 7\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(1..5) === 7"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 49,
       "text": [
        "false"
       ]
      }
     ],
     "prompt_number": 49
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Dlatego w\u0142a\u015bnie mo\u017cliwe jest wykorzystanie zakres\u00f3w w instrukcji `case`:\n",
      "```ruby\n",
      "year = 1990\n",
      "case year\n",
      "when 1901..2000\n",
      "  \"XX wiek\"\n",
      "when 2001..2100\n",
      "  \"XXI wiek\"\n",
      "else\n",
      "  \"ciemne wieki\"\n",
      "end\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "year = 1690\n",
      "case year\n",
      "when 1901..2000\n",
      "  \"XX wiek\"\n",
      "when 2001..2100\n",
      "  \"XXI wiek\"\n",
      "else\n",
      "  \"ciemne wieki\"\n",
      "end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 51,
       "text": [
        "\"ciemne wieki\""
       ]
      }
     ],
     "prompt_number": 51
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Zadanie 2"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Korzystaj\u0105c z poprzedniego przyk\u0142adu zdefiniuj algorytm, kt\u00f3ry b\u0119dzie zamienia\u0142 warto\u015bci liczbowe w notacji arabskiej  na notacj\u0119 rzymsk\u0105\u00a0w przedziale od 1 do 10."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "def to_roman(value)\n",
      "\n",
      "  case value\n",
      "    when 1..3\n",
      "    puts \"I\" * value\n",
      "    when 4\n",
      "    puts \"IV\"\n",
      "    when 5..8\n",
      "    puts \"V\" + \"I\" * (value - 5)\n",
      "    when 9\n",
      "    puts \"IX\"\n",
      "    when 10\n",
      "    puts \"X\"\n",
      "  \n",
      "\n",
      "  end\n",
      "  \n",
      "end\n",
      "\n",
      "(1..10).each{|v| to_roman(v)}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "II\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "III\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "IV\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "V\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "VI\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "VII\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "VIII\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "IX\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "X\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 74,
       "text": [
        "1..10"
       ]
      }
     ],
     "prompt_number": 74
    }
   ],
   "metadata": {}
  }
 ]
}