Kolejna porcja rozwiązań zadań domowych

domowe/t2/dhont/dhont.py

+def dhont(wyniki, lmandatow):
+    ilorazy = sorted(((glosy/i, glosy, -poz, partia)
+                      for poz, (partia, glosy) in enumerate(wyniki.items())
+                      for i in range(1, lmandatow+1)), reverse=True)
+    mandaty = {partia: 0 for partia in wyniki.keys()}
+    for i, (iloraz, glosy, poz, partia) in enumerate(ilorazy):
+        if i >= lmandatow: break
+        mandaty[partia] += 1
+    return mandaty
+
+
+def main():
+    wyniki = {"czerwoni": 12000, "zieloni": 7000, "niebiescy": 5000, "pomarańczowi": 3000}
+    mandaty = dhont(wyniki, 5)
+    print(mandaty)
+    assert mandaty == {"czerwoni": 3, "zieloni": 1, "niebiescy": 1, "pomarańczowi": 0}
+
+
+if __name__ == '__main__':
+    main()

domowe/t2/electric_car/zad3_car_v1.py

+class ElectricCar:
+    """
+    Zaimplementuj klasę ElectricCar odwzorowującą zachowanie
+    samochodu elektrycznego. Klasa powinna umożliwiać pokonanie
+    zadanego dystansu, który nie może przekroczyć maksymalnego
+    zasięgu zdefiniowanego dla samochodu. Samochód powinien
+    mieć także możliwość naładowania baterii.
+    >>> car = ElectricCar(100)
+    >>> car.drive(70)
+    70
+    >>> car.drive(50)
+    30
+    >>> car.drive(50)
+    0
+    >>> car.charge()
+    >>> car.drive(50)
+    50
+    """
+
+    def __init__(self, zasieg):
+        self.max_zasieg = zasieg
+        self.biezacy_zasieg = zasieg
+
+    def drive(self, dystans):
+        if dystans <= self.biezacy_zasieg:
+            self.biezacy_zasieg -= dystans
+            return dystans
+        else:
+            try:
+                return self.biezacy_zasieg
+            finally:
+                self.biezacy_zasieg = 0
+
+    def charge(self):
+        self.biezacy_zasieg = self.max_zasieg
+
+
+#### Tutaj kilka testów pytest ####
+
+def test_drive1():
+    car = ElectricCar(100)
+    km = car.drive(70)
+    assert km == 70
+
+def test_drive_do_konca():
+    car = ElectricCar(100)
+    km = car.drive(70)
+    km = car.drive(50)
+    assert km == 30
+
+def test_wyladowanie_do_zera():
+    car = ElectricCar(100)
+    km = car.drive(150)
+    km = car.drive(50)
+    assert km == 0
+
+def test_charge1():
+    car = ElectricCar(200)
+    car.drive(150)
+    car.drive(100)
+    car.charge()
+    km = car.drive(150)
+    assert km == 150
+
+def test_charge2():
+    car = ElectricCar(500)
+    car.drive(300)
+    car.charge()
+    km = car.drive(600)
+    assert km == 500
+

domowe/t2/electric_car/zad3_car_v2.py

+class ElectricCar:
+    """
+    Zaimplementuj klasę ElectricCar odwzorowującą zachowanie
+    samochodu elektrycznego. Klasa powinna umożliwiać pokonanie
+    zadanego dystansu, który nie może przekroczyć maksymalnego
+    zasięgu zdefiniowanego dla samochodu. Samochód powinien
+    mieć także możliwość naładowania baterii.
+    >>> car = ElectricCar(100)
+    >>> car.drive(70)
+    70
+    >>> car.drive(50)
+    30
+    >>> car.drive(50)
+    0
+    >>> car.charge()
+    >>> car.drive(50)
+    50
+    """
+
+    def __init__(self, zasieg):
+        self.max_zasieg = zasieg
+        self.biezacy_zasieg = zasieg
+
+    def drive(self, dystans):
+        przejazd = dystans if dystans <= self.biezacy_zasieg else self.biezacy_zasieg
+        self.biezacy_zasieg -= przejazd
+        return przejazd
+
+    def charge(self):
+        self.biezacy_zasieg = self.max_zasieg
+
+
+#### Tutaj kilka testów pytest ####
+
+def test_drive1():
+    car = ElectricCar(100)
+    km = car.drive(70)
+    assert km == 70
+
+def test_drive_do_konca():
+    car = ElectricCar(100)
+    km = car.drive(70)
+    km = car.drive(50)
+    assert km == 30
+
+def test_wyladowanie_do_zera():
+    car = ElectricCar(100)
+    km = car.drive(150)
+    km = car.drive(50)
+    assert km == 0
+
+def test_charge1():
+    car = ElectricCar(200)
+    car.drive(150)
+    car.drive(100)
+    car.charge()
+    km = car.drive(150)
+    assert km == 150
+
+def test_charge2():
+    car = ElectricCar(500)
+    car.drive(300)
+    car.charge()
+    km = car.drive(600)
+    assert km == 500
+

domowe/t2/electric_car/zad3_car_v3.py

+class ElectricCar:
+    """
+    Zaimplementuj klasę ElectricCar odwzorowującą zachowanie
+    samochodu elektrycznego. Klasa powinna umożliwiać pokonanie
+    zadanego dystansu, który nie może przekroczyć maksymalnego
+    zasięgu zdefiniowanego dla samochodu. Samochód powinien
+    mieć także możliwość naładowania baterii.
+    >>> car = ElectricCar(100)
+    >>> car.drive(70)
+    70
+    >>> car.drive(50)
+    30
+    >>> car.drive(50)
+    0
+    >>> car.charge()
+    >>> car.drive(50)
+    50
+    """
+
+    def __init__(self, zasieg):
+        self.max_zasieg = zasieg
+        self.biezacy_zasieg = zasieg
+
+    def drive(self, dystans):
+        przejazd = min(dystans, self.biezacy_zasieg)
+        self.biezacy_zasieg -= przejazd
+        return przejazd
+
+    def charge(self):
+        self.biezacy_zasieg = self.max_zasieg
+
+
+#### Tutaj kilka testów pytest ####
+
+def test_drive1():
+    car = ElectricCar(100)
+    km = car.drive(70)
+    assert km == 70
+
+def test_drive_do_konca():
+    car = ElectricCar(100)
+    km = car.drive(70)
+    km = car.drive(50)
+    assert km == 30
+
+def test_wyladowanie_do_zera():
+    car = ElectricCar(100)
+    km = car.drive(150)
+    km = car.drive(50)
+    assert km == 0
+
+def test_charge1():
+    car = ElectricCar(200)
+    car.drive(150)
+    car.drive(100)
+    car.charge()
+    km = car.drive(150)
+    assert km == 150
+
+def test_charge2():
+    car = ElectricCar(500)
+    car.drive(300)
+    car.charge()
+    km = car.drive(600)
+    assert km == 500
+

domowe/t2/electric_car/zad3_car_v4.py

+class ElectricCar:
+    """
+    Zaimplementuj klasę ElectricCar odwzorowującą zachowanie
+    samochodu elektrycznego. Klasa powinna umożliwiać pokonanie
+    zadanego dystansu, który nie może przekroczyć maksymalnego
+    zasięgu zdefiniowanego dla samochodu. Samochód powinien
+    mieć także możliwość naładowania baterii.
+    >>> car = ElectricCar(100)
+    >>> car.drive(70)
+    70
+    >>> car.drive(50)
+    30
+    >>> car.drive(50)
+    0
+    >>> car.charge()
+    >>> car.drive(50)
+    50
+    """
+
+    def __init__(self, zasieg):
+        self.max_zasieg = zasieg
+        self.biezacy_zasieg = zasieg
+
+    def drive(self, dystans):
+        if dystans > self.biezacy_zasieg:
+            dystans = self.biezacy_zasieg
+        self.biezacy_zasieg -= dystans
+        return dystans
+
+    def charge(self):
+        self.biezacy_zasieg = self.max_zasieg
+
+
+#### Tutaj kilka testów pytest ####
+
+def test_drive1():
+    car = ElectricCar(100)
+    km = car.drive(70)
+    assert km == 70
+
+def test_drive_do_konca():
+    car = ElectricCar(100)
+    km = car.drive(70)
+    km = car.drive(50)
+    assert km == 30
+
+def test_wyladowanie_do_zera():
+    car = ElectricCar(100)
+    km = car.drive(150)
+    km = car.drive(50)
+    assert km == 0
+
+def test_charge1():
+    car = ElectricCar(200)
+    car.drive(150)
+    car.drive(100)
+    car.charge()
+    km = car.drive(150)
+    assert km == 150
+
+def test_charge2():
+    car = ElectricCar(500)
+    car.drive(300)
+    car.charge()
+    km = car.drive(600)
+    assert km == 500
+

domowe/t2/fraction/fraction.py

+def gcd(a: int, b: int) -> int:
+    '''Największy wspólny dzielnik, algorytm Euklidesa.'''
+    while b != 0:
+        a, b = b, a % b
+    return a
+
+
+class Fraction:
+    def __init__(self, nominator: int = 0, denominator: int = 1):
+        if denominator == 0:
+            raise ValueError('Fraction denominator cannot be zero')
+        if denominator < 0:
+            nominator = -nominator
+            denominator = -denominator
+        self.nominator = nominator
+        self.denominator = denominator
+
+    def __repr__(self) -> str:
+        return f'Fraction({repr(self.nominator)},{repr(self.denominator)})'
+
+    def __str__(self) -> str:
+        return f'{self.nominator}/{self.denominator}'
+
+    def shortened(self) -> 'Fraction':
+        gcd_here = gcd(self.nominator, self.denominator)
+        return Fraction(self.nominator // gcd_here, self.denominator // gcd_here)
+
+    def reciprocal(self) -> 'Fraction':
+        return Fraction(self.denominator, self.nominator)
+
+    @property
+    def integer_part(self) -> int:
+        return self.nominator // self.denominator
+
+    @property
+    def fraction_part(self) -> 'Fraction':
+        return Fraction(self.nominator % self.denominator, self.denominator)
+
+    def __neg__(self) -> 'Fraction':
+        return Fraction(-self.nominator, self.denominator)
+
+    def __add__(self, other: 'Fraction') -> 'Fraction':
+        return Fraction(self.nominator * other.denominator + other.nominator * self.denominator,
+                        self.denominator * other.denominator).shortened()
+
+    def __add__v1_(self, other: 'Fraction') -> 'Fraction':
+        # wersja "szkolna"
+        common_denom = self.denominator * other.denominator // gcd(self.denominator, other.denominator)
+        nom1 = self.nominator * common_denom // self.denominator
+        nom2 = other.nominator * common_denom // other.denominator
+        return Fraction(nom1 + nom2, common_denom)
+
+    def __sub__(self, other: 'Fraction') -> 'Fraction':
+        return self + (-other)
+
+    def __mul__(self, other: 'Fraction') -> 'Fraction':
+        return Fraction(self.nominator * other.nominator,
+                        self.denominator * other.denominator).shortened()
+
+    def __truediv__(self, other: 'Fraction') -> 'Fraction':
+        return self * other.reciprocal()
+
+    def __floordiv__(self, other: 'Fraction') -> 'Fraction':
+        return Fraction(int(self / other))
+
+    def __float__(self) -> float:
+        return self.nominator / self.denominator
+
+    def __int__(self) -> int:
+        return self.integer_part
+
+    def __bool__(self) -> bool:
+        return self.nominator != 0
+
+    def __eq__(self, other: 'Fraction') -> bool:
+        return self.nominator * other.denominator == other.nominator * self.denominator
+
+    def __lt__(self, other: 'Fraction') -> bool:
+        return self.nominator * other.denominator <  other.nominator * self.denominator
+
+    def __le__(self, other: 'Fraction') -> bool:
+        return self.nominator * other.denominator <= other.nominator * self.denominator
+
+    def __gt__(self, other: 'Fraction') -> bool:
+        return self.nominator * other.denominator >  other.nominator * self.denominator
+
+    def __ge__(self, other: 'Fraction') -> bool:
+        return self.nominator * other.denominator >= other.nominator * self.denominator

domowe/t2/fraction/fraction_test.py

+from fraction import *
+
+def test_gcd_1():
+    assert gcd(1, 1) == 1
+
+def test_gcd_rowne():
+    assert gcd(17, 17) == 17
+
+def test_gcd_wielokrotnosc():
+    assert gcd(77, 11) == 11
+
+def test_gcd_3():
+    assert gcd(24, 15) == 3
+
+def test_add_1():
+    a = Fraction(2, 3)
+    b = Fraction(5, 3)
+    res = a + b
+    assert res.nominator == 7
+    assert res.denominator == 3
+
+def test_add_2():
+    a = Fraction(2, 3)
+    b = Fraction(3, 5)
+    res = a + b
+    assert res.nominator == 19
+    assert res.denominator == 15
+
+def test_add_3():
+    a = Fraction(3, 8)
+    b = Fraction(5, 6)
+    res = a + b
+    assert res.nominator == 29
+    assert res.denominator == 24
+
+def test_neg():
+    a = Fraction(3, 7)
+    res = -a
+    assert res.nominator == -3
+    assert res.denominator == 7
+
+def test_sub_3():
+    a = Fraction(3, 8)
+    b = Fraction(5, 6)
+    res = b - a
+    assert res.nominator == 11
+    assert res.denominator == 24
+
+def test_mul_1():
+    a = Fraction(2, 3)
+    b = Fraction(11, 7)
+    res = a * b
+    assert res.nominator == 22
+    assert res.denominator == 21
+
+def test_mul_2():
+    a = Fraction(2, 3)
+    b = Fraction(6, 7)
+    res = a * b
+    assert res.nominator == 4
+    assert res.denominator == 7
+
+def test_div_1():
+    a = Fraction(3412, 101)
+    b = Fraction(3412, 101)
+    res = a / b
+    assert res.nominator == 1
+    assert res.denominator == 1
+
+def test_div_2():
+    a = Fraction(2, 3)
+    b = Fraction(7, 6)
+    res = a / b
+    assert res.nominator == 4
+    assert res.denominator == 7
+
+def test_int():
+    a = Fraction(7, 4)
+    assert int(a) == 1
+
+def test_float():
+    a = Fraction(7, 4)
+    assert float(a) == 1.75
+
+def test_true():
+    a = Fraction(7, 4)
+    assert bool(a) == True
+
+def test_false():
+    a = Fraction(0, 4)
+    assert bool(a) == False

domowe/t2/ogloszenia/ogloszenia.py

+class Ogloszenie:
+
+    def __init__(self, tytul, cena, telefon, miasto):
+        self.tytul = tytul
+        self.cena = cena
+        self.telefon = telefon
+        self.miasto = miasto
+
+    def zmienCene(self, zmiana):
+        # gdyby cena miała wyjść ujemna
+        if self.cena + zmiana < 0:
+            raise ValueError('cena wyszłaby ujemna')
+        self.cena += zmiana
+
+    def __str__(self):
+        return f'Ogłoszenie z miasta {self.miasto}: {self.tytul}, cena: {self.cena}, kontakt: {self.telefon}'
+
+
+class OgloszenieSamochodowe(Ogloszenie):
+    def __init__(self, tytul, cena, telefon, miasto, marka, model, rocznik, przebieg, moc):
+        super().__init__(tytul, cena, telefon, miasto)
+        self.marka = marka
+        self.model = model
+        self.rocznik = rocznik
+        self.przebieg = przebieg
+        self.moc = moc
+
+
+class OgloszenieMieszkaniowe(Ogloszenie):
+    def __init__(self, tytul, cena, telefon, miasto, metraz, liczba_pokoi, pietro, balkon):
+        super().__init__(tytul, cena, telefon, miasto)
+        self.metraz = metraz
+        self.liczba_pokoi = liczba_pokoi
+        self.pietro = pietro
+        self.balkon = balkon

domowe/t2/ogloszenia/program.py

+from ogloszenia import OgloszenieSamochodowe
+
+ogloszenie = OgloszenieSamochodowe('Sprzedam Opla', 12300, '123123123', 'Warszawa',
+                 'Opel', 'Astra', 2005, 150000, 90)
+
+print(ogloszenie)
+
+# dzięki temu, że klasa wyrzuca wyjątek w przypadku problemów, to autor programu
+# może sam zdecydować co zrobić w przypadku wyjątku
+try:
+    zmiana = int(input('O ile chcesz zmienić cenę? '))
+    ogloszenie.zmienCene(zmiana)
+except Exception as e:
+    print('Nie da się zmienić ceny, bo', e)
+
+print(ogloszenie)

domowe/t2/pan_tadeusz/odmiana.py

+# Uwaga, plik PoliMorf trzeba sobie pobrać samemu
+
+class Odmiana:
+    def __init__(self, lowercase=False):
+        # słowniki zawierają wpisy postaci 'Tadeusz': {'Tadeusza', 'Tadeuszowi', ...}
+        # dla formy podstawowej pamięta odmiany
+        self._odmiany = {}
+        # dla słowa odmienionego pamięta formy podstawowe
+        # 'Tadeuszowi': '{'Tadeusz'}, 'dam': {'dać', 'dama'}
+        self._podstawowe = {}
+        self._lowercase = lowercase
+
+    def dodaj_wpis(self, podstawa, odmiana):
+        if self._lowercase:
+            podstawa = podstawa.lower()
+            odmiana = odmiana.lower()
+        if podstawa in self._odmiany:
+            self._odmiany[podstawa].add(odmiana)
+        else:
+            self._odmiany[podstawa] = {odmiana}
+        if odmiana in self._podstawowe:
+            self._podstawowe[odmiana].add(podstawa)
+        else:
+            self._podstawowe[odmiana] = {podstawa}
+
+    def znajdzOdmiany(self, slowo):
+        if self._lowercase:
+            slowo = slowo.lower()
+        try:
+            return self._odmiany[slowo]
+        except KeyError:
+            return set()
+
+    def znajdzFormyPodstawowe(self, slowo):
+        if self._lowercase:
+            slowo = slowo.lower()
+        try:
+            return self._podstawowe[slowo]
+        except KeyError:
+            return set()
+
+    def pierwszaFormaPodstawowa(self, slowo):
+        '''Zwraca pierwszą formę podstawową dla danego słowa odmienionego.
+        Jeśli słowo jest nieznane, to wynikiem jest to samo słowo.'''
+        for podstawa in self.znajdzFormyPodstawowe(slowo):
+            return podstawa
+        else:
+            return slowo
+
+    @staticmethod
+    def wczytaj(sciezka="PoliMorf-0.6.7.tab", lowercase=False):
+        baza = Odmiana(lowercase)
+        with open(sciezka, encoding='utf-8') as plik:
+            for linia in plik:
+                t = linia.split()
+                baza.dodaj_wpis(t[1], t[0])
+        return baza

domowe/t2/pan_tadeusz/policz_slowa0.py

+print('Startujemy...')
+
+licznik = 0
+
+with open('pan-tadeusz.txt', encoding='utf-8') as plik:
+    for linia in plik:
+        slowa = linia.strip().split()
+        for slowo in slowa:
+           print('[' + slowo + ']')
+           licznik += 1
+
+print('Wszystkich słów:', licznik)

domowe/t2/pan_tadeusz/policz_slowa1.py

+import re
+
+print('Startujemy...')
+
+licznik = 0
+
+with open('pan-tadeusz.txt', encoding='utf-8') as plik:
+    for linia in plik:
+        slowa = re.findall(r'\w+', linia)
+        for slowo in slowa:
+           print('[' + slowo + ']')
+           licznik += 1
+
+print('Wszystkich słów:', licznik)

domowe/t2/pan_tadeusz/policz_slowa2.py

+import re
+
+print('Startujemy...')
+
+slownik = {}
+licznik = 0
+
+with open('pan-tadeusz.txt', encoding='utf-8') as plik:
+    for linia in plik:
+        slowa = re.findall(r'\w+', linia)
+        for slowo in slowa:
+            licznik += 1
+            if slowo in slownik:
+                slownik[slowo] += 1
+            else:
+                slownik[slowo] = 1
+
+print('Wszystkich słów:', licznik)
+for slowo, liczba in slownik.items():
+    print(f'{slowo:15} → {liczba:5}')

domowe/t2/pan_tadeusz/policz_slowa3.py

+import re
+
+print('Startujemy...')
+
+slownik = {}
+licznik = 0
+
+pattern = re.compile(r'\w+')
+
+with open('pan-tadeusz.txt', encoding='utf-8') as plik:
+    for linia in plik:
+        for slowo in pattern.findall(linia):
+            licznik += 1
+            if slowo in slownik:
+                slownik[slowo] += 1
+            else:
+                slownik[slowo] = 1
+
+print('Wszystkich słów:', licznik)
+for slowo, liczba in slownik.items():
+    print(f'{slowo:15} → {liczba:5}')

domowe/t2/pan_tadeusz/policz_slowa3a.py

+import re
+
+print('Startujemy...')
+
+slownik = {}
+licznik = 0
+
+pattern = re.compile(r'\w+')
+
+with open('pan-tadeusz.txt', encoding='utf-8') as plik:
+    for linia in plik:
+        for match in pattern.finditer(linia):
+            slowo = match.group(0)
+            licznik += 1
+            if slowo in slownik:
+                slownik[slowo] += 1
+            else:
+                slownik[slowo] = 1
+
+print('Wszystkich słów:', licznik)
+for slowo, liczba in slownik.items():
+    print(f'{slowo:15} → {liczba:5}')

domowe/t2/pan_tadeusz/policz_slowa4.py

+import re
+
+print('Startujemy...')
+slownik = {}
+licznik = 0
+pattern = re.compile(r'\w+')
+
+with open('pan-tadeusz.txt', encoding='utf-8') as plik:
+    for linia in plik:
+        for slowo in pattern.findall(linia):
+            licznik += 1
+            if slowo in slownik:
+                slownik[slowo] += 1
+            else:
+                slownik[slowo] = 1
+
+slownik = dict(sorted(slownik.items(), key=lambda para: para[1], reverse=True))
+
+print('Wszystkich słów:', licznik)
+for slowo, liczba in slownik.items():
+    print(f'{slowo:15} → {liczba:5}')

domowe/t2/pan_tadeusz/policz_slowa5.py

+import re
+
+from odmiana import Odmiana
+
+print('Budujemy bazę odmian...')
+baza = Odmiana.wczytaj('PoliMorf-0.6.7.tab', lowercase=True)
+
+print('Czytam Pana Tadeusza...')
+slownik = {}
+licznik = 0
+pattern = re.compile(r'\w+')
+
+with open('pan-tadeusz.txt', encoding='utf-8') as plik:
+    for linia in plik:
+        for slowo in pattern.findall(linia):
+            slowo = slowo.lower()
+            licznik += 1
+            slowo = baza.pierwszaFormaPodstawowa(slowo)
+            if slowo in slownik:
+                slownik[slowo] += 1
+            else:
+                slownik[slowo] = 1
+
+slownik = dict(sorted(slownik.items(), key=lambda para: para[1], reverse=True))
+
+print('Wszystkich słów:', licznik)
+print('Po sprowadzeniu do podstawowych:', len(slownik))
+for slowo, liczba in slownik.items():
+    print(f'{slowo:15} → {liczba:5}')

domowe/t2/pan_tadeusz/sprawdzenie_odmian.py

+from odmiana import Odmiana
+
+print('Startujemy')
+baza = Odmiana.wczytaj('PoliMorf-0.6.7.tab')
+print('Baza odmian odmian wczytana')
+
+a = baza.znajdzOdmiany('Tadeusz')
+print(a)
+
+b = baza.znajdzFormyPodstawowe('damy')
+print(b)