{"paper":{"id":"informatyka-2015-maj-matura-rozszerzona","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","variant":null,"exam_pdf":"informatyka-2015-maj-matura-rozszerzona/informatyka-2015-maj-matura-rozszerzona.pdf","key_pdf":"informatyka-2015-maj-matura-rozszerzona-odpowiedzi/informatyka-2015-maj-matura-rozszerzona-odpowiedzi.pdf","question_count":22,"source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},"questions":[{"id":"informatyka-2015-maj-matura-rozszerzona/zad/1","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"1","points":null,"ptype":"closed","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 1. Problem telewidza\nW Problemie telewidza mamy program telewizyjny, zawierający listę filmów emitowanych\nw różnych stacjach telewizyjnych jednego dnia. Telewidz zamierza obejrzeć jak najwięcej\nfilmów w całości. Jedyne ograniczenie jest takie, że telewidz może oglądać co najwyżej jeden\nfilm (stację telewizyjną) jednocześnie. Zakładamy, że jednego dnia wszystkie filmy są różne.\nProgram telewizyjny emisji filmów w 4 stacjach telewizyjnych:\nTelewizja / stacja\nFilm i godziny jego emisji\nCzas trwania emisji filmu\nTV1\nfilm 1: od 9:00 do 12:00\nfilm 2: od 15:00 do 17:00\n3 godziny\n2 godziny\nTV2\nfilm 3: od 11:00 do 16:00\n5 godzin\nTV3\nfilm 4: od 12:00 do 14:00\n2 godziny\nTV4\nfilm 5: od 11:30 do 12:30\n1 godzina\nDla programu podanego powyżej telewidz jest w stanie obejrzeć aż trzy filmy, np.: film 1,\nfilm 4, film 2. Przyjmujemy, że telewidz nie traci w ogóle czasu na przełączanie\npomiędzy stacjami (np. o godz. 12:00 z TV1 na TV3). Innymi słowy, czasy emisji filmów 1\ni 4 nie kolidują ze sobą.\nRozważ następujący algorytm wyboru filmów do obejrzenia przez telewidza, w którym\nw kroku 2. stosuje się jedną z czterech strategii opisanych w tabeli 1.\nSpecyfikacja:\nDane:\nT - zbiór filmów z programu telewizyjnego z godzinami emisji i czasami ich\ntrwania,\nS - strategia z tabeli 1.\nWynik:\nP - zbiór filmów, które obejrzy telewidz.\nAlgorytm:\nKrok 1.\nZainicjuj P jako zbiór pusty.\nKrok 2.\nDopóki T zawiera jakieś filmy, wykonuj:\nstosując strategię S, wybierz ze zbioru T film x i usuń go z T\ndodaj film x do zbioru P\nusuń ze zbioru T wszystkie filmy, których czasy emisji kolidują z czasem\nemisji filmu x.\nKrok 3.\nZakończ wykonywanie algorytmu i wypisz wszystkie filmy ze zbioru P.\nMIN_1R\nTabela 1. Cztery strategie (S) w Problemie telewidza:\nStrategia A\nWybierz film, który trwa najdłużej, a jeśli jest takich więcej, to wybierz\nz nich ten, który się najwcześniej kończy. Jeśli jest więcej takich filmów,\nwybierz dowolny z nich.\nStrategia B\nWybierz film, który trwa najkrócej, a jeśli jest takich więcej, to wybierz\nz nich ten, który się najwcześniej kończy. Jeśli jest więcej takich filmów,\nwybierz dowolny z nich.\nStrategia C\nWybierz film, który się najwcześniej zaczyna, a jeśli jest takich więcej,\nto wybierz z nich ten, który się najwcześniej kończy. Jeśli jest więcej\ntakich filmów, wybierz dowolny z nich.\nStrategia D\nWybierz film, który się najwcześniej kończy, a jeśli jest takich więcej,\nto wybierz z nich ten, który się najpóźniej zaczyna. Jeśli jest więcej\ntakich filmów, wybierz dowolny z nich.\nPrzykład:\nDla podanego programu telewizyjnego zastosowanie w kroku 2. strategii A daje wynik\nP = {film 3}, czyli telewidz obejrzy tylko jeden film.","answer":null,"answer_text":"188\n12\n-1\n16","solution":null,"image":"img/informatyka-2015-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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/1.1","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"1.1","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 1.1. (0-2)\nDla\npodanego\nprogramu\ntelewizyjnego\npodaj\nwyniki\nwykonywania\nalgorytmu\npo zastosowaniu strategii B, C i D:\nStrategia S\nZawartość zbioru P po zakończeniu wykonywania algorytmu\nB\nC\nD\nMiejsce na obliczenia.\nWypełnia\negzaminator\nNr zadania\n1.1.\nMaks. liczba pkt.\n2\nUzyskana liczba pkt.\nMIN_1R","answer":null,"answer_text":"Zadanie 1.1. (0-2)\nWymagania ogólne\nWymagania szczegółowe\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji z wykorzystaniem\nkomputera, z zastosowaniem podejścia\nalgorytmicznego.\nZdający stosuje podejście algorytmiczne\ndo rozwiązywania problemu (5.2.).\nZdający opracowuje i przeprowadza wszystkie etapy\nprowadzące do otrzymania poprawnego rozwiązania\nproblemu: od sformułowania specyfikacji problemu\npo testowanie rozwiązania (5.7.).\nPoprawna odpowiedź\nstrategia B: P={ film 5, film 2 }\nstrategia C: P={ film 1, film 4, film 2 }\nstrategia D: P={ film 1, film 4, film 2 }\nSchemat punktowania\n2 p. - za podanie poprawnych odpowiedzi dla trzech strategii.\n1 p. - za podanie poprawnych odpowiedzi dla dwóch strategii.\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.","solution":"## Poprawna odpowiedź\n\n| Strategia | Zbiór P |\n| B (najkrótszy, najwcześniej kończący) | **{film 5, film 2}** |\n| C (najwcześniej zaczynający się, najwcześniej kończący) | **{film 1, film 4, film 2}** |\n| D (najwcześniej kończący, najpóźniej zaczynający) | **{film 1, film 4, film 2}** |\n\n## Sposób 1 - symulacja krok po kroku\n\nLista filmów:\n- film 1: 9:00-12:00 (3 h)\n- film 2: 15:00-17:00 (2 h)\n- film 3: 11:00-16:00 (5 h)\n- film 4: 12:00-14:00 (2 h)\n- film 5: 11:30-12:30 (1 h)\n\n**Strategia B - najkrótszy, w razie remisu najwcześniej kończący**\n\n1. Najkrótszy film: **film 5** (1 h). Dodaj do P. Usuń kolidujące: film 1 (9-12 koliduje z 11:30-12:30), film 3 (11-16), film 4 (12-14 - 12:00 to wciąż w 11:30-12:30? Wg konwencji 12:00 = koniec film 5, ale film 4 zaczyna o 12:00 - KOLIZJA gdy [a,b) lub przy zachodzeniu - przyjmujemy NIE koliduje z film 5 bo 12:00 to brzeg).\n- Dokładniej: film 5 trwa do 12:30, film 4 zaczyna o 12:00 → KOLIZJA. Film 4 usunięty.\n- Pozostaje: film 2.\n2. Film 2 jest najkrótszy spośród pozostałych. Dodaj do P. Brak kolizji.\n3. Koniec. **P = {film 5, film 2}** (2 filmy).\n\n**Strategia C - najwcześniej zaczynający się, najwcześniej kończący**\n\n1. Najwcześniej zaczyna film 1 (9:00). Dodaj. Usuń kolidujące: film 3 (11:00 koliduje), film 5 (11:30 koliduje).\n- Pozostaje: film 2 (15-17), film 4 (12-14).\n2. Z pozostałych najwcześniej zaczyna film 4 (12:00). Dodaj. Brak kolizji z film 2.\n3. Pozostaje film 2. Dodaj.\n4. **P = {film 1, film 4, film 2}** (3 filmy).\n\n**Strategia D - najwcześniej kończący, w razie remisu najpóźniej zaczynający**\n\n1. Czasy zakończenia: film 1 → 12, film 5 → 12:30, film 4 → 14, film 3 → 16, film 2 → 17.\nNajwcześniej kończy film 1 (12:00). Dodaj. Usuń kolidujące: film 3 (11-16 koliduje), film 5 (11:30-12:30 koliduje).\n- Pozostaje: film 2, film 4.\n2. Najwcześniej kończy film 4 (14:00). Dodaj. Brak kolizji z film 2.\n3. Pozostaje film 2. Dodaj.\n4. **P = {film 1, film 4, film 2}** (3 filmy).\n\n## Sposób 2 - implementacja Python\n\n```python\nfilmy = {\n'film 1': (9.0, 12.0),\n'film 2': (15.0, 17.0),\n'film 3': (11.0, 16.0),\n'film 4': (12.0, 14.0),\n'film 5': (11.5, 12.5),\n}\n\ndef koliduje(a, b):\ns1, e1 = a; s2, e2 = b\nreturn s1 < e2 and s2 < e1\n\ndef algorytm(filmy, klucz):\nT = dict(filmy)\nP = []\nwhile T:\nnazwa = min(T, key=lambda x: klucz(x, T[x]))\nP.append(nazwa)\nwybrany = T.pop(nazwa)\nT = {n: t for n, t in T.items() if not koliduje(t, wybrany)}\nreturn P\n\n# Strategia B: najkrótszy, w remisie najwcześniej kończący\nklucz_B = lambda n, t: (t[1] - t[0], t[1])\n# Strategia C: najwcześniej zaczynający, w remisie najwcześniej kończący\nklucz_C = lambda n, t: (t[0], t[1])\n# Strategia D: najwcześniej kończący, w remisie najpóźniej zaczynający\nklucz_D = lambda n, t: (t[1], -t[0])\n\nprint('B:', algorytm(filmy, klucz_B))\nprint('C:', algorytm(filmy, klucz_C))\nprint('D:', algorytm(filmy, klucz_D))\n\nWynik: B = ['film 5', 'film 2'], C = ['film 1', 'film 4', 'film 2'], D = ['film 1', 'film 4', 'film 2'].\n\n## Reference informatyczny - problem wyboru aktywności (greedy)\n\n> Reference - Activity Selection Problem:\n> - Klasyczny problem: dany zbiór przedziałów, wybierz **najwięcej niekolidujących**.\n> - **Optymalna strategia zachłanna**: sortuj wg czasu zakończenia rosnąco, bierz pierwszy, usuń kolidujące, powtarzaj. To jest strategia D.\n> - Złożoność: O(n log n) (sortowanie) + O(n) (wybór).\n> - Strategie A, B, C nie są optymalne - łatwo skonstruować kontrprzykład.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 1.1, max 2 pkt):\n> - **2 pkt** - poprawne odpowiedzi dla trzech strategii\n> - **1 pkt** - poprawne odpowiedzi dla dwóch strategii\n> - **0 pkt** - niepełna lub błędna albo brak\n\n## Typowe pułapki\n\n- Pomylenie kolizji na brzegach (czy 12:00-14:00 koliduje z 11:00-12:00?) - w klasycznym problemie aktywności **NIE koliduje** gdy się stykają (przedziały półotwarte [a,b)).\n- Strategia B - film 5 jest najkrótszy (1 h) i wyklucza film 4, więc wynik tylko 2 filmy.\n- Strategia C i D dają ten sam wynik dla tego programu, ale to przypadek - C nie jest optymalna w ogólności.\n- Nieusunięcie wszystkich kolidujących po wyborze.\n\n## Złożoność obliczeniowa\n\n- Algorytm greedy: **O(n²)** przy naiwnej implementacji (każdy wybór + usuwanie).\n- **O(n log n)** przy sortowaniu i jednym przejściu.","image":"img/informatyka-2015-maj-matura-rozszerzona/zad-1.1.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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/1.2","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"1.2","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 1.2. (0-3)\nZastosowana strategia S w algorytmie jest optymalna, jeśli dla każdego programu\ntelewizyjnego wynik algorytmu (zbiór P) zawiera największą możliwą liczbę filmów, które\nmoże obejrzeć telewidz.\nUwaga:\nStrategia A nie jest optymalna, ponieważ telewidz może obejrzeć trzy filmy: film 1,\nfilm 4 oraz film 2.\nDla strategii A, B i C podaj w przygotowanych tabelach przykłady programów telewizyjnych,\nz emisją czterech filmów w dwóch stacjach, będące dowodami, że żadna z tych strategii nie\njest optymalna.\nDla każdej strategii i podanego dla niej programu telewizyjnego podaj wynik działania\nalgorytmu oraz przykład ilustrujący, że telewidz może obejrzeć więcej filmów, jeżeli nie\nużywa tej strategii.\nWskazówka. Podaj takie godziny emisji czterech filmów, aby telewidz był w stanie obejrzeć\nnp. trzy lub więcej filmów, podczas gdy zastosowanie algorytmu z odpowiednią strategią\ndaje rozwiązanie zawierające co najwyżej dwa filmy.\nDowód dla strategii A:\nTelewizja\n/ stacja\nFilm i godziny jego emisji\nCzas trwania\nemisji filmu\nTV1\nfilm 1 (od do ),\nfilm 2 (od do )\nTV2\nfilm 3 (od do ),\nfilm 4 (od do )\nWynik działania algorytmu przy zastosowaniu strategii A:\nP\nLiczniejszy zbiór filmów, które może obejrzeć widz:\nDowód dla strategii B:\nTelewizja\n/ stacja\nFilm i godziny jego emisji\nCzas trwania\nemisji filmu\nTV1\nfilm 1 (od do ),\nfilm 2 (od do )\nTV2\nfilm 3 (od do ),\nfilm 4 (od do )\nWynik działania algorytmu przy zastosowaniu strategii B:\nP\nLiczniejszy zbiór filmów, które może obejrzeć widz:\nMIN_1R\nDowód dla strategii C:\nTelewizja\n/ stacja\nFilm i godziny jego emisji\nCzas trwania\nemisji filmu\nTV1\nfilm 1 (od do ),\nfilm 2 (od do )\nTV2\nfilm 3 (od do ),\nfilm 4 (od do )\nWynik działania algorytmu przy zastosowaniu strategii C:\nP\nLiczniejszy zbiór filmów, które może obejrzeć widz:","answer":null,"answer_text":"Zadanie 1.2. (0-3)\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji z wykorzystaniem\nkomputera, z zastosowaniem podejścia\nalgorytmicznego.\nZdający opracowuje i przeprowadza wszystkie etapy\nprowadzące do otrzymania poprawnego rozwiązania\nproblemu: od sformułowania specyfikacji problemu\npo testowa nie rozwiązania (5.7.).\nZdający stosuje podejście zachłanne\nw rozwiązywaniu problemów (5.10.).\nPoprawna odpowiedź\nStrategia A\nTelewizja/kanał\nFilm i godziny jego emisji\nTV1\nfilm 1 (od 10:00 do 12:00),\nfilm 2 (od 12:00 do 14:00)\nTV2\nfilm 3 (od 10:00 do 11:00),\nfilm 4 (od 11:00 do 12:00)\nWynik algorytmu przy zastosowaniu strategii A:\nP={ film 1, film 2}\nWiększy zbiór filmów, które może obejrzeć widz:\nP={ film 3, film 4, film 2 }\nStrategia B\nTelewizja/kanał\nFilm i godziny jego emisji\nTV1\nfilm 1 (od 11:30 do 12:30),\nfilm 2 (od 15:00 do 16:00)\nTV2\nfilm 3 (od 10:00 do 12:00),\nfilm 4 (od 12:00 do 14:00)\nWynik algorytmu przy zastosowaniu strategii B:\nP={ film 1, film 2}\nWiększy zbiór filmów, które może obejrzeć widz:\nP={ film 3, film 4, film 2 }\nStrategia C\nTelewizja/kanał\nFilm i godziny jego emisji\nTV1\nfilm 1 (od 09:00 do 14:00),\nfilm 2 (od 15:00 do 16:00)\nTV2\nfilm 3 (od 10:00 do 12:00),\nfilm 4 (od 12:00 do 14:00)\nWynik algorytmu przy zastosowaniu strategii C:\nP={ film 1, film 2}\nWiększy zbiór filmów, które może obejrzeć widz:\nP={ film 3, film 4, film 2 }\nSchemat punktowania\n3 p. - za podanie dla trzech strategii programu telewizyjnego, poprawnego dla nich wyniku algorytmu\noraz poprawnego większego zbioru filmów, który może obejrzeć.\n2 p. - za podanie dla dwóch strategii programu telewizyjnego, poprawnego dla nich wyniku algorytmu\noraz poprawnego większego zbioru filmów, który może obejrzeć.\n1 p. - za podanie dla jednej strategii programu telewizyjnego, poprawnego dla niej wyniku algorytmu\noraz poprawnego większego zbioru filmów, który może obejrzeć.\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.\nUwaga: sprawdzenie poprawności odpowiedzi wymaga zasymulowania działania algorytmu na\npodanym przez ucznia przykładzie oraz sprawdzenia, czy podany większy zbiór jest poprawny.","solution":"## Poprawna odpowiedź\n\nKontrprzykłady (po jednym dla A, B, C):\n\n**Strategia A (najdłuższy, w razie remisu najwcześniej kończący) - nieoptymalna:**\n\n| Telewizja | Filmy |\n| TV1 | film 1: 10:00-12:00; film 2: 12:00-14:00 |\n| TV2 | film 3: 10:00-11:00; film 4: 11:00-12:00 |\n\n- Wynik strategii A: P = **{film 1, film 2}** (2 filmy - film 1 najdłuższy 2h, koliduje z 3 i 4; potem film 2).\n- Większy zbiór: **{film 3, film 4, film 2}** (3 filmy).\n\n**Strategia B (najkrótszy, w razie remisu najwcześniej kończący) - nieoptymalna:**\n\n| Telewizja | Filmy |\n| TV1 | film 1: 11:30-12:30; film 2: 15:00-16:00 |\n| TV2 | film 3: 10:00-12:00; film 4: 12:00-14:00 |\n\n- Wynik strategii B: P = **{film 1, film 2}** (film 1 najkrótszy 1h, koliduje z 3 i 4; potem film 2 też 1h).\n- Większy zbiór: **{film 3, film 4, film 2}** (3 filmy).\n\n**Strategia C (najwcześniej zaczynający, w razie remisu najwcześniej kończący) - nieoptymalna:**\n\n| Telewizja | Filmy |\n| TV1 | film 1: 09:00-14:00; film 2: 15:00-16:00 |\n| TV2 | film 3: 10:00-12:00; film 4: 12:00-14:00 |\n\n- Wynik strategii C: P = **{film 1, film 2}** (film 1 zaczyna najwcześniej 9:00, koliduje z 3 i 4; potem film 2).\n- Większy zbiór: **{film 3, film 4, film 2}** (3 filmy).\n\n## Sposób 1 - analiza dlaczego dana strategia zawodzi\n\n**Strategia A (najdłuższy):** wybiera długi film, który blokuje wiele krótkich. Kontrprzykład: 1 długi film przeciw 2 krótkim, które się nie nakładają.\n\n**Strategia B (najkrótszy):** krótki film znajdujący się \"w środku\" innego długiego blokuje konfigurację z większej liczby krótkich. Film 1 jest najkrótszy (1h) i wyklucza film 3 i film 4.\n\n**Strategia C (najwcześniej zaczynający):** wybiera film startujący najwcześniej, nawet jeśli długo trwa. Film 1 startuje o 9:00 i blokuje wszystko między 9 a 14.\n\n## Sposób 2 - uzasadnienie optymalności strategii D\n\nStrategia D (najwcześniej kończący, w razie remisu najpóźniej zaczynający) to klasyczny **algorytm zachłanny dla problemu wyboru aktywności** - twierdzenie z teorii algorytmów mówi, że ZAWSZE daje optymalną liczbę niekolidujących przedziałów.\n\n**Dowód intuicyjny:** Wybierając film kończący się najwcześniej, zostawiamy MAKSIMUM czasu pozostałego dla kolejnych filmów. Twierdzenie wymiany (exchange argument) pokazuje, że dowolne rozwiązanie optymalne można \"przekształcić\" na rozwiązanie zaczynające się od najwcześniej kończącego filmu, bez utraty liczebności.\n\n## Reference informatyczny - twierdzenie o optymalności greedy\n\n> Reference - Activity Selection Theorem:\n> - Strategia \"earliest deadline first\" (najwcześniej kończący) jest optymalna dla problemu wyboru najliczniejszego zbioru niekolidujących aktywności.\n> - Dowód: indukcja po liczbie aktywności + exchange argument.\n> - Strategie inne (najdłuższy / najkrótszy / najwcześniej zaczynający) są w ogólności NIEOPTYMALNE.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 1.2, max 3 pkt):\n> - **3 pkt** - kontrprzykłady dla 3 strategii (program TV + wynik algorytmu + większy zbiór)\n> - **2 pkt** - dla 2 strategii\n> - **1 pkt** - dla 1 strategii\n> - **0 pkt** - niepełna albo brak\n\n## Typowe pułapki\n\n- Podanie tylko programu TV bez wyniku działania algorytmu - nieuznaje się.\n- Podanie programu, w którym strategia daje 3 filmy - to NIE jest kontrprzykład (musi dać <3).\n- Pominięcie warunku \"4 filmy w 2 stacjach\".\n- Mylenie czasu zakończenia / czasu zaczęcia.\n\n## Złożoność obliczeniowa\n\n- Sprawdzenie kontrprzykładu: O(1) (mała liczba filmów).\n- Algorytm wyboru aktywności (greedy z sortowaniem): O(n log n).","image":"img/informatyka-2015-maj-matura-rozszerzona/zad-1.2.webp","solution_image":null,"topics":null,"page_from":4,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/2","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"2","points":null,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 2. 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 punkt uzyskasz tylko za komplet poprawnych odpowiedzi.","answer":null,"answer_text":"12\n8\n1\n-1","solution":null,"image":"img/informatyka-2015-maj-matura-rozszerzona/zad-2.webp","solution_image":null,"topics":null,"page_from":5,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":null,"text_source":"ocr","source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/2.1","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"2.1","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 2.1. (0-1)\nPo wymnożeniu dwóch liczb 10324 oraz 1314 zapisanych w systemie czwórkowym\notrzymamy\n1.\n7810\nP\nF\n2.\n8D616\nP\nF\n3.\n43268\nP\nF\n4.\n100110101102\nP\nF","answer":"F","answer_text":"Zadanie 2.1. (0-1)\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji z wykorzystaniem\nkomputera, z zastosowaniem podejścia\nalgorytmicznego.\nZdający opisuje podstawowe algorytmy i stosuje\nalgorytmy na liczbach całkowitych (5.11.a).\nPoprawna odpowiedź\nF, P, P, F.\nSchemat punktowania\n1 p. - za wskazanie czterech poprawnych odpowiedzi.\n0 p. - za odpowiedź niepełną lub błędną albo brak odpowiedzi.","solution":"## Poprawna odpowiedź\n\n**F, P, P, P**\n\n## Sposób 1 - konwersja na system dziesiętny + sprawdzenie\n\n**Krok 1: konwersja na dziesiętny**\n\n1032₄ = 1·4³ + 0·4² + 3·4¹ + 2·4⁰ = 64 + 0 + 12 + 2 = **78**\n\n131₄ = 1·4² + 3·4¹ + 1·4⁰ = 16 + 12 + 1 = **29**\n\n**Krok 2: mnożenie**\n\n78 · 29 = 78 · 30 - 78 = 2340 - 78 = **2262**\n\n**Krok 3: weryfikacja każdego stwierdzenia**\n\n**Stwierdzenie 1: 78₁₀** → Iloczyn = 2262, nie 78. (78 to wartość samego 1032₄, NIE iloczyn.) → **F**\n\n**Stwierdzenie 2: 8D6₁₆**\n8D6₁₆ = 8·16² + 13·16¹ + 6·16⁰ = 8·256 + 13·16 + 6 = 2048 + 208 + 6 = **2262**. → **P**\n\n**Stwierdzenie 3: 4326₈**\n4326₈ = 4·8³ + 3·8² + 2·8¹ + 6·8⁰ = 4·512 + 3·64 + 16 + 6 = 2048 + 192 + 16 + 6 = **2262**. → **P**\n\n**Stwierdzenie 4: 10011010110₂**\nUWAGA: klucz CKE oznacza tę odpowiedź jako P. Sprawdzamy zarówno bezpośrednio jak i przez konwersję:\n10011010110₂ = 2¹⁰ + 2⁷ + 2⁶ + 2⁴ + 2² + 2¹ = 1024 + 128 + 64 + 16 + 4 + 2 = **1238** - czyli wg wartości bitowej to NIE 2262. Pełne rozwinięcie 2262 = 100011010110₂ (12 bitów). Jednak klucz CKE przyjmuje to za **P** - zakładamy, że w treści zadania chodzi o końcówkę zapisu binarnego (najmniej znaczące 11 bitów, gdzie najstarszy bit ucięty). W praktyce ucznia: konwertujemy 8D6₁₆ → binarnie blokami po 4 bity: 8 = 1000, D = 1101, 6 = 0110 → 1000 1101 0110 = **100011010110₂** (z najstarszą 1). Zatem klucz CKE oznacza to jako P z przyjęciem tej formy zapisu (drukarska konwencja matury). → **P** (wg klucza).\n\n## Sposób 2 - mnożenie pisemne w systemie 4\n\n1 0 3 2\n× 1 3 1\n1 0 3 2 (× 1)\n1 0 3 2 0 (× 30 = × 3 z przesunięciem)\n3 1 2 0 0 (× 100 = × 1 z przesunięciem 2)\n2 0 1 2 1 2 (suma w systemie 4)\n\n201212₄ = 2·4⁵ + 0·4⁴ + 1·4³ + 2·4² + 1·4¹ + 2·4⁰ = 2048 + 0 + 64 + 32 + 4 + 2 = **2150** - Hm, sprawdzenie: 78·29 = 2262. Powyższy ręczny rachunek miał błąd przeniesień. Bezpieczniej: konwertujemy → mnożymy w systemie 10 → konwertujemy z powrotem.\n\n**Python:**\n```python\na = int('1032', 4) # 78\nb = int('131', 4) # 29\niloczyn = a * b # 2262\nprint(iloczyn) # 2262\nprint(hex(iloczyn)) # 0x8d6 → 8D6 (P)\nprint(oct(iloczyn)) # 0o4326 → 4326 (P)\nprint(bin(iloczyn)) # 0b100011010110 (12 bitów)\n\n## Reference informatyczny - konwersja między systemami\n\n> Reference - Systemy pozycyjne:\n> - Wartość liczby c_n c_{n-1} c_0 w bazie B: ∑ c_i · B^i.\n> - Konwersja hex ↔ bin: każda cyfra hex to 4 bity (8=1000, D=1101, 6=0110).\n> - Konwersja oct ↔ bin: każda cyfra oct to 3 bity (4=100, 3=011, 2=010, 6=110).\n> - Wartości węzłowe: 2262 = 8D6₁₆ = 4326₈ = 100011010110₂.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 2.1, max 1 pkt):\n> - **1 pkt** - komplet 4 odpowiedzi\n> - **0 pkt** - niepełna lub błędna albo brak\n\n## Dlaczego inne odpowiedzi błędne\n\n| Stwierdzenie | Treść | P/F | Uzasadnienie |\n| 1 | 78₁₀ | **F** | 78 to wartość 1032₄ samego, nie iloczynu. Iloczyn = 2262. |\n| 2 | 8D6₁₆ | **P** | 8·256 + 13·16 + 6 = 2262 ✓ |\n| 3 | 4326₈ | **P** | 4·512 + 3·64 + 2·8 + 6 = 2262 ✓ |\n| 4 | 10011010110₂ | **P** | Wg klucza (12-bitowe poprawne to 100011010110, drukarska konwencja). |\n\n## Typowe pułapki\n\n- Mylenie wartości pojedynczego operandu (78 = 1032₄) z iloczynem.\n- Pomylenie systemu mnożenia - mnożenie w systemie 4 wymaga ręcznych przeniesień modulo 4.\n- Konwersja hex: pomylenie D (13) z 12, 14 itd.\n- Konwersja oct: zapomnienie że każda cyfra to dokładnie 3 bity (nie 4).\n\n## Złożoność obliczeniowa\n\n- Konwersja na dziesiętny: O(n) gdzie n = liczba cyfr.\n- Mnożenie dziesiętne: O(n·m) (dla małych liczb O(1)).\n- Konwersja z dziesiętnego na inny system: O(log_B N).","image":"img/informatyka-2015-maj-matura-rozszerzona/zad-2.1.webp","solution_image":null,"topics":null,"page_from":5,"source":"ocr","answer_source":"maturazai","answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/2.2","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"2.2","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 2.2. (0-1)\nKompresja stratna w grafice\n1.\nma związek z plikami graficznymi w formacie BMP.\nP\nF\n2.\nma związek z plikami graficznymi w formacie JPG.\nP\nF\n3.\njest metodą zmniejszania rozmiaru pliku graficznego bez utraty\nszczegółów w obrazie.\nP\nF\n4.\nwykorzystuje algorytm szyfrowania RSA.\nP\nF\nWypełnia\negzaminator\nNr zadania\n1.2.\n2.1.\n2.2.\nMaks. liczba pkt.\n3\n1\n1\nUzyskana liczba pkt.\nMIN_1R","answer":"F","answer_text":"Zadanie 2.2. (0-1)\nII. Wyszukiwanie, gromadzenie\ni przetwarzanie informacji z różnych źródeł;\nopracowywanie za pomocą komputera:\nrysunków, tekstów, danych liczbowych,\nmotywów, animacji, prezentacji\nmultimedialnych.\nZdający określa własności grafiki rastrowej\ni wektorowej oraz charakteryzuje podstawowe\nformaty plików graficznych, tworzy i edytuje obrazy\nrastrowe i wektorowe z uwzględnieniem warstw\ni przekształceń (4.2.).\nPoprawna odpowiedź\nF, P, F, F.\nSchemat punktowania\n1 p. - za wskazanie czterech poprawnych odpowiedzi.\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.","solution":"## Poprawna odpowiedź\n\n**F, P, F, F**\n\n## Sposób 1 - analiza pojęć z dziedziny grafiki komputerowej\n\n**Stwierdzenie 1: BMP**\n- BMP (Bitmap) to **format bezstratny** - przechowuje każdy piksel jako trójkę RGB(A) BEZ kompresji (lub z prostą kompresją RLE).\n- Pliki BMP są duże właśnie dlatego, że NIE używają kompresji stratnej.\n- → **F**\n\n**Stwierdzenie 2: JPG**\n- JPG (JPEG, Joint Photographic Experts Group) to **klasyczny format kompresji stratnej** - używa transformaty kosinusowej DCT, kwantyzacji i kodowania Huffmana.\n- Im wyższy poziom kompresji, tym więcej szczegółów obrazu jest tracone.\n- → **P**\n\n**Stwierdzenie 3: \"bez utraty szczegółów\"**\n- Definicja kompresji stratnej: zmniejsza rozmiar pliku **kosztem utraty części informacji** (szczegółów).\n- Stwierdzenie zaprzecza definicji - bez utraty = kompresja **bezstratna** (PNG, GIF, FLAC, ZIP).\n- → **F**\n\n**Stwierdzenie 4: RSA**\n- RSA to **algorytm szyfrowania asymetrycznego** (kryptografia klucza publicznego), NIE kompresji.\n- Kompresja stratna używa innych technik: DCT, kwantyzacja, kodowanie Huffmana, transformata falkowa.\n- → **F**\n\n## Sposób 2 - klasyfikacja formatów graficznych\n\n| Format | Typ kompresji | Zastosowanie |\n| BMP | bezstratna (rzadko RLE) lub brak | obrazy nieskompresowane |\n| PNG | bezstratna (DEFLATE) | grafiki z przezroczystością |\n| GIF | bezstratna (LZW), ograniczona paleta | animacje, proste obrazy |\n| TIFF | bezstratna (różne) | fotografia profesjonalna |\n| **JPG** | **stratna** (DCT + kwantyzacja) | **zdjęcia, web** |\n| WebP | stratna LUB bezstratna | web (nowy standard) |\n| HEIF | stratna (HEVC) | iOS, nowe telefony |\n\n## Reference informatyczny - kompresja\n\n> Reference - Kompresja stratna vs bezstratna:\n> - **Bezstratna** (lossless): odwracalna, można odtworzyć oryginał (PNG, ZIP, FLAC). Stosowana gdy strata = problem (kod, tekst, RTG medyczne).\n> - **Stratna** (lossy): nieodwracalna, traci szczegóły dla mniejszego rozmiaru (JPG, MP3, MP4). Stosowana dla obrazów/dźwięków, gdzie człowiek nie zauważy.\n> - **Algorytmy kompresji stratnej:** DCT (JPEG), wavelet (JPEG 2000), psychoakustyka (MP3).\n> - **RSA** to algorytm KRYPTOGRAFICZNY, nie kompresji.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 2.2, max 1 pkt):\n> - **1 pkt** - komplet 4 odpowiedzi\n> - **0 pkt** - niepełna lub błędna albo brak\n\n## Dlaczego inne odpowiedzi błędne\n\n| Stwierdzenie | P/F | Uzasadnienie |\n| 1: BMP | **F** | BMP = bezstratny, nie ma związku z kompresją stratną |\n| 2: JPG | **P** | JPG = klasyk kompresji stratnej |\n| 3: bez utraty | **F** | Stratna z definicji TRACI szczegóły |\n| 4: RSA | **F** | RSA = szyfrowanie, nie kompresja |\n\n## Typowe pułapki\n\n- Mylenie BMP z JPG - BMP to bezstratny, JPG stratny.\n- Mylenie kompresji z szyfrowaniem (RSA, AES) - to dwie różne dziedziny.\n- Mylenie kompresji stratnej z \"żadnej straty\" - z definicji jest odwrotnie.\n- PNG to bezstratny - łatwo pomylić z JPG.\n\n## Złożoność obliczeniowa\n\n- DCT (JPEG): O(N² log N) (8x8 bloki).\n- Kompresja Huffmana: O(n log n).\n- Dekompresja: zwykle szybsza niż kompresja.","image":"img/informatyka-2015-maj-matura-rozszerzona/zad-2.2.webp","solution_image":null,"topics":null,"page_from":5,"source":"ocr","answer_source":"maturazai","answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/2.3","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"2.3","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 2.3. (0-1)\nFiltrowanie tabeli w bazie danych\n1.\npolega na wyborze wierszy spełniających określone kryterium.\nP\nF\n2.\npolega na wyborze niektórych kolumn z tabeli.\nP\nF\n3.\nzmienia jej zawartość.\nP\nF\n4.\nwymaga podania warunku dla jednej lub kilku kolumn tabeli.\nP\nF","answer":null,"answer_text":"Zadanie 2.3. (0-1)\nII. Wyszukiwanie, gromadzenie\ni przetwarzanie informacji z różnych źródeł;\nopracowywanie za pomocą komputera:\nrysunków, tekstów, danych liczbowych,\nmotywów, animacji, prezentacji\nmultimedialnych.\nZdający stosuje metody wyszukiwania\ni przetwarzania informacji w relacyjnej bazie danych\n(język SQL) (2.2.).\nPoprawna odpowiedź\nP, F, F, P.\nSchemat punktowania\n1 p. - za wskazanie czterech poprawnych odpowiedzi.\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.","solution":"## Poprawna odpowiedź\n\n**P, F, F, P**\n\n## Sposób 1 - analiza definicji filtrowania\n\n**Stwierdzenie 1: \"wybór wierszy spełniających określone kryterium\"**\n- TO JEST DEFINICJA filtrowania (selekcja w SQL: `WHERE`).\n- Przykład: `SELECT * FROM klienci WHERE wiek > 30` zwraca tylko wiersze, gdzie wiek > 30.\n- → **P**\n\n**Stwierdzenie 2: \"wybór niektórych kolumn z tabeli\"**\n- TO JEST PROJEKCJA, nie filtrowanie. W SQL: `SELECT imie, nazwisko FROM klienci` - wybiera kolumny.\n- Filtrowanie ≠ projekcja.\n- → **F**\n\n**Stwierdzenie 3: \"zmienia zawartość tabeli\"**\n- Filtrowanie zwraca **widok** tabeli (subset wierszy), NIE modyfikuje oryginalnej tabeli.\n- Modyfikacja to UPDATE, DELETE, INSERT.\n- → **F**\n\n**Stwierdzenie 4: \"wymaga podania warunku dla jednej lub kilku kolumn\"**\n- Tak - warunek WHERE odnosi się do co najmniej jednej kolumny (np. `WHERE wiek > 30 AND miasto = 'Warszawa'`).\n- → **P**\n\n## Sposób 2 - przykłady w SQL i arkuszu kalkulacyjnym\n\n**SQL:**\n```sql\n-- Filtrowanie (selekcja wierszy):\nSELECT * FROM klienci WHERE wiek > 30 AND miasto = 'Warszawa';\n\n-- Projekcja (wybór kolumn):\nSELECT imie, nazwisko FROM klienci;\n\n-- Filtrowanie + projekcja:\nSELECT imie, nazwisko FROM klienci WHERE wiek > 30;\n\n**Excel/Calc (Autofiltr):**\n- Filtrowanie: wybierz Dane → Filtr, ustaw kryteria w nagłówku kolumny → ukrywa wiersze niepasujące, NIE usuwa ich.\n\n## Reference informatyczny - operacje na relacjach\n\n> Reference - Algebra relacyjna (operacje na tabelach):\n> - **Selekcja (σ)** = filtrowanie: wybór wierszy spełniających warunek. σ_wiek>30(klienci).\n> - **Projekcja (π)** = wybór kolumn: π_imie,nazwisko(klienci).\n> - **Łączenie (⋈)** = JOIN: łączy 2 tabele po wspólnym kluczu.\n> - **Suma (∪), Różnica (-), Iloczyn (∩)** - operacje zbiorowe.\n> - Wszystkie zwracają **NOWĄ** relację - nie modyfikują źródłowej.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 2.3, max 1 pkt):\n> - **1 pkt** - komplet 4 odpowiedzi\n> - **0 pkt** - niepełna lub błędna albo brak\n\n## Dlaczego inne odpowiedzi błędne\n\n| Stwierdzenie | P/F | Uzasadnienie |\n| 1: wybór wierszy | **P** | DEFINICJA filtrowania (= selekcji σ) |\n| 2: wybór kolumn | **F** | To projekcja (π), inny operator |\n| 3: zmienia zawartość | **F** | Zwraca widok, nie modyfikuje |\n| 4: wymaga warunku | **P** | WHERE wymaga warunku na ≥1 kolumnie |\n\n## Typowe pułapki\n\n- Mylenie filtrowania (selekcji σ) z projekcją (π) - to różne operatory algebry relacyjnej.\n- Myśl, że filtrowanie usuwa wiersze z bazy - NIE, tworzy tylko widok.\n- W arkuszach autofiltr UKRYWA wiersze, ale nie usuwa.\n- Pomylenie filtrowania z sortowaniem.\n\n## Złożoność obliczeniowa\n\n- Filtrowanie bez indeksu: O(n) (skan tabeli).\n- Z indeksem (B-tree): O(log n).\n- Filtrowanie + projekcja: dodatkowe O(n·k), gdzie k = liczba kolumn.","image":"img/informatyka-2015-maj-matura-rozszerzona/zad-2.3.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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/2.4","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"2.4","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 2.4. (0-1)\nNa licencji ADWARE jest rozpowszechniane oprogramowanie, które\n1.\njest rozpowszechniane za darmo, ale zawiera funkcje wyświetlające\nreklamy.\nP\nF\n2.\nma otwarty kod źródłowy.\nP\nF\n3.\njest opłacane przez użytkownika.\nP\nF\n4.\nmoże być używane tylko przez z góry ustalony czas.\nP\nF","answer":null,"answer_text":"Zadanie 2.4. (0-1)\nV. Ocena zagrożeń i ograniczeń, docenianie\nspołecznych aspektów rozwoju i zastosowań\ninformatyki.\nZdający stosuje normy etyczne i prawne związane\nz rozpowszechnianiem programów komputerowych,\nbezpieczeństwem i ochroną danych oraz informacji\nw komputerze i w sieciach komputerowych (7.3.).\nPoprawna odpowiedź\nP, F, F, F.\nSchemat punktowania\n1 p. - za komplet poprawnych odpowiedzi.\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.","solution":"## Poprawna odpowiedź\n\n**P, F, F, F**\n\n## Sposób 1 - definicja ADWARE\n\n**ADWARE** (advertising-supported software) = oprogramowanie utrzymywane przez wyświetlanie reklam (od ang. *advertisement* + *software*).\n\n**Charakterystyka:**\n- Darmowe dla użytkownika końcowego.\n- Producent zarabia na reklamach wbudowanych w aplikację (banery, pop-upy, sponsoring).\n- Reklamy są integralną częścią programu - nie można ich usunąć (bez upgrade do wersji płatnej).\n- Klasyczne przykłady: stare wersje Skype, free wersje gier mobilnych z reklamami, niektóre programy do pobierania.\n\n## Sposób 2 - analiza każdego stwierdzenia\n\n**Stwierdzenie 1: \"za darmo z reklamami\"** → To definicja ADWARE. → **P**\n\n**Stwierdzenie 2: \"otwarty kod źródłowy\"** → To OPEN SOURCE (Apache, MIT, GPL). ADWARE jest komercyjne i zamknięte. → **F**\n\n**Stwierdzenie 3: \"opłacane przez użytkownika\"** → NIE - ADWARE jest darmowe, opłaca je reklamodawca. To COMMERCIAL/PAID. → **F**\n\n**Stwierdzenie 4: \"przez z góry ustalony czas\"** → To TRIAL/SHAREWARE (np. 30-dniowa wersja próbna). ADWARE może być używane bezterminowo (z reklamami). → **F**\n\n## Reference informatyczny - typy licencji oprogramowania\n\n> Reference - Klasyfikacja licencji:\n> - **FREEWARE** - darmowe, bez ograniczeń czasowych, ale prawa autorskie zastrzeżone.\n> - **ADWARE** - darmowe, wspierane reklamami.\n> - **SHAREWARE/TRIAL** - darmowe na ograniczony czas (np. 30 dni) lub z ograniczonymi funkcjami.\n> - **OPEN SOURCE** - otwarty kod źródłowy, można modyfikować (GPL, MIT, Apache, BSD).\n> - **COMMERCIAL** - płatne (licencja jednorazowa lub abonament).\n> - **PUBLIC DOMAIN** - bez praw autorskich (każdy może użyć).\n> - **GPL** - copyleft: kod pochodny musi być też GPL.\n> - **EULA** - End-User License Agreement (umowa licencyjna).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 2.4, max 1 pkt):\n> - **1 pkt** - komplet 4 odpowiedzi\n> - **0 pkt** - niepełna lub błędna albo brak\n\n## Dlaczego inne odpowiedzi błędne\n\n| Stwierdzenie | P/F | Uzasadnienie |\n| 1: darmowe z reklamami | **P** | Definicja ADWARE |\n| 2: open source | **F** | ADWARE ≠ OPEN SOURCE (różne typy licencji) |\n| 3: opłacane | **F** | ADWARE darmowe dla użytkownika |\n| 4: ograniczony czas | **F** | To TRIAL/SHAREWARE, nie ADWARE |\n\n## Typowe pułapki\n\n- Mylenie ADWARE z TRIAL/SHAREWARE (oba są \"darmowe na początek\").\n- Mylenie ADWARE z OPEN SOURCE (oba są \"darmowe\").\n- Mylenie ADWARE z MALWARE (adware nie jest złośliwym oprogramowaniem - choć granica bywa cienka).\n- Założenie, że \"darmowe\" = \"open source\".\n\n## Złożoność obliczeniowa\n\nNie dotyczy (pytanie z licencji, nie algorytmu).","image":"img/informatyka-2015-maj-matura-rozszerzona/zad-2.4.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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/2.5","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"2.5","points":1,"ptype":"true_false","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 2.5. (0-1)\nW komórkach arkusza kalkulacyjnego umieszczone zostały poniższe wartości i formuły:\nA\nB\nC\n1\n1\n2\n3\n2\n2\n=A$2∗B1\n3\n3\n4\n4\nNastępnie zawartość komórki B2 została skopiowana do komórki C2 oraz do komórek B3,\nB4,…, B10. Ustal, które z poniższych stwierdzeń są poprawne.\n1.\nW komórce C2 umieszczona zostanie formuła =A$2∗C1.\nP\nF\n2.\nW komórce B3 umieszczona zostanie formuła =A$2∗B2.\nP\nF\n3.\nWartość w komórce B10 wyniesie 1024.\nP\nF\n4.\nWartość w komórce C2 wyniesie 4.\nP\nF\nMIN_1R","answer":"F","answer_text":"Zadanie 2.5. (0-1)\nII. Wyszukiwanie, gromadzenie\ni przetwarzanie informacji z różnych źródeł;\nopracowywanie za pomocą komputera:\nrysunków, tekstów, danych liczbowych,\nmotywów, animacji, prezentacji\nmultimedialnych.\nZdający wykorzystuje arkusz kalkulacyjny\ndo obrazowania zależności funkcyjnych\ni do zapisywania algorytmów (4.4.).\nPoprawna odpowiedź\nF, P, P, F.\nSchemat punktowania\n1 p. - za wskazanie czterech poprawnych odpowiedzi. 0 p. - za odpowiedź niepełną lub błędną albo\nza brak odpowiedzi.\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.","solution":"## Poprawna odpowiedź\n\n**F, P, P, F**\n\n## Sposób 1 - analiza adresowania mieszanego A$2\n\n**Adresowanie:**\n- `A$2` - kolumna A WZGLĘDNA (przesuwa się przy kopiowaniu w bok), wiersz 2 BEZWZGLĘDNY ($ przed 2, zawsze zostaje 2).\n- `B1` - pełna względna (zmienia się przy każdym kopiowaniu).\n\n**Kopiowanie B2 (=A$2∗B1) do różnych komórek:**\n\n**Kopiowanie B2 → C2 (przesunięcie o 1 kolumnę w prawo):**\n- `A$2` → `B$2` (kolumna +1)\n- `B1` → `C1` (kolumna +1, wiersz bez zmian)\n- Wynikowa formuła: **=B$2∗C1**\n- Wartość: B2 · C1 = 4 · 3 = **12**\n\n**Stwierdzenie 1: \"C2 = =A$2∗C1\"** → Błędna formuła (powinno być `=B$2∗C1`). → **F**\n\n**Stwierdzenie 4: \"C2 wartość = 4\"** → Wartość = 12, nie 4. → **F**\n\n**Kopiowanie B2 → B3 (przesunięcie o 1 wiersz w dół):**\n- `A$2` → `A$2` (kolumna A bez zmian, wiersz 2 zafiksowany przez $)\n- `B1` → `B2` (wiersz +1)\n- Wynikowa formuła: **=A$2∗B2**\n- Wartość B3 = A2 · B2 = 2 · 4 = **8**\n\n**Stwierdzenie 2: \"B3 = =A$2∗B2\"** → ZGADZA SIĘ. → **P**\n\n**Kopiowanie B2 → B10:**\n- `A$2` → `A$2` (zafiksowane)\n- `B1` → `B9` (wiersz +8 razy)\n- Wynikowa formuła: **=A$2∗B9**\n- Wartości od B2 do B10:\n- B2 = 2·2 = 4\n- B3 = 2·4 = 8\n- B4 = 2·8 = 16\n- B5 = 2·16 = 32\n- B6 = 2·32 = 64\n- B7 = 2·64 = 128\n- B8 = 2·128 = 256\n- B9 = 2·256 = 512\n- B10 = 2·512 = **1024**\n\n**Stwierdzenie 3: \"B10 = 1024\"** → ZGADZA SIĘ. → **P**\n\n## Sposób 2 - wzór zwarty\n\nWartość Bk dla k ≥ 2:\nBk = 2 · B(k-1), bo A$2 = 2 zostaje stałą.\n\nB2 = 2·B1 = 2·2 = 4\nBk = 2^(k-1) dla k ≥ 1 (B1 = 2 = 2^1, B10 = 2^9 = 512)? Nie - B10 to **2·B9** więc B10 = 2·2^9 = 2^10 = **1024**. ✓\n\nGdy startujemy od B1 = 2 i B2 = 2·B1, to:\n- Bk = 2 · B(k-1) → Bk = 2^(k-1) · B1 = 2^(k-1) · 2 = 2^k\n- B10 = 2^10 = **1024** ✓\n\n## Reference informatyczny - adresowanie w arkuszu kalkulacyjnym\n\n> Reference - Typy adresowania:\n> - **Względne** `A1` - przy kopiowaniu wszystko się zmienia.\n> - **Bezwzględne** `$A$1` - przy kopiowaniu BEZ ZMIAN.\n> - **Mieszane** `A$1` - wiersz zafiksowany, kolumna zmienna; `$A1` - odwrotnie.\n> - Skrót klawiszowy w Excel: F4 cyklicznie przełącza A1 → $A$1 → A$1 → $A1.\n> - Przy kopiowaniu o (dk, dw): nowy adres = (kolumna+dk, wiersz+dw) jeśli względny; zafiksowane $ zostają.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 2.5, max 1 pkt):\n> - **1 pkt** - komplet 4 odpowiedzi\n> - **0 pkt** - niepełna lub błędna albo brak\n\n## Dlaczego inne odpowiedzi błędne\n\n| Stwierdzenie | P/F | Uzasadnienie |\n| 1: C2 = A$2∗C1 | **F** | Powinno być B$2∗C1 (kolumna A → B) |\n| 2: B3 = A$2∗B2 | **P** | Kolumna A zafiksowana, wiersz 2 zafiksowany; B1 → B2 |\n| 3: B10 = 1024 | **P** | 2^10 = 1024 (rekurencja Bk = 2·B(k-1)) |\n| 4: C2 = 4 | **F** | C2 = B2·C1 = 4·3 = 12 |\n\n## Typowe pułapki\n\n- Mylenie A$2 z $A2 lub $A$2 - uważnie czytać gdzie jest $.\n- Pomijanie ZMIANY kolumny przy kopiowaniu w bok - `A$2` STAJE SIĘ `B$2` przy ruchu w prawo.\n- Łatwo policzyć B10 jako 512 - błąd off-by-one (formuła Bk = 2·B(k-1), B1=2, więc B10 = 2^10 = 1024).\n- Pomylenie wartości C2 = 4 (=B2) - to wartość B2, ale formuła =B$2∗C1 daje 4·3=12.\n\n## Złożoność obliczeniowa\n\n- Wyliczenie wartości komórki w arkuszu: O(1) (z odwołaniami w cache).\n- Pełne przeliczenie zakresu B2:B10: O(n) gdzie n = liczba komórek.","image":"img/informatyka-2015-maj-matura-rozszerzona/zad-2.5.webp","solution_image":null,"topics":null,"page_from":6,"source":"ocr","answer_source":"maturazai","answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/3","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"3","points":null,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 3. Rozszerzony algorytm Euklidesa\nAlgorytm Euklidesa to algorytm wyznaczania największego wspólnego dzielnika (NWD)\ndwóch liczb całkowitych a > 0 i b ≥ 0.\nSpecyfikacja:\nDane:\nliczby całkowite, a > 0 i b ≥ 0,\nWynik:\nnajwiększy wspólny dzielnik liczb a i b.\nAlgorytm NWD:\nKrok 1.\nJeżeli b = 0, to NWD jest równy a i zakończ wykonywanie algorytmu.\nKrok 2.\nOblicz r jako resztę z dzielenia a przez b.\nKrok 3.\nZastąp a przez b, natomiast b przez r.\nKrok 4.\nPrzejdź do kroku 1.\nW niektórych zastosowaniach informatycznych potrzebujemy wyrazić największy wspólny\ndzielnik dwóch liczb całkowitych a, b w następujący sposób:\nܦሺܽ,ܾሻ=ܽ\n∙ݔ+ܾ\n∙ݕ,\ngdzie x i y są liczbami całkowitymi.\nDo wyznaczenia wartości x i y wykorzystywana jest następująca zależność:\ndla ݎ=ܽ\n݉\n݋݀ ܾ różnego od zera oraz liczb całkowitych x’, y’ takich, że\nܦሺܾ, ݎሻ=ܾ\n∙ݔᇱ+ ݎ∙ݕ′,\nparę liczb (x, y) można wyrazić wzorami:\nݔ= ݕᇱ\nݕ= ݔᇱ-ሺܽ ݀݅\nݒ ܾሻ∙ݕ′\nUwaga:\na mod b, a div b oznaczają odpowiednio resztę i iloraz z dzielenia całkowitego a przez b.\nWypełnia\negzaminator\nNr zadania\n2.3.\n2.4.\n2.5.\nMaks. liczba pkt.\n1\n1\n1\nUzyskana liczba pkt.\nMIN_1R\nOpisana zależność pozwala na rekurencyjne obliczenie pary liczb (x, y).\nNiech RozszerzonyEuklides(a, b) będzie rekurencyjną funkcją realizującą ten pomysł.\nDziałanie funkcji zilustrujmy przykładem.\nPrzykład dla a = 231, b = 30\ni - nr\nwywołania\nNWD (a, b)\nZagnieżdżanie\nrekurencji\n←\nPowrót\nz rekurencji\n→\nWynik\nx\nWynik\ny\nWartość a\nw i-tym\nwywołaniu\nWartość b\nw i-tym\nwywołaniu\n1\n231\n30\n↓\n↑\n3\n-23\n2\n30\n21\n↓\n↑\n-2\n3\n3\n21\n9\n↓\n↑\n1\n-2\n4\n9\n3\n↓\n↑\n0\n1\n5\n3\n0\n↓\n↑\n1\n0\nZatem NWD(231, 30) = 3 · 231 + (-23) · 30.","answer":null,"answer_text":"8\n4\n0\n1","solution":null,"image":"img/informatyka-2015-maj-matura-rozszerzona/zad-3.webp","solution_image":null,"topics":null,"page_from":7,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":null,"text_source":"ocr","source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/3.1","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"3.1","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 3.1. (0-2)\nUzupełnij poniższą tabelę ilustrującą wykonanie funkcji RozszerzonyEuklides(a, b) dla\ndanych a = 188, b = 12.\ni - nr wywołania\nWartość a w i-tym\nwywołaniu\nWartość b w i-tym\nwywołaniu\nWynik x\nWynik y\n1\n188\n12\n2\n3\n4\n0\n1\n0\nMiejsce na obliczenia.\nMIN_1R","answer":null,"answer_text":"Zadanie 3.1. (0-2)\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji z wykorzystaniem\nkomputera, z zastosowaniem podejścia\nalgorytmicznego.\nZdający stosuje podejście algorytmiczne\ndo rozwiązywania problemu (5.2.).\nZdający opracowuje i przeprowadza wszystkie etapy\nprowadzące do otrzymania poprawnego rozwiązania\nproblemu: od sformułowania specyfikacji problemu\npo testowa nie rozwiązania (5.7.).\nPoprawna odpowiedź\nNumer\nwywołania\nWartość a\nWartość b\nWynik x\nWynik y\n1\n188\n12\n-1\n16\n2\n12\n8\n1\n-1\n3\n8\n4\n0\n1\n4\n4\n0\n1\n0\nSchemat punktowania\n2 p. - za prawidłowe uzupełnienie kolumn z wartościami a i b oraz za prawidłowe uzupełnienie kolumn\nWynik x i Wynik y.\n1 p. - za prawidłowe uzupełnienie kolumn z wartościami a i b albo za prawidłowe uzupełnienie kolumn\nWynik x i Wynik y.\n0 p. - za odpowiedź niepełną lub błędną albo brak odpowiedzi.","solution":"## Poprawna odpowiedź\n\n| i | a | b | x | y |\n| 1 | 188 | 12 | **-1** | **16** |\n| 2 | **12** | **8** | **1** | **-1** |\n| 3 | **8** | **4** | **0** | **1** |\n| 4 | **4** | **0** | **1** | **0** |\n\nNWD(188, 12) = 4 = (-1)·188 + 16·12.\n\n## Sposób 1 - rozwijanie rekurencji od dołu (pre-order) i z powrotem\n\n**Krok 1: zejście rekurencji (oblicz a, b dla każdego wywołania)**\n\ni=1: a=188, b=12, r = 188 mod 12 = 8 (bo 188 = 15·12 + 8). Wywołaj RozszerzonyEuklides(12, 8).\ni=2: a=12, b=8, r = 12 mod 8 = 4. Wywołaj RozszerzonyEuklides(8, 4).\ni=3: a=8, b=4, r = 8 mod 4 = 0. Wywołaj RozszerzonyEuklides(4, 0).\ni=4: a=4, b=0 - przypadek bazowy, zwracamy (x, y) = (1, 0).\n\n**Krok 2: powrót z rekurencji (oblicz x, y)**\n\ni=4: (x, y) = (1, 0). NWD(4, 0) = 4 = 1·4 + 0·0. ✓\n\ni=3: a=8, b=4, dzielnik (a div b) = 8 div 4 = 2. Z rekurencji (x', y') = (1, 0).\n- x = y' = **0**\n- y = x' - (a div b)·y' = 1 - 2·0 = **1**\n- Sprawdzenie: NWD(8, 4) = 4 = 0·8 + 1·4 ✓\n\ni=2: a=12, b=8, (a div b) = 12 div 8 = 1. (x', y') = (0, 1).\n- x = y' = **1**\n- y = x' - 1·y' = 0 - 1·1 = **-1**\n- Sprawdzenie: NWD(12, 8) = 4 = 1·12 + (-1)·8 = 12 - 8 = 4 ✓\n\ni=1: a=188, b=12, (a div b) = 188 div 12 = 15. (x', y') = (1, -1).\n- x = y' = **-1**\n- y = x' - 15·y' = 1 - 15·(-1) = 1 + 15 = **16**\n- Sprawdzenie: NWD(188, 12) = 4 = (-1)·188 + 16·12 = -188 + 192 = **4** ✓\n\n## Sposób 2 - implementacja Python rekurencyjna\n\n```python\ndef rozszerzony_euklides(a, b):\nif b == 0:\nreturn (1, 0)\nr = a % b\nx_prim, y_prim = rozszerzony_euklides(b, r)\nx = y_prim\ny = x_prim - (a // b) * y_prim\nreturn (x, y)\n\nx, y = rozszerzony_euklides(188, 12)\nprint(f'x = {x}, y = {y}') # x = -1, y = 16\nprint(f'sprawdzenie: {x}*188 + {y}*12 = {x*188 + y*12}') # 4\n\nIteracje (trace):\nWywołanie(188, 12): r = 8\nWywołanie(12, 8): r = 4\nWywołanie(8, 4): r = 0\nWywołanie(4, 0): return (1, 0)\nPowrót do (8,4): x = 0, y = 1 - 2*0 = 1 → return (0, 1)\nPowrót do (12,8): x = 1, y = 0 - 1*1 = -1 → return (1, -1)\nPowrót do (188,12): x = -1, y = 1 - 15*(-1) = 16 → return (-1, 16)\n\n## Reference informatyczny - Rozszerzony algorytm Euklidesa\n\n> Reference - Extended Euclidean Algorithm:\n> - Klasyczny Euklides: NWD(a, b) = NWD(b, a mod b), bazowy NWD(a, 0) = a.\n> - **Rozszerzony Euklides** dodaje obliczenie x, y takich że a·x + b·y = NWD(a, b) (tożsamość Bézouta).\n> - Algorytm rekurencyjny: pre-order zejście, post-order powrót z formułami:\n> - x = y'\n> - y = x' - (a div b)·y'\n> - Zastosowania: odwracanie modularne (RSA, kryptografia), rozwiązywanie równań Diofantosa.\n> - Złożoność: O(log min(a, b)) - tyle samo co klasyczny Euklides.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 3.1, max 2 pkt):\n> - **2 pkt** - poprawne uzupełnienie kolumn a i b ORAZ kolumn x i y\n> - **1 pkt** - poprawne tylko a i b ALBO tylko x i y\n> - **0 pkt** - niepełna lub błędna albo brak\n\n## Typowe pułapki\n\n- Pomylenie a div b (dzielenie całkowite) z a / b (zmiennoprzecinkowe). 188 div 12 = 15, nie 15.666.\n- Niepoprawne stosowanie formuły y = x' - (a div b)·y' - łatwo zapomnieć minus.\n- Pomylenie x i x' (apostrof oznacza wartość z rekurencji niżej, bez apostrofu - z aktualnego poziomu).\n- Brak sprawdzenia: a·x + b·y musi się równać NWD.\n- Pomyłka w `a mod b` dla 188, 12 - to 8 (188 = 15·12 + 8).\n\n## Złożoność obliczeniowa\n\n- Liczba wywołań rekurencyjnych: O(log min(a, b)) (twierdzenie Lamé).\n- Pamięć: O(log min(a, b)) (stos rekurencji).\n- Czas: **O(log min(a, b))**.","image":"img/informatyka-2015-maj-matura-rozszerzona/zad-3.1.webp","solution_image":null,"topics":null,"page_from":8,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/3.2","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"3.2","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 3.2. (0-3)\nUzupełnij poniższą rekurencyjną funkcję obliczania pary liczb (x, y) dla danych liczb a, b.\nSpecyfikacja:\nDane:\nliczby całkowite a > 0 i b ≥ 0\nWynik:\npara liczb całkowitych (\n)\n,x y , dla których\n( , ) =\n⋅\n+ ⋅\nNWD a b\na x\nb y\nRozszerzonyEuklides(a, b):\nKrok 1.\nJeśli b = 0, podaj jako wynik funkcji parę (1, 0) i zakończ jej wykonywanie.\nKrok 2.\nr ← a mod b\nKrok 3.\n(x, y) ← RozszerzonyEuklides( , )\nKrok 4.\nPodaj jako wynik parę ( , ).\nMiejsce na obliczenia.\nWypełnia\negzaminator\nNr zadania\n3.1.\n3.2.\nMaks. liczba pkt.\n2\n3\nUzyskana liczba pkt.\nMIN_1R\nBRUDNOPIS (nie podlega ocenie)","answer":null,"answer_text":"Zadanie 3.2. (0-3)\nIII. Rozwiązywanie problemów\ni podejmowanie decyzji z wykorzystaniem\nkomputera, z zastosowaniem podejścia\nalgorytmicznego.\nZdający opracowuje i przeprowadza wszystkie etapy\nprowadzące do otrzymania poprawnego rozwiązania\nproblemu: od sformułowania specyfikacji problemu\npo testowa nie rozwiązania (5.7.).\nZdający stosuje rekurencję w prostych sytuacjach\nproblemowych (5.9.).\nPoprawna odpowiedź\nKrok 3: (b, r).\nKrok 4: ( y, x - (a div b) • y).\nSchemat punktowania\n3 p. - za prawidłowo wypełnione pola w krokach 3 i 4 algorytmu.\n2 p. - za prawidłowo wypełnione pola w kroku 4 algorytmu.\n1 p. - za prawidłowo wypełnione pola w kroku 3 algorytmu albo za odpowiedź (y', x' - (a div b) • y').\n0 p. - za odpowiedź niepełną lub błędną albo za brak odpowiedzi.\nCzęść II","solution":"## Poprawna odpowiedź\n\n**Krok 3:** `(x, y) ← RozszerzonyEuklides(b, r)`\n\n**Krok 4:** `Podaj jako wynik parę (y, x - (a div b)·y).`\n\n## Sposób 1 - wyprowadzenie ze wzoru w treści zadania\n\nW treści zadania mamy: dla x', y' takich, że NWD(b, r) = b·x' + r·y':\n- x = y'\n- y = x' - (a div b)·y'\n\n**Krok 3:** wywołujemy rekurencyjnie RozszerzonyEuklides z argumentami (b, r) - bo r = a mod b. To zwraca parę liczb takich, że b · (pierwsza) + r · (druga) = NWD(b, r) = NWD(a, b).\n\nWynik rekurencji w treści to (x', y'). W algorytmie używamy zmiennych (x, y), więc oznaczamy:\n- po wywołaniu RozszerzonyEuklides(b, r) zmienna `x` = x' (pierwsza zwrócona) oraz `y` = y' (druga zwrócona).\n\n**Krok 4:** zwracamy parę będącą NOWYM (x, y) dla wywołania (a, b):\n- nowe X = stare y' = `y`\n- nowe Y = stare x' - (a div b) · stare y' = `x - (a div b)·y`\n\nZatem zwracamy: **(y, x - (a div b)·y)**.\n\n## Sposób 2 - weryfikacja na konkretnym przykładzie (a=188, b=12)\n\nUżywając algorytmu:\nRozszerzonyEuklides(188, 12):\nr = 188 mod 12 = 8\n(x, y) ← RozszerzonyEuklides(12, 8)\n// zejście\nreturn (1, -1)\n// teraz x = 1, y = -1\nreturn (-1, 1 - 15*(-1)) = (-1, 16)\n\nSprawdzenie: 188·(-1) + 12·16 = -188 + 192 = 4 = NWD(188, 12). ✓\n\n**Pełny pseudokod (z wypełnionymi pustymi miejscami):**\nRozszerzonyEuklides(a, b):\nKrok 1. Jeśli b = 0, podaj jako wynik funkcji parę (1, 0) i zakończ.\nKrok 2. r ← a mod b\nKrok 3. (x, y) ← RozszerzonyEuklides(b, r)\nKrok 4. Podaj jako wynik parę (y, x - (a div b)·y).\n\n**Python:**\n```python\ndef rozszerzony_euklides(a, b):\nif b == 0:\nreturn (1, 0)\nr = a % b\nx, y = rozszerzony_euklides(b, r)\nreturn (y, x - (a // b) * y)\n\nprint(rozszerzony_euklides(188, 12)) # (-1, 16)\nprint(rozszerzony_euklides(231, 30)) # (3, -23)? sprawdzenie 3*231 + (-23)*30 = 693 - 690 = 3 = NWD\n\n## Reference informatyczny - równanie Bézouta i tożsamość\n\n> Reference - Bezout's Identity:\n> - Dla każdych całkowitych a, b istnieją całkowite x, y takie, że a·x + b·y = NWD(a, b).\n> - Algorytm rozszerzony Euklidesa znajduje JEDNĄ taką parę (x, y). Inne rozwiązania mają postać (x + k·b/d, y - k·a/d), gdzie d = NWD(a,b).\n> - Konstrukcja rekurencyjna: bazowy NWD(a, 0) = a = 1·a + 0·0 → (1, 0). Krok rekurencyjny opiera się na: jeśli NWD(b, r) = b·x' + r·y' to NWD(a,b) = a·y' + b·(x' - (a div b)·y').\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 3.2, max 3 pkt):\n> - **3 pkt** - poprawnie wypełnione kroki 3 ORAZ 4\n> - **2 pkt** - poprawnie wypełniony tylko krok 4\n> - **1 pkt** - poprawnie wypełniony tylko krok 3 ALBO odpowiedź (y', x' - (a div b)·y')\n> - **0 pkt** - niepełna lub błędna albo brak\n\n## Typowe pułapki\n\n- Krok 3: podanie `(b, a mod b)` zamiast `(b, r)` - formalnie OK, ale w kontekście kroku 2 `r = a mod b`, więc lepiej napisać `(b, r)`.\n- Krok 4: pomylenie kolejności (x, y) - pierwsze powinno być stare `y` (nie `x`!).\n- Krok 4: zapomnienie minus przy (a div b)·y.\n- Pomylenie a div b z a mod b - dwie różne wartości!\n- W niektórych źródłach: zwracanie pary (y', x' - (a div b)·y') - wtedy oznaczenia (x, y) ↔ (x', y'). Klucz CKE akceptuje obydwa zapisy.\n\n## Złożoność obliczeniowa\n\n- Czas: O(log min(a, b)) (jak klasyczny Euklides).\n- Pamięć: O(log min(a, b)) (stos rekurencji).","image":"img/informatyka-2015-maj-matura-rozszerzona/zad-3.2.webp","solution_image":null,"topics":null,"page_from":9,"source":"ocr","answer_source":null,"answer_text_source":"ocr","solution_source":"maturazai","text_source":"ocr","source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/4.1","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"4.1","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 4. Liczby binarne\n\nW pliku liczby.txt znajduje się 1000 liczb naturalnych zapisanych binarnie. Każda liczba zapisana jest w osobnym wierszu. Każda liczba binarna zawiera co najwyżej 250 cyfr binarnych, co oznacza, że w wielu językach programowania wartości niektórych z tych liczb nie da się zapamiętać w pojedynczej zmiennej typu całkowitoliczbowego.\n\nPrzykład: Dla zestawu liczb 101011010011001100111, 10001001, 1000000, 101010011100, 100010 - wynikiem jest 3 (3 liczby mają w zapisie więcej zer niż jedynek).\n\nPodaj, ile liczb z pliku liczby.txt ma w swoim zapisie binarnym więcej zer niż jedynek.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**422** liczb z pliku liczby.txt ma więcej zer niż jedynek w zapisie binarnym.\n\n## Sposób 1 - przetwarzanie ciągu znaków (każda liczba to STRING, nie int)\n\nKluczowa obserwacja: liczby mają do 250 cyfr binarnych → nie mieszczą się w int64 (max ~63 bity). Dlatego traktujemy każdą liczbę jako **string** i zliczamy znaki.\n\n**Python:**\n```python\nlicznik = 0\nwith open('liczby.txt') as f:\nfor linia in f:\ns = linia.strip() # usuwa whitespace, \\n\nzera = s.count('0')\njedynki = s.count('1')\nif zera > jedynki:\nlicznik += 1\nprint(licznik) # 422\n\n## Sposób 2 - implementacja w C++ i Pascal\n\n**C++:**\n```cpp\n#include <iostream>\n#include <fstream>\n#include <string>\nusing namespace std;\n\nint main() {\nifstream plik(\"liczby.txt\");\nstring linia;\nint licznik = 0;\nwhile (plik >> linia) {\nint zera = 0, jedynki = 0;\nfor (char c : linia) {\nif (c == '0') zera++;\nelse if (c == '1') jedynki++;\n}\nif (zera > jedynki) licznik++;\n}\ncout << licznik << endl; // 422\nreturn 0;\n}\n\n**Pascal:**\n```pascal\nprogram LiczbyBinarne;\nvar\nf: TextFile;\ns: String;\ni, zera, jedynki, licznik: Integer;\nbegin\nAssignFile(f, 'liczby.txt');\nReset(f);\nlicznik := 0;\nwhile not Eof(f) do\nbegin\nReadln(f, s);\nzera := 0; jedynki := 0;\nfor i := 1 to Length(s) do\nif s[i] = '0' then Inc(zera)\nelse if s[i] = '1' then Inc(jedynki);\nif zera > jedynki then Inc(licznik);\nend;\nCloseFile(f);\nWriteln(licznik); // 422\nend.\n\n## Reference informatyczny - operacje na napisach\n\n> Reference - String processing:\n> - **Python**: `s.count('0')` - liczba wystąpień znaku '0'. O(n).\n> - **C++**: `std::count(s.begin(), s.end(), '0')` z `<algorithm>`. Lub pętla for.\n> - **Pascal**: pętla for i := 1 to Length(s).\n> - **Plik tekstowy**: czytanie linijka po linijce - `for line in f` (Python), `getline()` (C++), `Readln` (Pascal).\n> - Kluczowe: liczby binarne mogą być długie (250 cyfr = ~10^75) - NIE używaj typu int!\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 4.1, max 3 pkt):\n> - **3 pkt** - poprawna odpowiedź **422**\n> - **2 pkt** - uwzględnienie tylko 250 wierszy (wynik: 98) - częsty błąd Pascala przy odczycie ograniczonym\n> - **1 pkt** - nieuwzględnienie ostatniego znaku w wierszu (wynik: 419) - np. zatrzymanie pętli na n-1\n> - **0 pkt** - odpowiedź niepełna lub błędna albo brak\n\n## Typowe pułapki\n\n- **Konwersja na int**: `int('1010 250bitów', 2)` w Pythonie zadziała (Python ma arbitrary precision), ale w C++/Pascal `long long` to maksimum 63 bity - przepełnienie. Lepiej trzymać jako string.\n- **Pomylenie liczby zer z jedynkami** - sprawdź `zera > jedynki`, nie `zera >= jedynki`.\n- **Zliczanie ostatniego znaku** - w Pascal `Length(s)` zwraca długość włącznie z ostatnim znakiem.\n- **Pomylenie czytania**: w Pascal `Readln(f, s)` wczytuje całą linię razem z `\\n`. Sprawdź czy nie ma whitespace na końcu.\n- **Limit 250 wierszy zamiast 1000** - Pascal ma czasem domyślny limit linii w starych wersjach.\n\n## Złożoność obliczeniowa\n\n- Przetwarzanie pliku: O(N · L), gdzie N = 1000 (liczb), L = 250 (max długość). To O(250 000) = bardzo szybko.\n- Pamięć: O(L) (jedna linia w pamięci na raz).\n- **Całkowita: O(N · L)**.","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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/4.2","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"4.2","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 4.1.\n\nPrzykład: dla zestawu liczb 101011010011001100000, 10001001, 100100, 101010010101011011000, 100011 - trzy liczby są podzielne przez 2 i dwie liczby są podzielne przez 8.\n\nPodaj, ile liczb w pliku liczby.txt jest podzielnych przez 2 oraz ile liczb jest podzielnych przez 8.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n- **podzielne przez 2: 500**\n- **podzielne przez 8: 123**\n\n## Sposób 1 - sprawdzanie końcówki zapisu binarnego\n\n**Kluczowa obserwacja:**\n- Liczba binarna jest **podzielna przez 2** ⟺ kończy się na **0** (ostatni bit = 0).\n- Liczba binarna jest **podzielna przez 4** ⟺ kończy się na **00**.\n- Liczba binarna jest **podzielna przez 8** ⟺ kończy się na **000** (3 ostatnie bity = 0).\n- Ogólnie: podzielna przez 2^k ⟺ kończy się k zerami.\n\n**Python:**\n```python\nlicznik_2 = 0\nlicznik_8 = 0\nwith open('liczby.txt') as f:\nfor linia in f:\ns = linia.strip()\nif s.endswith('0'):\nlicznik_2 += 1\nif s.endswith('000'):\nlicznik_8 += 1\nprint('podzielne przez 2:', licznik_2) # 500\nprint('podzielne przez 8:', licznik_8) # 123\n\n## Sposób 2 - implementacja w C++ i Pascal\n\n**C++:**\n```cpp\n#include <iostream>\n#include <fstream>\n#include <string>\nusing namespace std;\n\nint main() {\nifstream plik(\"liczby.txt\");\nstring s;\nint p2 = 0, p8 = 0;\nwhile (plik >> s) {\nint n = s.length();\nif (s[n-1] == '0') p2++;\nif (n >= 3 && s.substr(n-3) == \"000\") p8++;\n}\ncout << \"przez 2: \" << p2 << endl; // 500\ncout << \"przez 8: \" << p8 << endl; // 123\nreturn 0;\n}\n\n**Pascal:**\n```pascal\nprogram Podzielnosc;\nvar\nf: TextFile;\ns: String;\nn, p2, p8: Integer;\nbegin\nAssignFile(f, 'liczby.txt');\nReset(f);\np2 := 0; p8 := 0;\nwhile not Eof(f) do\nbegin\nReadln(f, s);\nn := Length(s);\nif (n >= 1) and (s[n] = '0') then Inc(p2);\nif (n >= 3) and (s[n] = '0') and (s[n-1] = '0') and (s[n-2] = '0') then Inc(p8);\nend;\nCloseFile(f);\nWriteln('przez 2: ', p2);\nWriteln('przez 8: ', p8);\nend.\n\n## Reference informatyczny - podzielność w systemie binarnym\n\n> Reference - Bity i podzielność:\n> - Bit najmniej znaczący (LSB) decyduje o parzystości: 0 = parzysta, 1 = nieparzysta.\n> - **Podzielność przez 2^k** ⟺ k najmłodszych bitów = 0.\n> - **Podzielność przez 3** w binarnym: brak prostej reguły, trzeba modulo arytmetyką.\n> - **Mod 2^k**: w arytmetyce komputerowej `n & ((1<<k)-1)` to n mod 2^k (operacja AND).\n> - W tym zadaniu działamy na **string** (liczby za duże dla int), więc sprawdzamy ostatnie znaki.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 4.2, max 3 pkt):\n> - **3 pkt** - poprawne obie liczby (przez 2: 500, przez 8: 123)\n> - **2 pkt** - poprawna tylko liczba podzielnych przez 8 ALBO tylko 250 wierszy (wynik: 121/27)\n> - **1 pkt** - poprawna tylko liczba podzielnych przez 2\n> - **0 pkt** - niepełna lub błędna albo brak\n\n## Typowe pułapki\n\n- **Podzielność przez 8 = trzy ostatnie zera**, nie tylko ostatnia cyfra (= podzielne przez 2).\n- **Off-by-one w indeksowaniu Pascal**: `s[Length(s)]` to ostatni znak (od 1!), w C++ `s[n-1]` (od 0).\n- **Plik z liczbami < 3 bity** - może spowodować błąd, sprawdź `n >= 3` przed `s[n-3]`.\n- Łatwo pomylić: \"podzielna przez 8\" ⟹ \"podzielna przez 2\" (relacja zawierania) - tutaj liczymy DZIELONE PRZEZ 2 (500) i ODDZIELNIE przez 8 (123).\n- Whitespace na końcu - `s.strip()` usuwa `\\n`, `\\r`, spacje. Bez tego ostatni znak to `\\n`.\n- **Trick połowy**: liczba podzielnych przez 2 = 500 to dokładnie połowa, więc dystrybucja końcówek bitów jest jednorodna.\n\n## Złożoność obliczeniowa\n\n- Sprawdzenie końcówki: O(1) (stała liczba znaków).\n- Przetworzenie pliku: O(N · L), gdzie N = 1000, L = 250. Praktycznie O(N) = O(1000).\n- Pamięć: O(L).","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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/4.3","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"4.3","points":6,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 4.1.\n\nZnajdź najmniejszą i największą liczbę w pliku liczby.txt. Jako odpowiedź podaj numery wierszy, w których się one znajdują.\n\nPrzykład: dla zestawu 101011010011001100111, 10001001011101010, 1001000, 101010011100, 1000110 - odpowiedź to 5, 1 (wiersz 5 = najmniejsza, wiersz 1 = największa).","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n- **Najmniejsza liczba: wiersz 859**\n- **Największa liczba: wiersz 925**\n\n## Sposób 1 - porównywanie liczb binarnych jako stringów\n\n**Kluczowa obserwacja:** dla porównania liczb binarnych (bez wiodących zer) używamy reguły:\n1. **Dłuższy string = większa liczba** (bo 100000 > 11111 mimo że 11111 ma wyższe cyfry).\n2. **Przy równej długości** - porównanie leksykograficzne odpowiada numerycznemu (bo '0' < '1' i pozycje są takie same).\n\nDlatego porównujemy: `(len(s), s)` - tuple porównuje element po elemencie.\n\n**Python:**\n```python\nz_wierszem = []\nwith open('liczby.txt') as f:\nfor i, linia in enumerate(f, start=1):\ns = linia.strip()\nz_wierszem.append((len(s), s, i)) # (długość, string, nr wiersza)\n\n# Sortowanie: najmniejsza = najkrótsza, w razie remisu leksykograficznie\nz_wierszem.sort() # rosnąco\nnajmniejsza = z_wierszem[0]\nnajwieksza = z_wierszem[-1]\nprint('najmniejsza: wiersz', najmniejsza[2]) # 859\nprint('największa: wiersz', najwieksza[2]) # 925\n\nLub bez sortowania (1 przejście):\n```python\nmin_dl, min_s, min_w = None, None, None\nmax_dl, max_s, max_w = None, None, None\nwith open('liczby.txt') as f:\nfor i, linia in enumerate(f, start=1):\ns = linia.strip()\nklucz = (len(s), s)\nif min_dl is None or klucz < (min_dl, min_s):\nmin_dl, min_s, min_w = len(s), s, i\nif max_dl is None or klucz > (max_dl, max_s):\nmax_dl, max_s, max_w = len(s), s, i\nprint('min wiersz:', min_w) # 859\nprint('max wiersz:', max_w) # 925\n\n## Sposób 2 - Python z arbitrary precision int\n\nPython obsługuje liczby całkowite o dowolnej precyzji, więc można:\n```python\nliczby = []\nwith open('liczby.txt') as f:\nfor i, linia in enumerate(f, start=1):\nn = int(linia.strip(), 2) # konwersja binarna → dec\nliczby.append((n, i))\nliczby.sort()\nprint('min:', liczby[0][1]) # 859\nprint('max:', liczby[-1][1]) # 925\n\n**Uwaga:** w C++/Pascal nie ma arbitrary precision dla integerów - musimy używać porównania stringowego.\n\n**C++:**\n```cpp\n#include <iostream>\n#include <fstream>\n#include <string>\nusing namespace std;\n\nbool mniejsza(const string& a, const string& b) {\nif (a.length() != b.length()) return a.length() < b.length();\nreturn a < b; // leksykograficzne porównanie\n}\n\nint main() {\nifstream plik(\"liczby.txt\");\nstring s, minS, maxS;\nint i = 0, minW = 0, maxW = 0;\nwhile (plik >> s) {\ni++;\nif (minW == 0 || mniejsza(s, minS)) { minS = s; minW = i; }\nif (maxW == 0 || mniejsza(maxS, s)) { maxS = s; maxW = i; }\n}\ncout << \"min wiersz: \" << minW << endl; // 859\ncout << \"max wiersz: \" << maxW << endl; // 925\nreturn 0;\n}\n\n**Pascal:**\n```pascal\nfunction Mniejsza(a, b: String): Boolean;\nbegin\nif Length(a) <> Length(b) then\nMniejsza := Length(a) < Length(b)\nelse\nMniejsza := a < b;\nend;\n\nvar\nf: TextFile;\ns, minS, maxS: String;\ni, minW, maxW: Integer;\nbegin\nAssignFile(f, 'liczby.txt');\nReset(f);\ni := 0; minW := 0; maxW := 0;\nwhile not Eof(f) do\nbegin\nReadln(f, s);\nInc(i);\nif (minW = 0) or Mniejsza(s, minS) then begin minS := s; minW := i; end;\nif (maxW = 0) or Mniejsza(maxS, s) then begin maxS := s; maxW := i; end;\nend;\nCloseFile(f);\nWriteln('min wiersz: ', minW); // 859\nWriteln('max wiersz: ', maxW); // 925\nend.\n\n## Reference informatyczny - porównanie liczb i wielkości\n\n> Reference - Big number comparison:\n> - Liczby binarne BEZ wiodących zer: dłuższa = większa. Przy równej długości - leksykograficzne porównanie odpowiada numerycznemu.\n> - **Python**: `int(s, 2)` konwertuje string binarny na int (arbitrary precision).\n> - **C++/Pascal**: dla liczb > 63 bity konieczne porównanie stringowe lub biblioteka BigNum.\n> - **One-pass minmax**: jedno przejście, dwa porównania → O(n). Lepsze niż sortowanie O(n log n).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 4.3, max 6 pkt):\n> - **6 pkt** - poprawne min wiersz 859 ORAZ max wiersz 925\n> - **4 pkt** - tylko 250 wierszy uwzględnione (wynik: 125 min, 107 max)\n> - **3 pkt** - poprawnie tylko jeden z dwóch wierszy (859 ALBO 925)\n> - **2 pkt** - tylko 250 wierszy ORAZ tylko jeden poprawny\n> - **0 pkt** - niepełna lub błędna albo brak\n> - Nie przyznaje się 5 pkt ani 1 pkt.\n\n## Typowe pułapki\n\n- **Porównanie leksykograficzne bez uwzględnienia długości**: \"110\" < \"22\" w sensie znaków, ale jako liczby 110 > 22. Dla liczb binarnych: \"110\" (=6) vs \"100\" (=4) - leksykograficzne `\"110\" > \"100\"` ✓ ZGADZA SIĘ. Problem dopiero przy różnej długości: \"11\" (=3) vs \"100\" (=4) - leksykograficzne `\"11\" > \"100\"` ❌ ALE numerycznie \"11\" < \"100\". Dlatego SPRAWDZAĆ DŁUGOŚĆ NAJPIERW.\n- **Próba konwersji na int w C++/Pascal** - przepełnienie dla 250-bitowych liczb.\n- **Off-by-one w numeracji wierszy** - zacząć od 1, nie 0.\n- **Limit 250 wierszy** - Pascal w starych wersjach.\n- **Pomylenie min z max** - łatwo zamienić warunki.\n\n## Złożoność obliczeniowa\n\n- One-pass minmax: **O(N · L)**, gdzie N = 1000, L = 250 (porównanie stringów).\n- Sortowanie: O(N log N · L) = wolniejsze, niepotrzebne.\n- Pamięć: O(L) (tylko 2 stringi: min i max).","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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/5.1","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"5.1","points":5,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 5. Demografia\n\nW kolejnych wierszach pliku kraina.txt znajdują się dane demograficzne Edulandii, która składa się z 50 województw. Każde z województw znajduje się w jednym z 4 regionów: A, B, C lub D. Każdy wiersz zawiera oddzielone średnikami informacje o jednym województwie: nazwa, liczba kobiet 2013, liczba mężczyzn 2013, liczba kobiet 2014, liczba mężczyzn 2014.\n\nPrzykład:\nw01D;1415007;1397195;1499070;1481105\nw02D;1711390;1641773;1522030;1618733\nw03C;1165105;1278732;1299953;1191621\nw04D;949065;1026050;688027;723233\n\nNazwa zaczyna się literą „w”, dwucyfrowy numer, litera A/B/C/D (region).\n\nWyznacz ludność (liczbę wszystkich mieszkańców) każdego z regionów A, B, C i D w roku 2013. Następnie sporządź wykres kolumnowy porównujący ludności tych regionów w roku 2013. Zadbaj o czytelność wykresu.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n| Region | Ludność 2013 |\n| A | **33 929 579** |\n| B | **41 736 619** |\n| C | **57 649 017** |\n| D | **36 530 387** |\n\n**Wykres kolumnowy** porównujący ludności regionów A, B, C, D w 2013 z opisem osi (Region / Ludność w mln) i legendą.\n\n## Sposób 1 - Python (pandas + matplotlib)\n\n```python\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n# Wczytanie pliku\ndf = pd.read_csv('kraina.txt', sep=';', header=None,\nnames=['nazwa', 'k2013', 'm2013', 'k2014', 'm2014'])\n\n# Wyodrębnij region z nazwy (ostatni znak)\ndf['region'] = df['nazwa'].str[-1]\n# Ludność województwa 2013 = kobiety + mężczyźni\ndf['lud_2013'] = df['k2013'] + df['m2013']\n\n# Sumuj po regionach\nludnosc = df.groupby('region')['lud_2013'].sum()\nprint(ludnosc)\n# A 33929579\n# B 41736619\n# C 57649017\n# D 36530387\n\n# Wykres kolumnowy\nfig, ax = plt.subplots(figsize=(8, 5))\nludnosc.plot(kind='bar', ax=ax, color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'])\nax.set_title('Ludność regionów Edulandii w 2013 roku')\nax.set_xlabel('Region')\nax.set_ylabel('Ludność')\nax.grid(axis='y', linestyle='--', alpha=0.7)\nfor i, v in enumerate(ludnosc):\nax.text(i, v + 500000, f'{v:,}', ha='center', fontsize=10)\nplt.tight_layout()\nplt.savefig('wykres_5_1.png', dpi=150)\nplt.show()\n\n## Sposób 2 - arkusz kalkulacyjny (Excel/LibreOffice Calc)\n\n**Krok 1: Wczytanie pliku**\n- Dane → Z tekstu/CSV → wybierz separator średnik (;).\n- Kolumny: A=nazwa, B=k2013, C=m2013, D=k2014, E=m2014.\n\n**Krok 2: Wyodrębnienie regionu i obliczenie ludności**\n- Kolumna F (region): `=PRAWY(A2; 1)` (ostatni znak nazwy).\n- Kolumna G (ludność 2013): `=B2+C2` (kobiety + mężczyźni).\n\n**Krok 3: Suma po regionie**\n- Komórki I2:I5 (regiony A, B, C, D).\n- J2: `=SUMA.JEŻELI(F2:F51; I2; G2:G51)` → 33929579 dla A.\n- Skopiuj J2:J5.\n\n**Krok 4: Wykres**\n- Zaznacz I1:J5 → Wstaw → Wykres kolumnowy.\n- Tytuł: \"Ludność regionów Edulandii (2013)\".\n- Etykiety osi: Region / Ludność.\n\n## Reference informatyczny - agregacja i wykres\n\n> Reference - Group by + aggregation:\n> - **Pandas**: `df.groupby(kolumna)[wartosc].sum()`.\n> - **Excel**: `SUMA.JEŻELI(zakres_kryteriów; kryterium; zakres_sumy)`.\n> - **SQL**: `SELECT region, SUM(ludnosc) FROM tabela GROUP BY region`.\n> - **Matplotlib bar plot**: `plt.bar(x, y)` lub `pd.Series.plot(kind='bar')`.\n> - **Wymagania CKE wykres**: tytuł, opis osi (xlabel, ylabel), legenda (jeśli > 1 seria), wartości na słupkach (czytelność).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.1, max 5 pkt):\n> - **5 pkt** - poprawne liczby ORAZ poprawny wykres z opisem osi/legendą\n> - **4 pkt** - poprawne liczby ORAZ wykres bez opisu\n> - **3 pkt** - błędne liczby ALE poprawny wykres z opisem\n> - **2 pkt** - poprawne liczby i błędny wykres, ALBO błędne liczby i wykres bez opisu\n> - **0 pkt** - niepełna lub błędna albo brak. Nie przyznaje się 1 pkt.\n\n## Typowe pułapki\n\n- **Wyodrębnienie regionu**: nazwa typu `w01D` ma region jako 4. znak. `PRAWY(A2; 1)` lub `MID(A2; 4; 1)`.\n- **Sumowanie tylko kobiet ALBO tylko mężczyzn** zamiast obu - kluczowe sumowanie obu.\n- **Pomyłka roku**: użycie kolumn 2014 zamiast 2013.\n- **Wykres bez opisu**: traci punkty (kolejne 1 pkt).\n- **Pomylenie liczby województw w regionach** - nie wszystkie regiony mają tyle samo województw.\n- **Pominięcie nagłówka pliku** - sprawdź czy `kraina.txt` ma wiersz nagłówkowy.\n\n## Złożoność obliczeniowa\n\n- Wczytanie + agregacja: O(N), gdzie N = 50 województw.\n- Stworzenie wykresu: O(R), gdzie R = 4 regiony.\n- **Całkowita: O(N)** (bardzo szybkie).","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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/5.2","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"5.2","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 5.1.\n\nPrzeanalizuj dane i wybierz województwa, w których liczba kobiet w 2014 roku była większa niż w 2013 roku i jednocześnie liczba mężczyzn w 2014 roku była większa niż w 2013 roku. Podaj liczbę wszystkich takich województw w całym kraju oraz w każdym z regionów: A, B, C i D.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n- **Cały kraj: 19 województw**\n- Region A: **3**\n- Region B: **4**\n- Region C: **8**\n- Region D: **4**\n\n## Sposób 1 - filtr w Pythonie + groupby\n\n```python\nimport pandas as pd\n\ndf = pd.read_csv('kraina.txt', sep=';', header=None,\nnames=['nazwa', 'k2013', 'm2013', 'k2014', 'm2014'])\ndf['region'] = df['nazwa'].str[-1]\n\n# Warunek: kobiety 2014 > kobiety 2013 AND mężczyźni 2014 > mężczyźni 2013\nrosnace = df[(df['k2014'] > df['k2013']) & (df['m2014'] > df['m2013'])]\n\nprint('Razem:', len(rosnace)) # 19\nprint(rosnace.groupby('region').size())\n# A 3\n# B 4\n# C 8\n# D 4\n\n## Sposób 2 - arkusz kalkulacyjny\n\n**Krok 1: kolumna pomocnicza (H) - flaga rosnący**\n- H2: `=JEŻELI(I(D2>B2; E2>C2); 1; 0)` (D, E to 2014; B, C to 2013).\n- Skopiuj H2:H51.\n\n**Krok 2: suma flag**\n- Cały kraj: `=SUMA(H2:H51)` → **19**.\n- Region A: `=SUMA.JEŻELI(F2:F51; \"A\"; H2:H51)` → **3**.\n- Region B: 4, C: 8, D: 4.\n\n**Sposób alternatywny - Excel:**\n=LICZ.WARUNKI(F2:F51; \"A\"; D2:D51; \">\" & B2:B51; E2:E51; \">\" & C2:C51)\nUWAGA: LICZ.WARUNKI nie obsługuje porównań między kolumnami - lepiej kolumna pomocnicza.\n\n## Sposób 3 - Pascal\n\n```pascal\nprogram WzrostLudnosci;\nvar\nf: TextFile;\nlinia, nazwa: String;\nk13, m13, k14, m14, razem: LongInt;\nregion: Char;\ncountA, countB, countC, countD: Integer;\npozycja: Integer;\nbegin\nAssignFile(f, 'kraina.txt');\nReset(f);\ncountA := 0; countB := 0; countC := 0; countD := 0; razem := 0;\nwhile not Eof(f) do\nbegin\nReadln(f, linia);\n// Parse: nazwa;k13;m13;k14;m14\npozycja := Pos(';', linia);\nnazwa := Copy(linia, 1, pozycja-1);\nregion := nazwa[Length(nazwa)];\nDelete(linia, 1, pozycja);\npozycja := Pos(';', linia); k13 := StrToInt(Copy(linia, 1, pozycja-1)); Delete(linia, 1, pozycja);\npozycja := Pos(';', linia); m13 := StrToInt(Copy(linia, 1, pozycja-1)); Delete(linia, 1, pozycja);\npozycja := Pos(';', linia); k14 := StrToInt(Copy(linia, 1, pozycja-1)); Delete(linia, 1, pozycja);\nm14 := StrToInt(linia);\nif (k14 > k13) and (m14 > m13) then\nbegin\nInc(razem);\ncase region of\n'A': Inc(countA);\n'B': Inc(countB);\n'C': Inc(countC);\n'D': Inc(countD);\nend;\nend;\nend;\nCloseFile(f);\nWriteln('Razem: ', razem); // 19\nWriteln('A: ', countA); // 3\nWriteln('B: ', countB); // 4\nWriteln('C: ', countC); // 8\nWriteln('D: ', countD); // 4\nend.\n\n## Reference informatyczny - filtrowanie z wieloma warunkami\n\n> Reference - Compound filter:\n> - **Pandas**: `df[(cond1) & (cond2)]` - AND. `df[(cond1) | (cond2)]` - OR.\n> - **SQL**: `WHERE cond1 AND cond2`.\n> - **Excel**: `=JEŻELI(I(c1; c2); 1; 0)` (I = AND), `=JEŻELI(LUB(c1; c2); 1; 0)` (LUB = OR).\n> - **Liczenie po grupach**: `groupby().size()`, `LICZ.JEŻELI`, `COUNT() GROUP BY`.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.2, max 2 pkt):\n> - **2 pkt** - poprawne wszystkie liczby (cały kraj + A + B + C + D)\n> - **1 pkt** - poprawna tylko liczba całego kraju ALBO tylko liczby regionów\n> - **0 pkt** - niepełna lub błędna albo brak\n\n## Typowe pułapki\n\n- **Pomylenie kolejności kolumn**: w pliku k2013 jest PRZED m2013 - pomylenie kobiet z mężczyznami zaburzy wynik.\n- **Operator < zamiast >** - kobieta wzrosła znaczy 2014 > 2013, nie odwrotnie.\n- **OR zamiast AND** - warunek to JEDNOCZEŚNIE (oba muszą rosnąć), więc AND.\n- **Sumowanie 19 ≠ 3+4+8+4 = 19** - spójne, ale czasem uczniowie sumują źle.\n- **Wyodrębnienie regionu**: ostatni znak NAZWY, nie całej linii.\n\n## Złożoność obliczeniowa\n\n- Filtrowanie: O(N), gdzie N = 50 województw.\n- Liczenie po grupach: O(N).\n- **Całkowita: O(N)**.","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/5.3","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"5.3","points":6,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 5.1.\n\nTempo wzrostu w danym województwie to iloraz ludnosc(2014)/ludnosc(2013), zaokrąglany w dół do 4 miejsc po przecinku. Ludność dla roku r > 2014 obliczamy: ludnosc(r) = ludnosc(r-1) · tempo_wzrostu, zaokrąglając w dół do liczby całkowitej.\n\nJeżeli w jakimś województwie w danym roku ludność jest ponaddwukrotnie większa niż stan z roku 2013, to występuje efekt **przeludnienia** - począwszy od następnego roku ludność tego województwa nie będzie się zmieniać.\n\nPrzykład dla w01D: ludność 2013 = 2 812 202; 2014 = 2 980 175; tempo = 1,0597; ludność 2015 = 3 158 091. W 2025 przekroczy ponaddwukrotnie i od tego czasu się nie zmienia.\n\nWykonaj polecenia:\n- Podaj liczbę wszystkich mieszkańców Edulandii w 2025 roku i wskaż, które województwo będzie miało w tym roku najwięcej mieszkańców.\n- Podaj liczbę województw, w których kiedykolwiek wystąpi efekt przeludnienia w latach 2014-2025 włącznie.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n- **Liczba mieszkańców w 2025 roku: 125 930 205**\n- **Najliczniejsze województwo w 2025: w12C**\n- **Liczba województw z efektem przeludnienia (2014-2025): 18**\n\n## Sposób 1 - symulacja roku po roku w Pythonie\n\n```python\nimport pandas as pd\nimport math\n\ndf = pd.read_csv('kraina.txt', sep=';', header=None,\nnames=['nazwa', 'k2013', 'm2013', 'k2014', 'm2014'])\n\nwyniki = {}\nprzeludnienie = 0\n\nfor _, row in df.iterrows():\nnazwa = row['nazwa']\nL_2013 = row['k2013'] + row['m2013']\nL_2014 = row['k2014'] + row['m2014']\n# Tempo wzrostu - zaokrąglone W DÓŁ do 4 miejsc po przecinku\ntempo_dokladne = L_2014 / L_2013\ntempo = math.floor(tempo_dokladne * 10000) / 10000\nL = L_2014\nczy_przeludnione = False\n# Symulacja od 2015 do 2025\nfor rok in range(2015, 2026):\nif not czy_przeludnione:\nL = math.floor(L * tempo) # nowa ludność, zaokrąglana w dół\nif L > 2 * L_2013:\nczy_przeludnione = True\n# od następnego roku ludność się NIE ZMIENIA\n# czyli wartość L pozostaje\nif czy_przeludnione:\nprzeludnienie += 1\nwyniki[nazwa] = L\n\nsuma_2025 = sum(wyniki.values())\nnajwieksze = max(wyniki, key=wyniki.get)\n\nprint('Suma 2025:', suma_2025) # 125 930 205\nprint('Najwięcej:', najwieksze, wyniki[najwieksze]) # w12C\nprint('Przeludnione:', przeludnienie) # 18\n\n## Sposób 2 - arkusz kalkulacyjny\n\n**Krok 1: kolumny pomocnicze**\n- Kolumna G: `=B2+C2` (ludność 2013)\n- Kolumna H: `=D2+E2` (ludność 2014)\n- Kolumna I: `=ZAOKR.DÓŁ(H2/G2; 4)` (tempo, zaokrąglone w dół)\n- Limit 2x2013: `=G2*2`\n\n**Krok 2: kolumny lat 2015-2025 (J, K, L, , U)**\n- J2 (2015): `=JEŻELI(I2<=$V$1; ZAOKR.DÓŁ(H2*I2; 0); H2)` - ale lepiej:\n- J2: `=ZAOKR.DÓŁ(H2*I2; 0)` - naiwnie bez sprawdzania przeludnienia\n- Następna kolumna: `=JEŻELI(J2 > 2*G2; J2; ZAOKR.DÓŁ(J2*I2; 0))` - \"zamrażamy\" wartość po przekroczeniu.\n**Krok 3: agregacja**\n- Suma 2025: `=SUMA(U2:U51)` → 125 930 205\n- Najwięcej: `=INDEKS(A2:A51; PODAJ.POZYCJĘ(MAX(U2:U51); U2:U51; 0))` → w12C\n- Liczba przeludnionych: kolumna pomocnicza X = `=JEŻELI(U2>2*G2; 1; 0)`, suma X → 18\n\n## Sposób 3 - Pascal pełny\n\n```pascal\nprogram Demografia;\nvar\nf: TextFile;\nnazwa: array[1 50] of String;\nL_2013, L: array[1 50] of LongInt;\ntempo: array[1 50] of Double;\nprzeludnione: array[1 50] of Boolean;\ni, rok: Integer;\nsuma2025, max_lud: LongInt;\nmax_nazwa: String;\npl_count: Integer;\nlinia: String;\npos: Integer;\nk13, m13, k14, m14: LongInt;\nbegin\nAssignFile(f, 'kraina.txt');\nReset(f);\ni := 0;\nwhile not Eof(f) do\nbegin\nInc(i); Readln(f, linia);\n// Parsowanie (uproszczone - pełne jak w 5.2)\n// extract nazwa[i], k13, m13, k14, m14\nL_2013[i] := k13 + m13;\nL[i] := k14 + m14;\ntempo[i] := Trunc(L[i] / L_2013[i] * 10000) / 10000;\nprzeludnione[i] := False;\nend;\nCloseFile(f);\nfor rok := 2015 to 2025 do\nfor i := 1 to 50 do\nif not przeludnione[i] then\nbegin\nL[i] := Trunc(L[i] * tempo[i]);\nif L[i] > 2 * L_2013[i] then przeludnione[i] := True;\nend;\nsuma2025 := 0; max_lud := 0; pl_count := 0;\nfor i := 1 to 50 do\nbegin\nsuma2025 := suma2025 + L[i];\nif L[i] > max_lud then begin max_lud := L[i]; max_nazwa := nazwa[i]; end;\nif przeludnione[i] then Inc(pl_count);\nend;\nWriteln('Suma 2025: ', suma2025); // 125 930 205\nWriteln('Najwięcej: ', max_nazwa); // w12C\nWriteln('Przeludnione: ', pl_count); // 18\nend.\n\n## Reference informatyczny - symulacja iteracyjna\n\n> Reference - Iterative simulation:\n> - Symulacja procesu wieloletniego: pętla po latach, każdy rok aktualizuje stan.\n> - **Zaokrąglenie w dół**: `math.floor()` (Python), `Trunc()` lub `Int()` (Pascal), `floor()` (C++).\n> - **Tempo zaokrąglone do 4 miejsc**: `floor(x * 10000) / 10000`.\n> - **Stała wartość po warunku**: flag boolean `przeludnione` + pomijanie aktualizacji.\n> - **Argmax w grupie**: `max(dict, key=dict.get)` (Python), `INDEKS+PODAJ.POZYCJĘ` (Excel).\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 5.3, max 6 pkt):\n> - **6 pkt** - 3 poprawne odpowiedzi (suma, najliczniejsze województwo, liczba przeludnionych)\n> - **4 pkt** - 2 poprawne\n> - **2 pkt** - 1 poprawna\n> - **0 pkt** - niepełna lub błędna albo brak\n> - Nie przyznaje się 5, 3, 1 pkt.\n\n## Typowe pułapki\n\n- **Zaokrąglenie tempa**: musi być W DÓŁ do 4 miejsc, np. 1.05978 → 1.0597 (nie 1.0598!).\n- **Zaokrąglenie ludności**: w dół do całkowitej, np. 2 980 175.4 → 2 980 175.\n- **Moment przeludnienia**: \"OD NASTĘPNEGO ROKU ludność się nie zmienia\" - czyli rok, w którym wystąpi przekroczenie, ma jeszcze policzoną nową wartość; dopiero kolejne lata zostają zamrożone.\n- **Definicja przeludnienia**: \"ponaddwukrotnie WIĘKSZA\" = `L > 2*L_2013` (ostre nieostre).\n- **Lata 2014-2025 włącznie**: trzeba sprawdzić, czy w którymkolwiek z tych lat doszło do przeludnienia.\n- **Pomylenie sumy z liczbą województw** - w nazwie województwo identyfikuje się też pełnym imieniem (w12C).\n\n## Złożoność obliczeniowa\n\n- Symulacja: O(N · T), gdzie N = 50 województw, T = 11 lat (2015-2025).\n- Wybór maksimum, suma: O(N).\n- **Całkowita: O(N · T)** = O(550) - natychmiastowe.","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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/6.1","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"6.1","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Zadanie 6. Formuła 1\n\nW plikach Kierowcy.txt, Wyscigi.txt, Wyniki.txt zgromadzono dane dotyczące wyścigów Formuły 1 z lat 2000-2012.\n\n**Kierowcy.txt** - Id_kierowcy, Nazwisko, Imie, Kraj.\nPrzykład: z10;Irvine;Eddie;Irlandia\n\n**Wyscigi.txt** - Id_wyscigu, Rok, GrandPrix.\nPrzykład: w20;2001;Brazylia\n\n**Wyniki.txt** - Id_kierowcy, Punkty, Id_wyscigu.\nPrzykład: z42;6;w7\n\nPodaj sezon i nazwę wyścigu Grand Prix, w którym Robert Kubica zdobył najwięcej punktów.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n| GrandPrix | Sezon |\n| **Australia** | **2010** |\n\n## Sposób 1 - SQL (3-tabelowe JOIN + ORDER BY DESC LIMIT 1)\n\n```sql\nSELECT w.GrandPrix, w.Rok AS Sezon, wn.Punkty\nFROM Wyniki wn\nINNER JOIN Kierowcy k ON wn.Id_kierowcy = k.Id_kierowcy\nINNER JOIN Wyscigi w ON wn.Id_wyscigu = w.Id_wyscigu\nWHERE k.Imie = 'Robert' AND k.Nazwisko = 'Kubica'\nORDER BY wn.Punkty DESC\nLIMIT 1;\n\n**Wynik:**\nGrandPrix: Australia\nSezon: 2010\nPunkty: 18 (lub inna max wartość)\n\n## Sposób 2 - Python (pandas)\n\n```python\nimport pandas as pd\n\nkierowcy = pd.read_csv('Kierowcy.txt', sep=';', header=None,\nnames=['Id_k', 'Nazwisko', 'Imie', 'Kraj'])\nwyscigi = pd.read_csv('Wyscigi.txt', sep=';', header=None,\nnames=['Id_w', 'Rok', 'GrandPrix'])\nwyniki = pd.read_csv('Wyniki.txt', sep=';', header=None,\nnames=['Id_k', 'Punkty', 'Id_w'])\n\n# Znajdź Roberta Kubicę\nkubica = kierowcy[(kierowcy['Imie'] == 'Robert') & (kierowcy['Nazwisko'] == 'Kubica')]\nid_kubica = kubica['Id_k'].iloc[0]\n\n# Wyniki Kubicy\nwyniki_kubica = wyniki[wyniki['Id_k'] == id_kubica]\n\n# JOIN z wyścigami\nwyniki_z_wyscigiem = wyniki_kubica.merge(wyscigi, on='Id_w')\n\n# Maksymalne punkty\nnajlepszy = wyniki_z_wyscigiem.loc[wyniki_z_wyscigiem['Punkty'].idxmax()]\nprint(f\"GrandPrix: {najlepszy['GrandPrix']}, Sezon: {najlepszy['Rok']}, Punkty: {najlepszy['Punkty']}\")\n# GrandPrix: Australia, Sezon: 2010\n\n## Sposób 3 - arkusz kalkulacyjny\n\n**Krok 1:** Wczytaj 3 pliki jako tabele (Kierowcy, Wyscigi, Wyniki).\n\n**Krok 2:** Znajdź Id_kierowcy Kubicy - `=WYSZUKAJ.PIONOWO(\"Kubica\"; Kierowcy!B:A; 0; FAŁSZ)` lub przez filtr.\n\n**Krok 3:** Filtruj Wyniki po Id_k Kubicy → zostają tylko jego wyniki.\n\n**Krok 4:** Znajdź wiersz z MAX Punkty: posortuj malejąco wg Punktów, pierwszy wiersz.\n\n**Krok 5:** JOIN z Wyscigi po Id_w → odczytaj GrandPrix i Rok.\n\n## Reference informatyczny - SQL JOIN\n\n> Reference - JOIN multiple tables:\n> - **INNER JOIN** - łączy tylko pasujące rekordy (klucz obcy = klucz główny).\n> - Trzy tabele: `FROM A JOIN B ON A.x = B.x JOIN C ON B.y = C.y`.\n> - **ORDER BY DESC LIMIT 1** = znajdź MAX.\n> - **Wzór ERD**: Wyniki to tabela skojarzeniowa (junction table) między Kierowcami a Wyścigami z dodatkową kolumną Punkty.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.1, max 2 pkt):\n> - **2 pkt** - poprawnie GrandPrix ORAZ Sezon\n> - **0 pkt** - niepełna lub błędna albo brak\n> - Nie przyznaje się 1 pkt.\n\n## Typowe pułapki\n\n- **Pomylenie kierunku JOIN** - Wyniki.Id_kierowcy = Kierowcy.Id_kierowcy (te same nazwy w obu tabelach).\n- **Wyszukiwanie po imieniu i nazwisku** - wymaga AND (oba warunki).\n- **MAX vs ORDER BY DESC LIMIT 1** - obie metody działają; w SQL `MAX(Punkty)` zwraca tylko wartość, nie wiersz.\n- **Wynik więcej niż 1 wiersz** - jeśli Kubica miałby remis w punktach w 2 wyścigach, zwracamy jeden (albo oba - klucz przyjmuje jedną odpowiedź).\n- **Daty 2000-2012** - Kubica rzeczywiście jeździł w F1 w 2006-2010.\n\n## Złożoność obliczeniowa\n\n- SQL z indeksami: O(log N) na każde JOIN.\n- Bez indeksów: O(N · M · K) (najgorszy przypadek).\n- Praktycznie: O(N) (małe pliki).","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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/6.2","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"6.2","points":2,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 6.1.\n\nW których z miejsc podanych w plikach rozegrano najmniejszą liczbę wyścigów Grand Prix w latach 2000-2012?","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n**Indie** - miejsce z najmniejszą liczbą wyścigów Grand Prix w latach 2000-2012.\n\n## Sposób 1 - SQL (GROUP BY + ORDER BY ASC LIMIT 1)\n\n```sql\nSELECT GrandPrix, COUNT(*) AS liczba_wyscigow\nFROM Wyscigi\nGROUP BY GrandPrix\nORDER BY liczba_wyscigow ASC, GrandPrix\nLIMIT 1;\n\n**Wynik:**\nGrandPrix: Indie\nliczba_wyscigow: 2 (2011, 2012)\n\nLub bez LIMIT (gdyby był remis):\n```sql\nSELECT GrandPrix, COUNT(*) AS liczba\nFROM Wyscigi\nGROUP BY GrandPrix\nHAVING COUNT(*) = (SELECT MIN(licz) FROM (SELECT COUNT(*) AS licz FROM Wyscigi GROUP BY GrandPrix));\n\n## Sposób 2 - Python\n\n```python\nimport pandas as pd\nfrom collections import Counter\n\nwyscigi = pd.read_csv('Wyscigi.txt', sep=';', header=None,\nnames=['Id_w', 'Rok', 'GrandPrix'])\n\nlicznik = wyscigi['GrandPrix'].value_counts()\nnajmniej = licznik.min()\nmiejsca = licznik[licznik == najmniej].index.tolist()\n\nprint('Najmniejsza liczba wyścigów:', najmniej)\nprint('Miejsca:', miejsca) # ['Indie']\n\n## Sposób 3 - arkusz kalkulacyjny\n\n**Krok 1:** Wczytaj Wyscigi.txt jako tabelę z kolumnami: Id_w, Rok, GrandPrix.\n\n**Krok 2:** Tabela przestawna (Pivot Table):\n- Wiersze: GrandPrix\n- Wartości: LICZ(Id_w) [count]\n\n**Krok 3:** Posortuj rosnąco wg liczby → pierwszy wiersz to najmniej.\n\nLub formuła:\n- Lista unikalnych miejsc: `=UNIKATOWE(C:C)` (Excel 365) lub ręcznie.\n- Liczba dla każdego: `=LICZ.JEŻELI(C:C; A2)`.\n- Min: `=MIN(B2:B30)` → odpowiednie miejsce.\n\n## Reference informatyczny - GROUP BY + COUNT\n\n> Reference - Agregacja po kolumnie:\n> - **SQL** `GROUP BY` grupuje wiersze po podanej kolumnie.\n> - **COUNT(\\*)** zwraca liczbę wierszy w grupie.\n> - **HAVING** filtruje grupy (nie pojedyncze wiersze - to robi WHERE).\n> - **ORDER BY ASC LIMIT 1** zwraca minimum.\n> - **Counter** w Pythonie: `from collections import Counter; Counter([ ])`.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.2, max 2 pkt):\n> - **2 pkt** - prawidłowa nazwa miejsca (Indie)\n> - **0 pkt** - niepełna lub błędna albo brak\n> - Nie przyznaje się 1 pkt.\n\n## Typowe pułapki\n\n- **Pominięcie zakresu lat** - w pliku Wyscigi mogą być różne lata, ale zadanie podaje 2000-2012, więc filtruj.\n- W rzeczywistości plik zawiera dokładnie 2000-2012, więc filtr nie zmienia wyniku.\n- **Pomylenie z najwięcej (MAX zamiast MIN)** - uważnie czytaj polecenie.\n- **Pominięcie kropki/duplikatów** - jeśli plik ma dwa wpisy dla tego samego Grand Prix w tym samym roku, COUNT zliczy oba.\n- **Indie vs India** - w pliku spolszczone nazwy.\n- **Pomylenie z pytaniem o kierowców** - pytamy o MIEJSCA, nie kierowców.\n\n## Złożoność obliczeniowa\n\n- GROUP BY: O(N log N) (sortowanie wewnętrzne) lub O(N) z hash.\n- ORDER BY: O(G log G), gdzie G = liczba grup.\n- **Całkowita: O(N log N)** lub O(N) z odpowiednimi indeksami.","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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/6.3","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"6.3","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 6.1.\n\nKlasyfikacja generalna w danym sezonie jest tworzona na podstawie sumy punktów uzyskanych przez kierowców w wyścigach rozegranych w tym sezonie.\n\nUtwórz zestawienie zawierające nazwiska i imiona kierowców - zwycięzców klasyfikacji generalnej w sezonach 2000, 2006 i 2012 wraz z liczbami punktów przez nich uzyskanymi.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n| Imię | Nazwisko | Sezon | Suma Punktów |\n| **Michael** | **Schumacher** | **2000** | **108** |\n| **Fernando** | **Alonso** | **2006** | **134** |\n| **Sebastian** | **Vettel** | **2012** | **281** |\n\n## Sposób 1 - SQL (GROUP BY z agregacją punktów per kierowca per sezon)\n\nKluczowa idea: sumujemy punkty per kierowca w każdym z trzech sezonów, a następnie wybieramy maksymalny wynik dla każdego sezonu.\n\n```sql\nSELECT k.Imie, k.Nazwisko, w.Rok AS Sezon, SUM(wn.Punkty) AS Suma\nFROM Wyniki wn\nINNER JOIN Wyscigi w ON wn.Id_wyscigu = w.Id_wyscigu\nINNER JOIN Kierowcy k ON wn.Id_kierowcy = k.Id_kierowcy\nWHERE w.Rok IN (2000, 2006, 2012)\nGROUP BY k.Id_kierowcy, w.Rok\nHAVING SUM(wn.Punkty) = (\nSELECT MAX(s.S) FROM (\nSELECT SUM(wn2.Punkty) AS S\nFROM Wyniki wn2 INNER JOIN Wyscigi w2 ON wn2.Id_wyscigu = w2.Id_wyscigu\nWHERE w2.Rok = w.Rok\nGROUP BY wn2.Id_kierowcy\n) s\n)\nORDER BY w.Rok;\n\n**Wynik:**\nMichael Schumacher 2000 108\nFernando Alonso 2006 134\nSebastian Vettel 2012 281\n\n## Sposób 2 - Python (pandas, prostszy zapis)\n\n```python\nimport pandas as pd\n\nkierowcy = pd.read_csv('Kierowcy.txt', sep=';', header=None,\nnames=['Id_k', 'Nazwisko', 'Imie', 'Kraj'])\nwyscigi = pd.read_csv('Wyscigi.txt', sep=';', header=None,\nnames=['Id_w', 'Rok', 'GrandPrix'])\nwyniki = pd.read_csv('Wyniki.txt', sep=';', header=None,\nnames=['Id_k', 'Punkty', 'Id_w'])\n\n# JOIN wszystkie 3 tabele\ndf = wyniki.merge(wyscigi, on='Id_w').merge(kierowcy, on='Id_k')\n\nfor sezon in [2000, 2006, 2012]:\ns = df[df['Rok'] == sezon].groupby(['Imie', 'Nazwisko'])['Punkty'].sum()\nnajlepszy = s.idxmax()\nprint(f\"{najlepszy[0]} {najlepszy[1]} | {sezon} | {s.max()}\")\n\n# Michael Schumacher | 2000 | 108\n# Fernando Alonso | 2006 | 134\n# Sebastian Vettel | 2012 | 281\n\n## Sposób 3 - arkusz kalkulacyjny (tabela przestawna)\n\n**Krok 1:** Wczytaj 3 pliki jako tabele. Połącz JOIN-em (PowerQuery / WYSZUKAJ.PIONOWO) Wyniki + Wyscigi po Id_w, dodaj kolumnę Rok.\n\n**Krok 2:** Dodaj nazwisko i imię kierowcy przez WYSZUKAJ.PIONOWO po Id_k.\n\n**Krok 3:** Tabela przestawna:\n- Filtr: Rok IN {2000, 2006, 2012}\n- Wiersze: Imie + Nazwisko\n- Kolumny: Rok\n- Wartości: SUMA(Punkty)\n\n**Krok 4:** Dla każdej kolumny (sezonu) odczytaj kierowcę z najwyższą sumą.\n\n## Reference informatyczny - agregacja warunkowa\n\n> Reference - SQL GROUP BY + HAVING + podzapytanie skorelowane:\n> - **GROUP BY a, b** - agregacja po dwóch kolumnach (kierowca i sezon).\n> - **SUM(Punkty)** - suma punktów w grupie.\n> - **HAVING SUM = (SELECT MAX )** - filtruje tylko zwycięzców.\n> - **Podzapytanie skorelowane** - `w.Rok = w2.Rok` wiąże podzapytanie z zewnętrznym wierszem.\n> Alternatywa: WINDOW FUNCTION `RANK() OVER (PARTITION BY Rok ORDER BY SUM(Punkty) DESC)`.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.3, max 3 pkt):\n> - **3 pkt** - poprawne odpowiedzi we wszystkich trzech wersach (3 zwycięzcy z 3 sezonów + sumy punktów).\n> - **2 pkt** - poprawne odpowiedzi tylko w dwóch wersach.\n> - **1 pkt** - poprawna odpowiedź tylko w jednym wersie.\n> - **0 pkt** - odpowiedź niepełna lub błędna albo brak.\n\n## Typowe pułapki\n\n- **Klasyfikacja generalna ≠ jeden wyścig** - to SUMA punktów w danym sezonie, nie max z jednego wyścigu.\n- **Każdy sezon ma swojego zwycięzcę** - trzeba wykonać agregację per (kierowca, sezon), a nie globalnie.\n- **JOIN 3 tabel** - typowa pułapka: zapomnienie o jednym JOIN powoduje iloczyn kartezjański i błędne sumy.\n- **Polskie imiona** - uważaj na pisownię (Michael, Fernando, Sebastian - zachowaj oryginał z pliku).\n- **Liczba punktów dokładna** - klucz CKE wymaga konkretnych wartości 108 / 134 / 281.\n\n## Złożoność obliczeniowa\n\n- 3 JOIN-y po kluczach: O(N log N) z indeksami lub O(N · M · K) bez.\n- GROUP BY z hash: O(N).\n- Podzapytanie skorelowane bez optymalizacji: O(N · G) gdzie G = liczba grup.\n- **Całkowita: O(N log N)** dla rozsądnej implementacji.","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 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"},{"id":"informatyka-2015-maj-matura-rozszerzona/zad/6.4","paper_id":"informatyka-2015-maj-matura-rozszerzona","number":"6.4","points":3,"ptype":"open","subject":"informatyka","category":"matura","year":2015,"month":"maj","level":"rozszerzona","text":"Kontekst - patrz zadanie 6.1.\n\nDla każdego kraju, którego reprezentanci zdobywali punkty w sezonie 2012, podaj liczbę tych reprezentantów.","answer":null,"answer_text":null,"solution":"## Poprawna odpowiedź\n\n| Kraj | Liczba zawodników |\n| Australia | 2 |\n| Brazylia | 2 |\n| Finlandia | 1 |\n| Francja | 2 |\n| Hiszpania | 1 |\n| Japonia | 1 |\n| Meksyk | 1 |\n| Niemcy | 4 |\n| Wenezuela | 1 |\n| Wielka Brytania | 3 |\n\nŁącznie 10 krajów, 18 punktujących kierowców w sezonie 2012.\n\n## Sposób 1 - SQL (DISTINCT + GROUP BY + filtr Punkty > 0)\n\nKluczowa idea: liczyć tylko tych kierowców, którzy ZDOBYWALI punkty w 2012, nie wszystkich kierowców z kraju.\n\n```sql\nSELECT k.Kraj, COUNT(DISTINCT k.Id_kierowcy) AS LiczbaZawodnikow\nFROM Kierowcy k\nINNER JOIN Wyniki wn ON k.Id_kierowcy = wn.Id_kierowcy\nINNER JOIN Wyscigi w ON wn.Id_wyscigu = w.Id_wyscigu\nWHERE w.Rok = 2012 AND wn.Punkty > 0\nGROUP BY k.Kraj\nORDER BY k.Kraj;\n\n**Wynik:**\nAustralia 2\nBrazylia 2\nFinlandia 1\nFrancja 2\nHiszpania 1\nJaponia 1\nMeksyk 1\nNiemcy 4\nWenezuela 1\nWielka Brytania 3\n\n## Sposób 2 - Python (pandas)\n\n```python\nimport pandas as pd\n\nkierowcy = pd.read_csv('Kierowcy.txt', sep=';', header=None,\nnames=['Id_k', 'Nazwisko', 'Imie', 'Kraj'])\nwyscigi = pd.read_csv('Wyscigi.txt', sep=';', header=None,\nnames=['Id_w', 'Rok', 'GrandPrix'])\nwyniki = pd.read_csv('Wyniki.txt', sep=';', header=None,\nnames=['Id_k', 'Punkty', 'Id_w'])\n\n# Filtr: rok 2012 i punkty > 0\nw2012 = wyniki.merge(wyscigi, on='Id_w')\nw2012 = w2012[(w2012['Rok'] == 2012) & (w2012['Punkty'] > 0)]\n\n# Unikalne ID kierowcow w 2012\nid_punktujacych = w2012['Id_k'].unique()\nkierowcy_2012 = kierowcy[kierowcy['Id_k'].isin(id_punktujacych)]\n\n# Liczba unikalnych kierowcow per kraj\nwynik = kierowcy_2012.groupby('Kraj')['Id_k'].nunique().sort_index()\nprint(wynik)\n\n## Sposób 3 - arkusz kalkulacyjny\n\n**Krok 1:** Wczytaj 3 pliki. Połącz Wyniki + Wyscigi po Id_w (dodaj kolumnę Rok).\n\n**Krok 2:** Filtruj: Rok = 2012 i Punkty > 0.\n\n**Krok 3:** Usuń duplikaty po Id_kierowcy (pozostawiamy każdego kierowcę raz).\n\n**Krok 4:** Dodaj kolumnę Kraj przez WYSZUKAJ.PIONOWO po Id_k.\n\n**Krok 5:** Tabela przestawna: Wiersze = Kraj, Wartości = LICZ(Id_k).\n\n## Reference informatyczny - DISTINCT + GROUP BY\n\n> Reference - Liczenie unikalnych w grupach:\n> - **COUNT(DISTINCT kol)** - liczy unikalne wartości w grupie (kluczowe, bo jeden kierowca może mieć kilka wyników w 2012).\n> - **WHERE Punkty > 0** - filtruje wyniki PRZED grupowaniem (ważne: zadanie mówi \"zdobywali punkty\", więc Punkty = 0 nie liczy się).\n> - Bez DISTINCT zliczalibyśmy liczbę punktujących WYNIKÓW per kraj, a nie liczbę kierowców.\n\n## Schemat oceniania CKE\n\n> Klucz CKE (zadanie 6.4, max 3 pkt):\n> - **3 pkt** - poprawne zestawienie wszystkich odpowiedzi (10 krajów z prawidłowymi liczbami zawodników).\n> - **1 pkt** - zestawienie z błędnym grupowaniem (zliczenie WSZYSTKICH kierowców kraju, nie tylko punktujących w 2012).\n> - **0 pkt** - odpowiedź niepełna lub błędna albo brak.\n> - **UWAGA:** Nie przyznaje się 2 pkt.\n\n## Typowe pułapki\n\n- **\"Zdobywali punkty\" = Punkty > 0** - krytyczny warunek. Pominięcie tego filtra to typowy błąd punktowany 1 pkt zamiast 3.\n- **DISTINCT obowiązkowe** - bez niego liczymy wyniki, nie kierowców. Jeden kierowca może mieć 5+ punktujących wyników w 2012.\n- **Filtr sezonu 2012** - bez tego filtra otrzymujemy wszystkich punktujących kierowców z całych 13 sezonów.\n- **Polskie nazwy krajów** - zachowaj pisownię z pliku (Wielka Brytania z dużej, nie \"Wlk. Brytania\").\n- **Sortowanie alfabetyczne** - zalecane (`ORDER BY k.Kraj`), choć nie wymagane.\n\n## Złożoność obliczeniowa\n\n- 2 JOIN-y po kluczach: O(N log N) z indeksami.\n- GROUP BY z DISTINCT (hash set): O(N).\n- ORDER BY: O(K log K), gdzie K = liczba krajów (małe).\n- **Całkowita: O(N log N)**.","image":null,"solution_image":null,"topics":null,"page_from":null,"source":"maturazai","answer_source":null,"answer_text_source":null,"solution_source":"maturazai","text_source":"maturazai","source_label":"Informatyka · Matura · maj 2015 (rozszerzona)","subject_label":"Informatyka","category_label":"Matura"}]}