Matura 2024 — maj, poziom rozszerzony (formuła 2015)
ARKUSZ CZ. IARKUSZ CZ. IIDANEODPOWIEDZI
Treść zadania
Każdą liczbę całkowitą większą od 1 można rozłożyć na iloczyn czynników pierwszych (liczba pierwsza ma jeden czynnik — samą siebie), np. 120 = 2 · 2 · 2 · 3 · 5, więc największym czynnikiem pierwszym 120 jest 5.
- 1.1 — Uzupełnij tabelę: dla liczb 32, 99 i 252 zapisz rozkład na czynniki pierwsze i największy czynnik pierwszy (przykłady: 120 → 5, 14 = 2 · 7 → 7).
- 1.2 — Zapisz (w pseudokodzie, liście kroków lub wybranym języku) funkcję
Największy_Czynnik(n), która dla liczby całkowitej n > 1 wyznacza największy czynnik d w jej rozkładzie na czynniki pierwsze. Wolno używać tylko zmiennych całkowitych, podstawowych operacji arytmetycznych (w tym dzielenia całkowitego i reszty), porównań, instrukcji sterujących i własnych funkcji — bez funkcji wbudowanych.
def najwiekszy_czynnik(n):
d = 2
while n > 1:
if n % d == 0:
n = n // d
else:
d = d + 1
return d
def rozklad(n):
czynniki = []
d = 2
while n > 1:
if n % d == 0:
czynniki.append(d)
n //= d
else:
d += 1
return czynniki
# 1.1
for n in [32, 99, 252]:
print(n, " * ".join(map(str, rozklad(n))), najwiekszy_czynnik(n))#include <print>
#include <string>
#include <vector>
// 1.2
int najwiekszy_czynnik(int n) {
int d = 2;
while (n > 1) {
if (n % d == 0) {
n = n / d;
} else {
d = d + 1;
}
}
return d;
}
std::vector<int> rozklad(int n) {
std::vector<int> czynniki;
int d = 2;
while (n > 1) {
if (n % d == 0) {
czynniki.push_back(d);
n /= d;
} else {
d += 1;
}
}
return czynniki;
}
int main() {
// 1.1
for (int n : {32, 99, 252}) {
std::string napis = "";
for (int czynnik : rozklad(n)) {
if (!napis.empty()) {
napis += " * ";
}
napis += std::to_string(czynnik);
}
std::println("{} {} {}", n, napis, najwiekszy_czynnik(n));
}
}import java.util.ArrayList;
import java.util.List;
public class Zadanie {
// 1.2
static int najwiekszyCzynnik(int n) {
int d = 2;
while (n > 1) {
if (n % d == 0) {
n = n / d;
} else {
d = d + 1;
}
}
return d;
}
static List<String> rozklad(int n) {
List<String> czynniki = new ArrayList<>();
int d = 2;
while (n > 1) {
if (n % d == 0) {
czynniki.add(String.valueOf(d));
n /= d;
} else {
d += 1;
}
}
return czynniki;
}
public static void main(String[] args) throws Exception {
// 1.1
for (int n : new int[]{32, 99, 252}) {
System.out.println(n + " " + String.join(" * ", rozklad(n)) + " " + najwiekszyCzynnik(n));
}
}
}Odpowiedź: 1.1: 32 = 2 · 2 · 2 · 2 · 2, d = 2; 99 = 3 · 3 · 11, d = 11; 252 = 2 · 2 · 3 · 3 · 7, d = 7. 1.2: funkcja najwiekszy_czynnik.
Treść zadania
Dana jest funkcja rekurencyjna fun(a, b) dla liczb całkowitych a i b, b ≥ 2:
fun(a, b):
jeżeli a ≤ 2
jeżeli a = 2: wynikiem jest PRAWDA, zakończ
w przeciwnym przypadku: wynikiem jest FAŁSZ, zakończ
jeżeli a mod b = 0: wynikiem jest FAŁSZ, zakończ
jeżeli b * b > a: wynikiem jest PRAWDA, zakończ
wynikiem jest fun(a, b + 1)- 2.1 — Podaj wynik fun(a, 2) dla a = 1, 7, 16 i −4 (przykład: dla a = 0 wynikiem jest FAŁSZ).
- 2.2 — Podaj, ile razy zostanie wykonane wywołanie fun(a, b + 1) po wywołaniu fun(a, 2) dla a = 17 i a = 77 (samego wywołania fun(a, 2) nie liczymy; przykłady: a = 2 → 0, a = 35 → 3).
wywolania = 0
def fun(a, b):
global wywolania
if a <= 2:
return a == 2
if a % b == 0:
return False
if b * b > a:
return True
wywolania += 1
return fun(a, b + 1)
# 2.1
for a in [1, 7, 16, -4]:
print(a, fun(a, 2))
# 2.2
for a in [17, 77]:
wywolania = 0
fun(a, 2)
print(a, wywolania)#include <print>
int wywolania = 0;
bool fun(int a, int b) {
if (a <= 2) {
return a == 2;
}
if (a % b == 0) {
return false;
}
if (b * b > a) {
return true;
}
wywolania += 1;
return fun(a, b + 1);
}
int main() {
// 2.1 (wypisujemy True/False jak Python)
for (int a : {1, 7, 16, -4}) {
std::println("{} {}", a, fun(a, 2) ? "True" : "False");
}
// 2.2
for (int a : {17, 77}) {
wywolania = 0;
fun(a, 2);
std::println("{} {}", a, wywolania);
}
}public class Zadanie {
static int wywolania = 0;
static boolean fun(int a, int b) {
if (a <= 2) {
return a == 2;
}
if (a % b == 0) {
return false;
}
if (b * b > a) {
return true;
}
wywolania += 1;
return fun(a, b + 1);
}
public static void main(String[] args) throws Exception {
// 2.1 (wypisujemy True/False jak Python)
for (int a : new int[]{1, 7, 16, -4}) {
System.out.println(a + " " + (fun(a, 2) ? "True" : "False"));
}
// 2.2
for (int a : new int[]{17, 77}) {
wywolania = 0;
fun(a, 2);
System.out.println(a + " " + wywolania);
}
}
}Odpowiedź: 2.1: 1 – FAŁSZ, 7 – PRAWDA, 16 – FAŁSZ, −4 – FAŁSZ (funkcja sprawdza, czy a jest liczbą pierwszą). 2.2: a = 17 → 3, a = 77 → 5.
↑Treść zadania
Plik plansza.txt opisuje rozmieszczenie statków na planszy 100 × 100: 100 wierszy po 100 cyfr 0 lub 1 oddzielonych spacjami (1 — pole ze statkiem, 0 — pole puste). Jednomasztowiec to pojedyncza jedynka otoczona zewsząd zerami lub krawędzią planszy, a dwumasztowiec — dwie sąsiednie (w poziomie lub pionie) jedynki otoczone zerami lub krawędzią. Statki nie stykają się ani bokami, ani wierzchołkami. Odpowiedzi zapisz w pliku wyniki4.txt, poprzedzając każdą numerem zadania. Plik plansza_przyklad.txt (plansza 10 × 10) służy do testów.
- 4.1 — Podaj liczbę pól, na których można jeszcze postawić jednomasztowiec, tj. pól z zerem, które nie stykają się bokiem ani wierzchołkiem z żadnym polem zajętym przez statek (dla pliku przykładowego: 11).
- 4.2 — Podaj liczbę par jednomasztowców położonych symetrycznie względem przekątnej biegnącej od lewego górnego do prawego dolnego rogu; statków leżących na tej przekątnej nie liczymy (dla pliku przykładowego: 2).
- 4.3 — Podaj liczbę dwumasztowców na planszy (dla pliku przykładowego: 7).
- 4.4 — Podaj liczbę jednomasztowców i liczbę dwumasztowców, których co najmniej jedno pole leży na jednej z dwóch głównych przekątnych planszy (dla pliku przykładowego: 1 jednomasztowiec i 3 dwumasztowce).
with open("plansza.txt") as file:
plansza = [linia.split() for linia in file if linia.strip()]
n = len(plansza)
wynik = open("wyniki4.txt", "w")
def pole(w, k):
# pole poza planszą traktujemy jak puste
if 0 <= w < n and 0 <= k < n:
return plansza[w][k]
return "0"
def sasiedzi_puste(w, k, pomin=()):
# czy wszystkie pola dookoła (w, k) - poza polami z listy pomin - są puste
for dw in (-1, 0, 1):
for dk in (-1, 0, 1):
if (dw, dk) != (0, 0) and (w + dw, k + dk) not in pomin and pole(w + dw, k + dk) == "1":
return False
return True
# 4.1
wolne = 0
for w in range(n):
for k in range(n):
if plansza[w][k] == "0" and sasiedzi_puste(w, k):
wolne += 1
print("4.1", wolne, file=wynik)
# wyszukanie jednomasztowców i dwumasztowców
jednomasztowce = []
dwumasztowce = []
for w in range(n):
for k in range(n):
if plansza[w][k] == "1":
if sasiedzi_puste(w, k):
jednomasztowce.append((w, k))
for dw, dk in ((0, 1), (1, 0)): # drugi maszt na prawo albo poniżej
w2, k2 = w + dw, k + dk
if pole(w2, k2) == "1" and sasiedzi_puste(w, k, [(w2, k2)]) \
and sasiedzi_puste(w2, k2, [(w, k)]):
dwumasztowce.append(((w, k), (w2, k2)))
# 4.2
pary = 0
for w, k in jednomasztowce:
if w < k and (k, w) in jednomasztowce:
pary += 1
print("4.2", pary, file=wynik)
# 4.3
print("4.3", len(dwumasztowce), file=wynik)
# 4.4
def na_przekatnej(w, k):
return w == k or w + k == n - 1
jedno = 0
for w, k in jednomasztowce:
if na_przekatnej(w, k):
jedno += 1
dwu = 0
for (w1, k1), (w2, k2) in dwumasztowce:
if na_przekatnej(w1, k1) or na_przekatnej(w2, k2):
dwu += 1
print("4.4", jedno, dwu, file=wynik)
wynik.close()#include <algorithm>
#include <fstream>
#include <print>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using Pole = std::pair<int, int>;
std::vector<std::vector<std::string>> plansza;
int n;
std::string pole(int w, int k) {
// pole poza planszą traktujemy jak puste
if (0 <= w && w < n && 0 <= k && k < n) {
return plansza[w][k];
}
return "0";
}
bool sasiedzi_puste(int w, int k, const std::vector<Pole>& pomin = {}) {
// czy wszystkie pola dookoła (w, k) - poza polami z listy pomin - są puste
for (int dw = -1; dw <= 1; dw++) {
for (int dk = -1; dk <= 1; dk++) {
bool pominiete = std::ranges::find(pomin, Pole{w + dw, k + dk}) != pomin.end();
if (!(dw == 0 && dk == 0) && !pominiete && pole(w + dw, k + dk) == "1") {
return false;
}
}
}
return true;
}
bool na_przekatnej(int w, int k) {
return w == k || w + k == n - 1;
}
int main() {
std::ifstream plik("plansza.txt");
std::string linia;
while (std::getline(plik, linia)) {
std::istringstream strumien(linia);
std::vector<std::string> wiersz;
std::string s;
while (strumien >> s) {
wiersz.push_back(s);
}
if (!wiersz.empty()) {
plansza.push_back(wiersz);
}
}
n = plansza.size();
std::ofstream wynik("wyniki4.txt");
// 4.1
int wolne = 0;
for (int w = 0; w < n; w++) {
for (int k = 0; k < n; k++) {
if (plansza[w][k] == "0" && sasiedzi_puste(w, k)) {
wolne += 1;
}
}
}
std::println(wynik, "4.1 {}", wolne);
// wyszukanie jednomasztowców i dwumasztowców
std::vector<Pole> jednomasztowce;
std::vector<std::pair<Pole, Pole>> dwumasztowce;
for (int w = 0; w < n; w++) {
for (int k = 0; k < n; k++) {
if (plansza[w][k] == "1") {
if (sasiedzi_puste(w, k)) {
jednomasztowce.push_back({w, k});
}
for (auto [dw, dk] : {Pole{0, 1}, Pole{1, 0}}) { // drugi maszt na prawo albo poniżej
int w2 = w + dw, k2 = k + dk;
if (pole(w2, k2) == "1" && sasiedzi_puste(w, k, {{w2, k2}})
&& sasiedzi_puste(w2, k2, {{w, k}})) {
dwumasztowce.push_back({{w, k}, {w2, k2}});
}
}
}
}
}
// 4.2
int pary = 0;
for (auto [w, k] : jednomasztowce) {
if (w < k && std::ranges::find(jednomasztowce, Pole{k, w}) != jednomasztowce.end()) {
pary += 1;
}
}
std::println(wynik, "4.2 {}", pary);
// 4.3
std::println(wynik, "4.3 {}", dwumasztowce.size());
// 4.4
int jedno = 0;
for (auto [w, k] : jednomasztowce) {
if (na_przekatnej(w, k)) {
jedno += 1;
}
}
int dwu = 0;
for (auto [p1, p2] : dwumasztowce) {
if (na_przekatnej(p1.first, p1.second) || na_przekatnej(p2.first, p2.second)) {
dwu += 1;
}
}
std::println(wynik, "4.4 {} {}", jedno, dwu);
}import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
public class Zadanie {
static List<String[]> plansza = new ArrayList<>();
static int n;
// pole zapisujemy jako rekord (w, k) - equals działa po wartościach
record Pole(int w, int k) {}
static String pole(int w, int k) {
// pole poza planszą traktujemy jak puste
if (0 <= w && w < n && 0 <= k && k < n) {
return plansza.get(w)[k];
}
return "0";
}
static boolean sasiedziPuste(int w, int k, List<Pole> pomin) {
// czy wszystkie pola dookoła (w, k) - poza polami z listy pomin - są puste
for (int dw = -1; dw <= 1; dw++) {
for (int dk = -1; dk <= 1; dk++) {
if (!(dw == 0 && dk == 0) && !pomin.contains(new Pole(w + dw, k + dk))
&& pole(w + dw, k + dk).equals("1")) {
return false;
}
}
}
return true;
}
static boolean naPrzekatnej(int w, int k) {
return w == k || w + k == n - 1;
}
public static void main(String[] args) throws Exception {
for (String linia : Files.readAllLines(Path.of("plansza.txt"))) {
if (!linia.isBlank()) {
plansza.add(linia.trim().split("\\s+"));
}
}
n = plansza.size();
PrintWriter wynik = new PrintWriter("wyniki4.txt");
// 4.1
int wolne = 0;
for (int w = 0; w < n; w++) {
for (int k = 0; k < n; k++) {
if (plansza.get(w)[k].equals("0") && sasiedziPuste(w, k, List.of())) {
wolne += 1;
}
}
}
wynik.println("4.1 " + wolne);
// wyszukanie jednomasztowców i dwumasztowców
List<Pole> jednomasztowce = new ArrayList<>();
List<Pole[]> dwumasztowce = new ArrayList<>();
int[][] kierunki = {{0, 1}, {1, 0}}; // drugi maszt na prawo albo poniżej
for (int w = 0; w < n; w++) {
for (int k = 0; k < n; k++) {
if (plansza.get(w)[k].equals("1")) {
if (sasiedziPuste(w, k, List.of())) {
jednomasztowce.add(new Pole(w, k));
}
for (int[] kierunek : kierunki) {
int w2 = w + kierunek[0], k2 = k + kierunek[1];
if (pole(w2, k2).equals("1") && sasiedziPuste(w, k, List.of(new Pole(w2, k2)))
&& sasiedziPuste(w2, k2, List.of(new Pole(w, k)))) {
dwumasztowce.add(new Pole[]{new Pole(w, k), new Pole(w2, k2)});
}
}
}
}
}
// 4.2
int pary = 0;
for (Pole p : jednomasztowce) {
if (p.w() < p.k() && jednomasztowce.contains(new Pole(p.k(), p.w()))) {
pary += 1;
}
}
wynik.println("4.2 " + pary);
// 4.3
wynik.println("4.3 " + dwumasztowce.size());
// 4.4
int jedno = 0;
for (Pole p : jednomasztowce) {
if (naPrzekatnej(p.w(), p.k())) {
jedno += 1;
}
}
int dwu = 0;
for (Pole[] statek : dwumasztowce) {
if (naPrzekatnej(statek[0].w(), statek[0].k()) || naPrzekatnej(statek[1].w(), statek[1].k())) {
dwu += 1;
}
}
wynik.println("4.4 " + jedno + " " + dwu);
wynik.close();
}
}Odpowiedź: 4.1: 9321. 4.2: 5. 4.3: 35. 4.4: 1 jednomasztowiec, 10 dwumasztowców.
↑