Klasa 4 · rozdział 7 · lekcje 40–45 · II okres
Szyfrowanie
Cezar przesuwa litery. Podstawieniowy wymienia je według klucza.
Przestawieniowy zostawia te same litery i zmienia kolejność.
Wspólna baza Szyfr ma szyfruj i deszyfruj.
Poza zakresem zostają RSA i inne szyfry z kluczem publicznym.
Po tym rozdziale powinieneś umieć
- nazwać tekst jawny, szyfrogram i klucz;
- zaszyfrować i odszyfrować Cezara z zawijaniem alfabetu;
- zastosować podstawienie 26 liter i przestawienie parami;
- zostawić znaki spoza a–z i A–Z bez zmian;
- ująć szyfr w klasie z metodami, bez
cinw środku; - porównać siłę szkolną: Cezar ma 25 sensownych kluczy, podstawienie — znacznie więcej.
1. Tekst jawny, szyfr, klucz
Tekst jawny to wiadomość przed zaszyfrowaniem. Szyfrogram to wynik. Klucz mówi, jak przekształcić. Deszyfrowanie tym samym kluczem (albo kluczem wyliczonym z niego) ma oddać tekst jawny. Na lekcji alfabet to 26 liter łacińskich, osobno małe i wielkie. Cyfry, spacje i polskie znaki zostają bez zmian — takie jest ustalenie tego podręcznika.
Dwie rodziny. Podstawienie zmienia która litera stoi na danym miejscu (Cezar jest jego szczególnym przypadkiem: każda litera idzie o stałą liczbę pozycji). Przestawienie zmienia gdzie litera stoi, a zestaw liter zostaje ten sam.
2. Szyfr Cezara
Klucz to przesunięcie 0…25. Litera c idzie na pozycję (c - 'a' + k) % 26 w swoim alfabecie.
Klucz 1: Abc → Bcd. Klucz 0 nic nie zmienia. Deszyfrowanie to przesunięcie o 26 - (k % 26),
albo o -k po sprowadzeniu reszty do 0…25.
char przesun(char c, int k) {
k %= 26;
if (k < 0) k += 26;
if (c >= 'a' && c <= 'z')
return 'a' + (c - 'a' + k) % 26;
if (c >= 'A' && c <= 'Z')
return 'A' + (c - 'A' + k) % 26;
return c;
}
string cezar(const string& tekst, int k) {
string w = tekst;
for (int i = 0; i < (int)w.size(); i++)
w[i] = przesun(w[i], k);
return w;
}
cezar("Abc z!", 1) → Bcd a!. Wykrzyknik i spacja stoją.
cezar(cezar("Abc z!", 1), -1) wraca do Abc z!.
Pusty napis zostaje pusty. Klucz 27 działa jak 1, bo k % 26.
3. Szyfr podstawieniowy
Klucz to 26 liter — obraz alfabetu. Pozycja 0 mówi, na co idzie a, pozycja 1 — na co idzie b.
Wielkie litery idą tym samym obrazem, z zachowaniem wielkości. Deszyfrowanie szuka litery w kluczu
i wraca do pozycji w alfabecie. Klucz musi być permutacją: każda litera dokładnie raz, inaczej deszyfrowanie jest niejednoznaczne.
string podstaw(const string& tekst, const string& klucz, bool szyfruj) {
string w = tekst;
for (int i = 0; i < (int)w.size(); i++) {
char c = w[i];
bool wielka = c >= 'A' && c <= 'Z';
char mala = wielka ? c - 'A' + 'a' : c;
if (mala < 'a' || mala > 'z') continue;
int poz;
if (szyfruj) poz = mala - 'a';
else {
poz = (int)klucz.find(mala);
if (poz < 0) continue;
}
char n = szyfruj ? klucz[poz] : char('a' + poz);
w[i] = wielka ? n - 'a' + 'A' : n;
}
return w;
}
Klucz qwertyuiopasdfghjklzxcvbnm (26 znaków, każda litera raz).
a idzie na q, b na w. ab → qw.
Deszyfrowanie szuka q w kluczu (pozycja 0) i wraca do a.
Cezar z kluczem 1 da się zapisać jako podstawienie bcdefghijklmnopqrstuvwxyza — jeden mechanizm, szczególny klucz.
4. Szyfr przestawieniowy
Litery się nie zmieniają, zmieniają się miejsca. Wersja z lekcji zamienia sąsiednie pary: pozycje (0,1), (2,3), … Ostatnia litera nieparzystego tekstu zostaje. Ta sama funkcja szyfruje i deszyfruje, bo druga zamiana par wraca do układu początkowego.
string pary(string s) {
for (int i = 0; i + 1 < (int)s.size(); i += 2) {
char tmp = s[i];
s[i] = s[i + 1];
s[i + 1] = tmp;
}
return s;
}
pary("KOT") → OKT. pary("OKT") → KOT.
pary("AB") → BA. Pusty napis i jedna litera nic nie zmieniają.
To nie jest Cezar: K nie stało się następną literą alfabetu, tylko zamieniło się miejscem z O.
KOT i OKT mają te same litery. Abc i Bcd — nie.
5. Szyfr jako klasa
Wspólna umowa: każda pochodna umie zaszyfrować i odszyfrować. Baza jest abstrakcyjna.
main trzyma Szyfr* i nie wie, czy to Cezar, czy pary.
Metody nie wołają cin. Klucz Cezara jest polem prywatnym.
class Szyfr {
public:
virtual string szyfruj(const string& tekst) const = 0;
virtual string deszyfruj(const string& tekst) const = 0;
virtual ~Szyfr() {}
};
class Cezar : public Szyfr {
int klucz;
public:
Cezar(int k) : klucz(k) {
if (k < 0) throw invalid_argument("klucz");
}
string szyfruj(const string& tekst) const override {
return cezar(tekst, klucz);
}
string deszyfruj(const string& tekst) const override {
return cezar(tekst, -klucz);
}
};
class Pary : public Szyfr {
public:
string szyfruj(const string& tekst) const override { return pary(tekst); }
string deszyfruj(const string& tekst) const override { return pary(tekst); }
};
Test obiektu: deszyfruj(szyfruj(tekst)) równa się tekst.
Dotyczy pustego napisu, jednej litery, znaku spoza alfabetu i zwykłego słowa.
Klucz ujemny w konstruktorze Cezara jest błędem umowy — wyjątek, nie „przesuń w drugą stronę po cichu”.
Deszyfrowanie wolno liczyć ujemnym przesunięciem wewnątrz metody, bo to już nie wejście użytkownika.
6. Porównanie
| Cezar | Podstawienie | Pary | |
|---|---|---|---|
| Co się zmienia | Litera o stałą | Litera według klucza | Pozycja, nie litera |
| Odwracalność | Przesunięcie −k | Szukanie w kluczu | Ta sama operacja drugi raz |
| Liczba kluczy szkolnie | 25 nietrywialnych | permutacje 26 liter | w tej wersji jeden schemat |
| Znaki spoza alfabetu | bez zmian | bez zmian | też wędrują, bo to pozycje |
Pary przesuwają także spację i cyfrę, bo nie patrzą na alfabet — patrzą na indeks.
Cezar i podstawienie zostawiają je. To różnica, którą sprawdzasz testem "A!":
Cezar z kluczem 1 daje "B!", pary dają "!A".
Ćwiczenia do samodzielnego wykonania
Folder: Dokumenty\cwiczenia-po\klasa-4\rozdzial-07.
Ćwiczenie 1. Cezar łatwe
Abc z! kluczem 1 → Bcd a!. Deszyfrowanie wraca do oryginału. Pusty napis zostaje pusty.
Ćwiczenie 2. Klucz 27 łatwe
Pokaż, że klucz 27 daje to samo co 1. W komentarzu: skąd % 26.
Ćwiczenie 3. Podstawienie średnie
Klucz 26 różnych liter. Zaszyfruj ab i odszyfruj. Znak ! zostaje.
Ćwiczenie 4. Pary średnie
KOT → OKT → KOT. Porównaj litery z Cezarem: w jednym zdaniu napisz, czemu to przestawienie.
Ćwiczenie 5. Klasa trudne
Cezar i Pary jako pochodne Szyfr. Wskaźnik do bazy. Test okrągły: deszyfruj(szyfruj(s)) == s, w tym "A!" i "".
Ćwiczenie 6. 25 kluczy trudne
Dla szyfrogramu Cezara wypisz 25 możliwych tekstów. Wskaż, który czyta się po polsku albo po angielsku. Napisz, czemu podstawienie nie da się tak przejść pętlą 1…25.
Sprawdź się
Wymagania na ocenę
Dział 7 planu (lekcje 40–45), ocena roczna. Ocena wyższa zawiera wymagania na oceny niższe.
| Ocena | Uczeń |
|---|---|
| 2 | Omawia ideę Cezara. Szyfruje krótki tekst przesunięciem z pomocą wzoru. |
| 3 | Programuje Cezara (szyfrowanie i deszyfrowanie). Omawia ideę podstawienia albo przestawienia. |
| 4 | Programuje wybrany szyfr przestawieniowy lub podstawieniowy. Wydziela szyfrowanie do funkcji. Znaki spoza alfabetu zostawia zgodnie z ustaleniem lekcji. |
| 5 | Programuje szyfr jako klasę z szyfruj i deszyfruj. Testuje pusty napis i znaki spoza alfabetu. Sprawdza, że deszyfrowanie wraca do tekstu jawnego. |
| 6 | Porównuje poznane szyfry (odwracalność, liczba kluczy). Może wypisać 25 wariantów Cezara i wskazać, czemu podstawienia tak nie przejdziesz. |