Matura 2025 — maj, poziom rozszerzony (formuła 2015)
ARKUSZ CZ. IARKUSZ CZ. IIDANEODPOWIEDZI
Treść zadania
Dana jest rekurencyjna funkcja przestaw dla nieujemnej liczby całkowitej n (mod — reszta, div — część całkowita z dzielenia):
przestaw(n):
r ← n mod 100
a ← r div 10
b ← r mod 10
n ← n div 100
jeżeli n > 0
w ← a + 10 * b + 100 * przestaw(n)
w przeciwnym razie
jeżeli a > 0
w ← a + 10 * b
w przeciwnym razie
w ← b
wynikiem jest w- 1.1 — Uzupełnij tabelę: dla n = 43657688, 154005710 i 998877665544321 podaj wynik przestaw(n) oraz łączną liczbę wywołań funkcji (z pierwszym włącznie). Przykład: przestaw(316498) = 134689, 3 wywołania.
- 1.2 — Oceń (P/F), czy liczba wywołań funkcji dla liczby k-cyfrowej (k > 0) jest równa: 1) k/2; 2) (k + 1) div 2; 3) k/2 dla parzystego k oraz (k + 1)/2 dla nieparzystego k; 4) k/2 + 1.
wywolania = 0
def przestaw(n):
global wywolania
wywolania += 1
r = n % 100
a = r // 10
b = r % 10
n = n // 100
if n > 0:
w = a + 10 * b + 100 * przestaw(n)
elif a > 0:
w = a + 10 * b
else:
w = b
return w
# 1.1
for n in [43657688, 154005710, 998877665544321]:
wywolania = 0
print(n, przestaw(n), wywolania)
# 1.2 - liczba wywołań dla liczby k-cyfrowej porównana z podanymi wzorami
for k in range(1, 9):
wywolania = 0
przestaw(10 ** (k - 1))
print(k, wywolania, k / 2, (k + 1) // 2, k / 2 if k % 2 == 0 else (k + 1) / 2, (k + 1) / 2)#include <print>
int wywolania = 0;
long long przestaw(long long n) {
wywolania += 1;
long long r = n % 100;
long long a = r / 10;
long long b = r % 10;
n = n / 100;
long long w;
if (n > 0) {
w = a + 10 * b + 100 * przestaw(n);
} else if (a > 0) {
w = a + 10 * b;
} else {
w = b;
}
return w;
}
int main() {
// 1.1 (największa liczba ma 15 cyfr - potrzebny long long)
for (long long n : {43657688LL, 154005710LL, 998877665544321LL}) {
wywolania = 0;
long long wynik = przestaw(n);
std::println("{} {} {}", n, wynik, wywolania);
}
// 1.2 - liczba wywołań dla liczby k-cyfrowej porównana z podanymi wzorami
// ułamki wypisujemy z jedną cyfrą po kropce (jak Python: 0.5, 1.0)
long long dziesiatka_do_k = 1; // 10^(k-1)
for (int k = 1; k < 9; k++) {
wywolania = 0;
przestaw(dziesiatka_do_k);
dziesiatka_do_k *= 10;
double wzor3 = k % 2 == 0 ? k / 2.0 : (k + 1) / 2.0;
std::println("{} {} {:.1f} {} {:.1f} {:.1f}", k, wywolania, k / 2.0, (k + 1) / 2, wzor3, (k + 1) / 2.0);
}
}public class Zadanie {
static int wywolania = 0;
static long przestaw(long n) {
wywolania += 1;
long r = n % 100;
long a = r / 10;
long b = r % 10;
n = n / 100;
long w;
if (n > 0) {
w = a + 10 * b + 100 * przestaw(n);
} else if (a > 0) {
w = a + 10 * b;
} else {
w = b;
}
return w;
}
public static void main(String[] args) throws Exception {
// 1.1 (największa liczba ma 15 cyfr - potrzebny long)
for (long n : new long[]{43657688L, 154005710L, 998877665544321L}) {
wywolania = 0;
long wynik = przestaw(n);
System.out.println(n + " " + wynik + " " + wywolania);
}
// 1.2 - liczba wywołań dla liczby k-cyfrowej porównana z podanymi wzorami
// double wypisuje się jak w Pythonie: 0.5, 1.0
long dziesiatkaDoK = 1; // 10^(k-1)
for (int k = 1; k < 9; k++) {
wywolania = 0;
przestaw(dziesiatkaDoK);
dziesiatkaDoK *= 10;
double wzor3 = k % 2 == 0 ? k / 2.0 : (k + 1) / 2.0;
System.out.println(k + " " + wywolania + " " + k / 2.0 + " " + (k + 1) / 2 + " " + wzor3 + " " + (k + 1) / 2.0);
}
}
}Odpowiedź: 1.1: 43657688 → 34566788, 4 wywołania; 154005710 → 145007501, 5; 998877665544321 → 989786756453412, 8. 1.2: FPPF (liczba wywołań to (k + 1) div 2).
↑Treść zadania
Liczba falista to liczba całkowita większa od 10, w której zapisie dziesiętnym na przemian występują tylko dwie różne cyfry (np. 41414, 4545). Liczba bazowa to liczba n > 10, której dwie ostatnie cyfry są niezerowe i różne od siebie; te dwie cyfry (w tej kolejności) to jej baza. Z liczby bazowej otrzymujemy liczbę falistą o tej samej bazie i tej samej długości, np. 78234 → 43434, 52786 → 68686.
- 2.1 — Uzupełnij tabelę: podaj liczby faliste dla liczb bazowych 326, 414141, 7732 i 21289.
- 2.2 — Zapisz (w pseudokodzie lub wybranym języku) algorytm, który dla liczby bazowej n oblicza liczbę falistą f o tej samej bazie i długości (np. 556621 → 212121, 45621 → 12121). Wolno używać tylko zmiennych przechowujących pojedyncze liczby, operatorów arytmetycznych (w tym dzielenia całkowitego i reszty), logicznych, porównań, przypisań i własnych funkcji — bez funkcji wbudowanych i konwersji liczba ↔ napis.
def falista(n):
baza = n % 100
f = 0
pot = 1
while n > 0:
if n >= 10: # zostały co najmniej dwie cyfry - wstawiamy całą bazę
f = f + baza * pot
else: # została jedna cyfra - wstawiamy cyfrę jedności bazy
f = f + (baza % 10) * pot
n = n // 100
pot = pot * 100
return f
# 2.1
for n in [326, 414141, 7732, 21289]:
print(n, falista(n))#include <print>
// 2.2
long long falista(long long n) {
long long baza = n % 100;
long long f = 0;
long long pot = 1;
while (n > 0) {
if (n >= 10) { // zostały co najmniej dwie cyfry - wstawiamy całą bazę
f = f + baza * pot;
} else { // została jedna cyfra - wstawiamy cyfrę jedności bazy
f = f + (baza % 10) * pot;
}
n = n / 100;
pot = pot * 100;
}
return f;
}
int main() {
// 2.1
for (long long n : {326, 414141, 7732, 21289}) {
std::println("{} {}", n, falista(n));
}
}public class Zadanie {
// 2.2
static long falista(long n) {
long baza = n % 100;
long f = 0;
long pot = 1;
while (n > 0) {
if (n >= 10) { // zostały co najmniej dwie cyfry - wstawiamy całą bazę
f = f + baza * pot;
} else { // została jedna cyfra - wstawiamy cyfrę jedności bazy
f = f + (baza % 10) * pot;
}
n = n / 100;
pot = pot * 100;
}
return f;
}
public static void main(String[] args) throws Exception {
// 2.1
for (long n : new long[]{326, 414141, 7732, 21289}) {
System.out.println(n + " " + falista(n));
}
}
}Odpowiedź: 2.1: 326 → 626, 414141 → 414141, 7732 → 3232, 21289 → 98989. 2.2: funkcja falista.
Treść zadania
Plik symbole.txt zawiera 2000 napisów, każdy w osobnym wierszu i złożony z dokładnie 12 znaków spośród o, +, *. Odpowiedzi zapisz w pliku wyniki4.txt, poprzedzając każdą numerem zadania. Plik symbole_przyklad.txt (20 wierszy) służy do testów.
- 4.1 — Wypisz (po jednym w wierszu, w kolejności z pliku) wszystkie napisy będące palindromami (dla pliku przykładowego:
oooo+**+oooo). - 4.2 — Podaj, ile napisów nie jest palindromami, ale stałoby się nimi po zmianie dokładnie jednego znaku (dla pliku przykładowego: 1 — napis
*+++++++++**). - 4.3 — Traktując plik jako prostokąt znaków, znajdź wszystkie „kwadraty” 3 × 3 złożone z dziewięciu jednakowych symboli. Podaj ich liczbę oraz dla każdego numer wiersza i numer pozycji w wierszu (licząc od 1) jego środkowego pola (dla pliku przykładowego:
1 6 3). - 4.4 — Każdy napis traktujemy jako liczbę w systemie trójkowym:
o= 0,+= 1,*= 2. Podaj największą z tych liczb w zapisie dziesiętnym oraz odpowiadający jej napis (dla pliku przykładowego:519789 ***+o*ooo++o). - 4.5 — Oblicz sumę wszystkich liczb z pliku (w rozumieniu 4.4). Podaj ją dziesiętnie oraz w zapisie trójkowym symbolami
o,+,*(dla pliku przykładowego:4841542 +oooo****+oo+o+).
with open("symbole.txt") as file:
napisy = [linia.strip() for linia in file if linia.strip()]
wynik = open("wyniki4.txt", "w")
# 4.1
print("4.1", file=wynik)
for napis in napisy:
if napis == napis[::-1]:
print(napis, file=wynik)
# 4.2 - dokładnie jedna para niezgodnych znaków napis[i] i napis[11 - i]
ile = 0
for napis in napisy:
rozne = 0
for i in range(len(napis) // 2):
if napis[i] != napis[len(napis) - 1 - i]:
rozne += 1
if rozne == 1:
ile += 1
print("4.2", ile, file=wynik)
# 4.3
srodki = []
for w in range(1, len(napisy) - 1):
for k in range(1, len(napisy[w]) - 1):
znak = napisy[w][k]
kwadrat = True
for dw in (-1, 0, 1):
for dk in (-1, 0, 1):
if napisy[w + dw][k + dk] != znak:
kwadrat = False
if kwadrat:
srodki.append((w + 1, k + 1))
print("4.3", len(srodki), file=wynik)
for w, k in srodki:
print(w, k, file=wynik)
# 4.4 i 4.5
cyfry = {"o": 0, "+": 1, "*": 2}
symbole = "o+*"
def na_liczbe(napis):
liczba = 0
for znak in napis:
liczba = liczba * 3 + cyfry[znak]
return liczba
def na_napis(liczba):
napis = ""
while liczba > 0:
napis = symbole[liczba % 3] + napis
liczba //= 3
return napis
najwiekszy = max(napisy, key=na_liczbe)
print("4.4", na_liczbe(najwiekszy), najwiekszy, file=wynik)
suma = 0
for napis in napisy:
suma += na_liczbe(napis)
print("4.5", suma, na_napis(suma), file=wynik)
wynik.close()#include <fstream>
#include <print>
#include <string>
#include <utility>
#include <vector>
const std::string symbole = "o+*";
long long na_liczbe(const std::string& napis) {
long long liczba = 0;
for (char znak : napis) {
liczba = liczba * 3 + symbole.find(znak); // "o" -> 0, "+" -> 1, "*" -> 2
}
return liczba;
}
std::string na_napis(long long liczba) {
std::string napis = "";
while (liczba > 0) {
napis = symbole[liczba % 3] + napis;
liczba /= 3;
}
return napis;
}
int main() {
std::ifstream plik("symbole.txt");
std::vector<std::string> napisy;
std::string linia;
while (plik >> linia) {
napisy.push_back(linia);
}
std::ofstream wynik("wyniki4.txt");
// 4.1
std::println(wynik, "4.1");
for (const std::string& napis : napisy) {
if (napis == std::string(napis.rbegin(), napis.rend())) {
std::println(wynik, "{}", napis);
}
}
// 4.2 - dokładnie jedna para niezgodnych znaków napis[i] i napis[11 - i]
int ile = 0;
for (const std::string& napis : napisy) {
int rozne = 0;
for (size_t i = 0; i < napis.size() / 2; i++) {
if (napis[i] != napis[napis.size() - 1 - i]) {
rozne += 1;
}
}
if (rozne == 1) {
ile += 1;
}
}
std::println(wynik, "4.2 {}", ile);
// 4.3
std::vector<std::pair<int, int>> srodki;
for (int w = 1; w < (int)napisy.size() - 1; w++) {
for (int k = 1; k < (int)napisy[w].size() - 1; k++) {
char znak = napisy[w][k];
bool kwadrat = true;
for (int dw = -1; dw <= 1; dw++) {
for (int dk = -1; dk <= 1; dk++) {
if (napisy[w + dw][k + dk] != znak) {
kwadrat = false;
}
}
}
if (kwadrat) {
srodki.push_back({w + 1, k + 1});
}
}
}
std::println(wynik, "4.3 {}", srodki.size());
for (auto [w, k] : srodki) {
std::println(wynik, "{} {}", w, k);
}
// 4.4 i 4.5
std::string najwiekszy = napisy[0];
for (const std::string& napis : napisy) {
if (na_liczbe(napis) > na_liczbe(najwiekszy)) {
najwiekszy = napis;
}
}
std::println(wynik, "4.4 {} {}", na_liczbe(najwiekszy), najwiekszy);
long long suma = 0;
for (const std::string& napis : napisy) {
suma += na_liczbe(napis);
}
std::println(wynik, "4.5 {} {}", suma, na_napis(suma));
}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 final String SYMBOLE = "o+*";
static long naLiczbe(String napis) {
long liczba = 0;
for (char znak : napis.toCharArray()) {
liczba = liczba * 3 + SYMBOLE.indexOf(znak); // "o" -> 0, "+" -> 1, "*" -> 2
}
return liczba;
}
static String naNapis(long liczba) {
String napis = "";
while (liczba > 0) {
napis = SYMBOLE.charAt((int) (liczba % 3)) + napis;
liczba /= 3;
}
return napis;
}
public static void main(String[] args) throws Exception {
List<String> napisy = new ArrayList<>();
for (String linia : Files.readAllLines(Path.of("symbole.txt"))) {
if (!linia.isBlank()) {
napisy.add(linia.strip());
}
}
PrintWriter wynik = new PrintWriter("wyniki4.txt");
// 4.1
wynik.println("4.1");
for (String napis : napisy) {
if (napis.equals(new StringBuilder(napis).reverse().toString())) {
wynik.println(napis);
}
}
// 4.2 - dokładnie jedna para niezgodnych znaków napis[i] i napis[11 - i]
int ile = 0;
for (String napis : napisy) {
int rozne = 0;
for (int i = 0; i < napis.length() / 2; i++) {
if (napis.charAt(i) != napis.charAt(napis.length() - 1 - i)) {
rozne += 1;
}
}
if (rozne == 1) {
ile += 1;
}
}
wynik.println("4.2 " + ile);
// 4.3
List<int[]> srodki = new ArrayList<>();
for (int w = 1; w < napisy.size() - 1; w++) {
for (int k = 1; k < napisy.get(w).length() - 1; k++) {
char znak = napisy.get(w).charAt(k);
boolean kwadrat = true;
for (int dw = -1; dw <= 1; dw++) {
for (int dk = -1; dk <= 1; dk++) {
if (napisy.get(w + dw).charAt(k + dk) != znak) {
kwadrat = false;
}
}
}
if (kwadrat) {
srodki.add(new int[]{w + 1, k + 1});
}
}
}
wynik.println("4.3 " + srodki.size());
for (int[] s : srodki) {
wynik.println(s[0] + " " + s[1]);
}
// 4.4 i 4.5
String najwiekszy = napisy.get(0);
for (String napis : napisy) {
if (naLiczbe(napis) > naLiczbe(najwiekszy)) {
najwiekszy = napis;
}
}
wynik.println("4.4 " + naLiczbe(najwiekszy) + " " + najwiekszy);
long suma = 0;
for (String napis : napisy) {
suma += naLiczbe(napis);
}
wynik.println("4.5 " + suma + " " + naNapis(suma));
wynik.close();
}
}Odpowiedź: 4.1: ++o+o++o+o++, +\+\\++\\+\+, \+o++\\++o+\, \oo\*o\\o\*oo\, +\++\*oo\++\*+, +o++oooo++o+. 4.2: 32. 4.3: 3 kwadraty, środki: (399, 5), (546, 2), (630, 11). 4.4: 531246, *******o+*+o. 4.5: 527865439, ++oo*+oo*++ooo*o*++.