{"paper":{"id":"informatyka-2018-maj-matura-rozszerzona","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","variant":null,"exam_pdf":"informatyka-2018-maj-matura-rozszerzona/informatyka-2018-maj-matura-rozszerzona.pdf","key_pdf":"informatyka-2018-maj-matura-rozszerzona-odpowiedzi/informatyka-2018-maj-matura-rozszerzona-odpowiedzi.pdf","question_count":23,"source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},"questions":[{"id":"informatyka-2018-maj-matura-rozszerzona/zad/1","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"1","points":null,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 1. Analiza algorytmu\nRozważamy następujący algorytm:\nDane:\nn - liczba całkowita dodatnia\nWynik:\np - liczba całkowita dodatnia\np ← 1\nq ← n\ndopóki p < q wykonuj\ns ← (p+q) div 2\n(*) jeżeli s*s*s < n wykonaj\np ← s+1\nw przeciwnym wypadku\nq ← s\nUwaga: zapis div oznacza dzielenie całkowite.","answer":null,"answer_text":null,"solution":null,"image":"img/informatyka-2018-maj-matura-rozszerzona/zad-1.webp","solution_image":null,"topics":null,"page_from":2,"source":"ocr","answer_source":null,"answer_text_source":null,"solution_source":null,"text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/1.1","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"1.1","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 1.1. (0-3)\nPodaj wynik działania algorytmu dla wskazanych w tabeli wartości n.\nn\np\n28\n64\n80\nMiejsce na obliczenia.\nMIN_1R","answer":null,"answer_text":"Zadanie 1.1. (0-3)\nWymagania ogólne\nWymagania szczegółowe\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji […] z zastosowaniem\npodejścia algorytmicznego.\n5. Rozwiązywanie problemów\ni podejmowanie decyzji […], stosowanie\npodejścia algorytmicznego.\nZdający:\n11) opisuje podstawowe algorytmy\ni stosuje:\na) algorytmy na liczbach całkowitych,\n16) opisuje własności algorytmów na\npodstawie ich analizy;\n17) ocenia zgodność algorytmu ze\nspecyfikacją problemu;\n18) oblicza liczbę operacji wykonywanych\nprzez algorytm.\nSchemat punktowania\n3 p. - za prawidłową odpowiedź w trzech wierszach.\n2 p. - za prawidłową odpowiedź w dwóch wierszach.\n1 p. - za prawidłową odpowiedź w jednym wierszu.\n0 p. - za podanie odpowiedzi błędnej albo brak odpowiedzi.\nPoprawna odpowiedź\nn\np\n28\n4\n64\n4\n80\n5","solution":"## Poprawna odpowiedź\n\n| n | p |\n| 28 | **4** |\n| 64 | **4** |\n| 80 | **5** |\n\n## Sposób 1 - interpretacja algorytmu\n\n**Algorytm to wyszukiwanie binarne najmniejszej liczby p takiej, że p³ ≥ n.**\n\nInicjalizacja: p = 1, q = n. Pętla `while p < q` w każdej iteracji:\n- s = (p+q) div 2\n- Jeśli s³ < n → szukamy w prawej części: p = s+1\n- W przeciwnym razie → szukamy w lewej części: q = s\n\nKoniec gdy p = q. Wynik to **p = ⌈∛n⌉** (sufit pierwiastka sześciennego).\n\n## Sposób 2 - symulacja krok po kroku\n\n### n = 28\nSzukamy p takiego, że p³ ≥ 28. Sprawdzamy: 3³=27 < 28, 4³=64 ≥ 28 → **p = 4**.\n\n| iter | p | q | s | s³ | s³<28? | nowe p | nowe q |\n| 1 | 1 | 28 | 14 | 2744 | NIE | 1 | 14 |\n| 2 | 1 | 14 | 7 | 343 | NIE | 1 | 7 |\n| 3 | 1 | 7 | 4 | 64 | NIE | 1 | 4 |\n| 4 | 1 | 4 | 2 | 8 | TAK | 3 | 4 |\n| 5 | 3 | 4 | 3 | 27 | TAK | 4 | 4 |\n\nKończymy: p = q = **4** ✓.\n\n### n = 64\n4³ = 64 ≥ 64 ✓ → **p = 4**.\n\n| iter | p | q | s | s³ | s³<64? | p | q |\n| 1 | 1 | 64 | 32 | 32768 | NIE | 1 | 32 |\n| 2 | 1 | 32 | 16 | 4096 | NIE | 1 | 16 |\n| 3 | 1 | 16 | 8 | 512 | NIE | 1 | 8 |\n| 4 | 1 | 8 | 4 | 64 | NIE | 1 | 4 |\n| 5 | 1 | 4 | 2 | 8 | TAK | 3 | 4 |\n| 6 | 3 | 4 | 3 | 27 | TAK | 4 | 4 |\n\nKończymy: p = q = **4** ✓.\n\n### n = 80\n4³ = 64 < 80, 5³ = 125 ≥ 80 → **p = 5**.\n\n| iter | p | q | s | s³ | s³<80? | p | q |\n| 1 | 1 | 80 | 40 | 64000 | NIE | 1 | 40 |\n| 2 | 1 | 40 | 20 | 8000 | NIE | 1 | 20 |\n| 3 | 1 | 20 | 10 | 1000 | NIE | 1 | 10 |\n| 4 | 1 | 10 | 5 | 125 | NIE | 1 | 5 |\n| 5 | 1 | 5 | 3 | 27 | TAK | 4 | 5 |\n| 6 | 4 | 5 | 4 | 64 | TAK | 5 | 5 |\n\nKończymy: p = q = **5** ✓.\n\n## Sposób 3 - implementacja Python (weryfikacja)\n\n```python\ndef algorytm(n):\np, q = 1, n\nwhile p < q:\ns = (p + q) // 2\nif s ** 3 < n:\np = s + 1\nelse:\nq = s\nreturn p\n\nfor n in [28, 64, 80]:\nprint(f\"n={n}: p={algorytm(n)}\")\n\nWynik:\nn=28: p=4\nn=64: p=4\nn=80: p=5\n\n## Reference informatyczny - wyszukiwanie binarne\n\n> Reference - Wyszukiwanie binarne (binary search):\n> - Wyszukuje element/wartość spełniającą warunek monotoniczny.\n> - **Idea**: dzielimy przedział na pół, sprawdzamy środek, kierujemy się w prawą lub lewą połowę.\n> - **Złożoność**: O(log n).\n> - Tu zastosowanie: znalezienie minimalnego p takiego, że p³ ≥ n. Funkcja monotoniczna (p³ rośnie z p) - idealna dla binary search.\n>\n> Reference - Pierwiastek całkowity (integer cube root):\n> - `⌈∛n⌉` to najmniejsze całkowite p z p³ ≥ n.\n> - Można policzyć: `p = round(n ** (1/3))` lub szukaniem binarnym.\n> - Dla n = 64: ∛64 = 4 (idealny sześcian). Dla n = 27: ∛27 = 3.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 1.1, max 3 pkt):\n> - **3 pkt** - wszystkie 3 wartości p prawidłowe\n> - **2 pkt** - 2 prawidłowe\n> - **1 pkt** - 1 prawidłowa\n> - **0 pkt** - wszystkie błędne\n\n## Typowe pułapki\n\n- **Pomyłka warunku `<` vs `≤`** - wpływa na to, gdzie przesuwa się p i q. Tu jest `s³ < n` (ostry).\n- **div = dzielenie całkowite** - `(p+q) div 2` to floor; w Pythonie `//`, w C++ `/` dla int.\n- **Pomylenie warunku zakończenia** - kończymy gdy `p = q` (nie `p > q`).\n- **Niepoprawne s³** - uważać na 14³ = 2744, 32³ = 32768 (duże liczby, ale w int wystarczy).\n- **Pomyłka „64³” zamiast „4³”** - czytanie n jako liczby do potęgowania, podczas gdy potęgujemy s.\n- **Mylenie p i q** - p to dolna granica, q to górna; szukamy minimalnego.\n\n## Złożoność obliczeniowa\n\n- W każdej iteracji przedział `[p, q]` zmniejsza się o połowę.\n- Liczba iteracji: O(log n).\n- Każda iteracja: stały koszt (mnożenie + porównanie).\n- **Łącznie: O(log n)** operacji.","image":"img/informatyka-2018-maj-matura-rozszerzona/zad-1.1.webp","solution_image":null,"topics":null,"page_from":2,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/1.2","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"1.2","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 1.2. (0-2)\nPodaj najmniejszą oraz największą liczbę n, dla której wynikiem działania algorytmu będzie\np = 10.\nMiejsce na obliczenia.\nOdpowiedź: Najmniejsza liczba to , największa liczba to","answer":null,"answer_text":"Zadanie 1.2. (0-2)\nWymagania ogólne\nWymagania szczegółowe\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji […],\nz zastosowaniem podejścia algorytmicznego.\n5. Rozwiązywanie problemów\ni podejmowanie decyzji […] stosowanie\npodejścia algorytmicznego.\nZdający:\n11) opisuje podstawowe algorytmy\ni stosuje:\na) algorytmy na liczbach całkowitych,\n16) opisuje własności algorytmów na\npodstawie ich analizy;\n17) ocenia zgodność algorytmu ze\nspecyfikacją problemu;\n18) oblicza liczbę operacji wykonywanych\nprzez algorytm.\nSchemat punktowania\n2 p. - za dwie poprawne odpowiedzi.\n1 p. - za jedną poprawną odpowiedź.\n0 p. - za podanie odpowiedzi błędnej albo brak odpowiedzi.\nPoprawna odpowiedź\n730, 1000","solution":"## Poprawna odpowiedź\n\n**Najmniejsza n: 730**\n\n**Największa n: 1000**\n\n## Sposób 1 - wyprowadzenie z definicji p\n\nZ zadania 1.1 wiemy, że algorytm zwraca `p = ⌈∛n⌉` - najmniejsze p takie, że **p³ ≥ n**.\n\n**Aby p = 10:**\n- 10³ ≥ n musi być spełnione → n ≤ 1000.\n- 9³ < n musi być spełnione (inaczej wynik byłby 9 lub mniejszy) → n > 729 → n ≥ 730.\n\n**Zakres: 729 < n ≤ 1000**, czyli **n ∈ {730, 731, , 1000}**.\n\n- Najmniejsza n = **730**.\n- Największa n = **1000**.\n\n## Sposób 2 - weryfikacja na granicach\n\n### n = 729 → czy p = 9?\n9³ = 729 ≥ 729 ✓, więc p = 9 (nie 10). Granica dolna jest WYŁĄCZONA z zakresu p=10.\n\n### n = 730 → czy p = 10?\n9³ = 729 < 730, 10³ = 1000 ≥ 730. Najmniejsze p z p³ ≥ 730 to **10** ✓.\n\n### n = 1000 → czy p = 10?\n10³ = 1000 ≥ 1000 ✓, najmniejsze p z p³ ≥ 1000 to **10** ✓.\n\n### n = 1001 → czy p = 11?\n10³ = 1000 < 1001, 11³ = 1331 ≥ 1001. p = **11**, nie 10. Granica górna 1000 jest WŁĄCZONA do zakresu p=10.\n\n## Sposób 3 - implementacja Python (skanowanie)\n\n```python\ndef algorytm(n):\np, q = 1, n\nwhile p < q:\ns = (p + q) // 2\nif s ** 3 < n:\np = s + 1\nelse:\nq = s\nreturn p\n\nzakres_p10 = [n for n in range(700, 1010) if algorytm(n) == 10]\nprint(\"Min:\", min(zakres_p10)) # 730\nprint(\"Max:\", max(zakres_p10)) # 1000\nprint(\"Liczność:\", len(zakres_p10)) # 271\n\n## Reference informatyczny - sufit pierwiastka sześciennego\n\n> Reference - Sufit funkcji odwrotnej:\n> - Niech `f` będzie monotoniczna rosnąca i całkowitoliczbowa.\n> - Wartość `g(n) = min { k : f(k) ≥ n }` jest funkcją odwrotną \"od góry\".\n> - Dla f(k) = k³: g(n) = ⌈∛n⌉.\n> - **Zakres wartości n** dla którego g(n) = m: `f(m-1) < n ≤ f(m)`, czyli `(m-1)³ < n ≤ m³`.\n>\n> Reference - Sześciany potęg 10:\n> - 9³ = 729\n> - 10³ = 1000\n> - 11³ = 1331\n> - 12³ = 1728\n> - 13³ = 2197\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 1.2, max 2 pkt):\n> - **2 pkt** - obie wartości prawidłowe (min = 730, max = 1000)\n> - **1 pkt** - jedna prawidłowa\n> - **0 pkt** - błędne lub brak\n\n## Typowe pułapki\n\n- **Min = 729** - pomyłka. Dla n=729 wynik to p=9 (bo 9³=729 ≥ 729). Algorytm ma warunek `s³ < n` (ostry), więc 9³ = n daje p = 9.\n- **Max = 999** - pomyłka. Dla n=1000 wynik to p=10 (bo 10³=1000 ≥ 1000). 1000 JEST w zakresie.\n- **Pomylenie krańców otwartych i zamkniętych** - z definicji algorytmu zakres to (9³, 10³] = (729, 1000] = {730, , 1000}.\n- **Niepoprawne wyliczenie 9³ lub 10³** - proste, ale uczniowie potrafią się pomylić.\n\n## Złożoność obliczeniowa\n\n- Obliczenie zakresu: O(1) (wzór).\n- Liczność zakresu: 1000 - 730 + 1 = 271 liczb.","image":"img/informatyka-2018-maj-matura-rozszerzona/zad-1.2.webp","solution_image":null,"topics":null,"page_from":3,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/1.3","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"1.3","points":1,"ptype":"closed","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 1.3. (0-1)\nDokończ zdanie. Wybierz i zaznacz właściwą odpowiedź spośród podanych.\nDla każdej liczby całkowitej n > 1 instrukcja oznaczona w algorytmie symbolem (*)\nwykona się\nA. mniej niż 2·݈݋݃\nଶ݊ razy.\nB. więcej niż n/2, ale mniej niż n razy.\nC. więcej niż n+1, ale mniej niż 2n razy.\nD. więcej niż n2 razy.\nWypełnia\negzaminator\nNr zadania\n1.1.\n1.2.\n1.3.\nMaks. liczba pkt.\n3\n2\n1\nUzyskana liczba pkt.\nMIN_1R","answer":"A","answer_text":"Zadanie 1.3. (0-1)\nWymagania ogólne\nWymagania szczegółowe\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji […] z zastosowaniem\npodejścia algorytmicznego.\n5. Rozwiązywanie problemów\ni podejmowanie decyzji […], stosowanie\npodejścia algorytmicznego.\nZdający:\n11) opisuje podstawowe algorytmy\ni stosuje:\na) algorytmy na liczbach całkowitych,\n16) opisuje własności algorytmów na\npodstawie ich analizy;\n17) ocenia zgodność algorytmu ze\nspecyfikacją problemu;\n18) oblicza liczbę operacji wykonywanych\nprzez algorytm.\nSchemat punktowania\n1 p. - za poprawną odpowiedź.\n0 p. - za podanie odpowiedzi błędnej albo brak odpowiedzi.\nPoprawna odpowiedź:\nA","solution":"## Poprawna odpowiedź\n\n**A** - mniej niż 2·log₂n razy.\n\n## Sposób 1 - analiza algorytmu jako wyszukiwanie binarne\n\nAlgorytm z zadania 1.1 to **wyszukiwanie binarne** (binary search). Instrukcja (*) wykonuje się w każdej iteracji pętli `while p < q`.\n\n**Kluczowa obserwacja:** W każdej iteracji długość przedziału `[p, q]` zmniejsza się co najmniej o połowę:\n- Jeśli `s³ < n`: `p := s+1`, więc nowy przedział = `[s+1, q]`, długość ≤ q - s ≤ (q-p)/2.\n- Jeśli `s³ ≥ n`: `q := s`, więc nowy przedział = `[p, s]`, długość = s - p ≤ (q-p)/2.\n\nPoczątkowa długość przedziału = n - 1 ≈ n. Liczba iteracji potrzebnych do zmniejszenia z n do 1: **log₂(n)** iteracji.\n\n## Sposób 2 - empirycznie\n\n**Z symulacji w 1.1:**\n- n = 28: 5 iteracji. log₂(28) ≈ 4.81. 2·log₂(28) ≈ 9.6. **5 < 9.6** ✓\n- n = 64: 6 iteracji. log₂(64) = 6. 2·log₂(64) = 12. **6 < 12** ✓\n- n = 80: 6 iteracji. log₂(80) ≈ 6.32. 2·log₂(80) ≈ 12.6. **6 < 12.6** ✓\n\nLiczba iteracji jest **bliska log₂(n)**, więc na pewno mniejsza niż 2·log₂(n). Odpowiedź A.\n\n## Sposób 3 - eliminacja błędnych opcji\n\n### Opcja B: więcej niż n/2, mniej niż n razy\nDla n = 28: n/2 = 14, n = 28. Liczba iteracji = 5. 5 NIE jest > 14 → **B błędna**.\n\n### Opcja C: więcej niż n+1, mniej niż 2n razy\nDla n = 28: n+1 = 29. Liczba iteracji = 5. 5 NIE jest > 29 → **C błędna**.\n\n### Opcja D: więcej niż n² razy\nDla n = 28: n² = 784. Liczba iteracji = 5. 5 NIE jest > 784 → **D błędna**.\n\n### Opcja A: mniej niż 2·log₂n razy\nDla n = 28: 2·log₂(28) ≈ 9.6. Iteracji 5 < 9.6 → **A poprawna** ✓.\n\n## Reference informatyczny - złożoność wyszukiwania binarnego\n\n> Reference - Wyszukiwanie binarne:\n> - **Klasyczna złożoność**: O(log n).\n> - **Dokładna liczba iteracji**: ⌈log₂(n)⌉ + O(1).\n> - Każda iteracja zmniejsza długość przedziału co najmniej o połowę.\n> - Dla n = 1024: ~10 iteracji. Dla n = 10⁶: ~20 iteracji.\n>\n> Reference - Klasy złożoności:\n> | Klasa | Notacja | Przykład |\n> |-------|---------|----------|\n> | logarytmiczna | O(log n) | binary search, drzewo BST |\n> | liniowa | O(n) | wyszukiwanie liniowe |\n> | n log n | O(n log n) | mergesort, heapsort |\n> | kwadratowa | O(n²) | bubble sort, naiwne porównanie par |\n> | wykładnicza | O(2ⁿ) | brute-force kombinacji |\n>\n> Reference - Konwersja log:\n> - log₂(n) = ln(n) / ln(2) = log₁₀(n) / log₁₀(2) ≈ log₁₀(n) · 3.32\n> - log₂(1000) ≈ 10\n> - log₂(10⁶) ≈ 20\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 1.3, max 1 pkt):\n> - **1 pkt** - odpowiedź **A**\n> - **0 pkt** - błędna lub brak\n\n## Typowe pułapki\n\n- **Pomylenie z O(n)** - naiwna analiza \"pętla się powtarza\" sugeruje O(n), ale dzięki halving to O(log n).\n- **Niezrozumienie struktury binary search** - jeśli ktoś nie widzi, że to wyszukiwanie binarne, może pomyśleć, że (*) wykonuje się n razy (B).\n- **Mylenie 2·log₂n z log₂n²** - log₂(n²) = 2·log₂(n), więc obie formy są równoważne.\n- **Pomylenie podstawy logarytmu** - log₂ (binarny) vs log₁₀ (dziesiętny). Różnica stała, ale w wartości liczbowej ważne.\n\n## Złożoność obliczeniowa\n\n- Liczba iteracji pętli `while`: O(log n).\n- Instrukcja (*) wykonuje się raz na iterację: **O(log n)** razy.\n- Każda iteracja: stały koszt (mnożenie + porównanie + przypisanie).\n- **Łączna złożoność algorytmu: O(log n)** czas, O(1) pamięć.","image":"img/informatyka-2018-maj-matura-rozszerzona/zad-1.3.webp","solution_image":null,"topics":null,"page_from":3,"source":"ocr","answer_source":"ocr","answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/2","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"2","points":null,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 2. Krajobraz\nW pewnym paśmie górskim znajduje się n szczytów, które będziemy przedstawiać jako punkty\nw układzie kartezjańskim na płaszczyźnie. Wszystkie punkty leżą powyżej osi OX, tzn. druga\nwspółrzędna (y) każdego punktu jest dodatnia.\nW punkcie (0,0) stoi obserwator. Jeśli dwa szczyty A i B mają współrzędne (xA, yA) oraz\n(xB, yB), to mówimy, że:\n• szczyt A jest dla obserwatora widoczny na lewo od B, jeśli xA/yA < xB/yB;\n• szczyt B jest widoczny na lewo od A, jeśli xA/yA > xB/yB.\nWiemy, że żadne dwa szczyty nie leżą w jednej linii z obserwatorem, a zatem dla obserwatora\nte szczyty nie zasłaniają się nawzajem. Ilustrację przykładowego położenia szczytów można\nzobaczyć na poniższym rysunku:\nW tym przykładzie, patrząc od lewej do prawej strony, obserwator widzi kolejno szczyt D,\nszczyt A, szczyt B i szczyt C.\nWspółrzędne szczytów dane są w dwóch tablicach X[1 n] oraz Y[1 n] - szczyt numer i ma\nwspółrzędne (X[i], Y[i]).\nMIN_1R","answer":null,"answer_text":null,"solution":null,"image":"img/informatyka-2018-maj-matura-rozszerzona/zad-2.webp","solution_image":null,"topics":null,"page_from":4,"source":"ocr","answer_source":null,"answer_text_source":null,"solution_source":null,"text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/2.1","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"2.1","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 2.1. (0-2)\nNapisz algorytm (w pseudokodzie lub wybranym języku programowania), który znajdzie i poda\nwspółrzędne skrajnie lewego szczytu, tzn. widocznego dla obserwatora na lewo od wszystkich\npozostałych szczytów.\nSpecyfikacja:\nDane:\nn\n- liczba całkowita dodatnia\nX[1 n] - tablica liczb całkowitych\nY[1 n] - tablica liczb całkowitych dodatnich\nPara (X[i], Y[i]) to współrzędne jednego szczytu, i = 1, 2, …, n.\nŻadne dwa szczyty nie leżą w jednej linii z obserwatorem.\nWynik:\nx, y - współrzędne skrajnie lewego szczytu spośród tych opisanych w tablicach X i Y.\nAlgorytm\nWypełnia\negzaminator\nNr zadania\n2.1.\nMaks. liczba pkt.\n2\nUzyskana liczba pkt.\nMIN_1R","answer":null,"answer_text":"Zadanie 2.1. (0-2)\nWymagania ogólne\nWymagania szczegółowe\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji […] z zastosowaniem\npodejścia algorytmicznego.\n5. Rozwiązywanie problemów\ni podejmowanie decyzji […], stosowanie\npodejścia algorytmicznego.\nZdający:\n1) analizuje, modeluje i rozwiązuje sytuacje\nproblemowe z różnych dziedzin;\n2) stosuje podejście algorytmiczne do\nrozwiązywania problemu;\n4) dobiera efektywny algorytm do\nrozwiązania sytuacji problemowej\ni zapisuje go w wybranej notacji;\n5) posługuje się podstawowymi technikami\nalgorytmicznymi;\n11) opisuje podstawowe algorytmy\ni stosuje:\nb) algorytmy wyszukiwania\ni porządkowania (sortowania), np.:\n- jednoczesne znajdowanie największego\ni najmniejszego elementu w zbiorze:\nalgorytm naiwny i optymalny,\n- algorytmy sortowania ciągu liczb:\nbąbelkowy, przez wybór, przez wstawianie\nliniowe lub binarne, przez scalanie, szybki,\nkubełkowy.\nSchemat punktowania\n2 p. - za poprawny algorytm, w tym:\n1 p. - za prawidłową inicjalizację oraz konstrukcję pętli,\n1 p. - za zastosowanie prawidłowego porównania oraz wyznaczenie współrzędnych\nskrajnie lewego szczytu,\nUwaga: za prawidłowe porównanie i wyznaczenie poprawnej najmniejszej wartości ilorazu\nwspółrzędnych oraz poprawnego indeksu - 1 punkt,\n0 p. - za podanie odpowiedzi błędnej albo brak odpowiedzi.\nPrzykładowe rozwiązanie\nk ← 1\ndla i = 2, 3, , n wykonuj\njeżeli X[i]/Y[i] < X[k]/Y[k]\nk ← i\nx ←X[k], y←Y[k]","solution":"## Poprawna odpowiedź\n\n**Algorytm (pseudokod):**\n\nk ← 1\ndla i = 2, 3, , n wykonuj:\njeżeli X[i]/Y[i] < X[k]/Y[k]:\nk ← i\nx ← X[k]\ny ← Y[k]\n\nLub równoważnie (bez dzielenia, uważając na znak Y[i] > 0):\nk ← 1\ndla i = 2, 3, , n wykonuj:\njeżeli X[i] * Y[k] < X[k] * Y[i]:\nk ← i\nx ← X[k]\ny ← Y[k]\n\n## Sposób 1 - analiza problemu i klasyczny algorytm znajdowania minimum\n\n**Idea:** szczyt jest \"widoczny na lewo\" gdy ma najmniejszą wartość ilorazu `X[i]/Y[i]`. Szukamy więc **MINIMUM** spośród wszystkich ilorazów `X[i]/Y[i]`.\n\nAlgorytm to standardowe **wyszukiwanie minimum** w tablicy z modyfikacją w warunku porównania:\n1. Załóżmy, że minimum jest na pozycji 1 (k = 1).\n2. Iterujemy i od 2 do n.\n3. Jeśli iloraz pozycji i jest mniejszy niż na pozycji k → aktualizujemy k = i.\n4. Po pętli zwracamy współrzędne (X[k], Y[k]).\n\n## Sposób 2 - implementacja Python\n\n```python\ndef skrajnie_lewy(X, Y):\nn = len(X)\nk = 0 # indeks od 0 w Python\nfor i in range(1, n):\nif X[i] / Y[i] < X[k] / Y[k]:\nk = i\nreturn X[k], Y[k]\n\n# Przykład: D(-2,2), A(1,3), B(3,4), C(2,1)\nX = [-2, 1, 3, 2]\nY = [2, 3, 4, 1]\nprint(skrajnie_lewy(X, Y)) # (-2, 2) - szczyt D\n\n**Weryfikacja na przykładzie:**\n- D: -2/2 = **-1.0** (najmniejszy)\n- A: 1/3 ≈ 0.333\n- B: 3/4 = 0.75\n- C: 2/1 = 2.0\n\nMinimum = -1.0 → D ✓\n\n## Sposób 3 - C++ / Pascal\n\n**C++ (bezpieczna wersja bez dzielenia float):**\n```cpp\nvoid skrajnieLewy(int X[], int Y[], int n, int& x, int& y) {\nint k = 0;\nfor (int i = 1; i < n; i++) {\n// X[i]/Y[i] < X[k]/Y[k] <=> X[i]*Y[k] < X[k]*Y[i] (Y[i], Y[k] > 0)\nif ((long long)X[i] * Y[k] < (long long)X[k] * Y[i]) {\nk = i;\n}\n}\nx = X[k]; y = Y[k];\n}\n\n**Pascal:**\n```pascal\nprocedure SkrajnieLewy(X, Y: array of LongInt; n: Integer; var x, y: LongInt);\nvar i, k: Integer;\nbegin\nk := 0;\nfor i := 1 to n - 1 do begin\nif X[i] * Y[k] < X[k] * Y[i] then k := i;\nend;\nx := X[k]; y := Y[k];\nend;\n\n## Reference informatyczny - wyszukiwanie minimum\n\n> Reference - Wyszukiwanie minimum w tablicy:\n> - Klasyczny algorytm O(n) z jedną zmienną przechowującą bieżące minimum.\n> - Inicjalizacja: minimum = pierwszy element. Iteracja: porównanie z pozostałymi.\n> - Tutaj funkcja porównująca to `X[i]/Y[i]`, czyli **funkcja klucza** (analogicznie do `key=` w Python `min()`).\n>\n> Reference - Porównanie ilorazów bez dzielenia:\n> - `a/b < c/d` ⟺ `a·d < c·b` (gdy b, d > 0).\n> - Zaleta: brak błędów zaokrąglenia floating-point.\n> - Wada: ryzyko przepełnienia int (gdy `a·d` duże). W zadaniu Y > 0 zawsze, więc bezpiecznie.\n>\n> Reference - Interpretacja geometryczna:\n> - Iloraz X/Y to **kąt nachylenia** linii od obserwatora (0,0) do punktu (X, Y).\n> - Im mniejszy iloraz (ujemny dla X<0), tym bardziej w lewo.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 2.1, max 2 pkt):\n> - **1 pkt** za prawidłową inicjalizację (k = 1) ORAZ poprawną pętlę (dla i = 2, , n)\n> - **1 pkt** za prawidłowe porównanie (X[i]/Y[i] < X[k]/Y[k]) ORAZ wyznaczenie wyniku (x, y)\n> - **0 pkt** - odpowiedź błędna lub brak\n\n## Typowe pułapki\n\n- **Inicjalizacja k = 0** - w pseudokodzie CKE indeks startowy to 1, nie 0.\n- **Wyszukiwanie maksimum** zamiast minimum - szczyt skrajnie LEWY to NAJMNIEJSZY iloraz X/Y.\n- **Porównanie bezpośrednie X[i] < X[k]** - zła interpretacja \"lewo\" jako najmniejsze X. Trzeba uwzględnić Y.\n- **Zwracanie indeksu** zamiast współrzędnych - pytanie pyta o (x, y), nie o k.\n- **Float vs integer division** - w Pascal `/` zwraca Real, w C++ trzeba uważać przy int. Bezpieczniej mnożyć skrośnie.\n- **Pominięcie warunku Y > 0** - w zadaniu Y jest dodatnie (z definicji), więc krzyżowe mnożenie bezpieczne.\n\n## Złożoność obliczeniowa\n\n- Jedno przejście przez tablicę: **O(n)** porównań.\n- Pamięć: **O(1)** dodatkowa (tylko zmienna k).\n- **Optymalne** - nie da się znaleźć minimum w mniej niż O(n) (każdy element trzeba sprawdzić).","image":"img/informatyka-2018-maj-matura-rozszerzona/zad-2.1.webp","solution_image":null,"topics":null,"page_from":5,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/2.2","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"2.2","points":4,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 2.2. (0-4)\nNapisz algorytm (w pseudokodzie lub wybranym języku programowania), który przestawi\nelementy tablic X i Y tak, aby szczyty były uporządkowane w kolejności, w której obserwator\nwidzi je od lewej do prawej strony. Aby otrzymać maksymalną ocenę, Twój algorytm powinien\nmieć złożoność czasową kwadratową lub mniejszą.\nAlgorytm może używać wyłącznie instrukcji sterujących, operatorów arytmetycznych,\noperatorów logicznych, porównań i przypisań do zmiennych. Zabronione jest używanie funkcji\nbibliotecznych dostępnych w językach programowania.\nSpecyfikacja:\nDane:\nn\n- liczba całkowita dodatnia\nX[1 n] - tablica liczb całkowitych\nY[1 n] - tablica liczb całkowitych dodatnich\nPara (X[i], Y[i]) to współrzędne jednego szczytu, i = 1, 2, …, n.\nŻadne dwa szczyty nie leżą w jednej linii z obserwatorem.\nWynik:\nX[1 n], Y[1 n] - tablice zawierające współrzędne danych szczytów, uporządkowanych\nw kolejności, w której obserwator widzi je od lewej do prawej strony.\nAlgorytm\nMIN_1R","answer":null,"answer_text":"Zadanie 2.2. (0-4)\nWymagania ogólne\nWymagania szczegółowe\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji […] z zastosowaniem\npodejścia algorytmicznego.\n5. Rozwiązywanie problemów\ni podejmowanie decyzji […], stosowanie\npodejścia algorytmicznego.\nZdający:\n1) analizuje, modeluje i rozwiązuje sytuacje\nproblemowe z różnych dziedzin;\n2) stosuje podejście algorytmiczne do\nrozwiązywania problemu;\n4) dobiera efektywny algorytm do\nrozwiązania sytuacji problemowej\ni zapisuje go w wybranej notacji;\n5) posługuje się podstawowymi technikami\nalgorytmicznymi;\n11) opisuje podstawowe algorytmy\ni stosuje:\nb) algorytmy wyszukiwania\ni porządkowania (sortowania), np.:\n- algorytmy sortowania ciągu liczb:\nbąbelkowy, przez wybór, przez wstawianie\nliniowe lub binarne, przez scalanie, szybki,\nkubełkowy.\nSchemat punktowania\n4 p. - za poprawny algorytm, w tym:\n1 p. - za poprawną konstrukcję zewnętrznej pętli algorytmu sortowania,\n1 p. - za poprawną konstrukcję wewnętrznej pętli algorytmu sortowania,\n1 p. - za poprawne porównanie elementów,\n1 p. - za poprawną zamianę elementów uwzględniającą zarówno X, jak i Y.\nUwaga: za prawidłowe rozwiązanie o złożoności większej niż kwadratowa - maksymalnie 3\npunkty,\n0 p. - za podanie odpowiedzi błędnej albo brak odpowiedzi.\nUwaga: za każde inne niż przedstawione niżej, ale całkowicie poprawne rozwiązanie\nprzyznajemy maksymalną liczbę punktów.\nPrzykładowe rozwiązania\nPrzykładowe rozwiązanie 1. (sortowanie bąbelkowe):\npowtarzaj n-1 razy:\ndla i = 1, 2, , n-1\njeżeli X[i+1]/Y[i+1] < X[i]/Y[i]\nt = X[i]\nX[i] = X[i+1]\nX[i+1] = t\nt = Y[i]\nY[i] = Y[i+1]\nY[i+1] = t\nPrzykładowe rozwiązanie 2. (sortowanie przez wybór):\ndla i = 1, 2, , n-1:\nm = i\ndla j = i+1, i+2, , n\njeżeli X[j]/Y[j] < X[m]/Y[m]\nm = j\nt = X[i]\nX[i] = X[m]\nX[m] = t\nt = Y[i]\nY[i] = Y[m]\nY[m] = t\nPrzykładowe rozwiązanie 3. (sortowanie przez wstawianie):\ndla i = 2, 3, , n:\nj = i\ndopóki j>1 oraz X[j]/Y[j]<X[j-1]/Y[j-1]:\nt = X[j]\nX[j] = X[j-1]\nX[j-1] = t\nt = Y[j]\nY[j] = Y[j-1]\nY[j-1] = t\nj = j-1","solution":"## Poprawna odpowiedź\n\n**Algorytm - sortowanie bąbelkowe (bubble sort) wg ilorazu X[i]/Y[i]:**\n\npowtarzaj n-1 razy:\ndla i = 1, 2, , n-1 wykonuj:\njeżeli X[i+1]/Y[i+1] < X[i]/Y[i]:\nt ← X[i]\nX[i] ← X[i+1]\nX[i+1] ← t\nt ← Y[i]\nY[i] ← Y[i+1]\nY[i+1] ← t\n\n## Sposób 1 - sortowanie bąbelkowe\n\n**Idea:** w każdym przejściu \"bąbel\" (największy nieuporządkowany element) wędruje na koniec. Powtarzając n-1 razy, mamy gwarancję pełnego posortowania.\n\n**Klucz porównania:** `X[i]/Y[i]` (kąt nachylenia od obserwatora).\n\n**Zamiana par (X[i], Y[i]) ↔ (X[i+1], Y[i+1])** - zamieniamy OBIE tablice synchronicznie.\n\n## Sposób 2 - implementacja Python\n\n```python\ndef sortuj_szczyty(X, Y):\nn = len(X)\nfor k in range(n - 1):\nfor i in range(n - 1 - k): # optymalizacja: ostatnie k jest posortowane\nif X[i+1] / Y[i+1] < X[i] / Y[i]:\nX[i], X[i+1] = X[i+1], X[i]\nY[i], Y[i+1] = Y[i+1], Y[i]\nreturn X, Y\n\nX = [3, -2, 2, 1]\nY = [4, 2, 1, 3]\nprint(sortuj_szczyty(X, Y))\n# Posortowane: D(-2,2), A(1,3), B(3,4), C(2,1)\n# X = [-2, 1, 3, 2], Y = [2, 3, 4, 1]\n\n## Sposób 3 - sortowanie przez wybieranie (selection sort)\n\nAlternatywa - w każdym przejściu wybieramy minimum z reszty i wymieniamy z pozycją k:\n\ndla k = 1, 2, , n-1 wykonuj:\nmin_idx ← k\ndla i = k+1, , n wykonuj:\njeżeli X[i]/Y[i] < X[min_idx]/Y[min_idx]:\nmin_idx ← i\nzamień X[k] z X[min_idx]\nzamień Y[k] z Y[min_idx]\n\n**C++ (selection sort):**\n```cpp\nvoid sortuj(int X[], int Y[], int n) {\nfor (int k = 0; k < n - 1; k++) {\nint min_idx = k;\nfor (int i = k + 1; i < n; i++) {\n// X[i]/Y[i] < X[min_idx]/Y[min_idx]\nif ((long long)X[i] * Y[min_idx] < (long long)X[min_idx] * Y[i]) {\nmin_idx = i;\n}\n}\nif (min_idx != k) {\nint tx = X[k]; X[k] = X[min_idx]; X[min_idx] = tx;\nint ty = Y[k]; Y[k] = Y[min_idx]; Y[min_idx] = ty;\n}\n}\n}\n\n## Sposób 4 - sortowanie przez wstawianie (insertion sort)\n\ndla k = 2, , n wykonuj:\ni ← k\ndopóki i > 1 oraz X[i]/Y[i] < X[i-1]/Y[i-1] wykonuj:\nzamień X[i] z X[i-1]\nzamień Y[i] z Y[i-1]\ni ← i - 1\n\n**Pascal:**\n```pascal\nprocedure InsertionSort(var X, Y: array of LongInt; n: Integer);\nvar k, i, tx, ty: Integer;\nbegin\nfor k := 1 to n - 1 do begin\ni := k;\nwhile (i > 0) and (X[i] * Y[i-1] < X[i-1] * Y[i]) do begin\ntx := X[i]; X[i] := X[i-1]; X[i-1] := tx;\nty := Y[i]; Y[i] := Y[i-1]; Y[i-1] := ty;\ni := i - 1;\nend;\nend;\nend;\n\n## Reference informatyczny - sortowanie\n\n> Reference - Sortowanie bąbelkowe (bubble sort):\n> - Powtarza n-1 razy: porównuje sąsiadów i zamienia jeśli nieuporządkowani.\n> - **Złożoność**: O(n²) najgorszy/średni, O(n) najlepszy (z flagą \"swap\").\n> - **Pamięć**: O(1) dodatkowa (in-place).\n> - **Stabilność**: stabilny (nie zamienia równych).\n>\n> Reference - Sortowanie przez wybieranie (selection sort):\n> - W każdym przejściu wybiera minimum i zamienia z pozycją k.\n> - **Złożoność**: O(n²) zawsze.\n> - **Niestabilny** (zamiana minimum z pozycją k niszczy kolejność).\n>\n> Reference - Sortowanie przez wstawianie (insertion sort):\n> - Bierze kolejny element i wstawia go w odpowiednie miejsce wśród posortowanych.\n> - **Złożoność**: O(n²) najgorszy, O(n) najlepszy (dane już posortowane).\n> - **Stabilny**, **in-place**, **adaptywny**.\n>\n> Reference - Sortowanie z funkcją porównawczą (klucz):\n> - Zamiast `a[i] < a[j]` używamy `klucz(a[i]) < klucz(a[j])`.\n> - Tu: `klucz(i) = X[i] / Y[i]`.\n> - Synchronicznie zamieniamy WSZYSTKIE elementy powiązane z indeksem (tu X i Y).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 2.2, max 4 pkt):\n> - **1 pkt** - poprawna konstrukcja zewnętrznej pętli sortowania\n> - **1 pkt** - poprawna konstrukcja wewnętrznej pętli\n> - **1 pkt** - poprawne porównanie elementów (iloraz X/Y)\n> - **1 pkt** - poprawna zamiana elementów uwzględniająca **OBA** X i Y\n>\n> **Uwaga: za algorytm o złożoności WIĘKSZEJ niż kwadratowa - maksymalnie 3 pkt.**\n\n## Typowe pułapki\n\n- **Zamiana tylko X bez Y** - strata 1 pkt. Synchronizacja par jest KRYTYCZNA.\n- **Zamiana tylko Y bez X** - j.w.\n- **Sortowanie po samym X** zamiast X/Y - błędna kolejność (np. D(-2,2) zaszedłby przed A(1,3), ale gdyby było C(2,1) i A(1,3), to A miało większe X niż źle).\n- **Złożoność O(n³)** - przy sortowaniu z dodatkową pętlą wewnątrz porównań. Strata 1 pkt.\n- **Użycie funkcji bibliotecznej `sorted()` / `qsort`** - **zabronione przez treść**.\n- **Off-by-one** w pętlach - pamiętaj o indeksowaniu od 1 w pseudokodzie.\n- **Niepoprawne zamiana** - bez zmiennej tymczasowej `t` można nadpisać wartości.\n\n## Złożoność obliczeniowa\n\n- **Czas**: O(n²) - dwie zagnieżdżone pętle do n.\n- **Pamięć**: O(1) dodatkowa (in-place, tylko zmienna `t` lub `min_idx`).\n- **Operacje porównania**: do n(n-1)/2.\n- **Operacje zamiany**: do n(n-1)/2 w bubble; do n-1 w selection.\n\nDla maksymalnej oceny (4 pkt) wystarcza kwadratowa - to jest mile widziane przez klucz CKE.","image":"img/informatyka-2018-maj-matura-rozszerzona/zad-2.2.webp","solution_image":null,"topics":null,"page_from":6,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/3","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"3","points":null,"ptype":"true_false","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 3. Test\nOceń prawdziwość podanych zdań. Zaznacz P, jeśli zdanie jest prawdziwe, albo F - jeśli jest\nfałszywe.\nW każdym zadaniu punkt uzyskasz tylko za komplet poprawnych odpowiedzi.","answer":null,"answer_text":null,"solution":null,"image":"img/informatyka-2018-maj-matura-rozszerzona/zad-3.webp","solution_image":null,"topics":null,"page_from":7,"source":"ocr","answer_source":null,"answer_text_source":null,"solution_source":null,"text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/3.1","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"3.1","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 3.1. (0-1)\nNa pewnym serwerze WWW znajduje się strona napisana w języku PHP, a jej kod zawiera\nfragmenty w języku JavaScript. Pewien komputer-klient pobrał i wyświetlił tę stronę.\nWiadomo, że:\n1. kod PHP jest wykonywany przez komputer - serwer.\nP\nF\n2. kod JavaScript jest wykonywany przez komputer - klient.\nP\nF\n3. podczas wykonywania kodu PHP zawsze pobierane są dane od\nklienta.\nP\nF\n4. podczas wykonywania kodu JavaScript mogą być pobierane\ndodatkowe dane zarówno od klienta, jak i od serwera.\nP\nF","answer":null,"answer_text":"Zadanie 3.1. (0-1)\nWymagania ogólne\nWymagania szczegółowe\nI. Bezpieczne posługiwanie się komputerem\ni jego oprogramowaniem, wykorzystanie sieci\nkomputerowej; komunikowanie się za\npomocą komputera i technologii\ninformacyjno-komunikacyjnych.\n3. Bezpieczne posługiwanie się\nkomputerem, jego oprogramowaniem\ni korzystanie z sieci komputerowej.\nZdający:\n3) […] opisuje zasady administrowania\nsiecią komputerową w architekturze klient-\nserwer, prawidłowo posługuje się\nterminologią sieciową, korzysta z usług\nw sieci komputerowej, lokalnej i globalnej,\nzwiązanych z dostępem do informacji,\nwymianą informacji i komunikacją.\nSchemat punktowania\n1 p. - za wskazanie czterech poprawnych odpowiedzi.\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.\nPoprawna odpowiedź\nP, P, F, P","solution":"## Poprawna odpowiedź\n\n**1) P, 2) P, 3) F, 4) P**\n\n## Sposób 1 - analiza poszczególnych stwierdzeń\n\n### Stwierdzenie 1: PHP wykonywany przez serwer → **P**\n\n**PHP** (PHP: Hypertext Preprocessor) to **język serwerowy**. Kod PHP jest interpretowany przez interpreter PHP na serwerze WWW (np. Apache + mod_php, lub PHP-FPM). Wynik to **statyczny HTML**, który wysyłany jest do przeglądarki klienta.\n\n**Klient NIE WIDZI** kodu PHP - widzi tylko wygenerowany przez PHP wynik.\n\n### Stwierdzenie 2: JavaScript wykonywany przez klienta → **P**\n\n**JavaScript** (w klasycznym webie) to **język klienta** - wykonywany przez silnik JS w przeglądarce (V8 w Chrome, SpiderMonkey w Firefox, JavaScriptCore w Safari).\n\nUWAGA: Node.js to JavaScript po stronie SERWERA, ale w kontekście strony WWW (treść mówi o stronie w PHP z fragmentami JS) - fragmenty JS w `<script>` są wykonywane przez przeglądarkę klienta.\n\n### Stwierdzenie 3: PHP ZAWSZE pobiera dane od klienta → **F**\n\n**Fałsz.** PHP MOŻE pobierać dane od klienta (przez formularze GET/POST, cookies, sesje), ale **nie zawsze tak robi**. Prosta strona PHP może po prostu wyświetlać aktualną datę z serwera lub liczyć liczbę odwiedzin - bez pobierania ŻADNYCH danych od klienta.\n\nKwantyfikator \"zawsze\" sprawia, że stwierdzenie jest fałszywe.\n\n### Stwierdzenie 4: JS może pobierać dane od klienta I od serwera → **P**\n\n**Prawda.** JavaScript w przeglądarce:\n- **Od klienta**: localStorage, sessionStorage, cookies, formularze, eventy klawiatury/myszy, czujniki.\n- **Od serwera**: `fetch()`, XMLHttpRequest (AJAX), WebSockets, Server-Sent Events.\n\nTo właśnie zapewnia interaktywność współczesnych aplikacji webowych (np. Facebook, Gmail).\n\n## Reference informatyczny - model klient-serwer w WWW\n\n> Reference - Architektura klient-serwer:\n> - **Klient** (browser): renderuje HTML, CSS; wykonuje JavaScript; obsługuje user input.\n> - **Serwer**: obsługuje requesty HTTP; uruchamia kod backendowy (PHP, Python, Java, Node.js); zwraca odpowiedź (HTML/JSON/itd.).\n>\n> Reference - Języki webowe:\n> | Język | Strona | Wykonanie |\n> |-------|--------|-----------|\n> | HTML | klient | renderowanie struktury |\n> | CSS | klient | stylowanie |\n> | JavaScript | klient (browser) | interaktywność |\n> | PHP | serwer | generowanie HTML, logika biznesowa |\n> | Python (Django/Flask) | serwer | jak PHP |\n> | Node.js | serwer | JS na serwerze |\n> | SQL | serwer (DB) | zapytania do bazy |\n>\n> Reference - Komunikacja w obie strony:\n> - **GET / POST** - request od klienta do serwera, response w drugą stronę.\n> - **AJAX (XHR, fetch)** - asynchroniczne pobieranie danych przez JS po załadowaniu strony.\n> - **WebSocket** - dwukierunkowe, ciągłe połączenie klient-serwer.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 3.1, max 1 pkt):\n> - **1 pkt** - wszystkie 4 odpowiedzi poprawne: P, P, F, P\n> - **0 pkt** - niepełna lub błędna\n\n## Typowe pułapki\n\n- **Mylenie języków serwerowych z klienckimi** - PHP/Python/Java to SERVER; JavaScript klasycznie CLIENT.\n- **Stwierdzenie 3: kwantyfikator \"zawsze\"** - uczniowie myślą \"PHP obsługuje formularze, więc tak\", ale `zawsze` jest za mocne. Wystarczy 1 przykład PHP bez wejścia od klienta (np. echo \"witaj\") = fałsz.\n- **JS tylko od klienta** - niedocenienie AJAX/fetch. JS może i pobiera od serwera (to clue Web 2.0).\n- **Mylenie Node.js z klasycznym JS w przeglądarce** - w treści mówimy o stronie WWW, więc JS = przeglądarka.\n\n## Złożoność obliczeniowa\n\nN/A - zadanie teoretyczne z zakresu technologii webowych.","image":"img/informatyka-2018-maj-matura-rozszerzona/zad-3.1.webp","solution_image":null,"topics":null,"page_from":7,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/3.2","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"3.2","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 3.2. (0-1)\n1. Plakat do druku lepiej przygotować w modelu barw RGB niż\nCMYK.\nP\nF\n2. Kolor żółty jest kolorem podstawowym w modelu RGB.\nP\nF\n3. W wyniku nałożenia się składowych Yellow i Magenta w modelu\nCMYK otrzymamy kolor czerwony.\nP\nF\n4. W modelu barw CMYK litera C pochodzi od angielskiego słowa\ncontrast.\nP\nF","answer":null,"answer_text":"Zadanie 3.2. (0-1)\nWymagania ogólne\nWymagania szczegółowe\nII. Wyszukiwanie, gromadzenie\ni przetwarzanie informacji z różnych źródeł;\nopracowywanie za pomocą komputera:\nrysunków, tekstów, danych liczbowych,\nmotywów, animacji, prezentacji\nmultimedialnych.\n4. Opracowywanie informacji za pomocą\nkomputera, w tym: rysunków, tekstów,\ndanych liczbowych, animacji, prezentacji\nmultimedialnych i filmów.\nZdający:\n3) przetwarza obrazy i filmy, np.: zmienia\nrozdzielczość, rozmiar, model barw, stosuje\nfiltry.\nSchemat punktowania\n1 p. - za wskazanie czterech poprawnych odpowiedzi.\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.\nPoprawna odpowiedź\nF, F, P, F","solution":"## Poprawna odpowiedź\n\n**1) F, 2) F, 3) P, 4) F**\n\n## Sposób 1 - analiza poszczególnych stwierdzeń\n\n### Stwierdzenie 1: Plakat do druku lepiej w RGB niż CMYK → **F**\n\n**Fałsz.** Do druku przygotowujemy w **CMYK**:\n- Drukarki używają 4 farb: Cyan, Magenta, Yellow, blacK (Key).\n- RGB to model SYNTEZY ADDYTYWNEJ (dla monitorów, wyświetlaczy emitujących światło).\n- CMYK to model SYNTEZY SUBTRAKTYWNEJ (dla druku - farby pochłaniają światło).\n- Jeżeli plakat zaprojektujemy w RGB, drukarka i tak musi konwertować na CMYK - kolory mogą się zmienić (jasne, jaskrawe kolory RGB nie są możliwe w CMYK).\n\n### Stwierdzenie 2: Żółty jest podstawowy w RGB → **F**\n\n**Fałsz.** W modelu **RGB** kolory podstawowe to:\n- **R**ed (czerwony)\n- **G**reen (zielony)\n- **B**lue (niebieski)\n\nŻółty NIE jest podstawowy w RGB. Żółty powstaje przez mieszanie R + G (czerwony + zielony = żółty w syntezie addytywnej).\n\nŻółty jest podstawowy w modelach: **RYB** (artystyczny), **CMYK** (Y = Yellow).\n\n### Stwierdzenie 3: Yellow + Magenta = czerwony w CMYK → **P**\n\n**Prawda.** W syntezie subtraktywnej CMYK:\n- **Yellow + Magenta = Red (czerwony)**\n- **Yellow + Cyan = Green (zielony)**\n- **Cyan + Magenta = Blue (niebieski)**\n- C + M + Y = Black (teoretycznie, w praktyce dodaje się dedykowaną czarną K).\n\nMożna to sprawdzić: Magenta = czerwono-różowa, Yellow = żółta. Nałożenie żółtego na magenta absorbuje niebieskie i część zielonego, pozostawiając czerwony.\n\n### Stwierdzenie 4: C w CMYK = contrast → **F**\n\n**Fałsz.** Litery CMYK pochodzą od:\n- **C** = **Cyan** (cyjan, bladoniebieski)\n- **M** = **Magenta** (magenta, fioletowo-różowy)\n- **Y** = **Yellow** (żółty)\n- **K** = **Key** lub b**lacK** (czarny - pomocniczy, dla kontrastu i głębi)\n\nC NIE oznacza \"contrast\".\n\n## Reference informatyczny - modele kolorów\n\n> Reference - Synteza addytywna vs subtraktywna:\n> - **Addytywna (RGB)**: dodawanie świateł kolorowych. Czarny = brak światła. Biały = R + G + B max.\n> - Stosowana w: monitorach, telewizorach, ekranach LED.\n> - **Subtraktywna (CMY/CMYK)**: pochłanianie składowych światła białego. Biały = papier. Czarny = wszystkie barwniki.\n> - Stosowana w: druku, malarstwie.\n>\n> Reference - Inne modele kolorów:\n> - **HSL/HSV**: hue (odcień), saturation (nasycenie), lightness/value (jasność). Wygodne dla projektantów.\n> - **YUV/YCbCr**: luminance + chrominance. Stosowane w video (JPEG, MPEG).\n> - **Lab/CIELAB**: percepcyjnie jednorodny, używany w grafice profesjonalnej.\n>\n> Reference - Wartości RGB:\n> - 8 bitów na kanał → 256 poziomów × 3 = 16,7 mln kolorów (24-bit color).\n> - Hex: `#FF0000` = czerwony, `#00FF00` = zielony, `#0000FF` = niebieski, `#FFFFFF` = biały, `#000000` = czarny.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 3.2, max 1 pkt):\n> - **1 pkt** - wszystkie 4 odpowiedzi poprawne: F, F, P, F\n> - **0 pkt** - niepełna lub błędna\n\n## Typowe pułapki\n\n- **Mylenie RGB z CMYK** - RGB dla ekranów (światło), CMYK dla druku (farby). Zapamiętaj: ekran emituje, farba pochłania.\n- **Żółty w RGB** - częsta pomyłka, bo żółty wydaje się \"podstawowy\". Ale w RGB to MIESZANINA R+G.\n- **K w CMYK = blacK lub Key** - NIE \"contrast\". Łatwa pomyłka.\n- **Niewiedza o syntezie subtraktywnej** - Yellow + Magenta = Red (NIE zielony!). Można pomyśleć logicznie: magenta jest \"czerwono-fioletowa\", żółta jest \"żółta\"; razem dają czerwony, bo magenta pochłania zielony a żółty pochłania niebieski.\n\n## Złożoność obliczeniowa\n\nN/A - zadanie teoretyczne z zakresu grafiki komputerowej.","image":"img/informatyka-2018-maj-matura-rozszerzona/zad-3.2.webp","solution_image":null,"topics":null,"page_from":7,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/3.3","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"3.3","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 3.3. (0-1)\nWskaż zdania prawdziwe dla języka SQL.\n1.\nW wynikach zapytania postaci SELECT ( ) ORDER BY ( )\nzawsze dostajemy rekordy uporządkowane ściśle rosnąco według\nwskazanego pola.\nP\nF\n2. Zapytanie UPDATE może zmienić wartości pól w bazie danych.\nP\nF\n3.\nZapytanie postaci SELECT * FROM tabela1 WHERE pole LIKE\n( ) może w pewnych warunkach dać wszystkie rekordy z tabeli\ntabela1.\nP\nF\n4.\nWynik zapytania SELECT * FROM tabela1 JOIN tabela2 ON\ntabela1.pole = tabela2.pole może być pusty przy niepustych\ntabelach tabela1 oraz tabela2.\nP\nF\nWypełnia\negzaminator\nNr zadania\n2.2.\n3.1.\n3.2.\n3.3.\nMaks. liczba pkt.\n4\n1\n1\n1\nUzyskana liczba pkt.\nMIN_1R\nBRUDNOPIS (nie podlega ocenie)","answer":null,"answer_text":"Zadanie 3.3. (0-1)\nWymagania ogólne\nWymagania szczegółowe\nII. Wyszukiwanie, gromadzenie\ni przetwarzanie informacji z różnych źródeł;\nopracowywanie za pomocą komputera:\nrysunków, tekstów, danych liczbowych,\nmotywów, animacji, prezentacji\nmultimedialnych.\n2. Wyszukiwanie, gromadzenie,\nselekcjonowanie, przetwarzanie\ni wykorzystywanie informacji,\nwspółtworzenie zasobów w sieci,\nkorzystanie z różnych źródeł i sposobów\nzdobywania informacji.\nZdający:\n2) stosuje metody wyszukiwania\ni przetwarzania informacji w relacyjnej\nbazie danych (język SQL).\nSchemat punktowania\n1 p. - za wskazanie czterech poprawnych odpowiedzi.\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.\nPoprawna odpowiedź\nF, P, P, P\nCzęść II\nUwaga: wszystkie wyniki muszą być odzwierciedleniem dołączonej komputerowej realizacji\nobliczeń.","solution":"## Poprawna odpowiedź\n\n**1) F, 2) P, 3) P, 4) P**\n\n## Sposób 1 - analiza poszczególnych stwierdzeń\n\n### Stwierdzenie 1: ORDER BY → ZAWSZE ściśle rosnąco → **F**\n\n**Fałsz.** Dwa powody:\n\n1. **Domyślnie ORDER BY sortuje ROSNĄCO (ASC), ale nie ŚCIŚLE.** Mogą być duplikaty (równe wartości), więc nie \"ściśle rosnąco\". Słowo \"ściśle\" oznacza, że a < b zawsze, a tu może być a = b.\n2. **Można sortować malejąco**: `ORDER BY kolumna DESC` - wtedy w ogóle nie rosnąco.\n3. **Słowo \"zawsze\" jest za mocne** - wystarczy jeden kontrprzykład.\n\n```sql\nSELECT * FROM tabela ORDER BY wiek; -- może być [25, 30, 30, 45] - to NIEROSNĄCO niemalejąco, ale NIE ściśle.\nSELECT * FROM tabela ORDER BY wiek DESC; -- malejąco.\n\n### Stwierdzenie 2: UPDATE może zmienić pola → **P**\n\n**Prawda.** UPDATE to **podstawowe zapytanie modyfikujące** w SQL:\n```sql\nUPDATE pracownicy\nSET pensja = pensja * 1.1\nWHERE staz_lat > 5;\nTo zmienia wartości pola `pensja` u pracowników ze stażem > 5 lat.\n\n### Stwierdzenie 3: SELECT * WHERE pole LIKE może zwrócić wszystkie → **P**\n\n**Prawda.** Wzorzec `LIKE '%'` (jeden znak %, dowolny ciąg) **pasuje do każdego niepustego stringa**:\n\n```sql\nSELECT * FROM tabela1 WHERE pole LIKE '%';\nTo zwróci wszystkie rekordy gdzie `pole` jest NOT NULL.\n\nMożna też `LIKE '%[anything]%'` - pasuje wszędzie, gdzie występuje [anything].\n\n### Stwierdzenie 4: JOIN może dać pusty wynik przy niepustych tabelach → **P**\n\n**Prawda.** INNER JOIN zwraca tylko **pasujące pary** - jeśli żaden klucz z tabela1 nie pasuje do tabela2, wynik jest **pusty**.\n\n**Przykład:**\n```sql\n-- tabela1: [{id: 1, kategoria: 'A'}, {id: 2, kategoria: 'A'}]\n-- tabela2: [{id: 10, typ: 'B'}, {id: 11, typ: 'C'}]\nSELECT * FROM tabela1 JOIN tabela2 ON tabela1.kategoria = tabela2.typ;\n-- Wynik: PUSTY, bo 'A' nigdy nie pasuje do 'B' ani 'C'.\n\n## Reference informatyczny - kluczowe konstrukcje SQL\n\n> Reference - ORDER BY:\n> - Domyślnie ASC (rosnąco). Można jawnie ASC/DESC.\n> - **NIE musi być ściśle rosnące** - równe wartości mogą sąsiadować.\n> - Sortowanie po wielu polach: `ORDER BY a, b DESC` (a rosnąco, b malejąco).\n> - **NULL**: zwykle na początku przy ASC (zależy od silnika).\n>\n> Reference - UPDATE:\n> - Składnia: `UPDATE tabela SET kol1 = val1, kol2 = val2 WHERE warunek;`.\n> - **UWAGA**: bez `WHERE` aktualizuje WSZYSTKIE rekordy.\n> - Może użyć podzapytań: `SET kol = (SELECT )`.\n>\n> Reference - LIKE:\n> - `%` = dowolny ciąg znaków (0 lub więcej).\n> - `_` = dokładnie jeden znak.\n> - `LIKE '%'` = każdy niepusty string.\n> - `LIKE 'A%'` = zaczynający się na A.\n> - `LIKE '%kot%'` = zawierający \"kot\".\n> - `LIKE '_at'` = 3-znakowy, kończący się na \"at\" (cat, bat, hat).\n>\n> Reference - JOIN:\n> - **INNER JOIN** (= JOIN) - tylko pasujące rekordy z obu tabel.\n> - **LEFT JOIN** - wszystkie z lewej + dopasowane z prawej (NULL gdy brak).\n> - **RIGHT JOIN** - analogicznie z prawej.\n> - **FULL JOIN** - wszystkie z obu.\n> - **CROSS JOIN** - kartezjański.\n> - Pusty wynik INNER JOIN może wystąpić nawet przy niepustych tabelach.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 3.3, max 1 pkt):\n> - **1 pkt** - wszystkie 4 odpowiedzi poprawne: F, P, P, P\n> - **0 pkt** - niepełna lub błędna\n\n## Typowe pułapki\n\n- **\"Zawsze ściśle rosnąco\"** - uczniowie myślą \"ORDER BY = rosnąco\" i klikają P, ale słowo \"ściśle\" wyklucza duplikaty. Plus można sortować DESC.\n- **LIKE z `%` jako jedynym znakiem** - często pomijane. To bardzo użyteczne w optional filters.\n- **JOIN z pustym wynikiem** - uczniowie mylą z tym, że tabele są niepuste = wynik niepusty. INNER JOIN wymaga DOPASOWAŃ.\n- **UPDATE bez WHERE** - pamiętać o ryzyku, ale w stwierdzeniu pyta tylko CZY MOŻE zmienić → tak, oczywiście.\n\n## Złożoność obliczeniowa\n\nN/A - zadanie teoretyczne z SQL.","image":"img/informatyka-2018-maj-matura-rozszerzona/zad-3.3.webp","solution_image":null,"topics":null,"page_from":7,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/4.1","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"4.1","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 4. WEGA\n\nW ramach projektu WEGA naukowcom udało się odczytać sygnały radiowe pochodzące z przestrzeni kosmicznej. Po wstępnej obróbce zapisali je do pliku sygnaly.txt.\n\nW pliku sygnaly.txt znajduje się 1000 wierszy. Każdy wiersz zawiera jedno niepuste słowo złożone z wielkich liter alfabetu angielskiego. Długość jednego słowa nie przekracza 100 znaków.\n\nNapisz program(y), który(e) da(dzą) odpowiedzi do poniższych zadań. Odpowiedzi zapisz w pliku wyniki4.txt, a każdą odpowiedź poprzedź numerem oznaczającym odpowiednie zadanie.\n\nUwaga: Plik przyklad.txt zawiera dane przykładowe spełniające warunki zadania. Odpowiedzi dla danych z pliku przyklad.txt są podane pod pytaniami.\n\nNaukowcy zauważyli, że po złączeniu dziesiątych liter co czterdziestego słowa (zaczynając od słowa czterdziestego) otrzymamy pewne przesłanie. Wypisz to przesłanie.\n\n**Uwaga:** Każde co czterdzieste słowo ma co najmniej 10 znaków.\n\nDla danych z pliku przyklad.txt wynikiem jest:\nNIECHCIMATURAPROSTABEDZIE","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**ZAPISZODPOWIEDZIWPLIKUTXT** (dla sygnaly.txt)\n\n**NIECHCIMATURAPROSTABEDZIE** (dla przyklad.txt)\n\n## Sposób 1 - interpretacja zadania\n\n**\"Co czterdzieste słowo zaczynając od czterdziestego\":** słowa o numerach 40, 80, 120, 160, , 1000.\nDla 1000 słów: 1000 / 40 = **25 słów** w sekwencji.\n\n**\"Dziesiąta litera\":** indeks 9 (od 0) lub indeks 10 (od 1).\n\n**Algorytm:**\n1. Wczytaj wszystkie słowa.\n2. Wybierz słowa o numerach 40, 80, 120, , 1000 (lub w pythonie indeksy 39, 79, 119, ).\n3. Z każdego wybranego słowa weź 10. literę.\n4. Złącz w jeden string.\n\n## Sposób 2 - implementacja Python\n\n```python\nslowa = []\nwith open('sygnaly.txt', encoding='utf-8') as f:\nfor linia in f:\ns = linia.strip()\nif s:\nslowa.append(s)\n\nprzeslanie = ''\nfor i in range(40, len(slowa) + 1, 40): # 40, 80, , 1000\nslowo = slowa[i - 1] # 40-te słowo to indeks 39\nprzeslanie += slowo[9] # 10. litera to indeks 9\n\nprint(przeslanie) # ZAPISZODPOWIEDZIWPLIKUTXT\n\n# Zapis do pliku\nwith open('wyniki4.txt', 'w', encoding='utf-8') as f:\nf.write(f\"4.1 {przeslanie}\\n\")\n\n**Weryfikacja długości:** liczba liter w przesłaniu = 1000 / 40 = 25. Słowo \"ZAPISZODPOWIEDZIWPLIKUTXT\" ma 25 liter ✓.\n\n## Sposób 3 - C++\n\n```cpp\n#include <iostream>\n#include <fstream>\n#include <string>\n#include <vector>\nusing namespace std;\n\nint main() {\nifstream f(\"sygnaly.txt\");\nvector<string> slowa;\nstring s;\nwhile (f >> s) slowa.push_back(s);\nstring przeslanie;\nfor (int i = 40; i <= (int)slowa.size(); i += 40) {\nprzeslanie += slowa[i - 1][9]; // 10. litera = indeks 9\n}\ncout << \"4.1 \" << przeslanie << endl;\nreturn 0;\n}\n\n## Sposób 4 - Pascal\n\n```pascal\nprogram Wega41;\nvar f: TextFile; s: String; slowa: array[1 1000] of String;\ni, n: Integer; przeslanie: String;\nbegin\nAssignFile(f, 'sygnaly.txt'); Reset(f);\nn := 0;\nwhile not Eof(f) do begin\nReadln(f, s);\nif Length(s) > 0 then begin\nInc(n);\nslowa[n] := s;\nend;\nend;\nCloseFile(f);\nprzeslanie := '';\ni := 40;\nwhile i <= n do begin\nprzeslanie := przeslanie + slowa[i][10]; // Pascal indeksuje od 1\ni := i + 40;\nend;\nWriteln('4.1 ', przeslanie);\nend.\n\n## Reference informatyczny - przetwarzanie pliku tekstowego\n\n> Reference - Czytanie pliku linia-po-linii:\n> - **Python**: `for linia in open('file.txt'):` lub `f.readlines()`.\n> - **C++**: `while (f >> s)` lub `getline(f, s)`.\n> - **Pascal**: `while not Eof(f) do Readln(f, s)`.\n>\n> Reference - Indeksowanie znaków:\n> - **Python**: od 0. `s[9]` = 10. znak.\n> - **C++**: od 0. `s[9]` = 10. znak.\n> - **Pascal**: od 1. `s[10]` = 10. znak.\n>\n> Reference - Co k-ty element:\n> - **Range step**: Python `range(40, n+1, 40)` lub `[i for i in range(n) if (i+1) % 40 == 0]`.\n> - **C++**: `for (int i = 40; i <= n; i += 40)`.\n> - Wzór: `i = k * 40` dla k = 1, 2, , n/40.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 4.1, max 3 pkt):\n> - **3 pkt** - prawidłowa odpowiedź **ZAPISZODPOWIEDZIWPLIKUTXT**\n> - **1 pkt** - wynik z 1 błędem (np. zła litera)\n> - **0 pkt** - błędna lub brak\n>\n> **Uwaga: NIE PRZYZNAJE SIĘ 2 PUNKTÓW.**\n\n## Typowe pułapki\n\n- **Off-by-one przy indeksie litery** - \"dziesiąta\" to indeks 9 (Python) lub 10 (Pascal). Łatwo wziąć 9. (indeks 8) lub 11. (indeks 10).\n- **Off-by-one przy numerze słowa** - \"40-te\" to indeks 39 w Python, 40 w Pascal. Lepiej iterować jasno: `for i in [40, 80, ]`.\n- **\"Zaczynając od czterdziestego\"** - pierwsze słowo to numer 40, NIE pierwsze (1) ani 41-sze.\n- **Pomyłka z \"co czterdzieste\"** - `range(40, 1001, 40)` da 40, 80, , 1000 = 25 elementów. NIE `range(40, 1000, 40)` które zatrzymuje się na 960.\n- **Nieskasowanie newline** - `.strip()` lub `s.trim()` na końcu.\n- **Słowo krótsze niż 10 znaków** - gwarancja z treści: \"każde co czterdzieste ma co najmniej 10 znaków\".\n\n## Złożoność obliczeniowa\n\n- Wczytanie 1000 słów: **O(N)**.\n- Przejście co 40-te: **O(N/40)** = O(25).\n- Pobranie 10. litery: O(1).\n- **Łącznie: O(N) ≈ 1000 operacji.**","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/4.2","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"4.2","points":4,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 4.1.\n\nZnajdź słowo, w którym występuje największa liczba **różnych** liter. Wypisz to słowo i liczbę występujących w nim różnych liter. Jeśli słów o największej liczbie różnych liter jest więcej niż jedno, wypisz pierwsze z nich pojawiające się w pliku z danymi.\n\nDla danych z pliku przyklad.txt wynikiem jest:\nAKLMNOPRSTWZA 12","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Słowo:** `SUOLDQWISCDRFLRWHZBNTMIAPHALMNCWHVGMXOZSQNXWXSFELZVTUTILXWKCTYBQYSUAKNYJKRXDJQYHXAQGWN`\n\n**Liczba różnych liter:** **26**\n\n## Sposób 1 - zliczanie unikalnych liter w słowie\n\n**Idea:** dla każdego słowa zlicz **różne** litery (np. używając zbioru). Znajdź słowo z maksymalną liczbą. Przy remisie wybieramy PIERWSZE w kolejności.\n\n**Klucz:** liczba unikalnych liter ≤ 26 (alfabet angielski). Tu maksimum to **26** - słowo zawierające KAŻDĄ literę alfabetu (pangram!).\n\n## Sposób 2 - implementacja Python\n\n```python\nnajlepsze_slowo = \"\"\nmax_roznych = 0\n\nwith open('sygnaly.txt', encoding='utf-8') as f:\nfor linia in f:\ns = linia.strip()\nif not s:\ncontinue\nrozne = len(set(s)) # set automatycznie usuwa duplikaty\nif rozne > max_roznych:\nmax_roznych = rozne\nnajlepsze_slowo = s\n\nprint(f\"4.2 {najlepsze_slowo} {max_roznych}\")\n# 4.2 SUOLDQWISCDRFLRWHZBNTMIAPHALMNCWHVGMXOZSQNXWXSFELZVTUTILXWKCTYBQYSUAKNYJKRXDJQYHXAQGWN 26\n\n## Sposób 3 - C++\n\n```cpp\n#include <iostream>\n#include <fstream>\n#include <string>\n#include <set>\nusing namespace std;\n\nint policzRozne(const string& s) {\nset<char> znaki(s.begin(), s.end());\nreturn znaki.size();\n}\n\nint main() {\nifstream f(\"sygnaly.txt\");\nstring s, najlepsze;\nint maxRoznych = 0;\nwhile (f >> s) {\nint r = policzRozne(s);\nif (r > maxRoznych) {\nmaxRoznych = r;\nnajlepsze = s;\n}\n}\ncout << \"4.2 \" << najlepsze << \" \" << maxRoznych << endl;\nreturn 0;\n}\n\n## Sposób 4 - Pascal (z tablicą boolowską)\n\n```pascal\nprogram Wega42;\nvar f: TextFile; s, najlepsze: String;\nmaxR, r, i: Integer; uzyte: array['A' 'Z'] of Boolean;\nch: Char;\nbegin\nAssignFile(f, 'sygnaly.txt'); Reset(f);\nmaxR := 0;\nnajlepsze := '';\nwhile not Eof(f) do begin\nReadln(f, s);\nif Length(s) = 0 then Continue;\nfor ch := 'A' to 'Z' do uzyte[ch] := False;\nfor i := 1 to Length(s) do uzyte[s[i]] := True;\nr := 0;\nfor ch := 'A' to 'Z' do if uzyte[ch] then r := r + 1;\nif r > maxR then begin\nmaxR := r;\nnajlepsze := s;\nend;\nend;\nCloseFile(f);\nWriteln('4.2 ', najlepsze, ' ', maxR);\nend.\n\n## Reference informatyczny - zbiory i unikalność\n\n> Reference - Liczenie unikalnych elementów:\n> - **Python**: `set(iterable)` - automatyczna deduplikacja. `len(set(s))` to liczba unikalnych elementów.\n> - **C++**: `std::set<char>` - uporządkowany zbiór; `std::unordered_set<char>` - hash-based, szybszy.\n> - **Pascal**: tablica boolowska `array['A' 'Z'] of Boolean` lub typ `set of Char`.\n> - **Złożoność**: O(L) na słowo, gdzie L = długość słowa.\n>\n> Reference - Pangram:\n> - **Pangram** = tekst zawierający każdą literę alfabetu co najmniej raz.\n> - Polski klasyk: \"Pchnąć w tę łódź jeża lub ośm skrzyń fig.\"\n> - Angielski klasyk: \"The quick brown fox jumps over the lazy dog.\"\n> - W tym zadaniu szukamy słowa-pangramu (lub przybliżającego pangram).\n>\n> Reference - Tie-breaking (remisy):\n> - \"Pierwsze pojawiające się\" → używamy ostrego `>` (NIE `>=`) przy aktualizacji.\n> - Wtedy zmienna `najlepsze` aktualizuje się TYLKO gdy znajdziemy BARDZIEJ unikalne słowo.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 4.2, max 4 pkt):\n> - **4 pkt** - prawidłowe słowo + liczba 26\n> - **2 pkt** - tylko prawidłowe słowo (bez liczby) lub odwrotnie\n> - **0 pkt** - błędne lub brak\n>\n> **Uwaga: NIE PRZYZNAJE SIĘ 3 ani 1 PUNKTU.**\n\n## Typowe pułapki\n\n- **Liczenie wszystkich liter** zamiast unikalnych - wtedy długie słowo wygrywa nawet z powtórzeniami. Trzeba `len(set(s))`, NIE `len(s)`.\n- **Operator `>=` zamiast `>`** - wtedy przy remisie wygra OSTATNIE napotkane, a powinniśmy PIERWSZE.\n- **Liczenie liter razem ze spacjami/newline** - `s.strip()` przed liczeniem.\n- **Pomylenie litery z bajtem** - w UTF-8 polski znak może mieć więcej bajtów. Tu jest tylko angielski A-Z, więc nie problem.\n- **Sortowanie liter** - niepotrzebne; zbiór automatycznie deduplikuje.\n\n## Złożoność obliczeniowa\n\n- Dla 1000 słów × max 100 znaków: **O(N · L)** = O(100 000) operacji.\n- Pamięć: O(26) (zbiór liter angielskich) per słowo.","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/4.3","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"4.3","points":4,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 4.1.\n\nNa przykład CGECF jest takim słowem, ale ABEZA nie jest (odległość A - Z wynosi 25).\n\nW tym zadaniu rozważmy odległość liter w alfabecie - np. litery A i B są od siebie oddalone o 1, A i E o 4, F i D o 2, a każda litera od siebie samej jest oddalona o 0. Wypisz wszystkie słowa, w których każde dwie litery oddalone są od siebie w alfabecie co najwyżej o 10. Słowa wypisz w kolejności występowania w pliku sygnaly.txt, po jednym w wierszu.\n\nDla danych z pliku przyklad.txt wynikiem jest 15 słów: AAAAAAAAAI, AAAAAAAAAE, AAAAAAAAAC, AAAAAAAAAH, AAAAAAAAAC, AAAAAAAAAI, AAAAAAAAAA, BB, AAAAAAAAAA, AAAAAAAAAA, AAAAAAAAAB, AAAAAAAAAE, AAAAAAAAAD, AAAAAAAAAI, AAAAAAAAAE.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Lista słów** (przykładowe pierwsze z sygnaly.txt):\nQQMLKKQNOHPKKPJOLHIPJKLKQIIHQHPNKNQPHNKLKQNIMLQPNLPMHNNIPNJJONQOHHKKQOIHOHHJMOJPMNIPIKION, OO, FH, AE, (cała lista to słowa spełniające warunek max odległość 10 między KAŻDYMI dwiema literami).\n\n## Sposób 1 - kluczowa interpretacja zadania\n\n**UWAGA - kluczowy detal:** warunek dotyczy **KAŻDEJ PARY liter w słowie**, nie tylko sąsiadów!\n\nDla słowa s, warunek: dla każdego i, j: `|s[i] - s[j]| ≤ 10`.\n\nTo równoważne: `max(s) - min(s) ≤ 10` (różnica między największą a najmniejszą literą).\n\n**Przykład:** `ABEZA`:\n- min = A, max = Z, różnica = 25. **NIE spełnia** warunku (25 > 10).\n- Mimo że sąsiednie litery są blisko siebie (np. A-B, B-E, E-Z=21, Z-A=25), to KAŻDE dwie litery muszą się różnić ≤ 10.\n\n**Przykład:** `CGECF`:\n- min = C, max = G, różnica = 4. **Spełnia** (4 ≤ 10).\n\n## Sposób 2 - implementacja Python\n\n```python\nwyniki = []\nwith open('sygnaly.txt', encoding='utf-8') as f:\nfor linia in f:\ns = linia.strip()\nif not s:\ncontinue\n# Warunek: max(s) - min(s) <= 10\nif ord(max(s)) - ord(min(s)) <= 10:\nwyniki.append(s)\n\nwith open('wyniki4.txt', 'a', encoding='utf-8') as f:\nf.write(\"4.3\\n\")\nfor s in wyniki:\nf.write(s + '\\n')\n\nprint(f\"Liczba słów: {len(wyniki)}\")\nprint(\"Pierwsze 5:\")\nfor s in wyniki[:5]:\nprint(s)\n\n## Sposób 3 - C++\n\n```cpp\n#include <iostream>\n#include <fstream>\n#include <string>\n#include <algorithm>\nusing namespace std;\n\nbool sprawdz(const string& s) {\nif (s.empty()) return false;\nchar min_c = *min_element(s.begin(), s.end());\nchar max_c = *max_element(s.begin(), s.end());\nreturn (max_c - min_c) <= 10;\n}\n\nint main() {\nifstream fin(\"sygnaly.txt\");\nofstream fout(\"wyniki4.txt\", ios::app);\nfout << \"4.3\\n\";\nstring s;\nwhile (fin >> s) {\nif (sprawdz(s)) fout << s << \"\\n\";\n}\nreturn 0;\n}\n\n## Sposób 4 - Pascal\n\n```pascal\nprogram Wega43;\nvar fin, fout: TextFile; s: String;\ni: Integer; minC, maxC: Char;\nbegin\nAssignFile(fin, 'sygnaly.txt'); Reset(fin);\nAssignFile(fout, 'wyniki4.txt'); Append(fout);\nWriteln(fout, '4.3');\nwhile not Eof(fin) do begin\nReadln(fin, s);\nif Length(s) = 0 then Continue;\nminC := s[1]; maxC := s[1];\nfor i := 2 to Length(s) do begin\nif s[i] < minC then minC := s[i];\nif s[i] > maxC then maxC := s[i];\nend;\nif (Ord(maxC) - Ord(minC)) <= 10 then Writeln(fout, s);\nend;\nCloseFile(fin); CloseFile(fout);\nend.\n\n## Reference informatyczny - odległość alfabetyczna\n\n> Reference - Min/max w stringu:\n> - **Python**: `min(s)`, `max(s)` - leksykograficznie (alfabetycznie).\n> - **C++**: `min_element(s.begin(), s.end())`, `max_element( )`.\n> - **Pascal**: pętla z porównaniem.\n>\n> Reference - Równoważność warunków:\n> - \"Każde dwie litery oddalone ≤ 10\" ≡ \"max(s) - min(s) ≤ 10\".\n> - DOWÓD: jeśli max - min ≤ 10, to dla dowolnej pary (a, b): |a-b| ≤ max-min ≤ 10. I odwrotnie - jeśli max-min > 10, to para (min, max) łamie warunek.\n>\n> Reference - Klucz CKE - pułapka z 2 pkt:\n> - **Jeśli porównujemy tylko SĄSIEDNIE litery** (s[i] vs s[i+1]), wynik to 207 słów. To częsta pomyłka.\n> - Poprawny wynik (max - min) daje 15 słów dla przyklad.txt.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 4.3, max 4 pkt):\n> - **4 pkt** - poprawna lista (warunek dla WSZYSTKICH par)\n> - **2 pkt** - lista z porównania tylko SĄSIADUJĄCYCH liter (207 słów dla sygnaly.txt)\n> - **0 pkt** - błędna lub brak\n>\n> **Uwaga: NIE PRZYZNAJE SIĘ 3 ani 1 PUNKTU.**\n\n## Typowe pułapki\n\n- **Porównywanie tylko sąsiadów** - KLASYCZNA pułapka. \"Każde dwie\" = WSZYSTKIE PARY, nie tylko sąsiednie.\n- **Wzór `max - min ≤ 10`** - eleganckie i poprawne; alternatywa to podwójna pętla po wszystkich parach (O(L²)).\n- **Pomylenie odległości** - A i B oddalone o 1 (nie 2), A i E o 4 (nie 5). Bez offset.\n- **Wartość bezwzględna** - `|a-b|`, bo odległość nie ma znaku.\n- **`ord('A')`** - kod ASCII A to 65. Dla A do Z: 65-90. Różnica między 'Z' a 'A' = 25.\n- **Pominięcie pustego słowa** - sprawdź `if not s` lub `if Length(s) = 0`.\n\n## Złożoność obliczeniowa\n\n- Dla każdego słowa: O(L) (znajdowanie min/max).\n- Dla 1000 słów × max 100 znaków: **O(N · L)** = O(100 000) operacji.\n- Alternatywa naiwna O(L²) per słowo = O(N · L²) = 10⁷ operacji. Mniej elegancko, ale wciąż mieści się w czasie.","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/5.1","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"5.1","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 5. Zbiornik\n\nRzeka Wirka co roku wylewała. Aby temu zapobiec, wybudowano na rzece zbiornik retencyjny. W kolejnych wierszach pliku woda.txt znajdują się dane dotyczące dziennego dopływu wody z rzeki Wirki do zbiornika retencyjnego w kolejnych dniach z lat 2008-2017. Plik zawiera 3 653 wiersze. W każdym wierszu podane są dane: data (rrrr-mm-dd) oraz liczba metrów sześciennych wody, jaka dopływała do zbiornika w ciągu doby. Dane oddzielone są znakami tabulacji.\n\nPrzykład:\n2008-01-01 | 2275\n2008-01-02 | 2831\n2008-01-03 | 4615\n2008-01-04 | 4084\n2008-01-05 | 3258\n\nPodaj rok, w którym zbiornik retencyjny został zasilony łącznie największą liczbą metrów sześciennych wody z rzeki Wirki.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Rok 2015**\n\n## Sposób 1 - agregacja po roku\n\n**Idea:** dla każdej daty wyciągamy rok (pierwsze 4 znaki), sumujemy dopływy per rok, znajdujemy maksimum.\n\n## Sposób 2 - Python\n\n```python\nfrom collections import defaultdict\n\nsumy = defaultdict(int)\nwith open('woda.txt', encoding='utf-8') as f:\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) != 2:\ncontinue\ndata, dop_str = cz\nrok = data[:4]\nsumy[rok] += int(dop_str)\n\nnajwiekszy = max(sumy.items(), key=lambda x: x[1])\nprint(f\"Rok: {najwiekszy[0]}, suma = {najwiekszy[1]}\") # 2015,\n\nfor rok, s in sorted(sumy.items()):\nprint(f\"{rok}: {s}\")\n\n## Sposób 3 - SQL\n\n```sql\nSELECT\nSUBSTRING(data, 1, 4) AS rok,\nSUM(doplyw) AS suma\nFROM woda\nGROUP BY SUBSTRING(data, 1, 4)\nORDER BY suma DESC\nLIMIT 1;\n\n## Sposób 4 - arkusz kalkulacyjny\n\n1. Otwórz woda.txt (separator: tabulacja).\n2. Kolumna A: data, B: dopływ.\n3. Kolumna C (pomocnicza): `=LEWY(A2; 4)` - rok jako string.\n4. **Tabela przestawna**: wiersze = C (rok), wartości = SUMA B.\n5. Sortuj malejąco - pierwszy wiersz to **2015** z najwyższą sumą.\n\nAlternatywnie z formuły:\n- F1:F10 - lata 2008 2017\n- G1: `=SUMA.JEŻELI(C:C; F1; B:B)` - suma dla danego roku.\n- Sortuj G malejąco lub `=INDEKS(F:F; PODAJ.POZYCJĘ(MAX(G:G); G:G; 0))` → 2015.\n\n## Sposób 5 - C++ / Pascal\n\n**C++:**\n```cpp\n#include <iostream>\n#include <fstream>\n#include <string>\n#include <map>\nusing namespace std;\n\nint main() {\nifstream f(\"woda.txt\");\nmap<string, long long> sumy;\nstring data, dopStr;\nwhile (f >> data >> dopStr) {\nstring rok = data.substr(0, 4);\nsumy[rok] += stoll(dopStr);\n}\nstring maxRok;\nlong long maxSuma = 0;\nfor (auto& [r, s] : sumy) {\nif (s > maxSuma) { maxSuma = s; maxRok = r; }\n}\ncout << \"Rok: \" << maxRok << \" suma: \" << maxSuma << endl;\nreturn 0;\n}\n\n## Reference informatyczny - agregacja danych\n\n> Reference - Wyciąganie roku z daty:\n> - **Format ISO 8601** (rrrr-mm-dd): rok to pierwsze 4 znaki → `data[:4]` (Python), `LEFT(data, 4)` (SQL), `Copy(data, 1, 4)` (Pascal).\n> - **W bazie danych** z typem DATE: `YEAR(data)` (MySQL) lub `EXTRACT(YEAR FROM data)` (PostgreSQL).\n>\n> Reference - defaultdict:\n> - **Python**: `defaultdict(int)` automatycznie inicjalizuje 0 dla nowych kluczy.\n> - **C++**: `std::map` z `operator[]` zachowuje się podobnie (auto-insert).\n> - **Alternatywa**: `dict.get(rok, 0) + 1` lub `Counter`.\n>\n> Reference - Agregacja sumująca:\n> - W SQL: `GROUP BY`. W Pythonie: słownik. W C++: map.\n> - **Complexity**: O(N) z dobrym hash/tree.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.1, max 2 pkt):\n> - **2 pkt** - odpowiedź **Rok 2015**\n> - **0 pkt** - błędna lub brak\n>\n> **Uwaga: NIE PRZYZNAJE SIĘ 1 PUNKTU.**\n\n## Typowe pułapki\n\n- **Sortowanie alfabetyczne lat zamiast wg sumy** - wynik byłby \"2008\" jako pierwszy.\n- **Pominięcie konwersji int** - w Python `int(dop_str)` konieczne, inaczej konkatenacja stringów.\n- **Pomyłka separatora** - TAB (\\t), nie spacja czy przecinek.\n- **Pomyłka roku - wziąć ostatnie 4 cyfry zamiast pierwszych** - `data[-4:]` da dzień + miesiąc; powinno być `data[:4]`.\n- **Brak EOL na końcu pliku** - większość parserów radzi sobie, ale uwaga w Pascal.\n\n## Złożoność obliczeniowa\n\n- Wczytanie 3653 wierszy: O(N).\n- Agregacja: O(N) z O(1) na wstawienie do mapy.\n- Znalezienie max: O(10) (10 lat).\n- **Łącznie: O(N) ≈ 3653 operacji.**","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/5.2","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"5.2","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 5.1.\n\nJaki był najdłuższy okres liczony w dniach, w którym codziennie dopływało do zbiornika retencyjnego co najmniej 10 000 metrów sześciennych wody z rzeki Wirki? Jest tylko jeden taki okres. Podaj datę początkową i datę końcową tego okresu.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Okres: od 2015-03-17 do 2015-05-10**\n\n**Długość: 55 dni**\n\n## Sposób 1 - najdłuższa seria spełniająca warunek\n\n**Idea:** to klasyczny problem **najdłuższy ciąg w tablicy spełniający warunek**.\n\nIterujemy po dniach:\n- Jeśli `dopływ ≥ 10000` → zwiększ aktualny licznik serii, zapisz datę pierwszego dnia.\n- Jeśli `dopływ < 10000` → reset licznika.\n- Po każdym dniu sprawdź, czy aktualna seria jest najdłuższa; jeśli tak, zapisz daty.\n\n## Sposób 2 - Python\n\n```python\nlinie = []\nwith open('woda.txt', encoding='utf-8') as f:\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) == 2:\ndata, dop = cz\nlinie.append((data, int(dop)))\n\nmax_dlugosc = 0\nmax_start = ''\nmax_koniec = ''\n\nakt_dlugosc = 0\nakt_start = ''\nakt_koniec = ''\n\nfor data, dop in linie:\nif dop >= 10000:\nif akt_dlugosc == 0:\nakt_start = data\nakt_dlugosc += 1\nakt_koniec = data\nif akt_dlugosc > max_dlugosc:\nmax_dlugosc = akt_dlugosc\nmax_start = akt_start\nmax_koniec = akt_koniec\nelse:\nakt_dlugosc = 0\n\nprint(f\"Od {max_start} do {max_koniec}, długość: {max_dlugosc} dni\")\n# Od 2015-03-17 do 2015-05-10, długość: 55 dni\n\n## Sposób 3 - arkusz kalkulacyjny\n\n1. Kolumny A (data), B (dopływ).\n2. Kolumna C: `=JEŻELI(B2>=10000; 1; 0)` - wskaźnik 1/0.\n3. Kolumna D (kumulatywna seria): D1=C1; D2=`=JEŻELI(C2=1; D1+1; 0)` - rośnie gdy spełnione, resetuje gdy nie.\n4. Znajdź max D: `=MAX(D:D)` → 55.\n5. Znajdź wiersz: `=PODAJ.POZYCJĘ(55; D:D; 0)` → numer wiersza końca serii (data końcowa = A[ten wiersz]).\n6. Data początkowa = data końcowa minus 54 dni (lub o pozycję A[wiersz_końca - 54]).\n\n## Sposób 4 - C++\n\n```cpp\n#include <iostream>\n#include <fstream>\n#include <string>\nusing namespace std;\n\nint main() {\nifstream f(\"woda.txt\");\nstring data, dopStr, prevData = \"\", aktStart = \"\";\nint dop, aktDl = 0, maxDl = 0;\nstring maxStart = \"\", maxKoniec = \"\";\nwhile (f >> data >> dopStr) {\ndop = stoi(dopStr);\nif (dop >= 10000) {\nif (aktDl == 0) aktStart = data;\naktDl++;\nif (aktDl > maxDl) {\nmaxDl = aktDl;\nmaxStart = aktStart;\nmaxKoniec = data;\n}\n} else {\naktDl = 0;\n}\n}\ncout << \"Od \" << maxStart << \" do \" << maxKoniec << \" (\" << maxDl << \" dni)\" << endl;\nreturn 0;\n}\n\n## Reference informatyczny - najdłuższy podciąg spełniający warunek\n\n> Reference - Klasyczne zadania na ciągach:\n> - **Najdłuższy podciąg jedynek** (np. \"010111110001\" → 5).\n> - **Najdłuższa seria niemalejąca** w tablicy.\n> - **Najdłuższa seria z warunkiem** P(x) - uogólnienie.\n>\n> Reference - Algorytm \"running streak\":\n> - Single-pass O(n).\n> - 2 zmienne: `akt` (aktualna długość), `max` (najdłuższa do tej pory).\n> - Reset `akt = 0` gdy warunek nie spełniony.\n> - Aktualizacja `max = max(max, akt)`.\n>\n> Reference - Daty:\n> - W stringach format ISO (rrrr-mm-dd) zachowuje porządek leksykograficzny == chronologiczny.\n> - Można porównywać daty jako stringi bez konwersji.\n> - Daty są ciągłe w pliku (codziennie od 2008-01-01 do 2017-12-31).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.2, max 2 pkt):\n> - **2 pkt** - obie daty prawidłowe (2015-03-17 i 2015-05-10)\n> - **1 pkt** - tylko jedna data ALBO tylko liczba dni (55)\n> - **0 pkt** - błędna lub brak\n\n## Typowe pułapki\n\n- **\"Co najmniej 10000\"** = `>= 10000`, NIE `> 10000`. Pominięcie wartości równej 10000.\n- **Brak resetowania licznika** - wynik byłby kumulatywny i bezsensowny.\n- **Pomyłka daty początkowej** - łatwo zapomnieć zapisać `akt_start` w momencie startu serii.\n- **Liczenie dni - `koniec - start + 1`** w datach, nie `koniec - start`.\n- **Konwersja int** - `int(dop_str)` w Python, bo bez tego porównanie string < string.\n- **Iteracja w niesortowanym pliku** - plik jest już chronologicznie (data rosnąco), więc iterujemy w kolejności.\n\n## Złożoność obliczeniowa\n\n- Single-pass: **O(N)** = O(3653).\n- Pamięć: O(1) dodatkowa.","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/5.3","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"5.3","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 5.1.\n\nUtwórz i podaj zestawienie łącznej liczby metrów sześciennych wody dopływającej do zbiornika retencyjnego w kolejnych miesiącach 2008 roku (od stycznia 2008 do grudnia 2008). Na podstawie zestawienia wykonaj wykres kolumnowy. Pamiętaj o czytelnym opisie wykresu (tytuł wykresu i opisy osi).","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n| Miesiąc | Łączny dopływ wody [m³] |\n| 2008-01 | 95 433 |\n| 2008-02 | 94 730 |\n| 2008-03 | 109 439 |\n| 2008-04 | **632 931** (największy) |\n| 2008-05 | 329 203 |\n| 2008-06 | 85 628 |\n| 2008-07 | 166 597 |\n| 2008-08 | 139 747 |\n| 2008-09 | 282 342 |\n| 2008-10 | 170 729 |\n| 2008-11 | 222 440 |\n| 2008-12 | 172 072 |\n\n**Wykres**: kolumnowy, oś X = miesiąc, oś Y = dopływ [m³], tytuł: \"Dopływ wody do zbiornika retencyjnego - 2008 rok\".\n\n## Sposób 1 - agregacja miesięczna\n\n**Idea:** filtruj dane do roku 2008, sumuj wg miesiąca (pozycje 6-7 daty w formacie rrrr-mm-dd).\n\n## Sposób 2 - Python + matplotlib\n\n```python\nfrom collections import defaultdict\nimport matplotlib.pyplot as plt\n\nsumy = defaultdict(int) # \"2008-01\", \"2008-02\",\nwith open('woda.txt', encoding='utf-8') as f:\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) != 2:\ncontinue\ndata, dop = cz\nif data.startswith('2008'):\nmiesiac = data[:7] # rrrr-mm\nsumy[miesiac] += int(dop)\n\nmiesiace = sorted(sumy.keys())\nwartosci = [sumy[m] for m in miesiace]\n\nfor m, w in zip(miesiace, wartosci):\nprint(f\"{m}: {w}\")\n\nplt.figure(figsize=(12, 6))\nplt.bar(miesiace, wartosci, color='steelblue')\nplt.title('Dopływ wody do zbiornika retencyjnego - 2008 rok')\nplt.xlabel('Miesiąc')\nplt.ylabel('Łączny dopływ wody [m³]')\nplt.xticks(rotation=45)\nplt.grid(axis='y', alpha=0.3)\nplt.tight_layout()\nplt.savefig('wykres_2008.png', dpi=120)\nplt.show()\n\n## Sposób 3 - arkusz kalkulacyjny\n\n**Kroki:**\n1. Otwórz woda.txt (separator TAB).\n2. Kolumna A: data, B: dopływ.\n3. Filtruj A na 2008 (Data > Filtr > Tekst > zawiera \"2008\").\n4. **Tabela przestawna**: wiersze = miesiąc (`=LEWY(A2; 7)` w kolumnie C), wartości = SUMA B.\n5. Posortuj wiersze tabeli przestawnej alfabetycznie po miesiącu.\n6. **Wstaw → Wykres → Kolumnowy** na bazie tabeli.\n7. Dodaj tytuł: \"Dopływ wody - 2008\".\n8. Opisz osie: X = \"Miesiąc\", Y = \"Dopływ [m³]\".\n\n**Wzór alternatywny - bez tabeli przestawnej:**\n- F1:F12 - etykiety miesięcy (\"2008-01\", \"2008-02\", ).\n- G1: `=SUMA.JEŻELI(C:C; F1; B:B)` → 95433.\n- G2 G12 - analogicznie.\n- Zaznacz F1:G12, wstaw wykres kolumnowy.\n\n## Reference informatyczny - agregacja czasowa + wizualizacja\n\n> Reference - Wyciąganie miesiąca:\n> - **Format rrrr-mm-dd**: `data[:7]` = rrrr-mm (Python).\n> - **SQL**: `SUBSTRING(data, 1, 7)` lub `DATE_FORMAT(data, '%Y-%m')`.\n> - **Arkusz**: `=LEWY(A2; 7)` lub `=TEKST(A2; \"RRRR-MM\")`.\n>\n> Reference - Wykres kolumnowy vs słupkowy:\n> - **Kolumnowy** - pionowe słupki, oś X = kategorie. Dla porównania kategorii.\n> - **Słupkowy** - poziome. Gdy nazwy są długie.\n> - **Liniowy** - dla trendów czasowych.\n> - W tym zadaniu kolumnowy jest wymagany przez treść.\n>\n> Reference - Wymagania CKE dla wykresu:\n> - **Tytuł** wykresu.\n> - **Opisy osi** (oś X i Y).\n> - **Legenda** (jeśli wiele serii).\n> - **Skala** czytelna.\n> - **Kolory** kontrastowe.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.3, max 3 pkt):\n> - **1 pkt** za prawidłowe zestawienie miesięcznych sum (12 wartości)\n> - **1 pkt** za poprawny zakres i typ wykresu (kolumnowy, 12 miesięcy)\n> - **1 pkt** za czytelny opis wykresu (tytuł + opisy obu osi)\n> - **0 pkt** - błędne lub brak\n\n## Typowe pułapki\n\n- **Filtrowanie po LEWY(A;4) = \"2008\"** - uczniowie często zapominają. Bez filtra suma obejmuje wszystkie lata.\n- **Tylko styczeń-listopad** - często ostatnie miesiące pomijane. Sprawdź 12 wierszy.\n- **Brak opisu osi** - strata 1 pkt. Tytuł + opis = obowiązkowe dla CKE.\n- **Wykres liniowy zamiast kolumnowego** - strata 1 pkt.\n- **Niepoprawny zakres** - czasem wstawiana jest tylko kolumna wartości bez etykiet - wykres bez nazw miesięcy.\n- **Suma w niewłaściwych jednostkach** - wynik w m³, NIE w litrach.\n\n## Złożoność obliczeniowa\n\n- Wczytanie 3653 wierszy: O(N).\n- Filtr (data startuje na 2008): O(N).\n- Agregacja po miesiącach: O(N) z O(1) per insert.\n- Wykres: O(12) słupków.\n- **Łącznie: O(N) ≈ 3653 operacji.**","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/5.4","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"5.4","points":5,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 5.1.\n\nPoniżej opisano cykl pracy zbiornika retencyjnego:\n1) Na początku doby, zaraz po północy, wykonywany jest pomiar objętości wody w zbiorniku i na jego podstawie realizuje się pozostałe działania.\n2) Jeśli pomiar wskazuje w zbiorniku więcej niż 1 000 000 m³ wody, to nastąpiło tzw. przepełnienie zbiornika. W takiej sytuacji, niezwłocznie po wykonaniu pomiaru i stwierdzeniu przepełnienia, nadmiar wody powyżej 1 000 000 m³ jest wypuszczany ze zbiornika.\n3) Codziennie rano (o godzinie 8) ze zbiornika wypuszcza się 2% objętości wody wykazanej przez pomiar zaraz po północy. Ilość wypuszczanej wody zaokrągla się w górę do pełnych metrów sześciennych.\n\nUwaga: pomiar wykonany po północy 2008-02-01 wskazał 338 406 m³ wody.\n\nUwzględnij opisany cykl pracy zbiornika retencyjnego oraz codzienne dopływy wody z Wirki i przyjmij, że pomiar w dniu 2008-01-01 wskazywał 500 000 m³ wody, a następnie:\n\na) podaj dzień, w którym pierwszy raz wypuszczono nadmiar wody po przepełnieniu,\n\nb) podaj, w ilu dniach z podanego okresu (tj. od 2008-01-01 do 2017-12-31) w zbiorniku w momencie pomiaru znajdowało się co najmniej 800 000 m³ wody,\n\nc) podaj, ile najwięcej wody znalazłoby się w podanym okresie (tj. od 2008-01-01 do 2017-12-31) w zbiorniku (w momencie pomiaru), gdyby całkowicie zrezygnować z procedury wypuszczania nadmiaru wody powyżej 1 000 000 m³, a zbiornik miałby nieograniczoną pojemność.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**a) Data pierwszego wypuszczenia nadmiaru: 2015-04-19**\n\n**b) Liczba dni z ≥ 800 000 m³: 188 dni**\n\n**c) Maksimum bez wypuszczania nadmiaru: 1 399 242 m³**\n\n## Sposób 1 - symulacja krok po kroku\n\n**Reguły cyklu pracy zbiornika:**\n1. Pomiar po północy: V_pomiar = V_z_poprzedniego_dnia + dopływ_z_poprzedniej_doby.\n2. Jeśli V_pomiar > 1 000 000 → przepełnienie → V := 1 000 000 (nadmiar wypuszczony tego dnia).\n3. Rano (8:00) wypuszczane 2% pomiaru, zaokrąglone w górę: V := V_pomiar - ⌈0.02 · V_pomiar⌉.\n4. Następnie w ciągu doby wpływa dopływ z bieżącej daty (do następnego pomiaru).\n\n**WAŻNE - niejasność interpretacji:** Treść mówi, że pomiar 2008-02-01 to 338 406. Sprawdźmy logikę:\n- 2008-01-01: pomiar = 500 000.\n- 2008-01-01 rano: wypuść 2% = 10 000 → V = 490 000.\n- 2008-01-01 doba: dopływ 2275 → V_koniec_doby = 492 275.\n- 2008-01-02 pomiar = 492 275.\n\nKontynuując 31 dni do 2008-02-01 osiągamy 338 406 (zgadzane się z treścią).\n\n## Sposób 2 - implementacja Python\n\n```python\nimport math\n\n# Wczytaj dane\nlinie = []\nwith open('woda.txt', encoding='utf-8') as f:\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) == 2:\ndata, dop = cz\nlinie.append((data, int(dop)))\n\n# Symulacja\nV = 500000 # stan początkowy 2008-01-01\nliczba_dni_ge_800k = 0\ndata_przepelnienie = None\nmax_V_pomiar = 0 # dla podpunktu c)\nV_bez_limitu = 500000 # symulacja bez procedury wypuszczania nadmiaru\nmax_V_bez_limitu = 0\n\nfor data, dop in linie:\n# pomiar po północy = V (z końca poprzedniej doby)\nV_pomiar = V\n# podpunkt b): czy >= 800 000\nif V_pomiar >= 800000:\nliczba_dni_ge_800k += 1\n# podpunkt a): czy przepełnienie\nif V_pomiar > 1000000 and data_przepelnienie is None:\ndata_przepelnienie = data\n# 1) wypuszczenie nadmiaru\nif V_pomiar > 1000000:\nV_pomiar = 1000000\n# 2) wypuszczenie 2% (zaokr. w górę)\nwypust = math.ceil(0.02 * V_pomiar)\nV_po_wypuszczeniu = V_pomiar - wypust\n# 3) doba: dopływ\nV = V_po_wypuszczeniu + dop\n# symulacja bez limitu (podpunkt c)\nV_bez_pomiar = V_bez_limitu\nif V_bez_pomiar > max_V_bez_limitu:\nmax_V_bez_limitu = V_bez_pomiar\nwypust_bl = math.ceil(0.02 * V_bez_pomiar)\nV_bez_limitu = V_bez_pomiar - wypust_bl + dop\n\nprint(f\"a) Pierwsze wypuszczenie: {data_przepelnienie}\") # 2015-04-19\nprint(f\"b) Dni z V >= 800000: {liczba_dni_ge_800k}\") # 188\nprint(f\"c) Max V (bez limitu): {max_V_bez_limitu}\") # 1399242\n\n## Sposób 3 - arkusz kalkulacyjny\n\n**Konstrukcja:**\n1. Kolumny A (data), B (dopływ).\n2. C2 = 500000 (stan początkowy 2008-01-01).\n3. C3 i niżej - pomiar = wartość z poprzedniego dnia po wszystkich operacjach.\n4. D = `=JEŻELI(C2>1000000; 1000000; C2)` (po wypuszczeniu nadmiaru).\n5. E = `=ZAOKR.GÓRA(D2*0,02; 0)` (wypust 2%).\n6. F = `=D2 - E2 + B2` (stan na koniec doby).\n7. C3 = `=F2` - pomiar następnego dnia.\n\n**Pytania:**\n- a) Najmniejszy wiersz z C > 1 000 000 → data w A.\n- b) `=LICZ.JEŻELI(C:C; \">=800000\")` → 188.\n- c) Druga symulacja bez kroku 4 (bez przepełnienia) → MAX → 1 399 242.\n\n## Sposób 4 - C++\n\n```cpp\n#include <iostream>\n#include <fstream>\n#include <string>\n#include <cmath>\nusing namespace std;\n\nint main() {\nifstream f(\"woda.txt\");\ndouble V = 500000;\nint liczba_ge_800k = 0;\nstring data_przep = \"\";\ndouble V_bez = 500000, max_bez = 0;\nstring data, dopStr;\nwhile (f >> data >> dopStr) {\nint dop = stoi(dopStr);\ndouble V_pomiar = V;\nif (V_pomiar >= 800000) liczba_ge_800k++;\nif (V_pomiar > 1000000 && data_przep.empty()) data_przep = data;\nif (V_pomiar > 1000000) V_pomiar = 1000000;\ndouble wypust = ceil(0.02 * V_pomiar);\nV = V_pomiar - wypust + dop;\n// symulacja bez limitu\ndouble Vb_pomiar = V_bez;\nif (Vb_pomiar > max_bez) max_bez = Vb_pomiar;\ndouble wypust_b = ceil(0.02 * Vb_pomiar);\nV_bez = Vb_pomiar - wypust_b + dop;\n}\ncout << \"a) \" << data_przep << \" b) \" << liczba_ge_800k << \" c) \" << max_bez << endl;\nreturn 0;\n}\n\n## Reference informatyczny - symulacja krok po kroku\n\n> Reference - Symulacja stanu z regułami:\n> - Iteruj po krokach czasowych.\n> - W każdym kroku: zapisz stan, zastosuj reguły w określonej kolejności.\n> - Akumuluj statystyki (liczniki, maksima) w trakcie iteracji.\n>\n> Reference - Zaokrąglenie w górę:\n> - **Python**: `math.ceil(x)` lub `-(-x // 1)`.\n> - **C++**: `ceil(x)` (z `<cmath>`).\n> - **Pascal**: `Ceil(x)` (z `Math`).\n> - **Arkusz**: `=ZAOKR.GÓRA(x; 0)`.\n>\n> Reference - Stan zbiornika:\n> - Volume balance: V_next = V_current - wypust + dopływ.\n> - Constraint: V ≤ pojemność maksymalna (1 mln tu).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.4, max 5 pkt):\n> - **2 pkt** za podpunkt a) - data 2015-04-19\n> - **1 pkt** za podpunkt b) - 188 dni\n> - **2 pkt** za podpunkt c) - 1 399 242 m³\n> - **0 pkt** - błędne lub brak\n\n## Typowe pułapki\n\n- **Kolejność operacji** - kluczowa! Pomiar PRZED wypuszczeniem nadmiaru PRZED wypuszczeniem 2% PRZED dopływem.\n- **Zaokrąglenie 2% w dół zamiast w górę** - daje minimalnie inne wyniki kumulatywnie.\n- **Pomiar bieżącego dnia vs koniec poprzedniego** - pomiar TO STAN po dobie poprzedniej (= V z końca poprzedniej iteracji).\n- **Mylenie \"przepełnienie\" z \"wypuszczeniem 2%\"** - to dwie różne operacje. Wypuszczenie nadmiaru tylko gdy > 1 000 000.\n- **Granica `>=` vs `>`** - treść: \"więcej niż 1 000 000\" = `> 1 000 000`. Pomiar równy 1 000 000 NIE jest przepełnieniem.\n- **Off-by-one przy liczbie dni** - `>=` 800 000 (\"co najmniej\"), nie `>`.\n\n## Złożoność obliczeniowa\n\n- Symulacja: O(N) gdzie N = 3653.\n- Pamięć: O(1) (zmienne, brak tablic).\n- **Łącznie: O(N) ≈ 3653 iteracji.**","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/6.1","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"6.1","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Zadanie 6. Centrum danych\n\nPewna firma utrzymuje centrum danych, w którym znajduje się kilkaset pracujących komputerów. Specjalny zespół pracowników odpowiada za wykrywanie i usuwanie awarii komputerów. Pliki komputery.txt, awarie.txt oraz naprawy.txt zawierają dane niezbędne do wykonania zadania.\n\n**komputery.txt** - pola: Numer_komputera (unikatowa liczba całkowita), Sekcja (A, B, C, - wielkie litery), Pojemnosc_dysku (w GB).\nPrzykład:\nNumer_komputera | Sekcja | Pojemnosc_dysku\n1 | R | 700\n2 | N | 130\n3 | E | 300\n\n**awarie.txt** - pola: Numer_zgloszenia (unikatowy), Numer_komputera, Czas_awarii (data + godz. + sek.), Priorytet (1-10, jak krytyczna).\nPrzykład:\nNumer_zgloszenia | Numer_komputera | Czas_awarii | Priorytet\n1 | 365 | 2015-01-01 04:40:55 | 8\n2 | 249 | 2015-01-01 06:08:24 | 3\n3 | 312 | 2015-01-01 06:33:43 | 4\n\n**naprawy.txt** - pola: Numer_zgloszenia, Czas_naprawy, Rodzaj (restart/wymiana).\nPrzykład:\nNumer_zgloszenia | Czas_naprawy | Rodzaj\n2 | 2015-01-01 20:08:15 | restart\n7 | 2015-01-02 16:30:15 | restart\n4 | 2015-01-02 19:37:03 | wymiana\n\nDane w wierszach plików są oddzielone znakami tabulacji, pierwszy wiersz pliku jest wierszem nagłówkowym.\n\nZnajdź 10 najczęstszych rodzajów dysków (czyli 10 najczęściej występujących pojemności) wśród komputerów w centrum. Dla każdej ze znalezionych pojemności podaj liczbę komputerów z takim dyskiem. Posortuj zestawienie nierosnąco względem liczby komputerów z dyskiem o danej pojemności.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n| Pojemność [GB] | Liczba komputerów |\n| 300 | 173 |\n| 200 | 31 |\n| 500 | 31 |\n| 800 | 29 |\n| 700 | 28 |\n| 600 | 26 |\n| 400 | 20 |\n| 290 | 11 |\n| 220 | 10 |\n| 160 | 10 |\n\n## Sposób 1 - SQL\n\n```sql\nSELECT Pojemnosc_dysku, COUNT(*) AS liczba\nFROM komputery\nGROUP BY Pojemnosc_dysku\nORDER BY liczba DESC\nLIMIT 10;\n\nKlauzule:\n- `GROUP BY Pojemnosc_dysku` - grupuje po pojemności.\n- `COUNT(*)` - liczy ile komputerów w grupie.\n- `ORDER BY liczba DESC` - sortuje malejąco (nierosnąco).\n- `LIMIT 10` - pierwszych 10.\n\n## Sposób 2 - Python\n\n```python\nfrom collections import Counter\n\nlicznik = Counter()\nwith open('komputery.txt', encoding='utf-8') as f:\nnext(f) # header\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 3:\npojemnosc = int(cz[2])\nlicznik[pojemnosc] += 1\n\ntop10 = licznik.most_common(10)\nfor pojemnosc, liczba in top10:\nprint(f\"{pojemnosc} GB: {liczba}\")\n\n**Wynik:**\n300 GB: 173\n200 GB: 31\n500 GB: 31\n800 GB: 29\n700 GB: 28\n600 GB: 26\n400 GB: 20\n290 GB: 11\n220 GB: 10\n160 GB: 10\n\n## Sposób 3 - arkusz kalkulacyjny\n\n1. Otwórz komputery.txt (TAB).\n2. **Tabela przestawna**: wiersze = Pojemnosc_dysku, wartości = Licznik Numer_komputera.\n3. Sortuj malejąco wg licznika.\n4. Pierwsze 10 wierszy = wynik.\n\nLub bez tabeli przestawnej:\n- D1: unikatowa lista pojemności (`=USUŃ.DUPLIKATY(C:C)`).\n- E1: `=LICZ.JEŻELI(C:C; D1)`.\n- Sortuj D:E malejąco wg E, weź pierwsze 10.\n\n## Reference informatyczny - agregacja TOP-N\n\n> Reference - TOP-N w SQL:\n> - `ORDER BY x DESC LIMIT n` - standardowe (MySQL, PostgreSQL, SQLite).\n> - `TOP n` w SQL Server: `SELECT TOP 10 `.\n> - `FETCH FIRST n ROWS ONLY` w Oracle/standardzie SQL.\n>\n> Reference - Counter w Pythonie:\n> - `collections.Counter` - specjalny słownik do zliczania.\n> - `.most_common(n)` - zwraca n najczęstszych jako listę krotek.\n> - **Złożoność**: O(N) build, O(k log k) most_common gdzie k = liczba unikalnych.\n>\n> Reference - Tabela przestawna (pivot):\n> - Wiersze: pole grupujące.\n> - Wartości: funkcja agregująca (suma, licznik, średnia).\n> - Idealne do szybkich agregacji bez kodu SQL.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.1, max 2 pkt):\n> - **1 pkt** za prawidłowe zestawienie 10 par (pojemność, liczba)\n> - **1 pkt** za prawidłowe sortowanie nierosnące\n> - **0 pkt** - błędne lub brak\n\n## Typowe pułapki\n\n- **\"Nierosnąco\" = malejąco lub równo** - DESC w SQL. Niektórzy uczniowie sortują rosnąco (ASC).\n- **Pominięcie nagłówka** - `next(f)` w Pythonie lub `Readln(f, s)` w Pascal przed pętlą.\n- **Tylko sumy bez nazw** - pytanie wymaga PARY (pojemność, liczba), nie tylko liczby.\n- **Mniej niż 10 wierszy** - jeśli unikalnych pojemności < 10, wystarczy mniej, ale w tym zadaniu jest co najmniej 10.\n- **Pomyłka z konwersją int** - pojemność jako string daje błędne sortowanie (\"100\" < \"200\" leksykograficznie OK, ale \"30\" > \"200\").\n\n## Złożoność obliczeniowa\n\n- Wczytanie ~500 komputerów: O(K).\n- Agregacja: O(K).\n- Sortowanie 10 najczęstszych: O(U log U) gdzie U = liczba unikalnych pojemności.\n- **Łącznie: O(K) ≈ 500 operacji.**","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/6.2","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"6.2","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 6.1.\n\nZnajdź wszystkie komputery w sekcji A, w których trzeba było przynajmniej dziesięciokrotnie wymieniać podzespoły. Podaj ich numery, a także liczbę wymian podzespołów dla każdego z nich.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n| Komputer | Liczba wymian podzespołów |\n| Komputer 202 | 12 |\n| Komputer 123 | 11 |\n| Komputer 171 | 12 |\n| Komputer 42 | 11 |\n\n## Sposób 1 - SQL z trzema tabelami\n\n**Schemat złączeń:**\n- `komputery` (sekcja = 'A') ← `awarie` (Numer_komputera) ← `naprawy` (Numer_zgloszenia, Rodzaj = 'wymiana').\n\n```sql\nSELECT k.Numer_komputera, COUNT(*) AS liczba_wymian\nFROM komputery k\nJOIN awarie a ON k.Numer_komputera = a.Numer_komputera\nJOIN naprawy n ON a.Numer_zgloszenia = n.Numer_zgloszenia\nWHERE k.Sekcja = 'A' AND n.Rodzaj = 'wymiana'\nGROUP BY k.Numer_komputera\nHAVING COUNT(*) >= 10\nORDER BY k.Numer_komputera;\n\n## Sposób 2 - Python\n\n```python\nfrom collections import Counter\n\n# Wczytaj komputery sekcji A\nsekcja_A = set()\nwith open('komputery.txt', encoding='utf-8') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 3 and cz[1] == 'A':\nsekcja_A.add(cz[0])\n\n# Mapuj zgłoszenie -> komputer (tylko sekcja A)\nzgl_to_kom = {}\nwith open('awarie.txt', encoding='utf-8') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 4:\nzgl, kom = cz[0], cz[1]\nif kom in sekcja_A:\nzgl_to_kom[zgl] = kom\n\n# Licz wymiany\nwymiany = Counter()\nwith open('naprawy.txt', encoding='utf-8') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 3 and cz[2] == 'wymiana':\nzgl = cz[0]\nif zgl in zgl_to_kom:\nwymiany[zgl_to_kom[zgl]] += 1\n\n# Filtruj >= 10\nwynik = [(k, c) for k, c in wymiany.items() if c >= 10]\nfor k, c in sorted(wynik):\nprint(f\"Komputer {k}: {c}\")\n\n**Wynik:**\nKomputer 42: 11\nKomputer 123: 11\nKomputer 171: 12\nKomputer 202: 12\n\n## Reference informatyczny - JOIN i agregacja z filtrem\n\n> Reference - Łańcuch JOIN:\n> - 3-tablicowy JOIN: `A JOIN B ON JOIN C ON `.\n> - Klucze: A.id = B.foreign_id, B.id = C.foreign_id.\n> - Sekwencyjne JOINy są bardzo wydajne z indeksami.\n>\n> Reference - HAVING vs WHERE:\n> - `WHERE` filtruje WIERSZE PRZED agregacją (przed GROUP BY).\n> - `HAVING` filtruje GRUPY PO agregacji (po GROUP BY).\n> - `HAVING COUNT(*) >= 10` to NIE może być w `WHERE`, bo COUNT to wynik agregacji.\n>\n> Reference - \"Wymiana\" jako Rodzaj:\n> - Dane mają 2 wartości: 'restart' i 'wymiana'.\n> - Filtr `WHERE Rodzaj = 'wymiana'` ogranicza do wymian podzespołów.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.2, max 2 pkt):\n> - **2 pkt** - wszystkie 4 wyniki (komputer + liczba) prawidłowe\n> - **1 pkt** - tylko numery komputerów bez liczb wymian ALBO bez warunku `>= 10` (czyli wszystkie komputery sekcji A z liczbą wymian)\n> - **0 pkt** - błędne lub brak\n\n## Typowe pułapki\n\n- **Pominięcie filtra Rodzaj = 'wymiana'** - wtedy liczymy restartów + wymian.\n- **Pominięcie warunku Sekcja = 'A'** - wyniki dla wszystkich sekcji.\n- **Mylenie awarii z naprawami** - awaria = zgłoszenie (zdarzenie), naprawa = działanie (rodzaj: restart/wymiana). JEDEN komputer może mieć WIELE awarii, każda awaria może mieć WIELE napraw.\n- **WHERE COUNT(*) >= 10** - błąd składni. Musi być HAVING.\n- **Liczenie awarii zamiast wymian** - wymiana to jeden Rodzaj naprawy; nie wszystkie naprawy są wymianami.\n- **DISTINCT na Numer_komputera** - nieprawidłowe; wtedy każdy komputer liczy się tylko raz.\n\n## Złożoność obliczeniowa\n\n- Wczytanie 3 plików: O(K + A + N) gdzie K = ~500 komputerów, A = liczba awarii, N = liczba napraw.\n- Filtrowanie i agregacja: O(K + A + N).\n- **Łącznie: O(K + A + N).**","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/6.3","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"6.3","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 6.1.\n\nPewnego dnia nastąpiła awaria wszystkich komputerów w jednej z sekcji. Podaj datę awarii oraz symbol sekcji, w której nastąpiła awaria.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Data awarii: 23-12-2015**\n\n**Sekcja: Q**\n\n## Sposób 1 - analiza zadania\n\n**Cel:** znaleźć datę X i sekcję S takie, że WSZYSTKIE komputery sekcji S miały awarię tego dnia.\n\n**Algorytm:**\n1. Dla każdej kombinacji (data, sekcja) policz liczbę UNIKALNYCH komputerów, które miały awarię tego dnia.\n2. Dla każdej sekcji znajdź liczbę komputerów w sekcji.\n3. Znajdź kombinację gdzie obie liczby są EQ.\n\n## Sposób 2 - SQL\n\n```sql\nSELECT DATE(a.Czas_awarii) AS dzien, k.Sekcja, COUNT(DISTINCT k.Numer_komputera) AS uszkodzone\nFROM awarie a\nJOIN komputery k ON a.Numer_komputera = k.Numer_komputera\nGROUP BY DATE(a.Czas_awarii), k.Sekcja\nHAVING COUNT(DISTINCT k.Numer_komputera) = (\nSELECT COUNT(*)\nFROM komputery k2\nWHERE k2.Sekcja = k.Sekcja\n);\n\nWynik: **(2015-12-23, Q)**.\n\n## Sposób 3 - Python\n\n```python\nfrom collections import defaultdict\n\n# Wczytaj komputery: pesel -> sekcja\nkomputer_sekcja = {}\nsekcja_liczba = defaultdict(int)\nwith open('komputery.txt', encoding='utf-8') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 3:\nkom, sek = cz[0], cz[1]\nkomputer_sekcja[kom] = sek\nsekcja_liczba[sek] += 1\n\n# Mapuj (data, sekcja) -> set(komputerów z awarią tego dnia)\nawarie = defaultdict(set)\nwith open('awarie.txt', encoding='utf-8') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 4:\nkom = cz[1]\nczas = cz[2] # format: \"2015-01-01 04:40:55\"\ndata = czas[:10] # \"2015-01-01\"\nsek = komputer_sekcja.get(kom)\nif sek:\nawarie[(data, sek)].add(kom)\n\n# Znajdź (data, sekcja) gdzie awaria objęła wszystkie komputery sekcji\nfor (data, sek), uszkodzone in awarie.items():\nif len(uszkodzone) == sekcja_liczba[sek]:\nprint(f\"Data: {data}, Sekcja: {sek}, Komputerów: {len(uszkodzone)}\")\n# Data: 2015-12-23, Sekcja: Q, Komputerów: X\n\n## Sposób 4 - arkusz kalkulacyjny\n\n1. W komputery.txt: kolumna A = numer, B = sekcja.\n2. W awarie.txt: dodaj kolumnę pomocniczą E = `=LEWY(C2; 10)` (data bez godz.).\n3. JOIN: kolumna F = `=WYSZUKAJ.PIONOWO(B2; komputery!A:B; 2; FAŁSZ)` (sekcja).\n4. **Tabela przestawna**: wiersze = (E, F), wartości = LICZNIK.UNIKATOWE komputerów.\n5. Dla każdej sekcji: liczba wszystkich komputerów (`=LICZ.JEŻELI(komputery!B:B; \"Q\")`).\n6. Znajdź wiersz, gdzie liczba uszkodzonych = liczba całkowita sekcji.\n\n## Reference informatyczny - wszystkie elementy grupy\n\n> Reference - Sprawdzenie \"wszystkie z grupy\":\n> - Liczba awarii w grupie = liczba całkowita grupy → wszystkie elementy.\n> - Alternatywnie: `NOT EXISTS (SELECT 1 FROM grupa WHERE el NOT IN awarie)`.\n>\n> Reference - DATE() w SQL:\n> - `DATE(timestamp)` - wyciąga datę z timestampa.\n> - `SUBSTRING(czas, 1, 10)` - ręczne wyciągnięcie pierwszych 10 znaków.\n> - W Python: `czas[:10]` lub `datetime.strptime(czas, ).date()`.\n>\n> Reference - Korelowany podzapytanie:\n> - Podzapytanie odwołujące się do wartości z głównego zapytania.\n> - Np. `(SELECT COUNT(*) FROM komputery k2 WHERE k2.Sekcja = k.Sekcja)`.\n> - Wykonywane RAZ na wiersz głównego zapytania (potencjalnie wolne, ale tu mało danych).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.3, max 3 pkt):\n> - **2 pkt** za prawidłową datę (23-12-2015)\n> - **1 pkt** za prawidłową sekcję (Q)\n> - **0 pkt** - błędne lub brak\n\n## Typowe pułapki\n\n- **Format daty: 2015-12-23 vs 23-12-2015** - CKE oczekuje w formacie z treści (DD-MM-YYYY w odpowiedzi).\n- **Liczenie awarii zamiast komputerów** - jeden komputer może mieć WIELE awarii tego samego dnia. Liczymy UNIKALNE komputery (DISTINCT).\n- **Pomyłka sekcji** - uważać na pomyłkę z innym dniem (mogło być wiele dni z niemal-pełną awarią sekcji).\n- **Tylko COUNT na awariach** - nie wystarczy; trzeba zliczać DISTINCT lub używać set.\n- **Pominięcie warunku \"wszystkich\"** - wymóg to 100% sekcji, nie 99%.\n\n## Złożoność obliczeniowa\n\n- Wczytanie 3 plików: O(K + A + N).\n- Agregacja po (data, sekcja): O(A) z hashmapą.\n- Sprawdzenie warunku dla każdej grupy: O(S·D) gdzie S = sekcje, D = dni.\n- **Łącznie: O(A + K).**","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/6.4","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"6.4","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 6.1.\n\nZnajdź awarię, której usunięcie trwało najdłużej (czas liczymy od wystąpienia awarii do momentu zakończenia ostatniej z napraw, jakiej ta awaria wymagała). Podaj numer zgłoszenia, czas wystąpienia awarii i czas zakończenia ostatniej naprawy.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Numer zgłoszenia: 2087**\n\n**Czas wystąpienia awarii: 06-11-2015 12:38:46**\n\n**Czas zakończenia ostatniej naprawy: 13-11-2015 12:38:32**\n\n## Sposób 1 - SQL\n\n**Idea:** dla każdej awarii znajdź MAX(Czas_naprawy) (czas ostatniej naprawy), oblicz różnicę z Czas_awarii, znajdź maksimum.\n\n```sql\nSELECT a.Numer_zgloszenia, a.Czas_awarii, MAX(n.Czas_naprawy) AS ostatnia_naprawa\nFROM awarie a\nJOIN naprawy n ON a.Numer_zgloszenia = n.Numer_zgloszenia\nGROUP BY a.Numer_zgloszenia, a.Czas_awarii\nORDER BY (julianday(MAX(n.Czas_naprawy)) - julianday(a.Czas_awarii)) DESC\nLIMIT 1;\n\n(W SQLite `julianday()` zwraca dzień juliański - pozwala odjąć daty. W innych SQL: `TIMESTAMPDIFF`, `EXTRACT(EPOCH )`.)\n\n## Sposób 2 - Python\n\n```python\nfrom datetime import datetime\nfrom collections import defaultdict\n\n# Wczytaj awarie\nawarie = {}\nwith open('awarie.txt', encoding='utf-8') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 4:\nzgl, kom, czas, prio = cz[0], cz[1], cz[2], cz[3]\nawarie[zgl] = czas\n\n# Mapuj zgl -> max czas_naprawy\nmax_naprawa = defaultdict(str)\nwith open('naprawy.txt', encoding='utf-8') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 3:\nzgl, czas = cz[0], cz[1]\nif czas > max_naprawa[zgl]:\nmax_naprawa[zgl] = czas\n\n# Oblicz różnice i znajdź max\nnajwieksza_roznica = 0\nnajwiekszy_zgl = None\nfor zgl in awarie:\nif zgl in max_naprawa:\nt1 = datetime.strptime(awarie[zgl], '%Y-%m-%d %H:%M:%S')\nt2 = datetime.strptime(max_naprawa[zgl], '%Y-%m-%d %H:%M:%S')\nroznica = (t2 - t1).total_seconds()\nif roznica > najwieksza_roznica:\nnajwieksza_roznica = roznica\nnajwiekszy_zgl = zgl\n\nprint(f\"Zgłoszenie: {najwiekszy_zgl}\")\nprint(f\"Awaria: {awarie[najwiekszy_zgl]}\")\nprint(f\"Naprawa: {max_naprawa[najwiekszy_zgl]}\")\nprint(f\"Czas: {najwieksza_roznica / 3600:.1f} h\")\n\n**Wynik:**\nZgłoszenie: 2087\nAwaria: 2015-11-06 12:38:46\nNaprawa: 2015-11-13 12:38:32\nCzas: ~167 h (~7 dni)\n\n## Sposób 3 - arkusz kalkulacyjny\n\n1. awarie.txt: kolumna A = nr_zgl, B = nr_kom, C = czas_awarii, D = priorytet.\n2. naprawy.txt: kolumna A = nr_zgl, B = czas_naprawy, C = rodzaj.\n3. W awarie dodaj E = `=MAKS.WARUNKÓW(naprawy!B:B; naprawy!A:A; A2)` (max czas_naprawy dla tego nr_zgl).\n4. F = `=E2 - C2` (czas trwania, jako liczba dni - format \"liczba\" lub \"daty\").\n5. Sortuj F malejąco. Pierwsze wiersz: nr_zgl 2087.\n\n## Reference informatyczny - agregacja MAX z różnicy dat\n\n> Reference - Operacje na czasie (timestamp):\n> - **Format ISO**: `YYYY-MM-DD HH:MM:SS` - sortuje leksykograficznie = chronologicznie.\n> - **Python**: `datetime.strptime()` + `total_seconds()`.\n> - **C++**: `std::chrono` lub konwersja na sekundy od epoki.\n> - **SQL**: `julianday()`, `TIMESTAMPDIFF()`, `EXTRACT(EPOCH FROM )`.\n>\n> Reference - \"Najdłużej trwająca awaria\":\n> - Czas trwania = MAX(czas_naprawy) - czas_awarii.\n> - Awaria może mieć wiele napraw - ostatnia decyduje.\n> - GROUP BY na poziomie awarii (Numer_zgloszenia).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.4, max 3 pkt):\n> - **1 pkt** za prawidłowy numer zgłoszenia (2087)\n> - **1 pkt** za prawidłowy czas wystąpienia awarii\n> - **1 pkt** za prawidłowy czas zakończenia ostatniej naprawy\n> - **0 pkt** - błędne lub brak\n\n## Typowe pułapki\n\n- **Liczenie czasu do PIERWSZEJ naprawy** zamiast OSTATNIEJ - błędne.\n- **Pominięcie awarii bez naprawy** - niektóre awarie mogą nie mieć wpisu w naprawy.txt; powinny być pominięte.\n- **Format daty** - CKE pokazuje 06-11-2015 (DD-MM-YYYY), ale plik ma ISO (2015-11-06). Konwertuj przy wyświetlaniu.\n- **Porównanie stringami** - działa dla ISO timestampów, NIE dla DD-MM-YYYY (\"06-11-2015\" < \"13-11-2015\" zgodnie z prefiksem, ale \"06-11-2015\" > \"05-12-2015\" mimo że chronologicznie odwrotnie).\n- **MAX bez GROUP BY** - daje tylko globalny max, nie per awaria.\n\n## Złożoność obliczeniowa\n\n- Wczytanie 2 plików: O(A + N).\n- Agregacja: O(N) dla maksimum naprawy per zgłoszenie.\n- Znalezienie max różnicy: O(A).\n- **Łącznie: O(A + N).**","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2018-maj-matura-rozszerzona/zad/6.5","paper_id":"informatyka-2018-maj-matura-rozszerzona","number":"6.5","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2018,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 6.1.\n\nPodaj liczbę komputerów, które nie uległy żadnej awarii o priorytecie większym lub równym 8 (wliczamy w to też komputery, które w ogóle nie uległy awarii).","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**149 komputerów**\n\n## Sposób 1 - interpretacja\n\n**Cel:** liczba komputerów, które NIE MIAŁY ŻADNEJ awarii z priorytetem ≥ 8.\nInaczej: wszyscy komputerzy MINUS ci, którzy mieli choć jedną awarię z priorytetem ≥ 8.\n\n## Sposób 2 - SQL (NOT EXISTS / NOT IN / LEFT JOIN)\n\n**Wariant 1 - NOT IN:**\n```sql\nSELECT COUNT(*) FROM komputery\nWHERE Numer_komputera NOT IN (\nSELECT DISTINCT Numer_komputera\nFROM awarie\nWHERE Priorytet >= 8\n);\n\n**Wariant 2 - NOT EXISTS:**\n```sql\nSELECT COUNT(*) FROM komputery k\nWHERE NOT EXISTS (\nSELECT 1 FROM awarie a\nWHERE a.Numer_komputera = k.Numer_komputera AND a.Priorytet >= 8\n);\n\n**Wariant 3 - odejmowanie:**\n```sql\nSELECT (SELECT COUNT(*) FROM komputery) -\n(SELECT COUNT(DISTINCT Numer_komputera) FROM awarie WHERE Priorytet >= 8);\n\nWynik: **149**.\n\n## Sposób 3 - Python\n\n```python\nwszyscy = set()\nwith open('komputery.txt', encoding='utf-8') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 1:\nwszyscy.add(cz[0])\n\nz_wysokim = set()\nwith open('awarie.txt', encoding='utf-8') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 4:\nkom, prio = cz[1], int(cz[3])\nif prio >= 8:\nz_wysokim.add(kom)\n\nbez_wysokim = wszyscy - z_wysokim\nprint(len(bez_wysokim)) # 149\n\n## Sposób 4 - arkusz kalkulacyjny\n\n1. awarie.txt: filtruj na priorytet >= 8 → odzyskaj listę unikalnych Numer_komputera.\n2. Policz unikalnych komputerów: powiedzmy X.\n3. Wszyscy komputery: powiedzmy K (~330).\n4. Wynik = K - X.\n\nLub przez SUMA.JEŻELI z warunkiem zawartości w liście awarii.\n\n## Reference informatyczny - antyjoin\n\n> Reference - Trzy sposoby antyjoinu:\n> - **NOT EXISTS** - najbezpieczniejszy z NULLami, najszybszy z indeksem.\n> - **NOT IN** - uważać na NULLe w podzapytaniu (zwraca pustą listę).\n> - **LEFT JOIN + WHERE NULL** - często bardzo wydajny.\n>\n> Reference - Set difference w Pythonie:\n> - `A - B` zwraca elementy w A ale nie w B.\n> - **Złożoność**: O(|A| + |B|).\n> - Bezpieczne, czytelne, idiomatyczne.\n>\n> Reference - Warunek priorytetu:\n> - \"większy lub równy 8\" = `>= 8` = priorytet 8, 9, 10.\n> - \"większy od 8\" = `> 8` = priorytet 9, 10. **Częsta pomyłka** - daje wynik 221.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.5, max 2 pkt):\n> - **2 pkt** - wynik **149** (priorytet >= 8)\n> - **1 pkt** - wynik **221** (tylko priorytet > 8, ekskluzywnie)\n> - **0 pkt** - inne błędne lub brak\n\n## Typowe pułapki\n\n- **\"Większy lub równy\" mylone z \"większy\"** - KRYTYCZNA pułapka. >= 8 vs > 8. Wynik 149 vs 221.\n- **Pominięcie komputerów BEZ żadnej awarii** - treść jasno mówi \"wliczamy też tych bez awarii\". NOT IN/NOT EXISTS to zapewnia, ale podejście naiwne (LEFT JOIN na awarie z warunkiem) może je pominąć.\n- **COUNT(DISTINCT)** zamiast set - w SQL konieczne, bo komputer może mieć wiele wysokich awarii.\n- **Pominięcie konwersji int** - `int(cz[3])` w Pythonie, bo string \"10\" < \"8\" leksykograficznie.\n\n## Złożoność obliczeniowa\n\n- Wczytanie 2 plików: O(K + A).\n- Set operations: O(K + A) amortyzowane.\n- **Łącznie: O(K + A).**","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2018 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"}]}