Matura 2015 — maj, poziom rozszerzony
ARKUSZ CZ. IARKUSZ CZ. IIDANEODPOWIEDZI
Treść zadania
Problem telewidza. Program telewizyjny to lista filmów emitowanych jednego dnia w różnych stacjach. Telewidz chce obejrzeć w całości jak najwięcej filmów, ale może oglądać tylko jeden film naraz (zmiana stacji nie zajmuje czasu, więc film kończący się o 12:00 nie koliduje z filmem zaczynającym się o 12:00). Przykładowy program:
- TV1: film 1 od 9:00 do 12:00, film 2 od 15:00 do 17:00,
- TV2: film 3 od 11:00 do 16:00,
- TV3: film 4 od 12:00 do 14:00,
- TV4: film 5 od 11:30 do 12:30.
Algorytm (dane: zbiór filmów T i strategia S; wynik: zbiór P filmów do obejrzenia): dopóki T nie jest pusty, wybierz z T film x według strategii S, przenieś go do P i usuń z T wszystkie filmy kolidujące z x.
- Strategia A — najdłuższy film (remis: kończący się najwcześniej),
- Strategia B — najkrótszy film (remis: kończący się najwcześniej),
- Strategia C — film zaczynający się najwcześniej (remis: kończący się najwcześniej),
- Strategia D — film kończący się najwcześniej (remis: zaczynający się najpóźniej).
Dla podanego programu strategia A daje P = {film 3}.
- 1.1 — Podaj zawartość zbioru P po wykonaniu algorytmu dla powyższego programu przy strategiach B, C i D.
- 1.2 — Strategia jest optymalna, jeśli dla każdego programu daje największą możliwą liczbę filmów. Dla każdej ze strategii A, B i C podaj kontrprzykład: program z czterema filmami w dwóch stacjach (godziny emisji i czasy trwania), wynik algorytmu dla tej strategii oraz liczniejszy zbiór filmów, które telewidz może obejrzeć.
def minuty(godzina):
h, m = godzina.split(":")
return int(h) * 60 + int(m)
strategie = {
"A": lambda f: (-(f[2] - f[1]), f[2]), # najdłuższy, potem najwcześniej się kończy
"B": lambda f: (f[2] - f[1], f[2]), # najkrótszy, potem najwcześniej się kończy
"C": lambda f: (f[1], f[2]), # najwcześniej się zaczyna, potem najwcześniej się kończy
"D": lambda f: (f[2], -f[1]), # najwcześniej się kończy, potem najpóźniej się zaczyna
}
def telewidz(program, strategia):
T = [(nazwa, minuty(od), minuty(do)) for nazwa, od, do in program]
P = []
while T:
x = min(T, key=strategie[strategia])
T.remove(x)
P.append(x[0])
# usuwamy filmy kolidujące z x (koniec jednego = początek drugiego to nie kolizja)
T = [f for f in T if f[2] <= x[1] or f[1] >= x[2]]
return P
# 1.1 - program z treści zadania
program = [
("film 1", "9:00", "12:00"),
("film 2", "15:00", "17:00"),
("film 3", "11:00", "16:00"),
("film 4", "12:00", "14:00"),
("film 5", "11:30", "12:30"),
]
for s in "ABCD":
print(s, telewidz(program, s))
# 1.2 - kontrprzykłady (strategia D jest optymalna, więc służy jako wzorzec)
kontrprzyklady = {
"A": [("film 1", "10:00", "12:00"), ("film 2", "12:00", "14:00"),
("film 3", "10:00", "11:00"), ("film 4", "11:00", "12:00")],
"B": [("film 1", "11:30", "12:30"), ("film 2", "15:00", "16:00"),
("film 3", "10:00", "12:00"), ("film 4", "12:00", "14:00")],
"C": [("film 1", "9:00", "14:00"), ("film 2", "15:00", "16:00"),
("film 3", "10:00", "12:00"), ("film 4", "12:00", "14:00")],
}
for s in kontrprzyklady:
print(s, telewidz(kontrprzyklady[s], s), "optymalnie:", telewidz(kontrprzyklady[s], "D"))#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
struct Film {
std::string nazwa;
int od, koniec;
};
struct Pozycja { // film z programu: nazwa, godzina rozpoczęcia, godzina zakończenia
std::string nazwa, od, koniec;
};
int minuty(const std::string& godzina) {
auto dwukropek = godzina.find(':');
return std::stoi(godzina.substr(0, dwukropek)) * 60 + std::stoi(godzina.substr(dwukropek + 1));
}
// klucz wyboru filmu dla danej strategii (porównywany jak krotka w Pythonie)
std::pair<int, int> klucz(const Film& f, char strategia) {
if (strategia == 'A') return {-(f.koniec - f.od), f.koniec}; // najdłuższy, potem najwcześniej się kończy
if (strategia == 'B') return {f.koniec - f.od, f.koniec}; // najkrótszy, potem najwcześniej się kończy
if (strategia == 'C') return {f.od, f.koniec}; // najwcześniej się zaczyna, potem najwcześniej się kończy
return {f.koniec, -f.od}; // D: najwcześniej się kończy, potem najpóźniej się zaczyna
}
std::vector<std::string> telewidz(const std::vector<Pozycja>& program, char strategia) {
std::vector<Film> T;
for (const auto& p : program) T.push_back({p.nazwa, minuty(p.od), minuty(p.koniec)});
std::vector<std::string> P;
while (!T.empty()) {
size_t najlepszy = 0;
for (size_t i = 1; i < T.size(); i++)
if (klucz(T[i], strategia) < klucz(T[najlepszy], strategia)) najlepszy = i;
Film x = T[najlepszy];
T.erase(T.begin() + najlepszy);
P.push_back(x.nazwa);
// usuwamy filmy kolidujące z x (koniec jednego = początek drugiego to nie kolizja)
std::vector<Film> reszta;
for (const auto& f : T)
if (f.koniec <= x.od || f.od >= x.koniec) reszta.push_back(f);
T = reszta;
}
return P;
}
std::string jako_lista(const std::vector<std::string>& P) { // zapis jak lista w Pythonie
std::string s = "[";
for (size_t i = 0; i < P.size(); i++) {
if (i > 0) s += ", ";
s += "'" + P[i] + "'";
}
return s + "]";
}
int main() {
// 1.1 - program z treści zadania
std::vector<Pozycja> program = {
{"film 1", "9:00", "12:00"},
{"film 2", "15:00", "17:00"},
{"film 3", "11:00", "16:00"},
{"film 4", "12:00", "14:00"},
{"film 5", "11:30", "12:30"},
};
for (char s : std::string("ABCD"))
std::cout << s << ' ' << jako_lista(telewidz(program, s)) << '\n';
// 1.2 - kontrprzykłady (strategia D jest optymalna, więc służy jako wzorzec)
std::map<char, std::vector<Pozycja>> kontrprzyklady = {
{'A', {{"film 1", "10:00", "12:00"}, {"film 2", "12:00", "14:00"},
{"film 3", "10:00", "11:00"}, {"film 4", "11:00", "12:00"}}},
{'B', {{"film 1", "11:30", "12:30"}, {"film 2", "15:00", "16:00"},
{"film 3", "10:00", "12:00"}, {"film 4", "12:00", "14:00"}}},
{'C', {{"film 1", "9:00", "14:00"}, {"film 2", "15:00", "16:00"},
{"film 3", "10:00", "12:00"}, {"film 4", "12:00", "14:00"}}},
};
for (const auto& [s, prog] : kontrprzyklady)
std::cout << s << ' ' << jako_lista(telewidz(prog, s)) << " optymalnie: "
<< jako_lista(telewidz(prog, 'D')) << '\n';
}import java.util.*;
public class Zadanie {
record Film(String nazwa, int od, int koniec) {}
static int minuty(String godzina) {
var czesci = godzina.split(":");
return Integer.parseInt(czesci[0]) * 60 + Integer.parseInt(czesci[1]);
}
// porównanie filmów dla danej strategii (jak klucz-krotka w Pythonie)
static Comparator<Film> strategia(char s) {
return switch (s) {
case 'A' -> Comparator.comparingInt((Film f) -> -(f.koniec() - f.od())).thenComparingInt(Film::koniec);
case 'B' -> Comparator.comparingInt((Film f) -> f.koniec() - f.od()).thenComparingInt(Film::koniec);
case 'C' -> Comparator.comparingInt(Film::od).thenComparingInt(Film::koniec);
default -> Comparator.comparingInt(Film::koniec).thenComparingInt((Film f) -> -f.od());
};
}
static List<String> telewidz(String[][] program, char s) {
var T = new ArrayList<Film>();
for (var p : program) T.add(new Film(p[0], minuty(p[1]), minuty(p[2])));
var P = new ArrayList<String>();
while (!T.isEmpty()) {
Film x = T.get(0);
for (var f : T) if (strategia(s).compare(f, x) < 0) x = f; // pierwszy najmniejszy
T.remove(x);
P.add(x.nazwa());
// usuwamy filmy kolidujące z x (koniec jednego = początek drugiego to nie kolizja)
final Film wybrany = x;
T.removeIf(f -> !(f.koniec() <= wybrany.od() || f.od() >= wybrany.koniec()));
}
return P;
}
static String jakoLista(List<String> P) { // zapis jak lista w Pythonie
var s = new StringJoiner(", ", "[", "]");
for (var nazwa : P) s.add("'" + nazwa + "'");
return s.toString();
}
public static void main(String[] args) {
// 1.1 - program z treści zadania
String[][] program = {
{"film 1", "9:00", "12:00"},
{"film 2", "15:00", "17:00"},
{"film 3", "11:00", "16:00"},
{"film 4", "12:00", "14:00"},
{"film 5", "11:30", "12:30"},
};
for (char s : "ABCD".toCharArray())
System.out.println(s + " " + jakoLista(telewidz(program, s)));
// 1.2 - kontrprzykłady (strategia D jest optymalna, więc służy jako wzorzec)
var kontrprzyklady = new LinkedHashMap<Character, String[][]>();
kontrprzyklady.put('A', new String[][] {{"film 1", "10:00", "12:00"}, {"film 2", "12:00", "14:00"},
{"film 3", "10:00", "11:00"}, {"film 4", "11:00", "12:00"}});
kontrprzyklady.put('B', new String[][] {{"film 1", "11:30", "12:30"}, {"film 2", "15:00", "16:00"},
{"film 3", "10:00", "12:00"}, {"film 4", "12:00", "14:00"}});
kontrprzyklady.put('C', new String[][] {{"film 1", "9:00", "14:00"}, {"film 2", "15:00", "16:00"},
{"film 3", "10:00", "12:00"}, {"film 4", "12:00", "14:00"}});
for (var e : kontrprzyklady.entrySet())
System.out.println(e.getKey() + " " + jakoLista(telewidz(e.getValue(), e.getKey()))
+ " optymalnie: " + jakoLista(telewidz(e.getValue(), 'D')));
}
}Odpowiedź: 1.1: B: {film 5, film 2}, C: {film 1, film 4, film 2}, D: {film 1, film 4, film 2}. 1.2: np. A: {film 1, film 2} zamiast {film 3, film 4, film 2} (programy jak w kodzie).
↑Treść zadania
Rozszerzony algorytm Euklidesa. Dla liczb całkowitych a > 0 i b ≥ 0 należy wyznaczyć liczby całkowite x, y takie, że NWD(a, b) = a·x + b·y. Jeśli b ≠ 0 i dla pary (b, a mod b) znamy x', y' spełniające NWD(b, a mod b) = b·x' + (a mod b)·y', to x = y', y = x' − (a div b)·y'. Dla b = 0 wynikiem jest para (1, 0). Przykład: NWD(231, 30) = 3 = 3·231 + (−23)·30.
- 3.1 — Uzupełnij tabelę kolejnych wywołań funkcji RozszerzonyEuklides(a, b) dla a = 188, b = 12: dla każdego wywołania podaj wartości a i b oraz zwrócone x i y.
- 3.2 — Uzupełnij rekurencyjną funkcję:
RozszerzonyEuklides(a, b):
Krok 1. Jeśli b = 0, zwróć (1, 0) i zakończ.
Krok 2. r ← a mod b
Krok 3. (x, y) ← RozszerzonyEuklides(____, ____)
Krok 4. Zwróć parę (____, ____).def rozszerzony_euklides(a, b, poziom=1):
if b == 0:
print(poziom, a, b, 1, 0)
return 1, 0
r = a % b
x, y = rozszerzony_euklides(b, r, poziom + 1) # krok 3: (b, r)
x, y = y, x - (a // b) * y # krok 4: (y', x' - (a div b) * y')
print(poziom, a, b, x, y)
return x, y
# 3.1 - tabela dla a = 188, b = 12 (wiersze wypisywane przy powrocie z rekurencji)
x, y = rozszerzony_euklides(188, 12)
print("NWD =", 188 * x + 12 * y)#include <iostream>
#include <utility>
std::pair<long long, long long> rozszerzony_euklides(long long a, long long b, int poziom = 1) {
if (b == 0) {
std::cout << poziom << ' ' << a << ' ' << b << ' ' << 1 << ' ' << 0 << '\n';
return {1, 0};
}
long long r = a % b;
auto [x1, y1] = rozszerzony_euklides(b, r, poziom + 1); // krok 3: (b, r)
long long x = y1, y = x1 - (a / b) * y1; // krok 4: (y', x' - (a div b) * y')
std::cout << poziom << ' ' << a << ' ' << b << ' ' << x << ' ' << y << '\n';
return {x, y};
}
int main() {
// 3.1 - tabela dla a = 188, b = 12 (wiersze wypisywane przy powrocie z rekurencji)
auto [x, y] = rozszerzony_euklides(188, 12);
std::cout << "NWD = " << 188 * x + 12 * y << '\n';
}public class Zadanie {
static long[] rozszerzonyEuklides(long a, long b, int poziom) {
if (b == 0) {
System.out.println(poziom + " " + a + " " + b + " " + 1 + " " + 0);
return new long[] {1, 0};
}
long r = a % b;
long[] xy = rozszerzonyEuklides(b, r, poziom + 1); // krok 3: (b, r)
long x = xy[1], y = xy[0] - (a / b) * xy[1]; // krok 4: (y', x' - (a div b) * y')
System.out.println(poziom + " " + a + " " + b + " " + x + " " + y);
return new long[] {x, y};
}
public static void main(String[] args) {
// 3.1 - tabela dla a = 188, b = 12 (wiersze wypisywane przy powrocie z rekurencji)
long[] xy = rozszerzonyEuklides(188, 12, 1);
System.out.println("NWD = " + (188 * xy[0] + 12 * xy[1]));
}
}Odpowiedź: 3.1: (188, 12, -1, 16), (12, 8, 1, -1), (8, 4, 0, 1), (4, 0, 1, 0). 3.2: krok 3: (b, r), krok 4: (y', x' - (a div b) · y').
↑Treść zadania
W pliku liczby.txt znajduje się 1000 liczb naturalnych zapisanych binarnie, każda w osobnym wierszu. Liczba ma co najwyżej 250 cyfr, więc może nie mieścić się w typie całkowitym (np. int). Odpowiedzi zapisz w pliku wynik4.txt, poprzedzając każdą numerem zadania.
Podaj, ile liczb z pliku ma w zapisie binarnym więcej zer niż jedynek.
Przykład: dla liczb 101011010011001100111, 10001001, 1000000, 101010011100, 100010 odpowiedzią jest 3.
wynik = 0
with open("liczby.txt") as file:
for line in file:
liczba = line.strip()
if liczba.count("0") > liczba.count("1"):
wynik += 1
print(wynik)#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
int main() {
int wynik = 0;
std::ifstream plik("liczby.txt");
std::string liczba;
while (plik >> liczba)
if (std::ranges::count(liczba, '0') > std::ranges::count(liczba, '1'))
wynik++;
std::cout << wynik << '\n';
}import java.nio.file.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
int wynik = 0;
for (var line : Files.readAllLines(Path.of("liczby.txt"))) {
var liczba = line.strip();
long zera = liczba.chars().filter(c -> c == '0').count();
long jedynki = liczba.chars().filter(c -> c == '1').count();
if (zera > jedynki) wynik++;
}
System.out.println(wynik);
}
}Odpowiedź: 422
↑Treść zadania
Plik liczby.txt zawiera 1000 liczb binarnych (do 250 cyfr). Podaj, ile liczb z pliku jest podzielnych przez 2, a ile przez 8. Odpowiedź zapisz w wynik4.txt.
Przykład: dla liczb 101011010011001100000, 10001001, 100100, 101010010101011011000, 100011 trzy liczby są podzielne przez 2, a dwie przez 8.
przez_dwa = przez_osiem = 0
with open("liczby.txt") as file:
for line in file:
liczba = line.strip()
# liczba binarna jest podzielna przez 2, gdy kończy się na 0, a przez 8 - gdy kończy się na 000
if liczba[-1] == "0":
przez_dwa += 1
if liczba[-3:] == "000":
przez_osiem += 1
print(przez_dwa, przez_osiem)#include <fstream>
#include <iostream>
#include <string>
int main() {
int przez_dwa = 0, przez_osiem = 0;
std::ifstream plik("liczby.txt");
std::string liczba;
while (plik >> liczba) {
// liczba binarna jest podzielna przez 2, gdy kończy się na 0, a przez 8 - gdy kończy się na 000
if (liczba.ends_with("0")) przez_dwa++;
if (liczba.ends_with("000")) przez_osiem++;
}
std::cout << przez_dwa << ' ' << przez_osiem << '\n';
}import java.nio.file.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
int przezDwa = 0, przezOsiem = 0;
for (var line : Files.readAllLines(Path.of("liczby.txt"))) {
var liczba = line.strip();
// liczba binarna jest podzielna przez 2, gdy kończy się na 0, a przez 8 - gdy kończy się na 000
if (liczba.endsWith("0")) przezDwa++;
if (liczba.endsWith("000")) przezOsiem++;
}
System.out.println(przezDwa + " " + przezOsiem);
}
}Odpowiedź: 500 liczb podzielnych przez 2, 123 liczby podzielne przez 8
↑Treść zadania
Plik liczby.txt zawiera 1000 liczb binarnych (do 250 cyfr). Znajdź najmniejszą i największą liczbę w pliku i podaj numery wierszy, w których się znajdują (najpierw najmniejszej, potem największej). Odpowiedź zapisz w wynik4.txt.
Przykład: dla liczb 101011010011001100111, 10001001011101010, 1001000, 101010011100, 1000110 odpowiedzią jest 5, 1.
lista = []
with open("liczby.txt") as file:
for line in file:
lista.append(int(line.strip(), 2))
# numer wiersza najmniejszej i największej liczby
print(lista.index(min(lista)) + 1, lista.index(max(lista)) + 1)#include <fstream>
#include <iostream>
#include <string>
#include <vector>
// liczby mają do 200 cyfr, więc nie mieszczą się w long long - porównujemy napisy:
// dłuższa liczba (bez zer wiodących) jest większa, przy równej długości decyduje porządek leksykograficzny
bool mniejsza(const std::string& a, const std::string& b) {
if (a.size() != b.size()) return a.size() < b.size();
return a < b;
}
int main() {
std::vector<std::string> lista;
std::ifstream plik("liczby.txt");
std::string liczba;
while (plik >> liczba) {
while (liczba.size() > 1 && liczba[0] == '0') liczba.erase(0, 1); // usuwamy zera wiodące
lista.push_back(liczba);
}
size_t najmniejsza = 0, najwieksza = 0; // pierwsze wystąpienie, jak index() w Pythonie
for (size_t i = 1; i < lista.size(); i++) {
if (mniejsza(lista[i], lista[najmniejsza])) najmniejsza = i;
if (mniejsza(lista[najwieksza], lista[i])) najwieksza = i;
}
// numer wiersza najmniejszej i największej liczby
std::cout << najmniejsza + 1 << ' ' << najwieksza + 1 << '\n';
}import java.math.BigInteger;
import java.nio.file.*;
import java.util.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
var lista = new ArrayList<BigInteger>(); // liczby mają do 200 cyfr
for (var line : Files.readAllLines(Path.of("liczby.txt")))
lista.add(new BigInteger(line.strip(), 2));
// numer wiersza najmniejszej i największej liczby
System.out.println((lista.indexOf(Collections.min(lista)) + 1) + " " + (lista.indexOf(Collections.max(lista)) + 1));
}
}Odpowiedź: 859 (najmniejsza), 925 (największa)
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Plik kraina.txt zawiera dane demograficzne 50 województw Edulandii. Każde należy do jednego z regionów A, B, C, D. Wiersz zawiera dane rozdzielone średnikami: nazwa województwa, liczba kobiet w 2013, liczba mężczyzn w 2013, liczba kobiet w 2014, liczba mężczyzn w 2014 (np. w01D;1415007;1397195;1499070;1481105). Nazwa ma postać „w”, dwucyfrowy numer i litera regionu. Odpowiedzi zapisz w pliku wynik5.txt, poprzedzając je numerem zadania.
Wyznacz ludność (kobiety + mężczyźni) każdego z regionów A, B, C i D w roku 2013 i sporządź czytelny wykres kolumnowy porównujący te wartości.
ludnosc = {"A": 0, "B": 0, "C": 0, "D": 0}
with open("kraina.txt") as file:
for line in file:
nazwa, k13, m13, k14, m14 = line.strip().split(";")
region = nazwa[-1]
ludnosc[region] += int(k13) + int(m13)
for region in ludnosc:
print(region, ludnosc[region])#include <fstream>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
int main() {
std::map<char, long long> ludnosc = {{'A', 0}, {'B', 0}, {'C', 0}, {'D', 0}};
std::ifstream plik("kraina.txt");
std::string line;
while (plik >> line) {
std::stringstream ss(line);
std::string nazwa, k13, m13;
std::getline(ss, nazwa, ';');
std::getline(ss, k13, ';');
std::getline(ss, m13, ';');
char region = nazwa.back();
ludnosc[region] += std::stoll(k13) + std::stoll(m13);
}
for (auto [region, liczba] : ludnosc)
std::cout << region << ' ' << liczba << '\n';
}import java.nio.file.*;
import java.util.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
var ludnosc = new LinkedHashMap<Character, Long>();
for (char r : "ABCD".toCharArray()) ludnosc.put(r, 0L);
for (var line : Files.readAllLines(Path.of("kraina.txt"))) {
var p = line.strip().split(";"); // nazwa, k13, m13, k14, m14
char region = p[0].charAt(p[0].length() - 1);
ludnosc.merge(region, Long.parseLong(p[1]) + Long.parseLong(p[2]), Long::sum);
}
for (var e : ludnosc.entrySet())
System.out.println(e.getKey() + " " + e.getValue());
}
}Odpowiedź: A: 33 929 579, B: 41 736 619, C: 57 649 017, D: 36 530 387 (+ wykres kolumnowy)
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku kraina.txt (województwo; kobiety 2013; mężczyźni 2013; kobiety 2014; mężczyźni 2014). Wybierz województwa, w których w 2014 roku zarówno liczba kobiet, jak i liczba mężczyzn była większa niż w 2013. Podaj liczbę takich województw w całym kraju oraz osobno w każdym regionie A, B, C i D.
regiony = {"A": 0, "B": 0, "C": 0, "D": 0}
with open("kraina.txt") as file:
for line in file:
nazwa, k13, m13, k14, m14 = line.strip().split(";")
if int(k14) > int(k13) and int(m14) > int(m13):
regiony[nazwa[-1]] += 1
print(sum(regiony.values()))
for region in regiony:
print(region, regiony[region])#include <fstream>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
int main() {
std::map<char, int> regiony = {{'A', 0}, {'B', 0}, {'C', 0}, {'D', 0}};
std::ifstream plik("kraina.txt");
std::string line;
while (plik >> line) {
std::stringstream ss(line);
std::vector<std::string> p; // nazwa, k13, m13, k14, m14
std::string pole;
while (std::getline(ss, pole, ';')) p.push_back(pole);
if (std::stoll(p[3]) > std::stoll(p[1]) && std::stoll(p[4]) > std::stoll(p[2]))
regiony[p[0].back()]++;
}
int suma = 0;
for (auto [region, ile] : regiony) suma += ile;
std::cout << suma << '\n';
for (auto [region, ile] : regiony)
std::cout << region << ' ' << ile << '\n';
}import java.nio.file.*;
import java.util.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
var regiony = new LinkedHashMap<Character, Integer>();
for (char r : "ABCD".toCharArray()) regiony.put(r, 0);
for (var line : Files.readAllLines(Path.of("kraina.txt"))) {
var p = line.strip().split(";"); // nazwa, k13, m13, k14, m14
if (Long.parseLong(p[3]) > Long.parseLong(p[1]) && Long.parseLong(p[4]) > Long.parseLong(p[2]))
regiony.merge(p[0].charAt(p[0].length() - 1), 1, Integer::sum);
}
System.out.println(regiony.values().stream().mapToInt(Integer::intValue).sum());
for (var e : regiony.entrySet())
System.out.println(e.getKey() + " " + e.getValue());
}
}Odpowiedź: 19 województw, w tym A: 3, B: 4, C: 8, D: 4
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku kraina.txt. Tempo wzrostu województwa to iloraz ludność(2014) / ludność(2013) zaokrąglony w dół do 4 miejsc po przecinku. Dla r > 2014: ludność(r) = ludność(r − 1) · tempo, zaokrąglone w dół do liczby całkowitej. Jeśli w danym roku ludność województwa jest ponad dwukrotnie większa niż w 2013, występuje przeludnienie i od następnego roku ludność tego województwa już się nie zmienia.
Przykład: dla w01D ludność 2013 = 2 812 202, 2014 = 2 980 175, tempo = 1,0597, ludność 2015 = 3 158 091; w 2025 roku wyniesie 5 639 669 (przeludnienie).
Podaj:
- łączną liczbę mieszkańców Edulandii w 2025 roku oraz województwo, które będzie miało wtedy najwięcej mieszkańców,
- liczbę województw, w których w latach 2014–2025 włącznie wystąpi efekt przeludnienia.
suma_2025 = 0
najwiecej = 0
najwieksze = ""
przeludnione = 0
with open("kraina.txt") as file:
for line in file:
nazwa, k13, m13, k14, m14 = line.strip().split(";")
l2013 = int(k13) + int(m13)
l2014 = int(k14) + int(m14)
# tempo zaokrąglone w dół do 4 miejsc - liczymy w dziesięciotysięcznych, żeby uniknąć błędów float
tempo = l2014 * 10000 // l2013
ludnosc = l2014
przeludnienie = ludnosc > 2 * l2013
for rok in range(2015, 2026):
if not przeludnienie:
ludnosc = ludnosc * tempo // 10000
if ludnosc > 2 * l2013:
przeludnienie = True
if przeludnienie:
przeludnione += 1
suma_2025 += ludnosc
if ludnosc > najwiecej:
najwiecej = ludnosc
najwieksze = nazwa
print(suma_2025)
print(najwieksze)
print(przeludnione)#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
int main() {
long long suma_2025 = 0, najwiecej = 0;
std::string najwieksze;
int przeludnione = 0;
std::ifstream plik("kraina.txt");
std::string line;
while (plik >> line) {
std::stringstream ss(line);
std::vector<std::string> p; // nazwa, k13, m13, k14, m14
std::string pole;
while (std::getline(ss, pole, ';')) p.push_back(pole);
long long l2013 = std::stoll(p[1]) + std::stoll(p[2]);
long long l2014 = std::stoll(p[3]) + std::stoll(p[4]);
// tempo zaokrąglone w dół do 4 miejsc - liczymy w dziesięciotysięcznych, żeby uniknąć błędów float
long long tempo = l2014 * 10000 / l2013;
long long ludnosc = l2014;
bool przeludnienie = ludnosc > 2 * l2013;
for (int rok = 2015; rok < 2026; rok++) {
if (!przeludnienie) {
ludnosc = ludnosc * tempo / 10000;
if (ludnosc > 2 * l2013) przeludnienie = true;
}
}
if (przeludnienie) przeludnione++;
suma_2025 += ludnosc;
if (ludnosc > najwiecej) {
najwiecej = ludnosc;
najwieksze = p[0];
}
}
std::cout << suma_2025 << '\n' << najwieksze << '\n' << przeludnione << '\n';
}import java.nio.file.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
long suma2025 = 0, najwiecej = 0;
String najwieksze = "";
int przeludnione = 0;
for (var line : Files.readAllLines(Path.of("kraina.txt"))) {
var p = line.strip().split(";"); // nazwa, k13, m13, k14, m14
long l2013 = Long.parseLong(p[1]) + Long.parseLong(p[2]);
long l2014 = Long.parseLong(p[3]) + Long.parseLong(p[4]);
// tempo zaokrąglone w dół do 4 miejsc - liczymy w dziesięciotysięcznych, żeby uniknąć błędów float
long tempo = l2014 * 10000 / l2013;
long ludnosc = l2014;
boolean przeludnienie = ludnosc > 2 * l2013;
for (int rok = 2015; rok < 2026; rok++) {
if (!przeludnienie) {
ludnosc = ludnosc * tempo / 10000;
if (ludnosc > 2 * l2013) przeludnienie = true;
}
}
if (przeludnienie) przeludnione++;
suma2025 += ludnosc;
if (ludnosc > najwiecej) {
najwiecej = ludnosc;
najwieksze = p[0];
}
}
System.out.println(suma2025);
System.out.println(najwieksze);
System.out.println(przeludnione);
}
}Odpowiedź: 125 930 205 mieszkańców w 2025 roku, najwięcej: w12C, przeludnienie w 18 województwach
↑