pn/izpiti/2023/1_resitev.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e1484c75",
   "metadata": {},
   "source": [
    "# Izpit 31. januar 2024\n",
    "\n",
    "# 1. Knjigovodstvo\n",
    "\n",
    "Napišite funkcijo `knjigovodstvo(ime_datoteke)`, ki prejme ime datoteke s prihodki (vrstice s pozitivnimi števili) in odhodki (negativna števila) v obliki, kot jo kaže okvirček na desni. Funkcija mora vrniti trojko: seznam s pari imen dohodkov in pripadajočih zneskov, seznam s pari imen odhodkov in pripadajočih cen (kot pozitivna števila) ter skupno vsoto. Za datoteko \n",
    "\n",
    "```\n",
    "slika: 50\n",
    "slika: 100\n",
    "tempera: -3\n",
    "stol: -20\n",
    "kip: 20\n",
    "zrak: 0\n",
    "torba: 12\n",
    "```\n",
    "\n",
    "vrne\n",
    "\n",
    "```\n",
    "([('slika', 50), ('slika', 100), ('kip', 20), ('torba', 12)],\n",
    " [('tempera', 3), ('stol', 20)],\n",
    " 159)\n",
    "```\n",
    "pri čemer je 159 preprosto vsota vseh številk.\n",
    "\n",
    "## Rešitev\n",
    "\n",
    "Najprej pripravimo, kar bomo vrnili - seznama `prihodki` in `odhodki` ter `bilanca`.\n",
    "\n",
    "Nato gremo po datoteki: vsako vrstico razdelimo glede na `:` in pretvorimo znesek v število. Če je šteivlo negativno, dodamo par s stvarjo in zneskom v `odhodki` (pri čemer mora biti število `-znesek`), sicer v `prihodki`. Pa `bilanco` povečamo za `znesek`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "baa62aca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def knjigovodstvo(ime_datoteke):\n",
    "    prihodki = []\n",
    "    odhodki = []\n",
    "    bilanca = 0\n",
    "    for vrstica in open(ime_datoteke):\n",
    "        stvar, znesek = vrstica.split(\":\")\n",
    "        znesek = int(znesek)\n",
    "        if znesek < 0:\n",
    "            odhodki.append((stvar, -znesek))\n",
    "        elif znesek > 0:\n",
    "            prihodki.append((stvar, znesek))\n",
    "        bilanca += znesek\n",
    "    return prihodki, odhodki, bilanca"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80ccf061",
   "metadata": {},
   "source": [
    "Nekateri radi pišejo\n",
    "\n",
    "```\n",
    "    if znesek > 0:\n",
    "        bilanca += znesek\n",
    "    else:\n",
    "        bilanca -= abs(znesek)\n",
    "```\n",
    "\n",
    "To seveda ni potrebno. Python zna prištevati negativne vrednosti. :)\n",
    "\n",
    "Prav tako je lepo, da bilanco spreminjamo izven `if` in ne znotraj, ločeno za odhodke in za prihodke.\n",
    "\n",
    "Eden od študentov je poskusil nalogo rešiti z `numpy`-jem. Sicer se mu ni čisto posrečilo, vendar gre in je kar lepo. Dobra ideja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "21471235",
   "metadata": {},
   "outputs": [],
   "source": [
    "def knjigovodstvo(ime_datoteke):\n",
    "    podatki = np.genfromtxt(ime_datoteke, delimiter=\":\", dtype=str)\n",
    "    stvari = podatki[:, 0]\n",
    "    cene = podatki[:, 1].astype(int)\n",
    "    prihodki = cene > 0\n",
    "    odhodki = cene < 0\n",
    "    return (list(zip(stvari[prihodki], cene[prihodki])),\n",
    "            list(zip(stvari[odhodki], -cene[odhodki])),\n",
    "            np.sum(cene))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c55e7fd5",
   "metadata": {},
   "source": [
    "Zoprna stvar je tisto na koncu: z `zip` poberemo skupaj stvari in cene, da nam sestavi pare, potem pa pokličemo še `list`, da jih zložimo v seznam."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad56cb88",
   "metadata": {},
   "source": [
    "# 2. Draginja\n",
    "\n",
    "Napiši funkcijo `draginja(odhodki)`, ki vrne seznam parov imen stvari in cen. Ista stvar se lahko pojavi večkrat, a morda z različnimi cenami. Funkcija mora vrniti ime stvari, katere povprečna cena je bila največja. Če je takšnih stvari več, lahko vrne poljubno izmed njih.\n",
    "\n",
    "Klic `draginja([('stol', 20), ('torba', 12), ('tempera', 3), ('miza', 50), ('stol', 30), ('stol', 60), ('miza', 40), ('torba', 5)])` vrne `'miza'`, saj je povprečna cena miz enaka `(50 + 40) / 2 = 45`, medtem ko je povprečna cena, recimo, stolov `(20 + 30 + 60) / 3 = 36,66`, torbe in tempere pa so še cenejše.\n",
    "\n",
    "## Rešitev\n",
    "\n",
    "Tole je naloga iz slovarjev. Da bomo lahko računali povprečne cene, bomo potrebovali dva: v enem beležimo vsote cen vsake stvari, v drugem število takšnih stvari.\n",
    "\n",
    "Ko se odločimo glede tega, je funkcija preprosta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9050b6ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "def draginja(odhodki):\n",
    "    skupna_cena = defaultdict(float)\n",
    "    skupno_kosov = defaultdict(int)\n",
    "    for stvar, cena in odhodki:\n",
    "        skupna_cena[stvar] += cena\n",
    "        skupno_kosov[stvar] += 1\n",
    "\n",
    "    naj_stvar, naj_povp = None, -1\n",
    "    for stvar in skupna_cena:\n",
    "        povp = skupna_cena[stvar] / skupno_kosov[stvar]\n",
    "        if povp > naj_povp:\n",
    "            naj_stvar, naj_povp = stvar, povp\n",
    "    return naj_stvar"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b6cf154",
   "metadata": {},
   "source": [
    "Zoprni drugi del se da skrajšati, če znamo bolj spretno uporabljati `max` in poznamo `lambde`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "55195d3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def draginja(odhodki):\n",
    "    skupna_cena = defaultdict(float)\n",
    "    skupno_kosov = defaultdict(int)\n",
    "    for stvar, cena in odhodki:\n",
    "        skupna_cena[stvar] += cena\n",
    "        skupno_kosov[stvar] += 1\n",
    "    return max(skupna_cena, key=lambda stvar: skupna_cena[stvar] / skupno_kosov[stvar])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d0ebd5f",
   "metadata": {},
   "source": [
    "# 3. Dragocenosti\n",
    "\n",
    "Napišite funkcijo `dragocenosti(stvari, cene, meja)`, ki prejme numpy-jevo tabelo z imeni stvari in dvodimenzionalno tabelo, katere vrstice ustrezajo stvarem (v enakem vrstnem redu kot so te naštete v prvi tabeli), stolpci pa dnevom. Vrednosti v tabeli povedo, koliko je stvar stala na posamezni dan.\n",
    "\n",
    "Funkcija mora vrniti tabelo z imeni vseh stvari, katerih cene so bile vsaj en dan višje od podane meje meja. Vrstni red mora biti enak vrstnemu redu v tabeli stvari.\n",
    "\n",
    "**Pri tej nalogi pričakujemo rešitev v čistem numpy-ju, brez zank v Pythonu.**\n",
    "\n",
    "## Rešitev\n",
    "\n",
    "Takole."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "65800639",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dragocenosti(stvari, cene_po_dnevih, meja):\n",
    "    return stvari[np.any(cene_po_dnevih > meja, axis=1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a39abc3a",
   "metadata": {},
   "source": [
    "Ali pa takole."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ad088bf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dragocenosti(stvari, cene_po_dnevih, meja):\n",
    "    return stvari[np.max(cene_po_dnevih, axis=1) > meja]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efe52eba",
   "metadata": {},
   "source": [
    "# 4. Spletno knjigovodstvo\n",
    "\n",
    "Ko poženete teste, se bo v direktoriju s programom pojavila datoteka knjigovodstvo.html. Lahko jo odprete v brskalniku ali urejevalniku.\n",
    "\n",
    "Napišite funkcijo `spletno_knjigovodstvo(ime_datoteke)`, ki zna prebrati podatke iz takšne datoteke. Predpostaviti smete, da opis nakupa vedno vsebuje le eno število ter da je to število pozitivno in celo. Funkcija mora vrniti seznam s pari stvari in cen. Za podano datoteko naj vrne `[('slika', 50), ('slika', 100), ('tempera', 3), ('polomljen stol', 20), ('kip', 20), ('zrak', 0), ('torba', 12)]`.\n",
    "\n",
    "## Rešitev\n",
    "\n",
    "Seveda bomo uporabili `BeautifulSoup` in regularne izraze.\n",
    "\n",
    "Podatki so v delu HTML-ja, ki je videti tako:\n",
    "\n",
    "```\n",
    "        <dt>slika</dt>\n",
    "        <dd>Stala je 50, lahko bi tudi malo manj.</dd>\n",
    "        <dt>slika</dt>\n",
    "        <dd>Ta je bila malo dražje, zanjo smo dali 100.</dd>\n",
    "```\n",
    "\n",
    "Poiščemo vse `dt` in potem `dd`, ki jim sledijo. Znotraj tega, kar je bilo v `dd` poiščemo zaporedja števk `\\d+`. Kar najdemo, pretvorimo v število."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "460b1d52",
   "metadata": {},
   "outputs": [],
   "source": [
    "def spletno_knjigovodstvo(ime_datoteke):\n",
    "    soup = BeautifulSoup(open(ime_datoteke), \"html.parser\")\n",
    "    postavke = []\n",
    "    for vrstica in soup.find_all(\"dt\"):\n",
    "        stvar = vrstica.text\n",
    "        opis = vrstica.find_next_sibling(\"dd\").text\n",
    "        znesek = re.search(r\"\\d+\", opis).group()\n",
    "        postavke.append((stvar, int(znesek)))\n",
    "    return postavke"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5733304",
   "metadata": {},
   "source": [
    "# 5. Evidenca\n",
    "\n",
    "Napišite funkcijo `evidenca(postavke, ime_datoteke)`, ki prejme postavke v obliki trojk z imenom stvarmi, ceno za kos in številom kosov, na primer `[(\"slika\", 50, 2), (\"tempera\", 3, 1), (\"stol\", 20, 1),  (\"kip\", 20, 12), (\"zrak\", 0, 141), (\"torba\", 12, 1)]`. Funkcija mora v datoteko ime_datoteke zapisati tabelo v obliki, ki jo kaže slika na desni. Točno obliko - število presledkov - razberite iz testov.\n",
    "\n",
    "```\n",
    "Stvar        Cena x Kosov     Skupaj\n",
    "------------------------------------\n",
    "slika          50 x 2            100\n",
    "tempera         3 x 1              3\n",
    "stol           20 x 1             20\n",
    "kip            20 x 12           240\n",
    "zrak            0 x 141            0\n",
    "torba          12 x 1             12\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96503d32",
   "metadata": {},
   "source": [
    "## Rešitev\n",
    "\n",
    "Tule gre zgolj za osnovno oblikovanje nizo: prešteti moramo, na koliko znakov poravnamo kakšno stvar, pa z `>` in `<` potiskati stvari na desno in na levo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b78c8f4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evidenca(postavke, ime_datoteke):\n",
    "    f = open(ime_datoteke, \"w\")\n",
    "    f.write(f\"{'Stvar':10} {'Cena':>6} x {'Kosov':<5} {'Skupaj':>10}\\n\")\n",
    "    f.write(\"-\" * 36 + \"\\n\")\n",
    "    for stvar, cena, kosov in postavke:\n",
    "        f.write(f\"{stvar:10} {cena:>6} x {kosov:<5} {cena * kosov:10}\\n\")"
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}