p1/domace-naloge/2021/10 Nacrt napada/resitev.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c2d4b5c7",
   "metadata": {},
   "source": [
    "**Disclaimer:** Vsaka podobnost z resničnimi osebami, vojskami, podjetji, ministrstvi ali sodišči je večinoma naključna.\n",
    "\n",
    "Nadaljujemo, kjer smo ostali [prejšnjič](https://ucilnica.fri.uni-lj.si/mod/assign/view.php?id=46861).\n",
    "\n",
    "Tokrat ni dodatne naloge.\n",
    "\n",
    "-----------------------\n",
    "\n",
    "Tole je ena velika blamaža. V treh točkah.\n",
    "\n",
    "1. Gospa Kozjančeva bi strateški plan napada na Marsovce hotela oddati v Excelu. *Centralni računalnik za koordinacijo napadov na vesoljce* (CRKnaV) seveda ne zna brati Excela. Gospa Kozjančeva je zato kot primer, kaj kani sproducirati, natipkala tole skrpucalo\n",
    "\n",
    "    ```\n",
    "    4.25, 8.5:   5.0, 5   |   8.125, -7.5    |   3.5, -6.75\n",
    "    6.0, 1.25:  15.5, 5.5  |  1.5, -1.25 | 2.5, -9.5625  | -3, -3\n",
    "    8, 1: -2, 5\n",
    "    ```\n",
    "\n",
    "    in v mail napisala, da \"*so u vsaki vrstici koordinate naše ladje pol pa še marsovskih in tko bom jest delala sploh nej me pa Grabnar iz general štaba neha [cenzurirano], drgač bom pač dala odpovet grem pač rajš delat na kakšno normalno ministrstvo kjer majo excel k to znam*\".\n",
    "\n",
    "    Podatki bodo torej v takšni obliki, le številke bodo drugačne. Trenutno so še vojaška skrivnost, ki jo pozna samo gospa Kozjančeva.\n",
    "\n",
    "2. Nadalje se je izkazalo, da CRKnaV pričakuje podatke v takšni obliki.\n",
    "\n",
    "    ```\n",
    "       1:     4.2500     8.5000 ->     5.0000     5.0000\n",
    "                                       8.1250     8.1250\n",
    "                                       3.5000     3.5000\n",
    "       2:     6.0000     1.2500 ->    15.5000     5.5000\n",
    "                                       1.5000     1.5000\n",
    "                                       2.5000     2.5000\n",
    "                                      -3.0000    -3.0000\n",
    "       3:     8.0000     1.0000 ->    -2.0000     5.0000\n",
    "    ```\n",
    "\n",
    "    Z vsemi decimalkami in presledki in vsem. Kolikor je Kozjančeva šlampasta do enomoglosti, je ta picajzlast do skrajnosti. Vsaka številka ima morebitni `-`, nato do štiri mesta levo od pike, štiri za piko, vmes presledki, pa dvopičja in puščice, točno tako in nič drugače. Ker je vojska vojska. Čeprav slovenska.\n",
    "\n",
    "3. Kot da ta zafrkancija s Kozjančevo in CRKnaV še ne bi bila zadosti, se je zgodilo naslednje. Neko podjetje je začelo izdelovati softver za pretvorbo, potem pa se je konkurenčno podjetje pritožilo na razpis, zadeva je šla do Ustavnega sodišča in le-to je razpis razveljavilo, saj škoda, ki bi nastala zaradi marsovskega napada ni sorazmezna s škodo, ki bi nastala s kršenjem zakonodaje s področja javnih naročil. Vse, kar je ostalo od njihovega dela, je nekaj testov. Znajti se bo potrebno iz njih.\n",
    "\n",
    "-------------\n",
    "\n",
    "Videti je, da bo potrebno napisati tri funkcije.\n",
    "\n",
    "- `preberi(ime_datoteke)` dobi ime datoteke, kakršne proizvaja Kozjančeva in, kot je sklepati iz testov, vrne slovar, katerega ključi so koordinate naših ladij, pripadajoče vrednosti pa seznami koordinat marsovskih ladij. Ime datoteke je načelno poljubno.\n",
    "\n",
    "- `vrstica(i, ladja, marsovec)` vrne eno vrstico navodil za CRKnaV. Iz testov lahko sklepamo, da `i` vsebuje zaporedno številko naše ladje ali pa `None`. Če je `i` številka, jo izpiše, nato izpiše koordinate naše in koordinate marsovske ladje. Če je `i` enak `None`, pa ne izpiše ne številke na koordinat naše ladje, temveč samo koordinato marsovske ladje. Torej: klic `vrstica(7, (4.25, 8.50), (5, 5))` vrne\n",
    "\n",
    "    ```\n",
    "       7:     4.2500     8.5000 ->     5.0000    12.3000\n",
    "    ```\n",
    "\n",
    "    klic `vrstica(None, (4.25, 8.50), (5, 12.3))` pa bi vrnil\n",
    "\n",
    "    ```\n",
    "                                       5.0000    12.3000\n",
    "    ```\n",
    "\n",
    "    O tem, kako, točno mora biti oblikovan izpis, bo potrebno sklepati iz testov. Good luck.\n",
    "\n",
    "- `navodila(razpored, ime_datoteke)` dobi slovar v takšni obliki, kot ga vrača prva funkcija in ime datoteke, v katero izpiše navodila, ki se do zadnje pike ujemajo s predvidenim formatom.\n",
    "\n",
    "Sreča v nesreči: v tej nalogi se se dogaja samo v dveh dimenzijah.\n",
    "\n",
    "## Rešitev\n",
    "\n",
    "### `preberi(ime_datoteke)`\n",
    "\n",
    "Pripravimo prazen slovar. Gremo čez vrstice datoteke; videti bodo, na primer, tako: `\"4.25, 8.5:   5.0, 5   |   8.125, -7.5    |   3.5, -6.75\"`. Vsako razbijemo po `\":\"`; dobljena dela (vedno bosta dva) bomo poimenovali `ladja` in `marsovci`. Ladjo razbijemo po `\",\"`, da dobimo koordinati, `x` in `y`. Marsovce razbijemo po `|`, da dobimo posamezne marsovske ladje; vsako od njih pa v notranji zanki potem še po `\",\"`, da dobimo posamezni koordinati. Koordinate zlagamo v seznam koordinat. Na koncu ga dodamo v slovar, pod ključem, ki predstavlja koordinati naše ladje.\n",
    "\n",
    "V spodnji kodi sem nekoliko pretiraval s praznimi vrsticami - to pa zaradi primerov, ki sledijo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "40b80b8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def preberi(ime_datoteke):\n",
    "    razpored = {}\n",
    "    \n",
    "    for vrstica in open(ime_datoteke):\n",
    "        ladja, marsovci = vrstica.split(\":\")\n",
    "        x, y = ladja.split(\",\")\n",
    "        \n",
    "        koordinate = []\n",
    "        for marsovec in marsovci.split(\"|\"):\n",
    "            mx, my = marsovec.split(\",\")\n",
    "            koordinate.append((float(mx), float(my)))\n",
    "            \n",
    "        razpored[(float(x), float(y))] = koordinate\n",
    "        \n",
    "    return razpored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1afa0d8e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(4.25, 8.5): [(5.0, 5.0), (8.125, -7.5), (3.5, -6.75)],\n",
       " (6.0, 1.25): [(15.5, 5.5), (1.5, -1.25), (2.5, -9.5625), (-3.0, -3.0)],\n",
       " (8.0, 1.0): [(-2.0, 5.0)]}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preberi(\"jozica-kozjanc.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e51760b6",
   "metadata": {},
   "source": [
    "V študentskih rešitvah je pogosto videti tole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "27351fdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def preberi(ime_datoteke):\n",
    "    razpored = {}\n",
    "    koordinate = []\n",
    "    \n",
    "    for vrstica in open(ime_datoteke):\n",
    "        ladja, marsovci = vrstica.split(\":\")\n",
    "        x, y = ladja.split(\",\")\n",
    "\n",
    "        for marsovec in marsovci.split(\"|\"):\n",
    "            mx, my = marsovec.split(\",\")\n",
    "            koordinate.append((float(mx), float(my)))\n",
    "            \n",
    "        razpored[(float(x), float(y))] = koordinate\n",
    "        koordinate = []\n",
    "        \n",
    "    return razpored"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf3647a2",
   "metadata": {},
   "source": [
    "Dasiravno to deluje,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7d4490c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(4.25, 8.5): [(5.0, 5.0), (8.125, -7.5), (3.5, -6.75)],\n",
       " (6.0, 1.25): [(15.5, 5.5), (1.5, -1.25), (2.5, -9.5625), (-3.0, -3.0)],\n",
       " (8.0, 1.0): [(-2.0, 5.0)]}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preberi(\"jozica-kozjanc.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "217c5711",
   "metadata": {},
   "source": [
    "mi ni všeč. Razlika je, kot vidite, v tem, da prazen seznam koordinat ustvari na začetku funkcije, pred zunanjo zanko, potem pa ga znotraj zunanje zanke pobriše. To zakrije resnično logiko programa. V gornji verziji imamo blokec"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9a3ca814",
   "metadata": {},
   "source": [
    "        koordinate = []\n",
    "        for marsovec in marsovci.split(\"|\"):\n",
    "            mx, my = marsovec.split(\",\")\n",
    "            koordinate.append((float(mx), float(my)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfa8a391",
   "metadata": {},
   "source": [
    "ki pripravi seznam in ga napolni. V spodnji različici imamo samo"
   ]
  },
  {
   "cell_type": "raw",
   "id": "90928478",
   "metadata": {},
   "source": [
    "        for marsovec in marsovci.split(\"|\"):\n",
    "            mx, my = marsovec.split(\",\")\n",
    "            koordinate.append((float(mx), float(my)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6000c04f",
   "metadata": {},
   "source": [
    "seznam `koordinate` pa se v bistvu ustvarja precej prej in nekoliko kasneje.\n",
    "\n",
    "Druga, bolj deviantna različica, ki sem jo videl, je tale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "83d245ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def preberi(ime_datoteke):\n",
    "    razpored = {}\n",
    "    koordinate = []\n",
    "    \n",
    "    for vrstica in open(ime_datoteke):\n",
    "        ladja, marsovci = vrstica.split(\":\")\n",
    "        x, y = ladja.split(\",\")\n",
    "\n",
    "        for marsovec in marsovci.split(\"|\"):\n",
    "            mx, my = marsovec.split(\",\")\n",
    "            koordinate.append((float(mx), float(my)))\n",
    "            \n",
    "        razpored[(float(x), float(y))] = koordinate\n",
    "        koordinate.clear()\n",
    "        \n",
    "    return razpored"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9aaa874",
   "metadata": {},
   "source": [
    "Tole pa prav poučno ne deluje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "07318ed4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(4.25, 8.5): [], (6.0, 1.25): [], (8.0, 1.0): []}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preberi(\"jozica-kozjanc.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc149dda",
   "metadata": {},
   "source": [
    "Ta funkcija ustvari en in en sam seznam `koordinate`, ki ga malo polni in prazni. Ker v slovar kot vrednost vstavlja ta, vedno en in isti seznam, se vse vrednosti nanašajo pač nanj in so med seboj enake. Še več, med seboj so *iste*. In to takšne, kot je ta seznam na koncu, torej prazen, saj je zadnja stvar, ki se mu zgodi, `koordinate.clear()`.\n",
    "\n",
    "### `vrstica(i, ladja, marsovec)`\n",
    "\n",
    "Rešitev je takšna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "05bd3ab1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def vrstica(i, ladja, marsovec):\n",
    "    if i is None:\n",
    "        return f\"{' ':4}  {' ':10} {' ':10}    {marsovec[0]:10.4f} {marsovec[1]:10.4f}\"\n",
    "    else:\n",
    "        return f\"{i:4}: {ladja[0]:10.4f} {ladja[1]:10.4f} -> {marsovec[0]:10.4f} {marsovec[1]:10.4f}\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de02d410",
   "metadata": {},
   "source": [
    "Kaj bomo izpisali, je odvisno od `i`. Najprej poglejmo drugo različico, tisto, ko `i` ni `None`. Tam pač izpišemo, kar je treba in kakor je treba: `i` na štiri mesta, pa koordinati ladij na deset mes s štirimi decimalkami, pa puščico in koordinate marsovcev na prav tak način. Nič posebnega, samo mesta je potrebno prav prešteti. In nize je potrebno znati oblikovati.\n",
    "\n",
    "Bolj zanimiva je prva različica - prav zato, ker je tako dolgočasna. Tu prvi del praktično prepišemo iz druge, le da `i` in koordinati ladje zamenjamo s presledki. Seveda bi lahko preprosto prešteli presledke in jih izpisali, kolikor jih je treba. Vendar je bolj pregledno in varneje imitirati drugo vrstico.\n",
    "\n",
    "Kdor res ne mara ponavljanja, pa napiše:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cd6f7d0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def vrstica(i, ladja, marsovec):\n",
    "    marsovec = f\"{marsovec[0]:10.4f} {marsovec[1]:10.4f}\"\n",
    "    if i is None:\n",
    "        return f\"{' ':4}  {' ':10} {' ':10}    {marsovec}\"\n",
    "    else:\n",
    "        return f\"{i:4}: {ladja[0]:10.4f} {ladja[1]:10.4f} -> {marsovec}\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d924e213",
   "metadata": {},
   "source": [
    "ali kaj podobnega. Nemara je tako res bolj prav.\n",
    "\n",
    "### `navodila`\n",
    "\n",
    "Tule je bila edina znanost, kako se izogniti izpisom številk v neprvih vrsticah. Takole: imeli bomo dve zanki.\n",
    "- Zunanja gre čez naše ladje in ta potrebuje številko; najlepše jo bo dobiti kar z `enumerate`. Kot argument bomo dodali `start=1`. Če tega trika ne poznamo, bo pač štel od `0` in bomo kasneje, v klicu funkcije vrstica, prištevali `1`.\n",
    "- Notranja zanka bo tekla čez marsovske ladje. Tu moramo pri prvi dodati številko, pri ostalih pa namesto številke podamo `None`. Ali smo pri prvi ladji, najlažje vemo tako, da \"enumeriramo\" tudi marsovce. Kadar je števec različen od `0`, podamo `None`, kadar je enak `0`, pa podamo števec iz prve zanke. Recimo tako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9bc718a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def navodila(razpored, ime_datoteke):\n",
    "    outf = open(ime_datoteke, \"w\")\n",
    "    for i, (ladja, marsovci) in enumerate(razpored.items(), start=1):\n",
    "        for j, marsovec in enumerate(marsovci):\n",
    "            outf.write(vrstica(None if j else i, ladja, marsovec) + \"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "083c770d",
   "metadata": {},
   "source": [
    "Izraz `None if j else i` bo vrnil `None`, kadar je `j` resničen (torej različen od `0`) in `i`, kadar je neresničen. Če takšnih izrazov ne znamo pisati, bo čisto lepo deloval tudi običajni `if`,"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5b86eddd",
   "metadata": {},
   "source": [
    "            if j != 0:\n",
    "                i = None\n",
    "            outf.write(vrstica(i, ladja, marsovec) + \"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f3bc98c",
   "metadata": {},
   "source": [
    "Ne bojte se pokvariti `i`. Zunanja zanka bo normalno delovala naprej; `enumerate` zna šteti tudi če vmes prirejamo imenu, v katerega je zanka vpisala tekočo vrednost, kakšne druge stvari.\n",
    "\n",
    "Če se ne znajdemo z enumeriranjem marsovcev, pa prvega marsovca izpišemo pred notranjo zanko, v notranji zanki pa izpisujemo ostale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c77e6daa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def navodila(razpored, ime_datoteke):\n",
    "    outf = open(ime_datoteke, \"w\")\n",
    "    for i, (ladja, marsovci) in enumerate(razpored.items(), start=1):\n",
    "        outf.write(vrstica(i, ladja, marsovci[0]) + \"\\n\")\n",
    "        for marsovec in marsovci[1:]:\n",
    "            outf.write(vrstica(None, ladja, marsovec) + \"\\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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}