Matura Rozszerzona Informatyka 2024 Maj
Rozwiązania krok po kroku

• Tablica $P[i][j]$ przechowuje informację, czy da się dojść z pola startowego $(1,1)$ do pola $(i,j)$.
• Zgodnie z kodem, jeśli pole jest czarne ($A[i][j] = 0$), od razu wpisujemy tam FAŁSZ (nie da się na nie wejść).
• Jeśli jesteśmy w pierwszym wierszu (i = 1), możemy przyjść tam tylko z lewej strony (z komórki [i][j - 1]).
• Jeśli jesteśmy w pierwszej kolumnie (j = 1), możemy przyjść tam tylko z góry (z komórki [i - 1][j]).
• W każdym innym przypadku (środek planszy), na dane pole możemy dojść albo z góry, albo z lewej strony. Stąd instrukcja lub.

• Z pola $(1, 1)$ możemy iść w prawo do $(1, 2)$.
• Z pola $(1, 2)$ możemy iść w dół do $(2, 2)$ (które jest białe).
• Z pola $(2, 2)$ możemy iść w dół do $(3, 2)$.
• Z pola $(3, 2)$ idziemy w prawo do celu $(3, 3)$.

• Początek to $(1, 1)$. W drugim wierszu białe jest tylko pole $(2, 3)$. Zatem musimy przejść przez pierwszy wiersz aż do prawej krawędzi: $(1, 1) \rightarrow (1, 2) \rightarrow (1, 3)$.
• Następnie z $(1, 3)$ idziemy w dół: $(2, 3) \rightarrow (3, 3)$.
• Jesteśmy w komórce $(3, 3)$. Algorytm pozwala poruszać się tylko w prawo lub w dół. Nie możemy cofnąć się w lewo.
• Z komórki $(3, 3)$ ruch w dół jest zablokowany, ponieważ pole $(4, 3)$ jest czarne.
• Aby dojść do celu $(5, 3)$, musielibyśmy ominąć ten czarny blok, przechodząc przez białe pole $(4, 1)$. Jednakże dostęp do $(4, 1)$ z góry blokuje czarne pole $(2, 1)$. Mamy absolutną blokadę z każdej ze stron.

1. Zaczynamy na $(1, 1)$ i schodzimy na $(2, 1)$.
2. Idziemy w prawo na $(2, 2)$ (ponieważ $(3, 1)$ jest czarne).
3. Z $(2, 2)$ możemy iść bezpiecznie w dół, przez cały biały "korytarz": $(3, 2) \rightarrow (4, 2)$.
4. Z $(4, 2)$ idziemy w prawo: $(4, 3) \rightarrow (4, 4)$.
5. Z $(4, 4)$ schodzimy w dół na $(5, 4)$.
6. Na koniec jeden krok w prawo do celu: $(5, 5)$.

• Zmienna b kontroluje aktualną pozycję dziesiętną budowanej liczby $c$ (kolejno 1, 10, 100, 1000 itd.).
• Jeżeli cyfra jest parzysta (a mod 2 = 0): algorytm wstawia w to miejsce połowę tej cyfry (a div 2).
• Jeżeli cyfra jest nieparzysta: wykonywana jest instrukcja c <- c + b. Dodanie samego b oznacza wstawienie w to miejsce cyfry 1 (bo $1 \cdot b = b$).

• 5 (nieparzysta) $\rightarrow$ zamienia się na 1
• 4 (parzysta) $\rightarrow$ zamienia się na $4 / 2 =$ 2
• 2 (parzysta) $\rightarrow$ zamienia się na $2 / 2 =$ 1
• 1 (nieparzysta) $\rightarrow$ zamienia się na 1
• 0 (parzysta) $\rightarrow$ zamienia się na $0 / 2 =$ 0
• 2 (parzysta) $\rightarrow$ zamienia się na $2 / 2 =$ 1

• 8 $\rightarrow$ 4, 7 $\rightarrow$ 1, 6 $\rightarrow$ 3, 5 $\rightarrow$ 1, 4 $\rightarrow$ 2, 3 $\rightarrow$ 1, 2 $\rightarrow$ 1, 1 $\rightarrow$ 1, 0 $\rightarrow$ 0
• 1 $\rightarrow$ 1, 2 $\rightarrow$ 1, 3 $\rightarrow$ 1, 4 $\rightarrow$ 2, 5 $\rightarrow$ 1, 6 $\rightarrow$ 3, 7 $\rightarrow$ 1, 8 $\rightarrow$ 4

• Pierwsze 6 cyfr to 3, czyli blok: 333333
• Kolejne 6 cyfr to 6, czyli blok: 666666
• Ostatnie 6 cyfr to 9, czyli blok: 999999

• Każda cyfra nieparzysta zamieniana jest na 1.
• Każda cyfra parzysta zamieniana jest na połowę swojej wartości.

• Blok 333333 (cyfry nieparzyste) zamienia się na same jedynki: 111111.
• Blok 666666 (cyfry parzyste) dzielimy na pół i zamienia się on na: 333333.
• Blok 999999 (cyfry nieparzyste) znów zamienia się na same jedynki: 111111.

• Odczytywanie cyfr: Reszta z dzielenia przez 10 (n mod 10) zawsze daje nam ostatnią cyfrę liczby. Dzielenie całkowite przez 10 (n div 10) usuwa tę ostatnią cyfrę. Pozwala to na przetwarzanie liczby od prawej do lewej (od jedności).
• Warunek: Sprawdzamy, czy wyłuskana cyfra jest nieparzysta, badając czy reszta z jej dzielenia przez 2 nie jest równa zero (cyfra mod 2 != 0).
• Sklejanie nowej liczby: Skoro czytamy cyfry od prawej do lewej, budując nową liczbę $m$ musimy umieszczać wybrane cyfry na odpowiednich pozycjach (jedności, dziesiątki, setki). Użyjemy do tego zmiennej mnoznik. Gdy znajdziemy nieparzystą cyfrę, dodajemy do $m$ wartość cyfra * mnoznik, a następnie mnożymy mnoznik przez 10, by przygotować odpowiednią pozycję dla kolejnej trafionej cyfry.

funkcja nieparzysty_skrot(n):
  m <- 0
  mnoznik <- 1
  
  dopóki n > 0 wykonuj
      cyfra <- n mod 10
      n <- n div 10
      
      jeżeli cyfra mod 2 <> 0
          m <- m + cyfra * mnoznik
          mnoznik <- mnoznik * 10
          
  zwróć m

def nieparzysty_skrot(n):
  m = 0
  mnoznik = 1
  
  while n > 0:
      cyfra = n % 10
      n = n // 10
      
      if cyfra % 2 != 0:
          m = m + cyfra * mnoznik
          mnoznik = mnoznik * 10
          
  return m

int nieparzysty_skrot(int n) {
  int m = 0;
  int mnoznik = 1;
  
  while (n > 0) {
      int cyfra = n % 10;
      n = n / 10;
      
      if (cyfra % 2 != 0) {
          m = m + cyfra * mnoznik;
          mnoznik = mnoznik * 10;
      }
  }
  
  return m;
}

• licznik – do zliczania liczb bez skrótu (początkowo 0).
• najwieksza – do zapamiętania największej takiej liczby (początkowo np. -1).

def czy_ma_skrot(n):
  # Przechodzimy po wszystkich cyfrach liczby
  while n > 0:
      cyfra = n % 10
      if cyfra % 2 != 0:
          return True # Znaleziono cyfrę nieparzystą - skrót istnieje
      n = n // 10
  return False # Same cyfry parzyste - skrót nie istnieje

def solve_3_2():
  licznik = 0
  najwieksza = -1
  
  with open('skrot.txt', 'r') as file:
      for line in file:
          liczba = int(line.strip())
          
          # Interesują nas liczby, dla których skrót NIE istnieje
          if not czy_ma_skrot(liczba):
              licznik += 1
              if liczba > najwieksza:
                  najwieksza = liczba
                  
  print(f"Ilość liczb bez skrótu: {licznik}")
  print(f"Największa z nich: {najwieksza}")

  # Zapis do pliku
  with open('wyniki3_2.txt', 'w') as out_file:
      out_file.write(f"{licznik}\n{najwieksza}\n")

solve_3_2()

#include <iostream>
#include <fstream>

using namespace std;

// Funkcja zwracająca true, jeśli liczba posiada nieparzysty skrót
bool czy_ma_skrot(int n) {
  while (n > 0) {
      int cyfra = n % 10;
      if (cyfra % 2 != 0) {
          return true; // Znaleziono cyfrę nieparzystą
      }
      n /= 10;
  }
  return false; // Brak cyfr nieparzystych
}

int main() {
  ifstream file("skrot.txt");
  ofstream out_file("wyniki3_2.txt");
  
  int liczba;
  int licznik = 0;
  int najwieksza = -1;
  
  // Odczyt dopóki plik nie jest pusty
  while (file >> liczba) {
      if (!czy_ma_skrot(liczba)) {
          licznik++;
          if (liczba > najwieksza) {
              najwieksza = liczba;
          }
      }
  }
  
  cout << "Ilosc liczb bez skrotu: " << licznik << endl;
  cout << "Najwieksza z nich: " << najwieksza << endl;
  
  // Zapisz wyniki do pliku
  out_file << licznik << "\n" << najwieksza << "\n";
  
  file.close();
  out_file.close();
  
  return 0;
}

• Obliczenie nieparzystego skrótu: Wykorzystamy funkcję, którą przygotowaliśmy w podpunkcie 3.1. Przekształca ona matematycznie liczbę, usuwając z niej cyfry parzyste.
• Obliczenie Największego Wspólnego Dzielnika (NWD): Użyjemy do tego klasycznego algorytmu Euklidesa, który pozwala na szybkie znalezienie NWD dwóch liczb całkowitych.

def nieparzysty_skrot(n):
  m = 0
  mnoznik = 1
  while n > 0:
      cyfra = n % 10
      n = n // 10
      if cyfra % 2 != 0:
          m = m + cyfra * mnoznik
          mnoznik = mnoznik * 10
  return m

def nwd(a, b):
  # Klasyczny algorytm Euklidesa
  while b > 0:
      a, b = b, a % b
  return a

def solve_3_3():
  with open('skrot2.txt', 'r') as in_file, open('wyniki3_3.txt', 'w') as out_file:
      for line in in_file:
          liczba = int(line.strip())
          skrot = nieparzysty_skrot(liczba)
          
          # Sprawdzamy warunek zadania
          if nwd(liczba, skrot) == 7:
              print(liczba)
              out_file.write(f"{liczba}\n")

solve_3_3()

#include <iostream>
#include <fstream>

using namespace std;

// Funkcja wyznaczająca nieparzysty skrót
int nieparzysty_skrot(int n) {
  int m = 0;
  int mnoznik = 1;
  while (n > 0) {
      int cyfra = n % 10;
      if (cyfra % 2 != 0) {
          m = m + cyfra * mnoznik;
          mnoznik *= 10;
      }
      n /= 10;
  }
  return m;
}

// Algorytm Euklidesa dla NWD
int nwd(int a, int b) {
  while (b > 0) {
      int temp = b;
      b = a % b;
      a = temp;
  }
  return a;
}

int main() {
  ifstream in_file("skrot2.txt");
  ofstream out_file("wyniki3_3.txt");
  
  int liczba;
  
  // Odczyt pliku do końca
  while (in_file >> liczba) {
      int skrot = nieparzysty_skrot(liczba);
      
      // Warunek zadania
      if (nwd(liczba, skrot) == 7) {
          cout << liczba << endl;
          out_file << liczba << "\n";
      }
  }
  
  in_file.close();
  out_file.close();
  
  return 0;
}

def solve_4():
  # Odczyt danych
  with open('liczby.txt', 'r') as f:
      linie = f.readlines()
      
  # Zamiana tekstowych linii na listy liczb całkowitych
  wiersz1 = list(map(int, linie[0].split()))
  wiersz2 = list(map(int, linie[1].split()))
  
  # --- ZADANIE 4.1 ---
  wynik_4_1 = 0
  for p in wiersz1:
      for n in wiersz2:
          if n % p == 0:
              wynik_4_1 += 1
              break # Jeśli znaleźliśmy jakikolwiek dzielnik, przerywamy by nie dublować
              
  print(f"4.1. Wynik: {wynik_4_1}")
  
  # --- ZADANIE 4.2 ---
  # Sortujemy malejąco
  wiersz1_posortowany = sorted(wiersz1, reverse=True)
  
  # Sto pierwsza liczba to indeks 100 (bo liczymy od 0)
  wynik_4_2 = wiersz1_posortowany[100]
  
  print(f"4.2. Wynik: {wynik_4_2}")

solve_4()

#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <algorithm>

using namespace std;

int main() {
  ifstream file("liczby.txt");
  string linia1, linia2;
  
  // Wczytujemy całe linie jako tekst
  getline(file, linia1);
  getline(file, linia2);
  
  vector<int> wiersz1, wiersz2;
  stringstream ss1(linia1), ss2(linia2);
  int liczba;
  
  // Konwertujemy i pakujemy do wektorów
  while(ss1 >> liczba) wiersz1.push_back(liczba);
  while(ss2 >> liczba) wiersz2.push_back(liczba);
  
  // --- ZADANIE 4.1 ---
  int wynik_4_1 = 0;
  for(int p : wiersz1) {
      for(int n : wiersz2) {
          if(n % p == 0) {
              wynik_4_1++;
              break;
          }
      }
  }
  cout << "4.1. Wynik: " << wynik_4_1 << endl;
  
  // --- ZADANIE 4.2 ---
  // Skopiowanie i sortowanie malejące
  vector<int> wiersz1_posortowany = wiersz1;
  sort(wiersz1_posortowany.rbegin(), wiersz1_posortowany.rend());
  
  cout << "4.2. Wynik: " << wiersz1_posortowany[100] << endl;
  
  return 0;
}

from collections import Counter

def solve_4_3():
  with open('liczby.txt', 'r') as f:
      linie = f.readlines()
      
  wiersz1 = list(map(int, linie[0].split()))
  wiersz2 = list(map(int, linie[1].split()))
  
  # "Magazyn" dostępnych czynników
  dostepne = Counter(wiersz1)
  wyniki = []
  
  for n in wiersz2:
      temp = n
      czynniki_n = {}
      d = 2
      
      # Rozkład na czynniki pierwsze
      while d * d <= temp:
          while temp % d == 0:
              czynniki_n[d] = czynniki_n.get(d, 0) + 1
              temp //= d
          d += 1
      if temp > 1:
          czynniki_n[temp] = czynniki_n.get(temp, 0) + 1
          
      # Sprawdzenie z magazynem
      czy_mozna = True
      for czynnik, ilosc in czynniki_n.items():
          if dostepne.get(czynnik, 0) < ilosc:
              czy_mozna = False
              break
              
      if czy_mozna:
          wyniki.append(n)
          
  print("4.3. Odpowiedź:")
  print(" ".join(map(str, wyniki)))

solve_4_3()

def solve_4_4():
  with open('liczby.txt', 'r') as f:
      linie = f.readlines()
  wiersz1 = list(map(int, linie[0].split()))
  
  max_srednia = -1.0
  najlepsza_dlugosc = 0
  najlepszy_start_wartosc = 0
  
  n = len(wiersz1)
  
  for i in range(n):
      obecna_suma = 0
      for j in range(i, n):
          obecna_suma += wiersz1[j]
          dlugosc = j - i + 1
          
          if dlugosc >= 50:
              srednia = obecna_suma / dlugosc
              
              # Znak > gwarantuje, że przy remisie zostanie 
              # ten znaleziony jako pierwszy
              if srednia > max_srednia:
                  max_srednia = srednia
                  najlepsza_dlugosc = dlugosc
                  najlepszy_start_wartosc = wiersz1[i]
                  
  # Formatowanie wyświetlania ułamków wzorem CKE (z przecinkiem)
  srednia_str = f"{max_srednia:.2f}".replace('.', ',')
  
  print("4.4. Odpowiedź:")
  print(f"{srednia_str} {najlepsza_dlugosc} {najlepszy_start_wartosc}")

solve_4_4()

#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <iomanip>

using namespace std;

int main() {
  ifstream file("liczby.txt");
  string linia1;
  getline(file, linia1);
  
  vector<int> wiersz1;
  stringstream ss(linia1);
  int liczba;
  while(ss >> liczba) wiersz1.push_back(liczba);
  
  double max_srednia = -1.0;
  int najlepsza_dlugosc = 0;
  int najlepszy_start_wartosc = 0;
  
  int n = wiersz1.size();
  
  for (int i = 0; i < n; i++) {
      long long obecna_suma = 0;
      for (int j = i; j < n; j++) {
          obecna_suma += wiersz1[j];
          int dlugosc = j - i + 1;
          
          if (dlugosc >= 50) {
              double srednia = (double)obecna_suma / dlugosc;
              
              if (srednia > max_srednia) {
                  max_srednia = srednia;
                  najlepsza_dlugosc = dlugosc;
                  najlepszy_start_wartosc = wiersz1[i];
              }
          }
      }
  }
  
  cout << "4.4. Odpowiedz:" << endl;
  cout << fixed << setprecision(2) << max_srednia << " ";
  cout << najlepsza_dlugosc << " " << najlepszy_start_wartosc << endl;
  
  return 0;
}

1. HTTP to protokół... do poczty elektronicznej.
   FAŁSZ (F). HTTP (Hypertext Transfer Protocol) służy do przesyłania dokumentów hipertekstowych (stron WWW). Do poczty elektronicznej wykorzystuje się protokoły takie jak SMTP (wysyłanie), POP3 lub IMAP (odbieranie).

2. FTP to protokół zamiany nazw domenowych na adresy IP.
   FAŁSZ (F). FTP (File Transfer Protocol) służy do przesyłania plików w sieci. Za zamianę nazw domenowych (np. www.google.com) na adresy IP odpowiada system DNS (Domain Name System).

3. DHCP to protokół umożliwiający hostom uzyskanie... danych konfiguracyjnych.
   PRAWDA (P). DHCP (Dynamic Host Configuration Protocol) dokładnie do tego służy – automatycznie przydziela podłączonym urządzeniom (hostom) parametry niezbędne do działania w sieci (adres IP, maskę, bramę, adresy DNS).

• 1 (dziewiątkowo) = 01 (trójkowo)
• 2 (dziewiątkowo) = 02 (trójkowo)
• 1 (dziewiątkowo) = 01 (trójkowo)

   101112
+  10201
--------
  112020

   101112
-  10201
--------
  20211

• 2 - 1 = 1
• 1 - 0 = 1
• 1 - 2 -> pożyczamy 1 od sąsiada po lewej. Sąsiad staje się 0, a my dostajemy +3. Mamy (1 + 3) - 2 = 2.
• 0 - 0 = 0
• 0 - 1 -> znów pożyczamy od lewej. Jedynka staje się 0, a my dostajemy +3. Mamy (0 + 3) - 1 = 2.
• 0 z lewej opada, otrzymujemy końcowy wynik.

1. Zaimportuj plik jablka.txt do bazy danych. Zadbaj o poprawne typy danych – liczba kilogramów musi być liczbą całkowitą, aby można było ją sumować.
2. Utwórz nowy Projekt kwerendy i dodaj do niego tabelę jablka.
3. Dodaj pola NIP, kod oraz liczba_kg do siatki kwerendy.
4. Włącz przycisk Sumy ($\Sigma$) w górnym menu.

5. Skonfiguruj wiersz "Suma" dla poszczególnych kolumn:

   • Dla pola NIP: pozostaw Grupuj według.
   • Dla pola kod: zmień na Warunek i w polu Kryteria wpisz "Z" (odfiltrowanie tylko odmian zimowych). Odznacz widoczność tego pola.
   • Dla pola liczba_kg: zmień na Suma i ustaw sortowanie na Malejąco.
6. Uruchom kwerendę i odczytaj pierwsze trzy rekordy z najwyższymi wynikami.

SELECT TOP 3 NIP, SUM(liczba_kg) AS Suma_Zimowych
FROM jablka
WHERE kod = 'Z'
GROUP BY NIP
ORDER BY SUM(liczba_kg) DESC;

def solve_7_1():
  zakupy_klientow = {}
  
  with open('jablka.txt', 'r') as file:
      for line in file:
          parts = line.strip().split('\t')
          if len(parts) >= 5:
              kod = parts[2]
              nip = parts[3]
              kilogramy = int(parts[4])
              
              # Interesują nas tylko odmiany zimowe (Z)
              if kod == 'Z':
                  zakupy_klientow[nip] = zakupy_klientow.get(nip, 0) + kilogramy
                  
  # Sortowanie słownika malejąco po zsumowanych kilogramach
  posortowani = sorted(zakupy_klientow.items(), key=lambda item: item[1], reverse=True)
  
  print("7.1. Wynik (Top 3):")
  for i in range(3):
      print(f"NIP: {posortowani[i][0]} | Suma: {posortowani[i][1]} kg")

solve_7_1()

SELECT SUM(jablka.liczba_kg * cennik.cena) AS Calkowity_Przychod
FROM jablka INNER JOIN cennik ON jablka.odmiana = cennik.odmiana;

SELECT TOP 1 jablka.odmiana, SUM(jablka.liczba_kg * cennik.cena) AS Przychod
FROM jablka INNER JOIN cennik ON jablka.odmiana = cennik.odmiana
GROUP BY jablka.odmiana
ORDER BY SUM(jablka.liczba_kg * cennik.cena) DESC;

def solve_7_2():
  # 1. Wczytanie cennika do słownika
  cennik = {}
  with open('cennik.txt', 'r') as f:
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) == 2:
              odmiana = parts[0]
              # Zamiana polskiego przecinka na kropkę!
              cena = float(parts[1].replace(',', '.'))
              cennik[odmiana] = cena

  # 2. Przetwarzanie transakcji
  calkowity_przychod = 0
  przychod_odmiany = {}

  with open('jablka.txt', 'r') as f:
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 5:
              odmiana = parts[1]
              kilogramy = int(parts[4])
              
              cena_za_kg = cennik.get(odmiana, 0)
              przychod_z_transakcji = kilogramy * cena_za_kg
              
              calkowity_przychod += przychod_z_transakcji
              przychod_odmiany[odmiana] = przychod_odmiany.get(odmiana, 0) + przychod_z_transakcji

  # 3. Znalezienie odmiany z największym przychodem
  najlepsza_odmiana = max(przychod_odmiany.items(), key=lambda x: x[1])

  print("7.2. Całkowity przychód: {:.2f} zł".format(calkowity_przychod))
  print(f"7.2. Najlepsza odmiana: {najlepsza_odmiana[0]} (Przychód: {najlepsza_odmiana[1]:.2f} zł)")

solve_7_2()

def solve_7_3():
  # Słownik zagnieżdżony: sprzedaz[miesiac][odmiana] = suma_kg
  sprzedaz = {str(i).zfill(2): {} for i in range(1, 13)}
  
  with open('jablka.txt', 'r') as f:
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 5:
              data = parts[0]
              miesiac = data[5:7] # Wyciągamy 'MM' z 'YYYY-MM-DD'
              odmiana = parts[1]
              kg = int(parts[4])
              
              sprzedaz[miesiac][odmiana] = sprzedaz[miesiac].get(odmiana, 0) + kg
              
  # Znalezienie najpopularniejszej odmiany w każdym miesiącu
  print("Dane do wklejenia do arkusza (Oś X \t Oś Y):")
  print("Miesiac_Odmiana\tSprzedaz_kg")
  
  for miesiac in sorted(sprzedaz.keys()):
      dane_miesiaca = sprzedaz[miesiac]
      if dane_miesiaca:
          # Znajdź odmianę z maksymalną wartością
          najlepsza_odmiana = max(dane_miesiaca.items(), key=lambda x: x[1])
          nazwa_odmiany = najlepsza_odmiana[0]
          max_kg = najlepsza_odmiana[1]
          
          # Wypisanie zgodnie z wytycznymi na osi X
          etykieta_x = f"{miesiac}-{nazwa_odmiany}"
          print(f"{etykieta_x}\t{max_kg}")

solve_7_3()

1. Zsumowanie kilogramów: Zapisz kwerendę pod nazwą np. Suma_Miesieczna.

   SELECT MONTH(data_sprzedazy) AS Miesiac, odmiana, SUM(liczba_kg) AS SumaKG 
   FROM jablka GROUP BY MONTH(data_sprzedazy), odmiana;

2. Znalezienie maksimum: Zapisz kwerendę pod nazwą np. Max_Miesieczny.

   SELECT Miesiac, MAX(SumaKG) AS MaxKG 
   FROM Suma_Miesieczna GROUP BY Miesiac;

3. Połączenie wyników do wykresu: Tworzymy finalną etykietę łącząc miesiąc i odmianę (w Accessie służy do tego znak &).

   SELECT S.Miesiac & "-" & S.odmiana AS EtykietaX, M.MaxKG AS OśY
   FROM Suma_Miesieczna AS S INNER JOIN Max_Miesieczny AS M 
   ON S.Miesiac = M.Miesiac AND S.SumaKG = M.MaxKG;

• Skopiuj wyniki wygenerowane z Kliku 2 lub 3 do Excela (dwie kolumny).
• Zaznacz obie kolumny, przejdź do zakładki Wstawianie i wybierz standardowy Wykres kolumnowy.
• Zmień tytuł wykresu na czytelny, np. "Wielkość sprzedaży najpopularniejszych odmian w miesiącach 2022 roku".
• Dodaj tytuł osi Y (kliknij znak "+" obok wykresu -> Tytuły osi) i wpisz np. "Sprzedaż [kg]". Oś X automatycznie zaczyta przygotowane etykiety w formacie np. 01-Jonagold.

def solve_7_4():
  # Słownik do śledzenia historii zakupów: {nip: suma_kg}
  historia_zakupow = {}
  
  liczba_transakcji_z_rabatem = 0
  laczna_wartosc_rabatow_pln = 0.0

  with open('jablka.txt', 'r') as file:
      for line in file:
          parts = line.strip().split('\t')
          if len(parts) >= 5:
              nip = parts[3]
              kg_w_transakcji = int(parts[4])
              
              # Aktualizujemy sumę klienta ZANIM sprawdzimy progi
              historia_zakupow[nip] = historia_zakupow.get(nip, 0) + kg_w_transakcji
              biezaca_suma = historia_zakupow[nip]
              
              # Sprawdzanie progów rabatowych
              if biezaca_suma >= 20000:
                  # Rabat 10 groszy (0.10 zł) za każdy kg z bieżącej transakcji
                  wartosc_rabatu = kg_w_transakcji * 0.10
                  liczba_transakcji_z_rabatem += 1
                  laczna_wartosc_rabatow_pln += wartosc_rabatu
                  
              elif biezaca_suma >= 15000:
                  # Rabat 5 groszy (0.05 zł) za każdy kg z bieżącej transakcji
                  wartosc_rabatu = kg_w_transakcji * 0.05
                  liczba_transakcji_z_rabatem += 1
                  laczna_wartosc_rabatow_pln += wartosc_rabatu

  print(f"7.4. Liczba transakcji z rabatem: {liczba_transakcji_z_rabatem}")
  
  # Formatowanie wyświetlania ułamków wzorem CKE (z przecinkiem)
  rabaty_str = f"{laczna_wartosc_rabatow_pln:.2f}".replace('.', ',')
  print(f"7.4. Łączna wartość rabatów: {rabaty_str} zł")

solve_7_4()

SELECT TOP 1 k.Imie, k.Nazwisko, SUM(t.Kwota) AS SumaKwot
FROM (kierowcy AS k
INNER JOIN rejestr AS r ON k.IdOsoby = r.IdOsoby)
INNER JOIN taryfikator AS t ON r.IdWykroczenia = t.IdWykroczenia
GROUP BY k.IdOsoby, k.Imie, k.Nazwisko
ORDER BY SUM(t.Kwota) DESC;

def solve_8_1():
  # 1. Wczytanie taryfikatora (IdWykroczenia -> Kwota)
  taryfikator = {}
  with open('taryfikator.txt', 'r') as f:
      next(f) # pominięcie nagłówka
      for line in f:
          parts = line.strip().split(';')
          taryfikator[parts[0]] = int(parts[3])
          
  # 2. Sumowanie kwot dla IdOsoby na podstawie rejestru
  kary_kierowcow = {}
  with open('rejestr.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split(';')
          id_osoby = parts[2]
          id_wykroczenia = parts[3]
          kary_kierowcow[id_osoby] = kary_kierowcow.get(id_osoby, 0) + taryfikator[id_wykroczenia]
          
  # 3. Znalezienie IdOsoby z największą sumą
  najgorszy_kierowca_id = max(kary_kierowcow, key=kary_kierowcow.get)
  max_kwota = kary_kierowcow[najgorszy_kierowca_id]
  
  # 4. Odczytanie danych z pliku kierowcy
  with open('kierowcy.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split(';')
          if parts[0] == najgorszy_kierowca_id:
              print(f"8.1. Wynik: {parts[1]} {parts[2]}, Suma: {max_kwota} zł")
              break

solve_8_1()

SELECT TOP 1 MONTH(r.Data) AS Miesiac, SUM(t.Punkty) AS LaczniePunktow
FROM rejestr AS r
INNER JOIN taryfikator AS t ON r.IdWykroczenia = t.IdWykroczenia
WHERE r.IdWykroczenia IN (3, 4, 5, 6)
GROUP BY MONTH(r.Data)
ORDER BY SUM(t.Punkty) ASC;

def solve_8_2():
  # Słownik: IdWykroczenia -> Punkty (tylko dla id 3, 4, 5, 6)
  punkty_za_wykroczenia = {}
  with open('taryfikator.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split(';')
          id_w = parts[0]
          if id_w in ['3', '4', '5', '6']:
              punkty_za_wykroczenia[id_w] = int(parts[2])
              
  # Słownik zliczający: Miesiac -> Suma Punktów
  punkty_miesiace = {}
  with open('rejestr.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split(';')
          data = parts[1]
          id_w = parts[3]
          
          # Jeśli wykroczenie nas interesuje
          if id_w in punkty_za_wykroczenia:
              miesiac = data[5:7] # Wyciągamy dwucyfrowy miesiąc
              punkty = punkty_za_wykroczenia[id_w]
              punkty_miesiace[miesiac] = punkty_miesiace.get(miesiac, 0) + punkty
              
  # Znalezienie najmniejszej wartości
  najlepszy_miesiac = min(punkty_miesiace, key=punkty_miesiace.get)
  min_punkty = punkty_miesiace[najlepszy_miesiac]
  
  print(f"8.2. Wynik: Miesiąc {najlepszy_miesiac}, Punktów: {min_punkty}")

solve_8_2()

SELECT NrRejestracyjny, Imie, Nazwisko
FROM kierowcy
WHERE IdOsoby NOT IN (SELECT IdOsoby FROM rejestr)
ORDER BY NrRejestracyjny ASC;

def solve_8_3():
  # 1. Zbiór ID ukaranych kierowców (używamy seta dla szybkości)
  ukarani = set()
  with open('rejestr.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split(';')
          ukarani.add(parts[2])
          
  # 2. Wyławiamy wzorowych kierowców
  wzorowi_kierowcy = []
  with open('kierowcy.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split(';')
          id_osoby = parts[0]
          if id_osoby not in ukarani:
              # Dołączamy jako krotkę: (NrRej, Imie, Nazwisko)
              wzorowi_kierowcy.append((parts[3], parts[1], parts[2]))
              
  # 3. Sortowanie alfabetyczne po numerze rejestracyjnym (pierwszy element krotki)
  wzorowi_kierowcy.sort()
  
  print("8.3. Wzorowi kierowcy (pierwsze 5 wyników):")
  for nr, imie, nazwisko in wzorowi_kierowcy[:5]:
      print(f"{nr} | {imie} {nazwisko}")
      
  print(f"...(łącznie {len(wzorowi_kierowcy)} kierowców)")

solve_8_3()

SELECT IdFotoradaru 
FROM Fotoradar 
WHERE IdFotoradaru NOT IN (SELECT IdFotoradaru FROM Rejestr);

SELECT f.IdFotoradaru 
FROM Fotoradar AS f LEFT JOIN Rejestr AS r 
ON f.IdFotoradaru = r.IdFotoradaru 
WHERE r.IdFotoradaru IS NULL;