Matura informatyka

Matura 2025 — maj, poziom rozszerzony (formuła 2023)

PythonC++23Java 25
Treść zadania

Dana jest rekurencyjna funkcja przestaw dla nieujemnej liczby całkowitej n (mod — reszta, div — część całkowita z dzielenia):

Kod
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.
Python
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)

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).

↑
PythonC++23Java 25
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).

Python
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)

Odpowiedź: funkcja przestaw2 (daje te same wyniki co przestaw).

↑
PythonC++23Java 25
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+).
Python
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))

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*++.

↑
PythonC++23Java 25
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).
Python
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])

Odpowiedź: 3.1: 40. 3.2: a) 24; b) (5832, 1801), (7410, 1990), (8988, 2179) — środkiem jest (7410, 1990).

↑

Edytuj na GitHubie