Matura 2010 — maj, poziom rozszerzony
ARKUSZ IARKUSZ IIDANEODPOWIEDZI
Arkusz I
1a
Treść zadania
Szyfr przestawieniowy: tekst wpisujemy wierszami do kwadratowej tablicy n × n, a szyfrogram odczytujemy kolumnami od lewej do prawej. Wymiar n to najmniejsza liczba, przy której cały tekst mieści się w tablicy; wolne pola uzupełnia się znakami odstępu (oznaczanymi _).
Przykład: ALGORYTM_PRZESTAWIENIOWY (24 znaki) → tablica 5 × 5 → AYRAILTZWOGMEIWO_SEYRPTN_.
Podaj wzór (lub algorytm) wyznaczający liczbę wierszy i kolumn tablicy dla tekstu o długości d znaków.
from math import ceil, sqrt
def wymiar(d):
# najmniejsze n, dla którego n * n >= d, czyli n = sufit(pierwiastek(d))
n = ceil(sqrt(d))
while n * n < d: # zabezpieczenie przed błędem zaokrąglenia
n += 1
return n
print(wymiar(24), wymiar(25), wymiar(26))#include <cmath>
#include <print>
int wymiar(int d) {
// najmniejsze n, dla którego n * n >= d, czyli n = sufit(pierwiastek(d))
int n = static_cast<int>(std::ceil(std::sqrt(d)));
while (n * n < d) { // zabezpieczenie przed błędem zaokrąglenia
n += 1;
}
return n;
}
int main() {
std::println("{} {} {}", wymiar(24), wymiar(25), wymiar(26));
}public class Zadanie {
static int wymiar(int d) {
// najmniejsze n, dla którego n * n >= d, czyli n = sufit(pierwiastek(d))
int n = (int) Math.ceil(Math.sqrt(d));
while (n * n < d) { // zabezpieczenie przed błędem zaokrąglenia
n += 1;
}
return n;
}
public static void main(String[] args) throws Exception {
System.out.println(wymiar(24) + " " + wymiar(25) + " " + wymiar(26));
}
}Odpowiedź: n = ⌈√d⌉ – najmniejsza liczba naturalna większa lub równa √d
↑Arkusz I
1b i 1c
Treść zadania
Szyfr przestawieniowy z zadania 1a (tekst wpisywany wierszami do tablicy n × n, odczytywany kolumnami).
- 1b — Rozszyfruj cytat z Sokratesa zaszyfrowany tą metodą — szyfrogram (64 znaki, czyli tablica 8 × 8) jest podany w arkuszu.
- 1c — Zapisz algorytm szyfrujący tą metodą. Dane: d — długość tekstu,
tekst[1..d]— znaki tekstu. Wynik: s — długość szyfrogramu,szyfr[1..s]— znaki szyfrogramu.
from math import ceil, sqrt
def szyfruj(tekst):
d = len(tekst)
n = ceil(sqrt(d))
while n * n < d:
n += 1
s = n * n
tekst = tekst + "_" * (s - d) # puste pola uzupełniamy znakami odstępu
szyfr = ""
for kolumna in range(n): # odczyt kolumnami
for wiersz in range(n):
szyfr += tekst[wiersz * n + kolumna]
return szyfr
# c) przykład z treści
print(szyfruj("ALGORYTM_PRZESTAWIENIOWY"))
# b) szyfr ma 64 znaki (kwadrat 8 x 8), a zamiana wierszy z kolumnami
# wykonana drugi raz przywraca tekst - wystarczy "zaszyfrować" szyfr
szyfr = "BTLLTU_ĘL_EOYPM_ĄPJZLCYNDREOKYLI_ZMFO_ĄGJY_Ó_N_DEWFWGISYSII_ŁEI_"
print(szyfruj(szyfr))#include <cmath>
#include <print>
#include <string>
#include <vector>
// std::string przechowuje bajty UTF-8, a polskie litery (np. Ę, Ą) zajmują po 2 bajty,
// dlatego najpierw dzielimy tekst na pojedyncze znaki - każdy jako osobny napis
std::vector<std::string> znaki(const std::string& tekst) {
std::vector<std::string> wynik;
size_t i = 0;
while (i < tekst.size()) {
unsigned char bajt = tekst[i];
size_t dlugosc = 1;
if (bajt >= 0xF0) dlugosc = 4;
else if (bajt >= 0xE0) dlugosc = 3;
else if (bajt >= 0xC0) dlugosc = 2;
wynik.push_back(tekst.substr(i, dlugosc));
i += dlugosc;
}
return wynik;
}
std::string szyfruj(const std::string& napis) {
std::vector<std::string> tekst = znaki(napis);
int d = static_cast<int>(tekst.size());
int n = static_cast<int>(std::ceil(std::sqrt(d)));
while (n * n < d) {
n += 1;
}
int s = n * n;
tekst.resize(s, "_"); // puste pola uzupełniamy znakami odstępu
std::string szyfr = "";
for (int kolumna = 0; kolumna < n; kolumna++) { // odczyt kolumnami
for (int wiersz = 0; wiersz < n; wiersz++) {
szyfr += tekst[wiersz * n + kolumna];
}
}
return szyfr;
}
int main() {
// c) przykład z treści
std::println("{}", szyfruj("ALGORYTM_PRZESTAWIENIOWY"));
// b) szyfr ma 64 znaki (kwadrat 8 x 8), a zamiana wierszy z kolumnami
// wykonana drugi raz przywraca tekst - wystarczy "zaszyfrować" szyfr
std::string szyfr = "BTLLTU_ĘL_EOYPM_ĄPJZLCYNDREOKYLI_ZMFO_ĄGJY_Ó_N_DEWFWGISYSII_ŁEI_";
std::println("{}", szyfruj(szyfr));
}public class Zadanie {
static String szyfruj(String tekst) {
int d = tekst.length();
int n = (int) Math.ceil(Math.sqrt(d));
while (n * n < d) {
n += 1;
}
int s = n * n;
tekst = tekst + "_".repeat(s - d); // puste pola uzupełniamy znakami odstępu
var szyfr = new StringBuilder();
for (int kolumna = 0; kolumna < n; kolumna++) { // odczyt kolumnami
for (int wiersz = 0; wiersz < n; wiersz++) {
szyfr.append(tekst.charAt(wiersz * n + kolumna));
}
}
return szyfr.toString();
}
public static void main(String[] args) throws Exception {
// c) przykład z treści
System.out.println(szyfruj("ALGORYTM_PRZESTAWIENIOWY"));
// b) szyfr ma 64 znaki (kwadrat 8 x 8), a zamiana wierszy z kolumnami
// wykonana drugi raz przywraca tekst - wystarczy "zaszyfrować" szyfr
String szyfr = "BTLLTU_ĘL_EOYPM_ĄPJZLCYNDREOKYLI_ZMFO_ĄGJY_Ó_N_DEWFWGISYSII_ŁEI_";
System.out.println(szyfruj(szyfr));
}
}Odpowiedź: b) BŁĄD JEST PRZYWILEJEM FILOZOFÓW, TYLKO GŁUPCY NIE MYLĄ SIĘ NIGDY; c) przykład: AYRAILTZWOGMEIWO_SEYRPTN_
↑Arkusz I
2a i 2b
Treść zadania
W tablicy a[1..1023] zapisano ciąg zer i jedynek tak, że wszystkie zera poprzedzają jedynki (mogą wystąpić same zera albo same jedynki). Dany jest niepełny algorytm liczenia zer:
liczba_zer ← 0
l ← 1, p ← 1023
dopóki l ≤ p wykonuj
s ← (l + p) div 2
jeżeli a[s] = 1 to p ← s − 1
w przeciwnym przypadku
liczba_zer ← liczba_zer + .....
l ← .....- 2a — Uzupełnij brakujące wyrażenia tak, aby algorytm zawsze poprawnie liczył zera.
- 2b — Ile razy wykonywane jest przypisanie
s ← (l + p) div 2w każdym przebiegu algorytmu? Uzasadnij.
def liczba_zer(a):
# a[1..1023], a[0] nieużywane - indeksy jak w zadaniu
przypisania_s = 0
zera = 0
l, p = 1, len(a) - 1
while l <= p:
s = (l + p) // 2
przypisania_s += 1
if a[s] == 1:
p = s - 1
else:
zera = zera + (s - l + 1) # zera na pozycjach l..s
l = s + 1
return zera, przypisania_s
# sprawdzenie dla wszystkich możliwych tablic (k zer, potem jedynki)
liczby_przypisan = set()
for k in range(1024):
a = [None] + [0] * k + [1] * (1023 - k)
zera, przypisania_s = liczba_zer(a)
if zera != k:
print("błąd dla", k)
liczby_przypisan.add(przypisania_s)
print(liczby_przypisan)#include <print>
#include <set>
#include <utility>
#include <vector>
std::pair<int, int> liczba_zer(const std::vector<int>& a) {
// a[1..1023], a[0] nieużywane - indeksy jak w zadaniu
int przypisania_s = 0;
int zera = 0;
int l = 1, p = static_cast<int>(a.size()) - 1;
while (l <= p) {
int s = (l + p) / 2;
przypisania_s += 1;
if (a[s] == 1) {
p = s - 1;
} else {
zera = zera + (s - l + 1); // zera na pozycjach l..s
l = s + 1;
}
}
return {zera, przypisania_s};
}
int main() {
// sprawdzenie dla wszystkich możliwych tablic (k zer, potem jedynki)
std::set<int> liczby_przypisan;
for (int k = 0; k < 1024; k++) {
std::vector<int> a(1024, 1); // a[0] nieużywane
for (int i = 1; i <= k; i++) {
a[i] = 0;
}
auto [zera, przypisania_s] = liczba_zer(a);
if (zera != k) {
std::println("błąd dla {}", k);
}
liczby_przypisan.insert(przypisania_s);
}
std::println("{}", liczby_przypisan); // zbiór wypisuje się jako {..}
}import java.util.*;
public class Zadanie {
static int[] liczbaZer(int[] a) {
// a[1..1023], a[0] nieużywane - indeksy jak w zadaniu
int przypisaniaS = 0;
int zera = 0;
int l = 1, p = a.length - 1;
while (l <= p) {
int s = (l + p) / 2;
przypisaniaS += 1;
if (a[s] == 1) {
p = s - 1;
} else {
zera = zera + (s - l + 1); // zera na pozycjach l..s
l = s + 1;
}
}
return new int[]{zera, przypisaniaS};
}
public static void main(String[] args) throws Exception {
// sprawdzenie dla wszystkich możliwych tablic (k zer, potem jedynki)
var liczbyPrzypisan = new TreeSet<Integer>();
for (int k = 0; k < 1024; k++) {
int[] a = new int[1024]; // a[0] nieużywane
for (int i = k + 1; i < 1024; i++) {
a[i] = 1;
}
int[] wynik = liczbaZer(a);
if (wynik[0] != k) {
System.out.println("błąd dla " + k);
}
liczbyPrzypisan.add(wynik[1]);
}
// zbiór wypisujemy w nawiasach klamrowych, jak Python
var napisy = new ArrayList<String>();
for (int x : liczbyPrzypisan) {
napisy.add(String.valueOf(x));
}
System.out.println("{" + String.join(", ", napisy) + "}");
}
}Odpowiedź: a) liczba_zer + (s − l + 1), l ← s + 1; b) zawsze 10 = log₂1024 – w każdym przebiegu pętli przedział do sprawdzenia zmniejsza się o połowę
↑Arkusz II
4a
Treść zadania
W pliku anagram.txt jest 200 wierszy, w każdym 5 słów (ciągów liter alfabetu łacińskiego, długości od 1 do 20) oddzielonych spacjami. Anagram to słowo powstałe z innego przez przestawienie liter (np. barok – korba – robak).
Wypisz te wiersze, w których wszystkie słowa mają tę samą liczbę znaków. Zapisz je w pliku odp_4a.txt.
with open("anagram.txt") as file, open("odp_4a.txt", "w") as wynik:
for line in file:
slowa = line.split()
if all(len(slowo) == len(slowa[0]) for slowo in slowa):
wynik.write(" ".join(slowa) + "\n")
print(" ".join(slowa))#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
int main() {
std::ifstream plik("anagram.txt");
std::ofstream wynik("odp_4a.txt");
std::string linia;
while (std::getline(plik, linia)) {
std::istringstream strumien(linia);
std::vector<std::string> slowa;
std::string slowo;
while (strumien >> slowo) {
slowa.push_back(slowo);
}
bool rowne = true;
for (const auto& s : slowa) {
if (s.size() != slowa[0].size()) {
rowne = false;
}
}
if (rowne) {
std::string zlaczone = "";
for (size_t i = 0; i < slowa.size(); i++) {
if (i > 0) zlaczone += " ";
zlaczone += slowa[i];
}
wynik << zlaczone << "\n";
std::cout << zlaczone << "\n";
}
}
}import java.io.*;
import java.nio.file.*;
import java.util.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
try (var wynik = new PrintWriter(new FileWriter("odp_4a.txt"))) {
for (String linia : Files.readAllLines(Path.of("anagram.txt"))) {
String[] slowa = linia.strip().split("\\s+");
boolean rowne = true;
for (String slowo : slowa) {
if (slowo.length() != slowa[0].length()) {
rowne = false;
}
}
if (rowne) {
String zlaczone = String.join(" ", slowa);
wynik.println(zlaczone);
System.out.println(zlaczone);
}
}
}
}
}Odpowiedź: wrona rossa slowo gwert rezas, grant hello zakon lloeh hello, kabaret kabanos kabaret gertyfu kabaret, … , burza orkan lukde pudeh lerfy (25 wierszy z klucza; program wypisuje też pierwszy wiersz pliku – przykład z treści „abcd cdba dbac cbad dcba”, którego klucz nie wymienia)
↑Arkusz II
4b
Treść zadania
Dane jak w 4a (plik anagram.txt, 200 wierszy po 5 słów).
Wypisz wszystkie wiersze, w których każde słowo jest anagramem pierwszego słowa w danym wierszu. Zapisz je w pliku odp_4b.txt.
def czy_anagram(a, b):
return sorted(a) == sorted(b)
with open("anagram.txt") as file, open("odp_4b.txt", "w") as wynik:
for line in file:
slowa = line.split()
if all(czy_anagram(slowa[0], slowo) for slowo in slowa[1:]):
wynik.write(" ".join(slowa) + "\n")
print(" ".join(slowa))#include <algorithm>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
bool czy_anagram(std::string a, std::string b) {
std::ranges::sort(a);
std::ranges::sort(b);
return a == b;
}
int main() {
std::ifstream plik("anagram.txt");
std::ofstream wynik("odp_4b.txt");
std::string linia;
while (std::getline(plik, linia)) {
std::istringstream strumien(linia);
std::vector<std::string> slowa;
std::string slowo;
while (strumien >> slowo) {
slowa.push_back(slowo);
}
bool anagramy = true;
for (size_t i = 1; i < slowa.size(); i++) {
if (!czy_anagram(slowa[0], slowa[i])) {
anagramy = false;
}
}
if (anagramy) {
std::string zlaczone = "";
for (size_t i = 0; i < slowa.size(); i++) {
if (i > 0) zlaczone += " ";
zlaczone += slowa[i];
}
wynik << zlaczone << "\n";
std::cout << zlaczone << "\n";
}
}
}import java.io.*;
import java.nio.file.*;
import java.util.*;
public class Zadanie {
static boolean czyAnagram(String a, String b) {
char[] x = a.toCharArray();
char[] y = b.toCharArray();
Arrays.sort(x);
Arrays.sort(y);
return Arrays.equals(x, y);
}
public static void main(String[] args) throws Exception {
try (var wynik = new PrintWriter(new FileWriter("odp_4b.txt"))) {
for (String linia : Files.readAllLines(Path.of("anagram.txt"))) {
String[] slowa = linia.strip().split("\\s+");
boolean anagramy = true;
for (int i = 1; i < slowa.length; i++) {
if (!czyAnagram(slowa[0], slowa[i])) {
anagramy = false;
}
}
if (anagramy) {
String zlaczone = String.join(" ", slowa);
wynik.println(zlaczone);
System.out.println(zlaczone);
}
}
}
}
}Odpowiedź: foto foto tofo tofo foto, glob lobg bogl glbo gblo, triada dariat aadrit iatdar adatri, kotek tekok teokk kokte otekk, rower werro werro owerr erwor, foto tofo foot ftoo ootf, spiker kerspi erspik erspki kiersp (oraz pierwszy wiersz pliku „abcd cdba dbac cbad dcba”, pominięty w kluczu)
↑Arkusz II
5a
Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Plik pesel.txt zawiera 150 numerów PESEL pracowników biura (wszyscy urodzeni przed 2000 r.). Cyfry 1–6 to data urodzenia (RRMMDD), 7–9 — liczba porządkowa, 10. — płeć (parzysta: kobieta, nieparzysta: mężczyzna), 11. — cyfra kontrolna. Cyfrę kontrolną liczy się tak: dziesięć pierwszych cyfr mnoży się przez wagi 1, 3, 7, 9, 1, 3, 7, 9, 1, 3, sumuje iloczyny, bierze resztę z dzielenia sumy przez 10; jeśli reszta to 0, cyfra kontrolna wynosi 0, w przeciwnym razie 10 − reszta. Dane osobowe są poprawne nawet przy błędnej cyfrze kontrolnej. Odpowiedzi zapisz w pliku odp_5.txt, poprzedzając je literą podpunktu.
Podaj, ile osób urodziło się w grudniu.
grudzien = 0
with open("pesel.txt") as file:
for line in file:
pesel = line.strip()
if pesel[2:4] == "12":
grudzien += 1
print(grudzien)#include <fstream>
#include <print>
#include <string>
int main() {
int grudzien = 0;
std::ifstream plik("pesel.txt");
std::string pesel;
while (plik >> pesel) {
if (pesel.substr(2, 2) == "12") {
grudzien += 1;
}
}
std::println("{}", grudzien);
}import java.nio.file.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
int grudzien = 0;
for (String linia : Files.readAllLines(Path.of("pesel.txt"))) {
String pesel = linia.strip();
if (pesel.substring(2, 4).equals("12")) {
grudzien += 1;
}
}
System.out.println(grudzien);
}
}Odpowiedź: 20
↑Arkusz II
5b
Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku pesel.txt (10. cyfra PESEL parzysta oznacza kobietę).
Podaj, ile kobiet pracuje w biurze.
kobiety = 0
with open("pesel.txt") as file:
for line in file:
pesel = line.strip()
if int(pesel[9]) % 2 == 0:
kobiety += 1
print(kobiety)#include <fstream>
#include <print>
#include <string>
int main() {
int kobiety = 0;
std::ifstream plik("pesel.txt");
std::string pesel;
while (plik >> pesel) {
if ((pesel[9] - '0') % 2 == 0) {
kobiety += 1;
}
}
std::println("{}", kobiety);
}import java.nio.file.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
int kobiety = 0;
for (String linia : Files.readAllLines(Path.of("pesel.txt"))) {
String pesel = linia.strip();
if ((pesel.charAt(9) - '0') % 2 == 0) {
kobiety += 1;
}
}
System.out.println(kobiety);
}
}Odpowiedź: 74
↑Arkusz II
5c
Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku pesel.txt.
Podaj rok, w którym urodziło się najwięcej pracowników biura.
lata = {}
with open("pesel.txt") as file:
for line in file:
rok = "19" + line.strip()[:2]
lata[rok] = lata.get(rok, 0) + 1
print(max(lata, key=lata.get))#include <fstream>
#include <map>
#include <print>
#include <string>
#include <vector>
int main() {
std::map<std::string, int> lata;
std::vector<std::string> kolejnosc; // lata w kolejności pojawienia się (jak słownik w Pythonie)
std::ifstream plik("pesel.txt");
std::string pesel;
while (plik >> pesel) {
std::string rok = "19" + pesel.substr(0, 2);
if (!lata.contains(rok)) {
kolejnosc.push_back(rok);
}
lata[rok] += 1;
}
std::string najczestszy = kolejnosc[0];
for (const auto& rok : kolejnosc) {
if (lata[rok] > lata[najczestszy]) {
najczestszy = rok;
}
}
std::println("{}", najczestszy);
}import java.nio.file.*;
import java.util.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
var lata = new LinkedHashMap<String, Integer>(); // zachowuje kolejność jak słownik w Pythonie
for (String linia : Files.readAllLines(Path.of("pesel.txt"))) {
String rok = "19" + linia.strip().substring(0, 2);
lata.put(rok, lata.getOrDefault(rok, 0) + 1);
}
String najczestszy = null;
for (String rok : lata.keySet()) {
if (najczestszy == null || lata.get(rok) > lata.get(najczestszy)) {
najczestszy = rok;
}
}
System.out.println(najczestszy);
}
}Odpowiedź: 1989
↑Arkusz II
5d
Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku pesel.txt (algorytm cyfry kontrolnej opisany w 5a).
Wypisz numery PESEL z niepoprawną cyfrą kontrolną, posortowane rosnąco.
wagi = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3]
bledne = []
with open("pesel.txt") as file:
for line in file:
pesel = line.strip()
suma = 0
for i in range(10):
suma += int(pesel[i]) * wagi[i]
kontrolna = (10 - suma % 10) % 10
if kontrolna != int(pesel[10]):
bledne.append(pesel)
for pesel in sorted(bledne):
print(pesel)#include <algorithm>
#include <fstream>
#include <print>
#include <string>
#include <vector>
int main() {
int wagi[] = {1, 3, 7, 9, 1, 3, 7, 9, 1, 3};
std::vector<std::string> bledne;
std::ifstream plik("pesel.txt");
std::string pesel;
while (plik >> pesel) {
int suma = 0;
for (int i = 0; i < 10; i++) {
suma += (pesel[i] - '0') * wagi[i];
}
int kontrolna = (10 - suma % 10) % 10;
if (kontrolna != pesel[10] - '0') {
bledne.push_back(pesel);
}
}
std::ranges::sort(bledne);
for (const auto& p : bledne) {
std::println("{}", p);
}
}import java.nio.file.*;
import java.util.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
int[] wagi = {1, 3, 7, 9, 1, 3, 7, 9, 1, 3};
var bledne = new ArrayList<String>();
for (String linia : Files.readAllLines(Path.of("pesel.txt"))) {
String pesel = linia.strip();
int suma = 0;
for (int i = 0; i < 10; i++) {
suma += (pesel.charAt(i) - '0') * wagi[i];
}
int kontrolna = (10 - suma % 10) % 10;
if (kontrolna != pesel.charAt(10) - '0') {
bledne.add(pesel);
}
}
Collections.sort(bledne);
for (String pesel : bledne) {
System.out.println(pesel);
}
}
}Odpowiedź: 54043010088, 60061144469, 77072919805, 77120835871, 83041812338, 89081421445, 91032272651, 92022716243
↑Arkusz II
5e
Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku pesel.txt.
Zestaw liczby osób urodzonych w kolejnych dziesięcioleciach: latach 50., 60., 70., 80. i 90. (np. lata 50. to roczniki 1950–1959 włącznie). Wykonaj wykres przedstawiający procentowy rozkład liczby osób w tych przedziałach.
dekady = {"50": 0, "60": 0, "70": 0, "80": 0, "90": 0}
with open("pesel.txt") as file:
for line in file:
dekady[line[0] + "0"] += 1
wszyscy = sum(dekady.values())
for dekada in dekady:
procent = dekady[dekada] / wszyscy * 100
print(f"{dekada}-te {dekady[dekada]} {procent:.1f}%")#include <fstream>
#include <map>
#include <print>
#include <string>
int main() {
std::map<std::string, int> dekady = {{"50", 0}, {"60", 0}, {"70", 0}, {"80", 0}, {"90", 0}};
std::ifstream plik("pesel.txt");
std::string pesel;
while (plik >> pesel) {
dekady[pesel.substr(0, 1) + "0"] += 1;
}
int wszyscy = 0;
for (const auto& [dekada, ile] : dekady) {
wszyscy += ile;
}
for (const auto& [dekada, ile] : dekady) {
double procent = static_cast<double>(ile) / wszyscy * 100;
std::println("{}-te {} {:.1f}%", dekada, ile, procent);
}
}import java.nio.file.*;
import java.util.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
var dekady = new LinkedHashMap<String, Integer>();
for (String d : List.of("50", "60", "70", "80", "90")) {
dekady.put(d, 0);
}
for (String linia : Files.readAllLines(Path.of("pesel.txt"))) {
String dekada = linia.charAt(0) + "0";
dekady.put(dekada, dekady.get(dekada) + 1);
}
int wszyscy = 0;
for (int ile : dekady.values()) {
wszyscy += ile;
}
for (var e : dekady.entrySet()) {
double procent = (double) e.getValue() / wszyscy * 100;
// Locale.ROOT - kropka dziesiętna niezależnie od ustawień systemu
System.out.println(String.format(Locale.ROOT, "%s-te %d %.1f%%", e.getKey(), e.getValue(), procent));
}
}
}Odpowiedź: 50-te 22, 60-te 28, 70-te 36, 80-te 58, 90-te 6 (wykres kołowy z procentami: ok. 15%, 19%, 24%, 39%, 4%)
↑