Matura 2018 — maj, poziom rozszerzony
ARKUSZ CZ. IARKUSZ CZ. IIDANEODPOWIEDZI
Treść zadania
Zadanie 1 (analiza algorytmu). Dla liczby całkowitej dodatniej n algorytm wyznacza liczbę całkowitą dodatnią p (div oznacza dzielenie całkowite):
p ← 1
q ← n
dopóki p < q wykonuj
s ← (p + q) div 2
(*) jeżeli s*s*s < n
p ← s + 1
w przeciwnym wypadku
q ← s- 1.1 — podaj wynik
pdlan= 28, 64 i 80. - 1.2 — podaj najmniejszą i największą liczbę
n, dla której wynikiem algorytmu jestp = 10.
def algorytm(n):
p = 1
q = n
while p < q:
s = (p + q) // 2
if s * s * s < n:
p = s + 1
else:
q = s
return p
# 1.1
for n in [28, 64, 80]:
print(n, algorytm(n))
# 1.2 - najmniejsze i największe n, dla którego p = 10
liczby = [n for n in range(1, 2000) if algorytm(n) == 10]
print(min(liczby), max(liczby))#include <algorithm>
#include <print>
#include <vector>
long long algorytm(long long n) {
long long p = 1;
long long q = n;
while (p < q) {
long long s = (p + q) / 2;
if (s * s * s < n)
p = s + 1;
else
q = s;
}
return p;
}
int main() {
// 1.1
for (int n : {28, 64, 80})
std::println("{} {}", n, algorytm(n));
// 1.2 - najmniejsze i największe n, dla którego p = 10
std::vector<int> liczby;
for (int n = 1; n < 2000; n++)
if (algorytm(n) == 10)
liczby.push_back(n);
std::println("{} {}", std::ranges::min(liczby), std::ranges::max(liczby));
}import java.util.ArrayList;
import java.util.Collections;
public class Zadanie {
static long algorytm(long n) {
long p = 1;
long q = n;
while (p < q) {
long s = (p + q) / 2;
if (s * s * s < n)
p = s + 1;
else
q = s;
}
return p;
}
public static void main(String[] args) throws Exception {
// 1.1
for (int n : new int[]{28, 64, 80})
System.out.println(n + " " + algorytm(n));
// 1.2 - najmniejsze i największe n, dla którego p = 10
var liczby = new ArrayList<Integer>();
for (int n = 1; n < 2000; n++)
if (algorytm(n) == 10)
liczby.add(n);
System.out.println(Collections.min(liczby) + " " + Collections.max(liczby));
}
}Odpowiedź: 1.1: 28 → 4, 64 → 4, 80 → 5; 1.2: najmniejsza 730, największa 1000
↑Treść zadania
Zadanie 2 (krajobraz). W paśmie górskim jest n szczytów — punktów o współrzędnych (X[i], Y[i]) z tablic X[1..n] (liczby całkowite) i Y[1..n] (liczby całkowite dodatnie). Obserwator stoi w punkcie (0,0). Szczyt A jest widoczny na lewo od B, gdy xA/yA < xB/yB; żadne dwa szczyty nie leżą w jednej linii z obserwatorem.
Napisz algorytm, który poda współrzędne x, y skrajnie lewego szczytu, czyli widocznego na lewo od wszystkich pozostałych.
def skrajnie_lewy(n, X, Y):
k = 0
for i in range(1, n):
if X[i] / Y[i] < X[k] / Y[k]:
k = i
return X[k], Y[k]
X = [3, -2, 5, -4]
Y = [4, 3, 2, 1]
print(skrajnie_lewy(len(X), X, Y))#include <print>
#include <utility>
#include <vector>
std::pair<int, int> skrajnie_lewy(int n, const std::vector<int>& X, const std::vector<int>& Y) {
int k = 0;
for (int i = 1; i < n; i++)
if ((double)X[i] / Y[i] < (double)X[k] / Y[k])
k = i;
return {X[k], Y[k]};
}
int main() {
std::vector<int> X = {3, -2, 5, -4};
std::vector<int> Y = {4, 3, 2, 1};
std::println("{}", skrajnie_lewy(X.size(), X, Y)); // para wypisuje się jako (x, y)
}public class Zadanie {
static int[] skrajnieLewy(int n, int[] X, int[] Y) {
int k = 0;
for (int i = 1; i < n; i++)
if ((double) X[i] / Y[i] < (double) X[k] / Y[k])
k = i;
return new int[]{X[k], Y[k]};
}
public static void main(String[] args) throws Exception {
int[] X = {3, -2, 5, -4};
int[] Y = {4, 3, 2, 1};
int[] szczyt = skrajnieLewy(X.length, X, Y);
System.out.println("(" + szczyt[0] + ", " + szczyt[1] + ")");
}
}Odpowiedź: przykładowy algorytm – szukamy szczytu o najmniejszym ilorazie X[i]/Y[i] (dla przykładu w kodzie: (-4, 1))
↑Treść zadania
Dane jak w zadaniu 2.1: tablice X[1..n], Y[1..n] ze współrzędnymi szczytów (Y[i] > 0), żadne dwa nie leżą w jednej linii z obserwatorem w (0,0).
Napisz algorytm, który przestawi elementy tablic X i Y tak, aby szczyty były uporządkowane w kolejności widzenia ich przez obserwatora od lewej do prawej (rosnąco względem X[i]/Y[i]). Złożoność co najwyżej kwadratowa; wolno używać tylko instrukcji sterujących, operatorów arytmetycznych i logicznych, porównań i przypisań — bez funkcji bibliotecznych (np. gotowego sortowania).
def sortuj_szczyty(n, X, Y):
# sortowanie przez wybór - złożoność kwadratowa
for i in range(n - 1):
m = i
for j in range(i + 1, n):
if X[j] / Y[j] < X[m] / Y[m]:
m = j
X[i], X[m] = X[m], X[i]
Y[i], Y[m] = Y[m], Y[i]
X = [3, -2, 5, -4]
Y = [4, 3, 2, 1]
sortuj_szczyty(len(X), X, Y)
print(X)
print(Y)#include <print>
#include <utility>
#include <vector>
void sortuj_szczyty(int n, std::vector<int>& X, std::vector<int>& Y) {
// sortowanie przez wybór - złożoność kwadratowa
for (int i = 0; i < n - 1; i++) {
int m = i;
for (int j = i + 1; j < n; j++)
if ((double)X[j] / Y[j] < (double)X[m] / Y[m])
m = j;
std::swap(X[i], X[m]);
std::swap(Y[i], Y[m]);
}
}
int main() {
std::vector<int> X = {3, -2, 5, -4};
std::vector<int> Y = {4, 3, 2, 1};
sortuj_szczyty(X.size(), X, Y);
std::println("{}", X);
std::println("{}", Y);
}import java.util.Arrays;
public class Zadanie {
static void sortujSzczyty(int n, int[] X, int[] Y) {
// sortowanie przez wybór - złożoność kwadratowa
for (int i = 0; i < n - 1; i++) {
int m = i;
for (int j = i + 1; j < n; j++)
if ((double) X[j] / Y[j] < (double) X[m] / Y[m])
m = j;
int t = X[i]; X[i] = X[m]; X[m] = t;
t = Y[i]; Y[i] = Y[m]; Y[m] = t;
}
}
public static void main(String[] args) throws Exception {
int[] X = {3, -2, 5, -4};
int[] Y = {4, 3, 2, 1};
sortujSzczyty(X.length, X, Y);
System.out.println(Arrays.toString(X));
System.out.println(Arrays.toString(Y));
}
}Odpowiedź: przykładowy algorytm – sortowanie (np. przez wybór) względem X[i]/Y[i], zamieniając jednocześnie elementy X i Y
↑Treść zadania
Zadanie 4 (sygnały). Plik sygnaly.txt zawiera 1000 wierszy, w każdym jedno niepuste słowo z wielkich liter alfabetu angielskiego o długości co najwyżej 100. Odpowiedzi zapisz w pliku wyniki4.txt, poprzedzając każdą numerem zadania (dane przykładowe: przyklad.txt).
Złącz dziesiąte litery co czterdziestego słowa, zaczynając od słowa 40. (każde takie słowo ma co najmniej 10 znaków), i wypisz otrzymane przesłanie.
Dla pliku przykładowego wynikiem jest NIECHCIMATURAPROSTABEDZIE.
przeslanie = ""
with open("sygnaly.txt") as file:
slowa = file.read().split()
for i in range(39, len(slowa), 40):
przeslanie += slowa[i][9]
print(przeslanie)#include <fstream>
#include <print>
#include <string>
#include <vector>
int main() {
std::ifstream plik("sygnaly.txt");
std::vector<std::string> slowa;
std::string slowo;
while (plik >> slowo)
slowa.push_back(slowo);
std::string przeslanie = "";
for (size_t i = 39; i < slowa.size(); i += 40)
przeslanie += slowa[i][9];
std::println("{}", przeslanie);
}import java.nio.file.Files;
import java.nio.file.Path;
public class Zadanie {
public static void main(String[] args) throws Exception {
String[] slowa = Files.readString(Path.of("sygnaly.txt")).trim().split("\\s+");
var przeslanie = new StringBuilder();
for (int i = 39; i < slowa.length; i += 40)
przeslanie.append(slowa[i].charAt(9));
System.out.println(przeslanie);
}
}Odpowiedź: ZAPISZODPOWIEDZIWPLIKUTXT
↑Treść zadania
Dane z pliku sygnaly.txt (1000 słów z wielkich liter).
Znajdź słowo zawierające największą liczbę różnych liter i wypisz je wraz z tą liczbą. Jeśli takich słów jest kilka, wypisz pierwsze z nich w pliku.
Dla pliku przykładowego: AKLMNOPRSTWZA 12.
with open("sygnaly.txt") as file:
slowa = file.read().split()
maks = 0
najlepsze = ""
for slowo in slowa:
rozne = len(set(slowo))
if rozne > maks:
maks = rozne
najlepsze = slowo
print(najlepsze, maks)#include <fstream>
#include <print>
#include <set>
#include <string>
int main() {
std::ifstream plik("sygnaly.txt");
size_t maks = 0;
std::string najlepsze = "";
std::string slowo;
while (plik >> slowo) {
std::set<char> litery(slowo.begin(), slowo.end());
size_t rozne = litery.size();
if (rozne > maks) {
maks = rozne;
najlepsze = slowo;
}
}
std::println("{} {}", najlepsze, maks);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashSet;
public class Zadanie {
public static void main(String[] args) throws Exception {
String[] slowa = Files.readString(Path.of("sygnaly.txt")).trim().split("\\s+");
int maks = 0;
String najlepsze = "";
for (String slowo : slowa) {
var litery = new HashSet<Character>();
for (char c : slowo.toCharArray())
litery.add(c);
int rozne = litery.size();
if (rozne > maks) {
maks = rozne;
najlepsze = slowo;
}
}
System.out.println(najlepsze + " " + maks);
}
}Odpowiedź: SUOLDQWISCDRFLRWHZBNTMIAPHALMNCWHVGMXOZSQNXWXSFELZVTUTILXWKCTYBQYSUAKNYJKRXDJQYHXAQGWN 26
↑Treść zadania
Dane z pliku sygnaly.txt (1000 słów z wielkich liter).
Odległość liter to różnica ich pozycji w alfabecie (np. A–B: 1, A–E: 4, litera od siebie: 0). Wypisz, po jednym w wierszu i w kolejności z pliku, wszystkie słowa, w których każde dwie litery są od siebie oddalone co najwyżej o 10.
Przykład: CGECF spełnia warunek, a ABEZA nie (odległość A–Z wynosi 25).
with open("sygnaly.txt") as file:
slowa = file.read().split()
for slowo in slowa:
# każde dwie litery są oddalone co najwyżej o 10 <=> największa i najmniejsza litera są oddalone co najwyżej o 10
if ord(max(slowo)) - ord(min(slowo)) <= 10:
print(slowo)#include <algorithm>
#include <fstream>
#include <print>
#include <string>
int main() {
std::ifstream plik("sygnaly.txt");
std::string slowo;
while (plik >> slowo) {
// każde dwie litery są oddalone co najwyżej o 10 <=> największa i najmniejsza litera są oddalone co najwyżej o 10
if (std::ranges::max(slowo) - std::ranges::min(slowo) <= 10)
std::println("{}", slowo);
}
}import java.nio.file.Files;
import java.nio.file.Path;
public class Zadanie {
public static void main(String[] args) throws Exception {
String[] slowa = Files.readString(Path.of("sygnaly.txt")).trim().split("\\s+");
for (String slowo : slowa) {
// każde dwie litery są oddalone co najwyżej o 10 <=> największa i najmniejsza litera są oddalone co najwyżej o 10
char najmniejsza = slowo.charAt(0), najwieksza = slowo.charAt(0);
for (char c : slowo.toCharArray()) {
najmniejsza = (char) Math.min(najmniejsza, c);
najwieksza = (char) Math.max(najwieksza, c);
}
if (najwieksza - najmniejsza <= 10)
System.out.println(slowo);
}
}
}Odpowiedź: QQMLKKQNOHPKKPJOLHIPJKLKQIIHQHPNKNQPHNKLKQNIMLQPNLPMHNNIPNJJONQOHKKQOIHOHHJMOJPMNIPIKION, PTPNTOLNOPOSKLQOQKNTQTPLPNLNRRSTNNSMRNNMLPNLKORTSMNKRTLLLLNRKKOLKTRQOQOQONKTKRSPTTORMKQTRNOKKQ, … (lista słów w kluczu odpowiedzi)
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Zadanie 5 (zbiornik). Plik woda.txt zawiera 3653 wiersze z danymi o dobowym dopływie wody z rzeki Wirki do zbiornika retencyjnego w latach 2008–2017. W wierszu: data (rrrr-mm-dd) i liczba m³ wody, która dopłynęła w ciągu doby, oddzielone tabulatorem (np. 2008-01-01 2275). Odpowiedzi zapisz w pliku wyniki5.txt, poprzedzając je numerem zadania.
Podaj rok, w którym do zbiornika dopłynęło łącznie najwięcej wody.
suma_rok = {}
with open("woda.txt") as file:
for line in file:
data, doplyw = line.split()
rok = data[:4]
suma_rok[rok] = suma_rok.get(rok, 0) + int(doplyw)
najlepszy = max(suma_rok, key=suma_rok.get)
print(najlepszy, suma_rok[najlepszy])#include <fstream>
#include <map>
#include <print>
#include <string>
int main() {
std::map<std::string, long long> suma_rok;
std::ifstream plik("woda.txt");
std::string data;
long long doplyw;
while (plik >> data >> doplyw) {
std::string rok = data.substr(0, 4);
suma_rok[rok] += doplyw;
}
std::string najlepszy;
long long maks = -1;
for (const auto& [rok, suma] : suma_rok)
if (suma > maks) {
maks = suma;
najlepszy = rok;
}
std::println("{} {}", najlepszy, maks);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.TreeMap;
public class Zadanie {
public static void main(String[] args) throws Exception {
var sumaRok = new TreeMap<String, Long>();
for (String line : Files.readAllLines(Path.of("woda.txt"))) {
String[] czesci = line.trim().split("\\s+");
String rok = czesci[0].substring(0, 4);
sumaRok.merge(rok, Long.parseLong(czesci[1]), Long::sum);
}
String najlepszy = "";
long maks = -1;
for (var e : sumaRok.entrySet())
if (e.getValue() > maks) {
maks = e.getValue();
najlepszy = e.getKey();
}
System.out.println(najlepszy + " " + maks);
}
}Odpowiedź: 2015
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku woda.txt (data i dobowy dopływ wody w m³, lata 2008–2017).
Znajdź najdłuższy okres (w dniach), w którym każdego dnia dopływało co najmniej 10 000 m³ wody (jest dokładnie jeden taki okres). Podaj jego datę początkową i końcową.
with open("woda.txt") as file:
dane = [line.split() for line in file]
najdluzszy = 0
dlugosc = 0
poczatek = ""
for i in range(len(dane)):
data, doplyw = dane[i][0], int(dane[i][1])
if doplyw >= 10000:
if dlugosc == 0:
start = data
dlugosc += 1
if dlugosc > najdluzszy:
najdluzszy = dlugosc
poczatek = start
koniec = data
else:
dlugosc = 0
print(najdluzszy, poczatek, koniec)#include <fstream>
#include <print>
#include <string>
#include <utility>
#include <vector>
int main() {
std::ifstream plik("woda.txt");
std::vector<std::pair<std::string, int>> dane;
std::string data;
int doplyw;
while (plik >> data >> doplyw)
dane.push_back({data, doplyw});
int najdluzszy = 0;
int dlugosc = 0;
std::string poczatek = "", start, koniec;
for (const auto& [data, doplyw] : dane) {
if (doplyw >= 10000) {
if (dlugosc == 0)
start = data;
dlugosc++;
if (dlugosc > najdluzszy) {
najdluzszy = dlugosc;
poczatek = start;
koniec = data;
}
} else {
dlugosc = 0;
}
}
std::println("{} {} {}", najdluzszy, poczatek, koniec);
}import java.nio.file.Files;
import java.nio.file.Path;
public class Zadanie {
public static void main(String[] args) throws Exception {
var dane = Files.readAllLines(Path.of("woda.txt"));
int najdluzszy = 0;
int dlugosc = 0;
String poczatek = "", start = "", koniec = "";
for (String line : dane) {
String[] czesci = line.trim().split("\\s+");
String data = czesci[0];
int doplyw = Integer.parseInt(czesci[1]);
if (doplyw >= 10000) {
if (dlugosc == 0)
start = data;
dlugosc++;
if (dlugosc > najdluzszy) {
najdluzszy = dlugosc;
poczatek = start;
koniec = data;
}
} else {
dlugosc = 0;
}
}
System.out.println(najdluzszy + " " + poczatek + " " + koniec);
}
}Odpowiedź: od 2015-03-17 do 2015-05-10
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku woda.txt (data i dobowy dopływ wody w m³, lata 2008–2017).
Zestaw łączne dopływy wody w poszczególnych miesiącach 2008 roku (od stycznia do grudnia) i na tej podstawie wykonaj wykres kolumnowy z tytułem i opisami osi.
miesiace = {}
with open("woda.txt") as file:
for line in file:
data, doplyw = line.split()
if data.startswith("2008"):
miesiac = data[:7]
miesiace[miesiac] = miesiace.get(miesiac, 0) + int(doplyw)
for miesiac in sorted(miesiace):
print(miesiac, miesiace[miesiac])
# na podstawie zestawienia należy jeszcze wykonać wykres kolumnowy#include <fstream>
#include <map>
#include <print>
#include <string>
int main() {
std::map<std::string, long long> miesiace; // std::map trzyma klucze posortowane
std::ifstream plik("woda.txt");
std::string data;
long long doplyw;
while (plik >> data >> doplyw) {
if (data.starts_with("2008")) {
std::string miesiac = data.substr(0, 7);
miesiace[miesiac] += doplyw;
}
}
for (const auto& [miesiac, suma] : miesiace)
std::println("{} {}", miesiac, suma);
// na podstawie zestawienia należy jeszcze wykonać wykres kolumnowy
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.TreeMap;
public class Zadanie {
public static void main(String[] args) throws Exception {
var miesiace = new TreeMap<String, Long>(); // TreeMap trzyma klucze posortowane
for (String line : Files.readAllLines(Path.of("woda.txt"))) {
String[] czesci = line.trim().split("\\s+");
String data = czesci[0];
if (data.startsWith("2008")) {
String miesiac = data.substring(0, 7);
miesiace.merge(miesiac, Long.parseLong(czesci[1]), Long::sum);
}
}
for (var e : miesiace.entrySet())
System.out.println(e.getKey() + " " + e.getValue());
// na podstawie zestawienia należy jeszcze wykonać wykres kolumnowy
}
}Odpowiedź: 2008-01 95433, 2008-02 94730, 2008-03 109439, 2008-04 632931, 2008-05 329203, 2008-06 85628, 2008-07 166597, 2008-08 139747, 2008-09 282342, 2008-10 170729, 2008-11 222440, 2008-12 172072 (+ wykres kolumnowy)
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku woda.txt (data i dobowy dopływ wody w m³, lata 2008–2017). Cykl pracy zbiornika:
- Zaraz po północy mierzy się objętość wody w zbiorniku.
- Jeśli pomiar przekracza 1 000 000 m³ (przepełnienie), od razu wypuszcza się cały nadmiar ponad 1 000 000 m³.
- Codziennie o 8 rano wypuszcza się 2% objętości wykazanej przez nocny pomiar (zaokrąglone w górę do pełnych m³).
- W ciągu doby do zbiornika dopływa woda z rzeki zgodnie z danymi.
Pomiar 2008-01-01 wskazał 500 000 m³ (kontrolnie: pomiar 2008-02-01 wskazał 338 406 m³). Podaj:
- a) dzień, w którym pierwszy raz wypuszczono nadmiar wody po przepełnieniu,
- b) w ilu dniach okresu 2008-01-01 – 2017-12-31 pomiar wykazał co najmniej 800 000 m³,
- c) największą objętość wody w momencie pomiaru w tym okresie, gdyby zrezygnować z wypuszczania nadmiaru (zbiornik o nieograniczonej pojemności; 2% nadal wypuszczane).
import math
with open("woda.txt") as file:
dane = [line.split() for line in file]
def symulacja(z_wypuszczaniem):
woda = 500000
pierwsze_przepelnienie = None
dni_800 = 0
maks = 0
for data, doplyw in dane:
pomiar = woda # pomiar zaraz po północy
maks = max(maks, pomiar)
if pomiar >= 800000:
dni_800 += 1
if z_wypuszczaniem and woda > 1000000:
if pierwsze_przepelnienie is None:
pierwsze_przepelnienie = data
woda = 1000000
woda -= math.ceil(pomiar * 2 / 100) # o 8 rano wypuszczamy 2% wody z pomiaru
woda += int(doplyw)
return pierwsze_przepelnienie, dni_800, maks
a, b, _ = symulacja(True)
_, _, c = symulacja(False)
print("a)", a)
print("b)", b)
print("c)", c)#include <algorithm>
#include <cmath>
#include <fstream>
#include <print>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
std::vector<std::pair<std::string, long long>> dane;
// zwraca: datę pierwszego przepełnienia ("None", gdy go nie było), liczbę dni z >= 800 000 m3 i maksimum
std::tuple<std::string, int, long long> symulacja(bool z_wypuszczaniem) {
long long woda = 500000;
std::string pierwsze_przepelnienie = "None";
int dni_800 = 0;
long long maks = 0;
for (const auto& [data, doplyw] : dane) {
long long pomiar = woda; // pomiar zaraz po północy
maks = std::max(maks, pomiar);
if (pomiar >= 800000)
dni_800++;
if (z_wypuszczaniem && woda > 1000000) {
if (pierwsze_przepelnienie == "None")
pierwsze_przepelnienie = data;
woda = 1000000;
}
woda -= (long long)std::ceil(pomiar * 2 / 100.0); // o 8 rano wypuszczamy 2% wody z pomiaru
woda += doplyw;
}
return {pierwsze_przepelnienie, dni_800, maks};
}
int main() {
std::ifstream plik("woda.txt");
std::string data;
long long doplyw;
while (plik >> data >> doplyw)
dane.push_back({data, doplyw});
auto [a, b, _] = symulacja(true);
auto c = std::get<2>(symulacja(false));
std::println("a) {}", a);
std::println("b) {}", b);
std::println("c) {}", c);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
public class Zadanie {
static List<String[]> dane = new ArrayList<>();
// zwraca: datę pierwszego przepełnienia ("None", gdy go nie było), liczbę dni z >= 800 000 m3 i maksimum
static String[] symulacja(boolean zWypuszczaniem) {
long woda = 500000;
String pierwszePrzepelnienie = "None";
int dni800 = 0;
long maks = 0;
for (String[] wiersz : dane) {
String data = wiersz[0];
long doplyw = Long.parseLong(wiersz[1]);
long pomiar = woda; // pomiar zaraz po północy
maks = Math.max(maks, pomiar);
if (pomiar >= 800000)
dni800++;
if (zWypuszczaniem && woda > 1000000) {
if (pierwszePrzepelnienie.equals("None"))
pierwszePrzepelnienie = data;
woda = 1000000;
}
woda -= (long) Math.ceil(pomiar * 2 / 100.0); // o 8 rano wypuszczamy 2% wody z pomiaru
woda += doplyw;
}
return new String[]{pierwszePrzepelnienie, String.valueOf(dni800), String.valueOf(maks)};
}
public static void main(String[] args) throws Exception {
for (String line : Files.readAllLines(Path.of("woda.txt")))
dane.add(line.trim().split("\\s+"));
String[] z = symulacja(true);
String[] bez = symulacja(false);
System.out.println("a) " + z[0]);
System.out.println("b) " + z[1]);
System.out.println("c) " + bez[2]);
}
}Odpowiedź: a) 2015-04-19, b) 188 dni, c) 1 399 242 m3
↑