Matura Rozszerzona Informatyka 2023 Maj
Rozwiązania krok po kroku

• Przegródka $B[0, 1]$ to korzeń drzewa (ang. root).
• Przejście do $B[i + 1, 2j - 1]$ w przypadku mniejszej wartości to przejście do lewego syna.
• Przejście do $B[i + 1, 2j]$ w przypadku większej wartości to przejście do prawego syna.

• 14: Półka jest pusta. Wstawiamy do korzenia $\rightarrow$ $B[0, 1] = 14$.

• 18: Porównujemy z 14. Jest większe, więc idziemy do prawego dziecka: $i+1=1$, $2j=2$ $\rightarrow$ $B[1, 2] = 18$.

• 12: Porównujemy z 14. Mniejsze, idziemy do lewego dziecka: $i+1=1$, $2j-1=1$ $\rightarrow$ $B[1, 1] = 12$.

• 9: Mniejsze od 14 (idziemy w lewo do $B[1, 1]$). W $B[1, 1]$ jest 12. 9 jest mniejsze od 12, więc idziemy do lewego dziecka: $i+1=2$, $2(1)-1=1$ $\rightarrow$ $B[2, 1] = 9$.

• 20: Większe od 14 (idziemy do $B[1, 2]$). W $B[1, 2]$ jest 18. 20 jest większe od 18, więc w prawo: $i+1=2$, $2(2)=4$ $\rightarrow$ $B[2, 4] = 20$.

• 15: Większe od 14 (do $B[1, 2]$). Mniejsze od 18 (w lewo): $i+1=2$, $2(2)-1=3$ $\rightarrow$ $B[2, 3] = 15$.

• 17: Większe od 14 (do $B[1, 2]$). Mniejsze od 18 (do $B[2, 3]$ gdzie jest 15). Większe od 15 (w prawo z pozycji $j=3$): $i+1=3$, $2(3)=6$ $\rightarrow$ $B[3, 6] = 17$.

• Maksymalna liczba półek: Otrzymujemy ją w najbardziej niekorzystnym przypadku, gdy drzewo jest "liniowe" (każda książka ma tylko jednego syna). Wtedy każda kolejna książka zajmuje nową półkę. Zatem dla $n$ książek mamy $n$ półek.
• Minimalna liczba półek: Otrzymujemy ją, gdy drzewo jest idealnie zbalansowane (każda półka jest zapełniona przed przejściem do kolejnej). Liczba miejsc na $h$ półkach (od 0 do $h-1$) to suma ciągu geometrycznego: $2^0 + 2^1 + ... + 2^{h-1} = 2^h - 1$.

• Zaczynamy od korzenia: 9
• Idziemy w lewo do: 2 (z niego już nie ma dróg w dół, więc się cofamy)
• Wracamy do 9 i idziemy w prawo do: 12
• Z 12 idziemy w lewo do: 10 (brak dalszych dróg, cofamy się do 12)
• Z 12 idziemy w prawo do: 14
• Z 14 idziemy w lewo do: 13 (brak dróg, cofamy się do 14)
• Z 14 idziemy w prawo do: 15

• Zaczynamy od korzenia: 10
• Idziemy w lewo do: 8
• Z 8 w lewo do: 4
• Z 4 w lewo się nie da, więc idziemy w prawo do: 6 (koniec lewej dużej gałęzi, cofamy się aż do korzenia)
• Z 10 idziemy w prawo do: 15
• Z 15 idziemy w lewo do: 12
• Z 12 w lewo się nie da, idziemy w prawo do: 13

• Każda liczba dodatnia ma co najmniej jeden blok. Zaczynamy więc od liczebności bloków $b = 1$.
• Wyciągamy ostatni bit (tzw. najmniej znaczący) i traktujemy go jako "poprzedni bit". Będziemy go porównywać z kolejnymi odczytanymi bitami.
• W pętli dzielimy liczbę przez 2 i odczytujemy następny bit. Jeśli różni się on od naszego "poprzedniego bitu", oznacza to zmianę cyfry (np. z 0 na 1 lub z 1 na 0) – a więc zaczął się nowy blok. Wtedy zwiększamy $b$ o 1.
• Zaktualizowany bit staje się teraz "poprzednim" i pętla toczy się dalej, dopóki $n > 0$.

b <- 1
poprzedni_bit <- n mod 2
n <- n div 2

dopóki n > 0 wykonuj
  aktualny_bit <- n mod 2
  jeżeli aktualny_bit != poprzedni_bit to
      b <- b + 1
  poprzedni_bit <- aktualny_bit
  n <- n div 2

wypisz b

def policz_bloki(n):
  b = 1
  poprzedni_bit = n % 2
  n = n // 2
  
  while n > 0:
      aktualny_bit = n % 2
      if aktualny_bit != poprzedni_bit:
          b += 1
      poprzedni_bit = aktualny_bit
      n = n // 2
      
  return b

def policz_bloki_string(s):
  if not s:
      return 0
  bloki = 1
  for i in range(1, len(s)):
      if s[i] != s[i-1]:
          bloki += 1
  return bloki

def solve_2_2():
  licznik = 0
  with open('bin.txt', 'r') as f:
      for line in f:
          linia = line.strip()
          if policz_bloki_string(linia) <= 2:
              licznik += 1
              
  print(f"2.2. Odpowiedź: {licznik}")

solve_2_2()

def solve_2_3():
  with open('bin.txt', 'r') as f:
      linie = [line.strip() for line in f.readlines()]
      
  # Funkcja max pozwala na użycie 'key' do wyznaczenia, jak oceniać wielkość elementu.
  # Używamy int(x, 2) do przekonwertowania ciągu binarnego na dziesiętny do celów porównania.
  najwieksza = max(linie, key=lambda x: int(x, 2))
  
  print(f"2.3. Odpowiedź: {najwieksza}")

solve_2_3()

• Pierwsza liczba: $123_{10}$
• Druga liczba (binarna): $101101_2 = 1 \cdot 32 + 0 \cdot 16 + 1 \cdot 8 + 1 \cdot 4 + 0 \cdot 2 + 1 \cdot 1 = 32 + 8 + 4 + 1 = 45_{10}$
• Trzecia liczba (szesnastkowa): $2\text{D}_{16} = 2 \cdot 16 + 13 = 32 + 13 = 45_{10}$

1. $123_{10}$ na system binarny to $1111011_2$.

2. $101101_2$ wyrównujemy zerami z lewej do 7 bitów: $0101101_2$.

3. Wykonujemy $123_{10} \text{ XOR } 101101_2$:

     1111011 (123)
   ^ 0101101 (45)
   ---------
   1010110 (86)

4. $2\text{D}_{16}$ zamieniamy na system binarny ($2 = 0010$, $ext{D} = 1101$): $00101101_2$.

5. Wykonujemy drugi XOR (wynik z kroku 3 i liczba z kroku 4):

     1010110 (86)
   ^ 0101101 (45)
   ---------
   1111011 (123)

6. Wynik $1111011_2$ zamieniamy z powrotem na dziesiętny: $64+32+16+8+2+1 = 123_{10}$.

• Wczytujemy liczbę jako ciąg znaków (np. z pliku).
• Konwertujemy ją na typ całkowity, podając podstawę 2: int(p, 2).
• Wykonujemy operację bitowego XOR (w Pythonie jest to znak ^) na tej liczbie oraz jej połowie (p // 2).
• Formatujemy wynik z powrotem do postaci binarnej za pomocą funkcji bin() i usuwamy z niego techniczny przedrostek 0b.

def solve_2_5():
  # Otwieramy strumienie odczytu i zapisu jednocześnie
  with open('bin.txt', 'r') as file_in, open('wyniki2_5.txt', 'w') as file_out:
      for line in file_in:
          p_str = line.strip()
          if not p_str:
              continue
              
          # 1. Konwersja z systemu binarnego (string) na dziesiętny (int)
          p = int(p_str, 2)
          
          # 2. Wykonanie wymaganej operacji bitowej i arytmetycznej
          wynik_dziesietny = p ^ (p // 2)
          
          # 3. Konwersja z powrotem na system binarny
          # Funkcja bin() zwraca string w formacie '0b101...', 
          # więc odcinamy znaki '0b' ucinając pierwsze dwa znaki [2:]
          wynik_binarny = bin(wynik_dziesietny)[2:]
          
          # Zapis do pliku wynikowego z dodaniem znaku nowej linii
          file_out.write(wynik_binarny + "\n")

solve_2_5()

• Najprościej wczytać wszystkie wiersze z pliku do jednej tablicy/listy. Pamiętamy o usunięciu białych znaków (np. znaków nowej linii) za pomocą strip().
• Następnie tworzymy pętlę, która przechodzi od pierwszego elementu (indeks 0) do przedostatniego (indeks $n-2$), aby nie wyjść poza zakres tablicy podczas odwoływania się do elementu $i+1$.
• Liczbę 2-cyfrową możemy stworzyć poprzez konkatenację (łączenie) stringów: cyfra1 + cyfra2 i rzutowanie wyniku na int (int()), albo matematycznie: cyfra1 * 10 + cyfra2 (jeśli operujemy już na liczbach).
• Sprawdzamy warunek > 90 i jeśli jest spełniony, zwiększamy nasz licznik.

def solve_3_1():
  # 1. Wczytanie danych do listy, z oczyszczeniem ze znaków nowej linii
  with open('pi.txt', 'r') as f:
      cyfry = [line.strip() for line in f.readlines() if line.strip()]

  licznik = 0
  
  # 2. Iteracja do przedostatniego elementu
  for i in range(len(cyfry) - 1):
      # Konkatenacja stringów (np. "9" + "2" = "92")
      fragment_str = cyfry[i] + cyfry[i+1]
      
      # Rzutowanie na int i sprawdzenie warunku
      if int(fragment_str) > 90:
          licznik += 1

  print(f"3.1. Odpowiedź: {licznik}")

solve_3_1()

• Najlepiej przygotować słownik (lub listę 100-elementową wyzerowaną na starcie), gdzie kluczem będzie nasz fragment (np. "05"), a wartością liczba jego wystąpień. Koniecznie generujemy bazę wszystkich stu fragmentów, ponieważ niektóre mogą w ogóle nie wystąpić w pliku (ich liczba wystąpień to 0).

• Ponownie przechodzimy pętlą po wczytanych cyfrach i sklejamy je parami, zwiększając odpowiedni licznik w słowniku.

• Kluczowym wymogiem jest: "wypisz ten o mniejszej wartości liczbowej". Aby to zagwarantować, wystarczy przeglądać nasz słownik w kolejności od "00" do "99" i aktualizować zmienne trzymające minimum/maksimum tylko wtedy, gdy znajdziemy wartość ostro mniejszą/większą (używając operatorów < i > zamiast <= czy >=).

def solve_3_2():
  with open('pi.txt', 'r') as f:
      cyfry = [line.strip() for line in f.readlines() if line.strip()]

  # Generujemy wszystkie kombinacje od "00" do "99" i ustawiamy ich licznik na 0
  wystapienia = {}
  for i in range(100):
      # zfill(2) dodaje wiodące zera, np. 5 -> "05"
      wystapienia[str(i).zfill(2)] = 0

  # Zliczamy fragmenty 2-cyfrowe
  for i in range(len(cyfry) - 1):
      fragment = cyfry[i] + cyfry[i+1]
      wystapienia[fragment] += 1

  # Inicjalizujemy min/max skrajnymi wartościami
  min_wystapien = float('inf')
  max_wystapien = -1
  najmniejszy_frag = ""
  najwiekszy_frag = ""

  # Przechodzimy po posortowanych kluczach (od "00" do "99")
  for frag in sorted(wystapienia.keys()):
      ile = wystapienia[frag]
      
      # Ostre < gwarantuje, że przy remisie zostawimy pierwszy 
      # znaleziony fragment (czyli ten o mniejszej wartości)
      if ile < min_wystapien:
          min_wystapien = ile
          najmniejszy_frag = frag
          
      if ile > max_wystapien:
          max_wystapien = ile
          najwiekszy_frag = frag

  print(f"3.2. Minimum: {najmniejszy_frag} {min_wystapien}")
  print(f"3.2. Maksimum: {najwiekszy_frag} {max_wystapien}")

solve_3_2()

def czy_rosnacy(fragment):
  for i in range(len(fragment) - 1):
      if fragment[i] >= fragment[i+1]:
          return False
  return True

def czy_malejacy(fragment):
  for i in range(len(fragment) - 1):
      if fragment[i] <= fragment[i+1]:
          return False
  return True

def czy_rosnaco_malejacy(fragment):
  # fragment ma zawsze długość 6.
  # Sprawdzamy możliwe punkty podziału k = 2, 3, 4
  for k in [2, 3, 4]:
      czesc_rosnaca = fragment[:k]
      czesc_malejaca = fragment[k:]
      
      if czy_rosnacy(czesc_rosnaca) and czy_malejacy(czesc_malejaca):
          return True
  return False

def solve_3_3():
  with open('pi.txt', 'r') as f:
      # Od razu konwertujemy wczytane znaki na liczby całkowite (int)
      cyfry = [int(line.strip()) for line in f.readlines() if line.strip()]

  licznik = 0
  
  # Przesuwamy "okno" o szerokości 6 po całej tablicy
  for i in range(len(cyfry) - 5):
      okno = cyfry[i : i+6]
      if czy_rosnaco_malejacy(okno):
          licznik += 1

  print(f"3.3. Odpowiedź: {licznik}")

solve_3_3()

• Krok 1: Tworzymy tablicę inc, w której inc[i] to długość najdłuższego ciągu rosnącego kończącego się na indeksie i. Wypełniamy ją idąc od lewej do prawej.

• Krok 2: Tworzymy tablicę dec, w której dec[i] to długość najdłuższego ciągu malejącego zaczynającego się na indeksie i. Wypełniamy ją idąc od prawej do lewej.

• Krok 3: Przeszukujemy tablicę, traktując każdy indeks k jako potencjalny koniec części rosnącej. Część malejąca będzie się wtedy zaczynać od indeksu k + 1.

• Krok 4: Jeśli inc[k] ≥ 2 (część rosnąca ma min. 2 elementy) oraz dec[k+1] ≥ 2 (część malejąca ma min. 2 elementy), to całkowita długość takiego połączonego ciągu wynosi inc[k] + dec[k+1].

def solve_3_4():
  with open('pi.txt', 'r') as f:
      cyfry = [int(line.strip()) for line in f.readlines() if line.strip()]

  n = len(cyfry)
  if n == 0:
      return

  # inc[i] - długość najdłuższego ciągu rosnącego kończącego się na i
  inc = [1] * n
  for i in range(1, n):
      if cyfry[i] > cyfry[i-1]:
          inc[i] = inc[i-1] + 1

  # dec[i] - długość najdłuższego ciągu malejącego zaczynającego się na i
  dec = [1] * n
  for i in range(n-2, -1, -1):
      if cyfry[i] > cyfry[i+1]:
          dec[i] = dec[i+1] + 1

  max_len = 0
  best_start = -1
  best_seq = ""

  # Szukamy optymalnego punktu podziału k
  for k in range(0, n - 1):
      # Część rosnąca (do k) i malejąca (od k+1) muszą mieć co najmniej po 2 elementy
      if inc[k] >= 2 and dec[k+1] >= 2:
          current_len = inc[k] + dec[k+1]
          
          if current_len > max_len:
              max_len = current_len
              # Obliczamy indeks początkowy (0-based)
              start_idx = k - inc[k] + 1
              
              # Dodajemy 1, bo numery wierszy są od 1
              best_start = start_idx + 1 
              best_seq = "".join(map(str, cyfry[start_idx : start_idx + current_len]))

  print("3.4. Odpowiedź:")
  print(best_start)
  print(best_seq)

solve_3_4()

1. odszyfrowania wiadomości wysłanej do osoby A przez osobę B.
   PRAWDA (P). Kiedy osoba B chce wysłać tajną wiadomość do osoby A, szyfruje ją za pomocą klucza publicznego osoby A. Jedynym kluczem, który może odszyfrować tę wiadomość, jest klucz prywatny osoby A.

2. uwierzytelnienia osoby B przez osobę A.
   FAŁSZ (F). Aby uwierzytelnić osobę B (czyli upewnić się, że to na pewno ona nadała wiadomość), B musi podpisać wiadomość swoim własnym kluczem prywatnym. Następnie osoba A do weryfikacji tego podpisu używa klucza publicznego osoby B. Klucz prywatny osoby A nie bierze udziału w uwierzytelnianiu innych osób.

• Rozwijamy pierwszą liczbę (podstawa 3):
  

  $(2222)_3 = 2 \cdot 3^3 + 2 \cdot 3^2 + 2 \cdot 3^1 + 2 \cdot 3^0$
  $= 2 \cdot 27 + 2 \cdot 9 + 2 \cdot 3 + 2 \cdot 1$
  $= 54 + 18 + 6 + 2 = 80_{10}$

• Rozwijamy drugą liczbę (podstawa 6):
  

  $(1111)_6 = 1 \cdot 6^3 + 1 \cdot 6^2 + 1 \cdot 6^1 + 1 \cdot 6^0$
  $= 216 + 36 + 6 + 1 = 259_{10}$

1. Zaimportuj plik owoce.txt do Excela. Upewnij się, że separator to tabulacja, a kolumna z datą została poprawnie rozpoznana (jako Data, a nie Tekst).

2. Aby móc grupować po miesiącach, dodaj nową kolumnę (np. w kolumnie E) o nazwie Miesiąc.

3. Wpisz w niej formułę: =MIESIĄC(A2) i przeciągnij ją w dół. Otrzymasz numery od 5 do 9 (maj - wrzesień).
   *Jeśli Excel nie rozpoznał formatu daty, wyciągnij miesiąc tekstowo formułą: =FRAGMENT.TEKSTU(A2; 4; 2).

1. Zaznacz całą tabelę z danymi i z zakładki Wstawianie wybierz Tabela przestawna.

2. W polach tabeli przestawnej przeciągnij:

   • Miesiąc do obszaru Wiersze.
   • dostawa_malin, dostawa_truskawek oraz dostawa_porzeczek do obszaru Wartości. Upewnij się, że domyślną funkcją jest "Suma" (a nie np. "Licznik").

3. Dla czytelności wykresu możesz zamienić numery miesięcy w wierszach na ich nazwy (5 -> Maj, 6 -> Czerwiec itd.).

4. Kliknij wewnątrz Tabeli Przestawnej, przejdź do zakładki Wstawianie i wybierz Wykres kolumnowy (standardowy, grupowy).

5. Dodaj wymagane elementy wykresu (przez kliknięcie "+" obok wykresu):

   • Tytuł wykresu: np. "Zestawienie dostaw owoców (maj-wrzesień 2020)".
   • Tytuły osi: oś pozioma (X) -> "Miesiąc", oś pionowa (Y) -> "Liczba kilogramów".
   • Legenda: powinna wygenerować się automatycznie i opisywać poszczególne owoce.

def solve_6_1():
  # Słownik trzymający sumy: miesiac -> [maliny, truskawki, porzeczki]
  miesieczne_dostawy = {
      '05': [0, 0, 0], '06': [0, 0, 0], 
      '07': [0, 0, 0], '08': [0, 0, 0], '09': [0, 0, 0]
  }
  
  with open('owoce.txt', 'r') as f:
      # Pomiń nagłówek, jeśli plik go posiada
      lines = f.readlines()
      if "data" in lines[0]:
          lines = lines[1:]
          
      for line in lines:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              data = parts[0]
              miesiac = data[3:5] # Pobieramy mm z dd.mm.rrrr
              
              maliny = int(parts[1])
              truskawki = int(parts[2])
              porzeczki = int(parts[3])
              
              if miesiac in miesieczne_dostawy:
                  miesieczne_dostawy[miesiac][0] += maliny
                  miesieczne_dostawy[miesiac][1] += truskawki
                  miesieczne_dostawy[miesiac][2] += porzeczki

  # Wypisywanie wyników (gotowe do wklejenia)
  print("Miesiąc\tMaliny\tTruskawki\tPorzeczki")
  nazwy = {'05': 'Maj', '06': 'Czerwiec', '07': 'Lipiec', '08': 'Sierpień', '09': 'Wrzesień'}
  
  for m in sorted(miesieczne_dostawy.keys()):
      dane = miesieczne_dostawy[m]
      print(f"{nazwy[m]}\t{dane[0]}\t{dane[1]}\t{dane[2]}")

solve_6_1()

1. W tabeli z danymi stwórz nową kolumnę (np. kolumnę F).

2. Interesują nas dni, w których waga porzeczek (kolumna D) jest ostro większa od wagi malin (kolumna B) oraz od wagi truskawek (kolumna C).

3. W komórce F2 wpisz formułę używającą funkcji logicznej ORAZ:
   

   =JEŻELI(ORAZ(D2 > B2; D2 > C2); 1; 0)

4. Przeciągnij formułę na sam dół tabeli.

5. Zsumuj wartości z kolumny F (np. formułą =SUMA(F:F)). Wynik to szukana odpowiedź.

def solve_6_2():
  licznik = 0
  with open('owoce.txt', 'r') as f:
      lines = f.readlines()
      if "data" in lines[0]:
          lines = lines[1:]
          
      for line in lines:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              maliny = int(parts[1])
              truskawki = int(parts[2])
              porzeczki = int(parts[3])
              
              # Porzeczki muszą dominować nad obiema pozostałymi wartościami
              if porzeczki > maliny and porzeczki > truskawki:
                  licznik += 1
                  
  print(f"6.2. Odpowiedź: {licznik}")

solve_6_2()

• Do produkcji bierzemy dwa owoce, których jest najwięcej – czyli te o ilości równej Maksimum oraz Medianie. Owoc o ilości równej Minimum nie jest używany.

• Proporcja to 1:1, a wykorzystujemy "maksymalną dostępną ilość". Oznacza to, że użyjemy całości owocu, którego z tej wybranej dwójki jest mniej. Tym owocem jest oczywiście ten odpowiadający Medianie. Z obu rodzajów wybranych owoców pobierzemy dokładnie tyle, ile wynosi Mediana.

• Stany po produkcji (reszta):
  • Owoc "Najmniejszy": nic z niego nie wzięliśmy, więc zostaje tyle, ile było.
  • Owoc "Średni" (Mediana): wzięliśmy z niego wszystko, więc jego stan wynosi dokładnie 0.
  • Owoc "Największy": pobraliśmy z niego ilość równą Medianie. Zostaje (Maksimum - Mediana).

1. Stan rano (Dostawa + Reszta): W kolumnach E, F, G wyliczymy całkowitą ilość owoców.

   • Dzień pierwszy (wiersz 2): E2 = B2, F2 = C2, G2 = D2.
   • Kolejne dni (wiersz 3): E3 = B3 + K2, F3 = C3 + L2, G3 = D3 + M2 (gdzie K, L, M to reszty z poprzedniego dnia - wyliczymy je w kroku 4).

2. Co produkujemy? W kolumnie H sprawdzamy, jakiego owocu jest najmniej (zatem pozostałe dwa idą do produkcji). Używamy funkcji MIN.

   
   

   Formuła w H2: =JEŻELI(E2=MIN(E2:G2); "Trusk-Porz"; JEŻELI(F2=MIN(E2:G2); "Mal-Porz"; "Mal-Trusk"))

3. Zużycie (Mediana): W kolumnie I wpisujemy po prostu ilość pobieranych owoców.

   
   

   Formuła w I2: =MEDIANA(E2:G2)

4. Reszta na koniec dnia: W kolumnach K (Maliny), L (Truskawki), M (Porzeczki) odejmujemy zużycie, ale tylko jeśli dany owoc brał udział w produkcji.

   • K2 = E2 - JEŻELI(E2=MIN($E2:$G2); 0; $I2)
   • L2 = F2 - JEŻELI(F2=MIN($E2:$G2); 0; $I2)
   • M2 = G2 - JEŻELI(G2=MIN($E2:$G2); 0; $I2)

5. Przeciągnij formuły z wiersza 3 w dół. Odpowiedzią na zadanie jest zliczenie wartości w kolumnie H za pomocą funkcji LICZ.JEŻELI().

def solve_6_3():
  # Stan magazynu
  magazyn = {'M': 0, 'T': 0, 'P': 0}
  
  # Liczniki konfitur
  konfitury = {'M-T': 0, 'M-P': 0, 'T-P': 0}
  
  with open('owoce.txt', 'r') as f:
      lines = f.readlines()
      if "data" in lines[0]:
          lines = lines[1:]
          
      for line in lines:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              # 1. Dodanie dostawy porannej do magazynu
              magazyn['M'] += int(parts[1])
              magazyn['T'] += int(parts[2])
              magazyn['P'] += int(parts[3])
              
              # 2. Sortowanie owoców po ilości, żeby znaleźć min, mid, max
              posortowane = sorted(magazyn.items(), key=lambda x: x[1])
              min_owoc = posortowane[0][0]  # np. 'P'
              mid_owoc = posortowane[1][0]  # np. 'M'
              max_owoc = posortowane[2][0]  # np. 'T'
              
              # 3. Decyzja o konfiturze (te, których NIE ma najmniej)
              if min_owoc == 'P':
                  konfitury['M-T'] += 1
              elif min_owoc == 'T':
                  konfitury['M-P'] += 1
              elif min_owoc == 'M':
                  konfitury['T-P'] += 1
                  
              # 4. Produkcja i aktualizacja stanów
              zuzycie = magazyn[mid_owoc]  # Pobieramy ilość równą medianie
              
              if min_owoc != 'M': magazyn['M'] -= zuzycie
              if min_owoc != 'T': magazyn['T'] -= zuzycie
              if min_owoc != 'P': magazyn['P'] -= zuzycie

  print("6.3. Odpowiedzi:")
  print(f"Malinowo-truskawkowe: {konfitury['M-T']}")
  print(f"Malinowo-porzeczkowe: {konfitury['M-P']}")
  print(f"Truskawkowo-porzeczkowe: {konfitury['T-P']}")

solve_6_3()

• Kolumnę H: Rodzaj produkowanej konfitury (np. "Mal-Trusk").
• Kolumnę I: Ilość zużywanego owocu (nasza wyliczona funkcja MEDIANA), która odpowiada wadze gotowej konfitury.

• Dla malinowo-truskawkowych: =SUMA.JEŻELI(H:H; "Mal-Trusk"; I:I)
• Dla malinowo-porzeczkowych: =SUMA.JEŻELI(H:H; "Mal-Porz"; I:I)
• Dla truskawkowo-porzeczkowych: =SUMA.JEŻELI(H:H; "Trusk-Porz"; I:I)

def solve_6_4():
  magazyn = {'M': 0, 'T': 0, 'P': 0}
  
  # Tym razem zliczamy wagę [kg], a nie liczbę dni
  produkcja = {'M-T': 0, 'M-P': 0, 'T-P': 0}
  
  with open('owoce.txt', 'r') as f:
      lines = f.readlines()
      if "data" in lines[0]:
          lines = lines[1:]
          
      for line in lines:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              magazyn['M'] += int(parts[1])
              magazyn['T'] += int(parts[2])
              magazyn['P'] += int(parts[3])
              
              posortowane = sorted(magazyn.items(), key=lambda x: x[1])
              min_owoc = posortowane[0][0]
              mid_owoc = posortowane[1][0]
              
              zuzycie = magazyn[mid_owoc]
              
              # Dodajemy wagę wyprodukowanej konfitury do odpowiedniego smaku
              if min_owoc == 'P':
                  produkcja['M-T'] += zuzycie
              elif min_owoc == 'T':
                  produkcja['M-P'] += zuzycie
              elif min_owoc == 'M':
                  produkcja['T-P'] += zuzycie
                  
              if min_owoc != 'M': magazyn['M'] -= zuzycie
              if min_owoc != 'T': magazyn['T'] -= zuzycie
              if min_owoc != 'P': magazyn['P'] -= zuzycie

  print("6.4. Odpowiedzi [kg]:")
  print(f"Malinowo-truskawkowe: {produkcja['M-T']}")
  print(f"Malinowo-porzeczkowe: {produkcja['M-P']}")
  print(f"Truskawkowo-porzeczkowe: {produkcja['T-P']}")

solve_6_4()

SELECT TOP 1 gry.nazwa, COUNT(oceny.id_gry) AS LiczbaOcen
FROM gry 
INNER JOIN oceny ON gry.id_gry = oceny.id_gry
GROUP BY gry.nazwa
ORDER BY COUNT(oceny.id_gry) DESC;

def solve_7_1():
  liczba_ocen = {}
  
  # Krok 1: Zliczenie ocen dla każdego id_gry
  with open('oceny.txt', 'r') as f:
      next(f) # pomijamy nagłówek
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              id_gry = parts[0]
              liczba_ocen[id_gry] = liczba_ocen.get(id_gry, 0) + 1
              
  # Krok 2: Znalezienie id_gry z największą liczbą ocen
  najpopularniejsze_id = max(liczba_ocen, key=liczba_ocen.get)
  max_ocen = liczba_ocen[najpopularniejsze_id]
  
  # Krok 3: Odszukanie nazwy gry
  with open('gry.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if parts[0] == najpopularniejsze_id:
              nazwa_gry = parts[1]
              print(f"7.1. Tytuł: {nazwa_gry} (Ocen: {max_ocen})")
              break

solve_7_1()

SELECT gry.nazwa, ROUND(AVG(oceny.ocena), 2) AS SredniaOcen
FROM gry INNER JOIN oceny ON gry.id_gry = oceny.id_gry
WHERE gry.kategoria = 'imprezowa'
GROUP BY gry.nazwa;

def solve_7_2():
  # Słownik gier imprezowych: id_gry -> nazwa
  gry_imprezowe = {}
  with open('gry.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 3 and parts[2] == 'imprezowa':
              gry_imprezowe[parts[0]] = parts[1]
              
  # Słownik do liczenia średniej: id_gry -> [suma_ocen, liczba_ocen]
  statystyki_ocen = {id_gry: [0, 0] for id_gry in gry_imprezowe}
  
  with open('oceny.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              id_gry = parts[0]
              ocena = int(parts[3])
              
              if id_gry in statystyki_ocen:
                  statystyki_ocen[id_gry][0] += ocena
                  statystyki_ocen[id_gry][1] += 1
                  
  print("7.2. Średnie ocen gier imprezowych:")
  for id_gry, staty in statystyki_ocen.items():
      if staty[1] > 0:
          srednia = staty[0] / staty[1]
          nazwa = gry_imprezowe[id_gry]
          # Formatowanie z kropką zamieniamy na polski przecinek
          srednia_str = f"{srednia:.2f}".replace('.', ',')
          print(f"{nazwa}: {srednia_str}")

solve_7_2()

SELECT COUNT(*) AS Liczba_Graczy
FROM (
  SELECT DISTINCT id_gracza 
  FROM oceny 
  WHERE id_gracza NOT IN (
      SELECT id_gracza FROM oceny WHERE stan = 'posiada'
  )
);

def solve_7_3():
  wszyscy_oceniajacy = set()
  posiadajacy_gre = set()
  
  with open('oceny.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 3:
              id_gracza = parts[1]
              stan = parts[2]
              
              wszyscy_oceniajacy.add(id_gracza)
              if stan == 'posiada':
                  posiadajacy_gre.add(id_gracza)
                  
  # Różnica zbiorów: oceniający MINUS posiadający
  wynik_zbior = wszyscy_oceniajacy - posiadajacy_gre
  
  print(f"7.3. Wynik: {len(wynik_zbior)}")

solve_7_3()

• Kwerenda 1 (Grupowanie i zliczanie): Łączymy wszystkie 3 tabele i dodajemy wirtualną kolumnę KategoriaWiekowa (przy użyciu instrukcji IIF). Zliczamy oceny dla każdej gry w każdej kategorii.
  SELECT gry.nazwa, IIf(gracze.wiek<=19, "juniorzy", IIf(gracze.wiek<=49, "seniorzy", "weterani")) AS KatWiekowa, COUNT(oceny.id_gry) AS LiczbaOcen FROM (gry INNER JOIN oceny ON gry.id_gry = oceny.id_gry) INNER JOIN gracze ON oceny.id_gracza = gracze.id_gracza GROUP BY gry.nazwa, IIf(gracze.wiek<=19, "juniorzy", IIf(gracze.wiek<=49, "seniorzy", "weterani"));
  Zapisz tę kwerendę pod nazwą np. Q1_Podsumowanie.

• Kwerenda 2 (Szukanie maksimum): Z kwerendy Q1_Podsumowanie wybieramy maksymalną wartość LiczbaOcen dla każdej kategorii wiekowej.
  SELECT KatWiekowa, MAX(LiczbaOcen) AS MaxOcen FROM Q1_Podsumowanie GROUP BY KatWiekowa;
  Zapisz tę kwerendę pod nazwą np. Q2_Maksima.

• Kwerenda 3 (Wynik finałowy): Łączymy Q1_Podsumowanie z Q2_Maksima, aby wyświetlić ostateczne nazwy gier (odrzucamy te, które nie są na szczycie w swojej kategorii).
  SELECT Q1.KatWiekowa, Q1.MaxOcen, Q1.nazwa FROM Q1_Podsumowanie AS Q1 INNER JOIN Q2_Maksima AS Q2 ON Q1.KatWiekowa = Q2.KatWiekowa AND Q1.LiczbaOcen = Q2.MaxOcen;

def solve_7_4():
  # 1. Przypisanie graczy do kategorii
  kategorie_graczy = {}
  with open('gracze.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              id_g = parts[0]
              wiek = int(parts[3])
              if wiek <= 19: kat = 'juniorzy'
              elif wiek <= 49: kat = 'seniorzy'
              else: kat = 'weterani'
              kategorie_graczy[id_g] = kat
              
  # 2. Nazwy gier
  nazwy_gier = {}
  with open('gry.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 2:
              nazwy_gier[parts[0]] = parts[1]
              
  # 3. Zliczanie ocen w kategoriach
  # Słownik zagnieżdżony: kategoria -> {id_gry -> liczba_ocen}
  zliczenia = {'juniorzy': {}, 'seniorzy': {}, 'weterani': {}}
  
  with open('oceny.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 2:
              id_gry = parts[0]
              id_gracza = parts[1]
              
              kat = kategorie_graczy.get(id_gracza)
              if kat:
                  zliczenia[kat][id_gry] = zliczenia[kat].get(id_gry, 0) + 1
                  
  # 4. Znalezienie i wypisanie maksimów
  print("7.4. Najwyżej oceniane gry w kategoriach wiekowych:")
  for kat in ['juniorzy', 'seniorzy', 'weterani']:
      if not zliczenia[kat]: continue
      
      max_ocen = max(zliczenia[kat].values())
      
      # Wyłapanie wszystkich gier, które mają to maksimum (remisy)
      najlepsze_id = [id_g for id_g, ilosc in zliczenia[kat].items() if ilosc == max_ocen]
      
      tytuly = [nazwy_gier[id_g] for id_g in najlepsze_id]
      print(f"[{kat}] Max ocen: {max_ocen} | Gry: {', '.join(tytuly)}")

solve_7_4()

• "ile należałoby zapłacić [...] po jednej sztuce": Obliczamy łączny koszt, więc użyjemy funkcji agregującej SUM(cena). Wiemy z uwagi, że gra w promocji występuje w tabeli sklep dokładnie jeden raz z wartością true, więc nie musimy się martwić o duplikaty.

• Tabele: Potrzebujemy informacji o kategorii (tabela gry) oraz o cenie i promocji (tabela sklep). Łączymy je klauzulą INNER JOIN po kluczu id_gry.

• "gier logicznych": Dodajemy warunek kategoria = 'logiczna'.

• "dostępnych w cenach promocyjnych": Dodajemy warunek promocja = true (lub w niektórych dialektach SQL promocja = 1).

SELECT SUM(sklep.cena) AS CalkowityKoszt
FROM gry INNER JOIN sklep ON gry.id_gry = sklep.id_gry
WHERE gry.kategoria = 'logiczna' 
AND sklep.promocja = true;

SELECT SUM(cena)
FROM gry, sklep
WHERE gry.id_gry = sklep.id_gry 
AND kategoria = 'logiczna' 
AND promocja = true;