{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python gyakorlat 2\n",
    "#### Minden részből oldj meg párat, majd térj vissza a kihagyott feladatokra!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Függvények sok paraméterrel\n",
    "### 1.1 Írj egy függvényt, ami tetszőleges számú számot elfogad és kiírja az összegüket "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mysum(*args):\n",
    "    #todo\n",
    "    \n",
    "assert mysum(1,2,3)==6\n",
    "assert mysum(2,2,3)==7\n",
    "assert mysum(*range(1,1000))==499500\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Írj egy függvényt, ami tetszőleges számú sztringet elfogad és kiírja az összefűzésüket\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myconcat(*args):\n",
    "    #todo\n",
    "   \n",
    "assert myconcat(\"rab\",\"lo\")==\"rablo\"\n",
    "assert myconcat(\"iroda\",\"lom\",\" \",\"borz\",\"alom\")==\"irodalom borzalom\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Írj egy függvényt, ami tetszőleges számú bemenetet elfogad és kiválogatja közüllük a számokat.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myselect(*args):\n",
    "    #todo\n",
    "   \n",
    "assert myselect(12,\"rab\",\"lo\",43)==[12,43]\n",
    "assert myselect(1,\"asd\",(1,3),[],2,myselect,3 )==[1,2,3]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 Írj egy függvényt, ami tetszőleges számú bemenetet elfogad, kiválogatja közüllük a számokat, majd azok összegével tér vissza. Használd a korábbi függvényeid. Ne feledd, hogy egy lista a * operátorral bontható ki. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myselectsum(*args):\n",
    "    #todo\n",
    "   \n",
    "assert myselectsum(12,\"rab\",\"lo\",43)==55\n",
    "assert myselectsum(1,\"asd\",(),[],2,myselect,3 )==6\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *1.5 Írj egy függvényt, ami a következőt csinálja. Egyetlen argumentum esetén visszatér az argumentummal, különben pedig (x_1, x_2, ... x_n) argumentumok esetén meghívja önmagát (x_1+x_2,x_2+x_3, x_3+x_4, ... , x_n-1+x_n) argumentumokkal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(*args):\n",
    "    #todo\n",
    "  \n",
    "    \n",
    "assert myfunc(1,1,1,1,1,1)==32  # miért van itt kettő hatvány?\n",
    "assert myfunc(1,2,3,5,8,13)==144  # és itt miért fibonacci az eredmény is?\n",
    "assert myfunc(\"alma \",\"körte \",\"barack \",\"szilva \")==\"alma körte körte barack körte barack barack szilva \" \n",
    "assert myfunc(\"1\",\"2\",\"3\",\"4\",\"5\",\"6\")==\"12232334233434452334344534454556\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. `list` \n",
    "\n",
    "### 2.1 Tegyük fel, hogy adott számok egy _l_ listája és egy egész szám *i < len(l)*. Add vissza az *i*-ik legnagyobb elemet a listából!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ith(l,i):\n",
    "   \n",
    "assert ith([1,4,2,7],2)==4\n",
    "assert ith([1,4,2,7],3)==2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Tegyük fel, hogy adott két, egész számokból álló rendezett lista. Fésüld össze őket egy rendezett listába!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge(l,k):\n",
    "    \n",
    "assert merge([1,2,7],[2,5])==[1,2,2,5,7]\n",
    "assert merge([1,4,8],[3,6,7])==[1,3,4,6,7,8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Tegyük fel, hogy adott 3D vektorok egy listája. Rendezd őket hátulról lexikografikus sorrenbe, azaz z koordináta szerint, döntetlen esetén pedig y és azon belül x koordináta szerint! \n",
    "Például:\n",
    "```\n",
    "Input: [[0,1,1], [5,4,6], [1,2,1]]\n",
    "Output: [[0,1,1], [1,2,1], [5,4,6]]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lex(l):\n",
    "   \n",
    "assert lex([[0,1,1], [5,4,6], [1,2,1]])==[[0,1,1], [1,2,1], [5,4,6]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Tegyük fel, hogy adott stringek egy listája. Rendezd a szavak hossza szerinti csökkenő sorrendbe!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lensort(l):\n",
    " \n",
    "assert lensort([\"alma\",\"körte\",\"dió\"])==[\"körte\",\"alma\",\"dió\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 Tegyük fel, hogy adott számokat tartalmazó listáknak egy listája. Rendezd a rész-listák összege szerinti növekvő sorrendbe!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sumsort(l):\n",
    "\n",
    "assert sumsort([[1], [-12, 3, 4], [3.5, 2]])==[[-12, 3, 4], [1], [3.5, 2]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 Tegyük fel, hogy adott két lista. Dönts el, hogy van-e közös elemük!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def common(l,k):\n",
    "\n",
    "assert common([1,2,3],[6,5,3])==True\n",
    "assert common([1,2,3],[6,5,4])==False\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.7 Tegyük fel, hogy adott két lista. Dönst el, hogy egymás cirkuláris permutációi-e!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def perm(l,k):\n",
    "\n",
    "assert perm([1,2,3],[2,3,1])==True\n",
    "assert perm([1,2,3],[3,2,1])==False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.8 (Collatz-sorozat) A sorozatot a következő rekurzióval definiáljuk: \n",
    "$$a_n = \\frac{a_{n-1}}{2} \\text{, ha } a_{n-1} \\text{páros,}$$\n",
    "$$a_n = a_{n-1} \\cdot 3 + 1 \\text{, ha } a_{n-1} \\text{ páratlan.}$$\n",
    "\n",
    "### Ha a sorozat eléri az 1-et, akkor végtelen ciklusba kerül (1-4-2-1), ezért ezt a sorozat végének tekinthetjük. Írj függvényt, ami tetszőleges pozitív egész szára kiszámolja annak Collatz sorozatát!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collatz(n):\n",
    "\n",
    "assert collatz(13)==[13, 40, 20, 10, 5, 16, 8, 4, 2, 1]\n",
    "assert collatz(17)==[17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. `dictionary`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Tegyük fel, hogy adott egész számok  egy listája és egy modulus. Válogasd szét a szavakat maradékosztályok szerint!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "def modulo(l,m):\n",
    "\n",
    "\n",
    "assert modulo([1,2,3,4,5,6,7,8,9,10],3)=={0: [3, 6, 9], 1: [1, 4, 7, 10], 2: [2, 5, 8]}\n",
    "assert modulo([1,2,3,4,5,6,7,8,9,10],4)=={0: [4, 8], 1: [1, 5, 9], 2: [2, 6, 10], 3: [3, 7]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Adott egy szöveg. Határozzuk meg, hogy milyen betűk szerepelnek benne és milyen gyakorisággal!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def freq(s):\n",
    "\n",
    "assert freq(\"almafa\")=={'a': 3, 'l': 1, 'm': 1, 'f': 1}\n",
    "assert freq(\"kalamajka\")=={'k': 2, 'a': 4, 'l': 1, 'm': 1, 'j': 1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Bioinformatikában egy DNS k-hoszú részsorozatait k-mer-nek nevezik. Egy adott DNS-szekvenciából számold meg az előforduló k-merek-et és azok gyakoriságát!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "def freq_dns(s):\n",
    " \n",
    "\n",
    "assert freq_dns(\"gtatatatac\")=={'gtat': 1, 'tata': 3, 'atat': 2, 'atac': 1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 Írj függvényt, amely egy dictionary-ben adott értékhez megkeresi a lehetséges kulcsokat! A függvény egy dictionary-t és egy tetszőleges változót várjon bemenetként, és egy listával térjen vissza!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rev(d,value):\n",
    "\n",
    "assert rev({\"a\":2,\"b\":4,\"c\":4,\"d\":1,\"e\":4},4)==['b', 'c', 'e']\n",
    "assert rev({\"a\":2,\"b\":4,\"c\":4,\"d\":1,\"e\":1},1)==['d','e']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5 Írj függvényt, amely invertál egy dictionary-t! A függvény egy dictionary-t vár bemenetnek és egy olyan dictionary-val tér vissza, amelynek a kulcsai a bemeneti dictionary különböző értékei, értékei pedig a bemeneti dictionary kulcsaiból alkotott listák!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inv(d):\n",
    "\n",
    "\n",
    "assert inv({\"a\":2,\"b\":4,\"c\":4,\"d\":1,\"e\":4})=={2: ['a'], 4: ['b', 'c', 'e'], 1: ['d']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. `srting` \n",
    "\n",
    "### 4.0 Olvasd be a Jókai összest. Ehhez töltsd le a következő fájlt: https://damasdigabor.web.elte.hu//python/jokai.zip, *csomagold ki* és helyezd ugyanabba a mappába, ahol ez a notebook is található. Ezután futtasd a következő cellát változtatás nélkül. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "with open(\"jokai.json\", 'r') as f:\n",
    "    jokai = json.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ha gond nélkül lefutott a fenti kód, a `jokai` változó tartalmazza Jókai összes művét. Ez egy dictionary {\"cím\": \"Regény szövege\"} formátumban"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Írd ki a korpuszban szereplő művek címét, hosszát, és első 150 karakterét:\n",
    "**NE** próbáld meg kiíratni a teljes korpuszt egy egyszerű `jokai` parancsal! Túl hosszú, és a számítógéped nem fog örülni!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.a Alakítsd át a korpuszt úgy, hogy csak alfanumerikus karakterek maradjanak benne, a következő trükkel (reguláris kifejezések): \n",
    "### 4.2.b Konvertáld kisbetűssé a korpuszt a .lower() függvény segítségével: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ej mi a kő! tyúkanyó, kend A szobában lakik itt bent? Lám, csak jó az isten, jót ád, Hogy fölvitte a kend dolgát!\n",
      "Ej mi a kő tyúkanyó kend A szobában lakik itt bent Lám csak jó az isten jót ád Hogy fölvitte a kend dolgát\n",
      "ej mi a kő tyúkanyó kend a szobában lakik itt bent lám csak jó az isten jót ád hogy fölvitte a kend dolgát\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "s=\"Ej mi a kő! tyúkanyó, kend A szobában lakik itt bent? Lám, csak jó az isten, jót ád, Hogy fölvitte a kend dolgát!\"\n",
    "print(s)\n",
    "s=re.sub(r'[^a-zA-Z0-9áéíóöőúüű\\s]+', '', s)\n",
    "print(s)\n",
    "s=s.lower()\n",
    "print(s) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 A .split() függvény segítségvel egy listát tudsz készíteni egy sztring szavaiból. Ezt felhasználva írd ki minden regény 100. szavát, és szavainak számát: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4 Készíts egy függvényt, ami leszámlálja egy sztringben szereplő szavakat, azaz egy dictionary-ban összegyűjti, hogy melyik szó hányszor szerepel. Írd ki, hogy melyik műben hányszor szerepel a \"ferenc\" szó: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.5 Írd ki jókai összes művében, illetve az \"Az arany ember\"-ben előforduló 20 leggyakoribb szót az alább mintájára: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A jövő század regénye 225640\n",
      "Elbeszélések 218338\n",
      "A magyar nemzet története regényes rajzokban 204249\n",
      "Eppur si muove – És mégis mozog a föld 182985\n",
      "Akik kétszer halnak meg 175008\n",
      "Fráter György 164869\n",
      "Az élet komédiásai 157319\n",
      "A kiskirályok 150109\n",
      "Az arany ember 146384\n",
      "A kőszívű ember fiai 144269\n"
     ]
    }
   ],
   "source": [
    "#kiirja a 10 legtöbb szóból álló regényt\n",
    "wordCounts={}\n",
    "for title in jokai:\n",
    "    words=jokai[title].split()\n",
    "    wordCounts[title]=len(words)\n",
    "\n",
    "for title, count in sorted(wordCounts.items(), key=lambda x: -x[1])[:10]:\n",
    "    print(title, count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}