Matura jako egzamin dojrzałości jest jednym z najważniejszych testów w życiu człowieka — zapewnia nam ona średnie wykształcenie i daje szanse na dobre studia i dobrze płatną pracę. Rozszerzone matury są również poświadczeniem naszej wiedzy z danej dziedziny, jednakże niektóre rozszerzenia nie należą do najłatwiejszych. Jednym z takich rozszerzeń jest informatyka, a ty zapewne znajdujesz się tu, aby poznać jej rozwiązania. Dobrze trafiłeś/aś — przedstawiamy arkusz matury z informatyki 2018 oraz jego rozwiązania z wytłumaczeniem.
Matura z informatyki 2018 — część pierwsza (teoria)
W części pierwszej matury z informatyki znajdziemy 3 zadania, z czego pierwsze i trzecie mają po 3 podpunkty, zaś drugie zadanie dwa podpunkty. Jak w prawie każdym egzaminie maturalnym, na samym końcu znajduje się również niepodlegający ocenie brudnopis. Należało oczywiście pamiętać o odpowiedniej organizacji czasu — na napisanie egzaminu było 60 minut. Przejdźmy zatem do rozwiązywania pierwszej części arkuszu matury z informatyki 2018.
Matura z informatyki 2018 odpowiedzi: Zadanie 1 — analiza
Zanim przejdziemy do rozwiązywania podpunktów proponuje przeanalizować podany w zadaniu algorytm:
![](https://binarnie.pl/wp-content/uploads/2020/10/image.png)
- Użytkownik wprowadza liczbę n
- Program przypisuje dwie zmienne: p równą 1 i q = n (czyli przypisuje liczbę, którą wprowadził użytkownik)
- Następnie program rozpoczyna pętle typu while, z warunkiem p mniejsze od q:
- Przypisujemy zmienną s, która jest liczbą całkowitą, a jej wartość to średnia ze zmiennych p i q (a więc ich średnia „odrzuci” ułamek dziesiętny)
- Jeżeli sześcian liczby s jest mniejszy od liczby, którą wprowadził użytkownik, to liczba p przyjmie wartość s+1.
- W przeciwnym wypadku zmienna q przyjmie wartość zmiennej s.
- Zwróć wartość zmiennej p.
Schemat blokowy tego algorytmu w uproszczeniu wygląda tak:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-5.png)
Zadanie 1 — podpunkt 1
Jak go rozwiązać? „Ręcznie” sprawdzamy krok po kroku działanie algorytmu dla każdej liczby z tabeli, a następnie wpisujemy wartość zmiennej p. Rozwiązanie może być nieco czasochłonne i łatwo tu o pomyłkę, jednak nie powinno z nim być większego problemu. Rozwiązana tabela powinna wyglądać tak:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-1.png)
Zadanie 1 — podpunkt 2
![](https://binarnie.pl/wp-content/uploads/2020/10/image-2.png)
Tutaj należy spojrzeć na to zadanie logicznie. Wynikiem końcowym musi być liczba 10. Taki wynik otrzymamy w sytuacji gdy:
- Zmienna s będzie równa 9 i jednocześnie jej sześcian będzie mniejszy od wprowadzonej liczby — wtedy algorytm zwiększy wartość p o 1, co da nam 10.
- Zmienna p będzie równa 10, a s również 10 — wtedy algorytm przerwie pracę, zwracając nam liczbę dziesięć.
Rozważając pierwszy przypadek powinniśmy otrzymać liczbę większą od 9*9*9, ale też jednocześnie jak najbliższą tej liczbie. 9 do 3 potęgi to 729, a najbliższa, większa liczba to 730. W kolejnym zaś przypadku wiedząc, że s=10 i nie spełnia warunku s^3 < n, to jedyną taką liczbą n, która nie spełnia tego warunku jest… 1000, gdyż jest to liczba równa, ale nie większa od sześcianu zmiennej s. Odpowiedziami są więc 730 i 1000.
Zadanie 1 — podpunkt 3
![](https://binarnie.pl/wp-content/uploads/2020/10/image-4.png)
W tym zadaniu należy obliczyć złożoność obliczeniową algorytmu. Po dokładnej analizie problemu łatwo stwierdzić, iż jest to algorytm o złożoności liniowo—logarytmicznej, co zgadza się z odpowiedzią 2*log2(n). Rozwiązaniem jest więc odpowiedź A.
Matura z informatyki 2018 odpowiedzi: Zadanie 2 — programy
![](https://binarnie.pl/wp-content/uploads/2020/10/image-3.png)
W zadaniu 2 szczególnie ważna jest prawidłowa interpretacja i analiza podanych danych. Istotne będzie również użycie podanych wzorów. W zasadzie to cała matura z informatyki jest oparta na poprawnym zrozumieniu zadań.
Zadanie 2 — podpunkt 1
![](https://binarnie.pl/wp-content/uploads/2020/10/image-6.png)
Do rozwiązania tego zadania możesz użyć dowolnego języka programowania, bądź pseudokodu — dokładnie takiego jaki zawarty był w zadaniu pierwszym. Poniżej znajdziesz kody źródłowe w trzech, dostępnych na maturze językach programowania: Pythonie, Javie i C++:
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
#include <iostream> using namespace std; int main(){ const int n =4; //zmienna n - ilosc szczytow int X[n] = {1, 3, 2, -2}; //tablica X - wspolrzedne X szczytow int Y[n] = {3, 4, 1, 2}; //tablica Y - wspolrzedne Y szczytow int x = X[0]; // zmienna pomocnicza x - szczyt docelowo najbardziej po lewo, poczatkowo przypisano wspolrzedne x pierwszego szczytu ze zbioru int y = Y[0]; // zmienna pomocnicza y - szczyt docelowo najbardziej po lewo, poczatkowo przypisano wspolrzedne y pierwszego szczytu ze zbioru for (int i = 1; i < n; i++){ //petla for - ilosc iteracji zmniejszona o jeden szczyt( bo przypisalismy go jako pierwszy) if((X[i])/((double)Y[i]) < (x)/((double)y)){ //rzutujemy dzielniki do liczby zmiennoprzecinkowej aby nastapilo dzielenie calkowite;jezeli iterowany szczyt jest bardziej po lewo niz ten zapisany x = X[i]; // przypisz y = Y[i]; // nowe wspolrzedne szczytu } } cout << "Wspolrzedne szczytu najbardziej po lewo: (" << x << ", " << y << ");"; } |
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public static void main(String[] args) { int n =4; //zmienna n - ilosc szczytow int[] X= {1, 3, 2, -2}; //tablica X - wspolrzedne X szczytow int[] Y = {3, 4, 1, 2}; //tablica Y - wspolrzedne Y szczytow int x = X[0]; // zmienna pomocnicza x - szczyt docelowo najbardziej po lewo, poczatkowo przypisano wspolrzedne x pierwszego szczytu ze zbioru int y = Y[0]; // zmienna pomocnicza y - szczyt docelowo najbardziej po lewo, poczatkowo przypisano wspolrzedne y pierwszego szczytu ze zbioru for (int i = 1; i < n; i++){ //petla for - ilosc iteracji zmniejszona o jeden szczyt( bo przypisalismy go jako pierwszy) if((X[i])/((double)Y[i]) < (x)/((double)y)){ //rzutujemy dzielniki do liczby zmiennoprzecinkowej aby nastapilo dzielenie calkowite;jezeli iterowany szczyt jest bardziej po lewo niz ten zapisany x = X[i]; // przypisz y = Y[i]; // nowe wspolrzedne szczytu } } System.out.println("Wspolrzedne szczytu najbardziej po lewo: (" + x + ", " + y+")"); } |
Python
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
n =4 #zmienna n - ilosc szczytow X = [1, 3, 2, -2] #tablica X - wspolrzedne X szczytow Y = [3, 4, 1, 2] #tablica Y - wspolrzedne Y szczytow x = X[0] # zmienna pomocnicza x - szczyt docelowo najbardziej po lewo, poczatkowo przypisano wspolrzedne x pierwszego szczytu ze zbioru y = Y[0] # zmienna pomocnicza y - szczyt docelowo najbardziej po lewo, poczatkowo przypisano wspolrzedne y pierwszego szczytu ze zbioru for i in range(n-1): #petla for - ilosc iteracji zmniejszona o jeden szczyt( bo przypisalismy go jako pierwszy) for j in range(n-1): if (X[i])/(float(Y[i])) < (x)/(float(y)): #ponownie wykorzystujemy rzutowanie;jezeli iterowany szczyt jest bardziej po prawo, niz szczyt nastepny x1 = X[j+1] # Nastepuje tutaj y1 = Y[j + 1] # zamiana miejsca szczytow w tabelach X[j + 1] = X[j] # te najbardziej po prawo zostana Y[j + 1] = Y[j] # wyrzucone na sam koniec X[j] = x1 # Jest to tzw. Y[j] = y1 # sortowanie babelkowe. for i in range(n): print("(" + str(X[i]) + "), (" + str(Y[i]) + ")") |
Zadanie 2 — podpunkt 2
![](https://binarnie.pl/wp-content/uploads/2020/10/image-10.png)
Do rozwiązania tego podpunktu potrzebne będzie użycie sortowania. Posłużymy się sortowaniem bąbelkowym, aczkolwiek użycie innego sposobu też byłoby poprawne. Poniżej kody źródłowe w trzech możliwych do wyboru językach programowania:
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
#include <iostream> using namespace std; int main(){ const int n =4; //zmienna n - ilosc szczytow int X[n] = {1, 3, 2, -2}; //tablica X - wspolrzedne X szczytow int Y[n] = {3, 4, 1, 2}; //tablica Y - wspolrzedne Y szczytow for (int i = 0; i < n; i++){ //petla for - ilosc iteracji zmniejszona o jeden szczyt( bo przypisalismy go jako pierwszy) for(int j=0; j<n-1;j++ ){ if((X[j])/(double)(Y[j]) > (X[j+1])/((double)Y[j+1])){ //ponownie wykorzystujemy rzutowanie;jezeli iterowany szczyt jest bardziej po prawo, niz szczyt nastepny int x1 = X[j+1]; // Nastepuje tutaj int y1 = Y[j+1]; // zamiana miejsca szczytow w tabelach X[j+1] = X[j]; // te najbardziej po prawo zostana Y[j+1] = Y[j]; // wyrzucone na sam koniec X[j] = x1; // Jest to tzw. Y[j] = y1; // sortowanie babelkowe. } } } for(int i = 0; i < n; i++){ // wyrzucenie zawartosci tabeli cout << "(" << X[i] << ", " << Y[i] << ") "; } return 0; } |
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
public static void main(String[] args) { int n = 4; //zmienna n - ilosc szczytow int[] X = { 1, 3, 2, -2 }; //tablica X - wspolrzedne X szczytow int[] Y = { 3, 4, 1, 2 }; //tablica Y - wspolrzedne Y szczytow for (int i = 0; i < n; i++) { //petla for - ilosc iteracji zmniejszona o jeden szczyt( bo przypisalismy go jako pierwszy) for (int j = 0; j < n - 1; j++) { if ((X[j + 1]) / ((double) Y[j + 1]) < (X[j]) / (double)(Y[j])) { //ponownie wykorzystujemy rzutowanie;jezeli iterowany szczyt jest bardziej po prawo, niz szczyt nastepny int x1 = X[j + 1]; // Nastepuje tutaj int y1 = Y[j + 1]; // zamiana miejsca szczytow w tabelach X[j + 1] = X[j]; // te najbardziej po prawo zostana Y[j + 1] = Y[j]; // wyrzucone na sam koniec X[j] = x1; // Jest to tzw. Y[j] = y1; // sortowanie babelkowe. } } } for (int i = 0; i < n; i++) { // wyrzucenie zawartosci tabeli System.out.println("(" + X[i] + ", " + Y[i] + ") "); } } |
Python
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
n =4 #zmienna n - ilosc szczytow X = [1, 3, 2, -2] #tablica X - wspolrzedne X szczytow Y = [3, 4, 1, 2] #tablica Y - wspolrzedne Y szczytow for i in range(n-1): #petla for - ilosc iteracji zmniejszona o jeden szczyt( bo przypisalismy go jako pierwszy) for j in range(n-1): if (X[i])/(float(Y[i])) < (X[i+1])/(float(Y[i+1])): #ponownie wykorzystujemy rzutowanie;jezeli iterowany szczyt jest bardziej po prawo, niz szczyt nastepny x1 = X[j+1] # Nastepuje tutaj y1 = Y[j + 1] # zamiana miejsca szczytow w tabelach X[j + 1] = X[j] # te najbardziej po prawo zostana Y[j + 1] = Y[j] # wyrzucone na sam koniec X[j] = x1 # Jest to tzw. Y[j] = y1 # sortowanie babelkowe. for i in range(n): print("(" + str(X[i]) + "), (" + str(Y[i]) + ")") |
Matura z informatyki 2018 odpowiedzi: Zadanie 3 — prawda/fałsz
Cóż tu więcej tłumaczyć — do wykonania tego zadania wymagana była podstawowa wiedza o językach PHP, SQL, JavaScript i o kolorach w standardzie CMYK. Warto pamiętać, że aby zdobyć punkty za jeden podpunkt, należy go bezbłędnie wykonać — jedna skucha = 0 punktów. Odpowiedzi zostały zaznaczone na zdjęciu:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-8.png)
![](https://binarnie.pl/wp-content/uploads/2020/02/Polub-profil-Binarnie.pl_-750x400.png)
Matura z informatyki 2018 rozwiązania — część druga (praktyka)
Składająca się z 3 zadań część 2 egzaminu maturalnego z informatyki, według danych podanych przez CKE, sprawiła większy problem, niż teoretyczna część. Poniżej jednak podamy poprawne odpowiedzi wraz z rozwiazaniami.
Matura z informatyki 2018 odpowiedzi: Zadanie 4 — WEGA
![](https://binarnie.pl/wp-content/uploads/2020/10/image-7.png)
W tym zadaniu bez wątpienia potrzebny będzie program odczytujący dane z pliku — w końcu komu by się chciało szukać pojedynczych liter w 1000 wierszach? Podamy więc prosty program w językach C++, Java i Python, który otworzy plik i wydrukuje w konsoli jego zawartość — modyfikując go wykonamy kolejne polecenia. Plik sygnaly.txt znajdziecie pod tym linkiem.
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
#include <iostream> #include <fstream> using namespace std; int main(){ string line; ifstream file("sygnaly.txt"); // otwieranie - nalezy podac lokalizacje pliku if(file.is_open()){ while (getline (file,line)){ // iteracja linii cout << line << endl; //drukowanie linii } file.close(); // zamkniecie pliku } return 0; } |
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
package matura; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; public class Main { public static void main(String[] args) throws IOException { String line; File f = new File("sygnaly.txt"); // otwieranie - nalezy podac lokalizacje pliku if (!f.exists()) { //sprawdzamy najpierw, czy aby napewno plik istnieje System.out.println("Nie znalezniono pliku"); // jezeli nie, zwracamy komunikat return; } BufferedReader br = new BufferedReader(new FileReader(f)); // w przeciwnmym wypadku tworzymy instancje BufferedReader - czytnika umozliwajacego sprawdzenie zawartosci pliku if (br.ready()) { // jezeli jest on gotowy while ((line = br.readLine()) != null) { // iteracja linii System.out.println(line); } br.close(); // zamkniecie pliku } } } |
Python
1 2 3 4 5 6 7 |
file = open("sygnaly.txt", "r") #otwieranie - nalezy podac lokalizacje pliku i parametr "r" - read if file.closed: #jeżeli plik został zamknięty print("Nie można odnaleźć pliku") #zakończ działanie programu exit(0); for line in file: #wczytuj każdy wiersz z pliku print(line) #i drukuj file.close() #zamknij plik |
Zadanie 4 — podpunkt 1
![](https://binarnie.pl/wp-content/uploads/2020/10/image-9.png)
Modyfikujemy więc powyższy kod tak, aby spełniał warunki zadania:
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
#include <iostream> #include <fstream> using namespace std; int main(){ string line; string final = ""; // inicjalizacja zmiennej przechowujacej finalny tekst ifstream file("sygnaly.txt"); int n = 1; // uzywamy zmiennej pomocniczej, aby przechowac aktualny numer wiersza if(file.is_open()){ while (getline (file,line)){ if(n % 40 == 0) // jezeli wiersz jest wielokrotnoscia liczby 40 final = final + line[9]; // dodaje do finalnego slowa 10 litere wiersza n++; // zwiekszenie liczby wierszy o 1 } file.close(); cout << final; } return 0; } |
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
package matura; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; public class Main { public static void main(String[] args) throws IOException { String line; File f = new File("sygnaly.txt"); // otwieranie - nalezy podac lokalizacje pliku if (!f.exists()) { //sprawdzamy najpierw, czy aby napewno plik istnieje System.out.println("Nie znalezniono pliku"); // jezeli nie, zwracamy komunikat return; } BufferedReader br = new BufferedReader(new FileReader(f)); // w przeciwnmym wypadku tworzymy instancje BufferedReader - czytnika umozliwajacego sprawdzenie zawartosci pliku if (br.ready()) { // jezeli jest on gotowy String Final = ""; // inicjalizacja zmiennej przechowujacej finalny tekst int n = 1; // uzywamy zmiennej pomocniczej, aby przechowac aktualny numer wiersza while ((line = br.readLine()) != null) { // iteracja linii if (n % 40 == 0) // jezeli wiersz jest wielokrotnoscia liczby 40 { Final = Final + line.charAt(9); // dodaje do finalnego slowa 10 litere wiersza } n++; // zwiekszenie liczby wierszy o 1 } br.close(); // zamkniecie pliku System.out.println(Final); //wypisujemy wynik } } } |
Python
1 2 3 4 5 6 7 8 9 10 11 12 |
file = open("sygnaly.txt", "r") #otwieranie - nalezy podac lokalizacje pliku i parametr "r" - read if file.closed: #jeżeli plik został zamknięty print("Nie można odnaleźć pliku") #zakończ działanie programu exit(0); final = "" #zmienna kontener, ktora przechowa slowo n = 1; #zmienna pomocnicza do iteracji for line in file: #wczytuj każdy wiersz z pliku if n % 40 == 0: #co cztedziesta linjke final = final + line[9] #dodaj do wyrazu dziesiata litere z wiersza n += 1 #zwiekszamy zmienna pomocnicza file.close() #zamknij plik print(final) #drukuj wynik |
Wynikiem powyższego programu jest: ZAPISZODPOWIEDZIWPLIKUTXT.
Zadanie 4 — podpunkt 2
![](https://binarnie.pl/wp-content/uploads/2020/10/image-14.png)
W tym zadaniu musimy dla każdego wyrazu stworzyć zbiór unikalnych liter, następnie sprawdzić ich ilość, a następnie porównać z dotychczas znalezionym wynikiem. Zwracamy uwagę, że należy dodać odpowiednią dyrektywę #include <set> w języku C++ oraz zaimportować java.util.ArrayList w Javie. W języku Python musimy wziąć pod uwagę, że przy wczytywaniu znaków z wiersza ostatnim będzie zawsze „\n” oznaczający jego koniec i początek kolejnej linijki.
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
#include <iostream> #include <fstream> #include <set> // NALEZY DODAC TA DYREKTYWE! using namespace std; int main(){ string line; string word; // zmienna przechowujaca najdluzsze slowo ifstream file("sygnaly.txt"); int max = 0; // zmienna przechowujaca dlugosc najdluzsego slowa if(file.is_open()){ while (getline (file,line)){ set<char> chars; // zbior przechowujacy niepowtarzalne literki int f = 0; //ilosc znalezionych niepowatrzalnych literek for(int i = 0; i < line.length(); i++){ //iteracja przez wiersz if(chars.find(line[i]) != chars.end()) //jezeli zbior zawiera juz ta literke continue; //przejdz do nastepnego iterowanego wyrazu chars.insert(line[i]); //dodaj do zbioru nowa literke f++; //zwieksz ilosc znalezionych liter } if(f > max){ //jezeli ilosc znalezionych liter jest wieksza niz dotychczas max = f; // podmien ja word = line; // i wyraz } } file.close(); cout << word << endl << max << " liter"; } return 0; } |
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
package matura; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; import java.util.ArrayList; // należy dodać ten import! public class Main { public static void main(String[] args) throws IOException { String line; String word = ""; // zmienna przechowujaca najdluzsze slowo int max = 0; // zmienna przechowujaca dlugosc najdluzsego slowa File f = new File("sygnaly.txt"); // otwieranie - nalezy podac lokalizacje pliku if (!f.exists()) { //sprawdzamy najpierw, czy aby napewno plik istnieje System.out.println("Nie znalezniono pliku"); // jezeli nie, zwracamy komunikat return; } BufferedReader br = new BufferedReader(new FileReader(f)); // w przeciwnmym wypadku tworzymy instancje BufferedReader - czytnika umozliwajacego sprawdzenie zawartosci pliku if (br.ready()) { // jezeli jest on gotowy while ((line = br.readLine()) != null) { // iteracja linii int k = 0; //ilosc znalezionych niepowatrzalnych litere ArrayList < Character > chars = new ArrayList < Character > (); // zbior przechowujacy niepowtarzalne literki for (int i = 0; i < line.length(); i++) { //iteracja przez wiersz if (chars.contains(line.charAt(i))) //jezeli zbior zawiera juz ta literke continue; //przejdz do nastepnego iterowanego wyrazu chars.add(line.charAt(i)); //w przeciwnym wypadku dodaj do zbioru nowa literke k++; //zwieksz ilosc znalezionych liter } if (k > max) { //jezeli ilosc znalezionych liter jest wieksza niz dotychczas max = k; // podmien ja word = line; // i wyraz } } br.close(); // zamkniecie pliku } System.out.println(word); System.out.println(max + " liter"); // wypisujemy słowo i jego długość } } |
Python
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
file = open("sygnaly.txt", "r") #otwieranie - nalezy podac lokalizacje pliku i parametr "r" - read if file.closed: #jeżeli plik został zamknięty print("Nie można odnaleźć pliku") #zakończ działanie programu exit(0); word = ""# zmienna przechowujaca najdluzsze slowo max = 0 # zmienna przechowujaca dlugosc najdluzsego slowa for line in file: #wczytuj każdy wiersz z pliku k = 0 #ilosc znalezionych niepowatrzalnych literek chars = [] #zbior przechowujacy niepowtarzalne literki for char in line: #iterujemy poprzez znaki wyrazu if chars.__contains__(char) or char == "\n": ## jezeli juz wczesniej znalezlismy ta litere LUB jest to znak nowej linijki continue; #to ja pomijamy chars.append(char); # w przeciwnym razie dodajemy do zbioru k += 1 #i zwiekszamy ilosc znalezionych literek if(k > max): #jezeli ilosc ta bedzie wieksza niz dotychczasowa max = k #to podmieniamy ja word = line #oraz slowo file.close() #zamknij plik print(word) #i drukuj print(str(max) + " liter") #wynik |
Wynikiem programu będzie słowo składające się z 26 liter.
Zadanie 4 — podpunkt 3
![](https://binarnie.pl/wp-content/uploads/2020/10/image-13.png)
W tym podpunkcie posłużymy się faktem, że w języku C++ możliwe jest obliczenie różnicy pomiędzy literkami — da nam ona ich odległość w alfabecie. Tym razem potrzebna będzie potrzebny import biblioteki
<math.h> w języku C++. W Javie korzystamy ze statycznej metody z klasy Math, zaś w Pythonie musimy znowu, tak jak w poprzednim podpunkcie, pominąć znak „\n” przy odczycie:
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
#include <iostream> #include <fstream> #include <math.h> // NALEZY DODAC TA DYREKTYWE! using namespace std; int main(){ string line; string words; // zmienna przechowujaca wyrazy ifstream file("sygnaly.txt"); if(file.is_open()){ while (getline (file,line)){ bool b = true; // zmienna pomocnicza, wskazujaca czy dany wyraz spelnia wymagania for(int i = 0; i<line.length(); i++){ //petla iterujaca poprzez kazda litere if(b){ for (int j = i+1; j < line.length(); j++){ //petla iterujaca przez kazda inna litere, w celu sprawdzenia roznicy int difference = abs(line[i] - line[j]); //obliczenie roznicy if(difference > 10) b=false; } } else break; } if(b) words = words + "\n" + line; //dodanie slowa } file.close(); cout << words; } return 0; } |
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
package matura; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; public class Main { public static void main(String[] args) throws IOException { String line; String words = ""; // zmienna przechowujaca wyrazy File f = new File("sygnaly.txt"); // otwieranie - nalezy podac lokalizacje pliku if (!f.exists()) { //sprawdzamy najpierw, czy aby napewno plik istnieje System.out.println("Nie znalezniono pliku"); // jezeli nie, zwracamy komunikat return; } BufferedReader br = new BufferedReader(new FileReader(f)); // w przeciwnmym wypadku tworzymy instancje BufferedReader - czytnika umozliwajacego sprawdzenie zawartosci pliku if (br.ready()) { // jezeli jest on gotowy while ((line = br.readLine()) != null) { // iteracja linii boolean b = true; // zmienna pomocnicza, wskazujaca czy dany wyraz spelnia wymagania for (int i = 0; i < line.length(); i++) { //petla iterujaca poprzez kazda litere if (b) { for (int j = i + 1; j < line.length(); j++) { //petla iterujaca przez kazda inna litere, w celu sprawdzenia roznicy int diff = Math.abs(line.charAt(i) - line.charAt(j)); //obliczenie roznicy if (diff > 10) b = false; } } else break; } if (b) { words = words + "\n" + line; //dodanie slowa } } br.close(); // zamkniecie pliku } System.out.println(words); // wypisanie wyniku } } |
Python
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
file = open("sygnaly.txt", "r") #otwieranie - nalezy podac lokalizacje pliku i parametr "r" - read if file.closed: #jeżeli plik został zamknięty print("Nie można odnaleźć pliku") #zakończ działanie programu exit(0) words = "" for line in file: #wczytuj każdy wiersz z pliku b = True #zmienna pomocnicza, wskazujaca czy dany wyraz spelnia wymagania for char in line: #petla iterujaca poprzez kazda litere if char == "\n": # musimy znowu sprawdzic, czy nie natrafilismy na znak rozpoczynajacy nastepny wiersz continue if b: for char2 in line[1:]: #petla iterujaca przez kazda inna litere, w celu sprawdzenia roznicy if char2 == "\n": # musimy znowu sprawdzic, czy nie natrafilismy na znak rozpoczynajacy nastepny wiersz continue diff = abs(ord(char) - ord(char2)) #obliczenie roznicy if diff > 10: #jezeli roznica jest wieksza niz 10 b = False #nie dodawaja tego wyrazu do listy else: break if b: words = words + "\n" + line #jezeli jednak wyraz spelnial wymogi, dodaj go do listy file.close() #zamknij plik print(words) #i drukuj wynik |
Matura z informatyki 2018: zadanie 5 — wylewy Wirki
![](https://binarnie.pl/wp-content/uploads/2020/10/image-11.png)
W tym zadaniu dostajemy nieco większe pole do popisu — do dyspozycji mamy wszelkie narzędzia informatyczne dostępne pod ręką. Możliwe jest więc napisanie specjalnego programu do odczytu danych, jednakże znacznie lepszym rozwiązaniem będzie tutaj wykorzystanie importu danych w programie Microsoft Excel. Przedstawiamy krok po kroku jak to zrobić:
- Wybieramy Dane>Z tekstu
- Wybieramy plik z danymi
- Bez zmian.
- Również bez zmian.
- Należy zmienić format daty, tak jak na zdjęciu:
- Tutaj bez zmian.
- Warto również „obniżyć” dane (ctrl+a, a następnie przesunąć myszką o jeden wiersz w dół), aby dodać tytuły kolumn:
Zadanie 5 — podpunkt 1
![](https://binarnie.pl/wp-content/uploads/2020/10/image-12.png)
Gdy już zaimportowaliśmy dane i podzieliliśmy je na kolumny, należy stworzyć kolejną kolumnę, w której będą wyciągnięte jedynie lata z podanej daty. Do tego przyda nam się formułą ROK — w komórce C1 wpisujemy tytuł kolumny „Rok”, a w komórce C2 wpisujemy formułe =ROK(A2). Następnie łapiemy myszką za mały kwadracik i przeciągamy aż do ostatniego wiersza.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-15.png)
Następnym krokiem jest wykorzystanie Sumy częściowej z zakładki dane:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-16.png)
Okienko wypełniamy tak jak na powyższym obrazku. Zwracamy uwagę, że aby uruchomić sumę częściową należy najpierw zaznaczyć obszar, w którym są dane (można użyć ctrl+a). Następnie, po kliknięciu OK, z boku pojawią się 3 zakładki. Wchodzimy w zakładkę numer 2, a następnie rozszerzamy kolumnę m3.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-18.png)
Następnie zaznaczamy wartości w kolumnie m3, klikamy prawym przyciskiem myszy i należy wybrać Sortuj>Sortuj od największej do najmniejszej. Po tej operacji na samej górze ujrzymy rok, w którym zbiornik został zasilony największą ilością wody.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-20.png)
![](https://binarnie.pl/wp-content/uploads/2020/10/image-21.png)
Odpowiedzią jest rok 2015.
Zadanie 5 — podpunkt 2
![](https://binarnie.pl/wp-content/uploads/2020/10/image-17.png)
W tym zadaniu musimy po 1. znaleźć dni, w których ilość wody przekracza 10000 m3, a następnie należy odnaleźć najdłuższy okres, w którym te wartości się utrzymywały. W tym celu utworzymy kolejne kolumny z nowymi formułami, jednakże zanim do tego przejdziemy należy posortować całą kolumnę Data — od najstarszej do najnowszej:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-19.png)
Następnie tworzymy kolumnę Czy więcej niż 10000? — w pierwszej komórce pod tytułem zamieszczamy zaś formułę =JEŻELI(B2>10000;”TAK”;”NIE”), a następnie „przeciągamy” ją na całą kolumnę. Teraz gdy w danym dniu było więcej niż 10000 m3 wody, to komórka przyjmie wartość TAK, a w przeciwnym wypadku NIE.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-22.png)
Następnie tworzymy kolumnę Ilość dni pod rząd, a w pierwszej komórce formuła =JEŻELI(C1=”TAK”;1+D1;0). Komórki będą przyjmować wartość o 1 większą od poprzedniej, jeżeli nadal ilość wody będzie przekraczać 10000 m3.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-25.png)
Teraz, dla ułatwienia, można stworzyć kolumnę Maksymalna ilość dni, w której wybierzemy z całego okresu największą ilość dni pod rząd, aby potem było łatwiej ją odszukać.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-23.png)
Gdy już mamy maksymalną ilość dni odszukujemy ją, a następnie odczytujemy zakres dat.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-24.png)
Odpowiedzią jest więc 55 dni, w okresie od 2015—03—17, do 2015—05—10.
Zadanie 5 — podpunkt 3
![](https://binarnie.pl/wp-content/uploads/2020/10/image-28.png)
W tym zadaniu wykorzystamy ponownie sumę częściową. Utworzymy w tym celu nową kolumnę Miesiąc z komórkami używającymi formuły =MIESIĄC.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-26.png)
Tutaj znów pomocne będzie posortowanie danych według daty — łatwiej będzie zaznaczyć dane z kolumny m3.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-30.png)
Tworzymy kolejną kolumnę, a następnie wpisujemy formułę tak jak na obrazku. Następnie „przeciągamy” daną formułę na całą kolumnę.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-29.png)
Następnym krokiem jest wygenerowanie sumy częściowej. W tym celu zaznaczamy wszystkie komórki (ctrl+a), a potem wybieramy Suma częściowa, z zakładki Dane. Okienko uzupełniamy tak jak pokazano na obrazku powyżej.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-27.png)
Teraz zaznaczamy dane z interesującego nas okresu (jeżeli posortowałeś daty, to będą to pierwsze 13 wierszy). Dobrym pomysłem jest ich przeniesienie do nowego arkusza, aby ułatwić tworzenie wykresu. W tym celu należy wcisnąć klawisz F5, wybrać Specjalnie…>Tylko widoczne komórki, a potem skopiować i wkleić w nowym arkuszu.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-31.png)
Po odpowiednim ułożeniu danych można przystąpić do tworzenia wykresu kolumnowego z zakładki Wstawianie. Ważne jest, aby odpowiednio podpisać wykres.
Zadanie 5 — podpunkt 4
![](https://binarnie.pl/wp-content/uploads/2020/10/image-32.png)
- W tym celu należy utworzyć dodatkowe kolumny z formułami takimi, jak na zdjęciach: Formuła =JEZELI jest tu wymagana ze względu na fakt, że objętość wody była obniżana równo do 1 miliona m3 w sytuacji, gdy go przekroczyła. Trzecia kolumna jest kolumną pomocniczą ułatwiającą znalezienie pierwszego dnia, w którym woda była upuszczana. Zwracam uwagę, że sprawdza ona, czy objętość jest większa lub równa 1000001 metrów sześciennych — pozwoli to uniknąć sytuacji, gdzie poziom wody po zasileniu byłby dokładnie równy 1000000 m3. Następnym krokiem jest złapanie za trzy komórki z nowo utworzonych kolumn i przeciągnięcie ich na wszystkie dane. Z arkusza jasno wynika, że pierwszym takim dniem był 19.04.2015.
- W tym podpunkcie wystarczy utworzyć dodatkową kolumnę Czy więcej niż 800000m3?, a w pierwszej komórce umieścić odpowiednią formułę, a następnie rozszerzyć ją na całą kolumnę: Następnie wystarczy utworzyć kolumnę zliczającą wszystkie komórki z utworzonego przedziału: Odpowiedź to 188 dni.
- W tym celu wystarczy po prostu zmodyfikować poprzednio wykorzystywaną formułę w komórce C2, a następnie należy ją rozszerzyć na całą kolumnę: Potem już tylko trzeba znaleźć maksymalną zawartość z kolumny C: Odpowiedź to 1 399 242 m3.
![grupa wsparcia matura z informatyki](https://binarnie.pl/wp-content/uploads/2019/10/matura-z-informatyki-grupa-fb.png)
Matura z informatyki 2018 arkusz — zadanie 6
![](https://binarnie.pl/wp-content/uploads/2020/10/image-34.png)
![](https://binarnie.pl/wp-content/uploads/2020/10/image-35.png)
Po przejrzeniu i analizie danych z plików komputery.txt, awarie.txt oraz naprawy.txt od razu widać, że są to powiązane ze sobą tabele bazy danych. Można by tutaj użyć phpMyAdmin, jednakże ze względu na przyjaźniejszy interfejs i wygodę importu najlepiej skorzystać z programu Microsoft Access. Rozpoczniemy więc od zaimportowania tabel. Ze względu na relacje należy wgrać je w kolejności komputery > awarie > naprawy.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-33.png)
Wybieramy Dane zewnętrzne>Nowe źródło danych > Plik tekstowy, a następnie wybieramy plik komputery.txt. W kolejnych krokach postępuj tak jak pokazano na obrazkach.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-36.png)
![](https://binarnie.pl/wp-content/uploads/2020/10/image-37.png)
![](https://binarnie.pl/wp-content/uploads/2020/10/image-40.png)
![](https://binarnie.pl/wp-content/uploads/2020/10/image-38.png)
Procedurę importu powtarzamy analogicznie dla plików awarie i naprawy. UWAGA: Przy imporcie pozostałych plików w drugim okienku należy kliknąć Zaawansowane i zmienić format daty na RMD.
Kolejnym krokiem jest utworzenie relacji. Wybieramy Narzędzia bazy danych>Relacje i tworzymy relacje zgodnie z obrazkiem:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-39.png)
Z tak przygotowaną bazą danych możemy przystąpić do rozwiązywania zadania.
Zadanie 6 — podpunkt 1
![](https://binarnie.pl/wp-content/uploads/2020/10/image-41.png)
Wykorzystamy kwerendę — w tym celu wchodzimy w Tworzenie>Kreator kwerend, a następnie dodajemy tabelę Komputery.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-42.png)
Musimy wybrać kolumnę Pojemnosc_dysku dwukrotnie tak jak na zdjęciu. Następnie klikamy Sumy w prawym górnym rogu, po czym uzupełniamy projekt tak jak na zdjęciu. Na koniec należy ograniczyć ilość wyszukanych wyników do 10 tuż obok przycisku Sumy.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-43.png)
Wynik kwerendy powinien być taki, jak na zdjęciu.
Zadanie 6 — podpunkt 2
![](https://binarnie.pl/wp-content/uploads/2020/10/image-44.png)
Tym razem w kwerendzie potrzebować będziemy wszystkich tabel — niestety w tabeli Naprawy brakuje odwołania do tabeli Komputery, dlatego trzeba posłużyć się tabelą Awarie.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-45.png)
Uzupełniamy projekt o wymogi zadania, pamiętając aby zwracać uwagę na wielkość liter przy kryteriach.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-47.png)
Wynik działania kwerendy widoczny jest na obrazku.
Zadanie 6 — podpunkt 4
![](https://binarnie.pl/wp-content/uploads/2020/10/image-46.png)
W tym celu potrzebne będzie utworzenie trzech kwerend pomocniczych:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-48.png)
Pierwsza kwerenda zliczająca ilość awarii w danym dni i dla każdej sekcji.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-51.png)
Druga kwerenda zliczająca ilość komputerów w danej sekcji.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-52.png)
Ostatnia kwerenda, która porównuje dwie poprzednie — da nam ona rozwiązanie zadania:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-49.png)
Zadanie 6 — podpunkt 4
![](https://binarnie.pl/wp-content/uploads/2020/10/image-50.png)
W tym podpunkcie do kwerendy potrzebne będą nam dwie tabele: awarie i naprawy. Obliczymy różnice czasu pomiędzy naprawą, a zgłoszeniem awarii, posortujemy wyniki, ograniczymy je do jednego i wydrukujemy pożądane dane — wszystko widoczne jest na obrazku:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-53.png)
Kwerenda ta daje nam wynik:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-55.png)
Zadanie 6 — podpunkt 5
![](https://binarnie.pl/wp-content/uploads/2020/10/image-54.png)
W tym podpunkcie wymagane będzie stworzenie kilku pomocniczych kwerend:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-56.png)
Pierwsza kwerenda wybierająca komputery, które miały awarie o priorytecie większym lub równym 8. Dlaczego tak? Dlatego, że odejmując ilość takich awarii od ilości wszystkich komputerów uzyskamy liczbę komputerów, które nie miały takich awarii.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-58.png)
Następna kwerenda będzie miała za zadanie zliczenie komputerów z poprzedniej kwerendy.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-59.png)
Kolejna kwerenda zliczy ilość wszystkich komputerów.
![](https://binarnie.pl/wp-content/uploads/2020/10/image-57.png)
Ostatnia, najważniejsza kwerenda będzie miała za zadanie obliczenie różnicy pomiędzy zliczonymi komputerami. Dzięki temu otrzymamy wynik i odpowiedź na pytanie:
![](https://binarnie.pl/wp-content/uploads/2020/10/image-60.png)
A więc odpowiedź to 149 komputerów.