Riešenie 18. cvičenia


  1. Napríklad:

    import turtle
    import random
    
    class MojaTurtle(turtle.Turtle):
        def domcek(self, dlzka):
            for uhol in 90, 90, 90, 30, 120, -60:
                self.fd(dlzka)
                self.rt(uhol)
    
    class MojaTurtle1(MojaTurtle):
        def fd(self, dlzka):
            while dlzka >= 5:
                self.lt(60)
                super().fd(5)
                self.rt(120)
                super().fd(5)
                self.lt(60)
                dlzka -= 5
            super().fd(dlzka)
    
    class MojaTurtle2(MojaTurtle):
        def fd(self, dlzka):
            super().fd(dlzka)
            self.rt(180 - random.randint(-3, 3))
            super().fd(dlzka)
            self.rt(180 - random.randint(-3, 3))
            super().fd(dlzka)
    
    turtle.delay(0)
    zoz = []
    moja = (MojaTurtle1, MojaTurtle2, MojaTurtle)
    for i in range(10):
        t = moja[i%3]()
        t.ht()
        t.speed(0)
        t.pu()
        t.setpos(i*60-300, 0)
        t.pd()
        zoz.append(t)
    
    for t in zoz:
        t.domcek(random.randint(30, 50))
    

  1. Riešenie:

    class MojaTurtle1(MojaTurtle):
        def rt(self, uhol):
            super().rt(uhol + random.randint(-5, 5))
    
    class MojaTurtle2(MojaTurtle):
        def fd(self, dlzka):
            super().fd(dlzka + random.randint(-5, 5))
    

    Ak bude trieda MojaTurtle2 odvodená z MojaTurtle1, t.j.

    class MojaTurtle2(MojaTurtle1):
        def fd(self, dlzka):
            super().fd(dlzka + random.randint(-5, 5))
    

    inštancie triedy MojaTurtle2 budú mať „pokazené“ obe metódy fd aj rt.


  1. Riešenie:

    >>> x = 5
    >>> (x * 7 - 8 ) / 4 ** 2
    1.6875
    >>> x.__mul__(7).__sub__(8).__truediv__((4).__pow__(2))
    1.6875
    
    >>> (6).__sub__((5).__mul__(4)).__add__((3).__pow__(2))
    -5
    >>> 6 - 5*4 + 3**2
    -5
    

  1. Riešenie:

    class Cas:
    
        def __init__(self, hodiny=0, minuty=0, sekundy=0):
            self.sek = abs(3600*hodiny + 60*minuty + sekundy)
    
        def __str__(self):
            return f'{self.sek // 3600}:{self.sek // 60 % 60:02}:{self.sek % 60:02}'
    
        __repr__ = __str__
    
        def __add__(self, iny):
            if isinstance(iny, int):
                return Cas(sekundy=self.sek+iny)
            if isinstance(iny, Cas):
                return Cas(sekundy=self.sek+iny.sek)
            sek = iny[0] * 3600
            if len(iny) > 1:
                sek += iny[1] * 60
            if len(iny) == 3:
                sek += iny[2]
            return Cas(sekundy=self.sek+sek)
    
        def __sub__(self, iny):
            if isinstance(iny, int):
                return Cas(sekundy=self.sek-iny)
            if isinstance(iny, Cas):
                return Cas(sekundy=self.sek-iny.sek)
            sek = iny[0] * 3600
            if len(iny) > 1:
                sek += iny[1] + 60
            if len(iny) == 3:
                sek += iny[2]
            return Cas(sekundy=self.sek-sek)
    
        def __gt__(self, iny):
            return self.sek > iny.sek
    
        def __eq__(self, iny):
            return self.sek == iny.sek
    

  1. Riešenie:

    import time
    
    def teraz():
        h, m, s = time.localtime()[3:6]
        return Cas(h, m, s)
    

    alebo

    def teraz():
        return Cas() + time.localtime()[3:6]
    

  1. Riešenie:

    zoznam = []
    for i in range(10):
        zoznam.append(Cas(random.randrange(24),
                          random.randrange(60),
                          random.randrange(60)))
    print('pôvodný zoznam:', zoznam)
    print('utriedený zoznam:', sorted(zoznam))
    

  1. Riešenie:

    def neparne(n):
        vysl = set()
        for i in range(1, n, 2):
            vysl.add(i)
        return vysl
    

    alebo

    def neparne(n):
        return set(range(1, n, 2))
    

  1. Riešenie:

    def samohlasky(veta):
        vysl = set()
        for znak in veta:
            if znak in {'a', 'e', 'i', 'o', 'u', 'y'}:
                vysl.add(znak)
        return vysl
    

    alebo:

    def samohlasky(veta):
        return set(veta) & set('aeiouy')
    

  1. Riešenie:

    def slova(meno_suboru):
        with open(meno_suboru, encoding='utf-8') as text:
            return set(text.read().split())
    

  1. Riešenie:

    def vyrob(od, do):
        vysl = set()
        for i in range(od, do+1):
            if i%7 != 0 and (i%5 == 2 or i%5 == 3):
                vysl.add(i)
        return vysl
    

    alebo

    def vyrob(od, do):
        return (set(range(od, do+1)) - set(range(0, do+1, 7)) &
                (set(range(2, do+1, 5)) | set(range(3, do+1, 5))))
    

  1. Riešenie:

    def bez(mnoz, k):
        for i in list(mnoz):
            if isinstance(i, int) and i%k == 0:
                mnoz.remove(i)
    

    alebo

    def bez(mnoz, k):
        pom = set()
        for i in mnoz:
            if isinstance(i, int) and i%k == 0:
                pom.add(i)
        mnoz -= pom
    

  1. Riešenie:

    def viac(zoznam):
        vysl = set()
        for prvok in set(zoznam):
            if zoznam.count(prvok) > 1:
                vysl.add(prvok)
        return vysl
    

    alebo:

    def viac(zoznam):
        vysl = set()
        for i, prvok in enumerate(zoznam):
            if prvok in zoznam[i+1:]:
                vysl.add(prvok)
        return vysl
    

    alebo:

    def viac(zoznam):
        vysl = set()
        raz = set()
        for prvok in zoznam:
            if prvok in raz:
                vysl.add(prvok)
            else:
                raz.add(prvok)
        return vysl
    

  1. Riešenie:

    def len_cisla(mnozina):
        vysl = set()
        for prvok in mnozina:
            if isinstance(prvok, (int, float)):
                vysl.add(prvok)
        return vysl
    

  1. Riešenie:

    def vsetky(a, b, c, d):
        return [{a, b}, {a, c}, {a, d}, {b, c}, {b, d}, {c, d}]
    

  1. Riešenie:

    def vsetky(postupnost):
        vysl = []
        for i in postupnost:
            for j in postupnost:
                if i != j and {i, j} not in vysl:
                    vysl.append({i, j})
        return vysl
    

    alebo:

    def vsetky(postupnost):
        vysl = []
        pom = list(set(postupnost))
        for i in range(len(pom)):
            for j in range(i+1, len(pom)):
                vysl.append({pom[i], pom[j]})
        return vysl
    

  1. Riešenie:

    def kartez_sucin(m1, m2):
        vysl = set()
        for i in m1:
            for j in m2:
                vysl.add((i, j))