Lekcja 30: Sprawdzian koncowy - klasa I

Odpowiedz: b) 11001

Rozwiazanie:
25 / 2 = 12 reszta 1
12 / 2 = 6  reszta 0
6  / 2 = 3  reszta 0
3  / 2 = 1  reszta 1
1  / 2 = 0  reszta 1

Czytamy od dolu: 11001

Odpowiedz: c) 12

Algorytm Euklidesa:
NWD(48, 36):
  48 % 36 = 12 -> NWD(36, 12)
  36 % 12 = 0  -> NWD(12, 0)
  b == 0, wiec NWD = 12

Odpowiedz: b) 0, 1, 1, 2, 3, 5, 8

Kazdy wyraz (od trzeciego) jest suma dwoch poprzednich:
0 + 1 = 1
1 + 1 = 2
1 + 2 = 3
2 + 3 = 5
3 + 5 = 8

Odpowiedz: a) NRW

K + 3 = N
O + 3 = R
T + 3 = W

Odpowiedz: c) sortowanie babelkowe

Sortowanie babelkowe (bubble sort) porownuje
sasiadujace elementy i zamienia je, jesli sa
w zlej kolejnosci. "Babelki" wiekszych elementow
"wyplywaja" na koniec listy.

Odpowiedz: b) Trzeba podac autora (BY = Attribution),
nie mozna uzywac komercyjnie (NC = NonCommercial).

Odpowiedz: c) MojPies!Lubi3$Spacery

- 21 znakow (dluzsze = lepsze)
- Duze i male litery
- Cyfry i znaki specjalne
- Fraza latwa do zapamietania
- Nie wystepuje w slownikach hasel

Odpowiedz: c) O(n^2)

Sortowanie babelkowe uzywa dwoch zagniezdzonych
petli, kazda iterujaca po n elementach.
Dlatego zlozonosc to O(n * n) = O(n^2).

NWD(84, 56):
Krok 1: 84 % 56 = 28 -> NWD(56, 28)
Krok 2: 56 % 28 = 0  -> NWD(28, 0)
b == 0, wiec NWD(84, 56) = 28

NWW(84, 56) = 84 * 56 / NWD(84, 56)
NWW(84, 56) = 4704 / 28 = 168

Lista poczatkowa: [5, 2, 8, 1, 9]

Przebieg 1:
  [5,2] -> zamiana -> [2, 5, 8, 1, 9]
  [5,8] -> OK      -> [2, 5, 8, 1, 9]
  [8,1] -> zamiana -> [2, 5, 1, 8, 9]
  [8,9] -> OK      -> [2, 5, 1, 8, 9]
Stan po przebiegu 1: [2, 5, 1, 8, 9]

Przebieg 2:
  [2,5] -> OK      -> [2, 5, 1, 8, 9]
  [5,1] -> zamiana -> [2, 1, 5, 8, 9]
  [5,8] -> OK      -> [2, 1, 5, 8, 9]
Stan po przebiegu 2: [2, 1, 5, 8, 9]

Przebieg 3:
  [2,1] -> zamiana -> [1, 2, 5, 8, 9]
  [2,5] -> OK      -> [1, 2, 5, 8, 9]
Stan po przebiegu 3: [1, 2, 5, 8, 9]

Przebieg 4:
  [1,2] -> OK      -> [1, 2, 5, 8, 9]
Stan po przebiegu 4: [1, 2, 5, 8, 9]

Wynik: [1, 2, 5, 8, 9] - POSORTOWANA!

import math

def czy_pierwsza(n):
    if n < 2:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True

def analizuj(lista):
    if not lista:
        return {"blad": "Lista jest pusta"}

    # Minimum (bez min())
    mini = lista[0]
    for x in lista:
        if x < mini:
            mini = x

    # Maksimum (bez max())
    maksi = lista[0]
    for x in lista:
        if x > maksi:
            maksi = x

    # Srednia
    suma = 0
    for x in lista:
        suma += x
    srednia = suma / len(lista)

    # Parzyste
    parzyste = 0
    for x in lista:
        if x % 2 == 0:
            parzyste += 1

    # Pierwsze
    pierwsze = 0
    for x in lista:
        if czy_pierwsza(x):
            pierwsze += 1

    return {
        "minimum": mini,
        "maksimum": maksi,
        "srednia": round(srednia, 2),
        "parzyste": parzyste,
        "pierwsze": pierwsze
    }

# Test
dane = [12, 7, 3, 18, 5, 2, 11, 4, 9, 13]
wynik = analizuj(dane)
print(f"Lista: {dane}")
for klucz, wartosc in wynik.items():
    print(f"  {klucz}: {wartosc}")

# Oczekiwany wynik:
# minimum: 2, maksimum: 18, srednia: 8.4
# parzyste: 4 (12, 18, 2, 4)
# pierwsze: 5 (7, 3, 5, 2, 11, 13) -> 6!

def szyfruj(tekst, klucz):
    wynik = ""
    for z in tekst:
        if 'a' <= z <= 'z':
            wynik += chr((ord(z) - ord('a') + klucz) % 26 + ord('a'))
        elif 'A' <= z <= 'Z':
            wynik += chr((ord(z) - ord('A') + klucz) % 26 + ord('A'))
        else:
            wynik += z
    return wynik

def deszyfruj(tekst, klucz):
    return szyfruj(tekst, -klucz)

def sortuj_babelkowo(lista):
    tab = lista.copy()
    n = len(tab)
    for i in range(n - 1):
        for j in range(n - 1 - i):
            if tab[j].lower() > tab[j+1].lower():
                tab[j], tab[j+1] = tab[j+1], tab[j]
    return tab

# Wczytaj zdania
zdania = []
for i in range(3):
    z = input(f"Podaj zdanie {i+1}: ")
    zdania.append(z)

# Szyfruj
klucz = 5
zaszyfrowane = [szyfruj(z, klucz) for z in zdania]
print("\n--- Zaszyfrowane ---")
for z in zaszyfrowane:
    print(f"  {z}")

# Sortuj
posortowane = sortuj_babelkowo(zaszyfrowane)
print("\n--- Posortowane (zaszyfrowane) ---")
for z in posortowane:
    print(f"  {z}")

# Deszyfruj
print("\n--- Odszyfrowane ---")
for z in posortowane:
    print(f"  {deszyfruj(z, klucz)}")

# Przykladowy test:
# Zdanie 1: "Python jest super"
# Zdanie 2: "Algorytmy sa wazne"
# Zdanie 3: "Informatyka to przyszlosc"