{"paper":{"id":"informatyka-2016-maj-matura-rozszerzona","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","variant":null,"exam_pdf":"informatyka-2016-maj-matura-rozszerzona/informatyka-2016-maj-matura-rozszerzona.pdf","key_pdf":"informatyka-2016-maj-matura-rozszerzona-odpowiedzi/informatyka-2016-maj-matura-rozszerzona-odpowiedzi.pdf","question_count":23,"source_label":"Informatyka · Matura · maj 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},"questions":[{"id":"informatyka-2016-maj-matura-rozszerzona/zad/1","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"1","points":null,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 1. Liczby skojarzone\nDwie różne liczby całkowite a i b większe od 1 nazwiemy skojarzonymi, jeśli suma\nwszystkich różnych dodatnich dzielników a mniejszych od a jest równa b+1, a suma\nwszystkich różnych dodatnich dzielników b mniejszych od b jest równa a+1.\nSkojarzone są np. liczby 140 i 195, ponieważ:\na) dzielnikami 140 są 1, 2, 4, 5, 7, 10, 14, 20, 28, 35, 70, a ich suma wynosi\n196 = 195+1.\nb) dzielnikami 195 są 1, 3, 5, 13, 15, 39, 65, a suma tych liczb równa jest 141 = 140+1.","answer":null,"answer_text":"143\n214\n285\n356\n427\n498\n569\n640\n711\n782\n853\n924\n995","solution":null,"image":"img/informatyka-2016-maj-matura-rozszerzona/zad-1.webp","solution_image":null,"topics":null,"page_from":2,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":null,"text_source":"ocr","source_label":"Informatyka · Matura · maj 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/1.1","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"1.1","points":1,"ptype":"closed","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 1.1. (0-1)\nZbadaj, które z następujących par liczb (a, b) są liczbami skojarzonymi, i wypełnij poniższą\ntabelę:\na\nb\ndzielniki a\n(mniejsze od a)\ndzielniki b\n(mniejsze od b)\nsuma\ndzielników\na\nsuma\ndzielników\nb\nskojarzone\nTAK/NIE\n78\n64\n1, 2, 3, 6, 13, 26, 39\n1, 2, 4, 8, 16, 32\n90\n63\nNIE\n20\n21\n75\n48\nMiejsce na obliczenia.\nMIN_1R","answer":"a","answer_text":"Zadanie 1.1. (0-1)\nWymagania ogólne\nWymagania szczegółowe\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji […],\nz zastosowaniem podejścia algorytmicznego.\n5. Rozwiązywanie problemów i podejmowanie\ndecyzji […], stosowanie podejścia algorytmicznego.\nZdający:\n2) stosuje podejście algorytmiczne do rozwiązywania\nproblemu.\nSchemat punktowania\n1 p. - za poprawne uzupełnienie wszystkich rubryk tabeli.\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.\nPoprawna odpowiedź\na\nb\ndzielniki a\ndzielniki b\nsuma\ndzielników a\nsuma\ndzielników b\nSkojarzone?\n78\n64\n1, 2, 3, 6, 13, 26, 39 1, 2, 4, 8, 16, 32\n90\n63\nNIE\n20\n21\n1, 2, 4, 5, 10\n1, 3, 7\n22\n11\nNIE\n75\n48\n1, 3, 5, 15, 25\n1, 2, 3, 4, 6, 8, 12,\n16, 24\n49\n76\nTAK","solution":"## Poprawna odpowiedź\n\n| a | b | dzielniki a | dzielniki b | suma a | suma b | Skojarzone? |\n| 78 | 64 | 1, 2, 3, 6, 13, 26, 39 | 1, 2, 4, 8, 16, 32 | 90 | 63 | NIE |\n| 20 | 21 | **1, 2, 4, 5, 10** | **1, 3, 7** | **22** | **11** | **NIE** |\n| 75 | 48 | **1, 3, 5, 15, 25** | **1, 2, 3, 4, 6, 8, 12, 16, 24** | **49** | **76** | **TAK** |\n\n## Sposób 1 - bezpośrednie sprawdzenie definicji\n\n**Definicja:** liczby a i b są skojarzone, gdy `suma_dzielnikow_wlasciwych(a) = b + 1` ORAZ `suma_dzielnikow_wlasciwych(b) = a + 1`.\n\n**Dzielniki właściwe** = wszystkie dzielniki mniejsze od samej liczby (czyli bez n).\n\n### Para (20, 21)\n- Dzielniki 20 mniejsze od 20: `1, 2, 4, 5, 10` (sprawdzamy: 20/1=20, 20/2=10, 20/4=5, 20/5=4, 20/10=2 - wszystko OK). Suma = `1+2+4+5+10 = 22`.\n- Dzielniki 21: `1, 3, 7` (21 = 3·7). Suma = `1+3+7 = 11`.\n- Warunek: `22 = 21 + 1` ✓ (suma a = b+1), ale `11 ≠ 20 + 1 = 21` ✗.\n- **Skojarzone: NIE** (drugi warunek nie spełniony).\n\n### Para (75, 48)\n- Dzielniki 75 mniejsze od 75: `1, 3, 5, 15, 25` (75 = 3·5²). Suma = `1+3+5+15+25 = 49`.\n- Dzielniki 48: `1, 2, 3, 4, 6, 8, 12, 16, 24` (48 = 2⁴·3). Suma = `1+2+3+4+6+8+12+16+24 = 76`.\n- Warunek: `49 = 48 + 1` ✓ ORAZ `76 = 75 + 1` ✓.\n- **Skojarzone: TAK** ✓\n\n## Sposób 2 - implementacja Python (do weryfikacji)\n\n```python\ndef suma_dzielnikow_wlasciwych(n):\ns = 1 if n > 1 else 0\ni = 2\nwhile i * i <= n:\nif n % i == 0:\ns += i\nif i != n // i:\ns += n // i\ni += 1\nreturn s\n\ndef skojarzone(a, b):\nreturn suma_dzielnikow_wlasciwych(a) == b + 1 and \\\nsuma_dzielnikow_wlasciwych(b) == a + 1\n\nfor a, b in [(78, 64), (20, 21), (75, 48)]:\nsa = suma_dzielnikow_wlasciwych(a)\nsb = suma_dzielnikow_wlasciwych(b)\nprint(a, b, sa, sb, 'TAK' if skojarzone(a, b) else 'NIE')\n\nWynik:\n78 64 90 63 NIE\n20 21 22 11 NIE\n75 48 49 76 TAK\n\n## Reference informatyczny - suma dzielników\n\n> Reference - Suma dzielników właściwych:\n> - **Dzielnik właściwy** = każdy dzielnik n mniejszy od samego n.\n> - **Efektywne wyznaczanie**: pętla i od 2 do √n; jeśli n mod i = 0, dodaj i oraz n/i (pomiń duplikat gdy i = n/i).\n> - **Złożoność**: O(√n) zamiast O(n).\n> - **Liczby zaprzyjaźnione (amicable)** - pokrewna definicja: `s(a) = b` i `s(b) = a` (suma WSZYSTKICH dzielników mniejszych od n, bez \"+1\"). Para 220-284. W zadaniu CKE jest wariant z `+1`.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 1.1, max 1 pkt):\n> - **1 pkt** - wszystkie rubryki tabeli (dzielniki, sumy, TAK/NIE) poprawne dla obu nowych wierszy\n> - **0 pkt** - odpowiedź niepełna lub błędna\n\n## Typowe pułapki\n\n- **Wliczanie n do dzielników** - niektórzy uczniowie dodają n do sumy. Wtedy dla 20 suma = 42 zamiast 22.\n- **Pominięcie pary dzielników** - np. dla 75 zapomnienie o 25 (= 5²) lub o 15 (= 3·5).\n- **Pomylenie warunku** - definicja wymaga `suma(a) = b+1`, nie `suma(a) = b`.\n- **Sprawdzenie tylko jednego warunku** - para musi spełniać OBA warunki naraz; (20, 21) spełnia jeden, drugi nie - więc NIE.\n\n## Złożoność obliczeniowa\n\n- Wyznaczenie dzielników jednej liczby: **O(√n)**.\n- Sprawdzenie pary (a, b): **O(√a + √b)**.\n- Dla wszystkich par tabeli: O(1) wywołań - tabela ma 3 wiersze.","image":"img/informatyka-2016-maj-matura-rozszerzona/zad-1.1.webp","solution_image":null,"topics":null,"page_from":2,"source":"ocr","answer_source":"ocr","answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/1.2","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"1.2","points":4,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 1.2. (0-4)\nDana jest liczba całkowita a większa od 1. Ułóż i zapisz w wybranej przez siebie notacji\nalgorytm, który znajdzie i wypisze liczbę b skojarzoną z a lub komunikat „NIE”, jeśli taka\nliczba nie istnieje.\nW zapisie algorytmu możesz korzystać tylko z następujących operacji arytmetycznych:\ndodawania, odejmowania, mnożenia, dzielenia całkowitego i obliczania reszty z dzielenia.\nUwaga:\nPrzy ocenie algorytmu będzie brana pod uwagę liczba operacji arytmetycznych\nwykonywanych przez Twój algorytm.\nSpecyfikacja:\nDane:\nLiczba całkowita a > 1.\nWynik:\nLiczba całkowita b skojarzona z a lub komunikat „NIE”, jeśli taka liczba\nnie istnieje.\nAlgorytm:\nWypełnia\negzaminator\nNr zadania\n1.1.\n1.2.\nMaks. liczba pkt.\n1\n4\nUzyskana liczba pkt.\nMIN_1R","answer":null,"answer_text":"Zadanie 1.2. (0-4)\nIII. Rozwiązywanie problemów i\npodejmowanie decyzji […], z zastosowaniem\npodejścia algorytmicznego.\n5. Rozwiązywanie problemów i podejmowanie\ndecyzji […], stosowanie podejścia algorytmicznego.\nZdający:\n2) stosuje podejście algorytmiczne do rozwiązywania\nproblemu;\n4) dobiera efektywny algorytm do rozwiązania\nsytuacji problemowej i zapisuje go w wy branej\nnotacji;\n11) opisuje podstawowe algorytmy i stosuje:\na) algorytmy na liczbach całkowitych;\n18) oblicz liczbę operacji wykonywanych przez\nalgorytm.\nSchemat punktowania\n4 p. - za poprawny algorytm, w tym:\n- 3 p. - za poprawne obliczanie sumy dzielników zadanej liczby (lub potencjalnej liczby\nskojarzonej):\no 1 p. - za sumowanie kolejnych dzielników,\no 1 p. - za poprawną konstrukcję pętli,\no 1 p. - za algorytm o złożoności nie gorszej niż √݊ ;\n- 1 p. - za poprawne ustalenie liczby b oraz za sprawdzenie, czy liczby a i b są skojarzone;\n0 p. - za odpowiedź błędną albo brak odpowiedzi.\nPrzykładowa odpowiedź\nfunkcja sumadz(n) {\nsuma = 1\ni = 2\ndopóki (i*i <= n)\njeżeli (n mod i = 0)\nsuma = suma + i\njeżeli (n div i != i)\nsuma = suma + n/i\ni = i + 1\nzwróć suma\n}\nx = sumadz(a)\ny = sumadz(x-1)\njeżeli (y-1 = a)\nwypisz x-1\nw przeciwnym wypadku\nwypisz „NIE”","solution":"## Poprawna odpowiedź\n\n**Algorytm (pseudokod):**\n\nfunkcja sumadz(n):\nsuma ← 1\ni ← 2\ndopóki i*i ≤ n wykonuj:\njeżeli n mod i = 0:\nsuma ← suma + i\njeżeli n div i ≠ i:\nsuma ← suma + n div i\ni ← i + 1\nzwróć suma\n\nx ← sumadz(a) // x = suma dzielników właściwych a; szukamy b takiego, że b = x - 1\nb ← x - 1\njeżeli b > 1:\ny ← sumadz(b)\njeżeli y = a + 1:\nwypisz b\nw przeciwnym razie:\nwypisz \"NIE\"\nw przeciwnym razie:\nwypisz \"NIE\"\n\n## Sposób 1 - wykorzystanie symetrii definicji\n\n**Idea kluczowa:** definicja skojarzenia mówi `sumadz(a) = b + 1`, więc skoro znamy a, możemy **wyliczyć kandydata** `b = sumadz(a) - 1`. Potem wystarczy sprawdzić drugi warunek: czy `sumadz(b) = a + 1`.\n\n**Krok po kroku:**\n1. Oblicz `x = sumadz(a)`. To koszt O(√a).\n2. Kandydat: `b = x - 1`.\n3. Jeśli `b ≤ 1`, brak skojarzenia (b musi być > 1 z definicji).\n4. Oblicz `y = sumadz(b)`. To koszt O(√b).\n5. Jeśli `y = a + 1` - wypisz b. W przeciwnym razie wypisz „NIE”.\n\nTo daje algorytm O(√a + √b), czyli **O(√n)** ogólnie.\n\n## Sposób 2 - implementacja Python\n\n```python\ndef sumadz(n):\nif n < 2:\nreturn 0\nsuma = 1\ni = 2\nwhile i * i <= n:\nif n % i == 0:\nsuma += i\nif n // i != i:\nsuma += n // i\ni += 1\nreturn suma\n\ndef skojarzona(a):\nx = sumadz(a)\nb = x - 1\nif b <= 1:\nreturn \"NIE\"\nif sumadz(b) == a + 1:\nreturn b\nreturn \"NIE\"\n\nprint(skojarzona(75)) # 48\nprint(skojarzona(140)) # 195\nprint(skojarzona(20)) # NIE\n\n**C++:**\n```cpp\n#include \nusing namespace std;\n\nlong long sumadz(long long n) {\nif (n < 2) return 0;\nlong long s = 1;\nfor (long long i = 2; i * i <= n; i++) {\nif (n % i == 0) {\ns += i;\nif (n / i != i) s += n / i;\n}\n}\nreturn s;\n}\n\nint main() {\nlong long a; cin >> a;\nlong long x = sumadz(a);\nlong long b = x - 1;\nif (b > 1 && sumadz(b) == a + 1) cout << b;\nelse cout << \"NIE\";\nreturn 0;\n}\n\n**Pascal:**\n```pascal\nfunction Sumadz(n: LongInt): LongInt;\nvar s, i: LongInt;\nbegin\nif n < 2 then begin Sumadz := 0; Exit end;\ns := 1;\ni := 2;\nwhile i * i <= n do begin\nif n mod i = 0 then begin\ns := s + i;\nif n div i <> i then s := s + n div i;\nend;\ni := i + 1;\nend;\nSumadz := s;\nend;\n\nvar a, x, b: LongInt;\nbegin\nReadln(a);\nx := Sumadz(a);\nb := x - 1;\nif (b > 1) and (Sumadz(b) = a + 1) then Writeln(b)\nelse Writeln('NIE');\nend.\n\n## Reference informatyczny - suma dzielników w O(√n)\n\n> Reference - Wyznaczanie sumy dzielników:\n> - **Trywialne O(n)**: iteruj i od 1 do n-1, jeśli n mod i = 0 dodaj i. Za wolne dla dużych n.\n> - **O(√n)**: iteruj i od 2 do √n. Każdy dzielnik d < √n ma parę n/d > √n. Sprawdzamy `i*i ≤ n` (nie `i ≤ sqrt(n)` - żeby uniknąć błędów float).\n> - **Pułapka kwadratu doskonałego**: gdy `i = n/i` (np. n=36, i=6), nie dodawaj dwa razy.\n> - **1 jest zawsze dzielnikiem** liczby > 1, dlatego inicjujemy `suma = 1`.\n> - **Liczby doskonałe** (perfect numbers): liczby gdzie suma dzielników właściwych = sama liczba. Przykład: 6 = 1+2+3, 28 = 1+2+4+7+14.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 1.2, max 4 pkt):\n> - **3 pkt** za poprawne obliczanie sumy dzielników:\n> - 1 pkt - sumowanie dzielników\n> - 1 pkt - poprawna konstrukcja pętli\n> - 1 pkt - złożoność **nie gorsza niż O(√n)**\n> - **1 pkt** za poprawne ustalenie b oraz sprawdzenie warunku skojarzenia\n> - **0 pkt** za odpowiedź błędną\n\n**WAŻNE - warunek z treści zadania:** \"Przy ocenie będzie brana pod uwagę liczba operacji arytmetycznych\". Stąd O(√n), nie O(n).\n\n## Typowe pułapki\n\n- **Złożoność O(n)** zamiast O(√n) - utrata 1 pkt. Pętla `dla i = 1 do n-1` to klasyczna pułapka.\n- **Liczenie pary (i, n/i) dwa razy** dla kwadratu doskonałego - wynik zawyżony.\n- **Pomijanie 1** w sumie - wtedy suma zawsze o 1 mniejsza.\n- **Próba enumerowania wszystkich b** od 2 do M - nieoptymalne; lepiej skorzystać z `b = sumadz(a) - 1`.\n- **Pomylenie definicji** - w zadaniu jest `+1` po obu stronach, nie jak w klasycznych amicable numbers gdzie suma a = b a suma b = a.\n- **Pominięcie warunku `b > 1`** - z definicji a i b > 1.\n\n## Złożoność obliczeniowa\n\n- `sumadz(n)`: pętla i = 2 do √n → **O(√n)** operacji.\n- Cały algorytm: 2 wywołania sumadz → **O(√a + √b) = O(√n)**.\n- **Liczba operacji arytmetycznych**: rzędu 2√a (porównanie + mod + dodawanie w każdej iteracji).","image":"img/informatyka-2016-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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/2","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"2","points":null,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 2. Przestawienia w tablicy\nParametrem podanej poniżej funkcji przestaw jest tablica A o długości n, indeksowana od 1,\nw której znajdują się liczby całkowite. Niech klucz będzie wartością pierwszego elementu\ntablicy A. Funkcja przestawia (zamienia wzajemnie) elementy tablicy A tak, aby po jej\nwykonaniu w lewej części tablicy były wszystkie elementy tablicy mniejsze od klucza,\nnatomiast w prawej części - wszystkie większe lub równe kluczowi.\nSpecyfikacja:\nDane:\nn - liczba całkowita dodatnia\nA[1 n] - tablica liczb całkowitych\nWynik:\nA[1 n] - tablica liczb całkowitych ułożona według podanej reguły\nfunkcja przestaw(A)\nklucz ← A[1]\nw ← 1\ndla k = 2,3, ,n wykonaj\njeśli A[k] Reference - Algorytm partycji (Lomuto):\n> - Algorytm `przestaw` to **wariant partycji Lomuto** używanej w quicksort.\n> - Idea: indeks `w` wskazuje pierwszą pozycję w \"prawej\" części. Wszystko PRZED `w` to elementy mniejsze od klucza.\n> - **Klasyczna wersja Lomuto** używa ostatniego elementu jako pivot; tutaj klucz to pierwszy element, więc partycja nie kończy się umieszczeniem klucza na właściwej pozycji.\n> - **Złożoność**: O(n) - jedno przejście przez tablicę.\n> - **Niestabilność**: elementy równe i większe od klucza mogą zmienić kolejność (np. tu 6 i 5 wymieszały się z kluczem 4).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 2.1, max 2 pkt):\n> - **2 pkt** - poprawna odpowiedź A = [3, 2, 1, 5, 6, 4]\n> - **0 pkt** - odpowiedź błędna albo brak\n>\n> **Uwaga: NIE PRZYZNAJE SIĘ 1 punktu** - odpowiedź musi być w pełni poprawna.\n\n## Typowe pułapki\n\n- **Mylenie kierunku porównania** - `A[k] < klucz` (ostro mniejszy, nie ≤). Element równy kluczowi trafia do prawej części.\n- **Inkrementacja `w` przy braku zamiany** - `w` rośnie TYLKO po wykonaniu zamiany.\n- **Inicjalizacja w = 0 lub w = 2** - poprawne to **w = 1** (start od miejsca klucza A[1]).\n- **Iteracja od k = 1** zamiast k = 2 - wtedy klucz zamieniłby się ze sobą.\n- **Pomyłka z indeksowaniem od 0** w Pythonie/C++ vs od 1 w pseudokodzie CKE.\n- **Pomyłka w stanie tablicy** po zamianach - łatwo pomylić, który element gdzie powędrował. Najlepiej rysować tablicę po każdej iteracji.\n\n## Złożoność obliczeniowa\n\n- Pętla iteruje od k = 2 do n: **O(n)** iteracji.\n- W każdej iteracji stały koszt: porównanie, ewentualna zamiana (3 przypisania), inkrementacja.\n- **Łączna złożoność: O(n)** czas, **O(1)** pamięć dodatkowa (in-place).","image":"img/informatyka-2016-maj-matura-rozszerzona/zad-2.1.webp","solution_image":null,"topics":null,"page_from":4,"source":"ocr","answer_source":"ocr","answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/2.2","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"2.2","points":1,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 2.2. (0-1)\nPodaj przykład siedmioelementowej tablicy A, dla której funkcja przestaw(A) dokładnie\n5 razy wykona zamień.\nMiejsce na obliczenia.\nOdp. A =","answer":null,"answer_text":"Zadanie 2.2. (0-1)\nIII. Rozwiązywanie problemów i\npodejmowanie decyzji […], z zastosowaniem\npodejścia algorytmicznego.\n5. Rozwiązywanie problemów i podejmowanie\ndecyzji […], stosowanie podejścia algorytmicznego.\nZdający:\n2) stosuje podejście algorytmiczne do rozwiązywania\nproblemu;\n7) opracowuje i przeprowadza wszystkie etapy\nprowadzące do otrzymania poprawnego rozwiązania\nproblemu: od sformułowania specyfikacji problemu\npo testowanie rozwiązania;\n11) opisuje podstawowe algorytmy i stosuje: […]\nb) algorytmy wyszukiwania i porządkowania\n(sortowania);\n17) Zdający ocenia zgodność algorytmu ze\nspecyfikacją problemu.\nSchemat punktowania\n1 p. - za poprawną odpowiedź.\n0 p. - za podanie odpowiedzi z tablicą większą niż 7-elementową lub odpowiedź błędną albo brak\nodpowiedzi.\nPrzykładowa odpowiedź\n[8,1,2,3,4,5,9]\nUwaga\nPoprawną odpowiedzią jest podanie dowolnej siedmioelementowej tablicy, w której dokładnie pięć\nelementów z pozycji 2…7 jest mniejszych od elementu pierwszego.","solution":"## Poprawna odpowiedź\n\n**A = [8, 1, 2, 3, 4, 5, 9]**\n\n## Sposób 1 - analiza warunku zamiany\n\n**Kiedy `zamień` jest wykonywany?** Tylko gdy `A[k] < klucz`, gdzie `klucz = A[1]`.\n\nDla tablicy 7-elementowej iterujemy k od 2 do 7 (6 razy). Aby `zamień` wykonał się **dokładnie 5 razy**, dokładnie 5 z elementów A[2 7] musi być **mniejszych od A[1]**.\n\n**Konstrukcja przykładu:**\n1. Wybierz dużą wartość jako klucz: np. **A[1] = 8**.\n2. Wstaw 5 wartości MNIEJSZYCH od 8 na pozycjach 2-7: np. 1, 2, 3, 4, 5.\n3. Wstaw 1 wartość WIĘKSZĄ lub równą 8 na jednej z pozycji 2-7: np. **A[7] = 9**.\n\n**A = [8, 1, 2, 3, 4, 5, 9]** → 5 elementów (1, 2, 3, 4, 5) < klucza 8; jeden (9) ≥ 8.\n\n## Sposób 2 - weryfikacja symulacją\n\n**Stan:** A = [8, 1, 2, 3, 4, 5, 9], klucz = 8, w = 1.\n\n| k | A[k] | < 8? | zamień(A[w], A[k]) | A po | w po |\n| 2 | 1 | TAK | zamień(A[1], A[2]) | [1,8,2,3,4,5,9] | 2 |\n| 3 | 2 | TAK | zamień(A[2], A[3]) | [1,2,8,3,4,5,9] | 3 |\n| 4 | 3 | TAK | zamień(A[3], A[4]) | [1,2,3,8,4,5,9] | 4 |\n| 5 | 4 | TAK | zamień(A[4], A[5]) | [1,2,3,4,8,5,9] | 5 |\n| 6 | 5 | TAK | zamień(A[5], A[6]) | [1,2,3,4,5,8,9] | 6 |\n| 7 | 9 | NIE | - | [1,2,3,4,5,8,9] | 6 |\n\n**Liczba zamian: 5** ✓\n\n## Sposób 3 - inne poprawne przykłady\n\nKażda tablica `[K, a, b, c, d, e, X]` gdzie:\n- `K` to klucz (dowolna wartość),\n- `a, b, c, d, e` to 5 wartości mniejszych od K (mogą być takie same),\n- `X` to 1 wartość ≥ K,\n- pozycje 5 mniejszych i 1 większego mogą być w dowolnej kolejności wśród A[2 7].\n\n**Inne poprawne odpowiedzi:**\n- A = [10, 1, 1, 1, 1, 1, 10]\n- A = [5, 3, 2, 9, 1, 4, 0] → wartości < 5: 3, 2, 1, 4, 0 (5 sztuk); ≥ 5: 9 (jeden)\n- A = [100, 99, 50, 1, 200, 25, 30]\n\n```python\ndef policz_zamiany(A):\nklucz = A[0]\nzamiany = 0\nfor k in range(1, len(A)):\nif A[k] < klucz:\nzamiany += 1\nreturn zamiany\n\nprint(policz_zamiany([8, 1, 2, 3, 4, 5, 9])) # 5\nprint(policz_zamiany([10, 1, 1, 1, 1, 1, 10])) # 5\n\n## Reference informatyczny - liczba operacji w algorytmach partycji\n\n> Reference - Analiza operacji partycji:\n> - Liczba wywołań `zamień` w `przestaw` = liczba elementów A[2 n] mniejszych od A[1].\n> - **Maksimum**: gdy wszystkie n-1 elementów są < klucza → n-1 zamian.\n> - **Minimum**: gdy żaden element nie jest < klucza → 0 zamian (tablica posortowana niemalejąco, klucz na pierwszej pozycji).\n> - Tutaj dokładnie 5 z 6 elementów po prawej musi być mniejszych.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 2.2, max 1 pkt):\n> - **1 pkt** - dowolny poprawny przykład (klucz + 5 mniejszych + 1 ≥ klucz wśród A[2 7])\n> - **0 pkt** - tablica większa/mniejsza niż 7 elementów ALBO odpowiedź błędna ALBO brak\n\n## Typowe pułapki\n\n- **Tablica nie 7-elementowa** - punkt nie zostanie przyznany. Klucz CKE wyraźnie: \"7-elementowej tablicy\".\n- **6 mniejszych** zamiast 5 - wynikiem byłoby 6 zamian, nie 5.\n- **4 mniejsze** - wynikiem byłoby 4 zamiany.\n- **Pomylenie ostrej nierówności** - wartość RÓWNA kluczowi NIE wywoła zamian (warunek to `<`, nie `≤`).\n- **Klucz na innej pozycji niż A[1]** - definicja jasno mówi `klucz ← A[1]`, więc klucz to ZAWSZE pierwszy element.\n\n## Złożoność obliczeniowa\n\n- Konstrukcja przykładu: O(1).\n- Weryfikacja przykładu (symulacja): O(n) = O(7) = O(1).","image":"img/informatyka-2016-maj-matura-rozszerzona/zad-2.2.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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/2.3","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"2.3","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 2.3. (0-3)\nTablica A[1 100] zawiera wszystkie liczby całkowite z przedziału <1, 100> w następującej\nkolejności:\nA = [10, 20, 30, , 100, 9, 19, 29, , 99, 8, 18, 28, , 98, , 1, 11, 21, , 91].\n(najpierw rosnąco wszystkie liczby kończące się na 0, potem rosnąco liczby kończące się\nna 9, potem na 8 itd.)\nPodaj wartość zmiennej w oraz wartości trzech pierwszych elementów tablicy A (A[1], A[2],\nA[3]), po wykonaniu funkcji przestaw(A).\nMiejsce na obliczenia.\nOdp. w =\nA[1] = , A[2] = A[3] =\nWypełnia\negzaminator\nNr zadania\n2.1.\n2.2.\n2.3.\nMaks. liczba pkt.\n2\n1\n3\nUzyskana liczba pkt.\nMIN_1R","answer":null,"answer_text":"Zadanie 2.3. (0-3)\nIII. Rozwiązywanie problemów i\npodejmowanie decyzji […], z zastosowaniem\npodejścia algorytmicznego.\n5. Rozwiązywanie problemów i podejmowanie\ndecyzji […], stosowanie podejścia algorytmicznego.\nZdający:\n2) stosuje podejście algorytmiczne do rozwiązywania\nproblemu;\n7) opracowuje i przeprowadza wszystkie etapy\nprowadzące do otrzymania poprawnego rozwiązania\nproblemu: od sformułowania specyfikacji problemu\npo testowanie rozwiązania;\n11) opisuje podstawowe algorytmy i stosuje: […]\nb) algorytmy wyszukiwania i porządkowania\n(sortowania);\n17) Zdający ocenia zgodność algorytmu ze\nspecyfikacją problemu.\nSchemat punktowania\n3 p. - za odpowiedź poprawną, w tym:\n- 1 p. - za poprawną wartość w\n- 2 p. - za poprawne wszystkie trzy wartości A[1], A[2] i A[3].\n0 p. - za odpowiedź błędną albo brak odpowiedzi.\nPoprawna odpowiedź\nw = 10\nA[1] = 9\nA[2] = 8\nA[3] = 7\nUwaga\nZa poprawne dwie z trzech wartości A[1], A[2] i A[3] - 1 punkt.","solution":"## Poprawna odpowiedź\n\n**w = 10**\n\n**A[1] = 9, A[2] = 8, A[3] = 7**\n\n## Sposób 1 - analiza struktury tablicy\n\n**Struktura tablicy A[1 100]:**\n- A[1 10] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] (kończące się na 0)\n- A[11 20] = [9, 19, 29, 39, 49, 59, 69, 79, 89, 99] (kończące się na 9)\n- A[21 30] = [8, 18, 28, 38, 48, 58, 68, 78, 88, 98] (kończące się na 8)\n- A[91 100] = [1, 11, 21, 31, 41, 51, 61, 71, 81, 91] (kończące się na 1)\n\n**Klucz = A[1] = 10.**\n\n**Ile elementów A[2 100] jest mniejszych od 10?** To liczby ze zbioru {1, 2, 3, 4, 5, 6, 7, 8, 9} = **9 elementów**.\n\n**Pozycje tych 9 elementów w tablicy:**\n- 9 → A[11] (pierwszy element grupy kończących się na 9, czyli najmniejsza wartość w tej grupie)\n- 8 → A[21]\n- 7 → A[31]\n- 6 → A[41]\n- 5 → A[51]\n- 4 → A[61]\n- 3 → A[71]\n- 2 → A[81]\n- 1 → A[91]\n\n## Sposób 2 - symulacja kluczowych kroków\n\nIterujemy k od 2 do 100. Pierwsze 9 elementów mniejszych od 10 napotykamy na pozycjach 11, 21, 31, 41, 51, 61, 71, 81, 91.\n\n**Krok dla k = 11 (A[11] = 9 < 10):** zamień(A[1], A[11]). Stan przed: A[1]=10, A[2 10]=[20,30, ,100], A[11]=9. Stan po:\n- A[1] = **9**\n- A[11] = 10\n- w → 2\n\n**Krok dla k = 21 (A[21] = 8 < 10):** zamień(A[2], A[21]). Przed: A[2] = 20, A[21] = 8. Po:\n- A[2] = **8**\n- A[21] = 20\n- w → 3\n\n**Krok dla k = 31 (A[31] = 7 < 10):** zamień(A[3], A[31]). Przed: A[3] = 30, A[31] = 7. Po:\n- A[3] = **7**\n- A[31] = 30\n- w → 4\n\nKolejne zamiany umieszczają 6, 5, 4, 3, 2, 1 na pozycjach A[4] A[9], a w rośnie do 10.\n\n**Po wszystkich 9 zamianach: w = 10.**\n\n## Sposób 3 - implementacja Python (weryfikacja)\n\n```python\n# Konstrukcja tablicy A\nA = []\nfor ostatnia_cyfra in [0, 9, 8, 7, 6, 5, 4, 3, 2, 1]:\nfor tens in range(0, 10):\nliczba = tens * 10 + ostatnia_cyfra\nif liczba == 0:\nliczba = 100 # przyjmujemy 100 w grupie \"kończą się na 0\"\nA.append(liczba)\n\n# Sprawdźmy pierwszych 11 elementów\nprint(A[:11]) # [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 9]\n\n# Wykonaj funkcję przestaw\nklucz = A[0]\nw = 0\nfor k in range(1, len(A)):\nif A[k] < klucz:\nA[w], A[k] = A[k], A[w]\nw += 1\n\nprint(\"w =\", w + 1) # w w pseudokodzie indeksowany od 1\nprint(\"A[1 3] =\", A[0], A[1], A[2]) # 9 8 7\n\nWynik:\nw = 10\nA[1 3] = 9 8 7\n\n## Reference informatyczny - partycja Lomuto na konkretnej tablicy\n\n> Reference - Stan końcowy partycji `przestaw`:\n> - Po pętli `w - 1` to liczba elementów `A[2 n]` mniejszych od klucza.\n> - Zatem **w = (liczba mniejszych) + 1**.\n> - Tutaj: 9 mniejszych → **w = 10**.\n> - W lewej części A[1 w-1] = A[1 9] znajdują się wszystkie elementy < klucza, w **kolejności, w jakiej zostały napotkane** podczas iteracji.\n> - Bo iterujemy k = 11, 21, 31, , 91 i wstawiamy 9, 8, 7, , 1 - **kolejność: 9, 8, 7, 6, 5, 4, 3, 2, 1**.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 2.3, max 3 pkt):\n> - **1 pkt** za poprawną wartość w = 10\n> - **2 pkt** za poprawne wszystkie trzy A[1], A[2], A[3] (= 9, 8, 7)\n> - **Uwaga: 2 z 3 wartości A[1] A[3] dają 1 pkt**\n> - **0 pkt** za odpowiedź błędną\n\n## Typowe pułapki\n\n- **Pomylenie kolejności kończących się na cyfry** - w pseudokodzie problemu cyfry są: 0, 9, 8, 7, (NIE rosnąco 1, 2, 3, ).\n- **Liczenie elementów ≤ 10** zamiast < 10 - to dałoby 10 elementów, ale klucz 10 nie jest < 10, więc i tak 9.\n- **Założenie, że tablica jest pomieszana losowo** - tu jest deterministyczna struktura ułożona w bloki.\n- **Pomyłka z wartościami zamienianymi** - pierwsza zamiana to A[1]↔A[11], wstawiająca 9 na pozycję 1 (nie A[2]↔A[11]).\n- **Off-by-one w w**: w startuje od 1; po każdej zamianie rośnie o 1. Po 9 zamianach w = 1 + 9 = 10.\n\n## Złożoność obliczeniowa\n\n- Algorytm O(n) = O(100) operacji.\n- Liczba zamian: 9 (= liczba elementów < klucza).","image":"img/informatyka-2016-maj-matura-rozszerzona/zad-2.3.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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/3","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"3","points":null,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 3. Test\nOceń, czy poniższe zdania są prawdziwe. Zaznacz P, jeśli zdanie jest prawdziwe,\nalbo F - jeśli zdanie jest fałszywe.\nW każdym zadaniu cząstkowym punkt uzyskasz tylko za komplet poprawnych odpowiedzi.","answer":null,"answer_text":null,"solution":null,"image":"img/informatyka-2016-maj-matura-rozszerzona/zad-3.webp","solution_image":null,"topics":null,"page_from":6,"source":"ocr","answer_source":null,"answer_text_source":null,"solution_source":null,"text_source":"ocr","source_label":"Informatyka · Matura · maj 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/3.1","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"3.1","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 3.1. (0-1)\nPo wpisaniu w pasku adresu przeglądarki http://81.219.47.83 otwiera się strona Centralnej\nKomisji Egzaminacyjnej, ale po wpisaniu http://cke.edu.pl pojawia się błąd „Nie można\nodnaleźć podanej strony”. Możliwe przyczyny tego stanu rzeczy to:\n1.\nawaria serwera SMTP Centralnej Komisji Egzaminacyjnej,\nP\nF\n2.\nawaria serwera poczty użytkownika,\nP\nF\n3.\nawaria serwera DNS,\nP\nF\n4.\nbrak prawidłowego klucza szyfrującego w przeglądarce.\nP\nF","answer":null,"answer_text":"Zadanie 3.1. (0-1)\nI. Bezpieczne posługiwanie się komputerem i\njego oprogramowaniem, wykorzystanie sieci\nkomputerowej. Komunikowanie się za\npomocą komputera i technologii\ninformacyjno-komunikacyjnych.\n1. Posługiwanie się komputerem i jego\noprogramowaniem, korzysta z sieci komputerowej.\nZdający:\n3) przedstawia warstwowy model sieci\nkomputerowych, określa ustawienia sieciowe dane\ngo komputera i jego lokalizacji w sieci, opisuje\nzasady administrowania siecią komputerową\nw architekturze klient-serwer, prawidłowo posługuje\nsię terminologią sieciową, korzysta z usług w sieci\nkomputerowej, lokalnej i globalnej, związanych\nz dostępem do informacji, wymianą informacji\ni 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ź\nF, F, P, F.","solution":"## Poprawna odpowiedź\n\n**1) F, 2) F, 3) P, 4) F**\n\n## Sposób 1 - analiza diagnostyczna\n\n**Kluczowa obserwacja:** Strona otwiera się przez adres IP (`http://81.219.47.83`), ale NIE otwiera się przez nazwę domeny (`http://cke.edu.pl`). To **klasyczny objaw problemu z DNS**.\n\n**Jak działa DNS?** Gdy wpisujesz `cke.edu.pl`, przeglądarka pyta serwer DNS o IP. Serwer DNS odpowiada np. `81.219.47.83`. Dopiero wtedy przeglądarka łączy się z serwerem WWW. Jeśli DNS nie działa, nazwa NIE zostanie zamieniona na IP, ale bezpośredni wpis IP wciąż działa.\n\n## Sposób 2 - analiza poszczególnych stwierdzeń\n\n### Stwierdzenie 1: Awaria serwera SMTP CKE → **F**\n\n**SMTP** (Simple Mail Transfer Protocol, port 25) służy do **wysyłania e-maili**. Nie ma związku z wyświetlaniem strony WWW. Awaria SMTP nie wpłynie ani na HTTP, ani na DNS.\n\n### Stwierdzenie 2: Awaria serwera poczty użytkownika → **F**\n\nSerwer poczty użytkownika (POP3/IMAP/SMTP) odpowiada za pobieranie i wysyłanie e-maili. Nie ma związku z przeglądaniem WWW przez HTTP ani z DNS.\n\n### Stwierdzenie 3: Awaria serwera DNS → **P**\n\n**TO JEST WŁAŚCIWA PRZYCZYNA.** Bez działającego DNS przeglądarka nie zamieni `cke.edu.pl` na `81.219.47.83`. Dlatego nazwa domeny zwraca błąd, ale wprowadzenie adresu IP bezpośrednio omija DNS i działa.\n\n### Stwierdzenie 4: Brak klucza szyfrującego → **F**\n\nKlucz szyfrujący dotyczy HTTPS/TLS (port 443). Adres `http://` (port 80) **nie używa szyfrowania**, więc klucze SSL/TLS są bez znaczenia. Ponadto, błąd byłby inny (np. \"ten certyfikat nie jest zaufany\"), nie \"nie można odnaleźć strony\".\n\n## Reference informatyczny - DNS\n\n> Reference - DNS (Domain Name System):\n> - **Funkcja**: tłumaczenie nazw domenowych (`cke.edu.pl`) na adresy IP (`81.219.47.83`).\n> - **Port**: 53 (UDP, czasem TCP).\n> - **Hierarchia**: root (`.`) → TLD (`.pl`) → SLD (`cke.edu.pl`) → hosty.\n> - **Cache**: przeglądarka, system operacyjny, router lokalny i ISP cache'ują odpowiedzi DNS, aby unikać powtórnych zapytań.\n> - **Awaria DNS** = nie można rozwiązać nazwy; bezpośredni wpis IP omija DNS i działa.\n>\n> Reference - Protokoły aplikacyjne i porty:\n> | Protokół | Port | Funkcja |\n> |----------|------|---------|\n> | HTTP | 80 | strony WWW |\n> | HTTPS | 443 | strony WWW szyfrowane (TLS) |\n> | SMTP | 25 | wysyłka e-maili |\n> | POP3 | 110 | odbiór e-maili |\n> | IMAP | 143 | odbiór e-maili (zdalnie) |\n> | DNS | 53 | nazwy domenowe |\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 3.1, max 1 pkt):\n> - **1 pkt** - wszystkie 4 odpowiedzi poprawne: F, F, P, F\n> - **0 pkt** - odpowiedź niepełna lub błędna\n\n## Typowe pułapki\n\n- **Mylenie SMTP z HTTP** - uczniowie nieraz utożsamiają \"awaria serwera CKE\" z wszelkimi problemami, jednak SMTP nie ma związku z WWW.\n- **Klucz szyfrujący kojarzy się z `https://`** - ale w zadaniu jest `http://` (bez 's').\n- **\"Awaria serwera poczty użytkownika\"** może brzmieć podobnie, ale nie wpływa na WWW.\n- **Niesprawdzenie definicji DNS** - kluczowy objaw (IP działa, nazwa nie) jednoznacznie wskazuje na DNS.\n\n## Złożoność obliczeniowa\n\nN/A - zadanie teoretyczne z zakresu sieci komputerowych. Analiza zajmuje O(1) - bezpośrednie zastosowanie wiedzy o protokołach.","image":"img/informatyka-2016-maj-matura-rozszerzona/zad-3.1.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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/3.2","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"3.2","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 3.2. (0-1)\nDana jest funkcja f określona wzorem rekurencyjnym\n( )\n(\n)\n( )\n1\n4\n1\n1\ndla\n1\n1\nf\nf n\nn\nf n\n\n\n≥\n\n\nWtedy:\n1.\n( )\n1\n8\n3\nf\nP\nF\n2.\n( )\n3\n9\n4\nf\nP\nF\n3.\n(\n)\n10\n4\nf\nP\nF\n4.\n(\n)\n1\n100\n3\nf\nP\nF\nMiejsce na obliczenia.\nMIN_1R","answer":null,"answer_text":"Zadanie 3.2. (0-1)\nIII. Rozwiązywanie problemów i\npodejmowanie decyzji […], z zastosowaniem\npodejścia algorytmicznego.\n5. Rozwiązywanie problemów i podejmowanie\ndecyzji […], stosowanie podejścia algorytmicznego.\nZdający:\n9) stosuje rekurencję w prostych sytuacjach\nproblemowych.\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, F.","solution":"## Poprawna odpowiedź\n\n**1) F, 2) P, 3) P, 4) F**\n\n## Sposób 1 - wyznaczenie cyklu funkcji\n\n**Obliczamy kolejne wartości:**\n\n- f(1) = **4**\n- f(2) = 1 / (1 - 4) = 1 / (-3) = **-1/3**\n- f(3) = 1 / (1 - (-1/3)) = 1 / (4/3) = **3/4**\n- f(4) = 1 / (1 - 3/4) = 1 / (1/4) = **4** ← powtarza się f(1)\n- f(5) = f(2) = -1/3\n- f(6) = f(3) = 3/4\n- f(7) = f(4) = 4\n\n**Funkcja jest cykliczna z okresem 3!** Wartość f(n) zależy tylko od `(n - 1) mod 3`:\n- `(n - 1) mod 3 = 0` → f(n) = **4**\n- `(n - 1) mod 3 = 1` → f(n) = **-1/3**\n- `(n - 1) mod 3 = 2` → f(n) = **3/4**\n\n## Sposób 2 - sprawdzenie poszczególnych stwierdzeń\n\n### f(8) = 1/3?\n(8 - 1) mod 3 = 7 mod 3 = 1 → f(8) = **-1/3**, NIE 1/3.\n**→ F (Fałsz).** Wartość to -1/3, nie +1/3 (uwaga na znak!).\n\n### f(9) = 3/4?\n(9 - 1) mod 3 = 8 mod 3 = 2 → f(9) = **3/4**. ✓\n**→ P (Prawda).**\n\n### f(10) = 4?\n(10 - 1) mod 3 = 9 mod 3 = 0 → f(10) = **4**. ✓\n**→ P (Prawda).**\n\n### f(100) = -1/3?\n(100 - 1) mod 3 = 99 mod 3 = 0 → f(100) = **4**, NIE -1/3.\n**→ F (Fałsz).**\n\n## Sposób 3 - implementacja Python (weryfikacja)\n\n```python\nfrom fractions import Fraction\n\ndef f(n):\nval = Fraction(4)\nfor _ in range(n - 1):\nval = Fraction(1) / (Fraction(1) - val)\nreturn val\n\nfor n in [1, 2, 3, 4, 8, 9, 10, 100]:\nprint(f\"f({n}) = {f(n)}\")\n\nWynik:\nf(1) = 4\nf(2) = -1/3\nf(3) = 3/4\nf(4) = 4\nf(8) = -1/3\nf(9) = 3/4\nf(10) = 4\nf(100) = 4\n\n## Reference informatyczny - rekurencja cykliczna\n\n> Reference - Funkcje cykliczne:\n> - Jeżeli ciąg rekurencyjny `a_{n+1} = g(a_n)` powraca do wartości startowej po k krokach (`a_{1+k} = a_1`), to ma **okres k**.\n> - Wtedy `a_n` zależy tylko od `(n - 1) mod k`.\n> - W tym zadaniu k = 3; cykl to (4, -1/3, 3/4, 4, -1/3, 3/4, ).\n>\n> Reference - Iterowane przekształcenia ułamkowe (Möbius transformations):\n> - Funkcja `g(x) = 1/(1-x)` to przekształcenie Möbiusa z okresem 3 (działa to dla bardzo wielu wartości startowych).\n> - Cyklem 3-elementowym tej funkcji są: x, 1/(1-x), (x-1)/x. Dla x=4 daje to dokładnie 4 → -1/3 → 3/4 → 4.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 3.2, max 1 pkt):\n> - **1 pkt** - wszystkie 4 odpowiedzi poprawne: F, P, P, F\n> - **0 pkt** - odpowiedź niepełna lub błędna\n\n## Typowe pułapki\n\n- **Pominięcie znaku minus** - f(8) = -1/3, a stwierdzenie mówi +1/3. Łatwo przeoczyć.\n- **Zła wartość mod dla 99** - niektórzy uczniowie zakładają `99 mod 3 ≠ 0`, ale 99 = 33·3, więc 99 mod 3 = **0**.\n- **Liczenie ręcznie do f(100)** zamiast skorzystać z okresu - strata czasu i ryzyko błędu rachunkowego.\n- **Mylenie `n` z `(n-1)`** w wyznaczaniu pozycji w cyklu - formula używa **(n-1) mod 3** bo f(1) startuje cykl.\n- **Niesprawdzenie cyklu** - niektórzy uczniowie obliczają f(8) krok po kroku, zamiast zauważyć powtarzanie po 3 iteracjach.\n\n## Złożoność obliczeniowa\n\n- Naiwne wyznaczanie f(n): O(n) iteracji.\n- Z wykorzystaniem cyklu: **O(1)** po wykryciu okresu.","image":"img/informatyka-2016-maj-matura-rozszerzona/zad-3.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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/3.3","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"3.3","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 3.3. (0-1)\nDla dwóch liczb 1111(2) i 101(2), ich\n1.\nsuma jest równa 10110(2).\nP\nF\n2.\nróżnica jest równa 1010(2).\nP\nF\n3.\niloczyn jest mniejszy od 110000(2).\nP\nF\n4.\niloraz jest większy od 10(2).\nP\nF\nMiejsce na obliczenia.","answer":null,"answer_text":"Zadanie 3.3. (0-1)\nIII. Rozwiązywanie problemów i\npodejmowanie decyzji […], z zastosowaniem\npodejścia algorytmicznego.\n5. Rozwiązywanie problemów i podejmowanie\ndecyzji […], stosowanie podejścia algorytmicznego.\nZdający:\n11) opisuje podstawowe algorytmy i stosuje\na) algorytmy na liczbach całkowitych.\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, F, P.","solution":"## Poprawna odpowiedź\n\n**1) F, 2) P, 3) F, 4) P**\n\n## Sposób 1 - konwersja na dziesiętne i obliczenia\n\n**Dane:**\n- 1111₂ = 8 + 4 + 2 + 1 = **15**\n- 101₂ = 4 + 0 + 1 = **5**\n\n### Stwierdzenie 1: Suma = 10110₂\n\n15 + 5 = **20**.\n10110₂ = 16 + 4 + 2 = **22** ≠ 20.\n**→ F.** Suma wynosi 20 = 10100₂, nie 10110₂.\n\n### Stwierdzenie 2: Różnica = 1010₂\n\n15 - 5 = **10**.\n1010₂ = 8 + 2 = **10** ✓.\n**→ P.**\n\n### Stwierdzenie 3: Iloczyn < 110000₂\n\n15 · 5 = **75**.\n110000₂ = 32 + 16 = **48**.\nCzy 75 < 48? **NIE.**\n**→ F.** Iloczyn 75 jest WIĘKSZY od 48.\n\n### Stwierdzenie 4: Iloraz > 10₂\n\n15 / 5 = **3** (dzielenie bez reszty).\n10₂ = **2**.\nCzy 3 > 2? **TAK.**\n**→ P.**\n\n## Sposób 2 - działania bezpośrednio w systemie binarnym\n\n### Suma binarna (15 + 5 = 20)\n\n1111\n+ 101\n10100\nKrok po kroku (od prawej): 1+1=10 (zapis 0, przeniesienie 1); 1+0+1=10 (zapis 0, przeniesienie 1); 1+1+1=11 (zapis 1, przeniesienie 1); 1+0+1=10 (zapis 0, przeniesienie 1); przeniesienie → 1. Wynik: **10100₂** = 20. (NIE 10110₂.)\n\n### Różnica binarna (15 - 5 = 10)\n\n1111\n- 101\n1010\n**1010₂** = 10. ✓\n\n### Iloczyn binarny (15 · 5 = 75)\n\n1111\n· 101\n1111\n0000\n1111\n1001011\n**1001011₂** = 64+8+2+1 = 75. Porównanie z 110000₂ = 48: 75 > 48.\n\n### Iloraz binarny (15 / 5 = 3)\n\nDzielenie pisemne lub po prostu 15:5 = 3 = **11₂**. Porównanie z 10₂ = 2: 11₂ (3) > 10₂ (2).\n\n## Reference informatyczny - system binarny\n\n> Reference - Konwersja binarna ↔ dziesiętna:\n> - `b_n b_{n-1} b_1 b_0` (binarnie) = `b_n · 2^n + b_{n-1} · 2^(n-1) + + b_1 · 2 + b_0` (dziesiętnie).\n> - Wartości węzłowe:\n> - 2⁰=1, 2¹=2, 2²=4, 2³=8, 2⁴=16, 2⁵=32, 2⁶=64, 2⁷=128.\n> - 1010₂ = 10, 10100₂ = 20, 10110₂ = 22, 110000₂ = 48, 1001011₂ = 75.\n> - **Dodawanie binarne**: 0+0=0, 0+1=1, 1+0=1, 1+1=10 (z przeniesieniem).\n> - **Mnożenie binarne**: standardowy algorytm szkolny dla każdej cyfry mnożnika.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 3.3, max 1 pkt):\n> - **1 pkt** - wszystkie 4 odpowiedzi poprawne: F, P, F, P\n> - **0 pkt** - odpowiedź niepełna lub błędna\n\n## Typowe pułapki\n\n- **Pomylenie 10100₂ z 10110₂** - łatwo pomylić cyfry. Krok po kroku dodawania jest kluczowy.\n- **Pomylenie znaczenia \"mniejszy\"** - \"iloczyn < 110000₂\" znaczy 75 < 48? FAŁSZ. Wielu uczniów myli kierunek nierówności.\n- **Rachunki binarne** - wymagają uważności. Lepiej konwertować na dziesiętne, policzyć, i konwertować spowrotem.\n- **Liczenie iloczynu jako sumy bitów** - błędna metoda. To MNOŻENIE, nie XOR ani AND.\n- **Niepoprawne wykonanie konwersji 110000₂** - 110000₂ = 1·32 + 1·16 = 48, nie 30 lub 60.\n\n## Złożoność obliczeniowa\n\nN/A - zadanie obliczeniowe, każda operacja w O(log n) bitów (tu liczby są małe, więc faktycznie O(1)).","image":"img/informatyka-2016-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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/3.4","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"3.4","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 3.4. (0-1)\n1.\nJednym z zadań systemu operacyjnego jest przydział pamięci\ndziałającym programom.\nP\nF\n2.\nNa jednym dysku twardym mogą być zainstalowane dwa systemy\noperacyjne.\nP\nF\n3.\nSystem operacyjny musi być przechowywany w pamięci ROM.\nP\nF\n4.\nSystem operacyjny musi być przechowywany na twardym dysku.\nP\nF\nWypełnia\negzaminator\nNr zadania\n3.1.\n3.2.\n3.3.\n3.4.\nMaks. liczba pkt.\n1\n1\n1\n1\nUzyskana liczba pkt.\nMIN_1R\nBRUDNOPIS (nie podlega ocenie)","answer":null,"answer_text":"Zadanie 3.4. (0-1)\nI. Bezpieczne posługiwanie się komputerem\ni jego oprogramowaniem, wykorzystanie\nsieci komputerowej; komunikowanie się\nza pomocą komputera i technologii\ninformacyjno-komunikacyjnych.\n1. Posługiwanie się komputerem i jego\noprogramowaniem, korzysta z sieci komputerowej.\nZdający:\n2) wyjaśnia funkcje systemu operacyjnego i korzysta\nz nich; opisuje różne systemy operacyjne.\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, F.\nCzęść II","solution":"## Poprawna odpowiedź\n\n**1) P, 2) P, 3) F, 4) F**\n\n## Sposób 1 - analiza poszczególnych stwierdzeń\n\n### Stwierdzenie 1: Przydział pamięci → **P**\n\nJedną z głównych funkcji systemu operacyjnego (obok zarządzania procesami, plikami, urządzeniami) jest **zarządzanie pamięcią**:\n- Przydzielanie segmentów RAM uruchamianym programom.\n- Obsługa pamięci wirtualnej (mapowanie stron, swap).\n- Zwalnianie pamięci po zakończeniu procesu.\n- Ochrona pamięci (proces A nie może czytać pamięci procesu B bez zgody).\n\n**To podstawowe zadanie kernela.** Prawda.\n\n### Stwierdzenie 2: Dwa systemy operacyjne na jednym dysku → **P**\n\n**Tak, możliwe - to nazywa się multiboot (dual boot).** Dysk można podzielić na **partycje**, każda z osobnym systemem plików i własnym OS:\n- np. partycja C: Windows, partycja D: Linux\n- Bootloader (GRUB, Windows Boot Manager) wyświetla menu wyboru przy uruchamianiu.\n\nPrzykłady: Windows + Ubuntu, Windows + macOS (Boot Camp), itd. Prawda.\n\n### Stwierdzenie 3: OS musi być w pamięci ROM → **F**\n\n**Fałsz.** Pamięć ROM (Read-Only Memory) zawiera tylko **firmware** uruchamiany podczas startu komputera:\n- BIOS / UEFI - testowanie sprzętu (POST), inicjalizacja podzespołów, ładowanie bootloadera.\n\n**System operacyjny** (Windows, Linux, macOS) jest przechowywany **na dysku twardym, SSD, pendrive lub w sieci** - NIE w ROM. ROM jest za mała (zwykle kilka MB) na cały OS (kilka GB).\n\n### Stwierdzenie 4: OS musi być na dysku twardym → **F**\n\n**Fałsz.** OS można uruchomić z różnych nośników:\n- **Live USB / Live DVD** - Linux działa wprost z pendrive (Ubuntu Live, Tails, Kali Live).\n- **PXE boot** - sieciowe ładowanie OS przez TCP/IP (dystrybucje terminalowe).\n- **Karta SD** (Raspberry Pi, urządzenia embedded).\n- **NVMe / SSD** - nie są \"dyskami twardymi\" w klasycznym sensie HDD.\n- **Diskless workstations** - komputery bez dysku, OS w RAM lub przez sieć.\n\n## Sposób 2 - Reference informatyczny\n\n> Reference - System operacyjny:\n> - **Definicja**: oprogramowanie zarządzające zasobami sprzętowymi i dostarczające usług programom użytkownika.\n> - **Główne podsystemy**: zarządzanie procesami, pamięcią, plikami, urządzeniami I/O, siecią, bezpieczeństwem.\n> - **Stany procesu**: nowy, gotowy, wykonywany, oczekujący, zakończony.\n> - **Pamięć wirtualna**: każdy proces widzi ciągłą przestrzeń adresową, niezależnie od fizycznego rozłożenia w RAM.\n>\n> Reference - Rodzaje pamięci:\n> - **RAM** (Random Access Memory) - pamięć operacyjna, ulotna.\n> - **ROM** (Read-Only Memory) - pamięć tylko do odczytu; BIOS/UEFI/firmware.\n> - **HDD / SSD / NVMe** - pamięć masowa, trwała.\n> - **Cache** L1/L2/L3 - szybka pamięć w CPU.\n>\n> Reference - Bootowanie:\n> - **POST** (Power-On Self-Test) - sprawdza sprzęt.\n> - **BIOS/UEFI** - w ROM, ładuje **bootloader**.\n> - **Bootloader** (GRUB, NTLDR) - ładuje **kernel OS** z dysku/USB/sieci do RAM.\n> - **Kernel** - uruchamia procesy systemowe i interfejs użytkownika.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 3.4, max 1 pkt):\n> - **1 pkt** - wszystkie 4 odpowiedzi poprawne: P, P, F, F\n> - **0 pkt** - odpowiedź niepełna lub błędna\n\n## Typowe pułapki\n\n- **Mylenie ROM z RAM** - ROM jest mała i tylko-do-odczytu (firmware), RAM jest pamięcią roboczą.\n- **Sugerowanie, że OS musi być na HDD** - w rzeczywistości może być na USB, SSD, w sieci, w RAM-dysku.\n- **Niepamiętanie o multiboot** - Linux i Windows na jednym dysku to standard przy partycjonowaniu.\n- **Zaniedbanie roli OS w przydziale pamięci** - to JEST jego zadanie (malloc, virtual memory, page tables).\n- **\"Twardy dysk\" mylony z \"dyskiem w ogóle\"** - terminologicznie HDD oznacza klasyczny dysk talerzowy; SSD/NVMe to nie HDD.\n\n## Złożoność obliczeniowa\n\nN/A - zadanie teoretyczne z zakresu systemów operacyjnych.","image":"img/informatyka-2016-maj-matura-rozszerzona/zad-3.4.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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/4.1","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"4.1","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 4. Liczba PI\n\nW kartezjańskim układzie współrzędnych na płaszczyźnie narysowano kwadrat o boku długości 400 i środku symetrii w punkcie (200;200). Boki kwadratu są równoległe do osi układu współrzędnych. W kwadrat wpisano koło. Następnie wylosowano 10 000 punktów należących do kwadratu. Współrzędne (x,y) punktów zostały zapisane w pliku punkty.txt, każdy punkt w osobnym wierszu. Wiersz ma postać dwóch liczb całkowitych z zakresu <0;400>, rozdzielonych pojedynczym znakiem odstępu.\n\nWskazówka: Równanie okręgu o środku w punkcie S = (a,b) i promieniu r > 0 ma postać: (x-a)² + (y-b)² = r².\n\nInformacja: W pliku wśród 100 pierwszych punktów 80 należy do wnętrza koła.\n\nWypisz współrzędne tych punktów, które należą do brzegu koła (okręgu), oraz podaj liczbę punktów należących do wnętrza koła (brzeg koła nie należy do wnętrza koła).","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Punkty na okręgu (brzegu koła):** **(256, 8)** oraz **(200, 400)**\n\n**Liczba punktów wewnątrz koła:** **7852**\n\n## Sposób 1 - geometryczna analiza\n\n**Parametry koła:**\n- Środek: S = (200, 200)\n- Bok kwadratu = 400, więc promień wpisanego koła = bok/2 = **r = 200**.\n- Równanie okręgu: `(x - 200)² + (y - 200)² = 200² = 40000`.\n\n**Klasyfikacja punktu (x, y):**\n- `d² = (x - 200)² + (y - 200)²`\n- `d² < 40000` → punkt **wewnątrz** koła\n- `d² = 40000` → punkt **na okręgu** (brzegu)\n- `d² > 40000` → punkt **poza** kołem\n\n## Sposób 2 - implementacja Python\n\n```python\nbrzeg = []\nwnetrze = 0\n\nwith open('punkty.txt') as f:\nfor linia in f:\nczesci = linia.strip().split()\nif len(czesci) != 2:\ncontinue\nx, y = int(czesci[0]), int(czesci[1])\nd2 = (x - 200) ** 2 + (y - 200) ** 2\nif d2 == 40000:\nbrzeg.append((x, y))\nelif d2 < 40000:\nwnetrze += 1\n\nprint(\"Punkty na okręgu:\", brzeg) # [(256, 8), (200, 400)]\nprint(\"Liczba punktów wewnątrz:\", wnetrze) # 7852\n\n**Dlaczego (256, 8) jest na okręgu?**\n(256 - 200)² + (8 - 200)² = 56² + (-192)² = 3136 + 36864 = **40000** ✓\n\n**Dlaczego (200, 400) jest na okręgu?**\n(200 - 200)² + (400 - 200)² = 0 + 200² = **40000** ✓ (punkt na styku okręgu z górnym bokiem kwadratu).\n\n## Sposób 3 - C++ i Pascal\n\n**C++:**\n```cpp\n#include \n#include \nusing namespace std;\n\nint main() {\nifstream f(\"punkty.txt\");\nint x, y, wnetrze = 0;\nwhile (f >> x >> y) {\nlong long d2 = (long long)(x - 200) * (x - 200)\n+ (long long)(y - 200) * (y - 200);\nif (d2 == 40000) cout << x << \" \" << y << endl;\nelse if (d2 < 40000) wnetrze++;\n}\ncout << \"Wnetrze: \" << wnetrze << endl;\nreturn 0;\n}\n\n**Pascal:**\n```pascal\nprogram LiczbaPi41;\nvar f: TextFile; x, y, wn, d2: LongInt;\nbegin\nAssignFile(f, 'punkty.txt'); Reset(f);\nwn := 0;\nwhile not Eof(f) do begin\nReadln(f, x, y);\nd2 := (x - 200) * (x - 200) + (y - 200) * (y - 200);\nif d2 = 40000 then Writeln(x, ' ', y)\nelse if d2 < 40000 then wn := wn + 1;\nend;\nCloseFile(f);\nWriteln('Wnetrze: ', wn);\nend.\n\n**Arkusz kalkulacyjny:**\n- Kolumna A: x, kolumna B: y.\n- Kolumna C: `=(A1-200)^2+(B1-200)^2` (kwadrat odległości od środka).\n- Kolumna D: `=JEŻELI(C1=40000;\"BRZEG\";JEŻELI(C1<40000;\"WNETRZE\";\"ZEWNETRZE\"))`.\n- Filtruj kolumnę D = \"BRZEG\" → punkty na okręgu.\n- `=LICZ.JEŻELI(D1:D10000;\"WNETRZE\")` → 7852.\n\n## Reference informatyczny - geometria okręgu w programowaniu\n\n> Reference - Sprawdzenie czy punkt leży w/na/poza okręgiem:\n> - **Punkt P = (x, y) względem okręgu o środku S = (a, b) i promieniu r**:\n> - Liczymy `d² = (x - a)² + (y - b)²` (uwaga: NIE pierwiastek, żeby uniknąć błędu float).\n> - Jeśli `d² < r²` → wewnątrz.\n> - Jeśli `d² = r²` → na okręgu.\n> - Jeśli `d² > r²` → poza.\n> - **Dla liczb całkowitych** porównanie `d² = r²` jest dokładne (brak zaokrągleń).\n> - **Dla zmiennoprzecinkowych** używaj `|d² - r²| < ε` (epsilon, np. 10⁻⁹).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 4.1, max 3 pkt):\n> - **2 pkt** za prawidłowe współrzędne punktów na okręgu (po 1 pkt za każdą parę: (256, 8) i (200, 400))\n> - **1 pkt** za prawidłową liczbę punktów wewnątrz koła (7852)\n> - **0 pkt** - odpowiedź błędna\n\n## Typowe pułapki\n\n- **Wliczanie brzegu do wnętrza** - treść wyraźnie mówi \"brzeg koła nie należy do wnętrza koła\". Punkty z `d² = r²` NIE są wnętrzem.\n- **Pomyłka ze środkiem** - środek to (200, 200), nie (0, 0). Łatwa pomyłka po przeczytaniu \"bok 400\".\n- **Niedokładne porównanie** - używanie `sqrt(d²) == 200` zamiast `d² == 40000` może dać błędy float (`sqrt(40000.0)` powinno być dokładnie 200, ale lepiej trzymać się arytmetyki całkowitoliczbowej).\n- **Overflow w C++** - (x - 200)² ≤ 200² = 40000, suma ≤ 80000 - mieści się w 32-bitowym int. Bez problemu.\n- **Brak konwersji na int** - `linia.strip().split()` w Pythonie zwraca stringi, trzeba zrzutować: `int( )`.\n\n## Złożoność obliczeniowa\n\n- Jedno przejście przez plik: **O(N)** gdzie N = 10000.\n- Każda iteracja: O(1) operacji arytmetycznych.\n- **Łącznie: O(N) = O(10000) ≈ 10⁴ 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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/4.2","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"4.2","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 4.1.\n\nPrzy założeniu równomiernego rozkładu punktów w kwadracie, stosunek liczby punktów nk należących do koła do liczby punktów n należących do kwadratu jest w przybliżeniu równy stosunkowi pola koła Pk do pola kwadratu P: nk/n ≈ Pk/P, gdzie Pk = π·r².\n\nInformacja: Przybliżona wartość liczby pi dla pierwszych 100 punktów z pliku wynosi 3,2000.\n\nWyznacz przybliżoną wartość liczby pi, biorąc pod uwagę punkty z pliku punkty.txt:\n• pierwszych 1000 punktów,\n• pierwszych 5000 punktów,\n• wszystkie punkty.\nWyniki zaokrąglij do 4 miejsc po przecinku.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n| Liczba punktów | Przybliżenie π |\n| pierwszych 1000 | **3,2280** |\n| pierwszych 5000 | **3,1656** |\n| wszystkie 10000 | **3,1416** |\n\n## Sposób 1 - wyprowadzenie wzoru Monte Carlo\n\n**Dane geometryczne:**\n- Kwadrat o boku 400: pole P = 400² = 160 000.\n- Koło wpisane: promień r = 200, pole P_k = π·r² = π·40000.\n\n**Stosunek pól:**\nP_k / P = π·40000 / 160000 = π / 4\n\n**Stosunek punktów (Monte Carlo):**\nn_k / n ≈ P_k / P = π / 4\nstąd:\nπ ≈ 4 · n_k / n\n\n**WAŻNE:** Z zadania 4.1: `n_k` to liczba punktów wewnątrz koła **PLUS** liczba punktów na brzegu (cały obszar koła, włącznie z okręgiem).\n\n## Sposób 2 - implementacja Python\n\n```python\npunkty = []\nwith open('punkty.txt') as f:\nfor linia in f:\nczesci = linia.strip().split()\nif len(czesci) == 2:\npunkty.append((int(czesci[0]), int(czesci[1])))\n\ndef policz_w_kole(n):\n\"\"\"Liczba punktów w kole (wnętrze + brzeg) wśród pierwszych n.\"\"\"\nnk = 0\nfor x, y in punkty[:n]:\nd2 = (x - 200) ** 2 + (y - 200) ** 2\nif d2 <= 40000: # <= bo brzeg JEST w kole\nnk += 1\nreturn nk\n\nfor n in [1000, 5000, 10000]:\nnk = policz_w_kole(n)\npi_approx = 4 * nk / n\nprint(f\"n={n}: nk={nk}, pi ≈ {pi_approx:.4f}\")\n\n**Wynik:**\nn=1000: nk=807, pi ≈ 3.2280\nn=5000: nk=3957, pi ≈ 3.1656\nn=10000: nk=7854, pi ≈ 3.1416\n\n**Weryfikacja przez informację z treści (100 pierwszych):**\nDla 100 pierwszych: 80 wewnątrz + 0 na brzegu = 80 → π ≈ 4·80/100 = **3,2000** ✓\n\n## Sposób 3 - arkusz kalkulacyjny\n\n- W kolumnie C: `=(A1-200)^2+(B1-200)^2`.\n- W kolumnie D: `=JEŻELI(C1<=40000;1;0)` (1 jeśli w kole).\n- E1: `=4*SUMA(D1:D1000)/1000` → 3,228\n- E2: `=4*SUMA(D1:D5000)/5000` → 3,1656\n- E3: `=4*SUMA(D1:D10000)/10000` → 3,1416\n- Zaokrąglenie: `=ZAOKR(E1;4)`.\n\n## Reference informatyczny - metoda Monte Carlo\n\n> Reference - Estymacja π metodą Monte Carlo:\n> - Losuj n punktów równomiernie w kwadracie [0, a] × [0, a].\n> - Policz, ile leży w kole wpisanym o promieniu a/2.\n> - π ≈ 4·n_k/n.\n> - Dokładność rośnie jak **O(1/√n)** (centralne twierdzenie graniczne).\n> - n=100 → ε ≈ 0,1; n=10⁴ → ε ≈ 0,01; n=10⁶ → ε ≈ 0,001.\n>\n> Reference - Inkluzja vs ekskluzja brzegu:\n> - Treść 4.1 wymaga rozdzielenia wnętrza i brzegu.\n> - Treść 4.2 mówi o **kole** ogólnie (= wnętrze ∪ brzeg). Klucz akceptuje zarówno wynik z brzegiem (3,2280; 3,1656; 3,1416) jak i bez (3,2240; 3,1648; 3,1408 - minus 2 punkty brzegowe na 10000).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 4.2, max 3 pkt):\n> - **3 pkt** - wszystkie 3 wyniki prawidłowe: 3,2280 (lub 3,228), 3,1656, 3,1416\n> - **2 pkt** - 2 prawidłowe wyniki ALBO wszystkie BEZ uwzględnienia brzegu (3,2240; 3,1648; 3,1408)\n> - **1 pkt** - 1 prawidłowy wynik\n> - **0 pkt** - odpowiedź błędna\n\n## Typowe pułapki\n\n- **Pominięcie brzegu** - jeśli `d² < 40000` (ostro mniejsze), tracimy 2 punkty z 10000 i wynik = 3,1408. Klucz akceptuje, ale daje mniej punktów.\n- **Niepoprawne zaokrąglenie** - wynik MUSI być do 4 miejsc po przecinku. 3,228 (3 miejsca) jest akceptowany, ale lepiej pisać 3,2280.\n- **Przecinek vs kropka** - w polskiej notacji 3,1416 (przecinek). W kodzie często 3.1416 (kropka). Klucz akceptuje przecinek.\n- **Pomylenie n z n_k** - pi ≈ 4·n_k/n, NIE 4·n/n_k (to dałoby wynik > 4).\n- **Pomyłka w pierwszych 1000 vs ostatnich 1000** - bierzemy PIERWSZE n punktów z pliku.\n\n## Złożoność obliczeniowa\n\n- Przejście przez plik: O(N) gdzie N = 10000.\n- Liczenie 3 razy (dla różnych n): w jednym przejściu można policzyć kumulatywnie.\n- **Łącznie: O(N) ≈ 10⁴ 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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/4.3","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"4.3","points":5,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 4.1.\n\nBłąd bezwzględny przybliżonej wartości liczby pi, wyznaczonej z n punktów: εn = |π - pin|.\n\nOblicz εn dla n = 1, 2, 3, …, 1700. Na podstawie powyższego zestawienia utwórz wykres liniowy ilustrujący zmiany dokładności wyznaczanej liczby pi. Zadbaj o czytelność wykresu.\n\nWartości dla ε1000 oraz ε1700 (zaokrąglone do czterech miejsc po przecinku) zapisz do pliku wyniki_4.txt.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**ε₁₀₀₀ = 0,0864**\n\n**ε₁₇₀₀ = 0,0184**\n\nWykres liniowy: oś X = n (1 1700), oś Y = εn. Charakter: szybki spadek na początku, malejąca obwiednia jak ~1/√n, drobne oscylacje. Tytuł: \"Błąd bezwzględny przybliżenia liczby π metodą Monte Carlo\". Osie: \"liczba punktów n\" / \"błąd bezwzględny εn\".\n\n## Sposób 1 - wzór i implementacja Python\n\n**Wzór:**\n- `pi_n = 4 · nk_n / n`, gdzie nk_n = liczba punktów w kole wśród pierwszych n.\n- `εn = |π - pi_n|`.\n\n```python\nimport math\nimport matplotlib.pyplot as plt\n\npunkty = []\nwith open('punkty.txt') as f:\nfor linia in f:\ncz = linia.strip().split()\nif len(cz) == 2:\npunkty.append((int(cz[0]), int(cz[1])))\n\nnk_cumulative = 0\nbledy = []\nfor i in range(1, 1701):\nx, y = punkty[i - 1]\nd2 = (x - 200) ** 2 + (y - 200) ** 2\nif d2 <= 40000:\nnk_cumulative += 1\npi_n = 4 * nk_cumulative / i\nepsilon = abs(math.pi - pi_n)\nbledy.append(epsilon)\n\nprint(f\"ε1000 = {bledy[999]:.4f}\") # 0.0864\nprint(f\"ε1700 = {bledy[1699]:.4f}\") # 0.0184\n\n# Zapis do pliku\nwith open('wyniki_4.txt', 'w') as f:\nf.write(f\"4.3\\n\")\nf.write(f\"ε1000 = {bledy[999]:.4f}\\n\")\nf.write(f\"ε1700 = {bledy[1699]:.4f}\\n\")\n\n# Wykres\nplt.figure(figsize=(12, 5))\nplt.plot(range(1, 1701), bledy, linewidth=0.7)\nplt.title('Błąd bezwzględny przybliżenia liczby π metodą Monte Carlo')\nplt.xlabel('liczba punktów n')\nplt.ylabel('błąd bezwzględny εn = |π - πn|')\nplt.grid(True, alpha=0.3)\nplt.savefig('wykres_blad_pi.png', dpi=120)\n\n## Sposób 2 - arkusz kalkulacyjny\n\n**Konstrukcja:**\n1. Kolumny A, B: x, y (1700 wierszy z pliku punkty.txt).\n2. Kolumna C: `=(A1-200)^2+(B1-200)^2`.\n3. Kolumna D: `=JEŻELI(C1<=40000;1;0)`.\n4. Kolumna E: kumulatywna suma - E1: `=D1`; E2: `=E1+D2`; przeciągnąć w dół.\n5. Kolumna F: `=4*E1/WIERSZ()`.\n6. Kolumna G: `=ABS(PI()-F1)`.\n7. ε1000 = G1000 = **0,0864**; ε1700 = G1700 = **0,0184**.\n8. Wykres: zaznacz zakres G1:G1700, Wstaw → wykres liniowy.\n9. Tytuł wykresu, opisy osi (n, εn).\n\n## Sposób 3 - pseudokod\n\nwczytaj punkty[1 10000] z pliku\nnk ← 0\notwórz wyniki_4.txt do zapisu\ndla i = 1 do 1700 wykonuj:\n(x, y) ← punkty[i]\nd2 ← (x-200)*(x-200) + (y-200)*(y-200)\njeżeli d2 ≤ 40000:\nnk ← nk + 1\npi_n ← 4 * nk / i\neps[i] ← |π - pi_n|\nzapisz \"ε1000 = \" + zaokrąglij(eps[1000], 4) do pliku\nzapisz \"ε1700 = \" + zaokrąglij(eps[1700], 4) do pliku\nzrób wykres liniowy z (i, eps[i]) dla i=1 1700\n\n## Reference informatyczny - Monte Carlo, dokładność\n\n> Reference - Konwergencja metody Monte Carlo:\n> - **Twierdzenie graniczne**: błąd estymatora maleje proporcjonalnie do `1/√n`.\n> - Dla π: błąd ε ≈ 1.642/√n (dla losowego rozkładu w kwadracie).\n> - **n = 100** → ε ≈ 0,16 (ale w zadaniu konkretnie 0,0584 dla danych - punkty nie są idealnie losowe).\n> - **n = 10000** → ε ≈ 0,016.\n> - Krzywa błędu **oscyluje, ale obwiednia maleje** monotonicznie.\n>\n> Reference - Wykresy w matplotlib / Excel:\n> - **Wykres liniowy**: gdy chcemy pokazać trend / przebieg czasowy.\n> - **Kolumnowy**: porównanie kategorii.\n> - **Punktowy (scatter)**: zależność między dwoma zmiennymi.\n> - Tytuł + opis osi = obowiązkowe dla CKE (1 punkt za czytelność).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 4.3, max 5 pkt):\n> - **3 pkt** za prawidłowe wartości ε:\n> - 1 pkt - wartość ε1000 = 0,0864\n> - 1 pkt - wartość ε1700 = 0,0184\n> - 1 pkt - odpowiednia dokładność (4 miejsca po przecinku)\n> - **1 pkt** - prawidłowy zakres danych i typ wykresu (liniowy)\n> - **1 pkt** - czytelny opis wykresu (tytuł + osie)\n> - **0 pkt** - odpowiedź błędna\n\n## Typowe pułapki\n\n- **Niesumowanie kumulatywne** - niektórzy uczniowie liczą tylko `nk_n` od i-tego punktu, a nie od 1. Wynik byłby chaotyczny.\n- **Pomylenie ε z pi** - zapisanie 3,228 zamiast 0,0864 (różnica między π a 3,228).\n- **Wykres bez tytułu/opisu osi** - strata 1 pkt.\n- **Wykres kolumnowy zamiast liniowego** - strata 1 pkt. Liniowy lepiej oddaje ciągłą zmianę.\n- **Niepoprawna dokładność** - 0,09 lub 0,0863 zamiast 0,0864 (3 vs 4 miejsca po przecinku, zaokrąglenie).\n- **Off-by-one** - czy ε1000 to błąd po 1000 punktach (włącznie z 1000-nym), czy 999-nym? Treść: \"εn dla n=1, 2, , 1700\" oznacza pierwszych n punktów, czyli n włącznie.\n\n## Złożoność obliczeniowa\n\n- Wczytanie 10000 punktów: O(N).\n- Obliczenie 1700 wartości εn: O(1700) z kumulatywną sumą.\n- Wykres: O(1700) renderowanych punktów.\n- **Łącznie: O(N) ≈ 10⁴ 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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/5.1","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"5.1","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 5. Biblioteka podręczników\n\nZ biblioteki podręczników, wypożyczanych na cały rok akademicki, mogą korzystać studenci z miasteczka akademickiego i spoza miasteczka. Każdy student może wypożyczyć wiele różnych książek. W miasteczku studenci mieszkają w pokojach po kilka osób w jednym.\n\nDane są trzy pliki: studenci.txt, meldunek.txt, wypozyczenia.txt.\n\n**studenci.txt** - pesel, nazwisko, imie.\n**meldunek.txt** - pesel, id_pok.\n**wypozyczenia.txt** - lp, pesel, tytul.\n\nPodaj imię i nazwisko osoby, która wypożyczyła najwięcej podręczników. Wypisz tytuły wszystkich książek przez nią wypożyczonych.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Imię i nazwisko: KRZYSZTOF LEWANDOWSKI**\n\n**Tytuły książek (4):**\n- FLASH I PHP\n- JEZYKI PROGRAMOWANIA II\n- METODY NUMERYCZNE II\n- TEORIA GRAFOW\n\n## Sposób 1 - SQL\n\n**Krok 1: znajdź PESEL osoby z największą liczbą wypożyczeń:**\n\n```sql\nSELECT pesel, COUNT(*) AS liczba\nFROM wypozyczenia\nGROUP BY pesel\nORDER BY liczba DESC\nLIMIT 1;\n\n**Krok 2: imię i nazwisko + tytuły książek:**\n\n```sql\nSELECT s.imie, s.nazwisko, w.tytul\nFROM studenci s\nJOIN wypozyczenia w ON s.pesel = w.pesel\nWHERE s.pesel = (\nSELECT pesel\nFROM wypozyczenia\nGROUP BY pesel\nORDER BY COUNT(*) DESC\nLIMIT 1\n)\nORDER BY w.tytul;\n\n**Wynik:**\nKRZYSZTOF | LEWANDOWSKI | FLASH I PHP\nKRZYSZTOF | LEWANDOWSKI | JEZYKI PROGRAMOWANIA II\nKRZYSZTOF | LEWANDOWSKI | METODY NUMERYCZNE II\nKRZYSZTOF | LEWANDOWSKI | TEORIA GRAFOW\n\n## Sposób 2 - Python\n\n```python\nfrom collections import Counter\n\n# Wczytaj studentów\nstudenci = {} # pesel -> (imie, nazwisko)\nwith open('studenci.txt', encoding='windows-1250') as f:\nnext(f) # header\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 3:\npesel, nazwisko, imie = cz[0], cz[1], cz[2]\nstudenci[pesel] = (imie, nazwisko)\n\n# Wczytaj wypożyczenia\nwypozyczenia = [] # (pesel, tytul)\nwith open('wypozyczenia.txt', encoding='windows-1250') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 3:\npesel, tytul = cz[1], cz[2]\nwypozyczenia.append((pesel, tytul))\n\n# Policz wypożyczenia per pesel\nlicznik = Counter(p for p, _ in wypozyczenia)\nnajwiekszy_pesel, ile = licznik.most_common(1)[0]\n\nimie, nazwisko = studenci[najwiekszy_pesel]\nprint(f\"{imie} {nazwisko} (wypożyczył {ile} książek)\")\nfor pesel, tytul in wypozyczenia:\nif pesel == najwiekszy_pesel:\nprint(f\" - {tytul}\")\n\n**Wynik:**\nKRZYSZTOF LEWANDOWSKI (wypożyczył 4 książek)\n- FLASH I PHP\n- JEZYKI PROGRAMOWANIA II\n- METODY NUMERYCZNE II\n- TEORIA GRAFOW\n\n## Sposób 3 - arkusz kalkulacyjny\n\n1. **Tabela przestawna**: zaimportuj wypozyczenia.txt. Pole PESEL → wiersze. Pole TYTUL → wartości (Licznik).\n2. Sortuj malejąco wg licznika. Pierwszy wiersz to PESEL z największą liczbą.\n3. **VLOOKUP** w studenci.txt po PESEL → imię, nazwisko.\n4. **Filtruj** wypozyczenia.txt wg tego PESEL → uzyskaj listę tytułów.\n\n## Reference informatyczny - SQL agregacja\n\n> Reference - Klauzule SQL do tego typu zadania:\n> - `GROUP BY` - grupuje rekordy wg pola; każda grupa to jedna linia wyniku.\n> - `COUNT(*)` - liczba rekordów w grupie.\n> - `ORDER BY DESC LIMIT 1` - wybiera grupę z największą liczbą.\n> - **Podzapytanie skorelowane** - pozwala odwołać się do wyniku w innej części.\n> - `JOIN ON` - łączy dwie tabele po kluczu.\n>\n> Reference - Alternatywa zamiast LIMIT 1 + ORDER BY (MAX):\n> ```sql\n> WHERE COUNT(*) = (SELECT MAX(c) FROM (SELECT COUNT(*) AS c FROM wypozyczenia GROUP BY pesel))\n> ```\n> Jest bezpieczniej gdy chcemy WSZYSTKICH osób z maksimum, nie tylko jednej.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.1, max 2 pkt):\n> - **2 pkt** - imię, nazwisko ORAZ wszystkie tytuły\n> - **1 pkt** - tylko imię i nazwisko ALBO tylko tytuły\n> - **0 pkt** - odpowiedź niepełna lub błędna\n\n## Typowe pułapki\n\n- **Nieuwzględnienie wszystkich tytułów** - może być pominięcie 1 z 4. Klucz wymaga **wszystkich**.\n- **PESEL jako liczba** - PESEL to 11 cyfr; w int może wystąpić overflow w niektórych językach. Lepiej traktować jako string.\n- **Kodowanie pliku** - pliki CKE zwykle w Windows-1250 (polskie znaki). W Pythonie: `encoding='windows-1250'` lub `'cp1250'`.\n- **Separator** - w plikach CKE często TAB; sprawdzić w pierwszej linii.\n- **Pomylenie wypożyczeń (lp, pesel, tytul) z meldunkiem (pesel, id_pok)** - meldunek nie ma tytułów, służy tylko do zameldowania w pokojach.\n\n## Złożoność obliczeniowa\n\n- Wczytanie plików: O(S + W) gdzie S = liczba studentów, W = liczba wypożyczeń.\n- Counter agregujący: O(W).\n- Wyszukanie max: O(unikalnych PESEL).\n- **Łącznie: O(S + W).**","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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/5.2","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"5.2","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 5.1.\n\nPodaj średnią liczbę osób zameldowanych w jednym pokoju. Wynik zaokrąglij do 4 miejsc po przecinku.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Średnia liczba osób zameldowanych w jednym pokoju: 4,7101**\n\n## Sposób 1 - SQL\n\n**Idea:** średnia = (liczba zameldowań) / (liczba różnych pokoi).\n\n```sql\nSELECT ROUND(\n1.0 * COUNT(pesel) / COUNT(DISTINCT id_pok),\n4\n) AS srednia\nFROM meldunek;\n\nAlbo dwa zapytania:\n```sql\nSELECT COUNT(*) FROM meldunek; -- 325 (liczba osób zameldowanych)\nSELECT COUNT(DISTINCT id_pok) FROM meldunek; -- 69 (liczba pokoi)\n\n**Średnia = 325 / 69 ≈ 4,7101449 ** → po zaokrągleniu do 4 miejsc: **4,7101**.\n\n## Sposób 2 - Python\n\n```python\nosoby = []\npokoje = set()\nwith open('meldunek.txt', encoding='windows-1250') as f:\nnext(f) # header\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 2:\npesel, id_pok = cz[0], cz[1]\nosoby.append(pesel)\npokoje.add(id_pok)\n\nsrednia = len(osoby) / len(pokoje)\nprint(f\"{srednia:.4f}\") # 4.7101\n\n## Sposób 3 - arkusz kalkulacyjny\n\n1. Otwórz meldunek.txt jako arkusz.\n2. Liczba osób = `=ILE.NIEPUSTYCH(A:A) - 1` (minus nagłówek). Tu: 325.\n3. Liczba pokoi = `=ILE.NIEPUSTYCH.UNIKATOWYCH(B2:B326)` lub przez tabelę przestawną z `id_pok` jako wiersze. Tu: 69.\n4. Średnia = `=ZAOKR(325/69; 4)` → **4,7101**.\n\n## Reference informatyczny - funkcje agregujące w SQL\n\n> Reference - Agregacja:\n> - `COUNT(*)` - liczba WSZYSTKICH rekordów.\n> - `COUNT(kol)` - liczba rekordów gdzie kol NIE jest NULL.\n> - `COUNT(DISTINCT kol)` - liczba **różnych** wartości kol.\n> - `AVG(kol)` - średnia (DLA wartości liczbowych, ignoruje NULL).\n> - **Ostrożność**: `AVG(COUNT(pesel))` nie zadziała bez podzapytania, bo COUNT już agreguje.\n>\n> Reference - Średnia ważona vs zwykła:\n> - **Zwykła średnia liczby osób na pokój** = `liczba_osob_zameldowanych / liczba_pokoi`.\n> - Można też policzyć średnią z grupowych liczników: `SELECT AVG(c) FROM (SELECT COUNT(*) AS c FROM meldunek GROUP BY id_pok)` - daje **ten sam wynik**, gdyby każdy pokój miał >=1 osobę.\n>\n> Reference - Zaokrąglenie:\n> - SQL: `ROUND(x, 4)` (zwykle).\n> - Python: `round(x, 4)` lub `f\"{x:.4f}\"` dla wyświetlania.\n> - W arkuszu: `=ZAOKR(x; 4)`.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.2, max 2 pkt):\n> - **2 pkt** - prawidłowy wynik z zaokrągleniem **4,7101**\n> - **1 pkt** - wynik BEZ prawidłowego zaokrąglenia (4,7101449275 lub 4,71) ALBO licząc na 70 pokojach (4,6429)\n> - **0 pkt** - błędna albo brak\n\n**WAŻNE - pułapka pokoi:** Niektórzy uczniowie wykorzystują pokoje z innych źródeł i otrzymują 70 pokoi (zamiast 69). To częsta pomyłka - dotyczy to studentów z pokojem 0 lub z pokojem spoza miasteczka.\n\n## Typowe pułapki\n\n- **Zaokrąglenie do 2 miejsc** (4,71) zamiast 4 (4,7101) - strata 1 pkt.\n- **Liczba pokoi z błędem** - sprawdź `COUNT(DISTINCT id_pok)`, nie po prostu max id_pok.\n- **Dzielenie całkowite** w Python 2 lub C++ - `325/69 = 4` (int), nie 4.71. Użyj `1.0 * 325 / 69` lub `from future import division`.\n- **Wliczenie nagłówka** do liczenia osób - minus 1 lub `next(f)` na początku.\n- **Pomyłka tabeli** - meldunek.txt ma kolumny PESEL i id_pok, a NIE imię/nazwisko (te są w studenci.txt).\n\n## Złożoność obliczeniowa\n\n- Wczytanie meldunek.txt: O(M) gdzie M = liczba zameldowań (~325).\n- Liczenie unikalnych pokoi (set): O(M) amortyzowane.\n- **Łącznie: O(M).**","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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/5.3","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"5.3","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 5.1.\n\nW numerze PESEL zawarta jest informacja o płci osoby. Jeżeli przedostatnia cyfra numeru jest parzysta, to PESEL należy do kobiety, jeśli nieparzysta, to do mężczyzny.\n\nPodaj liczbę kobiet i liczbę mężczyzn wśród studentów.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Kobiety: 138, Mężczyźni: 192**\n\n## Sposób 1 - SQL\n\n**Idea:** PESEL ma 11 cyfr; przedostatnia to pozycja 10. Wyciągamy ją funkcją tekstową i sprawdzamy parzystość.\n\n```sql\nSELECT\nSUM(CASE WHEN CAST(SUBSTRING(pesel, 10, 1) AS INT) % 2 = 0 THEN 1 ELSE 0 END) AS kobiety,\nSUM(CASE WHEN CAST(SUBSTRING(pesel, 10, 1) AS INT) % 2 = 1 THEN 1 ELSE 0 END) AS mezczyzni\nFROM studenci;\n\n**Alternatywnie** (dwa osobne zapytania):\n```sql\nSELECT COUNT(*) FROM studenci\nWHERE CAST(SUBSTRING(pesel, 10, 1) AS INT) % 2 = 0; -- 138 kobiet\n\nSELECT COUNT(*) FROM studenci\nWHERE CAST(SUBSTRING(pesel, 10, 1) AS INT) % 2 = 1; -- 192 mężczyzn\n\n## Sposób 2 - Python\n\n```python\nkobiety = 0\nmezczyzni = 0\nwith open('studenci.txt', encoding='windows-1250') as f:\nnext(f) # header\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) < 1:\ncontinue\npesel = cz[0]\nif len(pesel) >= 11:\nprzedostatnia = int(pesel[9]) # indeks 9 = 10. cyfra (od 1)\nif przedostatnia % 2 == 0:\nkobiety += 1\nelse:\nmezczyzni += 1\n\nprint(f\"Kobiety: {kobiety}\") # 138\nprint(f\"Mężczyźni: {mezczyzni}\") # 192\n\n## Sposób 3 - arkusz kalkulacyjny\n\n1. W kolumnie B (pomocniczej) wyciągamy 10. cyfrę: `=FRAGMENT.TEKSTU(A2; 10; 1)` (dla PESEL w A2).\n2. W kolumnie C sprawdzamy parzystość: `=JEŻELI(MOD(WARTOŚĆ(B2);2)=0; \"K\"; \"M\")`.\n3. Liczenie: `=LICZ.JEŻELI(C:C; \"K\")` → 138; `=LICZ.JEŻELI(C:C; \"M\")` → 192.\n\n## Reference informatyczny - struktura PESEL\n\n> Reference - Struktura numeru PESEL (11 cyfr):\n> - **Pozycje 1-2**: rok urodzenia (ostatnie 2 cyfry).\n> - **Pozycje 3-4**: miesiąc (z zakodowanym stuleciem: +20 dla 2000-2099, +40 dla 2100-2199, +80 dla 1800-1899).\n> - **Pozycje 5-6**: dzień.\n> - **Pozycje 7-10**: numer kolejny.\n> - **Pozycja 10**: cyfra **płci** - parzysta = kobieta, nieparzysta = mężczyzna.\n> - **Pozycja 11**: cyfra kontrolna.\n>\n> Reference - Wyciąganie n-tej cyfry stringa:\n> - **Python**: `pesel[9]` (indeks od 0), więc 10. cyfra (od 1) to `pesel[9]`.\n> - **SQL**: `SUBSTRING(pesel, 10, 1)` (indeks od 1).\n> - **C++**: `pesel[9]` (char, trzeba odjąć '0' żeby uzyskać int).\n> - **Pascal**: `Copy(pesel, 10, 1)` lub `pesel[10]`.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.3, max 2 pkt):\n> - **2 pkt** - oba wyniki prawidłowe (kobiety 138, mężczyźni 192)\n> - **1 pkt** - jeden prawidłowy wynik\n> - **0 pkt** - błędna albo brak\n>\n> **Uwaga: W przypadku wyników (K=153, M=177) - 1 punkt** (typowa pomyłka cyfry na innej pozycji, np. 11. zamiast 10.).\n\n## Typowe pułapki\n\n- **Pomylenie pozycji** - przedostatnia z 11 = **pozycja 10**, NIE pozycja 11 (to cyfra kontrolna) ani 9.\n- **Indeksowanie od 0 vs od 1** - w Pythonie `pesel[9]` = 10. cyfra; w SQL `SUBSTRING(pesel, 10, 1)` = 10. cyfra. Pomyłka daje błędny wynik (153/177).\n- **Pomyłka parzystości** - parzysta cyfra (0, 2, 4, 6, 8) = **KOBIETA**. Nieparzysta (1, 3, 5, 7, 9) = mężczyzna.\n- **Niepoprawne kodowanie pliku** - Windows-1250 dla polskich znaków w nazwiskach.\n- **Wliczenie nagłówka jako rekordu** - odejmij 1 lub użyj `next(f)`.\n\n## Złożoność obliczeniowa\n\n- Wczytanie pliku: O(S) gdzie S = liczba studentów (~330).\n- Sprawdzenie cyfry: O(1).\n- **Łącznie: O(S).**","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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/5.4","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"5.4","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 5.1.\n\nPodaj nazwiska i imiona studentów, którzy **nie** mieszkają w pokojach w miasteczku akademickim. Listę posortuj alfabetycznie wg nazwisk.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n| Nazwisko | Imię |\n| DYLAG | JACEK |\n| NAJDA | PIOTR |\n| PIETRASZEWSKI | STEFAN |\n| SIECZKOWSKI | MACIEJ |\n| ZALESKA | JULIA |\n\n## Sposób 1 - SQL (LEFT JOIN albo NOT IN)\n\n**Idea:** studenci, których PESEL **nie występuje** w meldunek.txt (= nie mieszkają w miasteczku).\n\n**Wersja 1 - LEFT JOIN + WHERE NULL:**\n```sql\nSELECT s.nazwisko, s.imie\nFROM studenci s\nLEFT JOIN meldunek m ON s.pesel = m.pesel\nWHERE m.pesel IS NULL\nORDER BY s.nazwisko;\n\n**Wersja 2 - NOT IN:**\n```sql\nSELECT nazwisko, imie\nFROM studenci\nWHERE pesel NOT IN (SELECT pesel FROM meldunek)\nORDER BY nazwisko;\n\n**Wersja 3 - NOT EXISTS (najbezpieczniej z NULLami):**\n```sql\nSELECT s.nazwisko, s.imie\nFROM studenci s\nWHERE NOT EXISTS (\nSELECT 1 FROM meldunek m WHERE m.pesel = s.pesel\n)\nORDER BY s.nazwisko;\n\n## Sposób 2 - Python\n\n```python\n# Wczytaj studentów\nstudenci = {}\nwith open('studenci.txt', encoding='windows-1250') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 3:\npesel, nazwisko, imie = cz[0], cz[1], cz[2]\nstudenci[pesel] = (nazwisko, imie)\n\n# Wczytaj PESELe zameldowanych\nzameldowani = set()\nwith open('meldunek.txt', encoding='windows-1250') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 1:\nzameldowani.add(cz[0])\n\n# Znajdź spoza miasteczka\nspoza = [studenci[p] for p in studenci if p not in zameldowani]\nspoza.sort() # sortuje alfabetycznie wg nazwiska (pierwszy element krotki)\n\nfor nazwisko, imie in spoza:\nprint(f\"{nazwisko} {imie}\")\n\n**Wynik (5 osób):**\nDYLAG JACEK\nNAJDA PIOTR\nPIETRASZEWSKI STEFAN\nSIECZKOWSKI MACIEJ\nZALESKA JULIA\n\n## Sposób 3 - arkusz kalkulacyjny\n\n1. W studenci.txt: kolumna D z formułą sprawdzającą obecność w meldunek.txt:\n`=JEŻELI(JEST.BŁĄD(WYSZUKAJ.PIONOWO(A2; meldunek!A:A; 1; FAŁSZ)); \"SPOZA\"; \"W KAMPUSIE\")`\n2. Filtruj kolumnę D = \"SPOZA\" → uzyskaj listę nazwisk.\n3. Sortuj kolumnę B (nazwisko) rosnąco.\n\n## Reference informatyczny - relacje NOT IN / NOT EXISTS / LEFT JOIN\n\n> Reference - Antyjoin (znajdowanie braku dopasowania):\n> - **LEFT JOIN + WHERE NULL**: najbardziej czytelne; bierzemy wszystkie z lewej, łączymy z prawą; brak dopasowania → NULL w polach prawej; filtrujemy.\n> - **NOT IN (podzapytanie)**: prosta składnia, ale **uwaga na NULLe** - `pesel NOT IN (1, 2, NULL)` zwróci `unknown` zamiast `true`!\n> - **NOT EXISTS**: najwydajniejsze i bezpieczne z NULLami.\n>\n> Reference - JOIN-y:\n> - **INNER JOIN** - tylko dopasowane rekordy.\n> - **LEFT JOIN** - wszystkie z lewej + dopasowane z prawej.\n> - **FULL JOIN** - wszystkie z obu (rzadko w CKE).\n> - **CROSS JOIN** - iloczyn kartezjański.\n>\n> Reference - ORDER BY:\n> - Domyślnie ASC (rosnąco).\n> - Sortowanie alfabetyczne stringów jest leksykograficzne (UPPER < lower w ASCII).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.4, max 3 pkt):\n> - **3 pkt** - wszystkie 5 nazwisk poprawnie + posortowane\n> - **2 pkt** - wszystkie 5 nazwisk poprawnie, ale BEZ sortowania\n> - **0 pkt** - niepełna lub błędna\n>\n> **Uwaga: NIE PRZYZNAJE SIĘ 1 PUNKTU** (binarnie: kompletna lista vs nic).\n\n## Typowe pułapki\n\n- **Posortowanie wg imienia** zamiast nazwiska - strata 1 pkt.\n- **Pominięcie 1 z 5 osób** - strata 3 pkt (niepełna = 0).\n- **Wpisanie osób Z miasteczka** zamiast SPOZA - odwrotny wynik (większość studentów).\n- **NOT IN z NULL** - jeśli w podzapytaniu pojawi się NULL, NOT IN zwraca pustą listę. Lepiej NOT EXISTS.\n- **Sortowanie nieczułe na wielkość znaków** - w CKE nazwiska są UPPERCASE, więc problem nie powinien wystąpić, ale w innych zadaniach `COLLATE NOCASE`.\n- **Włączenie nagłówka do wyniku** - w SQL nigdy nie ma, w arkuszu - uwaga.\n\n## Złożoność obliczeniowa\n\n- Wczytanie obu plików: O(S + M).\n- Sprawdzenie obecności w set: O(1) per query.\n- Sortowanie 5 wyników: O(k log k) gdzie k = 5.\n- **Łącznie: O(S + M).**","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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/5.5","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"5.5","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 5.1.\n\nBiblioteka planuje wprowadzenie zakazu wypożyczania kilku egzemplarzy tego samego tytułu podręcznika studentom mieszkającym w jednym pokoju. Gdy ta zasada będzie obowiązywać, w żadnym pokoju nie powtórzy się żaden tytuł podręcznika.\n\nPodaj, ile byłoby wypożyczonych podręczników, gdyby takie ograniczenie już funkcjonowało.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**316 podręczników**\n\n## Sposób 1 - analiza problemu\n\n**Reguła:** w jednym pokoju nie może być więcej niż jeden egzemplarz tego samego tytułu. Czyli z każdej trójki `(pokój, tytuł)` zliczamy 1 wypożyczenie (zamiast np. 2-3, gdy 2-3 osób z tego samego pokoju wypożyczyło ten sam podręcznik).\n\n**Studenci SPOZA miasteczka nie mają pokoju** → ich wypożyczenia liczymy WSZYSTKIE (każdy student spoza to \"osobny pokój\").\n\n**Algorytm:**\n1. Dla studentów Z miasteczka: zlicz **unikalne pary (id_pok, tytul)**.\n2. Dla studentów SPOZA miasteczka: zlicz wszystkie ich wypożyczenia.\n3. Suma = wynik.\n\n## Sposób 2 - SQL\n\n```sql\nSELECT\n(\n-- studenci z miasteczka: unikalne pary (pokój, tytuł)\nSELECT COUNT(DISTINCT m.id_pok || '|' || w.tytul)\nFROM wypozyczenia w\nJOIN meldunek m ON w.pesel = m.pesel\n)\n(\n-- studenci spoza miasteczka: wszystkie wypożyczenia\nSELECT COUNT(*)\nFROM wypozyczenia w\nWHERE w.pesel NOT IN (SELECT pesel FROM meldunek)\n) AS razem;\n\n**Alternatywnie - z UNION:**\n```sql\nSELECT COUNT(*) FROM (\nSELECT DISTINCT m.id_pok, w.tytul\nFROM wypozyczenia w\nJOIN meldunek m ON w.pesel = m.pesel\nUNION ALL\nSELECT NULL, w.tytul\nFROM wypozyczenia w\nWHERE w.pesel NOT IN (SELECT pesel FROM meldunek)\n) AS unique_loans;\n\n## Sposób 3 - Python\n\n```python\n# Wczytaj meldunek: pesel -> id_pok\nmeldunek = {}\nwith open('meldunek.txt', encoding='windows-1250') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 2:\nmeldunek[cz[0]] = cz[1]\n\n# Wczytaj wypożyczenia\nwypozyczenia_z_kampusu = set() # zbiór par (id_pok, tytul)\nwypozyczenia_spoza = 0\nwith open('wypozyczenia.txt', encoding='windows-1250') as f:\nnext(f)\nfor linia in f:\ncz = linia.strip().split('\\t')\nif len(cz) >= 3:\npesel, tytul = cz[1], cz[2]\nif pesel in meldunek:\nwypozyczenia_z_kampusu.add((meldunek[pesel], tytul))\nelse:\nwypozyczenia_spoza += 1\n\nrazem = len(wypozyczenia_z_kampusu) + wypozyczenia_spoza\nprint(razem) # 316\n\n## Sposób 4 - arkusz kalkulacyjny\n\n1. Wypożyczenia: dodaj kolumnę D z `=WYSZUKAJ.PIONOWO(B2; meldunek!A:B; 2; FAŁSZ)` (zwraca id_pok lub błąd dla SPOZA).\n2. Dodaj kolumnę E z formułą: `=JEŻELI(JEST.BŁĄD(D2); C2&\"|SPOZA|\"&A2; D2&\"|\"&C2)` - unikalny klucz dla każdego wiersza.\n- Dla SPOZA klucz zawiera nr wypożyczenia (zawsze unikatowy).\n- Dla z miasteczka klucz = id_pok + tytul (powtórki w pokoju mają ten sam klucz).\n3. Liczba unikalnych: `=ILE.NIEPUSTYCH.UNIKATOWYCH(E2:E_end)` → 316.\n\n## Reference informatyczny - DISTINCT + grupowanie\n\n> Reference - `COUNT(DISTINCT )`:\n> - Liczy liczbę **unikalnych** wartości w wyrażeniu.\n> - W większości SQL można konkatenować pola: `COUNT(DISTINCT a || '|' || b)` lub `COUNT(DISTINCT (a, b))` w PostgreSQL.\n> - **Pułapka NULL**: `COUNT(DISTINCT)` ignoruje NULLe.\n>\n> Reference - Pythonowy zbiór `set` z tuple:\n> - `s.add((a, b))` - dodaje krotkę; ZBIÓR przechowuje tylko unikalne.\n> - `len(s)` - liczba unikalnych krotek.\n> - **Wydajność**: O(1) amortyzowane na operację.\n>\n> Reference - Sprytna alternatywa:\n> - Zamiast `(id_pok, tytul)`, klucz dla SPOZA = `(pesel, tytul)` (unikalny per student) - wtedy nie trzeba rozdzielać przypadków.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.5, max 3 pkt):\n> - **3 pkt** - prawidłowy wynik **316**\n> - **1 pkt** - wynik NIEUWZGLĘDNIAJĄCY studentów spoza kampusu (311)\n> - **0 pkt** - błędna albo brak\n>\n> **Uwaga: NIE PRZYZNAJE SIĘ 2 PUNKTÓW.**\n\n## Typowe pułapki\n\n- **Pominięcie studentów spoza miasteczka** - wynik 311 zamiast 316 (różnica = 5 osób z 5.4, każda z co najmniej 1 wypożyczeniem). **Krytyczne!**\n- **Liczenie tylko `COUNT(*)` na pierwszym JOIN** - to da pełną liczbę wypożyczeń z kampusu, bez deduplikacji.\n- **Pomyłka z dopuszczalną redundancją** - niektórzy uczniowie odejmują wypożyczenia, zamiast policzyć unikalne pary.\n- **Pomylenie pokoju z PESEL** - pokój identyfikuje grupę współlokatorów, NIE jedną osobę.\n- **Sortowanie niepotrzebne** - zadanie pyta o LICZBĘ, nie listę.\n\n## Złożoność obliczeniowa\n\n- Wczytanie meldunek: O(M).\n- Wczytanie wypożyczeń: O(W).\n- Set z parami: O(W) operacji amortyzowanych.\n- **Łącznie: O(M + W).**","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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/6.1","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"6.1","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Zadanie 6. Szyfr Cezara\n\nPodstawieniowy szyfr Cezara z przesunięciem (kluczem) k polega na zastąpieniu każdego znaku jawnego znakiem leżącym w alfabecie o k pozycji w prawo od zastępowanego znaku. Przykład: znak 'B' po zakodowaniu kluczem k=3 zastąpiony zostanie znakiem 'E'.\n\nPrzy szyfrowaniu znaku należy postępować w sposób cykliczny: jawny znak 'X' kluczem k=3 → 'A', 'Y' → 'B', 'Z' → 'C'.\n\nW tym zadaniu rozpatrujemy tylko słowa zbudowane z wielkich liter alfabetu angielskiego (ASCII 65-90), długości ≤ 30 znaków.\n\nW pliku dane_6_1.txt znajduje się 100 słów (każde w osobnym wierszu). Fragment:\nINTERPRETOWANIE\nROZWESELANIE\nKONSERWOWANIE\n\nUwaga: Dla pierwszego słowa z pliku (INTERPRETOWANIE) wynikiem jest słowo LQWHUSUHWRZDQLH (k=3? - w treści k=107).\n\nNapisz program, który zaszyfruje słowa z pliku dane_6_1.txt z użyciem klucza k = 107. Wynik zapisz do pliku wyniki_6_1.txt, każde słowo w osobnym wierszu, w porządku odpowiadającym kolejności słów z pliku z danymi.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Ostatnie wiersze pliku wyniki_6_1.txt:**\n\n| Nr | Tekst jawny | Zaszyfrowany |\n| 97 | INWOKACJA | LQZRNDFMD |\n| 98 | INWESTOWANIE | LQZHVWRZDQLH |\n| 99 | ROZSZERZANIE | URCVCHUCDQLH |\n| 100 | ARYSTOTELES | DUBVWRWHOHV |\n\n## Sposób 1 - szyfr Cezara z modulo 26\n\n**Idea:** dla klucza k = 107, faktyczne przesunięcie = `k mod 26 = 107 mod 26 = 3` (bo 26·4 = 104, 107 - 104 = 3).\n\n**Wzór szyfrowania**:\nzaszyfrowane(c) = ((ord(c) - ord('A') + k) mod 26) + ord('A')\n\n## Sposób 2 - implementacja Python\n\n```python\ndef szyfruj_cezara(slowo, k):\nwynik = []\nfor znak in slowo:\npozycja = ord(znak) - ord('A') # 0 25\nnowa = (pozycja + k) % 26\nwynik.append(chr(ord('A') + nowa))\nreturn ''.join(wynik)\n\nk = 107\nz_wejscia = open('dane_6_1.txt', encoding='utf-8').read().splitlines()\nz_wyjscia = [szyfruj_cezara(s.strip(), k) for s in z_wejscia if s.strip()]\n\nwith open('wyniki_6_1.txt', 'w', encoding='utf-8') as f:\nfor s in z_wyjscia:\nf.write(s + '\\n')\n\n# Sprawdzenie ostatnich:\nfor i, (jawne, szyfr) in enumerate(zip(z_wejscia, z_wyjscia), 1):\nif i >= 97:\nprint(f\"{i} {jawne} -> {szyfr}\")\n\n**Wynik:**\n97 INWOKACJA -> LQZRNDFMD\n98 INWESTOWANIE -> LQZHVWRZDQLH\n99 ROZSZERZANIE -> URCVCHUCDQLH\n100 ARYSTOTELES -> DUBVWRWHOHV\n\n## Sposób 3 - C++\n\n```cpp\n#include \n#include \n#include \nusing namespace std;\n\nstring szyfruj(const string& s, int k) {\nstring wynik = s;\nfor (char& c : wynik) {\nint p = c - 'A';\nc = 'A' + (p + k) % 26;\n}\nreturn wynik;\n}\n\nint main() {\nifstream fin(\"dane_6_1.txt\");\nofstream fout(\"wyniki_6_1.txt\");\nstring s;\nint k = 107;\nwhile (fin >> s) fout << szyfruj(s, k) << \"\\n\";\nreturn 0;\n}\n\n## Sposób 4 - Pascal\n\n```pascal\nprogram Cezar61;\nvar fin, fout: TextFile; s: String; i: Integer;\n\nfunction Szyfruj(s: String; k: Integer): String;\nvar i, p: Integer;\nbegin\nfor i := 1 to Length(s) do begin\np := Ord(s[i]) - Ord('A');\ns[i] := Chr(Ord('A') + (p + k) mod 26);\nend;\nSzyfruj := s;\nend;\n\nbegin\nAssignFile(fin, 'dane_6_1.txt'); Reset(fin);\nAssignFile(fout, 'wyniki_6_1.txt'); Rewrite(fout);\nwhile not Eof(fin) do begin\nReadln(fin, s);\nWriteln(fout, Szyfruj(s, 107));\nend;\nCloseFile(fin); CloseFile(fout);\nend.\n\n## Reference informatyczny - szyfr Cezara\n\n> Reference - Szyfr Cezara:\n> - **Najstarszy szyfr podstawieniowy** (Juliusz Cezar, ok. 50 p.n.e.).\n> - Klucz k przesuwa każdą literę o k pozycji w prawo.\n> - **Cykliczność** - modulo długość alfabetu (26 dla angielskiego).\n> - **Klucz efektywny** = `k mod 26`. Klucze różniące się o wielokrotność 26 dają **ten sam wynik**.\n> - **Deszyfrowanie**: użyj klucza `26 - k` lub `-k mod 26`.\n>\n> Reference - Operacje na znakach:\n> - **Python**: `ord('A') = 65`, `chr(65) = 'A'`. Indeks `'A' 'Z'` = 0 25.\n> - **C++**: `'A' + i` (char arithmetic).\n> - **Pascal**: `Chr(Ord('A') + i)`.\n>\n> Reference - Modulo dla ujemnych:\n> - Python: `(-5) % 26 = 21` (zawsze dodatni wynik).\n> - C++: `(-5) % 26 = -5` (zależy od kompilatora, lepiej `((x % 26) + 26) % 26`).\n> - Pascal: `(-5) mod 26 = -5`. Tu klucz dodatni więc nie problem.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.1, max 3 pkt):\n> - **3 pkt** - poprawny plik wynikowy (wszystkie 100 słów)\n> - **2 pkt** - pominięcie ostatniego wiersza\n> - **1 pkt** - błąd zawijania (brak modulo 26) ALBO bez zawijania\n> - **0 pkt** - błędna albo brak\n\n## Typowe pułapki\n\n- **Brak `mod 26`** - klucz 107 bez modulo da `ord('A') + 65 + 107 = 237` → znak '`í`' lub coś niedrukowalnego. Konieczne `% 26`.\n- **Pomyłka `mod 26` z `mod 25` lub `mod 27`** - alfabet ma 26 liter.\n- **Indeksowanie od 1 vs 0** - Pascal stringi indeksowane od 1, Python/C++ od 0.\n- **Pominięcie ostatniego wiersza** - przy `while fin >> s` w C++ działa OK, ale `while not Eof(fin)` w Pascal może pominąć ostatni wiersz, jeśli plik nie kończy się newline.\n- **Klucz ujemny przy odszyfrowywaniu** - uważać na `(x % 26 + 26) % 26`.\n- **Polskie znaki** - w zadaniu są tylko wielkie litery angielskie A-Z; ewentualne polskie znaki pomijamy lub błąd danych.\n\n## Złożoność obliczeniowa\n\n- Szyfrowanie jednego słowa długości L: **O(L)**.\n- 100 słów × max 30 znaków: **O(3000)** operacji.\n- I/O dominuje, ale to też O(N) liniowo.","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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/6.2","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"6.2","points":4,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 6.1.\n\nW pliku dane_6_2.txt zapisano 3 000 szyfrogramów i odpowiadające im klucze szyfrujące. W każdym wierszu: szyfrogram + spacja + klucz (max 4-cyfrowa liczba). Fragment:\nBCYKUNCM 1718\nYFOGNSKGYW 7580\nWARDA 9334\n\nUwaga: Dla pierwszego szyfrogramu (BCYKUNCM) wynikiem jest słowo ZAWISLAK.\n\nNapisz program, który odszyfruje słowa zaszyfrowane podanymi kluczami. Wynik zapisz w pliku wyniki_6_2.txt: każde odszyfrowane słowo w osobnym wierszu, w porządku odpowiadającym kolejności szyfrogramów z pliku z danymi.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Przykładowe linie pliku wyniki_6_2.txt:**\n\n| Linia | Poprawny wynik |\n| 1 | ZAWISLAK |\n| 10 | KREZEL |\n| 11 | ANTOLAK |\n| 100 | KWIATKOWSKI |\n| 453 | LADA |\n\n## Sposób 1 - odszyfrowanie = szyfrowanie kluczem przeciwnym\n\n**Idea:** odszyfrowanie szyfru Cezara polega na przesunięciu w LEWO o k pozycji = przesunięciu w PRAWO o `26 - k mod 26`.\n\n**Wzór deszyfrowania:**\nrozszyfrowane(c) = ((ord(c) - ord('A') - k) mod 26 + 26) mod 26 + ord('A')\n\nlub równoważnie:\nrozszyfrowane(c) = ((ord(c) - ord('A') + (26 - k mod 26)) mod 26) + ord('A')\n\n**Weryfikacja BCYKUNCM z kluczem 1718:**\n- 1718 mod 26 = 1718 - 66·26 = 1718 - 1716 = **2**.\n- Deszyfrowanie: każdą literę przesuwamy o 2 w lewo.\n- B (1) → Z (25) ✓\n- C (2) → A (0) ✓\n- Y (24) → W (22) ✓\n- K (10) → I (8) ✓\n- U (20) → S (18) ✓\n- N (13) → L (11) ✓\n- C (2) → A (0) ✓\n- M (12) → K (10) ✓\n- Wynik: **ZAWISLAK** ✓\n\n## Sposób 2 - implementacja Python\n\n```python\ndef rozszyfruj(s, k):\nwynik = []\nfor znak in s:\np = ord(znak) - ord('A')\nnowa = (p - k) % 26\nwynik.append(chr(ord('A') + nowa))\nreturn ''.join(wynik)\n\nwith open('dane_6_2.txt', encoding='utf-8') as fin, \\\nopen('wyniki_6_2.txt', 'w', encoding='utf-8') as fout:\nfor linia in fin:\ncz = linia.strip().split()\nif len(cz) != 2:\ncontinue\nszyfr, k_str = cz\nk = int(k_str)\nfout.write(rozszyfruj(szyfr, k) + '\\n')\n\n## Sposób 3 - C++\n\n```cpp\n#include \n#include \n#include \nusing namespace std;\n\nstring rozszyfruj(const string& s, int k) {\nstring wynik = s;\nint kk = k % 26;\nfor (char& c : wynik) {\nint p = c - 'A';\nint n = ((p - kk) % 26 + 26) % 26;\nc = 'A' + n;\n}\nreturn wynik;\n}\n\nint main() {\nifstream fin(\"dane_6_2.txt\");\nofstream fout(\"wyniki_6_2.txt\");\nstring szyfr;\nint k;\nwhile (fin >> szyfr >> k) fout << rozszyfruj(szyfr, k) << \"\\n\";\nreturn 0;\n}\n\n## Sposób 4 - Pascal\n\n```pascal\nprogram Cezar62;\nvar fin, fout: TextFile; s: String; k, i, p, n: Integer;\nbegin\nAssignFile(fin, 'dane_6_2.txt'); Reset(fin);\nAssignFile(fout, 'wyniki_6_2.txt'); Rewrite(fout);\nwhile not Eof(fin) do begin\nRead(fin, s);\nReadln(fin, k);\nfor i := 1 to Length(s) do begin\np := Ord(s[i]) - Ord('A');\nn := ((p - k) mod 26 + 26) mod 26;\ns[i] := Chr(Ord('A') + n);\nend;\nWriteln(fout, s);\nend;\nCloseFile(fin); CloseFile(fout);\nend.\n\n## Reference informatyczny - odszyfrowanie szyfru Cezara\n\n> Reference - Odszyfrowanie:\n> - Skoro szyfr = `(p + k) mod 26`, to odszyfrowanie = `(p_szyfr - k) mod 26`.\n> - **Pułapka modulo ujemnego**: `(-5) % 26` w C/C++/Pascal może dać -5; w Pythonie 21. Dlatego `((x % 26) + 26) % 26` - bezpieczne dla wszystkich języków.\n> - Alternatywnie: szyfrowanie kluczem `(26 - k mod 26)` = odszyfrowanie kluczem k.\n>\n> Reference - Duże klucze:\n> - W tym zadaniu klucz może być do 4-cyfrowy (max 9999). Modulo 26 redukuje to do 0-25.\n> - `1718 mod 26 = 2`, `7580 mod 26 = 24`, `9334 mod 26 = 14`.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.2, max 4 pkt):\n> Sprawdzane jest pierwsze 700 wierszy pliku wynikowego.\n> - **4 pkt** - poprawny plik wynikowy\n> - **2 pkt** - błędne dekodowanie jednej litery ALBO błąd zawijania ALBO błędna długość alfabetu (25)\n> - **0 pkt** - błędna albo brak\n>\n> **Uwaga: NIE PRZYZNAJE SIĘ 3 ani 1 PUNKTU.**\n\n## Typowe pułapki\n\n- **Długość alfabetu 25 zamiast 26** - błąd modulo. Klucz angielski A-Z = 26 liter.\n- **Modulo ujemne** - w niektórych językach `(0 - 2) % 26 = -2` (powinno być 24). Zawsze `((x % 26) + 26) % 26`.\n- **Szyfrowanie zamiast deszyfrowania** - w zadaniu mamy SZYFROGRAM i klucz, więc odejmujemy klucz, nie dodajemy.\n- **Nieparsowanie linii poprawnie** - `split()` po spacji daje [szyfr, klucz]. Klucz konwertujemy `int()`.\n- **Włączenie pustych linii** - `if not linia.strip(): continue`.\n- **Pominięcie wiersza po ostatnim newline** - `for linia in fin` lub `while fin >> s >> k` zwykle radzi sobie z tym.\n\n## Złożoność obliczeniowa\n\n- 3000 słów × max 30 znaków: **O(90 000) = O(N·L)** operacji.\n- I/O liniowe.","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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2016-maj-matura-rozszerzona/zad/6.3","paper_id":"informatyka-2016-maj-matura-rozszerzona","number":"6.3","points":5,"ptype":"open","subject":"informatyka","category":"matura","year":2016,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 6.1.\n\nW pliku dane_6_3.txt zapisano 3 000 par słów. Drugie słowo w każdej parze jest szyfrogramem pierwszego z nieznanym kluczem. Niektóre szyfrogramy są błędne (niektóre litery zakodowano z różnymi przesunięciami). Słowo ma zawsze tę samą długość co odpowiadający mu szyfrogram.\n\nFragment:\nZAWISLAK EFBNXQFP\nKRASZEWSKI XENFMRJFXV\n\nUwaga: Pierwsze słowo w pliku wynikowym to SMIGIELSKI.\n\nNapisz program, który wyszuka i wypisze te słowa z pliku dane_6_3.txt, które błędnie zaszyfrowano. Wynik zapisz w pliku wyniki_6_3.txt: każde słowo w osobnym wierszu, w porządku odpowiadającym kolejności tych słów z pliku z danymi.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Pierwsze słowa w pliku wynikowym:**\n\nSMIGIELSKI\nJANEK\nJANUSZEWSKI\nWOLAK\nGAJEK\nMROCZKOWSKI\nSZCZESNIAK\nCIESLINSKI\n(i więcej, w kolejności występowania)\n\n## Sposób 1 - wykrywanie błędu szyfrowania\n\n**Idea:** prawidłowy szyfr Cezara to **stałe przesunięcie** dla całego słowa. Dla każdej pary (jawne, szyfr) liczymy przesunięcie każdej litery `delta_i = (szyfr[i] - jawne[i]) mod 26`. Jeśli **wszystkie delta_i są równe** → szyfrowanie prawidłowe. Jeśli różnią się → BŁĘDNE.\n\n**Weryfikacja KRASZEWSKI → XENFMRJFXV:**\n- K(10) → X(23): delta = (23-10) mod 26 = 13\n- R(17) → E(4): delta = (4-17) mod 26 = -13 mod 26 = 13 ✓\n- A(0) → N(13): delta = 13 ✓\n- S(18) → F(5): delta = (5-18) mod 26 = -13 mod 26 = 13 ✓\n- Z(25) → M(12): delta = (12-25) mod 26 = -13 mod 26 = 13 ✓\n- E(4) → R(17): delta = 13 ✓\n- W(22) → J(9): delta = (9-22) mod 26 = -13 mod 26 = 13 ✓\n- S(18) → F(5): 13 ✓\n- K(10) → X(23): 13 ✓\n- I(8) → V(21): delta = 13 ✓\n\nWszystkie delta = 13 → szyfr **prawidłowy**, NIE dodajemy KRASZEWSKI do wyniku.\n\n## Sposób 2 - implementacja Python\n\n```python\ndef przesuniecie(jawny, szyfr):\n\"\"\"Zwraca delta = (szyfr - jawne) mod 26 dla pierwszej litery.\"\"\"\nreturn (ord(szyfr) - ord(jawny)) % 26\n\ndef czy_blednie_zaszyfrowane(jawne, szyfr):\nif len(jawne) != len(szyfr):\nreturn True # różna długość = błąd\ndelty = [(ord(s) - ord(j)) % 26 for j, s in zip(jawne, szyfr)]\nreturn len(set(delty)) > 1 # więcej niż jedno przesunięcie\n\nwynik = []\nwith open('dane_6_3.txt', encoding='utf-8') as fin:\nfor linia in fin:\ncz = linia.strip().split()\nif len(cz) != 2:\ncontinue\njawne, szyfr = cz\nif czy_blednie_zaszyfrowane(jawne, szyfr):\nwynik.append(jawne)\n\nwith open('wyniki_6_3.txt', 'w', encoding='utf-8') as fout:\nfor s in wynik:\nfout.write(s + '\\n')\n\nprint(\"Pierwsze 10:\")\nfor s in wynik[:10]:\nprint(s)\n\n**Spodziewany początek wyniku:**\nSMIGIELSKI\nJANEK\nJANUSZEWSKI\nWOLAK\nGAJEK\nMROCZKOWSKI\nSZCZESNIAK\nCIESLINSKI\n\n## Sposób 3 - C++\n\n```cpp\n#include \n#include \n#include \n#include \nusing namespace std;\n\nbool blednyszyfr(const string& jawny, const string& szyfr) {\nif (jawny.size() != szyfr.size()) return true;\nset delty;\nfor (size_t i = 0; i < jawny.size(); i++) {\nint d = ((szyfr[i] - jawny[i]) % 26 + 26) % 26;\ndelty.insert(d);\n}\nreturn delty.size() > 1;\n}\n\nint main() {\nifstream fin(\"dane_6_3.txt\");\nofstream fout(\"wyniki_6_3.txt\");\nstring jawny, szyfr;\nwhile (fin >> jawny >> szyfr) {\nif (blednyszyfr(jawny, szyfr)) fout << jawny << \"\\n\";\n}\nreturn 0;\n}\n\n## Sposób 4 - Pascal\n\n```pascal\nprogram Cezar63;\nvar fin, fout: TextFile; jawny, szyfr: String;\ni, d, d0: Integer; blad: Boolean;\nbegin\nAssignFile(fin, 'dane_6_3.txt'); Reset(fin);\nAssignFile(fout, 'wyniki_6_3.txt'); Rewrite(fout);\nwhile not Eof(fin) do begin\nReadln(fin, jawny, ' ', szyfr); // lub Read + Read\nblad := False;\nif Length(jawny) <> Length(szyfr) then blad := True\nelse begin\nd0 := ((Ord(szyfr[1]) - Ord(jawny[1])) mod 26 + 26) mod 26;\nfor i := 2 to Length(jawny) do begin\nd := ((Ord(szyfr[i]) - Ord(jawny[i])) mod 26 + 26) mod 26;\nif d <> d0 then begin blad := True; Break; end;\nend;\nend;\nif blad then Writeln(fout, jawny);\nend;\nCloseFile(fin); CloseFile(fout);\nend.\n\n## Reference informatyczny - kryptoanaliza szyfru Cezara\n\n> Reference - Wykrywanie błędu szyfru Cezara:\n> - **Cecha charakterystyczna**: prawidłowy szyfr Cezara ma **stałe przesunięcie** dla całego słowa.\n> - Algorytm wykrywania: oblicz przesunięcie dla każdej pozycji; jeśli przynajmniej dwa różne → BŁĘDNE.\n> - **Złożoność**: O(L) na słowo, gdzie L = długość słowa.\n>\n> Reference - Modulo z ujemnymi:\n> - `(szyfr - jawne) mod 26` może dać wartość ujemną w C++/Pascal.\n> - Zabezpieczenie: `((x % 26) + 26) % 26`.\n> - W Pythonie `(szyfr - jawne) % 26` zwraca zawsze 0 25 - bez problemu.\n>\n> Reference - Set zamiast porównania:\n> - Jeśli wszystkie elementy listy są takie same, `set(lista)` ma rozmiar 1.\n> - Bardzo elegancka kontrola jednorodności.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.3, max 5 pkt):\n> - **5 pkt** - poprawny plik wynikowy\n> - **3 pkt** - program odwrotny (przepisuje POPRAWNIE szyfrowane)\n> - **2 pkt** - wynik bez uwzględnienia zawijania (modulo 26)\n> - **0 pkt** - błędna albo brak\n>\n> **Uwaga: NIE PRZYZNAJE SIĘ 4 ani 1 PUNKTU.**\n\n## Typowe pułapki\n\n- **Odwrotny program** - wypisuje TYLKO poprawnie zaszyfrowane zamiast BŁĘDNE - strata 2 pkt.\n- **Modulo ujemne nieprawidłowe** - `(B - Z)` w C++ daje -24 (zamiast 2). Konieczne `((x % 26) + 26) % 26`.\n- **Brak modulo 26** - przesunięcia mogą wyjść spoza zakresu 0-25, ale wciąż być stałe; bez modulo program zwraca BŁĘDNE dla wszystkich.\n- **Porównanie pierwszej z drugą tylko** - błąd: trzeba sprawdzić, czy WSZYSTKIE delta są równe.\n- **Pominięcie pierwszego przesunięcia** - niektóre implementacje porównują delta[i] z delta[i-1]; trzeba pamiętać, żeby zacząć od i=1 lub i=2 (Pascal).\n- **Pomylenie kolejności** - w pliku jest \"JAWNE SZYFR\", nie odwrotnie.\n\n## Złożoność obliczeniowa\n\n- 3000 słów × max 30 znaków: O(N·L) = **O(90 000) operacji**.\n- Set/porównanie delta: O(L) na 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 2016 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"}]}