p1/domace-naloge/2022/12 slalomist/resitev.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0abac3ad",
   "metadata": {},
   "source": [
    "# Slalomist\n",
    "\n",
    "## Ocena 6\n",
    "\n",
    "Sestavi razred `Steza`.\n",
    "\n",
    "- Konstruktor prejme tri argumente: širino in višino kolesarske steze ter seznam s terkami ovir (y, x0, x1). Argument s širino in višino vsebuje številko zadnjega stolpca oz. vrstice kolesarske steze. Dovoljeni stolpci so torej od 1 do (vključno) širina. Vrstice so oštevilčene od zgoraj navzdol.\n",
    "- `zaprto(x, y)` vrne `True`, če na polju s podanimi koordinatami stoji ovira.\n",
    "- `konec(x, y, smer)` prejme koordinati nekega polja (na katerem ni ovire) in smer, ki je `>`, `<`, `v` ali `^`. Vrniti mora koordinati polja, na katerem bi se ustavil kolesar, ki bi s podanega polja peljal v podano smer. Ustavi se na polju pred oviro oz. na polju pred robom kolesarske steze.\n",
    "\n",
    "### Rešitev\n",
    "\n",
    "Lahko, recimo, tako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "99b19a05",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Steza:\n",
    "    def __init__(self, sirina, visina, ovire):\n",
    "        self.sirina = sirina\n",
    "        self.visina = visina\n",
    "        self.ovire = ovire\n",
    "\n",
    "    def zaprto(self, x, y):\n",
    "        return any(y == y0 and x0 <= x <= x1 for y0, x0, x1 in self.ovire)\n",
    "\n",
    "    def konec(self, x, y, smer):\n",
    "        dx, dy = {\">\": (1, 0), \"<\": (-1, 0), \"v\": (0, 1), \"^\": (0, -1)}[smer]\n",
    "\n",
    "        while 0 < x <= self.sirina and 0 < y <= self.visina and not self.zaprto(x, y):\n",
    "            x += dx\n",
    "            y += dy\n",
    "        x -= dx\n",
    "        y -= dy\n",
    "        return x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f4ef7a3",
   "metadata": {},
   "source": [
    "- Konstruktor si zapomni vse, kar mu podamo.\n",
    "- V `zaprto` smo uporabili `any` in generator. Konec semestra je, dvoolj smo že stari, to znamo.\n",
    "- V `konec` rinemo v podano smer, dokler gre; ko se znajdemo izven polja ali v oviri, stopimo korak nazaj. To deluje, ker vemo, da se bo zanka izvedla vsaj enkrat, saj naloga zagotavlja, da na začetnem polju ni ovire."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41296d41",
   "metadata": {},
   "source": [
    "## Ocena 7\n",
    "\n",
    "Sestavi razred `Kolesar`.\n",
    "\n",
    "- Konstruktor prejme koordinati `x`, `y` in kolesarsko stezo - objekt razreda `Steza`.\n",
    "- `pozicija()` vrne trenutni koordinati (`(x, y)`) kolesarja.\n",
    "- `premik(smer)` premakne kolesarja v podani smeri do polja, ko se mora ustaviti, ker naleti na oviro ali rob kolesarske steze. Če premik v podano smer ni možen, se kolesar ne premakne. Metoda ne vrne ničesar.\n",
    "\n",
    "    Predpostavlja se, da bo metoda uporabila metodo `konec` podane steze. Če je ne bo, bodo testi javili napako.\n",
    "\n",
    "- `prevozeno()` vrne skupno prevoženo razdaljo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f3fffc5",
   "metadata": {},
   "source": [
    "<img style=\"float: right; margin-left: 10px\" src=\"data:image/.png;base64,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\"/>\n",
    "\n",
    "Program (`ovire` so seznam ovir kot v prejšnji nalogi)\n",
    "\n",
    "```python\n",
    "steza = Steza(17, 18, ovire)\n",
    "kolesar = Kolesar(12, 1, steza)\n",
    "kolesar.premik(\"v\")\n",
    "kolesar.premik(\">\")\n",
    "kolesar.premik(\"v\")\n",
    "kolesar.premik(\"<\")\n",
    "kolesar.premik(\"v\")\n",
    "kolesar.premik(\"<\")\n",
    "kolesar.premik(\"v\")\n",
    "kolesar.premik(\">\")\n",
    "kolesar.premik(\"v\")\n",
    "kolesar.premik(\">\")\n",
    "kolesar.premik(\"v\")\n",
    "kolesar.premik(\">\")\n",
    "kolesar.premik(\"v\")\n",
    "```\n",
    "\n",
    "mora voziti kolesarja, kot kaže slika. Številke kažejo prevožene razdalje."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a1b496d",
   "metadata": {},
   "source": [
    "### Rešitev\n",
    "\n",
    "Konstruktor si zapomni, kar mu je bilo podano, in nastavi števec na 0. Števcu bi radi rekli `self.prevozeno`, vendar ne smemo, ker je to že ime metode. Atribut `prevozeno` bi povozil metodo `prevozeno` in potem bi dobivali napake v slogu, da `int` ni \"callable\" - vsak, ki bi hotel poklicati *metodo* `prevozeno` bi namreč poklical `int` `prevozeno`.\n",
    "\n",
    "Ena od možnih rešitev je, da na začetek imena atributa dodamo podčrtaj. S tem tudi nakažemo, da je atribut nekako \"privaten\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "43c4c7da",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Kolesar:\n",
    "    def __init__(self, x, y, steza: Steza):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.steza = steza\n",
    "        self._prevozeno = 0\n",
    "\n",
    "    def premik(self, smer):\n",
    "        nx, ny = self.steza.konec(self.x, self.y, smer)\n",
    "        self._prevozeno += abs(self.x - nx) + abs(self.y - ny)\n",
    "        self.x, self.y = nx, ny\n",
    "\n",
    "    def pozicija(self):\n",
    "        return self.x, self.y\n",
    "\n",
    "    def prevozeno(self):\n",
    "        return self._prevozeno"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fa03f3d",
   "metadata": {},
   "source": [
    "Metode `pozicija` in `prevozeno` ne počneta ničesar posebnega. Bistvo je v metodi `premik`. Ta uporabi `self.steza.konec`, da izve novi koordinati kolesarja. V `self._prevozeno` dodamo razdaljo, ki jo dobimo kot absolutno vrednost razlike med novim in starim x ter novim in starim y. Eden od teh bo vedno nič, vendar nas ta nič nič ne boli.\n",
    "\n",
    "Pazi: pravilen klic je `self.steza.konec(...)` in ne `Steza.konec(self.steza, ...)`. To, drugo, sicer deluje, vendar je grdo, nenavadno, neugledno, neprimerno. Tako ne programiramo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2316986d",
   "metadata": {},
   "source": [
    "## Ocena 8\n",
    "\n",
    "Sestavi razred `AvtonomniKolesar`, ki je izpeljan iz razreda kolesar.\n",
    "\n",
    "- Konstruktor prejme enake argumente kot kolesar, poleg tega pa še argument `načrt`, ki je niz, sestavljen iz znakov `<` in `>`.\n",
    "- Metoda `premik` ne prejme argumentov (razen `self`) in počne naslednje.\n",
    "\n",
    "    - Ko jo pokličemo prvič, se kolesar odpelje dol (če more; če ne more, ne naredi ničesar). Pelje se, kolikor daleč dol se more. (Uporabi podedovano metodo `premik`!)\n",
    "    - Ko jo pokličemo naslednjič, se odpelje (kolikor daleč se more) v smer, ki jo narekuje prvi korak (= prvi znak) načrta, ki ga je dobil konstruktor.\n",
    "    - Ko jo pokličemo naslednjič, se odpelje dol.\n",
    "    - Ko jo pokličemo naslednjič, se odpelje v smeri drugega koraka (znaka) načrta.\n",
    "    - Ko jo pokličemo naslednjič, se odpelje dol.\n",
    "    - ... in tako naprej. **Če zmanjka načrta, ga začne ponavljati od začetka.**\n",
    "\n",
    "    Z drugimi besedami kolesar se izmenično premika dol in v smeri, ki jo daje načrt.\n",
    "\n",
    "    Metoda `premik` mora na primeren način klicati podedovano metodo `premik`.\n",
    "\n",
    "Tole pelje kolesarja po poti iz prejšnje slike. Načrt je predolg in se pač ne izvede do konca.\n",
    "\n",
    "```python\n",
    "steza = Steza(17, 18, ovire)  # kjer so ovire seznam ovir kot v prejšnji nalogi\n",
    "kolesar = AvtonomniKolesar(12, 1, steza, \"><<>><>\")\n",
    "```\n",
    "\n",
    "### Rešitev\n",
    "\n",
    "Kolesar mora vedeti do kod v načrtu, oziroma kateri bo naslednji uporabljeni znak načrta. Poleg tega mora vedeti, ali se mora premakniti dol ali iti, kot pravi načrt.\n",
    "\n",
    "Ena rešitev je takšna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "71d9bd32",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AvtonomniKolesar(Kolesar):\n",
    "    def __init__(self, x, y, steza, nacrt):\n",
    "        super().__init__(x, y, steza)\n",
    "        self.nacrt = nacrt\n",
    "        self.dol = True\n",
    "        self.korak = 0\n",
    "\n",
    "    def premik(self):\n",
    "        if self.dol:\n",
    "            super().premik(\"v\")\n",
    "        else:\n",
    "            super().premik(self.nacrt[self.korak])\n",
    "            self.korak += 1\n",
    "            if self.korak == len(self.nacrt):\n",
    "                self.korak = 0\n",
    "        self.dol = not self.dol"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b9c20ae",
   "metadata": {},
   "source": [
    "- `self.dol` je `True`, če bo naslednji korak `\"v\"` in `False`, če bomo uporabili znak iz načrta. V vsakem premiku ga \"obrnemo\" s `self.dol = not self.dol`.\n",
    "- `self.korak` pove, kateri znak iz načrta je na vrsti. V `premik` ga povečamo za `1`, vsakič, ko gremo po načrtu. Če pride do konca, ga postavimo nazaj na 0.\n",
    "\n",
    "Kot to sklenemo, je preprosto: premik preveri, ali je potrebno iti `dol`. Če je tako, gre dol, sicer po načrtu.\n",
    "\n",
    "Lahko pa bi šteli vsak korak. V tem primeru gremo ob sodih korakih dol, ob lihih po načrtu. Uporabljeni znak načrta dobimo tako, da `self.korak` delimo z `2` (deljenje bo vedno zaokrožilo navzdol, kar je dobro) in potem vzamemo ostanek po deljenju z dolžino načrta, s čimer dosežemo, da se načrt, po tem, ko pridemo do konca, ponovi od začetka."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e089b457",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AvtonomniKolesar(Kolesar):\n",
    "    def __init__(self, x, y, steza, nacrt):\n",
    "        super().__init__(x, y, steza)\n",
    "        self.nacrt = nacrt\n",
    "        self.korak = 0\n",
    "\n",
    "    def premik(self):\n",
    "        if self.korak % 2 == 0:\n",
    "            super().premik(\"v\")\n",
    "        else:\n",
    "            super().premik(self.nacrt[self.korak // 2 % len(self.nacrt)])\n",
    "        self.korak += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af07d4f1",
   "metadata": {},
   "source": [
    "## Ocena 9\n",
    "\n",
    "Sestavi razred `VzvratniKolesar`, izpeljan iz razreda `Kolesar`.\n",
    "\n",
    "- Konstruktor dopolnjuj po potrebi.\n",
    "- Metodo `premik` dopolnjuj po potrebi. Pri tem uporabljaj podedovano metodo premik; ne piši vsega od začetka.\n",
    "- Metoda `nazaj` se vede kot \"undo\": kolesarja vrne za en korak nazaj, torej v stanje, v kakršnem je bil pred klicem metode `premik`. To spremeni njegove koordinate, pa tudi prevožena razdalja se zmanjša. Učinek je torej enak, kot da ne bi bilo zadnjega premika.\n",
    "\n",
    "    Metodo `nazaj` lahko pokličemo tudi večkrat zapored; kolesarja lahko vrnemo čisto do njegove začetne pozicije. Če kličemo metodo `nazaj` takrat, ko smo ga že vrnili do začetka, metoda ne stori ničesar.\n",
    "    \n",
    "### Rešitev\n",
    "\n",
    "To je veliko lažje, kot je videti (in kot je pričakovati za oceno 9). Kolesar si zapomnjuje pretekle koordinate in prevožene kvadrate. Če hočemo nazaj, preprosto povrne stanje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4c81a564",
   "metadata": {},
   "outputs": [],
   "source": [
    "class VzvratniKolesar(Kolesar):\n",
    "    def __init__(self, x, y, steza):\n",
    "        super().__init__(x, y, steza)\n",
    "        self.pretekle = []\n",
    "\n",
    "    def premik(self, smer):\n",
    "        self.pretekle.append((self.x, self.y, self._prevozeno))\n",
    "        super().premik(smer)\n",
    "\n",
    "    def nazaj(self):\n",
    "        if self.pretekle:\n",
    "            self.x, self.y, self._prevozeno = self.pretekle.pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af4c5c0d",
   "metadata": {},
   "source": [
    "Opomniti pa moramo, da je tak način izvedbe \"undo\" potraten. Tule je seveda popolnoma vseeno, običajno pa si mora undo zapomniti spremembo. Navadno undo shrani akcijo, ki ga pripelje nazaj v prejšnje stanje in akcijo, ki ga pripelje nazaj nazaj (redo)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2822fbb9",
   "metadata": {},
   "source": [
    "## Ocena 10\n",
    "\n",
    "Sestavi razred `PametniKolesar` izpeljan iz razreda `VzvratniKolesar`.\n",
    "\n",
    "Razred ima metodo `nacrt`, ki poišče najkrajšo pot (to je, pot z najmanjšo prevoženo razdaljo) do zadnje vrstice. Kolesar se lahko premika le levo, desno in dol, pri čemer se, tako kot v prejšnjih nalogah, vedno pelje, dokler ne pride do ovire ali do roba poti.\n",
    "\n",
    "Funkcija mora vrniti par - dolžino prevožene poti in niz s potjo. Če pot z neke točke ni možna, funkcija vrne par `(`None`, \"\")`.\n",
    "\n",
    "<img style=\"float: right; margin-left: 20px\" src=\"data:image/.png;base64,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\"/>\n",
    "\n",
    "```python\n",
    "steza = Steza(17, 18, ovire)\n",
    "kolesar = PametniKolesar(12, 1, steza)\n",
    "print(kolesar.nacrt())\n",
    "```\n",
    "\n",
    "izpiše\n",
    "\n",
    "```\n",
    "(23, 'v<v>v>v>v')\n",
    "```\n",
    "\n",
    "Pot je na sliki. Ne spreglej: pot bi bila sicer krajša, če bi se kolesar z (12, 6) ne bi šel do (10, 6), temveč bi se že na pol poti, torej na (11, 6), obrnil navzdol. Vendar tega ne more, ker se vedno pelje do polja, kjer ga ustavi ovira ali rob.\n",
    "\n",
    "Nasvet: da se kolesar ne bo zaciklal, premiku levo nikoli ne sme slediti premik desno oz. obratno. Najbrž je najpreprosteje, da funkciji dodate argument s privzeto vrednostjo, ki bo povedal, ali je bil zadnji premik navzdol. Druga, morda še preprostejša možnost je, da funkciji dodate argument `pot`, ki beleži doslejšnje premike - ob vsakem rekurzivnem klicu dodate zadnjo smer. Ni najlepše, ampak dela. Tretja možnost je, da rekurzijo napišete tako, da funkcija v vsakem klicu naredi korak dol in desno.\n",
    "\n",
    "Pazite tudi na tole: če premik ne naredi ničesar (smo nad oviro in hočemo dol?) naj mu ne sledi rekurzivni klic."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0da46bc6",
   "metadata": {},
   "source": [
    "### Rešitev\n",
    "\n",
    "\n",
    "Moja rešitev, ki ni nujno najpreprostejša, je takšna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1cba4b5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PametniKolesar(VzvratniKolesar):\n",
    "    def nacrt(self, pot=\"\"):\n",
    "        if self.y == self.steza.visina:\n",
    "            return self.prevozeno(), pot\n",
    "\n",
    "        x, y = self.x, self.y\n",
    "        self.premik(\"v\")\n",
    "        mozne = []\n",
    "        if y != self.y:\n",
    "            mozne.append(self.nacrt(pot + \"v\"))\n",
    "        self.nazaj()\n",
    "        \n",
    "        if not pot or pot[-1] == \"v\":\n",
    "            self.premik(\"<\")\n",
    "            if x != self.x:\n",
    "                mozne.append(self.nacrt(pot + \"<\"))\n",
    "            self.nazaj()\n",
    "        \n",
    "            self.premik(\">\")\n",
    "            if x != self.x:\n",
    "                mozne.append(self.nacrt(pot + \">\"))\n",
    "            self.nazaj()\n",
    "        return min((x for x in mozne if x[0] is not None), default=(None, \"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac9ff624",
   "metadata": {},
   "source": [
    "Funkcija v rekurzivnem klicu dopolnjuje `pot`, da ve, kakšen je bil zadnji korak. In ker jo ravno ima, jo na koncu tudi vrne, prav tako pa vrne število prevoženih kvadratkov.\n",
    "\n",
    "Če ni na koncu pa poskusi vse tri možne smeri, si zapomni rezultat in naredi korak nazaj. Smeri levo in desno seveda preskusi le, če je zadnja smer na poti dol.\n",
    "\n",
    "Na koncu funkcije poiščemo minimum izmed vse rešitev, ki pripeljejo do cilja (`x[0] is not None`), kot privzeto vrednost (če nobena smer ni pripeljala do cilja) pa vrnemo `(None, \"\")`."
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}