Matura 2016 — maj, poziom rozszerzony
ARKUSZ CZ. IARKUSZ CZ. IIDANEODPOWIEDZI
Treść zadania
Liczby skojarzone. Dwie różne liczby całkowite a, b > 1 są skojarzone, jeśli suma wszystkich dodatnich dzielników a mniejszych od a wynosi b + 1, a suma wszystkich dodatnich dzielników b mniejszych od b wynosi a + 1. Np. 140 i 195 są skojarzone: dzielniki 140 sumują się do 196 = 195 + 1, a dzielniki 195 — do 141 = 140 + 1.
- 1.1 — Dla par (78, 64), (20, 21), (75, 48) podaj dzielniki a i b (mniejsze od tych liczb), ich sumy oraz rozstrzygnij, czy liczby są skojarzone (dla pary 78, 64: sumy 90 i 63, odpowiedź NIE).
- 1.2 — Zapisz algorytm, który dla danej liczby całkowitej a > 1 znajdzie i wypisze liczbę b skojarzoną z a albo komunikat „NIE”, jeśli taka liczba nie istnieje. Wolno używać tylko dodawania, odejmowania, mnożenia, dzielenia całkowitego i reszty z dzielenia; oceniana jest też liczba wykonywanych operacji arytmetycznych.
def suma_dzielnikow(n):
# suma dzielników n mniejszych od n - sprawdzamy tylko i <= pierwiastek(n)
suma = 1
i = 2
while i * i <= n:
if n % i == 0:
suma += i
if n // i != i:
suma += n // i
i += 1
return suma
def czy_skojarzone(a, b):
return a != b and suma_dzielnikow(a) == b + 1 and suma_dzielnikow(b) == a + 1
def skojarzona(a):
b = suma_dzielnikow(a) - 1
if b > 1 and b != a and suma_dzielnikow(b) == a + 1:
return b
return "NIE"
# 1.1
for a, b in [(78, 64), (20, 21), (75, 48)]:
print(a, b, suma_dzielnikow(a), suma_dzielnikow(b), "TAK" if czy_skojarzone(a, b) else "NIE")
# 1.2
print(skojarzona(140), skojarzona(75), skojarzona(20))#include <iostream>
#include <string>
#include <utility>
long long suma_dzielnikow(long long n) {
// suma dzielników n mniejszych od n - sprawdzamy tylko i <= pierwiastek(n)
long long suma = 1;
long long i = 2;
while (i * i <= n) {
if (n % i == 0) {
suma += i;
if (n / i != i)
suma += n / i;
}
i++;
}
return suma;
}
bool czy_skojarzone(long long a, long long b) {
return a != b && suma_dzielnikow(a) == b + 1 && suma_dzielnikow(b) == a + 1;
}
std::string skojarzona(long long a) { // liczba skojarzona albo "NIE"
long long b = suma_dzielnikow(a) - 1;
if (b > 1 && b != a && suma_dzielnikow(b) == a + 1)
return std::to_string(b);
return "NIE";
}
int main() {
// 1.1
for (auto [a, b] : {std::pair{78, 64}, std::pair{20, 21}, std::pair{75, 48}})
std::cout << a << ' ' << b << ' ' << suma_dzielnikow(a) << ' ' << suma_dzielnikow(b) << ' '
<< (czy_skojarzone(a, b) ? "TAK" : "NIE") << '\n';
// 1.2
std::cout << skojarzona(140) << ' ' << skojarzona(75) << ' ' << skojarzona(20) << '\n';
}public class Zadanie {
static long sumaDzielnikow(long n) {
// suma dzielników n mniejszych od n - sprawdzamy tylko i <= pierwiastek(n)
long suma = 1;
long i = 2;
while (i * i <= n) {
if (n % i == 0) {
suma += i;
if (n / i != i)
suma += n / i;
}
i++;
}
return suma;
}
static boolean czySkojarzone(long a, long b) {
return a != b && sumaDzielnikow(a) == b + 1 && sumaDzielnikow(b) == a + 1;
}
static String skojarzona(long a) { // liczba skojarzona albo "NIE"
long b = sumaDzielnikow(a) - 1;
if (b > 1 && b != a && sumaDzielnikow(b) == a + 1)
return String.valueOf(b);
return "NIE";
}
public static void main(String[] args) {
// 1.1
int[][] pary = {{78, 64}, {20, 21}, {75, 48}};
for (var p : pary)
System.out.println(p[0] + " " + p[1] + " " + sumaDzielnikow(p[0]) + " " + sumaDzielnikow(p[1]) + " "
+ (czySkojarzone(p[0], p[1]) ? "TAK" : "NIE"));
// 1.2
System.out.println(skojarzona(140) + " " + skojarzona(75) + " " + skojarzona(20));
}
}Odpowiedź: 1.1: (78, 64) NIE, (20, 21) sumy 22 i 11 - NIE, (75, 48) sumy 49 i 76 - TAK. 1.2: b = suma_dzielnikow(a) - 1, sprawdzamy, czy suma_dzielnikow(b) = a + 1.
↑Treść zadania
Przestawienia w tablicy. Dana jest dodatnia liczba całkowita n i tablica A[1..n] liczb całkowitych. Funkcja przestawia elementy tak, by na lewo znalazły się elementy mniejsze od klucza (pierwszego elementu tablicy), a na prawo — większe lub równe:
funkcja przestaw(A)
klucz ← A[1]
w ← 1
dla k = 2, 3, ..., n wykonaj
jeśli A[k] < klucz
zamień(A[w], A[k])
w ← w + 1- 2.1 — Podaj kolejność elementów tablicy A = [4, 6, 3, 5, 2, 1] (n = 6) po wykonaniu przestaw(A).
- 2.2 — Podaj przykład siedmioelementowej tablicy A, dla której funkcja wykona
zamieńdokładnie 5 razy. - 2.3 — Tablica A[1..100] zawiera liczby 1–100 w kolejności: najpierw rosnąco liczby kończące się na 0 (10, 20, …, 100), potem rosnąco kończące się na 9 (9, 19, …, 99), potem na 8 itd., aż do 1, 11, …, 91. Podaj wartość zmiennej w oraz A[1], A[2], A[3] po wykonaniu przestaw(A).
def przestaw(A):
# A indeksowana od 0 (w treści od 1); zwraca w (indeksowane od 1) i liczbę zamian
klucz = A[0]
w = 0
zamiany = 0
for k in range(1, len(A)):
if A[k] < klucz:
A[w], A[k] = A[k], A[w]
w += 1
zamiany += 1
return w + 1, zamiany
# 2.1
A = [4, 6, 3, 5, 2, 1]
przestaw(A)
print(A)
# 2.2 - zamiana wykona się tyle razy, ile elementów A[2..n] jest mniejszych od A[1]
A = [8, 1, 2, 3, 4, 5, 9]
print(przestaw(A)[1])
# 2.3
A = []
for koncowka in [0, 9, 8, 7, 6, 5, 4, 3, 2, 1]:
for liczba in range(1, 101):
if liczba % 10 == koncowka:
A.append(liczba)
w, zamiany = przestaw(A)
print(w, A[0], A[1], A[2])#include <iostream>
#include <utility>
#include <vector>
std::pair<int, int> przestaw(std::vector<int>& A) {
// A indeksowana od 0 (w treści od 1); zwraca w (indeksowane od 1) i liczbę zamian
int klucz = A[0];
int w = 0;
int zamiany = 0;
for (size_t k = 1; k < A.size(); k++) {
if (A[k] < klucz) {
std::swap(A[w], A[k]);
w++;
zamiany++;
}
}
return {w + 1, zamiany};
}
int main() {
// 2.1
std::vector<int> A = {4, 6, 3, 5, 2, 1};
przestaw(A);
std::cout << '['; // lista wypisana jak w Pythonie
for (size_t i = 0; i < A.size(); i++)
std::cout << (i > 0 ? ", " : "") << A[i];
std::cout << "]\n";
// 2.2 - zamiana wykona się tyle razy, ile elementów A[2..n] jest mniejszych od A[1]
A = {8, 1, 2, 3, 4, 5, 9};
std::cout << przestaw(A).second << '\n';
// 2.3
A.clear();
for (int koncowka : {0, 9, 8, 7, 6, 5, 4, 3, 2, 1})
for (int liczba = 1; liczba < 101; liczba++)
if (liczba % 10 == koncowka)
A.push_back(liczba);
auto [w, zamiany] = przestaw(A);
std::cout << w << ' ' << A[0] << ' ' << A[1] << ' ' << A[2] << '\n';
}import java.util.*;
public class Zadanie {
// A indeksowana od 0 (w treści od 1); zwraca {w (indeksowane od 1), liczba zamian}
static int[] przestaw(List<Integer> A) {
int klucz = A.get(0);
int w = 0;
int zamiany = 0;
for (int k = 1; k < A.size(); k++) {
if (A.get(k) < klucz) {
Collections.swap(A, w, k);
w++;
zamiany++;
}
}
return new int[] {w + 1, zamiany};
}
public static void main(String[] args) {
// 2.1
var A = new ArrayList<>(List.of(4, 6, 3, 5, 2, 1));
przestaw(A);
System.out.println(A);
// 2.2 - zamiana wykona się tyle razy, ile elementów A[2..n] jest mniejszych od A[1]
A = new ArrayList<>(List.of(8, 1, 2, 3, 4, 5, 9));
System.out.println(przestaw(A)[1]);
// 2.3
A = new ArrayList<>();
for (int koncowka : new int[] {0, 9, 8, 7, 6, 5, 4, 3, 2, 1})
for (int liczba = 1; liczba < 101; liczba++)
if (liczba % 10 == koncowka)
A.add(liczba);
int[] wynik = przestaw(A);
System.out.println(wynik[0] + " " + A.get(0) + " " + A.get(1) + " " + A.get(2));
}
}Odpowiedź: 2.1: A = [3, 2, 1, 5, 6, 4]; 2.2: np. [8, 1, 2, 3, 4, 5, 9]; 2.3: w = 10, A[1] = 9, A[2] = 8, A[3] = 7
↑Treść zadania
Na płaszczyźnie narysowano kwadrat o boku 400 i środku w punkcie (200, 200), o bokach równoległych do osi, i wpisano w niego koło. W pliku punkty.txt jest 10 000 wylosowanych punktów kwadratu — w każdym wierszu dwie liczby całkowite x, y z zakresu ⟨0, 400⟩ oddzielone spacją. Wyniki zapisz w pliku wyniki_4.txt, poprzedzając je numerem zadania.
Wypisz współrzędne punktów leżących na brzegu koła (okręgu (x − a)² + (y − b)² = r²) oraz podaj liczbę punktów leżących we wnętrzu koła (brzeg nie należy do wnętrza). Informacja: spośród pierwszych 100 punktów 80 leży we wnętrzu koła.
wewnatrz = 0
with open("punkty.txt") as file:
for line in file:
x, y = map(int, line.split())
# porównujemy kwadraty odległości od środka (200, 200) - bez pierwiastków i błędów float
odleglosc = (x - 200) ** 2 + (y - 200) ** 2
if odleglosc == 200 ** 2:
print(x, y)
elif odleglosc < 200 ** 2:
wewnatrz += 1
print(wewnatrz)#include <fstream>
#include <iostream>
int main() {
int wewnatrz = 0;
std::ifstream plik("punkty.txt");
int x, y;
while (plik >> x >> y) {
// porównujemy kwadraty odległości od środka (200, 200) - bez pierwiastków i błędów float
int odleglosc = (x - 200) * (x - 200) + (y - 200) * (y - 200);
if (odleglosc == 200 * 200)
std::cout << x << ' ' << y << '\n';
else if (odleglosc < 200 * 200)
wewnatrz++;
}
std::cout << wewnatrz << '\n';
}import java.nio.file.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
int wewnatrz = 0;
for (var line : Files.readAllLines(Path.of("punkty.txt"))) {
var p = line.strip().split("\\s+");
int x = Integer.parseInt(p[0]), y = Integer.parseInt(p[1]);
// porównujemy kwadraty odległości od środka (200, 200) - bez pierwiastków i błędów float
int odleglosc = (x - 200) * (x - 200) + (y - 200) * (y - 200);
if (odleglosc == 200 * 200)
System.out.println(x + " " + y);
else if (odleglosc < 200 * 200)
wewnatrz++;
}
System.out.println(wewnatrz);
}
}Odpowiedź: punkty okręgu: (256, 8), (200, 400); wewnątrz koła: 7852
↑Treść zadania
Punkty z pliku punkty.txt (kwadrat o boku 400, środek (200, 200), koło wpisane). Przy równomiernym rozkładzie punktów stosunek liczby punktów w kole n_k do liczby wszystkich punktów n jest w przybliżeniu równy stosunkowi pola koła (πr²) do pola kwadratu. Wyznacz przybliżoną wartość π na podstawie: pierwszych 1000 punktów, pierwszych 5000 punktów oraz wszystkich punktów. Wyniki zaokrąglij do 4 miejsc po przecinku (dla pierwszych 100 punktów wychodzi 3,2000).
punkty = []
with open("punkty.txt") as file:
for line in file:
x, y = map(int, line.split())
punkty.append((x, y))
def przyblizenie_pi(n):
# punkty należące do koła (razem z brzegiem) spośród n pierwszych
w_kole = 0
for x, y in punkty[:n]:
if (x - 200) ** 2 + (y - 200) ** 2 <= 200 ** 2:
w_kole += 1
# nk / n = Pk / P = pi * 200^2 / 400^2 = pi / 4
return 4 * w_kole / n
for n in [1000, 5000, len(punkty)]:
print(f"{przyblizenie_pi(n):.4f}")#include <fstream>
#include <print>
#include <utility>
#include <vector>
std::vector<std::pair<int, int>> punkty;
double przyblizenie_pi(int n) {
// punkty należące do koła (razem z brzegiem) spośród n pierwszych
int w_kole = 0;
for (int i = 0; i < n; i++) {
auto [x, y] = punkty[i];
if ((x - 200) * (x - 200) + (y - 200) * (y - 200) <= 200 * 200)
w_kole++;
}
// nk / n = Pk / P = pi * 200^2 / 400^2 = pi / 4
return 4.0 * w_kole / n;
}
int main() {
std::ifstream plik("punkty.txt");
int x, y;
while (plik >> x >> y)
punkty.push_back({x, y});
for (int n : {1000, 5000, static_cast<int>(punkty.size())})
std::println("{:.4f}", przyblizenie_pi(n));
}import java.nio.file.*;
import java.util.*;
public class Zadanie {
static List<int[]> punkty = new ArrayList<>();
static double przyblizeniePi(int n) {
// punkty należące do koła (razem z brzegiem) spośród n pierwszych
int wKole = 0;
for (var p : punkty.subList(0, n)) {
int x = p[0], y = p[1];
if ((x - 200) * (x - 200) + (y - 200) * (y - 200) <= 200 * 200)
wKole++;
}
// nk / n = Pk / P = pi * 200^2 / 400^2 = pi / 4
return 4.0 * wKole / n;
}
public static void main(String[] args) throws Exception {
for (var line : Files.readAllLines(Path.of("punkty.txt"))) {
var p = line.strip().split("\\s+");
punkty.add(new int[] {Integer.parseInt(p[0]), Integer.parseInt(p[1])});
}
for (int n : new int[] {1000, 5000, punkty.size()})
System.out.println(String.format(Locale.ROOT, "%.4f", przyblizeniePi(n))); // Locale.ROOT - kropka dziesiętna
}
}Odpowiedź: 3,2280; 3,1656; 3,1416
↑Treść zadania
Punkty z pliku punkty.txt; π_n to przybliżenie liczby π wyznaczone (jak w 4.2) z n pierwszych punktów pliku. Błąd bezwzględny definiujemy jako ε_n = |π − π_n|, gdzie π to wartość ze standardowej funkcji używanego narzędzia. Oblicz ε_n dla n = 1, 2, …, 1700 i utwórz czytelny wykres liniowy zmian tego błędu. Wartości ε_1000 i ε_1700, zaokrąglone do 4 miejsc po przecinku, zapisz w wyniki_4.txt.
import math
w_kole = 0
bledy = [] # bledy[n - 1] = |pi - pi_n|
with open("punkty.txt") as file:
for n in range(1, 1701):
x, y = map(int, file.readline().split())
if (x - 200) ** 2 + (y - 200) ** 2 <= 200 ** 2:
w_kole += 1
bledy.append(abs(math.pi - 4 * w_kole / n))
# dane do wykresu liniowego: n -> bledy[n - 1]
print(f"{bledy[1000 - 1]:.4f}")
print(f"{bledy[1700 - 1]:.4f}")#include <cmath>
#include <fstream>
#include <numbers>
#include <print>
#include <vector>
int main() {
int w_kole = 0;
std::vector<double> bledy; // bledy[n - 1] = |pi - pi_n|
std::ifstream plik("punkty.txt");
for (int n = 1; n < 1701; n++) {
int x, y;
plik >> x >> y;
if ((x - 200) * (x - 200) + (y - 200) * (y - 200) <= 200 * 200)
w_kole++;
bledy.push_back(std::abs(std::numbers::pi - 4.0 * w_kole / n));
}
// dane do wykresu liniowego: n -> bledy[n - 1]
std::println("{:.4f}", bledy[1000 - 1]);
std::println("{:.4f}", bledy[1700 - 1]);
}import java.nio.file.*;
import java.util.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
int wKole = 0;
var bledy = new ArrayList<Double>(); // bledy[n - 1] = |pi - pi_n|
var linie = Files.readAllLines(Path.of("punkty.txt"));
for (int n = 1; n < 1701; n++) {
var p = linie.get(n - 1).strip().split("\\s+");
int x = Integer.parseInt(p[0]), y = Integer.parseInt(p[1]);
if ((x - 200) * (x - 200) + (y - 200) * (y - 200) <= 200 * 200)
wKole++;
bledy.add(Math.abs(Math.PI - 4.0 * wKole / n));
}
// dane do wykresu liniowego: n -> bledy[n - 1]
System.out.println(String.format(Locale.ROOT, "%.4f", bledy.get(1000 - 1)));
System.out.println(String.format(Locale.ROOT, "%.4f", bledy.get(1700 - 1)));
}
}Odpowiedź: ε1000 = 0,0864; ε1700 = 0,0184 (+ wykres liniowy)
↑Treść zadania
Szyfr Cezara z kluczem k zastępuje każdą literę literą położoną o k pozycji dalej w alfabecie, cyklicznie (po Z następuje A), np. dla k = 3: B → E, X → A, Z → C. Rozważamy słowa z wielkich liter alfabetu angielskiego (A–Z) o długości do 30 znaków.
W pliku dane_6_1.txt jest 100 słów, każde w osobnym wierszu. Zaszyfruj je kluczem k = 107 i zapisz wynik do wyniki_6_1.txt, każde słowo w osobnym wierszu, w kolejności z pliku. Dla pierwszego słowa INTERPRETOWANIE wynikiem jest LQWHUSUHWRZDQLH.
def szyfruj(slowo, klucz):
wynik = ""
for znak in slowo:
wynik += chr((ord(znak) - 65 + klucz) % 26 + 65)
return wynik
with open("dane_6_1.txt") as file, open("wyniki_6_1.txt", "w") as wynik:
for line in file:
wynik.write(szyfruj(line.strip(), 107) + "\n")#include <fstream>
#include <string>
std::string szyfruj(const std::string& slowo, int klucz) {
std::string wynik = "";
for (char znak : slowo)
wynik += static_cast<char>((znak - 65 + klucz) % 26 + 65);
return wynik;
}
int main() {
std::ifstream plik("dane_6_1.txt");
std::ofstream wynik("wyniki_6_1.txt");
std::string slowo;
while (plik >> slowo)
wynik << szyfruj(slowo, 107) << '\n';
}import java.io.PrintWriter;
import java.nio.file.*;
public class Zadanie {
static String szyfruj(String slowo, int klucz) {
var wynik = new StringBuilder();
for (char znak : slowo.toCharArray())
wynik.append((char) ((znak - 65 + klucz) % 26 + 65));
return wynik.toString();
}
public static void main(String[] args) throws Exception {
try (var wynik = new PrintWriter("wyniki_6_1.txt")) {
for (var line : Files.readAllLines(Path.of("dane_6_1.txt")))
wynik.println(szyfruj(line.strip(), 107));
}
}
}Odpowiedź: plik wyniki_6_1.txt (pierwsze słowo: LQWHUSUHWRZDQLH, ostatnie: DUBVWRWHOHV)
↑Treść zadania
Szyfr Cezara (litery A–Z, przesunięcie cykliczne o k). W pliku dane_6_2.txt jest 3000 wierszy, każdy zawiera szyfrogram i po spacji klucz, którym go zaszyfrowano (co najwyżej czterocyfrowa liczba), np. BCYKUNCM 1718. Odszyfruj słowa i zapisz je do wyniki_6_2.txt, każde w osobnym wierszu, w kolejności z pliku. Dla pierwszego szyfrogramu BCYKUNCM wynikiem jest ZAWISLAK.
def odszyfruj(slowo, klucz):
wynik = ""
for znak in slowo:
wynik += chr((ord(znak) - 65 - klucz) % 26 + 65)
return wynik
with open("dane_6_2.txt") as file, open("wyniki_6_2.txt", "w") as wynik:
for line in file:
dane = line.split()
slowo = dane[0]
if len(dane) > 1:
klucz = int(dane[1])
else:
klucz = 0 # w kilku wierszach brakuje klucza - słowo zostaje bez zmian
wynik.write(odszyfruj(slowo, klucz) + "\n")#include <fstream>
#include <sstream>
#include <string>
std::string odszyfruj(const std::string& slowo, int klucz) {
std::string wynik = "";
for (char znak : slowo) {
int r = (znak - 65 - klucz) % 26;
if (r < 0) r += 26; // w C++ reszta bywa ujemna, w Pythonie % daje zawsze 0..25
wynik += static_cast<char>(r + 65);
}
return wynik;
}
int main() {
std::ifstream plik("dane_6_2.txt");
std::ofstream wynik("wyniki_6_2.txt");
std::string line;
while (std::getline(plik, line)) {
std::stringstream ss(line);
std::string slowo;
int klucz;
ss >> slowo;
if (!(ss >> klucz))
klucz = 0; // w kilku wierszach brakuje klucza - słowo zostaje bez zmian
wynik << odszyfruj(slowo, klucz) << '\n';
}
}import java.io.PrintWriter;
import java.nio.file.*;
public class Zadanie {
static String odszyfruj(String slowo, int klucz) {
var wynik = new StringBuilder();
for (char znak : slowo.toCharArray())
// Math.floorMod daje zawsze 0..25, jak % w Pythonie
wynik.append((char) (Math.floorMod(znak - 65 - klucz, 26) + 65));
return wynik.toString();
}
public static void main(String[] args) throws Exception {
try (var wynik = new PrintWriter("wyniki_6_2.txt")) {
for (var line : Files.readAllLines(Path.of("dane_6_2.txt"))) {
var dane = line.strip().split("\\s+");
String slowo = dane[0];
int klucz;
if (dane.length > 1)
klucz = Integer.parseInt(dane[1]);
else
klucz = 0; // w kilku wierszach brakuje klucza - słowo zostaje bez zmian
wynik.println(odszyfruj(slowo, klucz));
}
}
}
}Odpowiedź: plik wyniki_6_2.txt (pierwsze słowo: ZAWISLAK, wiersz 10: KREZEL, wiersz 100: KWIATKOWSKI)
↑Treść zadania
Szyfr Cezara (litery A–Z, przesunięcie cykliczne o k). W pliku dane_6_3.txt jest 3000 par słów oddzielonych spacją; drugie słowo jest szyfrogramem pierwszego z nieznanym kluczem (oba mają tę samą długość), np. ZAWISLAK EFBNXQFP. Niektóre szyfrogramy są błędne — litery zakodowano w nich z różnymi przesunięciami. Wypisz do wyniki_6_3.txt te słowa (pierwsze z pary), które zaszyfrowano błędnie, każde w osobnym wierszu, w kolejności z pliku. Pierwszym takim słowem jest SMIGIELSKI.
with open("dane_6_3.txt") as file, open("wyniki_6_3.txt", "w") as wynik:
for line in file:
jawne, szyfr = line.split()
klucz = (ord(szyfr[0]) - ord(jawne[0])) % 26
poprawne = True
for i in range(len(jawne)):
if (ord(szyfr[i]) - ord(jawne[i])) % 26 != klucz:
poprawne = False
break
if not poprawne:
wynik.write(jawne + "\n")#include <fstream>
#include <string>
int main() {
std::ifstream plik("dane_6_3.txt");
std::ofstream wynik("wyniki_6_3.txt");
std::string jawne, szyfr;
while (plik >> jawne >> szyfr) {
// (... % 26 + 26) % 26 - reszta zawsze 0..25, jak % w Pythonie
int klucz = ((szyfr[0] - jawne[0]) % 26 + 26) % 26;
bool poprawne = true;
for (size_t i = 0; i < jawne.size(); i++) {
if (((szyfr[i] - jawne[i]) % 26 + 26) % 26 != klucz) {
poprawne = false;
break;
}
}
if (!poprawne)
wynik << jawne << '\n';
}
}import java.io.PrintWriter;
import java.nio.file.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
try (var wynik = new PrintWriter("wyniki_6_3.txt")) {
for (var line : Files.readAllLines(Path.of("dane_6_3.txt"))) {
var p = line.strip().split("\\s+");
String jawne = p[0], szyfr = p[1];
// Math.floorMod - reszta zawsze 0..25, jak % w Pythonie
int klucz = Math.floorMod(szyfr.charAt(0) - jawne.charAt(0), 26);
boolean poprawne = true;
for (int i = 0; i < jawne.length(); i++) {
if (Math.floorMod(szyfr.charAt(i) - jawne.charAt(i), 26) != klucz) {
poprawne = false;
break;
}
}
if (!poprawne)
wynik.println(jawne);
}
}
}
}Odpowiedź: SMIGIELSKI, JANEK, JANUSZEWSKI, WOLAK, GAJEK, MROCZKOWSKI, SZCZESNIAK, CIESLINSKI
↑