ROZWIĄZANIA: Matura z informatyki – maj 2024 | Korepetycje do matury z informatyki

6 grudnia 2024
Posted by: Damian
Category: Baza wiedzy

Znajdziesz tu rozwiązania matury z informatyki 2024 w formule 2023, z pomocą programu Microsoft Access (SQL) oraz języków programowania C++, Java i Python. Załączniki wymagane do poszczególnych zadań znajdziesz w tym linku.

Spis treści

1 Zadanie 1 – Plansza

3 Zadanie 3 – Nieparzysty skrót

3.1 Zadanie 3.1.

3.2 Zadanie 3.2.

3.3 Zadanie 3.3.

4 Pełny kod 3.1 – 3.3 – implementacja w python, C++ i java

6 Pełny kod 4.1 – 4.4 – implementacja w python, C++ i java

7 Zadanie 5 – Test

8 Zadanie 6 – Systemy pozycyjne

9 Zadanie 7 – Hurtownia

10 Zadanie 8 – Rejestr wykroczeń

Zadanie 1 – Plansza

Rozwiązanie matura z informatyki 2024 - Zadanie 1 — Zadanie 1 – Plansza z arkusza maturalnego z informatyki maj 2024

Przed podejściem do rozwiązywania, pomocna może okazać się próba zrozumienia algorytmu, jeśli uda się to zrobić już na początku, wszystkie podpunkty powinny okazać się proste.

W pierwszej linijce po prostu upewniamy się, że pierwsza komórka jest biała i inne komórki będą mogły kopiować jej wartość. W następnych dwóch linijkach są pętle, które będą przechodziły po kolejnych komórkach tablicy P i A. Zmienna i odpowiada za indeks wiersza, a zmienna j za indeks kolumny. Jak widać będziemy przechodzić najpierw po wszystkich kolumnach i dopiero wtedy zmienimy wiersz.

Pierwszy warunek po prostu sprawia, że gdy wartość A[i]][j] = 0, to odpowiadająca wartość w tablicy P to FAŁSZ. Dlatego podczas analizy algorytmu wszystkie pola tablicy P, które odpowiadają czarnym polom ustawiamy na FAŁSZ. Następny warunek dotyczy i = 1, czyli pierwszego wiersza poza pierwszą komórką (j≠1). Widzimy, że każda komórka kopiuje wartość tej z poprzedniej kolumny prócz przypadku gdy A[i][j] = 0. Kolejny warunek dotyczy pierwszej kolumny, działa tak samo jak poprzedni tylko zamiast kopiować z poprzedniej kolumny, kopiujemy wartość z poprzedniego wiersza. Ostatni warunek dotyczy komórek, które nie leżą ani w pierwszym wierszu, ani w pierwszej komórce. Jeśli komórka po lewej lub wyżej ma wartość PRAWDA to też wstawiamy PRAWDA, lub FAŁSZ w przeciwnym przypadku. Na koniec zwracamy wartość komórki o indeksach [n][m] (czyli prawy dolny róg tablicy).

Algorytm normalnie wykonuje operacje po kolei dla każdego pola, zaczynając od pierwszego wiersza, gdy wpisze wartości we wszystkie komórki, przechodzi do kolejnego wiersza i tak dalej, aż do końca. Jednak wiedząc jak działa algorytm możemy nieco to zmienić, żeby było to dla nas wygodniejsze.

Dobrze narysować sobie w brudnopisie tabelę o identycznych wymiarach jak ta w zadaniu i działać w następujący sposób (F – FAŁSZ, P – PRAWDA):

W lewym górnym rogu tabeli wpisujemy P.
We wszystkie komórki o tych samych indeksach co czarne pola w danej tabeli wstawiamy F.
Uzupełniamy cały pierwszy wiersz, kopiując wartości poprzednich kolumn, chyba że już mają wartość F.
Uzupełniamy całą pierwszą kolumnę kopiując wartości poprzednich wierszy, chyba że już mają wartość F.
Następnie przechodzimy do uzupełniania komórek (prócz pierwszego wiersza i kolumny), idziemy po kolejnych kolumnach i zmieniamy wiersz na kolejny jak skończą się w nim komórki. Patrzymy czy w sąsiednich komórkach na górze i po lewej jest jakiekolwiek P. Jeśli tak, to wpisujemy P, inaczej wstawiamy tam F.
Wynik naszego algorytmu to wartość w prawym dolnym rogu tabeli.

Zadanie 1.1.

Rozwiązanie:

a) Tabela P:

	1	2	3
1	P	P	P
2	F	P	F
3	F	P	P

Wynik: PRAWDA

b) Tabela P:

	1	2	3
1	P	P	P
2	F	F	P
3	F	F	P
4	F	F	F
5	F	F	F

Wynik: FAŁSZ

c) Tabela P:

	1	2	3	4	5
1	P	F	F	F	F
2	P	P	F	F	F
3	F	P	F	F	F
4	F	P	P	P	F
5	F	P	F	P	P

Wynik: PRAWDA

Zadanie 1.2.

Rozwiązanie:

Wiemy już, że ostatnia komórka szuka wartości PRAWDA w komórce na górze i po lewej, wystarczy więc zamalować te dwa kwadraty.

	1	2	3	4	5
1
2
3
4
5

Teraz wystarczy że przykładowo w pierwszej kolumnie będą same wartości PRAWDA i w ostatnim wierszu również będzie tylko PRAWDA.

	1	2	3	4
1
2
3
4
5

Zadanie 1.3.

Jak widać nasz algorytm tak naprawdę sprawdza czy istnieje biała droga z lewego górnego rogu do prawego dolnego rogu (idąc tylko w prawo lub w dół). Najprostsza droga jaką możemy stworzyć, to ta jaką stworzyliśmy w podpunkcie 1.2 b) gdzie na 16 pól zostało zamalowanych 9. Zauważmy że w tym przypadku n = 4, 16 = 4², a 9 = 3², więc czyżby nasz wzór wyglądał tak: (n-1)²?

Jeśli cała kolumna ma być biała to już jest n pól, teraz dodajemy do tego cały dolny wiersz poza pierwszą komórką, czyli mamy n + n – 1 = 2n – 1. Jeśli teraz od wszystkich komórek n² odejmiemy liczbę białych pól, to otrzymamy: n² – 2n + 1 i ze wzoru skróconego mnożenia możemy otrzymać (n-1)², czyli nasz początkowy wzór jest poprawny!

Rozwiązanie:

(n-1)²

Zadanie 2 – Cyfry

Rozwiązanie matura z informatyki 2024 - Zadanie 2 — Zadanie 2 – Cyfry z arkusza maturalnego z informatyki maj 2024

Zadanie drugie również opiera się na analizie algorytmu. Tak samo jak w przypadku zadania pierwszego warto najpierw zrozumieć algorytm. Już na pierwszy rzut oka widać, że jest to algorytm modyfikujący w jakiś sposób cyfry z podanej liczby. Zmienna b przechowuje kolejne potęgi 10, z kolei c “zbiera” kolejne cyfry i tworzy nową liczbę, natomiast zmienna a przechowuje aktualnie badaną cyfrę.

W zasadzie jedyne co przykuwa uwagę to warunek jeżeli. Jeśli dana cyfra jest parzysta to dzieli ją na dwie i “przykleja” do liczby, z kolei jeżeli liczba jest nieparzysta to w jej miejsce wstawiana jest jedynka. Przykładowo n = 123456, wtedy wynik to c = 111213. Z tą wiedzą czas wziąć się za rozwiązywanie.

Zadanie 2.1.

Po prostu przepisujemy liczby z pierwszej kolumny do drugiej, dzieląc liczby parzyste na dwie i zmieniając liczby nieparzyste na jeden. Instrukcja opisana w trzeciej kolumnie wykonuje się, kiedy dana liczba jest nieparzysta, więc wystarczy policzyć ile cyfr nieparzystych ma liczba w pierwszej kolumnie i wpisać uzyskaną wartość.

Rozwiązanie:

n	Wartość c po wykonaniu algorytmu dla danego n	Liczba wykonań instrukcji c ← c + b
33658	11314	3
542102	121101	2
87654321012345678	41312111011121314	8

Zadanie 2.2.

Niezależnie od tego czy będziemy liczyć cyfry od lewej czy od prawej, wynik się nie zmieni, bo zarówno cyfra 3 jak i 9 jest nieparzysta. Nasza liczba to 333333666666999999 lub 333333666666999999.

Rozwiązanie:

Wystarczy zastosować algorytm, dzięki czemu uzyskamy wartość 111111333333111111.

Zadanie 3 – Nieparzysty skrót

Rozwiązanie matura z informatyki 2024 - Zadanie 3 — Zadanie 3 – Nieparzysty skrót z arkusza maturalnego z informatyki maj 2024

Zadanie 3.1.

Możemy na dobrą sprawę lekko zmodyfikować algorytm z poprzedniego zadania, zmieniając oczywiście nazwy zmiennych na bardziej odpowiednie. Jednak algorytm jest tak prosty, że lepiej napisać go od początku, żeby na pewno wszystko przemyśleć.

potega ← 1
m ← 0
dopóki n>0 wykonuj
    cyfra ← n mod 10
    jeżeli cyfra mod 2 = 1
        m ← m + potega * cyfra
        potega ← potega * 10
    n ← n div 10
zwróć m

potega ← 1

m ← 0

dopóki n>0 wykonuj

cyfra ← n mod 10

jeżeli cyfra mod 2 = 1

m ← m + potega * cyfra

potega ← potega * 10

n ← n div 10

zwróć m

Całość algorytmu jest dość standardowa poza warunkiem, który przed doklejeniem cyfry sprawdza czy jest nieparzysta. Trzeba zwrócić uwagę na to, że fragment potega ⬅ potega * 10, też jest umieszczony w warunku ponieważ nie chcemy zamiast cyfr parzystych wstawiać 0. Chcemy, żeby nie było ich wcale. Dla sprawdzenia można zawsze napisać to samo w pythonie i zobaczyć czy działa.

Rozwiązanie:

Implementacja – Python

def skrotLiczba(liczba):
    potega = 1
    wynik = 0
    while liczba > 0:
        cyfra = liczba % 10
        if cyfra % 2 == 1:
            wynik = potega*cyfra+wynik
            potega = potega*10
        liczba = liczba//10
    return wynik

def skrotLiczba(liczba):

potega = 1

wynik = 0

while liczba > 0:

cyfra = liczba % 10

if cyfra % 2 == 1:

wynik = potega*cyfra+wynik

potega = potega*10

liczba = liczba//10

return wynik

Implementacja – C++

#include <iostream>

using namespace std;

int skrotLiczba(int liczba) {
    int potega = 1;
    int wynik = 0;

    while (liczba > 0) {
        int cyfra = liczba % 10;  // Wyciągamy ostatnią cyfrę
        if (cyfra % 2 == 1) { 	// Sprawdzamy, czy cyfra jest nieparzysta
            wynik = potega * cyfra + wynik;
            potega = potega * 10;
        }
        liczba = liczba / 10; 	// Usuwamy ostatnią cyfrę
    }

    return wynik;
}

#include <iostream>

using namespace std;

int skrotLiczba(int liczba) {

int potega = 1;

int wynik = 0;

while (liczba > 0) {

int cyfra = liczba % 10; // Wyciągamy ostatnią cyfrę

if (cyfra % 2 == 1) { // Sprawdzamy, czy cyfra jest nieparzysta

wynik = potega * cyfra + wynik;

potega = potega * 10;

}

liczba = liczba / 10; // Usuwamy ostatnią cyfrę

}

return wynik;

}

Implementacja – Java

import java.util.Scanner;

public class Main {
    public static int skrotLiczba(int liczba) {
        int potega = 1;
        int wynik = 0;

        while (liczba > 0) {
            int cyfra = liczba % 10;  // Wyciągamy ostatnią cyfrę
            if (cyfra % 2 == 1) { 	// Sprawdzamy, czy cyfra jest nieparzysta
                wynik = potega * cyfra + wynik;
                potega = potega * 10;
            }
            liczba = liczba / 10; 	// Usuwamy ostatnią cyfrę
        }
    return wynik;
    }
}

import java.util.Scanner;

public class Main {

public static int skrotLiczba(int liczba) {

int potega = 1;

int wynik = 0;

while (liczba > 0) {

int cyfra = liczba % 10; // Wyciągamy ostatnią cyfrę

if (cyfra % 2 == 1) { // Sprawdzamy, czy cyfra jest nieparzysta

wynik = potega * cyfra + wynik;

potega = potega * 10;

}

liczba = liczba / 10; // Usuwamy ostatnią cyfrę

}

return wynik;

}

Zadanie 3.2.

Teraz i tak należy napisać funkcję w prawdziwym języku programowania, więc można upewnić się, czy odpowiedź z zadania 3.1 na pewno jest poprawna.

Implementacja – Python

def skrotLiczba(liczba):
    potega = 1
    wynik = 0
    while liczba > 0:
        cyfra = liczba % 10
        if cyfra % 2 == 1:
            wynik = potega*cyfra+wynik
            potega = potega*10
        liczba = liczba//10
    return wynik

with open("skrot.txt") as plik:
    linie = plik.readlines()
    for i in range(len(linie)):
        linie[i] = int(linie[i])

bezSkrotu = []
for liczba in linie:
    if skrotLiczba(liczba) == 0:
        bezSkrotu.append(liczba)
print(len(bezSkrotu),max(bezSkrotu))

def skrotLiczba(liczba):

potega = 1

wynik = 0

while liczba > 0:

cyfra = liczba % 10

if cyfra % 2 == 1:

wynik = potega*cyfra+wynik

potega = potega*10

liczba = liczba//10

return wynik

with open("skrot.txt") as plik:

linie = plik.readlines()

for i in range(len(linie)):

linie[i] = int(linie[i])

bezSkrotu = []

for liczba in linie:

if skrotLiczba(liczba) == 0:

bezSkrotu.append(liczba)

print(len(bezSkrotu),max(bezSkrotu))

Implementacja – C++

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

using namespace std;

int skrotLiczba(int liczba) {
    int potega = 1;
    int wynik = 0;

    while (liczba > 0) {
        int cyfra = liczba % 10;
        if (cyfra % 2 == 1) {
            wynik = potega * cyfra + wynik;
            potega *= 10;
        }
        liczba /= 10;
    }

    return wynik;
}

int main() {
    ifstream plik("skrot.txt");
    vector<int> linie;

    if (plik.is_open()) {
        int liczba;
        while (plik >> liczba) {
            linie.push_back(liczba);
        }
        plik.close();
    } else {
        cout << "Nie udalo sie otworzyc pliku!" << endl;
        return 1;
    }

    vector<int> bezSkrotu;

    for (int liczba : linie) {
        if (skrotLiczba(liczba) == 0) {
            bezSkrotu.push_back(liczba);
        }
    }

    if (!bezSkrotu.empty()) {
        cout << bezSkrotu.size() << " ";
        cout << *max_element(bezSkrotu.begin(), bezSkrotu.end());
    } else {
        cout << "Brak liczb bez skrotu" << endl;
    }

    return 0;
}

#include <iostream>

#include <fstream>

#include <vector>

#include <algorithm>

using namespace std;

int skrotLiczba(int liczba) {

int potega = 1;

int wynik = 0;

while (liczba > 0) {

int cyfra = liczba % 10;

if (cyfra % 2 == 1) {

wynik = potega * cyfra + wynik;

potega *= 10;

}

liczba /= 10;

}

return wynik;

}

int main() {

ifstream plik("skrot.txt");

vector<int> linie;

if (plik.is_open()) {

int liczba;

while (plik >> liczba) {

linie.push_back(liczba);

}

plik.close();

} else {

cout << "Nie udalo sie otworzyc pliku!" << endl;

return 1;

}

vector<int> bezSkrotu;

for (int liczba : linie) {

if (skrotLiczba(liczba) == 0) {

bezSkrotu.push_back(liczba);

}

if (!bezSkrotu.empty()) {

cout << bezSkrotu.size() << " ";

cout << *max_element(bezSkrotu.begin(), bezSkrotu.end());

} else {

cout << "Brak liczb bez skrotu" << endl;

}

return 0;

}

Implementacja – Java

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static int skrotLiczba(int liczba) {
        int potega = 1;
        int wynik = 0;

        while (liczba > 0) {
            int cyfra = liczba % 10;
            if (cyfra % 2 == 1) {
                wynik = potega * cyfra + wynik;
                potega *= 10;
            }
            liczba /= 10;
        }

        return wynik;
    }

    public static void main(String[] args) {
        List<Integer> linie = new ArrayList<>();

        try (BufferedReader br = new BufferedReader(new FileReader("skrot.txt"))) {
            String linia;
            while ((linia = br.readLine()) != null) {
                linie.add(Integer.parseInt(linia));
            }
        } catch (IOException e) {
            System.out.println("Nie udalo sie otworzyc pliku!");
            e.printStackTrace();
            return;
        }

        List<Integer> bezSkrotu = new ArrayList<>();

        for (int liczba : linie) {
            if (skrotLiczba(liczba) == 0) {
                bezSkrotu.add(liczba);
            }
        }

        if (!bezSkrotu.isEmpty()) {
            System.out.println(bezSkrotu.size()+" "+Collections.max(bezSkrotu));
        } else {
            System.out.println("Brak liczb bez skrotu");
        }
    }
}

import java.io.*;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class Main {

public static int skrotLiczba(int liczba) {

int potega = 1;

int wynik = 0;

while (liczba > 0) {

int cyfra = liczba % 10;

if (cyfra % 2 == 1) {

wynik = potega * cyfra + wynik;

potega *= 10;

}

liczba /= 10;

}

return wynik;

}

public static void main(String[] args) {

List<Integer> linie = new ArrayList<>();

try (BufferedReader br = new BufferedReader(new FileReader("skrot.txt"))) {

String linia;

while ((linia = br.readLine()) != null) {

linie.add(Integer.parseInt(linia));

}

} catch (IOException e) {

System.out.println("Nie udalo sie otworzyc pliku!");

e.printStackTrace();

return;

}

List<Integer> bezSkrotu = new ArrayList<>();

for (int liczba : linie) {

if (skrotLiczba(liczba) == 0) {

bezSkrotu.add(liczba);

}

if (!bezSkrotu.isEmpty()) {

System.out.println(bezSkrotu.size()+" "+Collections.max(bezSkrotu));

} else {

System.out.println("Brak liczb bez skrotu");

}

Po imporcie wystarczy stworzyć listę do której będziemy dodawać liczby dla których wynik to 0 (0 oznacza, że nie została dodana żadna liczba nieparzysta). Na koniec wypisujemy za pomocą print długość tablicy oraz używamy funkcji max(), żeby znaleźć największą z nich.

Rozwiązanie:

Ile: 18
Największa: 28422

Zadanie 3.3.

Implementacja – Python

from math import *
def skrotLiczba(liczba):
    potega = 1
    wynik = 0
    while liczba > 0:
        cyfra = liczba % 10
        if cyfra % 2 == 1:
            wynik = potega*cyfra+wynik
            potega = potega*10
        liczba = liczba//10
    return wynik


with open("skrot2.txt") as plik:
    linie = plik.readlines()
    for i in range(len(linie)):
        linie[i] = int(linie[i])


    for liczba in linie:
        if gcd(liczba,skrotLiczba(liczba)) == 7:
            print(liczba)

from math import *

def skrotLiczba(liczba):

potega = 1

wynik = 0

while liczba > 0:

cyfra = liczba % 10

if cyfra % 2 == 1:

wynik = potega*cyfra+wynik

potega = potega*10

liczba = liczba//10

return wynik

with open("skrot2.txt") as plik:

linie = plik.readlines()

for i in range(len(linie)):

linie[i] = int(linie[i])

for liczba in linie:

if gcd(liczba,skrotLiczba(liczba)) == 7:

print(liczba)

Implementacja – C++

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

using namespace std;

// Funkcja do obliczenia GCD (największy wspólny dzielnik)
int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

// Funkcja do obliczenia "skrótu" liczby
int skrotLiczba(int liczba) {
    int potega = 1;
    int wynik = 0;

    while (liczba > 0) {
        int cyfra = liczba % 10;
        if (cyfra % 2 == 1) {
            wynik = potega * cyfra + wynik;
            potega *= 10;
        }
        liczba /= 10;
    }

    return wynik;
}

int main() {
    ifstream plik("skrot2.txt");
    vector<int> linie;

    if (plik.is_open()) {
        int liczba;
        while (plik >> liczba) {
            linie.push_back(liczba);
        }
        plik.close();
    } else {
        cout << "Nie udalo sie otworzyc pliku!" << endl;
        return 1;
    }

    // Przetwarzanie liczb
    for (int liczba : linie) {
        int skrot = skrotLiczba(liczba);
        if (gcd(liczba, skrot) == 7) {
            cout << liczba << endl;
        }
    }

    return 0;
}

#include <iostream>

#include <fstream>

#include <vector>

#include <algorithm>

using namespace std;

// Funkcja do obliczenia GCD (największy wspólny dzielnik)

int gcd(int a, int b) {

while (b != 0) {

int temp = b;

b = a % b;

a = temp;

}

return a;

}

// Funkcja do obliczenia "skrótu" liczby

int skrotLiczba(int liczba) {

int potega = 1;

int wynik = 0;

while (liczba > 0) {

int cyfra = liczba % 10;

if (cyfra % 2 == 1) {

wynik = potega * cyfra + wynik;

potega *= 10;

}

liczba /= 10;

}

return wynik;

}

int main() {

ifstream plik("skrot2.txt");

vector<int> linie;

if (plik.is_open()) {

int liczba;

while (plik >> liczba) {

linie.push_back(liczba);

}

plik.close();

} else {

cout << "Nie udalo sie otworzyc pliku!" << endl;

return 1;

}

// Przetwarzanie liczb

for (int liczba : linie) {

int skrot = skrotLiczba(liczba);

if (gcd(liczba, skrot) == 7) {

cout << liczba << endl;

}

return 0;

}

Implementacja – Java

import java.io.*;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

public class Main {

    // Funkcja do obliczenia "skrótu" liczby
    public static int skrotLiczba(int liczba) {
        int potega = 1;
        int wynik = 0;

        while (liczba > 0) {
            int cyfra = liczba % 10;
            if (cyfra % 2 == 1) {
                wynik = potega * cyfra + wynik;
                potega *= 10;
            }
            liczba /= 10;
        }

        return wynik;
    }

    public static void main(String[] args) {
        List<Integer> linie = new ArrayList<>();

        // Wczytanie danych z pliku
        try (BufferedReader br = new BufferedReader(new FileReader("skrot2.txt"))) {
            String linia;
            while ((linia = br.readLine()) != null) {
                linie.add(Integer.parseInt(linia));
            }
        } catch (IOException e) {
            System.out.println("Nie udalo sie otworzyc pliku!");
            e.printStackTrace();
            return;
        }

        // Przetwarzanie liczb
        for (int liczba : linie) {
            int skrot = skrotLiczba(liczba);

            // Użycie BigInteger do obliczenia GCD
            BigInteger liczbaBig = BigInteger.valueOf(liczba);
            BigInteger skrotBig = BigInteger.valueOf(skrot);

            if (liczbaBig.gcd(skrotBig).intValue() == 7) {
                System.out.println(liczba);
            }
        }
    }
}

import java.io.*;

import java.math.BigInteger;

import java.util.ArrayList;

import java.util.List;

public class Main {

// Funkcja do obliczenia "skrótu" liczby

public static int skrotLiczba(int liczba) {

int potega = 1;

int wynik = 0;

while (liczba > 0) {

int cyfra = liczba % 10;

if (cyfra % 2 == 1) {

wynik = potega * cyfra + wynik;

potega *= 10;

}

liczba /= 10;

}

return wynik;

}

public static void main(String[] args) {

List<Integer> linie = new ArrayList<>();

// Wczytanie danych z pliku

try (BufferedReader br = new BufferedReader(new FileReader("skrot2.txt"))) {

String linia;

while ((linia = br.readLine()) != null) {

linie.add(Integer.parseInt(linia));

}

} catch (IOException e) {

System.out.println("Nie udalo sie otworzyc pliku!");

e.printStackTrace();

return;

}

// Przetwarzanie liczb

for (int liczba : linie) {

int skrot = skrotLiczba(liczba);

// Użycie BigInteger do obliczenia GCD

BigInteger liczbaBig = BigInteger.valueOf(liczba);

BigInteger skrotBig = BigInteger.valueOf(skrot);

if (liczbaBig.gcd(skrotBig).intValue() == 7) {

System.out.println(liczba);

}

Jeśli dobrze znamy język programowania tak naprawdę to zadanie nie jest żadnym problemem. Wystarczy prosty warunek i funkcja gcd() z biblioteki math. Jeśli ktoś nie zna takich przydatnych funkcji to może albo napisać je sam (co niestety poskutkuje utratą cennego czasu), albo zapoznać się z naszym artykułem o przydatnych funkcjach w języku python.

Rozwiązanie:

784
14196
2247
24087
3871
10192

Pełny kod 3.1 – 3.3 – implementacja w python, C++ i java

Implementacja – Python

from math import *

# Zadanie 3.1

def skrotLiczba(liczba):
    potega = 1
    wynik = 0
    while liczba > 0:
        cyfra = liczba % 10
        if cyfra % 2 == 1:
            wynik = potega*cyfra+wynik
            potega = potega*10
        liczba = liczba//10
    return wynik

# Zadanie 3.2

with open("skrot.txt") as plik:
    linie = plik.readlines()
    for i in range(len(linie)):
        linie[i] = int(linie[i])

    bezSkrotu = []
    for liczba in linie:
        if skrotLiczba(liczba) == 0:
            bezSkrotu.append(liczba)
    print(len(bezSkrotu),max(bezSkrotu))

# Zadanie 3.3

with open("skrot2.txt") as plik:
    linie = plik.readlines()
    for i in range(len(linie)):
        linie[i] = int(linie[i])


    for liczba in linie:
        if gcd(liczba,skrotLiczba(liczba)) == 7:
            print(liczba)

from math import *

# Zadanie 3.1

def skrotLiczba(liczba):

potega = 1

wynik = 0

while liczba > 0:

cyfra = liczba % 10

if cyfra % 2 == 1:

wynik = potega*cyfra+wynik

potega = potega*10

liczba = liczba//10

return wynik

# Zadanie 3.2

with open("skrot.txt") as plik:

linie = plik.readlines()

for i in range(len(linie)):

linie[i] = int(linie[i])

bezSkrotu = []

for liczba in linie:

if skrotLiczba(liczba) == 0:

bezSkrotu.append(liczba)

print(len(bezSkrotu),max(bezSkrotu))

# Zadanie 3.3

with open("skrot2.txt") as plik:

linie = plik.readlines()

for i in range(len(linie)):

linie[i] = int(linie[i])

for liczba in linie:

if gcd(liczba,skrotLiczba(liczba)) == 7:

print(liczba)

Implementacja – C++

Do zadania 3.3 zastosowano dodatkowo zmienne linie1 oraz plik1.

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


using namespace std;

// Zadanie 3.1

int skrotLiczba(int liczba) {
    int potega = 1;
    int wynik = 0;
    
    while (liczba > 0) {
        int cyfra = liczba % 10;  // Wyciągamy ostatnią cyfrę
        if (cyfra % 2 == 1) { 	// Sprawdzamy, czy cyfra jest nieparzysta
            wynik = potega * cyfra + wynik;
            potega = potega * 10;
        }
        liczba = liczba / 10; 	// Usuwamy ostatnią cyfrę
    }

    return wynik;
}

// Funkcja do obliczenia GCD (największy wspólny dzielnik)
int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int main() {
    // Zadanie 3.2
    ifstream plik("skrot.txt");
    vector<int> linie;

    if (plik.is_open()) {
        int liczba;
        while (plik >> liczba) {
            linie.push_back(liczba);
        }
        plik.close();
    } else {
        cout << "Nie udalo sie otworzyc pliku!" << endl;
        return 1;
    }

    vector<int> bezSkrotu;

    for (int liczba : linie) {
        if (skrotLiczba(liczba) == 0) {
            bezSkrotu.push_back(liczba);
        }
    }

    if (!bezSkrotu.empty()) {
        cout << bezSkrotu.size() << " ";
        cout << *max_element(bezSkrotu.begin(), bezSkrotu.end())<<endl;
    } else {
        cout << "Brak liczb bez skrotu" << endl;
    }
    
    // Zadanie 3.3
    
    vector<int> linie1;
    
    ifstream plik1("skrot2.txt");

    if (plik1.is_open()) {
        int liczba;
        while (plik1 >> liczba) {
            linie1.push_back(liczba);
        }
        plik1.close();
    } else {
        cout << "Nie udalo sie otworzyc pliku!" << endl;
        return 1;
    }

    // Przetwarzanie liczb
    for (int liczba : linie1) {
        int skrot = skrotLiczba(liczba);
        if (gcd(liczba, skrot) == 7) {
            cout << liczba << endl;
        }
    }

    return 0;
}

#include <iostream>

#include <fstream>

#include <vector>

#include <algorithm>

using namespace std;

// Zadanie 3.1

int skrotLiczba(int liczba) {

int potega = 1;

int wynik = 0;

while (liczba > 0) {

int cyfra = liczba % 10; // Wyciągamy ostatnią cyfrę

if (cyfra % 2 == 1) { // Sprawdzamy, czy cyfra jest nieparzysta

wynik = potega * cyfra + wynik;

potega = potega * 10;

}

liczba = liczba / 10; // Usuwamy ostatnią cyfrę

}

return wynik;

}

// Funkcja do obliczenia GCD (największy wspólny dzielnik)

int gcd(int a, int b) {

while (b != 0) {

int temp = b;

b = a % b;

a = temp;

}

return a;

}

int main() {

// Zadanie 3.2

ifstream plik("skrot.txt");

vector<int> linie;

if (plik.is_open()) {

int liczba;

while (plik >> liczba) {

linie.push_back(liczba);

}

plik.close();

} else {

cout << "Nie udalo sie otworzyc pliku!" << endl;

return 1;

}

vector<int> bezSkrotu;

for (int liczba : linie) {

if (skrotLiczba(liczba) == 0) {

bezSkrotu.push_back(liczba);

}

if (!bezSkrotu.empty()) {

cout << bezSkrotu.size() << " ";

cout << *max_element(bezSkrotu.begin(), bezSkrotu.end())<<endl;

} else {

cout << "Brak liczb bez skrotu" << endl;

}

// Zadanie 3.3

vector<int> linie1;

ifstream plik1("skrot2.txt");

if (plik1.is_open()) {

int liczba;

while (plik1 >> liczba) {

linie1.push_back(liczba);

}

plik1.close();

} else {

cout << "Nie udalo sie otworzyc pliku!" << endl;

return 1;

}

// Przetwarzanie liczb

for (int liczba : linie1) {

int skrot = skrotLiczba(liczba);

if (gcd(liczba, skrot) == 7) {

cout << liczba << endl;

}

return 0;

}

Implementacja – Java

Do zadania 3.3 zastosowano dodatkowo zmienne linie1 oraz linia1.

import java.util.Scanner;
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.math.BigInteger;


public class Main {
    
    // Zadanie 3.1

    public static int skrotLiczba(int liczba) {
        int potega = 1;
        int wynik = 0;

        while (liczba > 0) {
            int cyfra = liczba % 10;  // Wyciągamy ostatnią cyfrę
            if (cyfra % 2 == 1) { 	// Sprawdzamy, czy cyfra jest nieparzysta
                wynik = potega * cyfra + wynik;
                potega = potega * 10;
            }
            liczba = liczba / 10; 	// Usuwamy ostatnią cyfrę
        }

        return wynik;
    }
    
    public static void main(String[] args) {
   	 
        // Zadanie 3.2
   	 
        List<Integer> linie = new ArrayList<>();

        try (BufferedReader br = new BufferedReader(new FileReader("skrot.txt"))) {
            String linia;
            while ((linia = br.readLine()) != null) {
                linie.add(Integer.parseInt(linia));
            }
        } catch (IOException e) {
            System.out.println("Nie udalo sie otworzyc pliku!");
            e.printStackTrace();
            return;
        }

        List<Integer> bezSkrotu = new ArrayList<>();

        for (int liczba : linie) {
            if (skrotLiczba(liczba) == 0) {
                bezSkrotu.add(liczba);
            }
        }

        if (!bezSkrotu.isEmpty()) {
            System.out.println(bezSkrotu.size()+" "+Collections.max(bezSkrotu));
        } else {
            System.out.println("Brak liczb bez skrotu");
        }
   	 
    	// Zadanie 3.3
   	 
        List<Integer> linie1 = new ArrayList<>();

        // Wczytanie danych z pliku
        try (BufferedReader br = new BufferedReader(new FileReader("skrot2.txt"))) {
            String linia1;
            while ((linia1 = br.readLine()) != null) {
                linie1.add(Integer.parseInt(linia1));
            }
        } catch (IOException e) {
            System.out.println("Nie udalo sie otworzyc pliku!");
            e.printStackTrace();
            return;
        }

        // Przetwarzanie liczb
        for (int liczba : linie1) {
            int skrot = skrotLiczba(liczba);

            // Użycie BigInteger do obliczenia GCD
            BigInteger liczbaBig = BigInteger.valueOf(liczba);
            BigInteger skrotBig = BigInteger.valueOf(skrot);

            if (liczbaBig.gcd(skrotBig).intValue() == 7) {
                System.out.println(liczba);
            }
        }
    }
}

import java.util.Scanner;

import java.io.*;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.math.BigInteger;

public class Main {

// Zadanie 3.1

public static int skrotLiczba(int liczba) {

int potega = 1;

int wynik = 0;

while (liczba > 0) {

int cyfra = liczba % 10; // Wyciągamy ostatnią cyfrę

if (cyfra % 2 == 1) { // Sprawdzamy, czy cyfra jest nieparzysta

wynik = potega * cyfra + wynik;

potega = potega * 10;

}

liczba = liczba / 10; // Usuwamy ostatnią cyfrę

}

return wynik;

}

public static void main(String[] args) {

// Zadanie 3.2

List<Integer> linie = new ArrayList<>();

try (BufferedReader br = new BufferedReader(new FileReader("skrot.txt"))) {

String linia;

while ((linia = br.readLine()) != null) {

linie.add(Integer.parseInt(linia));

}

} catch (IOException e) {

System.out.println("Nie udalo sie otworzyc pliku!");

e.printStackTrace();

return;

}

List<Integer> bezSkrotu = new ArrayList<>();

for (int liczba : linie) {

if (skrotLiczba(liczba) == 0) {

bezSkrotu.add(liczba);

}

if (!bezSkrotu.isEmpty()) {

System.out.println(bezSkrotu.size()+" "+Collections.max(bezSkrotu));

} else {

System.out.println("Brak liczb bez skrotu");

}

// Zadanie 3.3

List<Integer> linie1 = new ArrayList<>();

// Wczytanie danych z pliku

try (BufferedReader br = new BufferedReader(new FileReader("skrot2.txt"))) {

String linia1;

while ((linia1 = br.readLine()) != null) {

linie1.add(Integer.parseInt(linia1));

}

} catch (IOException e) {

System.out.println("Nie udalo sie otworzyc pliku!");

e.printStackTrace();

return;

}

// Przetwarzanie liczb

for (int liczba : linie1) {

int skrot = skrotLiczba(liczba);

// Użycie BigInteger do obliczenia GCD

BigInteger liczbaBig = BigInteger.valueOf(liczba);

BigInteger skrotBig = BigInteger.valueOf(skrot);

if (liczbaBig.gcd(skrotBig).intValue() == 7) {

System.out.println(liczba);

}

Zadanie 4 – Liczby

Rozwiązanie matura z informatyki 2024 - Zadanie 4 — Zadanie 4 – Liczby z arkusza maturalnego z informatyki maj 2024

Zadanie 4.1.

Implementacja – Python

with open("liczby.txt") as plik:
    linie = plik.readlines()
    liczbyPierwszy = [int(liczba) for liczba in linie[0].split()]
    liczbyDrugi = [int(liczba) for liczba in linie[1].split()]


    licznik = 0
    for liczba1 in liczbyPierwszy:
        for liczba2 in liczbyDrugi:
            if liczba2 % liczba1 == 0:
                licznik+=1
                break
print("4.1")
print(licznik)

with open("liczby.txt") as plik:

linie = plik.readlines()

liczbyPierwszy = [int(liczba) for liczba in linie[0].split()]

liczbyDrugi = [int(liczba) for liczba in linie[1].split()]

licznik = 0

for liczba1 in liczbyPierwszy:

for liczba2 in liczbyDrugi:

if liczba2 % liczba1 == 0:

licznik+=1

break

print("4.1")

print(licznik)

Implementacja – C++

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

using namespace std;

int main() {
    ifstream plik("liczby.txt");
    vector<int> liczbyPierwszy;
    vector<int> liczbyDrugi;

    if (plik.is_open()) {
        string linia;

        // Pierwsza linia z liczbami
        getline(plik, linia);
        stringstream ss1(linia);
        int liczba;
        while (ss1 >> liczba) {
            liczbyPierwszy.push_back(liczba);
        }

        // Druga linia z liczbami
        getline(plik, linia);
        stringstream ss2(linia);
        while (ss2 >> liczba) {
            liczbyDrugi.push_back(liczba);
        }

        plik.close();
    } else {
        cout << "Nie udało się otworzyć pliku!" << endl;
        return 1;
    }

    int licznik = 0;

    // Sprawdzanie podzielności
    for (int liczba1 : liczbyPierwszy) {
        for (int liczba2 : liczbyDrugi) {
            if (liczba2 % liczba1 == 0) {
                licznik++;
                break; // Przerwij wewnętrzną pętlę, gdy znajdziesz podzielną liczbę
            }
        }
    }

    // Wyświetlanie wyniku
    cout << "4.1" << endl;
    cout << licznik << endl;

    return 0;
}

#include <iostream>

#include <fstream>

#include <sstream>

#include <vector>

using namespace std;

int main() {

ifstream plik("liczby.txt");

vector<int> liczbyPierwszy;

vector<int> liczbyDrugi;

if (plik.is_open()) {

string linia;

// Pierwsza linia z liczbami

getline(plik, linia);

stringstream ss1(linia);

int liczba;

while (ss1 >> liczba) {

liczbyPierwszy.push_back(liczba);

}

// Druga linia z liczbami

getline(plik, linia);

stringstream ss2(linia);

while (ss2 >> liczba) {

liczbyDrugi.push_back(liczba);

}

plik.close();

} else {

cout << "Nie udało się otworzyć pliku!" << endl;

return 1;

}

int licznik = 0;

// Sprawdzanie podzielności

for (int liczba1 : liczbyPierwszy) {

for (int liczba2 : liczbyDrugi) {

if (liczba2 % liczba1 == 0) {

licznik++;

break; // Przerwij wewnętrzną pętlę, gdy znajdziesz podzielną liczbę

}

// Wyświetlanie wyniku

cout << "4.1" << endl;

cout << licznik << endl;

return 0;

}

Implementacja – Java

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        List<Integer> liczbyPierwszy = new ArrayList<>();
        List<Integer> liczbyDrugi = new ArrayList<>();

        // Wczytanie danych z pliku
        try (BufferedReader br = new BufferedReader(new FileReader("liczby.txt"))) {
            String linia;

            // Pierwsza linia z liczbami
            if ((linia = br.readLine()) != null) {
                Scanner sc = new Scanner(linia);
                while (sc.hasNextInt()) {
                    liczbyPierwszy.add(sc.nextInt());
            }
        }

        // Druga linia z liczbami
        if ((linia = br.readLine()) != null) {
            Scanner sc = new Scanner(linia);
            while (sc.hasNextInt()) {
                liczbyDrugi.add(sc.nextInt());
            }
        }

    } catch (IOException e) {
        System.out.println("Nie udało się otworzyć pliku!");
        e.printStackTrace();
        return;
    }

    int licznik = 0;

    // Sprawdzanie podzielności
    for (int liczba1 : liczbyPierwszy) {
        for (int liczba2 : liczbyDrugi) {
            if (liczba2 % liczba1 == 0) {
                licznik++;
                break; // Przerwij wewnętrzną pętlę, gdy znajdziesz podzielną liczbę
            }
        }
    }

    // Wyświetlanie wyniku
    System.out.println("4.1");
    System.out.println(licznik);
    }
}

import java.io.*;

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

List<Integer> liczbyPierwszy = new ArrayList<>();

List<Integer> liczbyDrugi = new ArrayList<>();

// Wczytanie danych z pliku

try (BufferedReader br = new BufferedReader(new FileReader("liczby.txt"))) {

String linia;

// Pierwsza linia z liczbami

if ((linia = br.readLine()) != null) {

Scanner sc = new Scanner(linia);

while (sc.hasNextInt()) {

liczbyPierwszy.add(sc.nextInt());

}

// Druga linia z liczbami

if ((linia = br.readLine()) != null) {

Scanner sc = new Scanner(linia);

while (sc.hasNextInt()) {

liczbyDrugi.add(sc.nextInt());

}

} catch (IOException e) {

System.out.println("Nie udało się otworzyć pliku!");

e.printStackTrace();

return;

}

int licznik = 0;

// Sprawdzanie podzielności

for (int liczba1 : liczbyPierwszy) {

for (int liczba2 : liczbyDrugi) {

if (liczba2 % liczba1 == 0) {

licznik++;

break; // Przerwij wewnętrzną pętlę, gdy znajdziesz podzielną liczbę

}

// Wyświetlanie wyniku

System.out.println("4.1");

System.out.println(licznik);

}

Używając funkcji .split() i zagnieżdżonych pętli możemy bardzo łatwo zaimportować dane. Dobrze jest liczby od razu przekonwertować na typ int (liczbę całkowitą), dzięki czemu nie trzeba będzie robić tego za każdym razem.

W tym momencie wystarczy sprawdzić liczby każdą z każdą i zwiększać zmienną licznik jeśli warunek został spełniony. Trzeba tylko pamiętać o break, bo inaczej policzymy wszystkie liczby z drugiego wiersza, które są podzielne przez daną wartość, a chcemy tylko sprawdzać czy liczba może podzielić jakąkolwiek.

Rozwiązanie:

212

Zadanie 4.2.

W drugim zadaniu wystarczy posortować liczby malejąco i wyświetlić 101 pamiętając, że indeksy zaczynają się od 0.

Implementacja – Python

print("4.2")
print(sorted(liczbyPierwszy,reverse=True)[100])

1 2	print("4.2") print(sorted(liczbyPierwszy,reverse=True)[100])

Implementacja – C++

cout << "4.2" << endl;
sort(liczbyPierwszy.begin(), liczbyPierwszy.end(), greater<int>());
cout << liczbyPierwszy[100] << endl;

cout << "4.2" << endl;

sort(liczbyPierwszy.begin(), liczbyPierwszy.end(), greater<int>());

cout << liczbyPierwszy[100] << endl;

Implementacja – Java

System.out.println("4.2");
Collections.sort(liczbyPierwszy, Collections.reverseOrder());
System.out.println(liczbyPierwszy.get(100));

System.out.println("4.2");

Collections.sort(liczbyPierwszy, Collections.reverseOrder());

System.out.println(liczbyPierwszy.get(100));

Rozwiązanie:

1933

Zadanie 4.3.

W tym zadaniu nie jest napisane wprost, że trzeba użyć rozkładu na czynniki pierwsze, ale skoro w pierwszym wierszu znajdują się tylko liczby pierwsze jest to wskazane.

def rozkladNaPierwsze(liczba):
    czynniki = []
    for i in range(2,liczba+1):
        while (liczba%i==0):
            czynniki.append(i)
            liczba //= i
        if liczba == 1:
            break
    return czynniki

def rozkladNaPierwsze(liczba):

czynniki = []

for i in range(2,liczba+1):

while (liczba%i==0):

czynniki.append(i)

liczba //= i

if liczba == 1:

break

return czynniki

Po prostu sprawdzamy, czy liczba każdego czynnika “starczy”, a jeśli nie to nie wypisujemy liczby za pomocą print.

Rozwiązanie:

Implementacja – Python

print("4.3")
    licznik = 0
    for liczba2 in liczbyDrugi:
        git = True
        czynnikiLiczby = rozkladNaPierwsze(liczba2)
        for czynnik in czynnikiLiczby:
            if czynnikiLiczby.count(czynnik) > liczbyPierwszy.count(czynnik):
                git = False
                break
        if git:
            print(liczba2)

print("4.3")

licznik = 0

for liczba2 in liczbyDrugi:

git = True

czynnikiLiczby = rozkladNaPierwsze(liczba2)

for czynnik in czynnikiLiczby:

if czynnikiLiczby.count(czynnik) > liczbyPierwszy.count(czynnik):

git = False

break

if git:

print(liczba2)

Implementacja – C++

#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
#include <algorithm>

using namespace std;

// Funkcja rozkładająca liczbę na czynniki pierwsze
vector<int> rozkladNaPierwsze(int liczba) {
    vector<int> czynniki;
    for (int i = 2; i <= liczba; i++) {
        while (liczba % i == 0) {
            czynniki.push_back(i);
            liczba /= i;
        }
        if (liczba == 1) break;
    }
    return czynniki;
}

int main() {
    ifstream plik("liczby.txt");
    string linia;
    vector<int> liczbyPierwszy, liczbyDrugi;

    // Wczytywanie danych z pliku
    if (plik.is_open()) {
        getline(plik, linia);
        stringstream ss1(linia);
        int liczba;
        while (ss1 >> liczba) liczbyPierwszy.push_back(liczba);

        getline(plik, linia);
        stringstream ss2(linia);
        while (ss2 >> liczba) liczbyDrugi.push_back(liczba);
    }

    // Zadanie 4.3
    int licznik = 0;
    cout << "4.3" << endl;
    for (int liczba2 : liczbyDrugi) {
        bool git = true;
        vector<int> czynnikiLiczby = rozkladNaPierwsze(liczba2);

        for (int czynnik : czynnikiLiczby) {
            if (count(czynnikiLiczby.begin(), czynnikiLiczby.end(), czynnik) > count(liczbyPierwszy.begin(), liczbyPierwszy.end(), czynnik)) {
                git = false;
                break;
            }
        }

        if (git) {
            cout << liczba2 << endl;
        }
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <fstream>

#include <sstream>

#include <algorithm>

using namespace std;

// Funkcja rozkładająca liczbę na czynniki pierwsze

vector<int> rozkladNaPierwsze(int liczba) {

vector<int> czynniki;

for (int i = 2; i <= liczba; i++) {

while (liczba % i == 0) {

czynniki.push_back(i);

liczba /= i;

}

if (liczba == 1) break;

}

return czynniki;

}

int main() {

ifstream plik("liczby.txt");

string linia;

vector<int> liczbyPierwszy, liczbyDrugi;

// Wczytywanie danych z pliku

if (plik.is_open()) {

getline(plik, linia);

stringstream ss1(linia);

int liczba;

while (ss1 >> liczba) liczbyPierwszy.push_back(liczba);

getline(plik, linia);

stringstream ss2(linia);

while (ss2 >> liczba) liczbyDrugi.push_back(liczba);

}

// Zadanie 4.3

int licznik = 0;

cout << "4.3" << endl;

for (int liczba2 : liczbyDrugi) {

bool git = true;

vector<int> czynnikiLiczby = rozkladNaPierwsze(liczba2);

for (int czynnik : czynnikiLiczby) {

if (count(czynnikiLiczby.begin(), czynnikiLiczby.end(), czynnik) > count(liczbyPierwszy.begin(), liczbyPierwszy.end(), czynnik)) {

git = false;

break;

}

if (git) {

cout << liczba2 << endl;

}

return 0;

}

Implementacja – Java

import java.io.*;
import java.util.*;

public class Main {
    // Funkcja rozkładająca liczbę na czynniki pierwsze
    public static List<Integer> rozkladNaPierwsze(int liczba) {
        List<Integer> czynniki = new ArrayList<>();
        for (int i = 2; i <= liczba; i++) {
            while (liczba % i == 0) {
                czynniki.add(i);
                liczba /= i;
            }
            if (liczba == 1) break;
        }
    return czynniki;
    }

    public static void main(String[] args) {
        try {
            BufferedReader plik = new BufferedReader(new FileReader("liczby.txt"));
            String linia;

            List<Integer> liczbyPierwszy = new ArrayList<>();
            List<Integer> liczbyDrugi = new ArrayList<>();

            // Wczytywanie danych z pliku
            linia = plik.readLine();
            String[] liczby1 = linia.split(" ");
            for (String s : liczby1) {
                liczbyPierwszy.add(Integer.parseInt(s));
            }

            linia = plik.readLine();
            String[] liczby2 = linia.split(" ");
            for (String s : liczby2) {
                liczbyDrugi.add(Integer.parseInt(s));
            }


            // Zadanie 4.3
            int licznik = 0;
            System.out.println("4.3");
            for (int liczba2 : liczbyDrugi) {
                boolean git = true;
                List<Integer> czynnikiLiczby = rozkladNaPierwsze(liczba2);

                for (int czynnik : czynnikiLiczby) {
                    if (Collections.frequency(czynnikiLiczby, czynnik) > Collections.frequency(liczbyPierwszy, czynnik)) {
                        git = false;
                        break;
                    }
                }

                if (git) {
                    System.out.println(liczba2);
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;

import java.util.*;

public class Main {

// Funkcja rozkładająca liczbę na czynniki pierwsze

public static List<Integer> rozkladNaPierwsze(int liczba) {

List<Integer> czynniki = new ArrayList<>();

for (int i = 2; i <= liczba; i++) {

while (liczba % i == 0) {

czynniki.add(i);

liczba /= i;

}

if (liczba == 1) break;

}

return czynniki;

}

public static void main(String[] args) {

try {

BufferedReader plik = new BufferedReader(new FileReader("liczby.txt"));

String linia;

List<Integer> liczbyPierwszy = new ArrayList<>();

List<Integer> liczbyDrugi = new ArrayList<>();

// Wczytywanie danych z pliku

linia = plik.readLine();

String[] liczby1 = linia.split(" ");

for (String s : liczby1) {

liczbyPierwszy.add(Integer.parseInt(s));

}

linia = plik.readLine();

String[] liczby2 = linia.split(" ");

for (String s : liczby2) {

liczbyDrugi.add(Integer.parseInt(s));

}

// Zadanie 4.3

int licznik = 0;

System.out.println("4.3");

for (int liczba2 : liczbyDrugi) {

boolean git = true;

List<Integer> czynnikiLiczby = rozkladNaPierwsze(liczba2);

for (int czynnik : czynnikiLiczby) {

if (Collections.frequency(czynnikiLiczby, czynnik) > Collections.frequency(liczbyPierwszy, czynnik)) {

git = false;

break;

}

if (git) {

System.out.println(liczba2);

}

} catch (IOException e) {

e.printStackTrace();

}

Zadanie 4.4.

Zadanie zrobimy lekko zmodyfikowaną metodą brute force. Zaczynamy od pierwszego elementu i pobieramy sumę z niego oraz z kolejnych 49 elementów. Następnie liczymy średnią i sprawdzamy czy jest większa od obecnej maksymalnej średniej, jeśli tak to zapisujemy nową maksymalną średnią, nową pierwszą liczbę oraz długość ciągu z którego pobraliśmy średnią.

Następnie zwiększamy ciąg o kolejny element i powtarzamy wszystkie operacje. Tak idziemy aż do końca, czyli dopóki nie dojdziemy do ostatniego elementu, wtedy od początku ponownie bierzemy 50 elementów, ale tym razem od 2 elementu, a potem znowu bierzemy sumę oraz średnią z 51, następnie z 52 itd.

Matura z informatyki 2024 - zadanie 4.4a — Na powyższym obrazku gif zastosowano przykład wspomnianej wcześniej metody brute force, przy czym minimalna długość ciągu wynosi 5.

Elementy początkowe będziemy zmieniać aż do pięćdziesiątego ostatniego elementu – dalej nie ma sensu sprawdzać, bo musi być to ciąg o długości 50.

Implementacja – Python

print("4.4")
maksSrednia = 0
pierwszaLiczba = 0
maksDlugosc = 0
for i in range(len(liczbyPierwszy) - 49):
    suma = sum(liczbyPierwszy[i:i+50])
    for j in range(50, len(liczbyPierwszy) - i + 1):
        if j > 50:
            suma += liczbyPierwszy[i+j-1]

        srednia = suma / j
        if srednia > maksSrednia:
            maksSrednia = srednia
            maksDlugosc = j
            pierwszaLiczba = liczbyPierwszy[i]           

print(maksSrednia,maksDlugosc,pierwszaLiczba)

print("4.4")

maksSrednia = 0

pierwszaLiczba = 0

maksDlugosc = 0

for i in range(len(liczbyPierwszy) - 49):

suma = sum(liczbyPierwszy[i:i+50])

for j in range(50, len(liczbyPierwszy) - i + 1):

if j > 50:

suma += liczbyPierwszy[i+j-1]

srednia = suma / j

if srednia > maksSrednia:

maksSrednia = srednia

maksDlugosc = j

pierwszaLiczba = liczbyPierwszy[i]

print(maksSrednia,maksDlugosc,pierwszaLiczba)

Implementacja – C++

#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <numeric> // Dla std::accumulate

using namespace std;

int main() {
    ifstream plik("liczby.txt");
    string linia;
    vector<int> liczbyPierwszy, liczbyDrugi;

    if (plik.is_open()) {
        // Wczytanie pierwszej linii do liczbyPierwszy
        getline(plik, linia);
        stringstream ss1(linia);
        int liczba;
        while (ss1 >> liczba) {
            liczbyPierwszy.push_back(liczba);
        }

        // Wczytanie drugiej linii do liczbyDrugi
        getline(plik, linia);
        stringstream ss2(linia);
        while (ss2 >> liczba) {
            liczbyDrugi.push_back(liczba);
        }

        plik.close();
    }

    // 4.4
    double maksSrednia = 0;
    int pierwszaLiczba = 0;
    int maksDlugosc = 0;

    for (size_t i = 0; i < liczbyPierwszy.size() - 49; i++) {
        int suma = accumulate(liczbyPierwszy.begin() + i, liczbyPierwszy.begin() + i + 50, 0);

        for (size_t j = 50; j <= liczbyPierwszy.size() - i; j++) {
            if (j > 50) {
                suma += liczbyPierwszy[i + j - 1];
            }

            double srednia = static_cast<double>(suma) / j;
            if (srednia > maksSrednia) {
                maksSrednia = srednia;
                maksDlugosc = j;
                pierwszaLiczba = liczbyPierwszy[i];
            }
        }
    }

    cout << "4.4" << endl;
    cout << maksSrednia << " " << maksDlugosc << " " << pierwszaLiczba << endl;

    return 0;
}

#include <iostream>

#include <fstream>

#include <vector>

#include <sstream>

#include <numeric> // Dla std::accumulate

using namespace std;

int main() {

ifstream plik("liczby.txt");

string linia;

vector<int> liczbyPierwszy, liczbyDrugi;

if (plik.is_open()) {

// Wczytanie pierwszej linii do liczbyPierwszy

getline(plik, linia);

stringstream ss1(linia);

int liczba;

while (ss1 >> liczba) {

liczbyPierwszy.push_back(liczba);

}

// Wczytanie drugiej linii do liczbyDrugi

getline(plik, linia);

stringstream ss2(linia);

while (ss2 >> liczba) {

liczbyDrugi.push_back(liczba);

}

plik.close();

}

// 4.4

double maksSrednia = 0;

int pierwszaLiczba = 0;

int maksDlugosc = 0;

for (size_t i = 0; i < liczbyPierwszy.size() - 49; i++) {

int suma = accumulate(liczbyPierwszy.begin() + i, liczbyPierwszy.begin() + i + 50, 0);

for (size_t j = 50; j <= liczbyPierwszy.size() - i; j++) {

if (j > 50) {

suma += liczbyPierwszy[i + j - 1];

}

double srednia = static_cast<double>(suma) / j;

if (srednia > maksSrednia) {

maksSrednia = srednia;

maksDlugosc = j;

pierwszaLiczba = liczbyPierwszy[i];

}

cout << "4.4" << endl;

cout << maksSrednia << " " << maksDlugosc << " " << pierwszaLiczba << endl;

return 0;

}

Implementacja – Java

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> liczbyPierwszy = new ArrayList<>();
        List<Integer> liczbyDrugi = new ArrayList<>();

        try (BufferedReader br = new BufferedReader(new FileReader("liczby.txt"))) {
            String linia;

            // Wczytanie pierwszej linii do liczbyPierwszy
            if ((linia = br.readLine()) != null) {
                liczbyPierwszy = Arrays.stream(linia.split(" "))
                .map(Integer::parseInt)
                .collect(Collectors.toList());
            }

            // Wczytanie drugiej linii do liczbyDrugi
            if ((linia = br.readLine()) != null) {
                liczbyDrugi = Arrays.stream(linia.split(" "))
                .map(Integer::parseInt)
                .collect(Collectors.toList());
            }

        } catch (IOException e) {
            e.printStackTrace();
        }


        // 4.4
        double maksSrednia = 0;
        int pierwszaLiczba = 0;
        int maksDlugosc = 0;

        for (int i = 0; i < liczbyPierwszy.size() - 49; i++) {
            int suma = liczbyPierwszy.subList(i, i + 50).stream().mapToInt(Integer::intValue).sum();

            for (int j = 50; j <= liczbyPierwszy.size() - i; j++) {
                if (j > 50) {
                    suma += liczbyPierwszy.get(i + j - 1);
                }

                double srednia = (double) suma / j;
                if (srednia > maksSrednia) {
                    maksSrednia = srednia;
                    maksDlugosc = j;
                    pierwszaLiczba = liczbyPierwszy.get(i);
                }
            }
        }

        System.out.println("4.4");
        System.out.println(maksSrednia + " " + maksDlugosc + " " + pierwszaLiczba);
    }
}

import java.io.*;

import java.util.*;

import java.util.stream.Collectors;

public class Main {

public static void main(String[] args) {

List<Integer> liczbyPierwszy = new ArrayList<>();

List<Integer> liczbyDrugi = new ArrayList<>();

try (BufferedReader br = new BufferedReader(new FileReader("liczby.txt"))) {

String linia;

// Wczytanie pierwszej linii do liczbyPierwszy

if ((linia = br.readLine()) != null) {

liczbyPierwszy = Arrays.stream(linia.split(" "))

.map(Integer::parseInt)

.collect(Collectors.toList());

}

// Wczytanie drugiej linii do liczbyDrugi

if ((linia = br.readLine()) != null) {

liczbyDrugi = Arrays.stream(linia.split(" "))

.map(Integer::parseInt)

.collect(Collectors.toList());

}

} catch (IOException e) {

e.printStackTrace();

}

// 4.4

double maksSrednia = 0;

int pierwszaLiczba = 0;

int maksDlugosc = 0;

for (int i = 0; i < liczbyPierwszy.size() - 49; i++) {

int suma = liczbyPierwszy.subList(i, i + 50).stream().mapToInt(Integer::intValue).sum();

for (int j = 50; j <= liczbyPierwszy.size() - i; j++) {

if (j > 50) {

suma += liczbyPierwszy.get(i + j - 1);

}

double srednia = (double) suma / j;

if (srednia > maksSrednia) {

maksSrednia = srednia;

maksDlugosc = j;

pierwszaLiczba = liczbyPierwszy.get(i);

}

System.out.println("4.4");

System.out.println(maksSrednia + " " + maksDlugosc + " " + pierwszaLiczba);

}

Rozwiązanie:

1200.704918032787 61 1847

Pełny kod 4.1 – 4.4 – implementacja w python, C++ i java

Implementacja – Python

def rozkladNaPierwsze(liczba):
    czynniki = []
    for i in range(2,liczba+1):
        while (liczba%i==0):
            czynniki.append(i)
            liczba //= i
        if liczba == 1:
            break
    return czynniki

with open("liczby.txt") as plik:
    linie = plik.readlines()
    liczbyPierwszy = [int(liczba) for liczba in linie[0].split()]
    liczbyDrugi = [int(liczba) for liczba in linie[1].split()]


    licznik = 0
    for liczba1 in liczbyPierwszy:
        for liczba2 in liczbyDrugi:
            if liczba2 % liczba1 == 0:
                licznik+=1
                break
    print("4.1")
    print(licznik)
   
    print("4.2")
    print(sorted(liczbyPierwszy,reverse=True)[100])
   
   print("4.3")
   licznik = 0
   for liczba2 in liczbyDrugi:
        git = True
        czynnikiLiczby = rozkladNaPierwsze(liczba2)
        for czynnik in czynnikiLiczby:
            if czynnikiLiczby.count(czynnik) > liczbyPierwszy.count(czynnik):
                git = False
                break
        if git:
            print(liczba2)

print("4.4")
maksSrednia = 0
pierwszaLiczba = 0
maksDlugosc = 0
for i in range(len(liczbyPierwszy) - 49):
    suma = sum(liczbyPierwszy[i:i+50])
    for j in range(50, len(liczbyPierwszy) - i + 1):
        if j > 50:
            suma += liczbyPierwszy[i+j-1]


        srednia = suma / j
        if srednia > maksSrednia:
            maksSrednia = srednia
            maksDlugosc = j
            pierwszaLiczba = liczbyPierwszy[i]      	 

print(maksSrednia,maksDlugosc,pierwszaLiczba)

def rozkladNaPierwsze(liczba):

czynniki = []

for i in range(2,liczba+1):

while (liczba%i==0):

czynniki.append(i)

liczba //= i

if liczba == 1:

break

return czynniki

with open("liczby.txt") as plik:

linie = plik.readlines()

liczbyPierwszy = [int(liczba) for liczba in linie[0].split()]

liczbyDrugi = [int(liczba) for liczba in linie[1].split()]

licznik = 0

for liczba1 in liczbyPierwszy:

for liczba2 in liczbyDrugi:

if liczba2 % liczba1 == 0:

licznik+=1

break

print("4.1")

print(licznik)

print("4.2")

print(sorted(liczbyPierwszy,reverse=True)[100])

print("4.3")

licznik = 0

for liczba2 in liczbyDrugi:

git = True

czynnikiLiczby = rozkladNaPierwsze(liczba2)

for czynnik in czynnikiLiczby:

if czynnikiLiczby.count(czynnik) > liczbyPierwszy.count(czynnik):

git = False

break

if git:

print(liczba2)

print("4.4")

maksSrednia = 0

pierwszaLiczba = 0

maksDlugosc = 0

for i in range(len(liczbyPierwszy) - 49):

suma = sum(liczbyPierwszy[i:i+50])

for j in range(50, len(liczbyPierwszy) - i + 1):

if j > 50:

suma += liczbyPierwszy[i+j-1]

srednia = suma / j

if srednia > maksSrednia:

maksSrednia = srednia

maksDlugosc = j

pierwszaLiczba = liczbyPierwszy[i]

print(maksSrednia,maksDlugosc,pierwszaLiczba)

Implementacja – C++

Warto zauważyć, że w przypadku całego kodu, utworzono kopię zmiennej (wektora) liczbyPierwszy, czyli kopiaLiczbyPierwszy, z której korzysta się potem w podpunkcie 4.4. Dzięki temu wynik jest prawidłowy (bo fragment algorytmu z 4.4 musi działać na nieposortowanych liczbach).

#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <numeric> // Dla std::accumulate
#include <algorithm> // Dla std::sort, std::greater, std::count

using namespace std;

// Funkcja rozkładająca liczbę na czynniki pierwsze
vector<int> rozkladNaPierwsze(int liczba) {
    vector<int> czynniki;
    for (int i = 2; i <= liczba; i++) {
        while (liczba % i == 0) {
            czynniki.push_back(i);
            liczba /= i;
        }
        if (liczba == 1) break;
    }
    return czynniki;
}


int main() {
    ifstream plik("liczby.txt");
    string linia;
    vector<int> liczbyPierwszy, liczbyDrugi;

    // Wczytywanie danych z pliku
    if (plik.is_open()) {
        getline(plik, linia);
        stringstream ss1(linia);
        int liczba;
        while (ss1 >> liczba) liczbyPierwszy.push_back(liczba);

        getline(plik, linia);
        stringstream ss2(linia);
        while (ss2 >> liczba) liczbyDrugi.push_back(liczba);
    }
    
    // Zadanie 4.1
    
    int licznik = 0;

    // Sprawdzanie podzielności
    for (int liczba1 : liczbyPierwszy) {
        for (int liczba2 : liczbyDrugi) {
            if (liczba2 % liczba1 == 0) {
                licznik++;
                break; // Przerwij wewnętrzną pętlę, gdy znajdziesz podzielną liczbę
            }
        }
    }

    // Wyświetlanie wyniku
    cout << "4.1" << endl;
    cout << licznik << endl;

    // Zadanie 4.2
    
    cout << "4.2" << endl;
    vector<int> kopiaLiczbyPierwszy = liczbyPierwszy;
    sort(liczbyPierwszy.begin(), liczbyPierwszy.end(), greater<int>());
    cout << liczbyPierwszy[100] << endl;

    // Zadanie 4.3
    cout << "4.3" << endl;
    for (int liczba2 : liczbyDrugi) {
        bool git = true;
        vector<int> czynnikiLiczby = rozkladNaPierwsze(liczba2);

        for (int czynnik : czynnikiLiczby) {
            if (count(czynnikiLiczby.begin(), czynnikiLiczby.end(), czynnik) > count(liczbyPierwszy.begin(), liczbyPierwszy.end(), czynnik)) {
                git = false;
                break;
            }
        }

        if (git) {
            cout << liczba2 << endl;
        }
    }


    // 4.4
    double maksSrednia = 0;
    int pierwszaLiczba = 0;
    int maksDlugosc = 0;

    for (size_t i = 0; i < kopiaLiczbyPierwszy.size() - 49; i++) {
        int suma = accumulate(kopiaLiczbyPierwszy.begin() + i, kopiaLiczbyPierwszy.begin() + i + 50, 0);

        for (size_t j = 50; j <= kopiaLiczbyPierwszy.size() - i; j++) {
            if (j > 50) {
                suma += kopiaLiczbyPierwszy[i + j - 1];
            }

            double srednia = static_cast<double>(suma) / j;
            if (srednia > maksSrednia) {
                maksSrednia = srednia;
                maksDlugosc = j;
                pierwszaLiczba = kopiaLiczbyPierwszy[i];
            }
        }
    }

    cout << "4.4" << endl;
    cout << maksSrednia << " " << maksDlugosc << " " << pierwszaLiczba << endl;

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

#include <iostream>

#include <fstream>

#include <vector>

#include <sstream>

#include <numeric> // Dla std::accumulate

#include <algorithm> // Dla std::sort, std::greater, std::count

using namespace std;

// Funkcja rozkładająca liczbę na czynniki pierwsze

vector<int> rozkladNaPierwsze(int liczba) {

vector<int> czynniki;

for (int i = 2; i <= liczba; i++) {

while (liczba % i == 0) {

czynniki.push_back(i);

liczba /= i;

}

if (liczba == 1) break;

}

return czynniki;

}

int main() {

ifstream plik("liczby.txt");

string linia;

vector<int> liczbyPierwszy, liczbyDrugi;

// Wczytywanie danych z pliku

if (plik.is_open()) {

getline(plik, linia);

stringstream ss1(linia);

int liczba;

while (ss1 >> liczba) liczbyPierwszy.push_back(liczba);

getline(plik, linia);

stringstream ss2(linia);

while (ss2 >> liczba) liczbyDrugi.push_back(liczba);

}

// Zadanie 4.1

int licznik = 0;

// Sprawdzanie podzielności

for (int liczba1 : liczbyPierwszy) {

for (int liczba2 : liczbyDrugi) {

if (liczba2 % liczba1 == 0) {

licznik++;

break; // Przerwij wewnętrzną pętlę, gdy znajdziesz podzielną liczbę

}

// Wyświetlanie wyniku

cout << "4.1" << endl;

cout << licznik << endl;

// Zadanie 4.2

cout << "4.2" << endl;

vector<int> kopiaLiczbyPierwszy = liczbyPierwszy;

sort(liczbyPierwszy.begin(), liczbyPierwszy.end(), greater<int>());

cout << liczbyPierwszy[100] << endl;

// Zadanie 4.3

cout << "4.3" << endl;

for (int liczba2 : liczbyDrugi) {

bool git = true;

vector<int> czynnikiLiczby = rozkladNaPierwsze(liczba2);

for (int czynnik : czynnikiLiczby) {

if (count(czynnikiLiczby.begin(), czynnikiLiczby.end(), czynnik) > count(liczbyPierwszy.begin(), liczbyPierwszy.end(), czynnik)) {

git = false;

break;

}

if (git) {

cout << liczba2 << endl;

}

// 4.4

double maksSrednia = 0;

int pierwszaLiczba = 0;

int maksDlugosc = 0;

for (size_t i = 0; i < kopiaLiczbyPierwszy.size() - 49; i++) {

int suma = accumulate(kopiaLiczbyPierwszy.begin() + i, kopiaLiczbyPierwszy.begin() + i + 50, 0);

for (size_t j = 50; j <= kopiaLiczbyPierwszy.size() - i; j++) {

if (j > 50) {

suma += kopiaLiczbyPierwszy[i + j - 1];

}

double srednia = static_cast<double>(suma) / j;

if (srednia > maksSrednia) {

maksSrednia = srednia;

maksDlugosc = j;

pierwszaLiczba = kopiaLiczbyPierwszy[i];

}

cout << "4.4" << endl;

cout << maksSrednia << " " << maksDlugosc << " " << pierwszaLiczba << endl;

return 0;

}

Implementacja – Java

Warto zauważyć, że w przypadku całego kodu, utworzono kopię zmiennej liczbyPierwszy, czyli kopiaLiczbyPierwszy, z której korzysta się potem w podpunkcie 4.4. Dzięki temu wynik jest prawidłowy (bo fragment algorytmu z 4.4 musi działać na nieposortowanych liczbach).

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    // Funkcja rozkładająca liczbę na czynniki pierwsze
    public static List<Integer> rozkladNaPierwsze(int liczba) {
        List<Integer> czynniki = new ArrayList<>();
        for (int i = 2; i <= liczba; i++) {
            while (liczba % i == 0) {
                czynniki.add(i);
                liczba /= i;
            }
            if (liczba == 1) break;
        }
        return czynniki;
    }

    public static void main(String[] args) {
        try {
            BufferedReader plik = new BufferedReader(new FileReader("liczby.txt"));
            String linia;

            List<Integer> liczbyPierwszy = new ArrayList<>();
            List<Integer> liczbyDrugi = new ArrayList<>();

            // Wczytywanie danych z pliku
            linia = plik.readLine();
            String[] liczby1 = linia.split(" ");
            for (String s : liczby1) {
                liczbyPierwszy.add(Integer.parseInt(s));
            }

            linia = plik.readLine();
            String[] liczby2 = linia.split(" ");
            for (String s : liczby2) {
                liczbyDrugi.add(Integer.parseInt(s));
            }
       	 
            // Zadanie 4.1
       	 
            int licznik = 0;

            // Sprawdzanie podzielności
            for (int liczba1 : liczbyPierwszy) {
                for (int liczba2 : liczbyDrugi) {
                    if (liczba2 % liczba1 == 0) {
                        licznik++;
                        break; // Przerwij wewnętrzną pętlę, gdy znajdziesz podzielną liczbę
                    }
                }
            }

            // Wyświetlanie wyniku
            System.out.println("4.1");
            System.out.println(licznik);
   	 
            // Zadanie 4.2
            List<Integer> kopiaLiczbyPierwszy = new ArrayList<>(liczbyPierwszy);
            System.out.println("4.2");
            Collections.sort(liczbyPierwszy, Collections.reverseOrder());
            System.out.println(liczbyPierwszy.get(100));

            // Zadanie 4.3
            System.out.println("4.3");
            for (int liczba2 : liczbyDrugi) {
                boolean git = true;
                List<Integer> czynnikiLiczby = rozkladNaPierwsze(liczba2);

                for (int czynnik : czynnikiLiczby) {
                    if (Collections.frequency(czynnikiLiczby, czynnik) > Collections.frequency(liczbyPierwszy, czynnik)) {
                        git = false;
                        break;
                    }
                }

                if (git) {
                    System.out.println(liczba2);
                }
            }


            // 4.4
            double maksSrednia = 0;
            int pierwszaLiczba = 0;
            int maksDlugosc = 0;

            for (int i = 0; i < kopiaLiczbyPierwszy.size() - 49; i++) {
                int suma = kopiaLiczbyPierwszy.subList(i, i + 50).stream().mapToInt(Integer::intValue).sum();

                for (int j = 50; j <= kopiaLiczbyPierwszy.size() - i; j++) {
                    if (j > 50) {
                        suma += kopiaLiczbyPierwszy.get(i + j - 1);
                    }

                    double srednia = (double) suma / j;
                    if (srednia > maksSrednia) {
                        maksSrednia = srednia;
                        maksDlugosc = j;
                        pierwszaLiczba = kopiaLiczbyPierwszy.get(i);
                    }
                }
            }

            System.out.println("4.4");
            System.out.println(maksSrednia + " " + maksDlugosc + " " + pierwszaLiczba);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

import java.io.*;

import java.util.*;

import java.util.stream.Collectors;

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

public class Main {

// Funkcja rozkładająca liczbę na czynniki pierwsze

public static List<Integer> rozkladNaPierwsze(int liczba) {

List<Integer> czynniki = new ArrayList<>();

for (int i = 2; i <= liczba; i++) {

while (liczba % i == 0) {

czynniki.add(i);

liczba /= i;

}

if (liczba == 1) break;

}

return czynniki;

}

public static void main(String[] args) {

try {

BufferedReader plik = new BufferedReader(new FileReader("liczby.txt"));

String linia;

List<Integer> liczbyPierwszy = new ArrayList<>();

List<Integer> liczbyDrugi = new ArrayList<>();

// Wczytywanie danych z pliku

linia = plik.readLine();

String[] liczby1 = linia.split(" ");

for (String s : liczby1) {

liczbyPierwszy.add(Integer.parseInt(s));

}

linia = plik.readLine();

String[] liczby2 = linia.split(" ");

for (String s : liczby2) {

liczbyDrugi.add(Integer.parseInt(s));

}

// Zadanie 4.1

int licznik = 0;

// Sprawdzanie podzielności

for (int liczba1 : liczbyPierwszy) {

for (int liczba2 : liczbyDrugi) {

if (liczba2 % liczba1 == 0) {

licznik++;

break; // Przerwij wewnętrzną pętlę, gdy znajdziesz podzielną liczbę

}

// Wyświetlanie wyniku

System.out.println("4.1");

System.out.println(licznik);

// Zadanie 4.2

List<Integer> kopiaLiczbyPierwszy = new ArrayList<>(liczbyPierwszy);

System.out.println("4.2");

Collections.sort(liczbyPierwszy, Collections.reverseOrder());

System.out.println(liczbyPierwszy.get(100));

// Zadanie 4.3

System.out.println("4.3");

for (int liczba2 : liczbyDrugi) {

boolean git = true;

List<Integer> czynnikiLiczby = rozkladNaPierwsze(liczba2);

for (int czynnik : czynnikiLiczby) {

if (Collections.frequency(czynnikiLiczby, czynnik) > Collections.frequency(liczbyPierwszy, czynnik)) {

git = false;

break;

}

if (git) {

System.out.println(liczba2);

}

// 4.4

double maksSrednia = 0;

int pierwszaLiczba = 0;

int maksDlugosc = 0;

for (int i = 0; i < kopiaLiczbyPierwszy.size() - 49; i++) {

int suma = kopiaLiczbyPierwszy.subList(i, i + 50).stream().mapToInt(Integer::intValue).sum();

for (int j = 50; j <= kopiaLiczbyPierwszy.size() - i; j++) {

if (j > 50) {

suma += kopiaLiczbyPierwszy.get(i + j - 1);

}

double srednia = (double) suma / j;

if (srednia > maksSrednia) {

maksSrednia = srednia;

maksDlugosc = j;

pierwszaLiczba = kopiaLiczbyPierwszy.get(i);

}

System.out.println("4.4");

System.out.println(maksSrednia + " " + maksDlugosc + " " + pierwszaLiczba);

} catch (IOException e) {

e.printStackTrace();

}

Zadanie 5 – Test

Rozwiązanie:

HTTP służy do przesyłania stron internetowych, a nie poczty – F.
FTP służy do przesyłania plików (File Transfer Protocol), funkcję opisaną w zadaniu pełni DNS – F.
Tak, DHCP to protokół umożliwiający uzyskanie danych konfiguracyjnych – P.

Zadanie 6 – Systemy pozycyjne

Rozwiązanie:

1011123 = 28410

1219 = 10010

28410 + 10010 = 38410 = 1120203

28410 – 10010 = 18410 = 202113

Można sprawdzić wyniki w pythonie jednak nadal odpowiedź należy samemu przekonwertować na system trójkowy.

print(int("101112",3)+int("121",9))

1	print(int("101112",3)+int("121",9))

Zadanie 7 – Hurtownia

Rozwiązanie matura z informatyki 2024 - Zadanie 7 — Zadanie 7 – Hurtownia z arkusza maturalnego z informatyki maj 2024

Na początek przeprowadzamy standardowy import danych. Pamiętaj, że każdy z plików najlepiej zaimportować do osobnego arkusza.

Zadanie 7.1.

Na początek mamy do czynienia z typowym podpunktem wymagającym tabeli przestawnej. Wystarczy do nowego arkusza przykleić dane z arkusza z transakcjami, zaznaczyć je i w sekcji wstawianie wybrać Tabela przestawna.

Należy wstawić ją gdzieś obok, a do filtrów dodać kolumnę kod i wybrać filtr Z, z kolei do wiersza dodać nip, a do wartości kolumnę kg. Należy upewnić się, że na kolumnie wartości jest podsumowanie Suma. Wystarczy kliknąć prawym przyciskiem myszy na dowolną wartość i w sekcji Podsumuj wartości według wybrać opcję Suma. Teraz wszystko jest w zasadzie gotowe, wystarczy tylko posortować wartości – należy kliknąć na dowolną wartość prawym przyciskiem myszy i w sekcji sortuj wybrać opcję Sortuj od największych do najmniejszych.

Matura z informatyki 2024 - Zadanie 7.1a — Trzy górne wyniki to rozwiązanie.

Teraz wystarczy przekopiować 3 górne wyniki do pliku txt.

Rozwiązanie:

NIP	Suma z Kilogramy
164-61-25-530	12185
159-34-45-151	12047
091-99-74-175	11769

Zadanie 7.2.

Do nowego arkusza przyklejamy zaimportowane dane z obu plików. Wyszukiwanie odpowiednich wartości to coś do czego stworzona jest funkcja x.wyszukaj. Wystarczy szukać danej nazwy w kolumnie nazw i zwracać wartość z kolumny obok.

Matura z informatyki 2024 - Zadanie 7.2a — Z pomocą funkcji *x.wyszukaj* z łatwością znajdziesz wymagane wartości.

Oczywiście należy odpowiednio blokować przemieszczanie zakresów i mnożyć cenę razy liczbę zakupionych kilogramów. Teraz można użyć tabeli przestawnej do podsumowania dochodów. Zaznaczamy dane o transakcjach i dochody, po czym właśnie z tych pól tworzymy tabelę przestawną. Do kolumny wiersze dodajemy nazwę, a do wartości dochód. Tak jak w poprzednim podpunkcie sortujemy od największej do najmniejszej według wartości i w pierwszym wierszu zostaje podany nasz wynik.

Matura z informatyki 2024 - zadanie 7.2b — W ten sposób uzyskasz potrzebne rozwiązanie.

Rozwiązanie:

Łączny przychód 2422669,4
Największy przychód dała odmiana Reneta

Zadanie 7.3.

Po przeklejeniu danych o transakcjach dodajemy na ich podstawie tabelę przestawną. Do wierszy dodajemy datę, ale zostawiamy tylko miesiąc. Do kolumn dodajemy nazwę jabłek, a do wartości liczbę kg z podsumowaniem Suma.

Matura z informatyki 2024 - zadanie 7.3a — Tabela przestawna okazuje się tu ogromną pomocą.

Następnie w kolumnie po lewej używamy formuły x.wyszukaj(), żeby znaleźć którego typu jabłka było najwięcej, szukaną liczbą będzie oczywiście maksymalna wartość z danego wiersza.

Matura z informatyki 2024 - zadanie 7.3b — Należy użyć formuły x.wyszukaj(), żeby znaleźć rodzaj jabłek, których jest najwięcej.

Następnie kopiujemy uzyskane wartości do nowej kolumny, a obok wstawiamy maksymalne wartości z każdego wiersza oraz miesiące. Można też dokonać konkatenacji miesięcy z nazwą rodzaju jabłek z pomocą “&”, żeby mieć pewność że powstanie prawidłowy wykres.

Matura z informatyki 2024 - zadanie 7.3c — Teraz wystarczy utworzyć wykres kolumnowy za pomocą posiadanych danych.

Z tych danych bardzo łatwo tworzymy wykres kolumnowy w zakładce wstawianie, dodajemy też poszczególne elementy używając plusa, który wyświetla się z prawej strony po kliknięciu na wykres.

Rozwiązanie:

Matura z informatyki 2024 - zadanie 7.3d — Wykres będący rozwiązaniem podpunktu 7.3.

“Czyste” dane:

styczeń-Gala 14017
luty-Gala 14969
marzec-Jonagored 15079
kwiecień-Gala 19404
maj-Gala 17382
czerwiec-Reneta 18661
lipiec-Melba 21216
sierpień-Reneta 19054
wrzesień-Reneta 20881
październik-Reneta 17065
listopad-Reneta 19755
grudzień-Jonagored 13425

Zadanie 7.4.

W tym zadaniu posłużymy się paroma dodatkowymi kolumnami. Najpierw dodamy kolumnę ile już kupił, która będzie podsumowywała ilość jabłek sprzedanych danemu klientowi.

Matura z informatyki 2024 - zadanie 7.4a — Dodajemy kilka dodatkowych kolumn.

Przeanalizuj dokładnie jak blokowany jest zakres.

Kolejna kolumna będzie zawierała jak duży rabat (ile rabatu) na kilogram dostanie klient na tej transakcji.

Matura z informatyki 2024 - zadanie 7.4b — W ten sposób z pomocą między innymi funkcji LICZ.JEŻELI() można uzyskać rozwiązanie zadania.

Na koniec trzecia kolumna, zawiera operację mnożenia liczby kilogramów razy rabat. Teraz wystarczy policzyć za pomocą funkcji LICZ.JEŻELI() z warunkiem >0 na kolumnie ile rabatu, żeby zobaczyć w ilu transakcjach był udzielony rabat oraz podsumować ostatnią kolumnę, żeby poznać sumaryczną kwotę rabatu.

Rozwiązanie:
W 180 transakcjach
Łącznie 3089,10 zł

Zadanie 8 – Rejestr wykroczeń

Rozwiązanie matura z informatyki 2024 - Zadanie 8 — Zadanie 8 – Rejestr wykroczeń z arkusza maturalnego z informatyki maj 2024

Na początek import danych. Pamiętaj, żeby ustawić odpowiedni format daty. Należy też utworzyć relacje:

Matura z informatyki 2024 - zadanie 8a — Tak wyglądają gotowe relacje.

Zadanie 8.1.

W pierwszym podpunkcie należy dodać wszystkie tabele i pobrać Kierowcy.idOsoby, Kierowcy.Imie, Kierowcy.Nazwisko oraz Taryfikator.Kwota z sumą suma i sortowaniem malejącym.

Matura z informatyki 2024 - zadanie 8.1a — Pamiętaj o skopiowaniu pierwszego wiersza do pliku.

Teraz wystarczy przekopiować pierwszy wiersz do pliku z odpowiedzią.

Rozwiązanie:

Imie	Nazwisko	Kwota mandatu
Rafael	Blake	3700

Zadanie 8.2.

W tym podpunkcie znowu dodajemy wszystkie tabele. Na początek zamiast pobierać coś z tabeli klikamy prawym przyciskiem myszy na pustą komórkę w wierszu Pole po czym klikamy konstruuj. Tam wpisujemy Month([Rejestr].[Data]), dzięki czemu wyciągniemy miesiąc, o co jesteśmy proszeni w zadaniu. Następnie pobieramy Taryfikator.Punkty z sumą suma i Taryfikator.IdWykroczenia z sumą gdzie i filtrem >= 3. Suma gdzie to tak naprawdę po prostu WHERE w SQL.

Matura z informatyki 2024 - zadanie 8.2a — Końcowy etap rozwiązywania zadania 8.2.

Rozwiązanie:

miesiąc	łączna liczba punktów
listopad	1766

Zadanie 8.3.

Tym razem dodajemy jedynie tabele Kierowcy oraz Rejestr. Bardzo ważna jest zmiana typu relacji na taki który uwzględnia wszystkie rekordy z tabeli kierowcy. Wystarczy kliknąć prawym przyciskiem myszy na linię łączącą dwie tabele, po czym wybrać właściwości sprzężenia, i zmienić je na odpowiedni rodzaj.

Matura z informatyki 2024 - zadanie 8.3a — Pamiętaj o zmianie typu relacji na taką, która uwzględnia wszystkie rekordy z tabeli *kierowcy*.

Dla znających język SQL, jest to w Accessie odpowiednik left/right join.

Teraz pobieramy Id, imie i nazwisko osoby oraz dowolne pole z tabeli Rejestr. Możemy łatwo sprawdzić kto nie dostał mandatu, wystarczy dla pola z tabeli Rejestr dać warunek Is Null. Null pojawia się wtedy, kiedy u konkretnej osoby nie umieszczono danych, bo została dodana do wyniku przez zmianę sprzężenia.

Matura z informatyki 2024 - zadanie 8.3b — Ostatni etap rozwiązywania zadania 8.3.

Rozwiązanie:

NrRejestracyjny	Imie	Nazwisko
BHW4028	Sandra	Wheeler
CJX1859	Quynn	Travis
KNM7950	Jasper	Santos
NIP6570	Honorato	Roth
QFR8936	Ivy	Bowen
SRU9727	Helen	White
XHK9060	Quentin	Tyler
YYS1077	Kevin	Wright

Zadanie 8.4.

Dodajmy nową tabelę i dodajemy do niej opisane w zadaniu pola. Dodajemy również pole do tabeli Rejestr.

Matura z informatyki 2024 - zadanie 8.4a — Dodajemy nową tabelę oraz wstawiamy tam wymagane pola.

Modyfikujemy również relacje.

Matura z informatyki 2024 - zadanie 8.4b — Modyfikacja relacji.

Teraz po prostu tworzymy nowe zapytanie. Dodajemy tabele fotoradar i Rejestr. Tak jak w poprzednim podpunkcie zmieniamy sprzężenie na takie, które uwzględnia wszystkie rekordy z tabeli Fotoradar. Wystarczy pobrać Fotoradar.idFotoradaru i dowolne pole z tabeli Rejestr z warunkiem Is Null. Na koniec trzeba przepisać z widoku SQL zapytanie na arkusz maturalny, jednak pomijając przy tym nawiasy.

Rozwiązanie:

SELECT Fotoradar.IdFotoradaru
FROM Fotoradar LEFT JOIN Rejestr ON Fotoradar.IdFotoradaru = Rejestr.IdFotoradaru
WHERE Rejestr.IdFotoradaru Is Null;

Wpisy, które mogą Cię zainteresować:

ROZWIĄZANIA: Matura z informatyki – maj 2024

Zadanie 1 – Plansza

Zadanie 1.1.

Zadanie 1.2.

Zadanie 1.3.

Zadanie 2 – Cyfry

Zadanie 2.1.

Zadanie 2.2.

Zadanie 3 – Nieparzysty skrót

Zadanie 3.1.

Zadanie 3.2.

Zadanie 3.3.

Pełny kod 3.1 – 3.3 – implementacja w python, C++ i java

Zadanie 4 – Liczby

Zadanie 4.1.

Zadanie 4.2.

Zadanie 4.3.

Zadanie 4.4.

Pełny kod 4.1 – 4.4 – implementacja w python, C++ i java

Zadanie 5 – Test

Zadanie 6 – Systemy pozycyjne

Zadanie 7 – Hurtownia

Zadanie 7.1.

Zadanie 7.2.

Zadanie 7.3.

Zadanie 7.4.

Zadanie 8 – Rejestr wykroczeń

Zadanie 8.1.

Zadanie 8.2.

Zadanie 8.3.

Zadanie 8.4.

Terminy matur 2025: harmonogram, czas trwania i wyniki

ROZWIĄZANIA: Matura z informatyki – maj 2023

Do czego potrzebna jest matura z informatyki?

Dbamy o prywatność Twoich danych

Mapa witryny: Korepetycje z informatyki

Polecane wpisy na blogu poświęconemu nauce informatyki