Matura informatyka

Matura próbna 2014 — grudzień (formuła od 2015)

PythonC++23Java 25
Treść zadania

Zadanie 1. Liczby Armstronga. Liczba n-cyfrowa jest liczbą Armstronga (narcystyczną), jeśli równa się sumie swoich cyfr podniesionych do potęgi n, np. 153 = 1³ + 5³ + 3³.

  • 1.1 — sprawdź (P/F), czy liczbami Armstronga są 6, 407 i 2278.
  • 1.2 — zapisz algorytm, który dla liczby całkowitej dodatniej k umieści jej cyfry w tablicy tab_cyfr[] od najmniej do najbardziej znaczącej i zwróci liczbę cyfr n. Przykład: k = 54321 → n = 5, tab_cyfr = [1,2,3,4,5].
  • 1.3 — zapisz algorytm sprawdzający, czy k jest liczbą narcystyczną, mając dane k, n, tablicę tab_cyfr[] (jak w 1.2) i funkcję potega(a, n). Wynik: PRAWDA albo FAŁSZ.
Python
def cyfry(k):
    # 1.2 - cyfry od najmniej znaczacej, n - liczba cyfr
    tab_cyfr = []
    while True:
        tab_cyfr.append(k % 10)
        k = k // 10
        if k == 0:
            break
    return len(tab_cyfr), tab_cyfr


def czy_armstronga(k):
    # 1.3 - odejmujemy od k kolejne cyfry podniesione do potegi n
    n, tab_cyfr = cyfry(k)
    for j in range(n):
        k = k - tab_cyfr[j] ** n
    return k == 0


print(cyfry(54321))
for k in [6, 407, 2278]:
    print(k, "P" if czy_armstronga(k) else "F")

Odpowiedź: 1.1: 6 — P, 407 — P, 2278 — F; dla k = 54321: n = 5, tab_cyfr = [1, 2, 3, 4, 5]

↑
PythonC++23Java 25
Treść zadania

Zadanie 3. Kodowanie. Gdy tekst zawiera mniej niż 255 różnych znaków, można przypisać im kolejne kody binarne (większe od 0) o najmniejszej wystarczającej liczbie bitów i zapisać je jeden za drugim w bajtach; niewykorzystane bity ostatniego bajtu uzupełnia się zerami. Przykład: HANIA przy kodach H=001, A=010, N=011, I=100 daje bajty 41 i 196.

  • 3.1 — zdekoduj tekst zapisany w dwóch bajtach o wartościach dziesiętnych 110 i 64, jeśli każdy znak ma 2 bity: K=01, A=10, J=11.
  • 3.3 — zapisz algorytm dekodowania: dane są tablica bajtów v[] o n elementach, liczba różnych znaków r, tablica par {znak, kod} t[] i liczba bitów na znak bity; wynikiem jest tekst źródłowy s. Można użyć funkcji testBit(bajt, numerBitu) (czy bit jest równy 1) oraz ustawBit(bajt, numerBitu) (ustawia bit na 1).
Python
def dekoduj(v, t, bity):
    # v - bajty tekstu skompresowanego, t - slownik {kod: znak}
    # bity czytamy od najstarszego bitu kazdego bajtu
    ciag_bitow = ""
    for bajt in v:
        ciag_bitow += bin(bajt)[2:].zfill(8)
    s = ""
    for i in range(0, len(ciag_bitow) - bity + 1, bity):
        kod = int(ciag_bitow[i:i + bity], 2)
        if kod in t:            # kod 0 to bity wolne na koncu
            s += t[kod]
    return s


print(bin(110)[2:].zfill(8), bin(64)[2:].zfill(8))
print(dekoduj([110, 64], {1: "K", 2: "A", 3: "J"}, 2))
print(dekoduj([41, 196], {1: "H", 2: "A", 3: "N", 4: "I"}, 3))

Odpowiedź: 3.1: 01101110 01000000 — KAJAK

↑
PythonC++23Java 25
Treść zadania

Kodowanie tekstu jak w zadaniu 3. Zapisz algorytm, który dla łańcucha znaków s zwraca liczbę r różnych znaków w tym tekście (zakładamy r < 100).

Python
def rozne_znaki(s):
    R = []
    for znak in s:
        if znak not in R:
            R.append(znak)
    return len(R)


print(rozne_znaki("AAAABBBCCCBBBAAACC"), rozne_znaki("HANIA"))

Odpowiedź: dla "HANIA" r = 4

↑
PythonC++23Java 25

Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.

Treść zadania

Zadanie 4. Wirujący dysk i mrówka. Ruch punktu po okręgu o środku (0,0) opisują wzory x = r·sin(2πt/T), y = r·cos(2πt/T), gdzie r — promień, t — czas, T — okres obiegu. Wyniki zapisz w pliku dysk_mrowka.txt, poprzedzając każdy numerem zadania.

  • 4.1 — dla r = 5, T = 12,5 i kroku czasowego Δt = 0,05, zaczynając od t = 3, podaj, po jakim czasie (z dokładnością do setnych sekundy) współrzędna y mrówki stanie się większa od x.
  • 4.3 — mrówka idzie od środka obracającej się tarczy wzdłuż promienia z prędkością v, więc r = v·t i jej torem jest spirala (jak w zadaniu 4.2: T = 10, v = 1). Dla Δt = 0,5 oblicz łączną długość odcinków łączących kolejne punkty toru w ciągu pierwszych 10 sekund, zaczynając od (0,0). Wynik podaj z dokładnością do 4 miejsc po przecinku.
Python
import math

# 4.1 - x = r*sin(2*pi*t/T), y = r*cos(2*pi*t/T)
r, T, dt, t_pocz = 5, 12.5, 0.05, 3
krok = 0
while True:
    t = t_pocz + krok * dt
    x = r * math.sin(2 * math.pi * t / T)
    y = r * math.cos(2 * math.pi * t / T)
    if y > x:
        print("4.1", round(t - t_pocz, 2), "(czas od poczatku ruchu:", round(t, 2), ")")
        break
    krok += 1

# 4.3 - spirala r = v*t, T = 10, dt = 0,5, pierwsze 10 sekund
T, dt, v = 10, 0.5, 1
punkty = []
for i in range(21):
    t = i * dt
    punkty.append((v * t * math.sin(2 * math.pi * t / T), v * t * math.cos(2 * math.pi * t / T)))

dlugosc = 0
for i in range(1, len(punkty)):
    dlugosc += math.dist(punkty[i - 1], punkty[i])
print("4.3", f"{dlugosc:.4f}")

Odpowiedź: 4.1: 4,85 s (czyli 7,85 s od początku ruchu); 4.3: 33,6520

↑
PythonC++23Java 25

Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.

Treść zadania

Wirujący dysk i mrówka jak w zadaniu 4. Mrówka startuje ze środka tarczy i idzie wzdłuż promienia z prędkością v, więc jej odległość od środka to r = v·t, a tor (dla obserwatora z zewnątrz) jest spiralą. Dla T = 10, Δt = 0,5, v = 1 wykreśl tor ruchu mrówki w ciągu pierwszych 10 sekund i zapisz czytelny wykres w pliku.

Python
import math

# punkty spirali do wykresu punktowego (x, y) w arkuszu
with open("spirala_4_2.txt", "w") as wynik:
    wynik.write("t;x;y\n")
    for i in range(21):
        t = i * 0.5
        x = t * math.sin(2 * math.pi * t / 10)
        y = t * math.cos(2 * math.pi * t / 10)
        wynik.write(f"{t};{x:.4f};{y:.4f}\n")

Odpowiedź: wykres punktowy z liniami (spirala) tworzymy z pliku spirala_4_2.txt

↑
PythonC++23Java 25
Treść zadania

Zadanie 5. Zawody sportowe. W pliku dziennik.txt jest 310 liczb (po jednej w wierszu) — długości najlepszych skoków Mateusza w cm w kolejnych dniach treningowych. Pozytywna seria treningowa to maksymalny (nieprzedłużalny) ciąg kolejnych dni, w którym każdy wynik jest lepszy od poprzedniego. Przykład: w ciągu 478 475 470 480 481 481 475 477 480 482 470 najdłuższa seria to 475 477 480 482 (4 dni, poprawa o 7 cm). Odpowiedzi zapisz w pliku wynik5.txt, poprzedzając każdą numerem zadania.

  • 5.1 — podaj, ile było pozytywnych serii dłuższych niż 3 dni.
  • 5.2 — podaj długość najdłuższego i najkrótszego skoku oraz numery tych wyników (licząc od początku dziennika).
  • 5.3 — podaj długość (w dniach) najdłuższej pozytywnej serii i o ile centymetrów Mateusz poprawił w niej wynik.
Python
wyniki = []
with open("dziennik.txt") as file:
    for line in file:
        if line.strip():
            wyniki.append(int(line))

# 5.1 i 5.3 - pozytywne serie: (dlugosc, poprawa)
serie = []
poczatek = 0
for i in range(1, len(wyniki) + 1):
    if i == len(wyniki) or wyniki[i] <= wyniki[i - 1]:
        serie.append((i - poczatek, wyniki[i - 1] - wyniki[poczatek]))
        poczatek = i

print("5.1", sum(1 for dlugosc, poprawa in serie if dlugosc > 3))

najdluzszy = max(wyniki)
najkrotszy = min(wyniki)
print("5.2", najdluzszy, wyniki.index(najdluzszy) + 1, najkrotszy, wyniki.index(najkrotszy) + 1)

print("5.3", *max(serie))

Odpowiedź: 5.1: 11; 5.2: najdłuższy 601 (176. wynik), najkrótszy 401 (17. wynik); 5.3: 6 dni, poprawa o 158 cm

↑

Edytuj na GitHubie