{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python gyakorlat 3\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",
    "\n",
    "Ha `s='alma'` es `t='leves'` ket stringet tartalmazo valtozo, akkor `s+t='almaleves'`\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\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Írj egy függvényt, ami tetszőleges számú bemenetet elfogad és kiválogatja közülük a számokat (int, complex és float típusúakat).\n",
    "\n",
    "Egy elemrol a `type(a)` parancsal tudjuk eldonteni az elem tipusat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'complex'>\n",
      "<class 'float'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(1+1j))\n",
    "print(type(1.1))\n",
    "print(type(1))\n",
    "assert(type(1+1j)==complex)\n",
    "assert(type(1.1)==float)\n",
    "assert(type(1)==int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "unexpected EOF while parsing (<ipython-input-1-1f1216da8cd8>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-1f1216da8cd8>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    \u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unexpected EOF while parsing\n"
     ]
    }
   ],
   "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",
    "assert myselect(1+1j, 2.5, [1], (1, 2, 4), {1:3, 4:5}, 1)==[1+1j, 2.5, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. `list` \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listak rendezese (metodus):\n",
    "\n",
    "`list.sort(reverse=True|False, key=myFunc)`\n",
    "\n",
    "Lathatjuk, hogy a rendezes kulcsa lehet egy tetszoleges altalunk keszitett fuggveny, ami egy True/False ertekkel tud donteni 2 bemeneti elemrol, hogy az elso kisebb-e mint a masodik. A kovetkezo feladatokban ezt batran hasznaljuk."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 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.2 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.3 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.4 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": [
    "## 3. `dictionary`\n",
    "\n",
    "\n",
    "* szótár konstrukció `d={'a':'alfa','b':'beta','g':'gamma'}`\n",
    "* szótár kulcsai `d.keys()`\n",
    "* szótár értékei `d.values()`\n",
    "* szótér kulcs érték párjai `d.items()`\n",
    "* szótárban lenni `'a' in d`\n",
    "* szótár bővítése egy új elemmel `d['n']='nu'`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Készítsünk egy függvenyt, aminek a bemenete egy nem nulla egész szám és kiszámolja a prímtényezős felbontast, amit egy dict-ben ad vissza\n",
    "\n",
    "Pl:\n",
    "\n",
    "`factors(6)=={2:1,3:1}`, mert $6=2^1\\cdot 3^1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factors(n):\n",
    "    #TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Euler-fele $\\varphi$ fuggveny kiszamitasa (https://hu.wikipedia.org/wiki/Euler-f%C3%BCggv%C3%A9ny)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def euler_phi(n):\n",
    "    #TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Tegyük fel, hogy adott egész számok  egy listája és egy modulus. Válogasd szét a szamokat 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.4 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, k):\n",
    "    #TODO\n",
    "assert freq_dns(\"gtatatatac\", 4)=={'gtat': 1, 'tata': 3, 'atat': 2, 'atac': 1}\n",
    "assert freq_dns(\"almafa\", 1)=={'a': 3, 'l': 1, 'm': 1, 'f': 1}\n",
    "assert freq_dns(\"kalamajka\", 1)=={'k': 2, 'a': 4, 'l': 1, 'm': 1, 'j': 1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5 Í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.6 Í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. `string` \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. Majd ezt felhasznalva í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": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[1,2,3,4,5,6,7,8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[0:4][]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Szamits ki az inverzeket tartalmazo dictionry-t $\\mathbb{F}_q$-ban. (HF)"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}