Matura Rozszerzona Informatyka 2025 Maj
Rozwiązania krok po kroku

• 88 staje się 88
• 76 staje się 67
• 65 staje się 56
• 43 staje się 34

• 10 staje się 01
• 57 staje się 75
• 00 staje się 00
• 54 staje się 45
• 1 staje się 1 (samotna cyfra pozostaje bez zmian)

• ... 21 $\rightarrow$ 12
• ... 43 $\rightarrow$ 34
• (i tak dalej, każda para jest po prostu odwracana)
• ... 9 $\rightarrow$ 9

• Wiersz 1: Wzór $\frac{k}{2}$. Jeśli podstawimy nieparzyste $k=5$, otrzymamy $2,5$. To nie jest liczba całkowita, więc zdanie jest Fałszywe (F).
• Wiersz 4: Wzór $\frac{k+1}{2}$. Jeśli podstawimy parzyste $k=4$, otrzymamy $\frac{5}{2} = 2,5$. Znowu ułamek, więc zdanie jest Fałszywe (F).

• Dla parzystego $k=4$: $(4+1) \text{ div } 2 = 5 \text{ div } 2 = 2$. Zgadza się z naszymi ustaleniami.
• Dla nieparzystego $k=5$: $(5+1) \text{ div } 2 = 6 \text{ div } 2 = 3$. Również się zgadza.

• Gdy $k$ jest parzyste, stosuje $\frac{k}{2}$. Dla $k=4$ mamy $\frac{4}{2} = 2$. Zgadza się.
• Gdy $k$ jest nieparzyste, stosuje $\frac{k+1}{2}$. Dla $k=5$ mamy $\frac{5+1}{2} = \frac{6}{2} = 3$. Również się zgadza.

• Wyciągamy dwie ostatnie cyfry: r = n mod 100
• Rozbijamy je na dziesiątki (a = r div 10) i jedności (b = r mod 10)
• Skracamy n o dwie cyfry: n = n div 100
• Dodajemy do wyniku przeliczone wartości pomnożone przez obecny mnoznik. Musimy dokładnie skopiować instrukcje warunkowe jeżeli, które obsługiwały ostatnią, niepełną parę cyfr.

funkcja przestaw2(n):
  jeżeli n = 0
      zwróć 0
      
  w <- 0
  mnoznik <- 1
  
  dopóki n > 0 wykonuj:
      r <- n mod 100
      a <- r div 10
      b <- r mod 10
      n <- n div 100
      
      jeżeli n > 0
          w <- w + (a + 10 * b) * mnoznik
      w przeciwnym razie
          jeżeli a > 0
              w <- w + (a + 10 * b) * mnoznik
          w przeciwnym razie
              w <- w + b * mnoznik
              
      mnoznik <- mnoznik * 100
      
  wynikiem jest w

int przestaw2(int n) {
  if (n == 0) return 0;
  
  int w = 0;
  int mnoznik = 1;
  
  while (n > 0) {
      int r = n % 100;
      int a = r / 10;
      int b = r % 10;
      n = n / 100;
      
      if (n > 0) {
          w = w + (a + 10 * b) * mnoznik;
      } else {
          if (a > 0) {
              w = w + (a + 10 * b) * mnoznik;
          } else {
              w = w + b * mnoznik;
          }
      }
      mnoznik = mnoznik * 100;
  }
  return w;
}

def przestaw2(n):
  if n == 0:
      return 0
      
  w = 0
  mnoznik = 1
  
  while n > 0:
      r = n % 100
      a = r // 10
      b = r % 10
      n = n // 100
      
      if n > 0:
          w = w + (a + 10 * b) * mnoznik
      else:
          if a > 0:
              w = w + (a + 10 * b) * mnoznik
          else:
              w = w + b * mnoznik
              
      mnoznik = mnoznik * 100
      
  return w

• Utworzenie odwróconej kopii badanego napisu.
• Porównanie oryginalnego napisu z jego odwróconą wersją. Jeśli są identyczne – mamy palindrom.

def solve_2_1():
  with open('symbole.txt', 'r') as file:
      lines = file.read().splitlines()
      
  print("Odpowiedzi do zadania 2.1:")
  for line in lines:
      # line[::-1] tworzy odwrócony ciąg znaków
      if line == line[::-1]:
          print(line)

solve_2_1()

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>

using namespace std;

int main() {
  ifstream file("symbole.txt");
  string line;
  
  cout << "Odpowiedzi do zadania 2.1:" << endl;
  while (file >> line) {
      string reversed_line = line;
      // Odwracamy skopiowany string
      reverse(reversed_line.begin(), reversed_line.end());
      
      // Porównujemy oryginał z odwróconym
      if (line == reversed_line) {
          cout << line << endl;
      }
  }
  return 0;
}

• Współrzędna $y$ (wiersz) środka może znajdować się od indeksu 1 do liczba_wierszy - 2 (zakładając indeksowanie od 0).
• Współrzędna $x$ (kolumna) środka może znajdować się od indeksu 1 do 10 (ponieważ każdy wiersz ma długość 12 znaków, indeksy to 0-11, a środek kwadratu $3 \times 3$ nie może dotykać krawędzi).

def solve_2_2():
  with open('symbole.txt', 'r') as file:
      grid = file.read().splitlines()
      
  rows = len(grid)
  cols = len(grid[0]) if rows > 0 else 0
  
  found_squares = []
  
  # Iterujemy tylko po potencjalnych "środkach"
  for r in range(1, rows - 1):
      for c in range(1, cols - 1):
          center_char = grid[r][c]
          is_square = True
          
          # Sprawdzamy otoczenie 3x3
          for dr in [-1, 0, 1]:
              for dc in [-1, 0, 1]:
                  if grid[r + dr][c + dc] != center_char:
                      is_square = False
                      break
              if not is_square:
                  break
                  
          if is_square:
              # Zapisujemy pozycję (indeksowane od 1)
              found_squares.append((r + 1, c + 1))
              
  print(f"Liczba kwadratów: {len(found_squares)}")
  for r, c in found_squares:
      print(f"Środek w wierszu: {r}, na pozycji: {c}")

solve_2_2()

#include <iostream>
#include <fstream>
#include <vector>
#include <string>

using namespace std;

struct Point {
  int row;
  int col;
};

int main() {
  ifstream file("symbole.txt");
  vector<string> grid;
  string line;
  
  // Wczytywanie danych do dwuwymiarowej tablicy (wektora stringów)
  while (file >> line) {
      grid.push_back(line);
  }
  
  int rows = grid.size();
  if (rows == 0) return 0;
  int cols = grid[0].length();
  
  vector<Point> found_squares;
  
  // Iterujemy po potencjalnych środkach kwadratu
  for (int r = 1; r < rows - 1; ++r) {
      for (int c = 1; c < cols - 1; ++c) {
          char center_char = grid[r][c];
          bool is_square = true;
          
          // Weryfikacja wszystkich 9 komórek kwadratu
          for (int dr = -1; dr <= 1; ++dr) {
              for (int dc = -1; dc <= 1; ++dc) {
                  if (grid[r + dr][c + dc] != center_char) {
                      is_square = false;
                      break;
                  }
              }
              if (!is_square) break;
          }
          
          if (is_square) {
              // Zapamiętujemy pozycję (indeksowane od 1)
              found_squares.push_back({r + 1, c + 1});
          }
      }
  }
  
  cout << "Liczba kwadratów: " << found_squares.size() << endl;
  for (const auto& pt : found_squares) {
      cout << "Srodek w wierszu: " << pt.row << ", na pozycji: " << pt.col << endl;
  }
  
  return 0;
}

• Inicjujemy zmienną wartosc = 0.
• Dla każdego znaku w ciągu, mnożymy wartosc przez 3 i dodajemy wartość odpowiadającą temu znakowi (o to 0, + to 1, * to 2).

def solve_2_3():
  with open('symbole.txt', 'r') as file:
      lines = file.read().splitlines()
      
  max_dec = -1
  max_sym = ""
  
  # Tworzymy mapowanie znaków na cyfry
  trans = str.maketrans('o+*', '012')
  
  for line in lines:
      # Zamieniamy 'o+*' na '012' i parsujemy jako system trójkowy
      dec_val = int(line.translate(trans), 3)
      
      if dec_val > max_dec:
          max_dec = dec_val
          max_sym = line
          
  print("Odpowiedź do zadania 2.3:")
  print(f"{max_dec} {max_sym}")

solve_2_3()

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

long long to_decimal(const string& sym) {
  long long value = 0;
  for (char c : sym) {
      value *= 3;
      if (c == 'o') value += 0;
      else if (c == '+') value += 1;
      else if (c == '*') value += 2;
  }
  return value;
}

int main() {
  ifstream file("symbole.txt");
  string line;
  
  long long max_dec = -1;
  string max_sym = "";
  
  while (file >> line) {
      long long current_dec = to_decimal(line);
      if (current_dec > max_dec) {
          max_dec = current_dec;
          max_sym = line;
      }
  }
  
  cout << "Odpowiedz do zadania 2.3:" << endl;
  cout << max_dec << " " << max_sym << endl;
  
  return 0;
}

• Dzielimy liczbę przez 3 i odczytujemy resztę.
• Jeśli reszta to 0, dopisujemy z przodu znak o. Jeśli 1, dopisujemy +. Jeśli 2, dopisujemy *.
• Wynik dzielenia całkowitego staje się nową wartością do podzielenia w następnym kroku.
• Proces kończy się, gdy liczba do podzielenia spadnie do 0.

def solve_2_4():
  trans_to_dec = str.maketrans('o+*', '012')
  total_sum = 0
  
  with open('symbole.txt', 'r') as file:
      for line in file:
          line = line.strip()
          total_sum += int(line.translate(trans_to_dec), 3)
          
  # Konwersja sumy dziesiętnej z powrotem na symbole trójkowe
  temp = total_sum
  sym_result = ""
  symbols = ['o', '+', '*']
  
  if temp == 0:
      sym_result = "o"
  else:
      while temp > 0:
          remainder = temp % 3
          sym_result = symbols[remainder] + sym_result
          temp = temp // 3
          
  print("Odpowiedź do zadania 2.4:")
  print(f"{total_sum} {sym_result}")

solve_2_4()

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

long long to_decimal(const string& sym) {
  long long value = 0;
  for (char c : sym) {
      value *= 3;
      if (c == 'o') value += 0;
      else if (c == '+') value += 1;
      else if (c == '*') value += 2;
  }
  return value;
}

string to_symbolic(long long num) {
  if (num == 0) return "o";
  
  string result = "";
  while (num > 0) {
      int remainder = num % 3;
      if (remainder == 0) result = "o" + result;
      else if (remainder == 1) result = "+" + result;
      else if (remainder == 2) result = "*" + result;
      
      num /= 3;
  }
  return result;
}

int main() {
  ifstream file("symbole.txt");
  string line;
  long long total_sum = 0;
  
  while (file >> line) {
      total_sum += to_decimal(line);
  }
  
  cout << "Odpowiedz do zadania 2.4:" << endl;
  cout << total_sum << " " << to_symbolic(total_sum) << endl;
  
  return 0;
}

• Wartość bezwzględna: Z treści zadania wynika, że $A$ jest zawsze dodatnie, więc nie musimy zmieniać jego znaku. Liczba $B$ może być ujemna (gdy dron opada), dlatego musimy na niej wymusić wartość bezwzględną (np. za pomocą funkcji abs()).
• Algorytm NWD (Największy Wspólny Dzielnik): Najlepszą i najszybszą metodą obliczania NWD jest algorytm Euklidesa. Warto zauważyć, że klasyczny algorytm Euklidesa (oparty na reszcie z dzielenia) naturalnie obsługuje przypadek podany w uwadze do zadania, czyli $\text{NWD}(A, 0) = A$.

import math

def solve_3_1():
  count = 0
  with open('dron.txt', 'r') as file:
      for line in file:
          # Rozdzielamy linię na dwie liczby
          a_str, b_str = line.split()
          A = int(a_str)
          B = int(b_str)
          
          # Pobieramy wartość bezwzględną dla B
          B_abs = abs(B)
          
          # Sprawdzamy warunek zadania
          if math.gcd(A, B_abs) > 1:
              count += 1
              
  print(f"Odpowiedź do zadania 3.1: {count}")

solve_3_1()

#include <iostream>
#include <fstream>
#include <cmath>

using namespace std;

// Klasyczny Algorytm Euklidesa (wersja iteracyjna z resztą z dzielenia)
int nwd(int a, int b) {
  while (b != 0) {
      int temp = b;
      b = a % b;
      a = temp;
  }
  // Zauważ, że jeśli na start b = 0, pętla się nie wykona i zwrócimy a.
  // Daje to poprawny wynik NWD(A, 0) = A.
  return a;
}

int main() {
  ifstream file("dron.txt");
  int A, B;
  int count = 0;
  
  // Wczytywanie pliku para po parze dopóki są dane
  while (file >> A >> B) {
      int B_abs = abs(B); // Wartość bezwzględna
      
      if (nwd(A, B_abs) > 1) {
          count++;
      }
  }
  
  cout << "Odpowiedz do zadania 3.1: " << count << endl;
  return 0;
}

def solve_3_2():
  points = []
  curr_x, curr_y = 0, 0
  
  # KROK 1: Generowanie punktów
  with open('dron.txt', 'r') as file:
      for line in file:
          dx, dy = map(int, line.split())
          curr_x += dx
          curr_y += dy
          points.append((curr_x, curr_y))
          
  # KROK 2: Podpunkt A
  count_inside = 0
  for x, y in points:
      if 0 < x < 5000 and 0 < y < 5000:
          count_inside += 1
          
  print(f"a) {count_inside}")
  
  # KROK 3: Podpunkt B
  n = len(points)
  # 3 zagnieżdżone pętle dla wyboru 3 punktów (i < j < k)
  for i in range(n):
      for j in range(i + 1, n):
          for k in range(j + 1, n):
              xi, yi = points[i]
              xj, yj = points[j]
              xk, yk = points[k]
              
              # Sprawdzamy czy punkt j jest środkiem
              if xi + xk == 2 * xj and yi + yk == 2 * yj:
                  print(f"b) ({xi}, {yi}), ({xj}, {yj}), ({xk}, {yk})")
                  return # Przerywamy po znalezieniu pierwszej trójki

solve_3_2()

#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

struct Point {
  long long x;
  long long y;
};

int main() {
  ifstream file("dron.txt");
  vector<Point> points;
  long long dx, dy;
  long long curr_x = 0, curr_y = 0;
  
  // KROK 1: Wczytywanie i generowanie współrzędnych
  while (file >> dx >> dy) {
      curr_x += dx;
      curr_y += dy;
      points.push_back({curr_x, curr_y});
  }
  
  // KROK 2: Podpunkt A
  int count_inside = 0;
  for (const auto& p : points) {
      if (p.x > 0 && p.x < 5000 && p.y > 0 && p.y < 5000) {
          count_inside++;
      }
  }
  cout << "a) " << count_inside << endl;
  
  // KROK 3: Podpunkt B
  int n = points.size();
  for (int i = 0; i < n; ++i) {
      for (int j = i + 1; j < n; ++j) {
          for (int k = j + 1; k < n; ++k) {
              // Warunek środka odcinka: 2 * srodek = poczatek + koniec
              if (2 * points[j].x == points[i].x + points[k].x && 
                  2 * points[j].y == points[i].y + points[k].y) {
                  
                  cout << "b) (" << points[i].x << ", " << points[i].y << "), ("
<< points[j].x << ", " << points[j].y << "), ("
<< points[k].x << ", " << points[k].y << ")" << endl;
                  return 0; // Znaleziono trójkę, kończymy
              }
          }
      }
  }
  
  return 0;
}

• Opcja A opisuje działanie oprogramowania typu Ransomware lub narzędzi kryptograficznych.
• Opcja B to definicja menedżera haseł (np. KeePass, 1Password).
• Opcja C odnosi się do tokenów bezpieczeństwa lub aplikacji uwierzytelniających (np. Google Authenticator).
• Opcja D to poprawna definicja keyloggera, czyli złośliwego oprogramowania (bądź urządzenia sprzętowego), które w tajemnicy przed użytkownikiem nagrywa wszystko, co ten wpisuje na klawiaturze.

• 1. kolumna: $1 + 1 = 10_2$. Zapisano 0 na dole, a 1 przechodzi dalej. Zgadza się.
• 2. kolumna: Mamy górne okienko, dolne 1 oraz przeniesione 1. Wynik na dole to 1.
  Działanie: [ ] + 1 + 1 = ...1. Musi to być 3 (czyli $11_2$), by zapisać 1. Stąd górne okienko to 1. Przenosimy 1.
• 3. kolumna: Górne 0, dolne 1, przeniesione 1.
  Działanie: $0 + 1 + 1 = 10_2$. Dolne okienko to 0. Przenosimy 1.
• 4. kolumna: Górne 1, dolne 0, przeniesione 1.
  Działanie: $1 + 0 + 1 = 10_2$. Dolne okienko to 0. Przenosimy 1.

• 5. kolumna: Górne 1, dolne 1, przeniesione 1. $1 + 1 + 1 = 11_2$. Na dole zapisano 1, a 1 przechodzi dalej. Zgadza się.
• 6. kolumna: Górne 0, dolne okienko, przeniesione 1. Wynik ma wynosić 0.
  Działanie: 0 + [ ] + 1 = ...0. Aby z jedynki zrobić 0, musimy otrzymać $10_2$. Dolne okienko to 1. Przenosimy 1.
• 7. kolumna: Górne 1, dolne 0, przeniesione 1. $1 + 0 + 1 = 10_2$. Zapisano 0, 1 przechodzi dalej. Zgadza się.
• 8. kolumna: Górne 0, dolne 0, przeniesione 1. $0 + 0 + 1 = 1_2$. Zapisano 1, brak przeniesienia (czyli przenosimy 0).

• 9. kolumna: Górne okienko, dolne 1, brak przeniesienia. Wynik wynosi 1.
  Działanie: [ ] + 1 + 0 = 1_2. Stąd górne okienko to 0. Brak przeniesienia.
• 10. kolumna: Górne 1, dolne 1. $1 + 1 = 10_2$. Zapisano 0, przenosimy 1. Zgadza się.
• 11. kolumna: Górne 1, brak dolnego (0), przeniesione 1.
  Działanie: $1 + 0 + 1 = 10_2$. W okienku wyniku na dole zapisujemy 0. Przenosimy 1.
• 12. kolumna: Przeniesiona 1 ląduje na samym przodzie wyniku. Zgadza się.

• Łączna masa ładunków drona: To po prostu suma wszystkich wartości w kolumnie masa [kg].
• Łączna masa wydobytego martianeum: Musimy wyliczyć dla każdego wiersza masę samego minerału. Pamiętamy o kluczowym warunku: minerał jest wydobywany tylko wtedy, gdy jego zawartość wynosi co najmniej 1%. Jeśli warunek jest spełniony, masa wydobyta to masa_ładunku * (zawartość_w_procentach / 100).

1. Otwórz plik martianeum.txt w Excelu. Kreator importu automatycznie rozdzieli kolumny po znaku tabulacji.
2. Pierwsza odpowiedź (łączna masa) to po prostu suma kolumny C. W pustej komórce wpisz:
   =SUMA(C2:C10000).
3. Aby obliczyć wydobyty minerał, w kolumnie E (np. w komórce E2) stwórz formułę warunkową:
   =JEŻELI(D2>=1; C2*(D2/100); 0)
4. Przeciągnij formułę z E2 do samego dołu tabeli.
5. Druga odpowiedź to suma nowo utworzonej kolumny E. Wpisz:
   =SUMA(E2:E10000).

def solve_6_1():
  total_mass = 0.0
  extracted_martianeum = 0.0
  
  # Pomijamy pierwszy wiersz, bo zawiera nagłówki
  with open('martianeum.txt', 'r') as file:
      next(file) 
      
      for line in file:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              # Zamiana polskich przecinków na kropki
              mass_str = parts[2].replace(',', '.')
              percent_str = parts[3].replace(',', '.')
              
              mass = float(mass_str)
              percent = float(percent_str)
              
              # Dodajemy do całkowitej masy dronów
              total_mass += mass
              
              # Dodajemy wydobyty minerał, tylko gdy zawartość >= 1%
              if percent >= 1.0:
                  extracted_martianeum += mass * (percent / 100.0)
                  
  # Zaokrąglamy wyniki dla czytelności i uniknięcia błędów float
  print(f"6.1. Łączna masa ładunków: {round(total_mass, 2)} kg")
  print(f"6.1. Wydobyte martianeum: {round(extracted_martianeum, 4)} kg")

solve_6_1()

1. Zaznacz całą tabelę z danymi z pliku martianeum.txt.
2. Przejdź do zakładki Wstawianie i wybierz Tabela przestawna.
3. W polu roboczym tabeli przestawnej przeciągnij nazwa_obszaru do okienka Wiersze.
4. Przeciągnij pole masa [kg] do okienka Wartości.
5. Domyślnie Excel zsumuje masy. Kliknij na to pole w okienku wartości, wybierz Ustawienia pola wartości i zmień operację z "Suma" na Średnia.
6. Kliknij prawym przyciskiem myszy na dowolną wyliczoną średnią w tabeli, wybierz Sortuj $\rightarrow$ Sortuj od najmniejszych do największych.

def solve_6_2():
  area_mass = {}
  area_count = {}
  
  with open('martianeum.txt', 'r') as file:
      next(file) # Pominięcie nagłówka
      for line in file:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              area = parts[1]
              mass = float(parts[2].replace(',', '.'))
              
              # Agregacja danych
              area_mass[area] = area_mass.get(area, 0) + mass
              area_count[area] = area_count.get(area, 0) + 1
              
  # Szukanie minimum
  min_avg = float('inf')
  min_area = ""
  
  for area in area_mass:
      avg = area_mass[area] / area_count[area]
      if avg < min_avg:
          min_avg = avg
          min_area = area
          
  print(f"6.2. Obszar z najmniejszą średnią masą: {min_area}")

solve_6_2()

1. Utwórz nową kolumnę obok danych (np. kolumnę E) i nazwij ją Początek_okresu.

2. Wpisz poniższą formułę w komórkę E2:

   
   

   =A2 - RESZTA(A2 - DATA(2033;3;3); 7)

   Jak to działa? Odejmujemy datę bieżącą (A2) od daty startowej. RESZTA(różnica; 7) mówi nam, ile dni minęło od początku bieżącego 7-dniowego bloku. Odejmując tę resztę od daty w A2, "cofamy się" dokładnie do pierwszego dnia tego konkretnego 7-dniowego okresu.

3. Przeciągnij formułę do końca tabeli. Koniecznie upewnij się, że format nowej kolumny to "Data krótkie".
4. Wstaw Tabelę przestawną. W Wierszach umieść nowe pole Początek_okresu, a w okienku Wartości pole masa [kg] (z operacją Suma).
5. Posortuj wyliczone sumy od największej do najmniejszej – na samej górze znajdziesz szukaną datę początku okresu oraz maksymalną masę.

def solve_6_3():
  with open('martianeum.txt', 'r') as file:
      next(file) # Pomijamy nagłówki
      # Wczytujemy wszystkie linie do listy
      lines = [line.strip().split('\t') for line in file if line.strip()]
      
  max_sum = 0.0
  best_start_date = ""
  
  # Skaczemy co 7 wierszy
  for i in range(0, len(lines), 7):
      # Pobieramy 7-elementowy blok wierszy
      chunk = lines[i:i+7]
      
      # Sumujemy masę z kolumny o indeksie 2 dla całego bloku
      current_sum = sum(float(row[2].replace(',', '.')) for row in chunk)
      
      if current_sum > max_sum:
          max_sum = current_sum
          # Datą początku bloku jest data z jego pierwszego wiersza
          best_start_date = chunk[0][0] 
          
  print(f"6.3. Największa łączna masa: {round(max_sum, 2)} kg")
  print(f"6.3. Data początku okresu:   {best_start_date}")

solve_6_3()

1. Obok głównej tabeli stwórz nową kolumnę i nazwij ją np. Rok.
2. W drugim wierszu wpisz formułę: =ROK(A2) (zakładając, że daty są w kolumnie A).
3. Skopiuj formułę do samego dołu tabeli.

1. Zaznacz całą tabelę (łącznie z nową kolumną Rok) i wstaw Tabelę przestawną.
2. Przeciągnij pole nazwa_obszaru do okienka Wiersze (to będzie nasza oś X).
3. Przeciągnij pole Rok do okienka Kolumny (to będzie nasza legenda).
4. Przeciągnij dowolne pole tekstowe (np. nazwa_obszaru) do okienka Wartości. Excel automatycznie użyje operacji Licznik (Zlicz), co da nam ilość przewozów.

1. Kliknij w dowolne miejsce wewnątrz tabeli przestawnej.
2. Z górnego menu wybierz Wstawianie, następnie przejdź do sekcji wykresów kolumnowych i wybierz Skumulowany kolumnowy (drugi od lewej w grupie 2D, to ten, w którym słupki nakładają się na siebie tworząc jedną wieżę).
3. Formatowanie: Skorzystaj z plusa obok wykresu (lub zakładki Projekt), aby dodać Tytuł osi. Poziomą oś nazwij "nazwy obszarów", a pionową "liczba przewozów ładunku". Dodaj również ogólny Tytuł wykresu (np. "Przewozy ładunków w latach 2033-2038"). Upewnij się, że z boku lub na dole widoczna jest legenda z latami.

• Codziennie do magazynu trafia to, co wydobyto (obliczyliśmy to już w zadaniu 6.1).
• Na koniec dnia sprawdzamy: czy w magazynie jest $\ge 100$ kg?
• Jeśli tak, to odejmujemy 100 kg (wysyłka) i notujemy ten fakt. Reszta przechodzi na kolejny dzień.
• Jeśli nie, cała zawartość po prostu przechodzi na kolejny dzień.

1. Kolumna F: Stan przed wysyłką.
   W pierwszym wierszu (F2) wpisz po prostu: =E2.
   W następnym (F3) wpisz: =G2 + E3 (czyli to, co zostało wczoraj + dzisiejsze wydobycie). Przeciągnij F3 w dół.
2. Kolumna G: Stan po wysyłce (na jutro).
   Jeśli mamy 100 kg lub więcej, wysyłamy 100 kg. Wpisz w G2:
   =JEŻELI(F2>=100; F2-100; F2) i przeciągnij w dół.
3. Kolumna H: Czy był transport?.
   Wpisz w H2: =JEŻELI(F2>=100; 1; 0) i przeciągnij w dół.

def solve_6_5():
  storage = 0.0
  shipment_count = 0
  shipment_dates = []
  
  with open('martianeum.txt', 'r') as file:
      next(file) # Pomijamy nagłówki
      for line in file:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              date = parts[0]
              mass = float(parts[2].replace(',', '.'))
              percent = float(parts[3].replace(',', '.'))
              
              # Dodajemy do magazynu, jeśli zawartość >= 1%
              if percent >= 1.0:
                  storage += mass * (percent / 100.0)
                  
              # Koniec dnia: sprawdzamy czy możemy wysłać
              if storage >= 100.0:
                  storage -= 100.0
                  shipment_count += 1
                  shipment_dates.append(date)
                  
  print(f"6.5. Liczba wysłanych ładunków: {shipment_count}")
  if shipment_count > 0:
      print(f"6.5. Data pierwszego transportu: {shipment_dates[0]}")
      print(f"6.5. Data ostatniego transportu: {shipment_dates[-1]}")

solve_6_5()

1. Zaimportuj wszystkie trzy pliki tekstowe do programu Access jako nowe tabele. Pamiętaj o zaznaczeniu opcji "Pierwszy wiersz zawiera nazwy pól".
2. Przejdź do zakładki Narzędzia bazy danych i otwórz Relacje.

3. Połącz tabele odpowiednimi kluczami obcymi:

   • Pole nr_lazika z tabeli laziki połącz z polem nr_lazika w tabeli pomiary.
   • Pole kod_obszaru z tabeli obszary połącz z polem kod_obszaru w tabeli pomiary.

• Ograniczenie do 100 metrów: Dodaj pole glebokosc z tabeli pomiary. Odznacz je (nie musi być widoczne w wyniku), a w wierszu Kryteria wpisz <=100.

• Nazwa obszaru: Dodaj pole nazwa_obszaru z tabeli obszary. To po tym polu będziemy grupować wyniki.

• Sumowanie ilości wody: Dodaj pole ilosc z tabeli pomiary. Włącz opcję Sumy w górnym menu (ikona Sigmy $\Sigma$). W wierszu Suma pod polem ilosc zmień "Grupuj według" na Suma. Sortuj to pole Malejąco.

SELECT TOP 1 obszary.nazwa_obszaru, SUM(pomiary.ilosc) AS SumaWody
FROM obszary INNER JOIN pomiary 
ON obszary.kod_obszaru = pomiary.kod_obszaru
WHERE pomiary.glebokosc <= 100
GROUP BY obszary.nazwa_obszaru
ORDER BY SUM(pomiary.ilosc) DESC;

def solve_7_1():
  # 1. Wczytanie mapowania kod -> nazwa obszaru
  obszary_map = {}
  with open('obszary.txt', 'r') as f:
      next(f) # Pominięcie nagłówka
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 2:
              obszary_map[parts[0]] = parts[1]

  # 2. Agregacja ilości wody na obszarach (głębokość <= 100)
  woda_na_obszarach = {}
  with open('pomiary.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 6:
              kod_obszaru = parts[2]
              glebokosc = int(parts[4])
              ilosc = int(parts[5])
              
              # Warunek z zadania
              if glebokosc <= 100:
                  nazwa = obszary_map.get(kod_obszaru, "Nieznany")
                  woda_na_obszarach[nazwa] = woda_na_obszarach.get(nazwa, 0) + ilosc

  # 3. Znalezienie obszaru z maksymalną ilością wody
  najlepszy_obszar = max(woda_na_obszarach, key=woda_na_obszarach.get)
  max_wody = woda_na_obszarach[najlepszy_obszar]
  
  print(f"7.1. Obszar: {najlepszy_obszar} (łącznie {max_wody} m3 wody)")

solve_7_1()

1. Przejdź do Projektu kwerendy i dodaj tabele laziki oraz pomiary.
2. Dodaj pole nazwa_lazika z tabeli laziki.
3. Dodaj pole data_pomiaru z tabeli pomiary dwukrotnie.
4. Włącz opcję Sumy (ikona $\Sigma$).
5. Dla pierwszego pola data_pomiaru ustaw podsumowanie na Minimum (to data pierwszego pomiaru).
6. Dla drugiego pola data_pomiaru ustaw podsumowanie na Maksimum (to data ostatniego pomiaru).
7. W czwartej, pustej kolumnie stwórz własne pole obliczeniowe wpisując:
   Czas_trwania: Max([data_pomiaru]) - Min([data_pomiaru]).
8. Dla tego pola ustaw sortowanie na Malejące. Pierwszy wiersz wyniku to szukany łazik oraz jego skrajne daty.

SELECT TOP 1 laziki.nazwa_lazika, Min(pomiary.data_pomiaru) AS Pierwszy_pomiar, Max(pomiary.data_pomiaru) AS Ostatni_pomiar
FROM laziki INNER JOIN pomiary ON laziki.nr_lazika = pomiary.nr_lazika
GROUP BY laziki.nazwa_lazika
ORDER BY Max(pomiary.data_pomiaru) - Min(pomiary.data_pomiaru) DESC;

from datetime import datetime

def solve_7_2():
  # 1. Mapowanie numeru łazika na jego nazwę
  laziki_map = {}
  with open('laziki.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 2:
              laziki_map[parts[0]] = parts[1]

  # 2. Gromadzenie dat pomiarów dla każdego łazika
  daty_pomiarow = {}
  with open('pomiary.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 2:
              nr_lazika = parts[0]
              data_str = parts[1]
              data_obj = datetime.strptime(data_str, "%Y-%m-%d")
              
              if nr_lazika not in daty_pomiarow:
                  daty_pomiarow[nr_lazika] = []
              daty_pomiarow[nr_lazika].append(data_obj)

  # 3. Szukanie najdłuższego okresu
  max_roznica = -1
  najlepszy_lazik_nr = ""
  min_data_wynik = None
  max_data_wynik = None

  for nr_lazika, daty in daty_pomiarow.items():
      min_data = min(daty)
      max_data = max(daty)
      roznica = (max_data - min_data).days
      
      if roznica > max_roznica:
          max_roznica = roznica
          najlepszy_lazik_nr = nr_lazika
          min_data_wynik = min_data
          max_data_wynik = max_data

  nazwa = laziki_map.get(najlepszy_lazik_nr, "Nieznany")
  
  print(f"7.2. Łazik: {nazwa}")
  print(f"7.2. Pierwszy pomiar: {min_data_wynik.strftime('%Y-%m-%d')}")
  print(f"7.2. Ostatni pomiar: {max_data_wynik.strftime('%Y-%m-%d')}")

solve_7_2()

1. Kwerenda 1 (Wykluczająca): Tworzymy kwerendę z tabel laziki oraz pomiary. Wyciągamy z niej pole kod_obszaru. Dodajemy warunek porównujący rok z daty pomiaru z rokiem wysłania: Rok([data_pomiaru]) = [rok_wyslania]. Zapisujemy tę kwerendę jako np. "Obszary_Wykluczone".

2. Kwerenda 2 (Główna): Wykorzystujemy Kreatora kwerend wyszukujących niepasujące dane (lub tworzymy złączenie typu LEFT JOIN). Łączymy tabelę obszary z naszą kwerendą "Obszary_Wykluczone". Wybieramy obszary z tabeli głównej, dla których połączone pole w kwerendzie wykluczającej Is Null (czyli jest puste).

SELECT nazwa_obszaru
FROM obszary
WHERE kod_obszaru NOT IN (
  SELECT pomiary.kod_obszaru 
  FROM pomiary INNER JOIN laziki ON pomiary.nr_lazika = laziki.nr_lazika 
  WHERE Year(pomiary.data_pomiaru) = laziki.rok_wyslania
);

def solve_7_3():
  # 1. Pobranie roku wysłania dla każdego łazika
  rok_wyslania_map = {}
  with open('laziki.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 3:
              rok_wyslania_map[parts[0]] = parts[2] # jako string, np. "2050"

  # 2. Zbudowanie zbioru obszarów "wykluczonych"
  obszary_wykluczone = set()
  with open('pomiary.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 3:
              nr_lazika = parts[0]
              rok_pomiaru = parts[1][:4] # wycięcie pierwszych 4 znaków (YYYY)
              kod_obszaru = parts[2]
              
              # Jeśli rok pomiaru jest równy rokowi wysłania z Ziemi
              if rok_pomiaru == rok_wyslania_map.get(nr_lazika):
                  obszary_wykluczone.add(kod_obszaru)

  # 3. Wypisanie nazw obszarów, których nie ma w zbiorze wykluczonych
  print("7.3. Obszary spełniające warunek:")
  with open('obszary.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 2:
              kod_obszaru = parts[0]
              nazwa_obszaru = parts[1]
              
              if kod_obszaru not in obszary_wykluczone:
                  print(f"- {nazwa_obszaru}")

solve_7_3()

• Półkula południowa: LIKE "*S, *" (kończy się na S przed przecinkiem)
• Półkula północna: LIKE "*N, *" (kończy się na N przed przecinkiem)

1. Kwerenda Północ: Wyciągnij z tabeli pomiary pole nr_lazika z kryterium dla współrzędnych LIKE "*N, *". Zgrupuj wyniki, aby uniknąć duplikatów.
2. Kwerenda Południe: Zrób to samo, ale z kryterium LIKE "*S, *".
3. Kwerenda Główna: Dodaj tabelę laziki, Kwerendę Północ oraz Kwerendę Południe. Połącz je wszystkie relacjami poprzez pole nr_lazika (INNER JOIN). Dla pola wsp_ladowania z tabeli laziki ustaw kryterium LIKE "*S, *". Wyświetl pole nazwa_lazika.

SELECT DISTINCT laziki.nazwa_lazika
FROM (laziki 
INNER JOIN pomiary AS p1 ON laziki.nr_lazika = p1.nr_lazika)
INNER JOIN pomiary AS p2 ON laziki.nr_lazika = p2.nr_lazika
WHERE laziki.wsp_ladowania LIKE '*S,*'
AND p1.wspolrzedne LIKE '*N,*'
AND p2.wspolrzedne LIKE '*S,*';

def solve_7_4():
  # 1. Odczytanie łazików, które wylądowały na południu (S)
  laziki_S = {}
  with open('laziki.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              nr_lazika = parts[0]
              nazwa = parts[1]
              wsp_ladowania = parts[3]
              
              # Sprawdzenie czy przed przecinkiem jest litera S
              if 'S,' in wsp_ladowania:
                  laziki_S[nr_lazika] = nazwa

  # 2. Rejestrowanie półkul, na których dany łazik robił pomiary
  pomiary_N = set()
  pomiary_S = set()
  
  with open('pomiary.txt', 'r') as f:
      next(f)
      for line in f:
          parts = line.strip().split('\t')
          if len(parts) >= 4:
              nr_lazika = parts[0]
              wspolrzedne = parts[3]
              
              if 'N,' in wspolrzedne:
                  pomiary_N.add(nr_lazika)
              if 'S,' in wspolrzedne:
                  pomiary_S.add(nr_lazika)

  # 3. Wypisanie wyniku: przecięcie wszystkich trzech zbiorów warunków
  print("7.4. Łaziki spełniające warunki:")
  for nr, nazwa in laziki_S.items():
      if nr in pomiary_N and nr in pomiary_S:
          print(f"- {nazwa}")

solve_7_4()

1. Producent łączy się z tabelą Laziki kluczem kod_producenta.
2. Laziki łączą się z tabelą Pomiary kluczem nr_lazika.
3. Pomiary łączą się z tabelą Obszary kluczem kod_obszaru.

• Unikalność: W poleceniu podkreślono, że nazwy producentów nie mogą się powtarzać. To wymusza użycie słowa kluczowego DISTINCT tuż po instrukcji SELECT.

• Rok 2060: Ekstrakcję roku z pola zawierającego pełną datę najlepiej zrealizować standardową funkcją YEAR(nazwa_pola). Alternatywnie poprawny jest również zapis z ucięciem daty: LIKE '2060-*'.

• Nazwa obszaru: Warunek tekstowy = 'Arcadia' w klauzuli WHERE.

SELECT DISTINCT Producent.nazwa
FROM ((Producent
INNER JOIN laziki ON Producent.kod_producenta = laziki.kod_producenta)
INNER JOIN pomiary ON laziki.nr_lazika = pomiary.nr_lazika)
INNER JOIN obszary ON pomiary.kod_obszaru = obszary.kod_obszaru
WHERE obszary.nazwa_obszaru = 'Arcadia'
AND YEAR(pomiary.data_pomiaru) = 2060;