Matura 2025 — maj, poziom rozszerzony (formuła 2023)
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)
else:
if a > 0:
w = a + 10 * b
else:
w = b
return w
# 1.1
for n in [316498, 43657688, 154005710, 998877665544321]:
wywolania = 0
print(n, przestaw(n), wywolania)
# 1.2 - liczba wywołań dla liczb k-cyfrowych porównana ze wzorami
for k in range(1, 9):
wywolania = 0
przestaw(10 ** (k - 1)) # dowolna liczba k-cyfrowa
wzor1 = k / 2
wzor2 = (k + 1) // 2
wzor3 = k / 2 if k % 2 == 0 else (k + 1) / 2
wzor4 = (k + 1) / 2
print(k, wywolania, wzor1 == wywolania, wzor2 == wywolania,
wzor3 == wywolania, wzor4 == wywolania)#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;
}
// wartość logiczna wypisana tak jak w Pythonie
const char* napis(bool w) {
return w ? "True" : "False";
}
int main() {
// 1.1 (największa liczba ma 15 cyfr - potrzebny long long)
for (long long n : {316498LL, 43657688LL, 154005710LL, 998877665544321LL}) {
wywolania = 0;
long long wynik = przestaw(n);
std::println("{} {} {}", n, wynik, wywolania);
}
// 1.2 - liczba wywołań dla liczb k-cyfrowych porównana ze wzorami
long long dziesiatka_do_k = 1; // 10^(k-1)
for (int k = 1; k < 9; k++) {
wywolania = 0;
przestaw(dziesiatka_do_k); // dowolna liczba k-cyfrowa
dziesiatka_do_k *= 10;
double wzor1 = k / 2.0;
int wzor2 = (k + 1) / 2;
double wzor3 = k % 2 == 0 ? k / 2.0 : (k + 1) / 2.0;
double wzor4 = (k + 1) / 2.0;
std::println("{} {} {} {} {} {}", k, wywolania, napis(wzor1 == wywolania), napis(wzor2 == wywolania),
napis(wzor3 == wywolania), napis(wzor4 == wywolania));
}
}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;
}
// wartość logiczna wypisana tak jak w Pythonie
static String napis(boolean w) {
return w ? "True" : "False";
}
public static void main(String[] args) throws Exception {
// 1.1 (największa liczba ma 15 cyfr - potrzebny long)
for (long n : new long[]{316498L, 43657688L, 154005710L, 998877665544321L}) {
wywolania = 0;
long wynik = przestaw(n);
System.out.println(n + " " + wynik + " " + wywolania);
}
// 1.2 - liczba wywołań dla liczb k-cyfrowych porównana ze wzorami
long dziesiatkaDoK = 1; // 10^(k-1)
for (int k = 1; k < 9; k++) {
wywolania = 0;
przestaw(dziesiatkaDoK); // dowolna liczba k-cyfrowa
dziesiatkaDoK *= 10;
double wzor1 = k / 2.0;
int wzor2 = (k + 1) / 2;
double wzor3 = k % 2 == 0 ? k / 2.0 : (k + 1) / 2.0;
double wzor4 = (k + 1) / 2.0;
System.out.println(k + " " + wywolania + " " + napis(wzor1 == wywolania) + " " + napis(wzor2 == wywolania)
+ " " + napis(wzor3 == wywolania) + " " + napis(wzor4 == wywolania));
}
}
}Odpowiedź: 1.1: 316498 → 134689, 3 wywołania; 43657688 → 34566788, 4; 154005710 → 145007501, 5; 998877665544321 → 989786756453412, 8. 1.2: 1. F, 2. P, 3. P, 4. F (liczba wywołań to (k + 1) div 2).
↑Treść zadania
Funkcja przestaw jest opisana w zadaniu 1.1.
Napisz (w pseudokodzie lub wybranym języku) nierekurencyjną funkcję przestaw2, która dla nieujemnej liczby całkowitej n zwraca taką samą wartość w jak przestaw(n).
def przestaw2(n):
w = 0
p = 1
while n > 0:
r = n % 100
a = r // 10
b = r % 10
if n > 9:
w = p * a + 10 * p * b + w
else:
w = p * b + w
n = n // 100
p = p * 100
return w
for n in [316498, 43657688, 154005710, 998877665544321]:
print(n, przestaw2(n))
# sprawdzenie z wersją rekurencyjną
def przestaw(n):
r = n % 100
a = r // 10
b = r % 10
n = n // 100
if n > 0:
return a + 10 * b + 100 * przestaw(n)
if a > 0:
return a + 10 * b
return b
for n in range(0, 200000):
assert przestaw(n) == przestaw2(n)#include <print>
long long przestaw2(long long n) {
long long w = 0;
long long p = 1;
while (n > 0) {
long long r = n % 100;
long long a = r / 10;
long long b = r % 10;
if (n > 9) {
w = p * a + 10 * p * b + w;
} else {
w = p * b + w;
}
n = n / 100;
p = p * 100;
}
return w;
}
// sprawdzenie z wersją rekurencyjną
long long przestaw(long long n) {
long long r = n % 100;
long long a = r / 10;
long long b = r % 10;
n = n / 100;
if (n > 0) {
return a + 10 * b + 100 * przestaw(n);
}
if (a > 0) {
return a + 10 * b;
}
return b;
}
int main() {
for (long long n : {316498LL, 43657688LL, 154005710LL, 998877665544321LL}) {
std::println("{} {}", n, przestaw2(n));
}
for (long long n = 0; n < 200000; n++) {
if (przestaw(n) != przestaw2(n)) {
std::println("BŁĄD dla n = {}", n);
}
}
}public class Zadanie {
static long przestaw2(long n) {
long w = 0;
long p = 1;
while (n > 0) {
long r = n % 100;
long a = r / 10;
long b = r % 10;
if (n > 9) {
w = p * a + 10 * p * b + w;
} else {
w = p * b + w;
}
n = n / 100;
p = p * 100;
}
return w;
}
// sprawdzenie z wersją rekurencyjną
static long przestaw(long n) {
long r = n % 100;
long a = r / 10;
long b = r % 10;
n = n / 100;
if (n > 0) {
return a + 10 * b + 100 * przestaw(n);
}
if (a > 0) {
return a + 10 * b;
}
return b;
}
public static void main(String[] args) throws Exception {
for (long n : new long[]{316498L, 43657688L, 154005710L, 998877665544321L}) {
System.out.println(n + " " + przestaw2(n));
}
for (long n = 0; n < 200000; n++) {
if (przestaw(n) != przestaw2(n)) {
System.out.println("BŁĄD dla n = " + n);
}
}
}
}Odpowiedź: funkcja przestaw2 (daje te same wyniki co przestaw).
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 wyniki2.txt, poprzedzając każdą numerem zadania. Plik symbole_przyklad.txt (20 wierszy) służy do testów.
- 2.1 — Wypisz (po jednym w wierszu, w kolejności z pliku) wszystkie napisy będące palindromami (dla pliku przykładowego:
oooo+**+oooo). - 2.2 — 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). - 2.3 — 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). - 2.4 — Oblicz sumę wszystkich liczb z pliku (w rozumieniu 2.3). 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 = [wiersz.strip() for wiersz in file]
# 2.1
print("2.1")
for napis in napisy:
if napis == napis[::-1]:
print(napis)
# 2.2
srodki = []
for i in range(1, len(napisy) - 1):
for j in range(1, 11):
znak = napisy[i][j]
kwadrat = True
for di in [-1, 0, 1]:
for dj in [-1, 0, 1]:
if napisy[i + di][j + dj] != znak:
kwadrat = False
if kwadrat:
srodki.append((i + 1, j + 1)) # numeracja od 1
print("2.2", len(srodki), end=" ")
for wiersz, pozycja in srodki:
print(wiersz, pozycja, end=" ")
print()
# 2.3 i 2.4
cyfra = {"o": 0, "+": 1, "*": 2}
symbol = "o+*"
def na_liczbe(napis):
liczba = 0
for znak in napis:
liczba = liczba * 3 + cyfra[znak]
return liczba
def na_napis(liczba):
napis = ""
while liczba > 0:
napis = symbol[liczba % 3] + napis
liczba //= 3
return napis
najwiekszy = max(napisy, key=na_liczbe)
print("2.3", na_liczbe(najwiekszy), najwiekszy)
suma = sum(na_liczbe(napis) for napis in napisy)
print("2.4", suma, na_napis(suma))#include <fstream>
#include <print>
#include <string>
#include <utility>
#include <vector>
const std::string symbol = "o+*";
long long na_liczbe(const std::string& napis) {
long long liczba = 0;
for (char znak : napis) {
liczba = liczba * 3 + symbol.find(znak); // "o" -> 0, "+" -> 1, "*" -> 2
}
return liczba;
}
std::string na_napis(long long liczba) {
std::string napis = "";
while (liczba > 0) {
napis = symbol[liczba % 3] + napis;
liczba /= 3;
}
return napis;
}
int main() {
std::ifstream plik("symbole.txt");
std::vector<std::string> napisy;
std::string wiersz;
while (plik >> wiersz) {
napisy.push_back(wiersz);
}
// 2.1
std::println("2.1");
for (const std::string& napis : napisy) {
if (napis == std::string(napis.rbegin(), napis.rend())) {
std::println("{}", napis);
}
}
// 2.2
std::vector<std::pair<int, int>> srodki;
for (int i = 1; i < (int)napisy.size() - 1; i++) {
for (int j = 1; j < 11; j++) {
char znak = napisy[i][j];
bool kwadrat = true;
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
if (napisy[i + di][j + dj] != znak) {
kwadrat = false;
}
}
}
if (kwadrat) {
srodki.push_back({i + 1, j + 1}); // numeracja od 1
}
}
}
std::print("2.2 {} ", srodki.size());
for (auto [wiersz, pozycja] : srodki) {
std::print("{} {} ", wiersz, pozycja);
}
std::println();
// 2.3 i 2.4
std::string najwiekszy = napisy[0];
for (const std::string& napis : napisy) {
if (na_liczbe(napis) > na_liczbe(najwiekszy)) {
najwiekszy = napis;
}
}
std::println("2.3 {} {}", na_liczbe(najwiekszy), najwiekszy);
long long suma = 0;
for (const std::string& napis : napisy) {
suma += na_liczbe(napis);
}
std::println("2.4 {} {}", suma, na_napis(suma));
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
public class Zadanie {
static final String SYMBOL = "o+*";
static long naLiczbe(String napis) {
long liczba = 0;
for (char znak : napis.toCharArray()) {
liczba = liczba * 3 + SYMBOL.indexOf(znak); // "o" -> 0, "+" -> 1, "*" -> 2
}
return liczba;
}
static String naNapis(long liczba) {
String napis = "";
while (liczba > 0) {
napis = SYMBOL.charAt((int) (liczba % 3)) + napis;
liczba /= 3;
}
return napis;
}
public static void main(String[] args) throws Exception {
List<String> napisy = new ArrayList<>();
for (String wiersz : Files.readAllLines(Path.of("symbole.txt"))) {
napisy.add(wiersz.strip());
}
// 2.1
System.out.println("2.1");
for (String napis : napisy) {
if (napis.equals(new StringBuilder(napis).reverse().toString())) {
System.out.println(napis);
}
}
// 2.2
List<int[]> srodki = new ArrayList<>();
for (int i = 1; i < napisy.size() - 1; i++) {
for (int j = 1; j < 11; j++) {
char znak = napisy.get(i).charAt(j);
boolean kwadrat = true;
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
if (napisy.get(i + di).charAt(j + dj) != znak) {
kwadrat = false;
}
}
}
if (kwadrat) {
srodki.add(new int[]{i + 1, j + 1}); // numeracja od 1
}
}
}
StringBuilder linia = new StringBuilder("2.2 " + srodki.size() + " ");
for (int[] s : srodki) {
linia.append(s[0]).append(" ").append(s[1]).append(" ");
}
System.out.println(linia);
// 2.3 i 2.4
String najwiekszy = napisy.get(0);
for (String napis : napisy) {
if (naLiczbe(napis) > naLiczbe(najwiekszy)) {
najwiekszy = napis;
}
}
System.out.println("2.3 " + naLiczbe(najwiekszy) + " " + najwiekszy);
long suma = 0;
for (String napis : napisy) {
suma += naLiczbe(napis);
}
System.out.println("2.4 " + suma + " " + naNapis(suma));
}
}Odpowiedź: 2.1: ++o+o++o+o++, ++++++, +o++++o+, oo*oo*oo, +++*oo+++, +o++oooo++o+. 2.2: 3 kwadraty, środki: wiersz 399 pozycja 5, wiersz 546 pozycja 2, wiersz 630 pozycja 11. 2.3: 531246 *o++o. 2.4: 527865439 ++oo*+oo*++ooo*o*++.
↑Treść zadania
Dron leci po łamanej od punktu (0, 0) do punktu (20000, 0), poza startem i lądowaniem zawsze na dodatniej wysokości. Plik dron.txt zawiera 100 wierszy; w każdym są dwie liczby całkowite A i B oddzielone spacją: A (zawsze dodatnie) to przesunięcie w poziomie, a B — w pionie (dodatnie w górę, ujemne w dół, 0 bez zmiany wysokości) względem poprzedniej pozycji. Odpowiedzi zapisz w pliku wyniki3.txt, poprzedzając każdą numerem zadania. Plik dron_przyklad.txt służy do testów.
- 3.1 — Podaj liczbę par [A, B], dla których NWD(|A|, |B|) jest większy od 1 (przyjmujemy NWD(A, 0) = A).
- 3.2 — Rozważ punkty, w których dron znajduje się po kolejnych ruchach (np. dla ruchów [3000, 2000], [2000, 9000], [5000, −7000] są to (3000, 2000), (5000, 11000), (10000, 4000)…). a) Podaj, ile z nich leży wewnątrz kwadratu o wierzchołkach (0, 0), (0, 5000), (5000, 5000), (5000, 0) (bez punktów na brzegu). b) Znajdź trzy różne punkty takie, że jeden jest środkiem odcinka o końcach w dwóch pozostałych (jest jedna taka trójka; punkty nie muszą być kolejne). Dla pliku przykładowego: a) 2, b) (14000, 3014), (16000, 2010), (18000, 1006).
from math import gcd
with open("dron.txt") as file:
ruchy = [tuple(map(int, wiersz.split())) for wiersz in file]
# 3.1
ile = 0
for a, b in ruchy:
if gcd(abs(a), abs(b)) > 1:
ile += 1
print("3.1", ile)
# 3.2
punkty = []
x, y = 0, 0
for a, b in ruchy:
x += a
y += b
punkty.append((x, y))
wewnatrz = 0
for x, y in punkty:
if 0 < x < 5000 and 0 < y < 5000:
wewnatrz += 1
print("3.2 a)", wewnatrz)
zbior = set(punkty)
for i in range(len(punkty)):
for j in range(i + 1, len(punkty)):
(x1, y1), (x2, y2) = punkty[i], punkty[j]
if (x1 + x2) % 2 == 0 and (y1 + y2) % 2 == 0:
srodek = ((x1 + x2) // 2, (y1 + y2) // 2)
if srodek in zbior and srodek != punkty[i]:
print("3.2 b)", punkty[i], srodek, punkty[j])#include <cstdlib>
#include <fstream>
#include <numeric>
#include <print>
#include <set>
#include <utility>
#include <vector>
using Punkt = std::pair<int, int>;
int main() {
std::ifstream plik("dron.txt");
std::vector<Punkt> ruchy;
int a, b;
while (plik >> a >> b) {
ruchy.push_back({a, b});
}
// 3.1
int ile = 0;
for (auto [a, b] : ruchy) {
if (std::gcd(std::abs(a), std::abs(b)) > 1) {
ile += 1;
}
}
std::println("3.1 {}", ile);
// 3.2
std::vector<Punkt> punkty;
int x = 0, y = 0;
for (auto [a, b] : ruchy) {
x += a;
y += b;
punkty.push_back({x, y});
}
int wewnatrz = 0;
for (auto [x, y] : punkty) {
if (0 < x && x < 5000 && 0 < y && y < 5000) {
wewnatrz += 1;
}
}
std::println("3.2 a) {}", wewnatrz);
std::set<Punkt> zbior(punkty.begin(), punkty.end());
for (size_t i = 0; i < punkty.size(); i++) {
for (size_t j = i + 1; j < punkty.size(); j++) {
auto [x1, y1] = punkty[i];
auto [x2, y2] = punkty[j];
if ((x1 + x2) % 2 == 0 && (y1 + y2) % 2 == 0) {
Punkt srodek = {(x1 + x2) / 2, (y1 + y2) / 2};
if (zbior.contains(srodek) && srodek != punkty[i]) {
// para wypisuje się jak krotka w Pythonie: (x, y)
std::println("3.2 b) {} {} {}", punkty[i], srodek, punkty[j]);
}
}
}
}
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Zadanie {
// punkt jako rekord - equals i hashCode działają po wartościach
record Punkt(int x, int y) {
@Override
public String toString() {
return "(" + x + ", " + y + ")";
}
}
static int gcd(int a, int b) {
while (b != 0) {
int t = a % b;
a = b;
b = t;
}
return a;
}
public static void main(String[] args) throws Exception {
List<int[]> ruchy = new ArrayList<>();
for (String wiersz : Files.readAllLines(Path.of("dron.txt"))) {
String[] t = wiersz.trim().split("\\s+");
ruchy.add(new int[]{Integer.parseInt(t[0]), Integer.parseInt(t[1])});
}
// 3.1
int ile = 0;
for (int[] r : ruchy) {
if (gcd(Math.abs(r[0]), Math.abs(r[1])) > 1) {
ile += 1;
}
}
System.out.println("3.1 " + ile);
// 3.2
List<Punkt> punkty = new ArrayList<>();
int x = 0, y = 0;
for (int[] r : ruchy) {
x += r[0];
y += r[1];
punkty.add(new Punkt(x, y));
}
int wewnatrz = 0;
for (Punkt p : punkty) {
if (0 < p.x() && p.x() < 5000 && 0 < p.y() && p.y() < 5000) {
wewnatrz += 1;
}
}
System.out.println("3.2 a) " + wewnatrz);
Set<Punkt> zbior = new HashSet<>(punkty);
for (int i = 0; i < punkty.size(); i++) {
for (int j = i + 1; j < punkty.size(); j++) {
Punkt p1 = punkty.get(i), p2 = punkty.get(j);
if ((p1.x() + p2.x()) % 2 == 0 && (p1.y() + p2.y()) % 2 == 0) {
Punkt srodek = new Punkt((p1.x() + p2.x()) / 2, (p1.y() + p2.y()) / 2);
if (zbior.contains(srodek) && !srodek.equals(p1)) {
System.out.println("3.2 b) " + p1 + " " + srodek + " " + p2);
}
}
}
}
}
}Odpowiedź: 3.1: 40. 3.2: a) 24; b) (5832, 1801), (7410, 1990), (8988, 2179) — środkiem jest (7410, 1990).
↑