Matura 2019 — maj, poziom rozszerzony
ARKUSZ CZ. IARKUSZ CZ. IIDANEODPOWIEDZI
Treść zadania
Zadanie 1 (ulubione liczby). Małgosia lubi liczby nieparzyste, a Jaś parzyste. Na wspólnej kartce najpierw Małgosia zapisała kilka swoich liczb, a potem Jaś dopisał swoje (każde co najmniej jedną). Dane: n > 1 i tablica A[1..n] — najpierw same liczby nieparzyste, potem same parzyste. Wynik: w — pierwsza od lewej liczba parzysta w A.
Przykład: dla A = 5, 99, 3, 7, 111, 13, 4, 24, 4, 8 (n = 10) wynikiem jest w = 4.
- 1.1 — napisz algorytm znajdujący pierwszą liczbę zapisaną przez Jasia. Maksymalną liczbę punktów daje algorytm o złożoności lepszej niż liniowa. Wolno używać tylko operacji arytmetycznych (w tym div i mod), porównań, instrukcji sterujących, przypisań i własnych funkcji.
- 1.2 — podaj złożoność czasową swojego algorytmu (kwadratowa, liniowa, logarytmiczna lub inna).
def pierwsza_parzysta(A):
# wyszukiwanie binarne - złożoność logarytmiczna
p = 0
k = len(A) - 1
while p < k:
s = (p + k) // 2
if A[s] % 2 == 1:
p = s + 1
else:
k = s
return A[p]
A = [5, 99, 3, 7, 111, 13, 4, 24, 4, 8]
print(pierwsza_parzysta(A))#include <print>
#include <vector>
int pierwsza_parzysta(const std::vector<int>& A) {
// wyszukiwanie binarne - złożoność logarytmiczna
int p = 0;
int k = A.size() - 1;
while (p < k) {
int s = (p + k) / 2;
if (A[s] % 2 == 1)
p = s + 1;
else
k = s;
}
return A[p];
}
int main() {
std::vector<int> A = {5, 99, 3, 7, 111, 13, 4, 24, 4, 8};
std::println("{}", pierwsza_parzysta(A));
}public class Zadanie {
static int pierwszaParzysta(int[] A) {
// wyszukiwanie binarne - złożoność logarytmiczna
int p = 0;
int k = A.length - 1;
while (p < k) {
int s = (p + k) / 2;
if (A[s] % 2 == 1)
p = s + 1;
else
k = s;
}
return A[p];
}
public static void main(String[] args) throws Exception {
int[] A = {5, 99, 3, 7, 111, 13, 4, 24, 4, 8};
System.out.println(pierwszaParzysta(A));
}
}Odpowiedź: dla przykładu w = 4; złożoność logarytmiczna (wyszukiwanie binarne)
↑Treść zadania
Zadanie 2 (analiza algorytmu). Dane: napis s, liczba całkowita n nie mniejsza niż długość s oraz k z zakresu [2..10]. dł(x) to długość napisu, + łączy napisy, napis(p) to zapis dziesiętny liczby p.
funkcja pisz(s, n, k)
jeżeli dł(s) = n
wypisz s
w przeciwnym razie
dla i = 0, 1, …, k-1 wykonuj
pisz(s + napis(i), n, k)- 2.1 — uzupełnij drzewo wywołań funkcji dla
pisz("", 2, 2)(korzeń ma dziecipisz("0",2,2)ipisz("1",2,2)) i ponumeruj węzły w kolejności wywołań (pierwsze wywołanie ma numer 1). - 2.2 — dla wywołań
pisz("", 3, 2)ipisz("", 2, 3)podaj wypisane napisy oraz łączną liczbę wywołań funkcji. - 2.3 — podaj wzór na łączną liczbę wywołań funkcji
piszpo wywołaniupisz("", n, k).
wywolania = 0
def pisz(s, n, k):
global wywolania
wywolania += 1
if len(s) == n:
print(s)
else:
for i in range(k):
pisz(s + str(i), n, k)
for n, k in [(2, 2), (3, 2), (2, 3)]:
wywolania = 0
print(f'pisz("", {n}, {k}):')
pisz("", n, k)
# 2.3 - wzór: 1 + k + k^2 + ... + k^n = (k^(n+1) - 1) / (k - 1)
print("liczba wywołań:", wywolania, "wzór:", (k ** (n + 1) - 1) // (k - 1))#include <print>
#include <string>
#include <utility>
int wywolania = 0;
void pisz(const std::string& s, int n, int k) {
wywolania++;
if ((int)s.size() == n)
std::println("{}", s);
else
for (int i = 0; i < k; i++)
pisz(s + std::to_string(i), n, k);
}
int main() {
for (auto [n, k] : {std::pair{2, 2}, std::pair{3, 2}, std::pair{2, 3}}) {
wywolania = 0;
std::println("pisz(\"\", {}, {}):", n, k);
pisz("", n, k);
// 2.3 - wzór: 1 + k + k^2 + ... + k^n = (k^(n+1) - 1) / (k - 1)
long long potega = 1;
for (int i = 0; i < n + 1; i++)
potega *= k;
std::println("liczba wywołań: {} wzór: {}", wywolania, (potega - 1) / (k - 1));
}
}public class Zadanie {
static int wywolania = 0;
static void pisz(String s, int n, int k) {
wywolania++;
if (s.length() == n)
System.out.println(s);
else
for (int i = 0; i < k; i++)
pisz(s + i, n, k);
}
public static void main(String[] args) throws Exception {
int[][] pary = {{2, 2}, {3, 2}, {2, 3}};
for (int[] para : pary) {
int n = para[0], k = para[1];
wywolania = 0;
System.out.println("pisz(\"\", " + n + ", " + k + "):");
pisz("", n, k);
// 2.3 - wzór: 1 + k + k^2 + ... + k^n = (k^(n+1) - 1) / (k - 1)
long potega = 1;
for (int i = 0; i < n + 1; i++)
potega *= k;
System.out.println("liczba wywołań: " + wywolania + " wzór: " + (potega - 1) / (k - 1));
}
}
}Odpowiedź: 2.1: pisz("10",2,2), pisz("11",2,2) (kolejność wywołań 1, 2, 3, 4, 5, 6, 7 – w głąb); 2.2: pisz("",3,2) wypisuje 000 001 010 011 100 101 110 111, 15 wywołań; pisz("",2,3) wypisuje 00 01 02 10 11 12 20 21 22, 13 wywołań; 2.3: (k^(n+1) − 1)/(k − 1)
↑Treść zadania
Zadanie 4 (liczby). Plik liczby.txt zawiera 500 liczb całkowitych z zakresu [1, 100 000], po jednej w wierszu. Odpowiedzi zapisz w pliku wyniki4.txt, poprzedzając je numerem zadania (dane przykładowe: przyklad.txt).
Podaj, ile liczb z pliku jest potęgami liczby 3 (1, 3, 9, 27, …).
Dla pliku przykładowego odpowiedź wynosi 2.
potegi_trojki = []
potega = 1
while potega <= 100000:
potegi_trojki.append(potega)
potega *= 3
ile = 0
with open("liczby.txt") as file:
for line in file:
if int(line) in potegi_trojki:
ile += 1
print(ile)#include <algorithm>
#include <fstream>
#include <print>
#include <vector>
int main() {
std::vector<long long> potegi_trojki;
long long potega = 1;
while (potega <= 100000) {
potegi_trojki.push_back(potega);
potega *= 3;
}
int ile = 0;
std::ifstream plik("liczby.txt");
long long liczba;
while (plik >> liczba)
if (std::ranges::find(potegi_trojki, liczba) != potegi_trojki.end())
ile++;
std::println("{}", ile);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
public class Zadanie {
public static void main(String[] args) throws Exception {
var potegiTrojki = new ArrayList<Long>();
long potega = 1;
while (potega <= 100000) {
potegiTrojki.add(potega);
potega *= 3;
}
int ile = 0;
for (String line : Files.readAllLines(Path.of("liczby.txt")))
if (!line.isBlank() && potegiTrojki.contains(Long.parseLong(line.trim())))
ile++;
System.out.println(ile);
}
}Odpowiedź: 18
↑Treść zadania
Dane z pliku liczby.txt (500 liczb z zakresu [1, 100 000]).
Silnia: k! = 1·2·…·k, przy czym 0! = 1. Dla liczby można obliczyć sumę silni jej cyfr, np. dla 343: 3! + 4! + 3! = 36. Wypisz, w kolejności z pliku, wszystkie liczby równe sumie silni swoich cyfr.
W pliku przykładowym jest jedna taka liczba: 145 (1! + 4! + 5! = 145).
from math import factorial
with open("liczby.txt") as file:
for line in file:
liczba = line.strip()
suma = 0
for cyfra in liczba:
suma += factorial(int(cyfra))
if suma == int(liczba):
print(liczba)#include <fstream>
#include <print>
#include <string>
long long silnia(int n) {
long long wynik = 1;
for (int i = 2; i <= n; i++)
wynik *= i;
return wynik;
}
int main() {
std::ifstream plik("liczby.txt");
std::string liczba;
while (plik >> liczba) {
long long suma = 0;
for (char cyfra : liczba)
suma += silnia(cyfra - '0');
if (suma == std::stoll(liczba))
std::println("{}", liczba);
}
}import java.nio.file.Files;
import java.nio.file.Path;
public class Zadanie {
static long silnia(int n) {
long wynik = 1;
for (int i = 2; i <= n; i++)
wynik *= i;
return wynik;
}
public static void main(String[] args) throws Exception {
for (String line : Files.readAllLines(Path.of("liczby.txt"))) {
if (line.isBlank())
continue;
String liczba = line.strip();
long suma = 0;
for (char cyfra : liczba.toCharArray())
suma += silnia(cyfra - '0');
if (suma == Long.parseLong(liczba))
System.out.println(liczba);
}
}
}Odpowiedź: 145, 1, 40585, 2
↑Treść zadania
Dane z pliku liczby.txt (500 liczb z zakresu [1, 100 000]).
Znajdź najdłuższy spójny fragment ciągu liczb, których największy wspólny dzielnik jest większy od 1 (jest dokładnie jeden taki fragment). Podaj pierwszą liczbę fragmentu, jego długość i NWD wszystkich jego liczb. Można korzystać z NWD(a, b, c) = NWD(NWD(a, b), c).
Przykłady: dla 3, 7, 4, 6, 10, 2, 5 odpowiedź to 4, 4, 2; dla 5, 70, 28, 42, 98, 1 — 70, 4, 14. Dla pliku przykładowego: 90, 5, 10.
from math import gcd
with open("liczby.txt") as file:
liczby = [int(line) for line in file]
najdluzszy = 0
for i in range(len(liczby)):
nwd = liczby[i]
j = i
# rozszerzamy ciąg zaczynający się od i, dopóki NWD wszystkich liczb jest większy od 1
while j + 1 < len(liczby) and gcd(nwd, liczby[j + 1]) > 1:
j += 1
nwd = gcd(nwd, liczby[j])
if j - i + 1 > najdluzszy:
najdluzszy = j - i + 1
pierwsza = liczby[i]
dzielnik = nwd
print(pierwsza, najdluzszy, dzielnik)#include <fstream>
#include <numeric>
#include <print>
#include <vector>
int main() {
std::ifstream plik("liczby.txt");
std::vector<long long> liczby;
long long x;
while (plik >> x)
liczby.push_back(x);
int n = liczby.size();
int najdluzszy = 0;
long long pierwsza = 0, dzielnik = 0;
for (int i = 0; i < n; i++) {
long long nwd = liczby[i];
int j = i;
// rozszerzamy ciąg zaczynający się od i, dopóki NWD wszystkich liczb jest większy od 1
while (j + 1 < n && std::gcd(nwd, liczby[j + 1]) > 1) {
j++;
nwd = std::gcd(nwd, liczby[j]);
}
if (j - i + 1 > najdluzszy) {
najdluzszy = j - i + 1;
pierwsza = liczby[i];
dzielnik = nwd;
}
}
std::println("{} {} {}", pierwsza, najdluzszy, dzielnik);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
public class Zadanie {
static long gcd(long a, long b) {
while (b != 0) {
long r = a % b;
a = b;
b = r;
}
return a;
}
public static void main(String[] args) throws Exception {
var liczby = new ArrayList<Long>();
for (String line : Files.readAllLines(Path.of("liczby.txt")))
if (!line.isBlank())
liczby.add(Long.parseLong(line.trim()));
int n = liczby.size();
int najdluzszy = 0;
long pierwsza = 0, dzielnik = 0;
for (int i = 0; i < n; i++) {
long nwd = liczby.get(i);
int j = i;
// rozszerzamy ciąg zaczynający się od i, dopóki NWD wszystkich liczb jest większy od 1
while (j + 1 < n && gcd(nwd, liczby.get(j + 1)) > 1) {
j++;
nwd = gcd(nwd, liczby.get(j));
}
if (j - i + 1 > najdluzszy) {
najdluzszy = j - i + 1;
pierwsza = liczby.get(i);
dzielnik = nwd;
}
}
System.out.println(pierwsza + " " + najdluzszy + " " + dzielnik);
}
}Odpowiedź: pierwsza liczba 31968, długość ciągu 150, dzielnik 74
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Zadanie 5 (chmury). Plik pogoda.txt zawiera dane z 500 kolejnych dni pomiarów na odległej planecie, rozdzielone średnikami, z wierszem nagłówkowym: numer dnia (1–500), temperatura (z jednym miejscem po przecinku, nieujemna), opad w mm (całkowity), kategoria chmur (C — cirrusy, S — stratusy, 0 — brak chmur) i wielkość chmur (1–5, 0 gdy bezchmurnie). Każdego dnia występuje tylko jeden rodzaj chmur. Od dnia 301 kamera była zepsuta i wszystkie dni raportowano jako bezchmurne (temperatura i opad są nadal poprawne). Odpowiedzi zapisz w pliku wyniki5.txt, poprzedzając je numerem zadania.
Podaj liczbę dni z temperaturą co najmniej 20 stopni i jednocześnie opadem nie większym niż 5 mm.
ile = 0
with open("pogoda.txt") as file:
file.readline() # nagłówek
for line in file:
dzien, temperatura, opad, kategoria, wielkosc = line.strip().split(";")
temperatura = float(temperatura.replace(",", "."))
if temperatura >= 20 and int(opad) <= 5:
ile += 1
print(ile)#include <algorithm>
#include <fstream>
#include <print>
#include <sstream>
#include <string>
#include <vector>
// dzieli wiersz po średnikach
std::vector<std::string> podziel(const std::string& wiersz) {
std::vector<std::string> czesci;
std::stringstream ss(wiersz);
std::string czesc;
while (std::getline(ss, czesc, ';'))
czesci.push_back(czesc);
return czesci;
}
// liczba z przecinkiem dziesiętnym, np. "12,5" -> 12.5
double na_liczbe(std::string tekst) {
std::ranges::replace(tekst, ',', '.');
return std::stod(tekst);
}
int main() {
int ile = 0;
std::ifstream plik("pogoda.txt");
std::string linia;
std::getline(plik, linia); // nagłówek
while (std::getline(plik, linia)) {
if (!linia.empty() && linia.back() == '\r')
linia.pop_back();
if (linia.empty())
continue;
auto czesci = podziel(linia); // dzien, temperatura, opad, kategoria, wielkosc
double temperatura = na_liczbe(czesci[1]);
if (temperatura >= 20 && std::stoi(czesci[2]) <= 5)
ile++;
}
std::println("{}", ile);
}import java.nio.file.Files;
import java.nio.file.Path;
public class Zadanie {
public static void main(String[] args) throws Exception {
int ile = 0;
var linie = Files.readAllLines(Path.of("pogoda.txt"));
for (String line : linie.subList(1, linie.size())) { // pomijamy nagłówek
if (line.isBlank())
continue;
String[] czesci = line.strip().split(";"); // dzien, temperatura, opad, kategoria, wielkosc
double temperatura = Double.parseDouble(czesci[1].replace(",", "."));
if (temperatura >= 20 && Integer.parseInt(czesci[2]) <= 5)
ile++;
}
System.out.println(ile);
}
}Odpowiedź: 63
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku pogoda.txt (500 dni: temperatura, opad, kategoria i wielkość chmur).
Znajdź najdłuższy ciąg kolejnych dni, w którym temperatura każdego dnia jest wyższa niż dnia poprzedniego (jest jeden taki ciąg). Podaj numer pierwszego i ostatniego dnia ciągu.
Przykład: dla temperatur dni 34–39: 3,7; 3,4; 3,5; 3,6; 3,7; 3,5 ciąg zaczyna się w dniu 36 i kończy w dniu 38.
with open("pogoda.txt") as file:
file.readline()
temperatury = []
for line in file:
temperatury.append(float(line.split(";")[1].replace(",", ".")))
najdluzszy = 0
dlugosc = 0 # liczba kolejnych dni cieplejszych od dnia poprzedniego
for i in range(1, len(temperatury)):
if temperatury[i] > temperatury[i - 1]:
dlugosc += 1
else:
dlugosc = 0
if dlugosc > najdluzszy:
najdluzszy = dlugosc
koniec = i + 1 # dni numerujemy od 1
print(koniec - najdluzszy + 1, koniec)#include <algorithm>
#include <fstream>
#include <print>
#include <string>
#include <vector>
// liczba z przecinkiem dziesiętnym, np. "12,5" -> 12.5
double na_liczbe(std::string tekst) {
std::ranges::replace(tekst, ',', '.');
return std::stod(tekst);
}
int main() {
std::ifstream plik("pogoda.txt");
std::string linia;
std::getline(plik, linia); // nagłówek
std::vector<double> temperatury;
while (std::getline(plik, linia)) {
if (linia.empty() || linia == "\r")
continue;
// temperatura jest między pierwszym a drugim średnikiem
size_t a = linia.find(';'), b = linia.find(';', a + 1);
temperatury.push_back(na_liczbe(linia.substr(a + 1, b - a - 1)));
}
int najdluzszy = 0;
int dlugosc = 0; // liczba kolejnych dni cieplejszych od dnia poprzedniego
int koniec = 0;
for (size_t i = 1; i < temperatury.size(); i++) {
if (temperatury[i] > temperatury[i - 1])
dlugosc++;
else
dlugosc = 0;
if (dlugosc > najdluzszy) {
najdluzszy = dlugosc;
koniec = i + 1; // dni numerujemy od 1
}
}
std::println("{} {}", koniec - najdluzszy + 1, koniec);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
public class Zadanie {
public static void main(String[] args) throws Exception {
var linie = Files.readAllLines(Path.of("pogoda.txt"));
var temperatury = new ArrayList<Double>();
for (String line : linie.subList(1, linie.size())) // pomijamy nagłówek
if (!line.isBlank())
temperatury.add(Double.parseDouble(line.split(";")[1].replace(",", ".")));
int najdluzszy = 0;
int dlugosc = 0; // liczba kolejnych dni cieplejszych od dnia poprzedniego
int koniec = 0;
for (int i = 1; i < temperatury.size(); i++) {
if (temperatury.get(i) > temperatury.get(i - 1))
dlugosc++;
else
dlugosc = 0;
if (dlugosc > najdluzszy) {
najdluzszy = dlugosc;
koniec = i + 1; // dni numerujemy od 1
}
}
System.out.println((koniec - najdluzszy + 1) + " " + koniec);
}
}Odpowiedź: od dnia 448 do dnia 455
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku pogoda.txt (500 dni: temperatura, opad, kategoria i wielkość chmur).
Dla pierwszych 300 dni oblicz z dokładnością do dwóch miejsc po przecinku średni opad dla każdego rodzaju chmur (C1–C5, S1–S5) i przedstaw wyniki na czytelnie opisanym wykresie kolumnowym.
suma = {}
ile = {}
with open("pogoda.txt") as file:
file.readline()
for line in file:
dzien, temperatura, opad, kategoria, wielkosc = line.strip().split(";")
if int(dzien) <= 300 and kategoria != "0":
rodzaj = kategoria + wielkosc
suma[rodzaj] = suma.get(rodzaj, 0) + int(opad)
ile[rodzaj] = ile.get(rodzaj, 0) + 1
for rodzaj in sorted(suma):
print(rodzaj, round(suma[rodzaj] / ile[rodzaj], 2))
# na podstawie zestawienia należy jeszcze wykonać wykres kolumnowy#include <format>
#include <fstream>
#include <map>
#include <print>
#include <sstream>
#include <string>
#include <vector>
// dzieli wiersz po średnikach
std::vector<std::string> podziel(const std::string& wiersz) {
std::vector<std::string> czesci;
std::stringstream ss(wiersz);
std::string czesc;
while (std::getline(ss, czesc, ';'))
czesci.push_back(czesc);
return czesci;
}
// round(x, 2) z Pythona: zaokrąglenie do 2 miejsc po przecinku
double zaokraglij(double x) {
return std::stod(std::format("{:.2f}", x));
}
// liczba rzeczywista wypisana jak w Pythonie (np. 15.0 zamiast 15)
std::string jak_python(double x) {
std::string s = std::format("{}", x);
if (s.find_first_of(".en") == std::string::npos)
s += ".0";
return s;
}
int main() {
std::map<std::string, long long> suma; // std::map trzyma klucze posortowane
std::map<std::string, long long> ile;
std::ifstream plik("pogoda.txt");
std::string linia;
std::getline(plik, linia); // nagłówek
while (std::getline(plik, linia)) {
if (!linia.empty() && linia.back() == '\r')
linia.pop_back();
if (linia.empty())
continue;
auto czesci = podziel(linia); // dzien, temperatura, opad, kategoria, wielkosc
std::string kategoria = czesci[3], wielkosc = czesci[4];
if (std::stoi(czesci[0]) <= 300 && kategoria != "0") {
std::string rodzaj = kategoria + wielkosc;
suma[rodzaj] += std::stoi(czesci[2]);
ile[rodzaj]++;
}
}
for (const auto& [rodzaj, s] : suma)
std::println("{} {}", rodzaj, jak_python(zaokraglij((double)s / ile[rodzaj])));
// na podstawie zestawienia należy jeszcze wykonać wykres kolumnowy
}import java.math.BigDecimal;
import java.math.RoundingMode;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.TreeMap;
public class Zadanie {
// round(x, 2) z Pythona: zaokrąglenie do 2 miejsc po przecinku
static double zaokraglij(double x) {
return new BigDecimal(x).setScale(2, RoundingMode.HALF_EVEN).doubleValue();
}
public static void main(String[] args) throws Exception {
var suma = new TreeMap<String, Long>(); // TreeMap trzyma klucze posortowane
var ile = new TreeMap<String, Long>();
var linie = Files.readAllLines(Path.of("pogoda.txt"));
for (String line : linie.subList(1, linie.size())) { // pomijamy nagłówek
if (line.isBlank())
continue;
String[] czesci = line.strip().split(";"); // dzien, temperatura, opad, kategoria, wielkosc
String kategoria = czesci[3], wielkosc = czesci[4];
if (Integer.parseInt(czesci[0]) <= 300 && !kategoria.equals("0")) {
String rodzaj = kategoria + wielkosc;
suma.merge(rodzaj, Long.parseLong(czesci[2]), Long::sum);
ile.merge(rodzaj, 1L, Long::sum);
}
}
for (var e : suma.entrySet())
System.out.println(e.getKey() + " " + zaokraglij((double) e.getValue() / ile.get(e.getKey())));
// na podstawie zestawienia należy jeszcze wykonać wykres kolumnowy
}
}Odpowiedź: C1 3,45; C2 7,28; C3 9,05; C4 11,58; C5 19,40; S1 3,73; S2 6,52; S3 10,29; S4 15,00; S5 19,64 (+ wykres kolumnowy)
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Dane z pliku pogoda.txt (500 dni). Teoria prof. Nubisa:
- po dniu bezchmurnym następnego dnia pojawiają się chmury wielkości 1;
- chmury po trzech dniach przechodzą w wielkość o 1 większą (najwyżej do 5);
- chmury wielkości 5 znikają, gdy danego dnia spadnie co najmniej 20 mm deszczu — następny dzień jest wtedy bezchmurny;
- kategoria powstających chmur zależy od temperatury w dniu ich pojawienia się: co najmniej 10 stopni —
C, w przeciwnym razie —S.
Przyjmij, że chmury przez wszystkie 500 dni rozwijają się według teorii, a dzień 1 jest bezchmurny (przez pierwsze 20 dni teoria zgadza się z obserwacjami). Podaj:
- a) liczbę dni z chmurami wielkości 0, 1, 2, 3, 4 i 5 (osobno dla każdej wielkości; opady jak w pliku),
- b) w ilu z pierwszych 300 dni wielkość chmur według teorii zgadza się z odczytem kamery,
- c) w ilu z pierwszych 300 dni kategoria chmur według teorii zgadza się z odczytem kamery.
with open("pogoda.txt") as file:
file.readline()
dane = [line.strip().split(";") for line in file]
wielkosc = 0 # dzień pierwszy jest bezchmurny
kategoria = "0"
dni_tej_wielkosci = 1
ile_wielkosci = [0] * 6
zgodne_wielkosci = 0
zgodne_kategorie = 0
for i in range(len(dane)):
dzien, temperatura, opad, kat_kamera, wlk_kamera = dane[i]
temperatura = float(temperatura.replace(",", "."))
if i > 0:
poprzedni_opad = int(dane[i - 1][2])
if wielkosc == 0:
# pojawiają się chmury wielkości 1, kategoria zależy od temperatury w dniu ich powstania
wielkosc = 1
kategoria = "C" if temperatura >= 10 else "S"
dni_tej_wielkosci = 1
elif wielkosc == 5:
if poprzedni_opad >= 20:
wielkosc = 0
kategoria = "0"
elif dni_tej_wielkosci == 3:
wielkosc += 1
dni_tej_wielkosci = 1
else:
dni_tej_wielkosci += 1
ile_wielkosci[wielkosc] += 1
if int(dzien) <= 300:
if int(wlk_kamera) == wielkosc:
zgodne_wielkosci += 1
if kat_kamera == kategoria:
zgodne_kategorie += 1
print("a)")
for w in range(6):
print(w, ile_wielkosci[w])
print("b)", zgodne_wielkosci)
print("c)", zgodne_kategorie)#include <algorithm>
#include <fstream>
#include <print>
#include <sstream>
#include <string>
#include <vector>
// dzieli wiersz po średnikach
std::vector<std::string> podziel(const std::string& wiersz) {
std::vector<std::string> czesci;
std::stringstream ss(wiersz);
std::string czesc;
while (std::getline(ss, czesc, ';'))
czesci.push_back(czesc);
return czesci;
}
// liczba z przecinkiem dziesiętnym, np. "12,5" -> 12.5
double na_liczbe(std::string tekst) {
std::ranges::replace(tekst, ',', '.');
return std::stod(tekst);
}
int main() {
std::ifstream plik("pogoda.txt");
std::string linia;
std::getline(plik, linia); // nagłówek
std::vector<std::vector<std::string>> dane;
while (std::getline(plik, linia)) {
if (!linia.empty() && linia.back() == '\r')
linia.pop_back();
if (!linia.empty())
dane.push_back(podziel(linia));
}
int wielkosc = 0; // dzień pierwszy jest bezchmurny
std::string kategoria = "0";
int dni_tej_wielkosci = 1;
std::vector<int> ile_wielkosci(6, 0);
int zgodne_wielkosci = 0;
int zgodne_kategorie = 0;
for (size_t i = 0; i < dane.size(); i++) {
int dzien = std::stoi(dane[i][0]);
double temperatura = na_liczbe(dane[i][1]);
std::string kat_kamera = dane[i][3];
int wlk_kamera = std::stoi(dane[i][4]);
if (i > 0) {
int poprzedni_opad = std::stoi(dane[i - 1][2]);
if (wielkosc == 0) {
// pojawiają się chmury wielkości 1, kategoria zależy od temperatury w dniu ich powstania
wielkosc = 1;
kategoria = temperatura >= 10 ? "C" : "S";
dni_tej_wielkosci = 1;
} else if (wielkosc == 5) {
if (poprzedni_opad >= 20) {
wielkosc = 0;
kategoria = "0";
}
} else if (dni_tej_wielkosci == 3) {
wielkosc++;
dni_tej_wielkosci = 1;
} else {
dni_tej_wielkosci++;
}
}
ile_wielkosci[wielkosc]++;
if (dzien <= 300) {
if (wlk_kamera == wielkosc)
zgodne_wielkosci++;
if (kat_kamera == kategoria)
zgodne_kategorie++;
}
}
std::println("a)");
for (int w = 0; w < 6; w++)
std::println("{} {}", w, ile_wielkosci[w]);
std::println("b) {}", zgodne_wielkosci);
std::println("c) {}", zgodne_kategorie);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
public class Zadanie {
public static void main(String[] args) throws Exception {
var linie = Files.readAllLines(Path.of("pogoda.txt"));
var dane = new ArrayList<String[]>();
for (String line : linie.subList(1, linie.size())) // pomijamy nagłówek
if (!line.isBlank())
dane.add(line.strip().split(";"));
int wielkosc = 0; // dzień pierwszy jest bezchmurny
String kategoria = "0";
int dniTejWielkosci = 1;
int[] ileWielkosci = new int[6];
int zgodneWielkosci = 0;
int zgodneKategorie = 0;
for (int i = 0; i < dane.size(); i++) {
String[] d = dane.get(i);
int dzien = Integer.parseInt(d[0]);
double temperatura = Double.parseDouble(d[1].replace(",", "."));
String katKamera = d[3];
int wlkKamera = Integer.parseInt(d[4]);
if (i > 0) {
int poprzedniOpad = Integer.parseInt(dane.get(i - 1)[2]);
if (wielkosc == 0) {
// pojawiają się chmury wielkości 1, kategoria zależy od temperatury w dniu ich powstania
wielkosc = 1;
kategoria = temperatura >= 10 ? "C" : "S";
dniTejWielkosci = 1;
} else if (wielkosc == 5) {
if (poprzedniOpad >= 20) {
wielkosc = 0;
kategoria = "0";
}
} else if (dniTejWielkosci == 3) {
wielkosc++;
dniTejWielkosci = 1;
} else {
dniTejWielkosci++;
}
}
ileWielkosci[wielkosc]++;
if (dzien <= 300) {
if (wlkKamera == wielkosc)
zgodneWielkosci++;
if (katKamera.equals(kategoria))
zgodneKategorie++;
}
}
System.out.println("a)");
for (int w = 0; w < 6; w++)
System.out.println(w + " " + ileWielkosci[w]);
System.out.println("b) " + zgodneWielkosci);
System.out.println("c) " + zgodneKategorie);
}
}Odpowiedź: a) 0: 34, 1: 102, 2: 102, 3: 102, 4: 100, 5: 60; b) 296; c) 286
↑