Matura 2014 — maj, poziom rozszerzony
ARKUSZ IARKUSZ IIDANEODPOWIEDZI
Treść zadania
Zadanie 1. Korale. Rekurencyjna procedura Korale(n) dla dodatniej liczby całkowitej n:
Korale(n):
jeżeli n = 1: nawlecz czarny koralik na prawy koniec sznurka; zakończ
jeżeli n parzyste: Korale(n/2); nawlecz biały koralik na prawy koniec; zakończ
jeżeli n nieparzyste: Korale((n-1)/2); nawlecz czarny koralik na prawy koniec; zakończPodaj wynik działania Korale(n) (ciąg koralików) dla n = 1, 2, 3, 4, 7, 8, 15, 16.
def korale(n):
if n == 1:
return "C"
if n % 2 == 0:
return korale(n // 2) + "B"
return korale((n - 1) // 2) + "C"
for n in [1, 2, 3, 4, 7, 8, 15, 16]:
print(n, korale(n))#include <print>
#include <string>
// C - czarny koralik, B - bialy koralik
std::string korale(int n) {
if (n == 1) return "C";
if (n % 2 == 0) return korale(n / 2) + "B";
return korale((n - 1) / 2) + "C";
}
int main() {
for (int n : {1, 2, 3, 4, 7, 8, 15, 16}) {
std::println("{} {}", n, korale(n));
}
}public class Zadanie {
// C - czarny koralik, B - bialy koralik
static String korale(int n) {
if (n == 1) return "C";
if (n % 2 == 0) return korale(n / 2) + "B";
return korale((n - 1) / 2) + "C";
}
public static void main(String[] args) throws Exception {
for (int n : new int[]{1, 2, 3, 4, 7, 8, 15, 16}) {
System.out.println(n + " " + korale(n));
}
}
}Odpowiedź: 1: C, 2: CB, 3: CC, 4: CBB, 7: CCC, 8: CBBB, 15: CCCC, 16: CBBBB (czarny = 1, biały = 0 — zapis binarny liczby n)
↑Treść zadania
Procedura Korale(n) jak w zadaniu 1a (w efekcie nawleka koraliki odpowiadające zapisowi binarnemu n: czarny = 1, biały = 0). Zaprojektuj nierekurencyjną procedurę KoraleBis(n) dającą ten sam efekt, przy czym koraliki wolno nawlekać tylko na jeden, wybrany koniec sznurka.
(W podpunkcie 1b należało podać i uzasadnić, ile koralików zostanie nawleczonych.)
# nierekurencyjna wersja - koraliki nawlekamy zawsze na lewy koniec sznurka
def korale_bis(n):
sznurek = ""
while n > 0:
if n % 2 == 0:
sznurek = "B" + sznurek
else:
sznurek = "C" + sznurek
n = n // 2
return sznurek
for n in [1, 2, 3, 4, 7, 8, 15, 16]:
print(n, korale_bis(n))#include <print>
#include <string>
// nierekurencyjna wersja - koraliki nawlekamy zawsze na lewy koniec sznurka
std::string korale_bis(int n) {
std::string sznurek = "";
while (n > 0) {
if (n % 2 == 0) sznurek = "B" + sznurek;
else sznurek = "C" + sznurek;
n = n / 2;
}
return sznurek;
}
int main() {
for (int n : {1, 2, 3, 4, 7, 8, 15, 16}) {
std::println("{} {}", n, korale_bis(n));
}
}public class Zadanie {
// nierekurencyjna wersja - koraliki nawlekamy zawsze na lewy koniec sznurka
static String koraleBis(int n) {
String sznurek = "";
while (n > 0) {
if (n % 2 == 0) sznurek = "B" + sznurek;
else sznurek = "C" + sznurek;
n = n / 2;
}
return sznurek;
}
public static void main(String[] args) throws Exception {
for (int n : new int[]{1, 2, 3, 4, 7, 8, 15, 16}) {
System.out.println(n + " " + koraleBis(n));
}
}
}Odpowiedź: ten sam wynik co Korale(n); liczba koralików (1b) to liczba cyfr binarnych n, czyli ⌊log2 n⌋ + 1
Treść zadania
Zadanie 2. Bisekcja. Dla funkcji ciągłej na <a, b>, o wartościach różnych znaków na końcach przedziału, liczymy f w środku x = (a+b)/2. Jeśli f(x) = 0, x jest miejscem zerowym; w przeciwnym razie zawężamy przedział do <a, x> lub <x, b> tak, by na końcach znów były różne znaki. Powtarzamy do znalezienia zera lub aż długość przedziału spadnie poniżej dokładności d — wtedy wynikiem jest środek ostatniego przedziału.
Dla f(x) = x³ − x − 2 i przedziału <0, 2>:
- 2a — wykonaj trzy pierwsze kroki bisekcji, podając w każdym
a,b,f(a),f(b),x,f(x)i wybrany nowy przedział (krok 1:a = 0,b = 2,f(a) = −2,f(b) = 4,x = 1,f(x) = −2, więc wybieramy<x, b>). - 2b — podaj, w którym kroku długość przedziału
<a, b>po raz pierwszy będzie mniejsza niż0,1.
def f(x):
return x ** 3 - x - 2
a, b = 0, 2
krok = 1
while b - a >= 0.1:
x = (a + b) / 2
if krok <= 3:
print(krok, a, b, f(a), f(b), x, f(x))
if f(a) * f(x) < 0:
b = x
else:
a = x
krok += 1
print("dlugosc przedzialu < 0,1 w kroku", krok)#include <cmath>
#include <format>
#include <print>
#include <string>
double f(double x) {
return std::pow(x, 3) - x - 2;
}
// W Pythonie a i b są na początku liczbami całkowitymi (0 i 2) i wypisują się bez ".0";
// po przypisaniu x stają się liczbami rzeczywistymi. Odwzorowujemy to przy wypisywaniu.
std::string wypisz(double x, bool rzeczywista) {
std::string s = std::format("{}", x);
if (rzeczywista && s.find('.') == std::string::npos) s += ".0";
return s;
}
int main() {
double a = 0, b = 2;
bool a_rzecz = false, b_rzecz = false;
int krok = 1;
while (b - a >= 0.1) {
double x = (a + b) / 2;
if (krok <= 3) {
std::println("{} {} {} {} {} {} {}", krok, wypisz(a, a_rzecz), wypisz(b, b_rzecz), wypisz(f(a), a_rzecz),
wypisz(f(b), b_rzecz), wypisz(x, true), wypisz(f(x), true));
}
if (f(a) * f(x) < 0) {
b = x;
b_rzecz = true;
} else {
a = x;
a_rzecz = true;
}
krok++;
}
std::println("dlugosc przedzialu < 0,1 w kroku {}", krok);
}public class Zadanie {
static double f(double x) {
return Math.pow(x, 3) - x - 2;
}
// W Pythonie a i b są na początku liczbami całkowitymi (0 i 2) i wypisują się bez ".0";
// po przypisaniu x stają się liczbami rzeczywistymi. Odwzorowujemy to przy wypisywaniu.
static String wypisz(double x, boolean rzeczywista) {
return rzeczywista ? Double.toString(x) : Long.toString((long) x);
}
public static void main(String[] args) throws Exception {
double a = 0, b = 2;
boolean aRzecz = false, bRzecz = false;
int krok = 1;
while (b - a >= 0.1) {
double x = (a + b) / 2;
if (krok <= 3) {
System.out.println(krok + " " + wypisz(a, aRzecz) + " " + wypisz(b, bRzecz) + " " + wypisz(f(a), aRzecz)
+ " " + wypisz(f(b), bRzecz) + " " + x + " " + f(x));
}
if (f(a) * f(x) < 0) {
b = x;
bRzecz = true;
} else {
a = x;
aRzecz = true;
}
krok++;
}
System.out.println("dlugosc przedzialu < 0,1 w kroku " + krok);
}
}Odpowiedź: a) krok 1: a=0, b=2, f(a)=-2, f(b)=4, x=1, f(x)=-2; krok 2: a=1, b=2, f(a)=-2, f(b)=4, x=1,5, f(x)=-0,125; krok 3: a=1,5, b=2, f(a)=-0,125, f(b)=4, x=1,75, f(x)=1,609375; b) 6
↑Treść zadania
Bisekcja jak w zadaniu 2. Dane są: przedział domknięty <a, b>, funkcja f ciągła na nim, taka że f(a)·f(b) < 0, oraz dodatnia dokładność d ≤ b − a. Zapisz algorytm wyznaczający metodą bisekcji przybliżenie miejsca zerowego f w <a, b> z dokładnością d.
def bisekcja(f, a, b, d):
x = (a + b) / 2
while b - a >= d:
if f(x) == 0:
return x
if f(a) * f(x) < 0:
b = x
else:
a = x
x = (a + b) / 2
return x
print(bisekcja(lambda x: x ** 3 - x - 2, 0, 2, 0.0001))#include <cmath>
#include <functional>
#include <print>
double bisekcja(std::function<double(double)> f, double a, double b, double d) {
double x = (a + b) / 2;
while (b - a >= d) {
if (f(x) == 0) return x;
if (f(a) * f(x) < 0) b = x;
else a = x;
x = (a + b) / 2;
}
return x;
}
int main() {
std::println("{}", bisekcja([](double x) { return std::pow(x, 3) - x - 2; }, 0, 2, 0.0001));
}import java.util.function.DoubleUnaryOperator;
public class Zadanie {
static double bisekcja(DoubleUnaryOperator f, double a, double b, double d) {
double x = (a + b) / 2;
while (b - a >= d) {
if (f.applyAsDouble(x) == 0) return x;
if (f.applyAsDouble(a) * f.applyAsDouble(x) < 0) b = x;
else a = x;
x = (a + b) / 2;
}
return x;
}
public static void main(String[] args) throws Exception {
System.out.println(bisekcja(x -> Math.pow(x, 3) - x - 2, 0, 2, 0.0001));
}
}Odpowiedź: algorytm jak wyżej (dla f(x) = x³ − x − 2 na <0, 2> daje ok. 1,5214)
↑Treść zadania
Zadanie 3. Dla dodatniej liczby całkowitej n:
jeżeli n = 1: suma ← 1
w przeciwnym razie:
suma ← 1 + n; i ← n - 1
dopóki i > 1: suma ← 1 + i * suma; i ← i - 1Podaj wartość zmiennej suma po zakończeniu algorytmu dla n = 4 i n = 6.
def algorytm(n):
if n == 1:
return 1
suma = 1 + n
i = n - 1
while i > 1:
suma = 1 + i * suma
i -= 1
return suma
print(algorytm(4), algorytm(6))#include <print>
long long algorytm(int n) {
if (n == 1) return 1;
long long suma = 1 + n;
int i = n - 1;
while (i > 1) {
suma = 1 + i * suma;
i--;
}
return suma;
}
int main() {
std::println("{} {}", algorytm(4), algorytm(6));
}public class Zadanie {
static long algorytm(int n) {
if (n == 1) return 1;
long suma = 1 + n;
int i = n - 1;
while (i > 1) {
suma = 1 + i * suma;
i--;
}
return suma;
}
public static void main(String[] args) throws Exception {
System.out.println(algorytm(4) + " " + algorytm(6));
}
}Odpowiedź: n = 4: 33, n = 6: 873
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Zadanie 4. Ferma. Na fermie jest początkowo 200 kur. Kilogram paszy kosztuje 1,9 zł, a kura zjada dziennie 0,2 kg. Okres hodowli to dni 1–180; pierwsza niedziela to dzień 7. Codziennie w południe, oprócz niedziel, każda kura znosi 1 jajko, a wszystkie jajka są sprzedawane tego dnia po 0,9 zł. W każdy dzień o nieparzystym numerze po zmroku (po posiłku i sprzedaży) lis zmniejsza stado o 2 kury. Co 30 dni (dzień 30, 60, …) rano, przed posiłkiem, stado powiększa się o 20% (liczbę kupionych kur zaokrąglamy w dół) — kura kosztuje 18 zł. Odpowiedzi do a–c zapisz w kolejnych wierszach pliku ZADANIE4.TXT, poprzedzając każdą literą podpunktu.
- a) Podaj dzień i porę dnia, w której liczba kur po raz pierwszy ponownie wyniesie dokładnie 200.
- b) Podaj łączną kwotę wydaną na paszę w ciągu 180 dni.
- c) Dzienny zysk to przychód ze sprzedaży jajek minus koszt paszy i koszt kur dokupionych tego dnia; realny zysk to suma dotychczasowych dziennych zysków. Podaj, po którym dniu realny zysk po raz pierwszy przekroczy 1500 zł, oraz jaki będzie realny zysk po 180 dniach.
kury = 200
pasza = 0
realny_zysk = 0
dzien_200 = None
dzien_1500 = None
for dzien in range(1, 181):
# rano - co 30 dni zakup kur
koszt_kur = 0
if dzien % 30 == 0:
nowe = int(kury * 0.2)
kury += nowe
koszt_kur = nowe * 18
if kury == 200 and dzien_200 is None:
dzien_200 = (dzien, "rano")
# posilek
koszt_paszy = kury * 0.2 * 1.9
pasza += koszt_paszy
# poludnie - sprzedaz jajek (bez niedziel)
przychod = 0
if dzien % 7 != 0:
przychod = kury * 0.9
realny_zysk += przychod - koszt_paszy - koszt_kur
if realny_zysk > 1500 and dzien_1500 is None:
dzien_1500 = dzien
# po zmroku - lis
if dzien % 2 == 1:
kury -= 2
if kury == 200 and dzien_200 is None:
dzien_200 = (dzien, "po zmroku")
print("a)", dzien_200)
print("b)", round(pasza, 2))
print("c)", dzien_1500, round(realny_zysk, 2))#include <format>
#include <print>
#include <string>
// liczba rzeczywista wypisana tak jak w Pythonie (np. 13533.7, 5.0)
std::string jak_python(double x) {
std::string s = std::format("{}", x);
if (s.find('.') == std::string::npos) s += ".0";
return s;
}
// round(x, 2) z Pythona
double zaokraglij2(double x) {
return std::stod(std::format("{:.2f}", x));
}
int main() {
int kury = 200;
double pasza = 0;
double realny_zysk = 0;
std::string dzien_200 = "None";
std::string dzien_1500 = "None";
for (int dzien = 1; dzien <= 180; dzien++) {
// rano - co 30 dni zakup kur
int koszt_kur = 0;
if (dzien % 30 == 0) {
int nowe = int(kury * 0.2);
kury += nowe;
koszt_kur = nowe * 18;
if (kury == 200 && dzien_200 == "None") dzien_200 = std::format("({}, 'rano')", dzien);
}
// posilek
double koszt_paszy = kury * 0.2 * 1.9;
pasza += koszt_paszy;
// poludnie - sprzedaz jajek (bez niedziel)
double przychod = 0;
if (dzien % 7 != 0) przychod = kury * 0.9;
realny_zysk += przychod - koszt_paszy - koszt_kur;
if (realny_zysk > 1500 && dzien_1500 == "None") dzien_1500 = std::to_string(dzien);
// po zmroku - lis
if (dzien % 2 == 1) {
kury -= 2;
if (kury == 200 && dzien_200 == "None") dzien_200 = std::format("({}, 'po zmroku')", dzien);
}
}
std::println("a) {}", dzien_200);
std::println("b) {}", jak_python(zaokraglij2(pasza)));
std::println("c) {} {}", dzien_1500, jak_python(zaokraglij2(realny_zysk)));
}import java.math.BigDecimal;
import java.math.RoundingMode;
public class Zadanie {
// round(x, 2) z Pythona
static double zaokraglij2(double x) {
return new BigDecimal(x).setScale(2, RoundingMode.HALF_EVEN).doubleValue();
}
public static void main(String[] args) throws Exception {
int kury = 200;
double pasza = 0;
double realnyZysk = 0;
String dzien200 = "None";
String dzien1500 = "None";
for (int dzien = 1; dzien <= 180; dzien++) {
// rano - co 30 dni zakup kur
int kosztKur = 0;
if (dzien % 30 == 0) {
int nowe = (int) (kury * 0.2);
kury += nowe;
kosztKur = nowe * 18;
if (kury == 200 && dzien200.equals("None")) dzien200 = "(" + dzien + ", 'rano')";
}
// posilek
double kosztPaszy = kury * 0.2 * 1.9;
pasza += kosztPaszy;
// poludnie - sprzedaz jajek (bez niedziel)
double przychod = 0;
if (dzien % 7 != 0) przychod = kury * 0.9;
realnyZysk += przychod - kosztPaszy - kosztKur;
if (realnyZysk > 1500 && dzien1500.equals("None")) dzien1500 = Integer.toString(dzien);
// po zmroku - lis
if (dzien % 2 == 1) {
kury -= 2;
if (kury == 200 && dzien200.equals("None")) dzien200 = "(" + dzien + ", 'po zmroku')";
}
}
System.out.println("a) " + dzien200);
System.out.println("b) " + zaokraglij2(pasza));
System.out.println("c) " + dzien1500 + " " + zaokraglij2(realnyZysk));
}
}Odpowiedź: a) 33 dnia po zmroku; b) 13 533,70 zł; c) po 19 dniu, 10 220,90 zł
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Symulacja fermy jak w zadaniu 4. Wykonaj czytelny wykres liniowy porównujący dzienny przychód (wartość sprzedanych jajek) z dziennymi kosztami w okresie 180 dni. Wykres zapisz w osobnym pliku.
# dane do wykresu liniowego: dzien, przychod ze sprzedazy jaj, koszty (pasza + zakup kur)
kury = 200
with open("wykres_4d.txt", "w") as wynik:
wynik.write("dzien;przychod;koszty\n")
for dzien in range(1, 181):
koszt_kur = 0
if dzien % 30 == 0:
nowe = int(kury * 0.2)
kury += nowe
koszt_kur = nowe * 18
koszty = kury * 0.2 * 1.9 + koszt_kur
przychod = kury * 0.9 if dzien % 7 != 0 else 0
wynik.write(f"{dzien};{przychod:.2f};{koszty:.2f}\n")
if dzien % 2 == 1:
kury -= 2#include <format>
#include <fstream>
// dane do wykresu liniowego: dzien, przychod ze sprzedazy jaj, koszty (pasza + zakup kur)
int main() {
int kury = 200;
std::ofstream wynik("wykres_4d.txt");
wynik << "dzien;przychod;koszty\n";
for (int dzien = 1; dzien <= 180; dzien++) {
int koszt_kur = 0;
if (dzien % 30 == 0) {
int nowe = int(kury * 0.2);
kury += nowe;
koszt_kur = nowe * 18;
}
double koszty = kury * 0.2 * 1.9 + koszt_kur;
double przychod = (dzien % 7 != 0) ? kury * 0.9 : 0;
wynik << std::format("{};{:.2f};{:.2f}\n", dzien, przychod, koszty);
if (dzien % 2 == 1) kury -= 2;
}
}import java.io.PrintWriter;
import java.util.Locale;
public class Zadanie {
// dane do wykresu liniowego: dzien, przychod ze sprzedazy jaj, koszty (pasza + zakup kur)
public static void main(String[] args) throws Exception {
int kury = 200;
try (var wynik = new PrintWriter("wykres_4d.txt")) {
wynik.print("dzien;przychod;koszty\n");
for (int dzien = 1; dzien <= 180; dzien++) {
int kosztKur = 0;
if (dzien % 30 == 0) {
int nowe = (int) (kury * 0.2);
kury += nowe;
kosztKur = nowe * 18;
}
double koszty = kury * 0.2 * 1.9 + kosztKur;
double przychod = (dzien % 7 != 0) ? kury * 0.9 : 0;
wynik.print(String.format(Locale.ROOT, "%d;%.2f;%.2f\n", dzien, przychod, koszty));
if (dzien % 2 == 1) kury -= 2;
}
}
}
}Odpowiedź: wykres liniowy (2 serie: przychód i koszty) tworzymy w arkuszu z pliku wykres_4d.txt
Treść zadania
Zadanie 5. Ciekawe napisy. W pliku NAPIS.TXT jest 1000 napisów (każdy w osobnym wierszu) o długości od 2 do 25 znaków, złożonych z wielkich liter alfabetu łacińskiego. Odpowiedzi zapisz w kolejnych wierszach pliku ZADANIE5.TXT, poprzedzając każdą literą podpunktu.
Napis pierwszy to napis, którego suma kodów ASCII jest liczbą pierwszą (np. ABB: suma 197). Podaj, ile jest napisów pierwszych w pliku.
def czy_pierwsza(x):
if x < 2:
return False
i = 2
while i * i <= x:
if x % i == 0:
return False
i += 1
return True
licznik = 0
with open("NAPIS.TXT") as file:
for line in file:
napis = line.strip()
suma = 0
for znak in napis:
suma += ord(znak)
if czy_pierwsza(suma):
licznik += 1
print(licznik)#include <fstream>
#include <print>
#include <string>
bool czy_pierwsza(int x) {
if (x < 2) return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
int main() {
std::ifstream plik("NAPIS.TXT");
int licznik = 0;
std::string napis;
while (plik >> napis) {
int suma = 0;
for (char znak : napis) suma += znak; // kod ASCII znaku
if (czy_pierwsza(suma)) licznik++;
}
std::println("{}", licznik);
}import java.nio.file.Files;
import java.nio.file.Path;
public class Zadanie {
static boolean czyPierwsza(int x) {
if (x < 2) return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
public static void main(String[] args) throws Exception {
int licznik = 0;
for (String line : Files.readAllLines(Path.of("NAPIS.TXT"))) {
String napis = line.strip();
int suma = 0;
for (char znak : napis.toCharArray()) suma += znak; // kod ASCII znaku
if (czyPierwsza(suma)) licznik++;
}
System.out.println(licznik);
}
}Odpowiedź: 122
↑Treść zadania
Napisy z pliku NAPIS.TXT jak w zadaniu 5a. Napis rosnący to napis, w którym kod ASCII każdej kolejnej litery jest większy od kodu poprzedniej. Wypisz wszystkie napisy rosnące z pliku.
with open("NAPIS.TXT") as file:
for line in file:
napis = line.strip()
rosnacy = True
for i in range(1, len(napis)):
if ord(napis[i]) <= ord(napis[i - 1]):
rosnacy = False
break
if rosnacy:
print(napis)#include <fstream>
#include <print>
#include <string>
int main() {
std::ifstream plik("NAPIS.TXT");
std::string napis;
while (plik >> napis) {
bool rosnacy = true;
for (size_t i = 1; i < napis.size(); i++) {
if (napis[i] <= napis[i - 1]) {
rosnacy = false;
break;
}
}
if (rosnacy) std::println("{}", napis);
}
}import java.nio.file.Files;
import java.nio.file.Path;
public class Zadanie {
public static void main(String[] args) throws Exception {
for (String line : Files.readAllLines(Path.of("NAPIS.TXT"))) {
String napis = line.strip();
boolean rosnacy = true;
for (int i = 1; i < napis.length(); i++) {
if (napis.charAt(i) <= napis.charAt(i - 1)) {
rosnacy = false;
break;
}
}
if (rosnacy) System.out.println(napis);
}
}
}Odpowiedź: FHJLMU, BEJNOSY, MNS, AEIOUY, BDL, JT, BJQR, AHJS, FHJLMU, DIT, CEGKZ, BCV, CEGIKOT, CEGKZ
↑Treść zadania
Napisy z pliku NAPIS.TXT jak w zadaniu 5a. Wypisz napisy, które występują w pliku więcej niż raz (każdy taki napis tylko jeden raz).
ile = {}
with open("NAPIS.TXT") as file:
for line in file:
napis = line.strip()
ile[napis] = ile.get(napis, 0) + 1
for napis, liczba in ile.items():
if liczba > 1:
print(napis)#include <fstream>
#include <map>
#include <print>
#include <string>
#include <vector>
int main() {
std::map<std::string, int> ile;
std::vector<std::string> kolejnosc; // kolejność pierwszego wystąpienia (jak w słowniku Pythona)
std::ifstream plik("NAPIS.TXT");
std::string napis;
while (plik >> napis) {
if (!ile.contains(napis)) kolejnosc.push_back(napis);
ile[napis]++;
}
for (const auto& n : kolejnosc) {
if (ile[n] > 1) std::println("{}", n);
}
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.LinkedHashMap;
public class Zadanie {
public static void main(String[] args) throws Exception {
// LinkedHashMap pamięta kolejność dodawania (jak słownik w Pythonie)
var ile = new LinkedHashMap<String, Integer>();
for (String line : Files.readAllLines(Path.of("NAPIS.TXT"))) {
ile.merge(line.strip(), 1, Integer::sum);
}
for (var wpis : ile.entrySet()) {
if (wpis.getValue() > 1) System.out.println(wpis.getKey());
}
}
}Odpowiedź: FHJLMU, GC, QULA, CEGKZ, BZYFFLOICLUNWLTH, SWIFT
↑