Matura informatyka maj 2025, zadanie 1 (przestaw) — rozwiązanie · Variant — matura z informatyki

Funkcja przestaw bierze liczbę po dwie cyfry od prawej i w każdej takiej parze zamienia cyfry miejscami. 316498 → 31|64|98 → 13|46|89 → 134689.

Arkusz CKE — maj 2025, rozszerzony

Zasada — `% 100` i `// 100`

def przestaw(n):
    r = n % 100          # ostatnie dwie cyfry
    a = r // 10          # dziesiątki
    b = r % 10           # jedności
    n = n // 100         # obetnij dwie cyfry
    if n > 0:
        return a + 10*b + 100 * przestaw(n)
    else:
        return a + 10*b if a > 0 else b

Gałąź else obsługuje ostatnią, najbardziej lewą grupę: dwie cyfry zamienia, pojedynczą zostawia. Stąd poprawne działanie dla nieparzystej liczby cyfr.

Każde wywołanie zjada dwie cyfry, więc dla liczby k-cyfrowej wywołań jest ⌈k/2⌉.

Zadanie 1.1 — uzupełnienie tabeli

`n`	`przestaw(n)`	wywołań
316498	134689	3
43657688	34566788	4
154005710	145007501	5
998877665544321	989786756453412	8

Szybkie sprawdzenie: wynik ma zawsze tyle samo cyfr co wejście. Jeśli zgubiłeś cyfrę, pomyliłeś grupowanie.

Zadanie 1.2 — prawda czy fałsz

Liczba k-cyfrowa, dwie cyfry na wywołanie, więc wywołań jest ⌈k/2⌉ = (k+1) div 2.

#	wyrażenie	ocena
1	`k/2`	F
2	`(k+1) div 2`	P
3	`k/2` gdy `k` parzyste, `(k+1)/2` gdy nieparzyste	P
4	`(k+1)/2`	F

Odpowiedź: F P P F

Sprawdź na danych z tabeli: k=6 → 3, k=8 → 4, k=9 → 5, k=15 → 8.

Zadanie 1.3 — wersja nierekurencyjna

Treść zabrania rekurencji. Stos wywołań zamieniasz na pętlę z mnożnikiem pozycji p, który rośnie razy 100 co krok.

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

Mnożnik p robi dokładnie to, co w rekurencji robiło 100 * przestaw(...). To jest uniwersalny sposób zamiany rekurencji ogonowej z mnożeniem przez stałą na pętlę.

Gdzie tracisz punkty

Warunek ostatniej grupy to n > 9, nie n > 0. Po n = n // 100 może zostać jeszcze jedna cyfra. Przy n > 0 dodasz 10*p*b zamiast p*b i wynik będzie przesunięty o rząd wielkości.
Mylenie div ze zwykłym dzieleniem w 1.2. Stwierdzenia 2 i 4 różnią się wyłącznie tym operatorem. Czytaj, które jest całkowite.
Złe grupowanie przy nieparzystej liczbie cyfr. Grupy liczysz od prawej, nie od lewej.