Matura 2017 — maj, poziom rozszerzony
ARKUSZ CZ. IARKUSZ CZ. IIDANEODPOWIEDZI
Treść zadania
Zadanie 1. Prostokąt. Dane są: liczba całkowita n > 1, zbiór A zawierający n różnych dodatnich liczb całkowitych oraz liczba pierwsza p. Szukamy największego pola prostokąta, którego sąsiednie boki mają różne długości należące do A (prostokąt nie może być kwadratem), a pole nie jest podzielne przez p. Jeśli takiego prostokąta nie ma, wynikiem jest 0.
- 1.1 — Oblicz to pole dla danych:
A = {7, 5, 11, 33}, p = 3(odpowiedź: 77);A = {15, 12, 10, 6, 5, 1}, p = 5;A = {6, 28, 7, 12, 10, 14, 5, 9, 4, 8, 18}, p = 7;A = {4, 34, 16, 8, 6, 22, 14, 12, 2, 7}, p = 2. - 1.2 — Zapisz algorytm, który dla
n, tablicyA[1..n]ipoblicza szukane poleS(lub 0). Liczy się złożoność obliczeniowa; wolno używać tylko dodawania, odejmowania, mnożenia, dzielenia całkowitego i reszty z dzielenia.
def najwieksze_pole(A, p):
# pole a*b nie dzieli się przez liczbę pierwszą p <=> ani a, ani b nie dzieli się przez p,
# więc wystarczy znaleźć dwie największe (różne) liczby z A niepodzielne przez p
max1 = max2 = 0
for a in A:
if a % p != 0:
if a > max1:
max2 = max1
max1 = a
elif a > max2:
max2 = a
return max1 * max2 # 0, gdy nie ma dwóch takich liczb
# 1.1
print(najwieksze_pole([15, 12, 10, 6, 5, 1], 5))
print(najwieksze_pole([6, 28, 7, 12, 10, 14, 5, 9, 4, 8, 18], 7))
print(najwieksze_pole([4, 34, 16, 8, 6, 22, 14, 12, 2, 7], 2))#include <print>
#include <vector>
long long najwieksze_pole(const std::vector<int>& A, int p) {
// pole a*b nie dzieli się przez liczbę pierwszą p <=> ani a, ani b nie dzieli się przez p,
// więc wystarczy znaleźć dwie największe (różne) liczby z A niepodzielne przez p
long long max1 = 0, max2 = 0;
for (int a : A) {
if (a % p != 0) {
if (a > max1) {
max2 = max1;
max1 = a;
} else if (a > max2) {
max2 = a;
}
}
}
return max1 * max2; // 0, gdy nie ma dwóch takich liczb
}
int main() {
// 1.1
std::println("{}", najwieksze_pole({15, 12, 10, 6, 5, 1}, 5));
std::println("{}", najwieksze_pole({6, 28, 7, 12, 10, 14, 5, 9, 4, 8, 18}, 7));
std::println("{}", najwieksze_pole({4, 34, 16, 8, 6, 22, 14, 12, 2, 7}, 2));
}public class Zadanie {
static long najwiekszePole(int[] A, int p) {
// pole a*b nie dzieli się przez liczbę pierwszą p <=> ani a, ani b nie dzieli się przez p,
// więc wystarczy znaleźć dwie największe (różne) liczby z A niepodzielne przez p
long max1 = 0, max2 = 0;
for (int a : A) {
if (a % p != 0) {
if (a > max1) {
max2 = max1;
max1 = a;
} else if (a > max2) {
max2 = a;
}
}
}
return max1 * max2; // 0, gdy nie ma dwóch takich liczb
}
public static void main(String[] args) {
// 1.1
System.out.println(najwiekszePole(new int[]{15, 12, 10, 6, 5, 1}, 5));
System.out.println(najwiekszePole(new int[]{6, 28, 7, 12, 10, 14, 5, 9, 4, 8, 18}, 7));
System.out.println(najwiekszePole(new int[]{4, 34, 16, 8, 6, 22, 14, 12, 2, 7}, 2));
}
}Odpowiedź: 1.1: 72 (12 · 6), 216 (18 · 12), 0. 1.2: algorytm liniowy jak w funkcji najwieksze_pole.
Treść zadania
Zadanie 2. Rekurencja. Funkcja licz(x) dla dodatniej liczby całkowitej x:
licz(x):
jeżeli x = 1: wynik 1
w przeciwnym przypadku
w ← licz(x div 2)
jeżeli x mod 2 = 1: wynik w+1
w przeciwnym przypadku: wynik w−1- 2.1 — Podaj
licz(x)dlax= 13, 21, 32 (dlax=11wynik to 2). - 2.2 — Jaka jest najmniejsza dodatnia liczba
x, dla której obliczenielicz(x)wymaga dokładniekwywołań funkcji (licząc pierwsze)? Wybierz: A)k², B)2^(k−1), C)k+1, D)2^k. (Np.licz(13)wymaga 4 wywołań.) - 2.3 — Podaj najmniejszą liczbę całkowitą
x > 100, dla którejlicz(x) = 0.
wywolania = 0
def licz(x):
global wywolania
wywolania += 1
if x == 1:
return 1
w = licz(x // 2)
if x % 2 == 1:
return w + 1
return w - 1
# 2.1
for x in [11, 13, 21, 32]:
print(x, licz(x))
# 2.2 - najmniejsze x wymagające dokładnie k wywołań
for k in range(1, 8):
x = 1
while True:
wywolania = 0
licz(x)
if wywolania == k:
break
x += 1
print(k, x, 2 ** (k - 1))
# 2.3
x = 101
while licz(x) != 0:
x += 1
print(x)#include <print>
int wywolania = 0;
int licz(int x) {
wywolania++;
if (x == 1)
return 1;
int w = licz(x / 2);
if (x % 2 == 1)
return w + 1;
return w - 1;
}
int main() {
// 2.1
for (int x : {11, 13, 21, 32})
std::println("{} {}", x, licz(x));
// 2.2 - najmniejsze x wymagające dokładnie k wywołań
for (int k = 1; k < 8; k++) {
int x = 1;
while (true) {
wywolania = 0;
licz(x);
if (wywolania == k)
break;
x++;
}
std::println("{} {} {}", k, x, 1 << (k - 1));
}
// 2.3
int x = 101;
while (licz(x) != 0)
x++;
std::println("{}", x);
}public class Zadanie {
static int wywolania = 0;
static int licz(int x) {
wywolania++;
if (x == 1)
return 1;
int w = licz(x / 2);
if (x % 2 == 1)
return w + 1;
return w - 1;
}
public static void main(String[] args) {
// 2.1
for (int x : new int[]{11, 13, 21, 32})
System.out.println(x + " " + licz(x));
// 2.2 - najmniejsze x wymagające dokładnie k wywołań
for (int k = 1; k < 8; k++) {
int x = 1;
while (true) {
wywolania = 0;
licz(x);
if (wywolania == k)
break;
x++;
}
System.out.println(k + " " + x + " " + (1 << (k - 1)));
}
// 2.3
int x = 101;
while (licz(x) != 0)
x++;
System.out.println(x);
}
}Odpowiedź: 2.1: licz(11) = 2, licz(13) = 2, licz(21) = 1, licz(32) = -4; 2.2: B) x = 2^(k-1); 2.3: 135
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Zadanie 4. Słodzik. Plik cukier.txt zawiera 2162 wiersze z transakcjami sprzedaży cukru w latach 2005–2014, uporządkowane niemalejąco według daty. W każdym wierszu (pola rozdzielone tabulatorami): data rrrr-mm-dd, NIP klienta (13-znakowy tekst) i liczba sprzedanych kilogramów (co najwyżej 3-cyfrowa liczba dodatnia). Plik cennik.txt podaje cenę 1 kg cukru w każdym roku (np. 2005 2,00); cena obowiązuje przez cały rok. Odpowiedzi zapisz w pliku wyniki4.txt, poprzedzając je numerami zadań.
Podaj NIP-y trzech klientów, którzy w latach 2005–2014 kupili łącznie najwięcej cukru, wraz z łączną liczbą kilogramów kupionych przez każdego z nich.
klienci = {} # NIP -> łączna liczba kg
with open("cukier.txt") as file:
for line in file:
data, nip, kg = line.split()
klienci[nip] = klienci.get(nip, 0) + int(kg)
najlepsi = sorted(klienci, key=klienci.get, reverse=True)
for nip in najlepsi[:3]:
print(nip, klienci[nip])#include <algorithm>
#include <fstream>
#include <map>
#include <print>
#include <string>
#include <utility>
#include <vector>
int main() {
// NIP -> łączna liczba kg; wektor zachowuje kolejność pierwszego wystąpienia (jak dict w Pythonie)
std::vector<std::pair<std::string, long long>> klienci;
std::map<std::string, int> indeks; // NIP -> pozycja w wektorze
std::ifstream plik("cukier.txt");
std::string data, nip;
long long kg;
while (plik >> data >> nip >> kg) {
if (!indeks.contains(nip)) {
indeks[nip] = klienci.size();
klienci.push_back({nip, 0});
}
klienci[indeks[nip]].second += kg;
}
// stable_sort - przy remisie zostaje kolejność pierwszego wystąpienia, jak w sorted()
std::stable_sort(klienci.begin(), klienci.end(),
[](const auto& a, const auto& b) { return a.second > b.second; });
for (int i = 0; i < 3; i++)
std::println("{} {}", klienci[i].first, klienci[i].second);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
public class Zadanie {
public static void main(String[] args) throws Exception {
// NIP -> łączna liczba kg; LinkedHashMap zachowuje kolejność wstawiania (jak dict w Pythonie)
Map<String, Long> klienci = new LinkedHashMap<>();
for (String linia : Files.readAllLines(Path.of("cukier.txt"))) {
String[] pola = linia.trim().split("\\s+");
klienci.merge(pola[1], Long.parseLong(pola[2]), Long::sum);
}
// sortowanie listy jest stabilne - przy remisie zostaje kolejność wstawiania, jak w sorted()
List<String> najlepsi = new ArrayList<>(klienci.keySet());
najlepsi.sort((a, b) -> Long.compare(klienci.get(b), klienci.get(a)));
for (String nip : najlepsi.subList(0, 3))
System.out.println(nip + " " + klienci.get(nip));
}
}Odpowiedź: 254-14-00-156 27505, 847-48-41-699 26955, 392-78-93-552 26451
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Na podstawie plików cukier.txt (transakcje: data, NIP, kg) i cennik.txt (cena 1 kg w danym roku) oblicz łączny przychód firmy Słodzik w latach 2005–2014. Przychód z jednej transakcji to cena z danego roku pomnożona przez liczbę sprzedanych kilogramów. Wynik zapisz w wyniki4.txt.
ceny = {} # rok -> cena 1 kg w groszach (liczymy w groszach, żeby uniknąć błędów float)
with open("cennik.txt") as file:
for line in file:
rok, cena = line.split()
zl, gr = cena.split(",")
ceny[rok] = int(zl) * 100 + int(gr)
przychod = 0
with open("cukier.txt") as file:
for line in file:
data, nip, kg = line.split()
przychod += int(kg) * ceny[data[:4]]
print(f"{przychod // 100},{przychod % 100:02d}")#include <fstream>
#include <map>
#include <print>
#include <string>
int main() {
std::map<std::string, long long> ceny; // rok -> cena 1 kg w groszach (liczymy w groszach, żeby uniknąć błędów float)
std::ifstream cennik("cennik.txt");
std::string rok, cena;
while (cennik >> rok >> cena) {
size_t przecinek = cena.find(',');
long long zl = std::stoll(cena.substr(0, przecinek));
long long gr = std::stoll(cena.substr(przecinek + 1));
ceny[rok] = zl * 100 + gr;
}
long long przychod = 0;
std::ifstream cukier("cukier.txt");
std::string data, nip;
long long kg;
while (cukier >> data >> nip >> kg)
przychod += kg * ceny[data.substr(0, 4)];
std::println("{},{:02d}", przychod / 100, przychod % 100);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.Map;
public class Zadanie {
public static void main(String[] args) throws Exception {
Map<String, Long> ceny = new HashMap<>(); // rok -> cena 1 kg w groszach (liczymy w groszach, żeby uniknąć błędów float)
for (String linia : Files.readAllLines(Path.of("cennik.txt"))) {
String[] pola = linia.trim().split("\\s+");
String[] zlGr = pola[1].split(",");
ceny.put(pola[0], Long.parseLong(zlGr[0]) * 100 + Long.parseLong(zlGr[1]));
}
long przychod = 0;
for (String linia : Files.readAllLines(Path.of("cukier.txt"))) {
String[] pola = linia.trim().split("\\s+");
przychod += Long.parseLong(pola[2]) * ceny.get(pola[0].substring(0, 4));
}
System.out.println(przychod / 100 + "," + String.format("%02d", przychod % 100));
}
}Odpowiedź: 643 267,07 zł
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Na podstawie pliku cukier.txt podaj zestawienie ilości cukru sprzedanego w kolejnych latach 2005–2014 i wykonaj wykres liniowy sprzedaży w tych latach (oś pionowa skalowana co 5000 kg, z tytułem i opisami osi). Wynik zapisz w wyniki4.txt.
lata = {} # rok -> sprzedane kg
with open("cukier.txt") as file:
for line in file:
data, nip, kg = line.split()
rok = data[:4]
lata[rok] = lata.get(rok, 0) + int(kg)
for rok in sorted(lata):
print(rok, lata[rok])#include <fstream>
#include <map>
#include <print>
#include <string>
int main() {
std::map<std::string, long long> lata; // rok -> sprzedane kg (std::map - klucze posortowane)
std::ifstream plik("cukier.txt");
std::string data, nip;
long long kg;
while (plik >> data >> nip >> kg)
lata[data.substr(0, 4)] += kg;
for (auto& [rok, suma] : lata)
std::println("{} {}", rok, suma);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.TreeMap;
public class Zadanie {
public static void main(String[] args) throws Exception {
Map<String, Long> lata = new TreeMap<>(); // rok -> sprzedane kg (TreeMap - klucze posortowane)
for (String linia : Files.readAllLines(Path.of("cukier.txt"))) {
String[] pola = linia.trim().split("\\s+");
lata.merge(pola[0].substring(0, 4), Long.parseLong(pola[2]), Long::sum);
}
for (var wpis : lata.entrySet())
System.out.println(wpis.getKey() + " " + wpis.getValue());
}
}Odpowiedź: 2005: 27016, 2006: 27226, 2007: 31720, 2008: 36523, 2009: 30764, 2010: 32521, 2011: 23778, 2012: 26976, 2013: 28419, 2014: 35284 (+ wykres liniowy)
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Załóżmy, że w latach 2005–2014 klienci firmy Słodzik (dane w cukier.txt) otrzymują rabat zależny od łącznej ilości cukru kupionej dotąd przez danego klienta, wliczając bieżącą transakcję. Rabat za każdy kilogram w bieżącej transakcji wynosi:
- 5 gr — przy łącznie co najmniej 100 kg, ale mniej niż 1000 kg;
- 10 gr — przy co najmniej 1000 kg, ale mniej niż 10 000 kg;
- 20 gr — przy co najmniej 10 000 kg.
Podaj łączną wartość wszystkich udzielonych rabatów. Wynik zapisz w wyniki4.txt.
zakupione = {} # NIP -> kg kupione do tej pory
rabaty = 0 # w groszach
with open("cukier.txt") as file:
for line in file:
data, nip, kg = line.split()
kg = int(kg)
zakupione[nip] = zakupione.get(nip, 0) + kg # razem z bieżącą transakcją
suma = zakupione[nip]
if suma >= 10000:
rabat = 20
elif suma >= 1000:
rabat = 10
elif suma >= 100:
rabat = 5
else:
rabat = 0
rabaty += kg * rabat
print(f"{rabaty // 100},{rabaty % 100:02d}")#include <fstream>
#include <map>
#include <print>
#include <string>
int main() {
std::map<std::string, long long> zakupione; // NIP -> kg kupione do tej pory
long long rabaty = 0; // w groszach
std::ifstream plik("cukier.txt");
std::string data, nip;
long long kg;
while (plik >> data >> nip >> kg) {
zakupione[nip] += kg; // razem z bieżącą transakcją
long long suma = zakupione[nip];
int rabat;
if (suma >= 10000)
rabat = 20;
else if (suma >= 1000)
rabat = 10;
else if (suma >= 100)
rabat = 5;
else
rabat = 0;
rabaty += kg * rabat;
}
std::println("{},{:02d}", rabaty / 100, rabaty % 100);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.Map;
public class Zadanie {
public static void main(String[] args) throws Exception {
Map<String, Long> zakupione = new HashMap<>(); // NIP -> kg kupione do tej pory
long rabaty = 0; // w groszach
for (String linia : Files.readAllLines(Path.of("cukier.txt"))) {
String[] pola = linia.trim().split("\\s+");
String nip = pola[1];
long kg = Long.parseLong(pola[2]);
long suma = zakupione.merge(nip, kg, Long::sum); // razem z bieżącą transakcją
int rabat;
if (suma >= 10000)
rabat = 20;
else if (suma >= 1000)
rabat = 10;
else if (suma >= 100)
rabat = 5;
else
rabat = 0;
rabaty += kg * rabat;
}
System.out.println(rabaty / 100 + "," + String.format("%02d", rabaty % 100));
}
}Odpowiedź: 38 126,35 zł
↑Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie.
Treść zadania
Firma Słodzik chce mieć na początku każdego miesiąca co najmniej 5000 kg cukru w magazynie. Ostatniego dnia miesiąca, po ostatniej sprzedaży, dokupuje u producenta tyle pełnych palet po 1000 kg, ile trzeba, aby stan wynosił co najmniej 5000 kg. 1.01.2005 przed sprzedażą w magazynie było 5000 kg. Na podstawie cukier.txt podaj, ile razy w latach 2005–2014 firma dokupiła na koniec miesiąca co najmniej 4000 kg cukru (w niektóre dni nie ma transakcji, w inne jest ich kilka). Wynik zapisz w wyniki4.txt.
sprzedaz = {} # "rrrr-mm" -> kg sprzedane w miesiącu
with open("cukier.txt") as file:
for line in file:
data, nip, kg = line.split()
miesiac = data[:7]
sprzedaz[miesiac] = sprzedaz.get(miesiac, 0) + int(kg)
magazyn = 5000
licznik = 0
for rok in range(2005, 2015):
for m in range(1, 13):
magazyn -= sprzedaz.get(f"{rok}-{m:02d}", 0)
palety = 0
while magazyn + palety * 1000 < 5000:
palety += 1
magazyn += palety * 1000
if palety * 1000 >= 4000:
licznik += 1
print(licznik)#include <format>
#include <fstream>
#include <map>
#include <print>
#include <string>
int main() {
std::map<std::string, long long> sprzedaz; // "rrrr-mm" -> kg sprzedane w miesiącu
std::ifstream plik("cukier.txt");
std::string data, nip;
long long kg;
while (plik >> data >> nip >> kg)
sprzedaz[data.substr(0, 7)] += kg;
long long magazyn = 5000;
int licznik = 0;
for (int rok = 2005; rok < 2015; rok++) {
for (int m = 1; m <= 12; m++) {
auto it = sprzedaz.find(std::format("{}-{:02d}", rok, m));
if (it != sprzedaz.end())
magazyn -= it->second;
int palety = 0;
while (magazyn + palety * 1000 < 5000)
palety++;
magazyn += palety * 1000;
if (palety * 1000 >= 4000)
licznik++;
}
}
std::println("{}", licznik);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.Map;
public class Zadanie {
public static void main(String[] args) throws Exception {
Map<String, Long> sprzedaz = new HashMap<>(); // "rrrr-mm" -> kg sprzedane w miesiącu
for (String linia : Files.readAllLines(Path.of("cukier.txt"))) {
String[] pola = linia.trim().split("\\s+");
sprzedaz.merge(pola[0].substring(0, 7), Long.parseLong(pola[2]), Long::sum);
}
long magazyn = 5000;
int licznik = 0;
for (int rok = 2005; rok < 2015; rok++) {
for (int m = 1; m <= 12; m++) {
magazyn -= sprzedaz.getOrDefault(String.format("%d-%02d", rok, m), 0L);
int palety = 0;
while (magazyn + palety * 1000 < 5000)
palety++;
magazyn += palety * 1000;
if (palety * 1000 >= 4000)
licznik++;
}
}
System.out.println(licznik);
}
}Odpowiedź: 14
↑Treść zadania
Zadanie 6. Piksele. Plik dane.txt zawiera 200 wierszy po 320 liczb z zakresu 0–255 oddzielonych spacjami — jasności pikseli czarno-białego obrazu 320×200 (0 — czarny, 255 — biały). Plik przyklad.txt zawiera dane przykładowe o tych samych wymiarach. Odpowiedzi zapisz w pliku wyniki6.txt, poprzedzając je numerami zadań.
Podaj jasność najjaśniejszego i najciemniejszego piksela. Dla przyklad.txt: 255 i 0.
najjasniejszy = 0
najciemniejszy = 255
with open("dane.txt") as file:
for line in file:
wiersz = list(map(int, line.split()))
najjasniejszy = max(najjasniejszy, max(wiersz))
najciemniejszy = min(najciemniejszy, min(wiersz))
print(najjasniejszy, najciemniejszy)#include <algorithm>
#include <fstream>
#include <print>
int main() {
int najjasniejszy = 0;
int najciemniejszy = 255;
std::ifstream plik("dane.txt");
int piksel;
while (plik >> piksel) { // wszystkie liczby z pliku po kolei
najjasniejszy = std::max(najjasniejszy, piksel);
najciemniejszy = std::min(najciemniejszy, piksel);
}
std::println("{} {}", najjasniejszy, najciemniejszy);
}import java.nio.file.Files;
import java.nio.file.Path;
public class Zadanie {
public static void main(String[] args) throws Exception {
int najjasniejszy = 0;
int najciemniejszy = 255;
for (String linia : Files.readAllLines(Path.of("dane.txt"))) {
for (String liczba : linia.trim().split("\\s+")) {
int piksel = Integer.parseInt(liczba);
najjasniejszy = Math.max(najjasniejszy, piksel);
najciemniejszy = Math.min(najciemniejszy, piksel);
}
}
System.out.println(najjasniejszy + " " + najciemniejszy);
}
}Odpowiedź: najjaśniejszy 221, najciemniejszy 7
↑Treść zadania
Dla obrazu z pliku dane.txt (200 wierszy po 320 jasności pikseli) podaj najmniejszą liczbę wierszy, które trzeba usunąć, aby obraz miał pionową oś symetrii, czyli aby w każdym wierszu i-ty piksel od lewej był równy i-temu pikselowi od prawej (dla każdego 1 ≤ i ≤ 320). Dla przyklad.txt wynik to 3. Wynik zapisz w wyniki6.txt.
licznik = 0
with open("dane.txt") as file:
for line in file:
wiersz = line.split()
# wiersz jest symetryczny, gdy czytany od prawej jest taki sam jak od lewej
if wiersz != wiersz[::-1]:
licznik += 1
print(licznik)#include <fstream>
#include <print>
#include <sstream>
#include <string>
#include <vector>
int main() {
int licznik = 0;
std::ifstream plik("dane.txt");
std::string linia;
while (std::getline(plik, linia)) {
std::istringstream ss(linia);
std::vector<std::string> wiersz;
std::string liczba;
while (ss >> liczba)
wiersz.push_back(liczba);
// wiersz jest symetryczny, gdy czytany od prawej jest taki sam jak od lewej
std::vector<std::string> odwrocony(wiersz.rbegin(), wiersz.rend());
if (wiersz != odwrocony)
licznik++;
}
std::println("{}", licznik);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Zadanie {
public static void main(String[] args) throws Exception {
int licznik = 0;
for (String linia : Files.readAllLines(Path.of("dane.txt"))) {
List<String> wiersz = List.of(linia.trim().split("\\s+"));
// wiersz jest symetryczny, gdy czytany od prawej jest taki sam jak od lewej
List<String> odwrocony = new ArrayList<>(wiersz);
Collections.reverse(odwrocony);
if (!wiersz.equals(odwrocony))
licznik++;
}
System.out.println(licznik);
}
}Odpowiedź: 149
↑Treść zadania
W obrazie z pliku dane.txt sąsiednimi pikselami są piksele leżące obok siebie w tym samym wierszu lub w tej samej kolumnie. Dwa sąsiednie piksele są kontrastujące, jeśli ich jasności różnią się o więcej niż 128. Podaj liczbę pikseli, które mają co najmniej jednego kontrastującego sąsiada. Dla przyklad.txt wynik to 5. Wynik zapisz w wyniki6.txt.
obraz = []
with open("dane.txt") as file:
for line in file:
obraz.append(list(map(int, line.split())))
wiersze = len(obraz)
kolumny = len(obraz[0])
licznik = 0
for i in range(wiersze):
for j in range(kolumny):
kontrastujacy = False
for di, dj in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
ni, nj = i + di, j + dj
if 0 <= ni < wiersze and 0 <= nj < kolumny:
if abs(obraz[i][j] - obraz[ni][nj]) > 128:
kontrastujacy = True
if kontrastujacy:
licznik += 1
print(licznik)#include <cstdlib>
#include <fstream>
#include <print>
#include <sstream>
#include <string>
#include <vector>
int main() {
std::vector<std::vector<int>> obraz;
std::ifstream plik("dane.txt");
std::string linia;
while (std::getline(plik, linia)) {
std::istringstream ss(linia);
std::vector<int> wiersz;
int piksel;
while (ss >> piksel)
wiersz.push_back(piksel);
obraz.push_back(wiersz);
}
int wiersze = obraz.size();
int kolumny = obraz[0].size();
int licznik = 0;
int kierunki[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
for (int i = 0; i < wiersze; i++) {
for (int j = 0; j < kolumny; j++) {
bool kontrastujacy = false;
for (auto [di, dj] : kierunki) {
int ni = i + di, nj = j + dj;
if (0 <= ni && ni < wiersze && 0 <= nj && nj < kolumny)
if (std::abs(obraz[i][j] - obraz[ni][nj]) > 128)
kontrastujacy = true;
}
if (kontrastujacy)
licznik++;
}
}
std::println("{}", licznik);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
public class Zadanie {
public static void main(String[] args) throws Exception {
List<int[]> obraz = new ArrayList<>();
for (String linia : Files.readAllLines(Path.of("dane.txt"))) {
String[] pola = linia.trim().split("\\s+");
int[] wiersz = new int[pola.length];
for (int k = 0; k < pola.length; k++)
wiersz[k] = Integer.parseInt(pola[k]);
obraz.add(wiersz);
}
int wiersze = obraz.size();
int kolumny = obraz.get(0).length;
int licznik = 0;
int[][] kierunki = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
for (int i = 0; i < wiersze; i++) {
for (int j = 0; j < kolumny; j++) {
boolean kontrastujacy = false;
for (int[] kierunek : kierunki) {
int ni = i + kierunek[0], nj = j + kierunek[1];
if (0 <= ni && ni < wiersze && 0 <= nj && nj < kolumny)
if (Math.abs(obraz.get(i)[j] - obraz.get(ni)[nj]) > 128)
kontrastujacy = true;
}
if (kontrastujacy)
licznik++;
}
}
System.out.println(licznik);
}
}Odpowiedź: 753
↑Treść zadania
W obrazie z pliku dane.txt podaj długość najdłuższej linii pionowej, czyli ciągu kolejnych pikseli w jednej kolumnie o tej samej jasności. Dla przyklad.txt wynik to 198. Wynik zapisz w wyniki6.txt.
obraz = []
with open("dane.txt") as file:
for line in file:
obraz.append(list(map(int, line.split())))
najdluzsza = 1
for j in range(len(obraz[0])):
dlugosc = 1
for i in range(1, len(obraz)):
if obraz[i][j] == obraz[i - 1][j]:
dlugosc += 1
else:
dlugosc = 1
najdluzsza = max(najdluzsza, dlugosc)
print(najdluzsza)#include <algorithm>
#include <fstream>
#include <print>
#include <sstream>
#include <string>
#include <vector>
int main() {
std::vector<std::vector<int>> obraz;
std::ifstream plik("dane.txt");
std::string linia;
while (std::getline(plik, linia)) {
std::istringstream ss(linia);
std::vector<int> wiersz;
int piksel;
while (ss >> piksel)
wiersz.push_back(piksel);
obraz.push_back(wiersz);
}
int najdluzsza = 1;
for (size_t j = 0; j < obraz[0].size(); j++) {
int dlugosc = 1;
for (size_t i = 1; i < obraz.size(); i++) {
if (obraz[i][j] == obraz[i - 1][j])
dlugosc++;
else
dlugosc = 1;
najdluzsza = std::max(najdluzsza, dlugosc);
}
}
std::println("{}", najdluzsza);
}import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
public class Zadanie {
public static void main(String[] args) throws Exception {
List<int[]> obraz = new ArrayList<>();
for (String linia : Files.readAllLines(Path.of("dane.txt"))) {
String[] pola = linia.trim().split("\\s+");
int[] wiersz = new int[pola.length];
for (int k = 0; k < pola.length; k++)
wiersz[k] = Integer.parseInt(pola[k]);
obraz.add(wiersz);
}
int najdluzsza = 1;
for (int j = 0; j < obraz.get(0).length; j++) {
int dlugosc = 1;
for (int i = 1; i < obraz.size(); i++) {
if (obraz.get(i)[j] == obraz.get(i - 1)[j])
dlugosc++;
else
dlugosc = 1;
najdluzsza = Math.max(najdluzsza, dlugosc);
}
}
System.out.println(najdluzsza);
}
}Odpowiedź: 5
↑