Matura Rozszerzona Informatyka 2026 Maj
Rozwiązania krok po kroku

Algorytm w każdym wywołaniu rekurencyjnym wykonuje dwie kluczowe operacje na argumentach:

Rekurencja kończy się, gdy $n$ osiągnie wartość 1. Oznacza to, że liczba wywołań rekurencyjnych jest ściśle powiązana z tym, ile razy możemy podzielić $n$ przez 2, zanim otrzymamy 1. Matematycznie odpowiada to wartości $\lfloor \log_2 n \rfloor$.

Mamy $m = 2^5$ (czyli 32) oraz $n = 2^5$ (czyli 32). Śledzimy kolejne wywołania:

Zatem liczba wywołań wynosi 5.

Mamy $m = 10$ oraz $n = 15$ (liczba nieparzysta). Śledzimy kolejne wywołania (pamiętając o podwajaniu $m$ i połowieniu $n$ w dół):

Zatem liczba wywołań wynosi 3.

W ostatnim wierszu mamy $n = 2^{100} + 1$. Zgodnie z poleceniem, interesuje nas tylko liczba wywołań. Zapisując tę liczbę w systemie binarnym, otrzymalibyśmy jedynkę, za nią 99 zer, a na końcu kolejną jedynkę (łącznie 101 bitów).

Liczba wywołań to po prostu liczba dzieleń całkowitych przez 2 potrzebnych do zredukowania liczby do 1. Dla $n = 2^{100} + 1$ wynosi to dokładnie 100.

Jeśli przeanalizujemy wyniki z zadania 1.1., łatwo dostrzec, że zdefiniowana funkcja jest algorytmem wykonującym w sposób rekurencyjny mnożenie dwóch liczb naturalnych. Zatem zawsze prawdziwa jest równość:

Korzystając z odkrytego wzoru, po prostu wymnażamy argumenty:

Rozpatrujemy pierwszy przypadek, w którym wartość $n$ jest potęgą dwójki. Z poprzednich zadań wiemy, że funkcja w każdym wywołaniu rekurencyjnym dzieli $n$ przez 2.

Drugi przypadek wydaje się trudniejszy, ale staje się bardzo prosty, gdy pomyślimy o systemie binarnym. Liczba postaci $2^k - 1$ to w zapisie dwójkowym ciąg składający się z dokładnie $k$ jedynek (np. $2^3 - 1 = 7 = 111_2$).

Symulujemy działanie algorytmu dodawania pisemnego (od prawej do lewej), sprawdzając na każdym kroku, czy suma cyfr oraz ewentualnego przeniesienia z poprzedniej pozycji przekracza 9.

Wszystkie sumy częściowe są cyframi jednocyfrowymi.

Liczba przeniesień wynosi 0.

Ponownie symulujemy dodawanie od prawej strony, pamiętając o uwzględnianiu przeniesienia w kolejnych rzędach:

Zliczając wystąpienia "jedynki dalej", otrzymujemy dokładnie 3 takie sytuacje.

Liczba przeniesień wynosi 3.

Z powodu restrykcyjnych ograniczeń (zakaz używania tablic i stringów), musimy symulować dodawanie pisemne, operując wyłącznie na matematyce. Aby "odciąć" ostatnią cyfrę z liczby, użyjemy operacji reszty z dzielenia przez 10 (często zapisywanej jako mod lub %). Z kolei aby usunąć przetworzoną cyfrę z liczby i przesunąć się w lewo, użyjemy dzielenia całkowitego przez 10 (div lub //).

W każdej iteracji algorytmu:

Proces powtarzamy, dopóki liczby są większe od zera.

Poniżej znajduje się czytelny zapis algorytmiczny, który w pełni spełnia wszystkie wymagania maturalne:

Poniżej ten sam algorytm zapisany w postaci funkcji w języku Python:

def policz_przeniesienia(a, b):
    p = 0
    przeniesienie = 0
    
    while a > 0:
        cyfra_a = a % 10
        cyfra_b = b % 10
        
        suma = cyfra_a + cyfra_b + przeniesienie
        
        if suma >= 10:<p
            przeniesienie = 1
            p += 1
        else:
            przeniesienie = 0
            
        a = a // 10
        b = b // 10
        
    return p

Rozwiązanie tego zadania sprowadza się do wczytania pliku linia po linii, rozdzielenia każdego wiersza na dwa słowa (oddzielone spacją) i policzenia dla nich wartości funkcji $f(s)$.

Poniżej znajduje się gotowy skrypt rozwiązujący zadanie 3.1:

def zadanie_3_1():
    max_diff = -1
    best_pair = ("", "")

    with open("pary.txt", "r") as file:
        for line in file:
            # Rozdzielenie wiersza na dwa słowa
            s1, s2 = line.strip().split()
            
            # Obliczenie sum kodów ASCII dla obu słów
            sum1 = sum(ord(char) for char in s1)
            sum2 = sum(ord(char) for char in s2)
            
            # Wartość bezwzględna różnicy
            diff = abs(sum1 - sum2)
            
            # Aktualizacja maksimum
            if diff > max_diff:
                max_diff = diff
                best_pair = (s1, s2)
                
    print(f"3.1: {best_pair[0]} {best_pair[1]} {max_diff}")

zadanie_3_1()

W tym zadaniu dla każdej pary słów musimy sprawdzić, ile razy dane litery powtarzają się w obu słowach.

Poniżej znajduje się gotowy skrypt rozwiązujący zadanie 3.2:

def zadanie_3_2():
    max_shared_sum = -1
    best_pair = ("", "")

    with open("pary.txt", "r") as file:
        for line in file:
            s1, s2 = line.strip().split()
            
            shared_sum = 0
            # Tworzymy zbiór unikalnych liter z pierwszego słowa
            unique_chars = set(s1)
            
            for char in unique_chars:
                count1 = s1.count(char)
                count2 = s2.count(char)
                
                # Dodajemy mniejszą liczbę wystąpień (część wspólną)
                shared_sum += min(count1, count2)
                
            # Aktualizacja maksimum
            if shared_sum > max_shared_sum:
                max_shared_sum = shared_sum
                best_pair = (s1, s2)
                
    print(f"3.2: {best_pair[0]} {best_pair[1]} {max_shared_sum}")

zadanie_3_2()

Zadanie wymaga zbadania dwóch niezależnych przypadków dla każdej pary słów $s_1$ i $s_2$:

Najwygodniejszym podejściem jest napisanie funkcji pomocniczej, która sprawdza narastająco długości potencjalnych dopasowań $l$ od 1 do maksymalnej możliwej długości (czyli długości krótszego ze słów). Wykorzystujemy technikę wycinania napisów (slicing) w Pythonie: s1[:l] da nam prefiks, a s2[-l:] da nam sufiks.

Poniższy program przetwarza cały plik wejściowy, filtruje pary według kryterium długości $\ge 5$ i wypisuje sformatowany wynik:

def podaj_najdluzszy_prefiksosufiks(s1, s2):
    max_dlugosc = 0
    max_mozliwa = min(len(s1), len(s2))
    
    # Przypadek 1: prefiks s1 i sufiks s2
    for l in range(1, max_mozliwa + 1):
        if s1[:l] == s2[-l:]:
            if l > max_dlugosc:
                max_dlugosc = l
                
    # Przypadek 2: prefiks s2 i sufiks s1
    for l in range(1, max_mozliwa + 1):
        if s2[:l] == s1[-l:]:
            if l > max_dlugosc:
                max_dlugosc = l
                
    return max_dlugosc

def zadanie_3_3():
    with open("pary.txt", "r") as file:
        for line in file:
            s1, s2 = line.strip().split()
            
            dlugosc = podaj_najdluzszy_prefiksosufiks(s1, s2)
            
            # Filtrujemy zgodnie z treścią zadania (minimum 5 liter)
            if dlugosc >= 5:
                print(f"{s1} {s2} {dlugosc}")

zadanie_3_3()

Przedstawiona hierarchia jest klasycznym drzewem skierowanym, w którym prezes (pracownik 1) stanowi korzeń.

Przeanalizujmy sytuację dla osób posiadających podwładnych na podstawie schematu graficznego:

Węzły, od których nie odchodzą w dół żadne inne strzałki, to tzw. liście. Nie posiadają one żadnych podwładnych.

Każda linia w pliku (oprócz pierwszej, która zawiera 0) reprezentuje numer bezpośredniego przełożonego dla kolejnych pracowników. Jeśli dany numer pracownika ani razu nie pojawia się w pliku jako przełożony, oznacza to, że ta osoba nie ma żadnych bezpośrednich podwładnych (jest tzw. "liściem" w strukturze drzewa).

Algorytm polega na wczytaniu wszystkich numerów przełożonych, zapisaniu ich do zbioru unikalnych wartości (ang. set), a następnie odjęciu liczby unikalnych przełożonych od całkowitej liczby pracowników wynoszącej 50 000. Pamiętamy o pominięciu wartości 0, która oznacza brak przełożonego.

Poniższy skrypt wczytuje dane i oblicza liczbę osób bez podwładnych:

def zadanie_4_2():
    bosses = set()
    
    with open("korpo.txt", "r") as file:
        for line in file:
            boss = int(line.strip())
            if boss != 0:
                bosses.add(boss)
            
            # Łączna liczba pracowników to 50 000
            pracownicy_bez_podwladnych = 50000 - len(bosses)
            print(f"4.2: {pracownicy_bez_podwladnych}")

zadanie_4_2()

Liczba bezpośrednich podwładnych danego pracownika jest dokładnie równa liczbie wystąpień jego numeru w pliku korpo.txt.

Naszym zadaniem jest zliczenie, ile razy każdy numer przełożonego pojawia się w pliku, a następnie znalezienie tego, który pojawia się najczęściej. Do realizacji tego zadania idealnie sprawdzi się słownik (często nazywany mapą lub tablicą asocjacyjną) w którym kluczem jest numer pracownika, a wartością liczba jego podwładnych.

Poniższy skrypt zlicza wystąpienia każdego przełożonego i wyznacza lidera z największą liczbą bezpośrednich podwładnych:

def zadanie_4_3():
    # Słownik do zliczania podwładnych dla każdego bossa
    podwladni_count = {}
    
    with open("korpo.txt", "r") as file:
        for line in file:
            boss = int(line.strip())
            if boss != 0:
                podwladni_count[boss] = podwladni_count.get(boss, 0) + 1
    
    # Znalezienie bossa z maksymalną liczbą podwładnych
    najwiekszy_boss = max(podwladni_count, key=podwladni_count.get)
    liczba_podwladnych = podwladni_count[najwiekszy_boss]
    
    print(f"4.3: {najwiekszy_boss} {liczba_podwladnych}")

zadanie_4_3()

Liczba wszystkich przełożonych danego pracownika to po prostu liczba kroków, jakie musimy wykonać, idąc od niego w górę hierarchii aż do samego prezesa (pracownika numer 1). W strukturach drzewiastych odpowiada to głębokości (poziomowi) danego węzła w drzewie.

Kluczowa informacja z treści całego zadania mówi, że numer bezpośredniego przełożonego pracownika jest zawsze mniejszy od numeru samego pracownika. To potężne ułatwienie! Oznacza to, że przetwarzając pracowników po kolei od numeru 1 do 50 000, w momencie analizowania pracownika $i$ znamy już dokładną liczbę przełożonych jego szefa.

Możemy zastosować proste podejście dynamiczne:

Poniższy program wczytuje plik, wyznacza tablicę głębokości dla każdego pracownika, a następnie zlicza wystąpienia maksymalnej wartości:

def zadanie_4_4():
    # Tablica przechowująca liczbę przełożonych dla każdego pracownika.
    # Indeks odpowiada numerowi pracownika. Pracowników jest 50 000 (indeksy 1-50000).
    # Tworzymy tablicę o rozmiarze 50001, wypełnioną zerami.
    liczba_przelozonych = [0] * 50001
    
    # Pracownik 1 (Prezes) ma 0 przełożonych, co już jest ustawione.
    
    current_worker = 2
    with open("korpo.txt", "r") as file:
        # Pomijamy pierwszą linię (zawierającą 0 dla prezesa)
        next(file)
        
        for line in file:
            direct_boss = int(line.strip())
            
            # Liczba przełożonych aktualnego pracownika to liczba przełożonych 
            # jego szefa powiększona o 1
            liczba_przelozonych[current_worker] = liczba_przelozonych[direct_boss] + 1
            current_worker += 1
    
    # Ignorujemy indeks 0, interesują nas tylko pracownicy 1-50000
    dane_pracownikow = liczba_przelozonych[1:50001]
    
    # Wyznaczamy maksymalną liczbę przełożonych
    max_przelozonych = max(dane_pracownikow)
    
    # Zliczamy, ilu pracowników osiągnęło ten maksymalny wynik
    liczba_pracownikow_z_max = dane_pracownikow.count(max_przelozonych)
    
    print(f"4.4: {max_przelozonych} {liczba_pracownikow_z_max}")

zadanie_4_4()

Zajmijmy się pierwszą równością: $1440_5 + X_5 = 427_{10}$. Na początku zamieńmy liczbę $1440_5$ na system dziesiętny:

Teraz możemy obliczyć wartość $X$ w systemie dziesiętnym:

Na koniec zamieniamy wynik $182_{10}$ na system piątkowy poprzez cykliczne dzielenie z resztą przez 5:

Czytając reszty od dołu, otrzymujemy pierwszą szukaną wartość: 1212₅.

Przejdźmy do drugiej równości: $427_{10} = Y_3 - 110002_3$. Najpierw przekształćmy odjemnik $110002_3$ na system dziesiętny:

Wyznaczamy wartość $Y$ w układzie dziesiętnym:

Zamieniamy liczbę $753_{10}$ na system trójkowy, dzieląc przez 3:

Czytając reszty od dołu, otrzymujemy drugą wartość: 1000220₃.

Prawidłowo uzupełnione wyrażenie ma postać:

Zadanie weryfikuje znajomość podstawowych protokołów sieciowych warstwy sieciowej:

Na podstawie wczytanych danych obliczamy średnie arytmetyczne temperatur dla każdego miesiąca. W programie Excel uzyskamy to błyskawicznie tworząc Tabelę Przestawną:

Oto wygenerowany wykres kolumnowy naśladujący standardowy wygląd z arkusza kalkulacyjnego Excel, uwzględniający wszystkie wymagane opisy osi i tytuł.

Problem polega na znalezieniu najdłuższego pasma dni, w których wartość w kolumnie Opady wynosi dokładnie $0$, z zastrzeżeniem, że analizujemy każdy miesiąc osobno.

Przechodząc przez kolejne dni danego miesiąca:

Poniższy program przetwarza dane dzień po dniu, samodzielnie pilnując granic miesięcy i resetując liczniki serii przy zmianie miesiąca:

def zadanie_7_2():
    # Słownik na maksymalne ciągi bez opadów dla każdego miesiąca
    max_streaks = {f"{i:02d}": 0 for i in range(1, 12 + 1)}
    
    current_month = "01"
    current_streak = 0
    
    with open("staw.txt", "r") as file:
        next(file) # pominięcie nagłówka
        for line in file:
            parts = line.strip().split("\t")
            if len(parts) < 3:
                continue
            data, _, opady_str = parts
            
            month = data.split("-")[1]
            opady = int(opady_str)
            
            # Jeśli zmienił się miesiąc, domykamy serię starego miesiąca i resetujemy
            if month != current_month:
                if current_streak > max_streaks[current_month]:
                    max_streaks[current_month] = current_streak
                current_month = month
                current_streak = 0
            
            # Sprawdzamy warunek braku opadów
            if opady == 0:
                current_streak += 1
            else:
                if current_streak > max_streaks[month]:
                    max_streaks[month] = current_streak
                current_streak = 0
                
        # Ostateczne sprawdzenie dla ostatniego wiersza w pliku (grudzień)
        if current_streak > max_streaks[current_month]:
            max_streaks[current_month] = current_streak

    print("Zadanie 7.2 - Najdłuższe ciągi bez opadów:")
    for m, streak in max_streaks.items():
        print(f"Miesiąc {m}: {streak} dni")

zadanie_7_2()

Poniżej znajduje się zestawienie wyników dla poszczególnych miesięcy:

Aby rozwiązać to zadanie w programie Excel lub LibreOffice Calc, tworzymy tabelę o następującej strukturze kolumn dla każdego ze 184 dni:

Szukamy pierwszego wiersza, w którym wartość w kolumnie Stan rano przekroczy 75% całkowitej powierzchni stawu, czyli:

Przeciągając formuły w dół, zauważymy, że wartość ta zostaje przekroczona w 167. dniu symulacji. Odpowiada to dokładnie dacie 14 sierpnia 2023 roku.

Odpowiedź: Rzęsa przekroczy 75% powierzchni w 167. dniu (14 sierpnia).

Chcemy, aby w żadnym ze 184 dni wartość w kolumnie Stan rano nie przekroczyła 50% powierzchni stawu, czyli 5000 m².

W arkuszu kalkulacyjnym możemy użyć narzędzia Szukaj wyniku (Goal Seek) lub po prostu stworzyć komórkę z parametrem liczby amurów i zmieniać jej wartość, obserwując maksymalną wartość z kolumny porannych pomiarów wyznaczoną formułą =MAKS(C2:C185).

Poniższy prosty kod pozwala precyzyjnie sprawdzić zachowanie ekosystemu dla różnych liczb ryb i znaleźć szukaną wartość graniczną:

def sprawdz_amury():
    # Sprawdzamy kolejne liczby ryb
    for liczba_amurów in range(80, 200):
        powierzchnia = 2000.0
        max_w_roku = powierzchnia
        
        # 1 marca 2023 to środa (w systemie Excela dzień tygodnia = 3)
        # Zatem piątek przypada na dzień o numerze 3, 10, 17 itd.
        for dzien in range(1, 185):
            if powierzchnia > max_w_roku:
                max_w_roku = powierzchnia
                
            # Działania w ciągu dnia
            powierzchnia -= (liczba_amurów * 0.25)
            if (dzien - 3) % 7 == 0:
                powierzchnia -= 60.0
                
            if powierzchnia < 0:
                powierzchnia = 0.0
                
            # Wzrost w nocy
            powierzchnia *= 1.0175
            
        # Szukamy pierwszej liczby ryb, dla której maks nie przekroczył 5000 m²
        if max_w_roku <= 5000.0:
            return liczba_amurów, max_w_roku

ryby, max_pow = sprawdz_amury()
print(f"Wynik: {ryby} amurów, maksymalna powierzchnia: {max_pow:.2f} m²")

Uruchomienie algorytmu wskazuje, że dla 93 amurów powierzchnia minimalnie przekracza próg, natomiast dla 94 amurów maksymalny stan rano wynosi około 4916,74 m².

Odpowiedź: Najmniejsza potrzebna liczba amurów białych to 94.

Każdy wiersz w pliku transakcje.txt reprezentuje jedną unikalną transakcję dokonaną przez konkretnego klienta identyfikowanego przez IdKlienta. Aby znaleźć klienta z największą liczbą transakcji, musimy zliczyć wystąpienia każdego IdKlienta w tabeli transakcji, wybrać identyfikator występujący najczęściej, a następnie połączyć go z tabelą klientów w celu wyciągnięcia imienia i nazwiska.

Jeśli importujesz pliki do bazy danych (np. MS Access, MySQL), najszybszą metodą jest wykonanie zapytania z grupowaniem (GROUP BY), zliczaniem (COUNT) oraz sortowaniem malejącym z limitem do pierwszego rekordu:

SELECT TOP 1 k.Imie, k.Nazwisko, COUNT(t.IdTransakcji) AS LiczbaTransakcji
FROM klienci k 
JOIN transakcje t ON k.IdKlienta = t.IdKlienta
GROUP BY k.IdKlienta, k.Imie, k.Nazwisko
ORDER BY COUNT(t.IdTransakcji) DESC;

Zadanie można też łatwo rozwiązać skryptem przy użyciu wbudowanej klasy Counter do zliczania identyfikatorów:

from collections import Counter

def zadanie_8_1():
    # Zliczamy ile razy dany IdKlienta pojawia się w transakcjach
    with open("transakcje.txt", "r") as f:
        next(f) # pomijamy nagłówek
        id_klientow = [line.split("\t")[2] for line in f]
    
    licznik = Counter(id_klientow)
    najczestszy_id, _ = licznik.most_common(1)[0]
    
    # Szukamy danych tego klienta w pliku klienci.txt
    with open("klienci.txt", "r") as f:
        next(f)
        for line in f:
            id_k, imie, nazwisko, _ = line.strip().split("\t")
            if id_k == najczestszy_id:
                print(f"8.1: {imie} {nazwisko}")
                break

zadanie_8_1()

Klient, który "nie kupił niczego", to taka osoba, której unikalny identyfikator IdKlienta zapisany w pliku klienci.txt ani razu nie pojawił się w pliku zawierającym rejestr zakupów transakcje.txt. Naszym celem jest wyodrębnienie tych brakujących identyfikatorów, a następnie zliczenie ich z podziałem na płeć (kolumna Plec).

W relacyjnych bazach danych odnajdywanie rekordów, które nie mają powiązań w drugiej tabeli, realizuje się najwygodniej za pomocą podzapytania z operatorem NOT IN lub poprzez LEFT JOIN z warunkiem sprawdzającym wartość IS NULL:

SELECT Plec, COUNT(*) AS IluKlientow
FROM klienci
WHERE IdKlienta NOT IN (SELECT IdKlienta FROM transakcje)
GROUP BY Plec;

Zapytanie zwróci dwa wiersze: liczbę kobiet (K) oraz liczbę mężczyzn (M), którzy nie dokonali żadnych zakupów.

W Pythonie idealnie sprawdzi się struktura zbioru (set), która pozwala na błyskawiczne wykonywanie operacji na członkostwie elementów:

def zadanie_8_2():
    # Pobieramy ID wszystkich klientów, którzy dokonali przynajmniej jednej transakcji
    Klienci_z_transakcjami = set()
    with open("transakcje.txt", "r") as f:
        next(f)
        for line in f:
            Klienci_z_transakcjami.add(line.split("\t")[2])
            
    kobiety_brak = 0
    mezczyzni_brak = 0
    
    # Sprawdzamy każdego zarejestrowanego klienta
    with open("klienci.txt", "r") as f:
        next(f)
        for line in f:
            id_k, _, _, plec = line.strip().split("\t")
            if id_k not in klienci_z_transakcjami:
                if plec == "K":
                    kobiety_brak += 1
                elif plec == "M":
                    mezczyzni_brak += 1
                    
    print(f"8.2 Kobiety (K): {kobiety_brak}")
    print(f"8.2 Mężczyźni (M): {mezczyzni_brak}")

zadanie_8_2()

Z treści głównej zadania wiemy, że jeśli klient korzystał z kasy samoobsługowej, to pole IdSprzedawcy w pliku transakcje.txt pozostało puste (brak danych).

Musimy zatem przefiltrować transakcje, wybierając tylko te z pustym identyfikatorem sprzedawcy, zliczyć unikalne wartości z kolumny IdSklepu, a następnie zsumować wartość wszystkich zakupów (Cena * Liczba) przypisanych do tych konkretnych numerów transakcji w pliku opis_transakcji.txt.

W bazie danych łączymy obie tabele relacją i filtrujemy po pustej wartości sprzedawcy (IS NULL):

SELECT COUNT(DISTINCT t.IdSklepu) AS LiczbaSklepow, 
       SUM(o.Cena * o.Liczba) AS LacznaSuma
FROM transakcje t
JOIN opis_transakcji o ON t.IdTransakcji = o.IdTransakcji
WHERE t.IdSprzedawcy IS NULL;

def zadanie_8_3():
    samoobslugowe_transakcje = set()
    sklepy = set()
    
    with open("transakcje.txt", "r") as f:
        next(f)
        for line in f:
            parts = line.strip().split("\t")
            # Jeśli wiersz nie ma kolumny sprzedawcy lub jest ona pusta
            if len(parts) < 5 or parts[4] == "":
                samoobslugowe_transakcje.add(parts[0]) # IdTransakcji
                sklepy.add(parts[3]) # IdSklepu
                
    laczna_kwota = 0.0
    with open("opis_transakcji.txt", "r") as f:
        next(f)
        for line in f:
            id_t, _, cena_str, liczba_str = line.strip().split("\t")
            if id_t in samoobslugowe_transakcje:
                cena = float(cena_str.replace(",", "."))
                liczba = int(liczba_str)
                laczna_kwota += cena * liczba
                
    print(f"8.3 Liczba sklepów: {len(sklepy)}, Łączna kwota: {laczna_kwota:.2f}")

W tym zadaniu kluczem jest unikalne połączenie sprzedawcy, miesiąca oraz sklepu. Musimy wyciągnąć numer miesiąca z daty transakcji (format dd.mm.rrrr, czyli interesują nas znaki na pozycjach od 4 do 5). Następnie dla każdej pary (IdSprzedawcy, Miesiac) wyznaczamy liczbę różnych (unikalnych) wartości IdSklepu i szukamy pary, która osiągnęła najwyższy wynik.

W Pythonie najwygodniej użyć słownika, w którym kluczem jest krotka (id_sprzedawcy, miesiac), a wartością zbiór (set) przechowujący unikalne identyfikatory sklepów:

def zadanie_8_4():
    # Klucz: (IdSprzedawcy, Miesiac) -> Wartość: set(IdSklepu)
    rejestr = {}
    
    with open("transakcje.txt", "r") as f:
        next(f)
        for line in f:
            parts = line.strip().split("\t")
            if len(parts) < 5 or parts[4] == "":
                continue # pomijamy kasy samoobsługowe
                
            id_sprzedawcy = parts[4]
            data = parts[1] # dd.mm.rrrr
            id_sklepu = parts[3]
            
            miesiac = data.split(".")[1]
            klucz = (id_sprzedawcy, miesiac)
            
            if klucz not in rejestr:
                rejestr[klucz] = set()
            rejestr[klucz].add(id_sklepu)
            
    # Szukanie pary z największą liczbą unikalnych sklepów
    max_sklepow = 0
    najlepszy_wynik = None
    
    for klucz, sklepy in rejestr.items():
        if len(sklepy) > max_sklepow:
            max_sklepow = len(sklepy)
            najlepszy_wynik = klucz
            
    print(f"8.4 Sprzedawca: {najlepszy_wynik[0]}, Miesiąc: {najlepszy_wynik[1]}")

Aby zapytanie było poprawne i wyświetliło wyłącznie zakupione produkty, musimy uwzględnić tabelę łączącą, czyli opis_transakcji. Wykorzystamy złączenia typu INNER JOIN do powiązania tabel po kluczach obcych.

Filtrowanie opisu zrealizujemy za pomocą operatora LIKE z użyciem znaków wieloznacznych % z obu stron szukanej frazy. Aby dany produkt nie wyświetlał się wielokrotnie (jeśli został zakupiony w wielu transakcjach), użyjemy klauzuli DISTINCT.

Poniższe zapytanie stanowi pełną, poprawną odpowiedź, którą należy zapisać w arkuszu:

SELECT DISTINCT p.IdProduktu, p.Nazwa
FROM opis_transakcji ot
INNER JOIN Produkty p ON ot.IdProduktu = p.IdProduktu
INNER JOIN Kategorie k ON p.IdKategorii = k.IdKategorii
WHERE k.NazwaKategorii = 'spożywcze'
  AND p.Opis LIKE '%do ekspresu kolbowego%';