{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cvičení č. 5 rozšířené o poznámky ze cvičení a řešení některých příkladů (ZS 2026/27)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### V minulém díle jste viděli..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data, se kterými pracuje počítač, jsou vždy zakódována v binární soustavě, bez ohledu na to, v jaké soustavě nebo multimediální reprezentaci jsou zobrazena uživateli na výstupu nebo vstupu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Základní aritmetické typů v jazyku Python jsou `bool`, `int`, `float` a `complex`.\n",
    "Kromě booleovských konstant `True` a `False` existuje také speciální hodnota `None`, která má svůj vlastní typ.\n",
    "Čísla můžeme zadávat v desítkové, dvojkové, osmičkové nebo šestnáctkové soustavě:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "9\n",
      "17\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(11)\n",
    "print(0o11)\n",
    "print(0x11)\n",
    "print(0b11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S číselnými hodnotami můžeme provádět běžné aritmetické operace pomocí operátorů `+`, `-`, `*`, `/`, `//`, `%` a `**`.\n",
    "Také jsou k dispozici funkce `abs`, `min`, `max` a můžeme importovat modul `math` pro zpřístupnění matematických konstant a funkcí:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Číslo π je přibližně 3.141592653589793\n",
      "Hodnota cos(π) je  -1.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print(\"Číslo π je přibližně\", math.pi)\n",
    "print(\"Hodnota cos(π) je \", math.cos(math.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Komentáře v jazyku Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Důležitým prvkem programovacích jazyků, který však nemá vliv na vykonávání kódu, jsou komentáře.\n",
    "__Komentáře__ ve zdrojovém kódu programu slouží programátorům k bližšímu vysvětlení příkazu nebo bloku příkazů, které se v programu vyskytují, a umožňují tak program učinit pro lidi pochopitelnějším.\n",
    "Na rozdíl od ostatních prvků jazyka Python nejsou komentáře vázány žádnými syntaktickými pravidly – interpret je zcela ignoruje, pro něj je komentář ekvivalentem mezery: kam se smí vložit mezera, tam se smí vložit komentář.\n",
    "\n",
    "V jazyku Python komentáře začínají znakem `#` a končí na konci řádku:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# první komentář\n",
    "a = 1\n",
    "b = 2 # druhý komentář\n",
    "c = 3 # třetí komentář"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pokud je komentář delší, typicky pokud komentuje několik příkazů společně, můžeme jej rozdělit na několik řádků.\n",
    "Takové _blokové komentáře_ je běžné psát __před kód, který komentují__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obvod kruhu je 9.42477796076938\n"
     ]
    }
   ],
   "source": [
    "# Zde nastavíme poloměr kruhu, spočítáme jeho obvod,\n",
    "# a výslednou hodnotu vypíšeme pomocí funkce print.\n",
    "import math\n",
    "r = 1.5\n",
    "obvod = 2 * math.pi * r\n",
    "print(\"Obvod kruhu je\", obvod)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obvod kruhu je 9.42477796076938\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Zde nastavíme poloměr kruhu, spočítáme jeho obvod,\n",
    "a výslednou hodnotu vypíšeme pomocí funkce print.\n",
    "\"\"\"\n",
    "r = 1.5\n",
    "obvod = 2 * math.pi * r\n",
    "print(\"Obvod kruhu je\", obvod)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obvod kruhu je 9.42477796076938\n"
     ]
    }
   ],
   "source": [
    "4 + 3\n",
    "r = 1.5\n",
    "obvod = 2 * math.pi * r\n",
    "print(\"Obvod kruhu je\", obvod)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strukturování programu: podmínky a cykly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Potřebujeme-li se v programu rozhodnout, jak dále řešit zadanou úlohu, používáme __podmíněný příkaz__, který vyhodnotí zadanou podmínku a na základě obdrženého výsledku se rozhodne, které příkazy bude provádět dál.\n",
    "Dalším velmi častým prvkem pro strukturování programu jsou __cykly__, které umožňují provádět určité příkazy opakovaně."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Podmíněný příkaz\n",
    "\n",
    "Podmíněný příkaz začíná klíčovým slovem `if`, za nímž následuje podmínka a dvojtečka (znak `:`).\n",
    "Podmínku podmíněného příkazu může tvořit libovolný booleovský výraz (resp. libovolný výraz, který lze převést na typ `bool`) a tělo podmíněného příkazu je tvořeno blokem příkazů, které se mají provést v případě, je-li podmínka splněna:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "číslo je kladné\n",
      "číslo se rovná 1\n",
      "provede se vzdy\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "if a > 0:\n",
    "    print(\"číslo je kladné\")\n",
    "    print(\"číslo se rovná\", a)\n",
    "print(\"provede se vzdy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "provede se vzdy\n"
     ]
    }
   ],
   "source": [
    "a = -1\n",
    "if a > 0:\n",
    "    print(\"číslo je kladné\")\n",
    "    print(\"číslo se rovná\", a)\n",
    "print(\"provede se vzdy\")  \n",
    "\n",
    "# tyto i předchozí buňku si pusťte v pytutoru"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (2411090243.py, line 5)",
     "output_type": "error",
     "traceback": [
      "  \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[31m    \u001b[39m\u001b[31mprint(\"číslo se rovná\", a)\u001b[39m\n    ^\n\u001b[31mIndentationError\u001b[39m\u001b[31m:\u001b[39m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "# správné odsazení je důležité:\n",
    "a = 1\n",
    "if a > 0:\n",
    "    print(\"číslo je kladné\")    \n",
    "     print(\"číslo se rovná\", a)\n",
    "print(\"provede se vzdy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unindent does not match any outer indentation level (<string>, line 7)",
     "output_type": "error",
     "traceback": [
      "  \u001b[36mFile \u001b[39m\u001b[32m<string>:7\u001b[39m\n\u001b[31m    \u001b[39m\u001b[31mprint(\"provede se vzdy\")\u001b[39m\n                            ^\n\u001b[31mIndentationError\u001b[39m\u001b[31m:\u001b[39m unindent does not match any outer indentation level\n"
     ]
    }
   ],
   "source": [
    "# správné odsazení je důležité:\n",
    "a = 1\n",
    "if a > 0:\n",
    "    print(\"číslo je kladné\")\n",
    "    \n",
    "    print(\"číslo se rovná\", a)\n",
    " print(\"provede se vzdy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 5px solid red; padding-left: 1em\">\n",
    "<p><strong>Univerzální syntaktické pravidlo:</strong></p>\n",
    "<p>Ve všech případech, kde znak <code>:</code> uvozuje nějaký blok příkazů, ať už jde o podmíněný příkaz, cyklus nebo definici nějakého objektu, musí být všechny příkazy, které do daného bloku patří, odsazeny stejným počtem mezer.\n",
    "</p>\n",
    "<p>Běžně se používá konvence odsazování pomocí 4 mezer. Přesný počet mezer sice není určen syntaktickými pravidly jazyka, ale všichni se této konvence budeme držet. Také pozor na míchání znaků \"mezera\" (<code>\" \"</code>, číslo 40 v ASCII) a \"tabulátor\" (<code>\"\t\"</code>, reprezentován symbolem <code>\"\\t\"</code>, číslo 9 v ASCII).\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za jednoduchým podmíněným příkazem může následovat příkaz `else`, který uvozuje blok příkazů, které se mají provést, pokud podmínka v předchozím příkazu `if` není splněna:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "číslo není kladné\n",
      "číslo se rovná 0\n",
      "provede se vzdy\n"
     ]
    }
   ],
   "source": [
    "# Větev else\n",
    "a = 0\n",
    "if a > 0:\n",
    "    print(\"číslo je kladné\")\n",
    "    print(\"číslo se rovná\", a)\n",
    "else:\n",
    "    print(\"číslo není kladné\")\n",
    "    print(\"číslo se rovná\", a)\n",
    "print(\"provede se vzdy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plná cena 200\n"
     ]
    }
   ],
   "source": [
    "vek = 25\n",
    "\n",
    "kategorie = \"plná cena\"\n",
    "cena = 200\n",
    "\n",
    "if vek > 65:\n",
    "    kategorie = \"sleva\"\n",
    "    cena = 100\n",
    "    \n",
    "print(kategorie, cena)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plná cena 200\n"
     ]
    }
   ],
   "source": [
    "vek = 25\n",
    "\n",
    "kategorie = \"\"\n",
    "cena = 0\n",
    "\n",
    "if vek > 65:\n",
    "    kategorie = \"sleva\"\n",
    "    cena = 100\n",
    "else:\n",
    "    kategorie = \"plná cena\"\n",
    "    cena = 200\n",
    "    \n",
    "print(kategorie, cena)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podmíněné příkazy lze samozřejmě vnořovat, přičemž je nutné dbát na správnou úroveň odsazení vnořených příkazů:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "číslo se rovná 0\n"
     ]
    }
   ],
   "source": [
    "# Podmínky můžeme vnořovat do sebe:\n",
    "a = 0\n",
    "if a > 0:\n",
    "    print(\"číslo je kladné\")\n",
    "    print(\"číslo se rovná\", a)\n",
    "else:\n",
    "    if a == 0:\n",
    "        print(\"číslo se rovná 0\")\n",
    "    else:\n",
    "        print(\"číslo není kladné\")\n",
    "        print(\"číslo se rovná\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mezi příkazy `if` a `else` spolu s jejich bloky příkazů může ještě vystupovat libovolný počet příkazů `elif` (zkratka pro `else`-`if`), které umožňují provádět ověření dodatečné podmínky v případě, že žádná z předchozích podmínek nebyla splněna.\n",
    "Předchozí příklad tedy můžeme zjednodušit takto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "číslo je kladné\n",
      "číslo se rovná 100\n"
     ]
    }
   ],
   "source": [
    "# větve elif - výpočet spadne do první větve, kde podmínka platí\n",
    "# ukázali jsme si, jak to funguje, pokud je pravdivých více podmínek\n",
    "a = 100\n",
    "if a > 0:\n",
    "    print(\"číslo je kladné\")\n",
    "    print(\"číslo se rovná\", a)\n",
    "elif a == 0:\n",
    "    print(\"číslo se rovná 0\")  \n",
    "elif a > 10: # neprovede se!\n",
    "    print(\"číslo vetsi nez 10\") \n",
    "else:\n",
    "    print(\"číslo není kladné\")\n",
    "    print(\"číslo se rovná\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Porovnávací operátory\n",
    "\n",
    "V jazyku Python jsou k dispozici následující operátory pro porovnávání hodnot výrazů:\n",
    "\n",
    "Operátor | Význam\n",
    "---------|-------\n",
    "`==`     | Rovnost dvou hodnot. __Pozor:__ neplést s přiřazovacím operátorem `=`.\n",
    "`!=`     | Nerovnost dvou hodnot ($a \\ne b$).\n",
    "`<`      | Ostře menší.\n",
    "`>`      | Ostře větší.\n",
    "`<=`     | Menší nebo rovno ($\\le$).\n",
    "`>=`     | Větší nebo rovno ($\\ge$).\n",
    "\n",
    "Jazyk Python dále umožňuje provádět _zřetězené porovnávání_.\n",
    "Např. výraz `x < y <= z > a` je ekvivalentní výrazu `x < y and y <= z and z > a`.\n",
    "\n",
    "Všechny operátory jsou k dispozici pro datové typy, kde uvedený význam má smysl (např. operátory `<`, `>`, `<=`, `>=` nejsou k dispozici pro komplexní čísla, kombinace číslo a textový řetězec, apod.) a jejich výsledek je booleovská hodnota `True` nebo `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sleva 100\n"
     ]
    }
   ],
   "source": [
    "# Podmínka může být složitější: použijeme operátory and, or, not\n",
    "# Operátory pro porovnávání: ==, !=, >, <, >=, <=\n",
    "vek = 40\n",
    "skupinova_sleva = True\n",
    "\n",
    "kategorie = \"plna cena\"\n",
    "cena = 200\n",
    "if vek <= 15 or vek > 65 or skupinova_sleva:\n",
    "    kategorie = \"sleva\"\n",
    "    cena = 100\n",
    "print(kategorie, cena)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ne, x není z intervalu\n"
     ]
    }
   ],
   "source": [
    "# TODO: zřetězené porovnání\n",
    "x = 0\n",
    "if x < 10 and x > 3:\n",
    "    print(\"ano, je z intervalu\")\n",
    "else:\n",
    "    print(\"ne, x není z intervalu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ano, je z intervalu\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "if 3 < x < 10 == 10.0:\n",
    "    print(\"ano, je z intervalu\")\n",
    "else:\n",
    "    print(\"ne, x není z intervalu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V podmíněných příkazech, kde je očekávána booleovská hodnota, je možné použít libovolný výraz, jehož hodnotu lze implicitně převést na typ `bool`.\n",
    "Převod se řídí těmito pravidly: `None` → `False`, `0` → `False`, `0.0` → `False`, `complex(0, 0)` → `False`, všechny ostatní číselné hodnoty → `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ano\n"
     ]
    }
   ],
   "source": [
    "# jako podmínka může sloužit i výraz, jehož hodnota lze implicitně převést na bool:\n",
    "x = 10\n",
    "if x != 0:\n",
    "    print(\"ano\")\n",
    "else:\n",
    "    print(\"ne\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ano\n"
     ]
    }
   ],
   "source": [
    "# jako podmínka může sloužit i výraz, jehož hodnota lze implicitně převést na bool:\n",
    "x = 10\n",
    "if x:\n",
    "    print(\"ano\")\n",
    "else:\n",
    "    print(\"ne\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ano\n"
     ]
    }
   ],
   "source": [
    "x = -100\n",
    "if x + 2.6:\n",
    "    print(\"ano\")\n",
    "else:\n",
    "    print(\"ne\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ano\n"
     ]
    }
   ],
   "source": [
    "if \"False\":\n",
    "    print(\"ano\")\n",
    "else:\n",
    "    print(\"ne\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ne\n"
     ]
    }
   ],
   "source": [
    "if \"\":\n",
    "    print(\"ano\")\n",
    "else:\n",
    "    print(\"ne\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# operátory == a !=\n",
    "a = 3\n",
    "b = 1 + 2\n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ne\n"
     ]
    }
   ],
   "source": [
    "# čísla typu float neporovnáváme pomocí == a !=, ale lépe pomocí přibližného porovnání:\n",
    "a = 0.3\n",
    "b = 0.1 + 0.2\n",
    "if a == b:\n",
    "    print(\"ano\")\n",
    "else:\n",
    "    print(\"ne\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 0.3\n",
    "b = 0.1 + 0.2\n",
    "abs(a - b) < 1e-9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 0.3\n",
    "b = 0.1 + 0.2\n",
    "math.isclose(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Příklady"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.  **Sudé-liché.** Napište program, který zjistí a vypíše, zda je zadané číslo sudé nebo liché."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej cislo 4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 je sude\n"
     ]
    }
   ],
   "source": [
    "# %\n",
    "cislo = int(input(\"Zadej cislo\"))\n",
    "if cislo % 2 == 1:\n",
    "    print(cislo, \"je liche\")\n",
    "else:\n",
    "    print(cislo, \"je sude\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej cislo 4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 je sude\n"
     ]
    }
   ],
   "source": [
    "cislo = int(input(\"Zadej cislo\"))\n",
    "if cislo % 2:\n",
    "    print(cislo, \"je liche\")\n",
    "else:\n",
    "    print(cislo, \"je sude\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej cislo 4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 je sude\n"
     ]
    }
   ],
   "source": [
    "cislo = int(input(\"Zadej cislo\"))\n",
    "if not cislo % 2:\n",
    "    print(cislo, \"je sude\")\n",
    "else:\n",
    "    print(cislo, \"je liche\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.  **Je větší.** Napište program, který zjistí a vypíše, které ze dvou zadaných čísel je větší."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej první číslo 4\n",
      "Zadej druhé číslo 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 je větší než 4\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"Zadej první číslo\"))\n",
    "b = int(input(\"Zadej druhé číslo\"))\n",
    "if a > b:\n",
    "    print(a, \"je větší než\", b)\n",
    "elif a == b:\n",
    "    print(\"čísla jsou stejná\")\n",
    "else:\n",
    "    print(b, \"je větší než\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.  **Je největší.** Napište program, který zjistí a vypíše, které ze tří zadaných čísel je největší."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej první číslo 4\n",
      "Zadej druhé číslo 4\n",
      "Zadej třetí číslo 7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 je největší.\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"Zadej první číslo\"))\n",
    "b = int(input(\"Zadej druhé číslo\"))\n",
    "c = int(input(\"Zadej třetí číslo\"))\n",
    "if a >= b and a >= c:\n",
    "    print(a, \"je největší.\")\n",
    "elif b >= a and b >= c:\n",
    "    print(b, \"je největší.\")\n",
    "else:\n",
    "    print(c, \"je největší.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej první číslo 4\n",
      "Zadej druhé číslo 4\n",
      "Zadej třetí číslo 4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nejvetsi je 4\n",
      "4 je nejvetsi (první číslo)\n",
      "4 je nejvetsi (druhé číslo)\n",
      "4 je nejvetsi (třetí číslo)\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Zadej první číslo\"))\n",
    "y = int(input(\"Zadej druhé číslo\"))\n",
    "z = int(input(\"Zadej třetí číslo\"))\n",
    "print(\"nejvetsi je\", max(x, y, z))\n",
    "\n",
    "if x >= y and x >= z:\n",
    "    print(x, \"je nejvetsi (první číslo)\")\n",
    "if y >= x and y >= z:\n",
    "    print(y, \"je nejvetsi (druhé číslo)\")\n",
    "if z >= x and z >= y: \n",
    "    print(z, \"je nejvetsi (třetí číslo)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4.  **Seřaď.** Napište program, který vypíše tři zadaná čísla v pořadí od největšího po nejmenší."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej první číslo 4\n",
      "Zadej druhé číslo 5\n",
      "Zadej třetí číslo 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 5 4\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Zadej první číslo\"))\n",
    "y = int(input(\"Zadej druhé číslo\"))\n",
    "z = int(input(\"Zadej třetí číslo\"))\n",
    "if x >= y >= z:\n",
    "    print(x, y, z)\n",
    "elif x >= z >= y:\n",
    "    print(x, z, y)\n",
    "elif y >= x >= z:\n",
    "    print(y, x, z)\n",
    "elif y >= z >= x:\n",
    "    print(y, z, x)\n",
    "elif z >= x >= y:\n",
    "    print(z, x, y)\n",
    "else:\n",
    "    print(z, y, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.  **Trojúhelník.** Napište program, který zjistí a vypíše, zda lze sestrojit trojúhelník zadaný pomocí tří délek stran."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej stranu a 10\n",
      "Zadej stranu b 5\n",
      "Zadej stranu c 7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ano\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"Zadej stranu a\"))\n",
    "b = int(input(\"Zadej stranu b\"))\n",
    "c = int(input(\"Zadej stranu c\"))\n",
    "if (a + b > c) and (a + c > b) and (b + c > a):\n",
    "    print(\"ano\")\n",
    "else:\n",
    "    print(\"ne\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "zadej stranu a 3\n",
      "zadej stranu b 2\n",
      "zadej stranu c 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ne, nejde to\n"
     ]
    }
   ],
   "source": [
    "a = float(input(\"zadej stranu a\"))\n",
    "b = float(input(\"zadej stranu b\"))\n",
    "c = float(input(\"zadej stranu c\"))\n",
    "\n",
    "if a > b and a > c and  b + c > a:\n",
    "    print(\"ano, jde to\")\n",
    "elif b > c and b > a and  a + c > b:\n",
    "    print(\"ano, jde to\")\n",
    "elif c > b and c > a and  a + b > c:\n",
    "    print(\"ano, jde to\")\n",
    "else:\n",
    "    print(\"ne, nejde to\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.  **Test plnoletosti.** Napište program, který se zeptá uživatele na věk a odpoví, zda je plnoletý."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Příkaz `while` – cyklus se vstupní podmínkou\n",
    "\n",
    "Příkaz `while` je variantou cyklu, který umožňuje ověření libovolné podmínky.\n",
    "Obecná syntaxe vypadá takto:\n",
    "```python\n",
    "while nějaká_podmínka:\n",
    "    tělo_cyklu\n",
    "    ...\n",
    "```\n",
    "K ověření podmínky dochází vždy před provedením příkazů z těla cyklu.\n",
    "Interpretace chování příkazu `while` tedy je: _dokud platí podmínka, prováděj příkazy_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Příklad:__ následující program vypíše všechna čísla od 0 do 10 včetně:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# program vypíše všechna čísla od 0 do 5 včetně:\n",
    "# zkuste si v pytutoru\n",
    "n = 0\n",
    "while n <= 5:\n",
    "    print(n)\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ahoj ahoj "
     ]
    }
   ],
   "source": [
    "# print co místo odřádkování končí mezerou ... výpis na jedem řádek\n",
    "print (\"ahoj\", end = \" \")\n",
    "print (\"ahoj\", end = \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "# program vypíše všechna čísla od 0 do 10 včetně, výpis na jeden řádek:\n",
    "n = 0\n",
    "while n <= 10:\n",
    "    print(n, end = \" \")\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 4 8 16 32 64 128 256 512 1024 "
     ]
    }
   ],
   "source": [
    "# program vypíše mocniny dvojky 2^0 ... 2^10:\n",
    "n = 0\n",
    "while n <= 10:\n",
    "    print(2 ** n, end = \" \")\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 5 7 9 "
     ]
    }
   ],
   "source": [
    "# cykly a podmínky můžeme vnořovat:\n",
    "# program vypíše jen sudá čísla z posloupnosti čísel od 0 do 10 (včetně)\n",
    "n = 0\n",
    "while n <= 10:\n",
    "    if n % 2:\n",
    "        print(n, end = \" \")\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 "
     ]
    }
   ],
   "source": [
    "# cyklus můžeme ukončit příkazem break:\n",
    "# zkuste si v pytutoru\n",
    "n = 0\n",
    "while n <= 10:\n",
    "    if n == 2:\n",
    "        break\n",
    "    print(n, end = \" \")\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 10 "
     ]
    }
   ],
   "source": [
    "# continue - okamžitě ukončí aktuální iteraci cyklu:\n",
    "n = 0\n",
    "while n <= 10:\n",
    "    if n % 2:\n",
    "        n += 1\n",
    "        continue\n",
    "    print(n, end = \" \")\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 10 "
     ]
    }
   ],
   "source": [
    "# bez continue se snadno obejdeme (využijeme else):\n",
    "n = 0\n",
    "while n <= 10:\n",
    "    if n % 2:\n",
    "        n += 1\n",
    "    else:\n",
    "        print(n, end = \" \")\n",
    "        n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "uz je konec? ne\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pokracuji\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "uz je konec? a\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pokracuji\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "uz je konec? jo\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pokracuji\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "uz je konec? ano\n"
     ]
    }
   ],
   "source": [
    "# while True + break\n",
    "while True:\n",
    "    x = input(\"uz je konec?\")\n",
    "    if x == \"ano\":\n",
    "        break\n",
    "    print(\"pokracuji\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pokracuj\n"
     ]
    }
   ],
   "source": [
    "# cyklus se neprovede ani jednou:\n",
    "n = 20\n",
    "while n <= 10:\n",
    "    print(n, end = \" \")\n",
    "    n += 1\n",
    "print(\"pokracuj\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mKeyboardInterrupt\u001b[39m                         Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[51]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m      1\u001b[39m n = \u001b[32m5\u001b[39m\n\u001b[32m      2\u001b[39m \u001b[38;5;28;01mwhile\u001b[39;00m n > \u001b[32m0\u001b[39m:\n\u001b[32m      3\u001b[39m     \u001b[38;5;66;03m#print(n, end = \" \")\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m     n += \u001b[32m1\u001b[39m\n\u001b[32m      5\u001b[39m print(\u001b[33m\"pokracuj\"\u001b[39m)\n",
      "\u001b[31mKeyboardInterrupt\u001b[39m: "
     ]
    }
   ],
   "source": [
    "# program se může tzv. zacyklit (pokud podmínku neuděláme správně)\n",
    "n = 5\n",
    "while n > 0:\n",
    "    #print(n, end = \" \")\n",
    "    n += 1\n",
    "print(\"pokracuj\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "soucet: 55\n"
     ]
    }
   ],
   "source": [
    "# součet čísel od 0 do 10:\n",
    "n = 0\n",
    "soucet = 0\n",
    "while n <= 10:\n",
    "    #print(n, end=\" \")\n",
    "    soucet += n\n",
    "    n += 1\n",
    "print(\"soucet:\", soucet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pocet: 6\n"
     ]
    }
   ],
   "source": [
    "# počet sudých čísel mezi 0 a 10:\n",
    "n = 0\n",
    "pocet = 0\n",
    "while n <= 10:\n",
    "    if n % 2 == 0:\n",
    "        #print(n, end=\" \")\n",
    "        pocet += 1\n",
    "    n += 1\n",
    "print(\"pocet:\", pocet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 5px solid green; padding-left: 1em\">\n",
    "<p><strong>Tip:</strong>\n",
    "Kliknutím na tlačítko <strong>pytutor</strong> v rozhraní JupyterLab se zobrazí grafická interpretace toho, co se v programu děje.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Příkaz `for` – cyklus s parametrem\n",
    "\n",
    "Příkaz `while` je sice obecný cyklus (umožňuje ověřovat libovolnou podmínku), ale často je poměrně nešikovný, protože musíme sami zajistit správný přechod na následující iteraci.\n",
    "Alternativní příkaz `for` je užitečný v případech, kdy chceme opakovat příkazy pro předem známou sadu hodnot.\n",
    "\n",
    "Obecná syntaxe příkazu `for` vypadá takto:\n",
    "```python\n",
    "for parametry_cyklu in zdroj:\n",
    "    tělo_cyklu\n",
    "```\n",
    "Parametr cyklu bývá většinou jen jeden.\n",
    "Může jich být i více, ale pak potřebujeme zdroj, který v každém kroku dodává příslušně velkou sadu hodnot.\n",
    "\n",
    "Jako zdroj hodnot pro příkaz `for` může sloužit mnoho různých objektů, např. kontejnery a datové struktury, se kterými se seznámíme později.\n",
    "Dnes si ukážeme jen základní, ale velmi častý zdroj hodnot: funkci `range`, která představuje posloupnost celých čísel v určitém rozmezí.\n",
    "Chování funkce `range` se liší podle počtu (celočíselných!) argumentů, které jí předáme:\n",
    "\n",
    "1. Zadáme-li jeden argument, zdroj představuje posloupnost celých čísel od nuly až po zadanou hodnotu, ale tu už ne.\n",
    "   Zadáte-li proto jako argument nulu nebo nějaké záporné číslo, dostaneme prázdnou posloupnost.\n",
    "   Následující program vypisuje čísla od 0 do 10 včetně:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for n in range(11):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ahoj\n",
      "ahoj\n",
      "ahoj\n",
      "ahoj\n",
      "ahoj\n"
     ]
    }
   ],
   "source": [
    "# udělej něco pětkrát:\n",
    "for n in range(5):\n",
    "    print(\"ahoj\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "# program vypíše všechna čísla od 0 do 10 včetně:\n",
    "for n in range(11):\n",
    "    print(n, end = \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 4 8 16 32 64 128 256 512 1024 "
     ]
    }
   ],
   "source": [
    "# program vypíše mocniny dvojky 2^0 ... 2^10\n",
    "for n in range(11):\n",
    "    print(2 ** n, end = \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 5 7 9 "
     ]
    }
   ],
   "source": [
    "# cykly a podmínky můžeme do sebe vnořovat:\n",
    "# program vypíše jen sudá čísla z intervalu od 0 do 10 (včetně)\n",
    "for n in range(11):\n",
    "    if n % 2:\n",
    "        print(n, end = \" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Zadáme-li dva argumenty, zdroj představuje posloupnost celých čísel od hodnoty prvního argumentu po hodnotu druhého, ale hodnotu druhého už ne.\n",
    "   Následující program vypisuje hodnoty od 7 do 10 včetně:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 8 9 10 "
     ]
    }
   ],
   "source": [
    "for n in range(7, 11):\n",
    "    print(n, end = \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cyklus se neprovede ani jednou:\n",
    "for n in range(11, 7):\n",
    "    print(n, end = \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 5 8 "
     ]
    }
   ],
   "source": [
    "for n in range(2, 11, 3):\n",
    "    print(n, end = \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22 21 20 19 18 17 16 15 14 13 12 "
     ]
    }
   ],
   "source": [
    "for n in range(22, 11, -1):\n",
    "    print(n, end = \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cyklus se neprovede ani jednou:\n",
    "for n in range(2, 11, -1):\n",
    "    print(n, end = \" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Zadáme-li tři argumenty, zdroj představuje posloupnost celých čísel od hodnoty prvního argumentu až po hodnotu druhého (jeho hodnotu už ne) s krokem zadaným ve třetím argumentu.\n",
    "   Pro kladný krok bude posloupnost rostoucí, pro záporný bude klesající."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 7 4 1 "
     ]
    }
   ],
   "source": [
    "for n in range(10, 0, -3):\n",
    "    print(n, end = \" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Příklady"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.  **Součet čísel pomocí for cyklu.** Napište program, který sečte čísla od 1 do n (pomocí for cyklu)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej číslo: 100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Součet čísel je 5050\n"
     ]
    }
   ],
   "source": [
    "# kontrola:\n",
    "n = int(input(\"Zadej číslo:\"))\n",
    "součet = (n * (n + 1)) // 2\n",
    "print(\"Součet čísel je\", součet) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 "
     ]
    }
   ],
   "source": [
    "# a) pomoci for cyklu\n",
    "# mezikrok\n",
    "for i in range(1, n + 1):  # pozor, použijte jinou řídící proměnnou\n",
    "    print(i, end = \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Součet čísel je 5050\n"
     ]
    }
   ],
   "source": [
    "# a) pomoci for cyklu: místo výpisu sčítám\n",
    "součet = 0\n",
    "for i in range(1, n + 1):  # pozor, použijte jinou řídící proměnnou\n",
    "    součet += i\n",
    "    \n",
    "print(\"Součet čísel je\", součet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to same pomoci while cyklu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej číslo: 100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5050\n"
     ]
    }
   ],
   "source": [
    "# b) totéž pomocí while cyklu\n",
    "n = int(input(\"Zadej číslo:\"))\n",
    "součet = 0\n",
    "i = 1\n",
    "while i <= n:\n",
    "    součet += i\n",
    "    i += 1\n",
    "print(součet) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **Sudé-liché podruhé.**\n",
    "Napište program, který bude pořád dokola žádat uživatele, aby zadal celé číslo, a poté vypíše, jestli je zadané číslo sudé nebo liché.\n",
    "Jakmile uživatel napíše \"konec\", tak program skončí."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej cele cislo 45\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45 je liche\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej cele cislo 40\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40 je sude\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej cele cislo konec\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Zadej cele cislo\")\n",
    "while s != \"konec\":\n",
    "    n = int(s)\n",
    "    if n % 2:\n",
    "        print(n, \"je liche\")\n",
    "    else:\n",
    "        print(n, \"je sude\")\n",
    "    s = input(\"Zadej cele cislo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    s = input(\"Zadej cele cislo\")\n",
    "    if s == \"konec\":\n",
    "        break\n",
    "    n = int(s)\n",
    "    if n % 2:\n",
    "        print(n, \"je liche\")\n",
    "    else:\n",
    "        print(n, \"je sude\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. **Načti a sečti čísla.** Napište program, který postupně načítá čísla ze vstupu, dokud nepřijde prázdný řetězec `\"\"`. Pak vypíše počet zadaných čísel a jejich součet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej cislo 45\n",
      "Zadej cislo 2.3\n",
      "Zadej cislo \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 47.3\n"
     ]
    }
   ],
   "source": [
    "soucet = 0\n",
    "pocet = 0\n",
    "while True:\n",
    "    s = input(\"Zadej cislo\")\n",
    "    if s == \"\":\n",
    "        break\n",
    "    x = float(s)\n",
    "    soucet += x\n",
    "    pocet += 1\n",
    "\n",
    "print(pocet, soucet)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4.  **Chci číslo z intervalu.** Program-kecálek čte čísla od uživatele, dokud uživatel nezadá číslo z požadovaného intervalu. Pak mu poděkuje a vypíše počet neúspěšných pokusů."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zadej cislo z intervalu ( 3 , 4 )\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "zadej cislo 1\n",
      "zadej cislo 3\n",
      "zadej cislo 4\n",
      "zadej cislo 2\n",
      "zadej cislo 3.5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prima, zadal jsi číslo  3.5 , počet neúspěšných pokusů je  4\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "b = 4\n",
    "pokusu = 0\n",
    "print(\"Zadej cislo z intervalu (\", a, \",\",b, \")\" )\n",
    "while True:\n",
    "    x = float(input(\"zadej cislo\"))\n",
    "    if a < x < b:\n",
    "        print(\"Prima, zadal jsi číslo \", x, \", počet neúspěšných pokusů je \", pokusu)\n",
    "        break\n",
    "    pokusu += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.  **Posloupnost.** Napište program, který vypíše prvních n členů následující posloupnosti: 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 "
     ]
    }
   ],
   "source": [
    "# a) pro 5 clenu vypis 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5\n",
    "n = 5\n",
    "for i in range(1, n + 1):\n",
    "    for j in range(1, i + 1):\n",
    "        print(j, end = \" \")\n",
    "    # print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 1 2 "
     ]
    }
   ],
   "source": [
    "# b) pro 5 clenu vypis 1 1 2 1 2\n",
    "n = 5\n",
    "pocet = 0\n",
    "for i in range(1, n + 1):\n",
    "    for j in range(1, i + 1):\n",
    "        print(j, end = \" \")\n",
    "        pocet += 1\n",
    "        if pocet == n:\n",
    "            break\n",
    "    if pocet == n:\n",
    "            break"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.14.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}