Matura 2009 — maj, poziom rozszerzony
ARKUSZ IARKUSZ IIDANEODPOWIEDZI
Arkusz I
2a i 2b
Treść zadania
Zadanie 2 (punkty kratowe). Punkt kratowy ma obie współrzędne całkowite. K(R) to koło o środku (0, 0) i promieniu R (z brzegiem), a N(R) — liczba punktów kratowych w K(R). Np. N(0) = 1, N(1) = 5, N(1,5) = 9.
- 2a — podaj N(R) dla R = 2,01 oraz R = 4,50;
- 2b — zaproponuj algorytm, który dla danej nieujemnej liczby całkowitej R oblicza N(R).
from math import floor
def punkty_kratowe(R):
# liczba punktów (x, y) o współrzędnych całkowitych, dla których x^2 + y^2 <= R^2
r = floor(R)
N = 0
for x in range(-r, r + 1):
for y in range(-r, r + 1):
if x * x + y * y <= R * R:
N += 1
return N
print(punkty_kratowe(0), punkty_kratowe(1), punkty_kratowe(1.5)) # przykłady z treści: 1 5 9
print(punkty_kratowe(2.01))
print(punkty_kratowe(4.50))#include <cmath>
#include <print>
int punkty_kratowe(double R) {
// liczba punktów (x, y) o współrzędnych całkowitych, dla których x^2 + y^2 <= R^2
int r = (int)std::floor(R);
int N = 0;
for (int x = -r; x <= r; x++)
for (int y = -r; y <= r; y++)
if (x * x + y * y <= R * R) N++;
return N;
}
int main() {
std::println("{} {} {}", punkty_kratowe(0), punkty_kratowe(1), punkty_kratowe(1.5)); // przykłady z treści: 1 5 9
std::println("{}", punkty_kratowe(2.01));
std::println("{}", punkty_kratowe(4.50));
}public class Zadanie {
static int punktyKratowe(double R) {
// liczba punktów (x, y) o współrzędnych całkowitych, dla których x^2 + y^2 <= R^2
int r = (int) Math.floor(R);
int N = 0;
for (int x = -r; x <= r; x++)
for (int y = -r; y <= r; y++)
if (x * x + y * y <= R * R) N++;
return N;
}
public static void main(String[] args) {
System.out.println(punktyKratowe(0) + " " + punktyKratowe(1) + " " + punktyKratowe(1.5)); // przykłady z treści: 1 5 9
System.out.println(punktyKratowe(2.01));
System.out.println(punktyKratowe(4.50));
}
}Odpowiedź: N(2,01) = 13, N(4,50) = 69
↑Arkusz I
3a
Treść zadania
Zadanie 3 (NWD). Algorytm Euklidesa rekurencyjnie: nwd(a, b) = a dla b = 0 oraz nwd(a, b) = nwd(b, a mod b) dla b ≥ 1. Np. nwd(16, 12) = nwd(12, 4) = nwd(4, 0) = 4 — funkcja jest wywoływana 3 razy.
Podaj liczbę wywołań funkcji dla a = 56, b = 72 oraz dla a = 72, b = 56.
wywolania = 0
def nwd(a, b):
global wywolania
wywolania += 1
if b == 0:
return a
return nwd(b, a % b)
for a, b in [(56, 72), (72, 56)]:
wywolania = 0
nwd(a, b)
print(a, b, wywolania)#include <print>
int wywolania = 0;
int nwd(int a, int b) {
wywolania++;
if (b == 0) return a;
return nwd(b, a % b);
}
int main() {
int pary[2][2] = {{56, 72}, {72, 56}};
for (auto& [a, b] : pary) {
wywolania = 0;
nwd(a, b);
std::println("{} {} {}", a, b, wywolania);
}
}public class Zadanie {
static int wywolania = 0;
static int nwd(int a, int b) {
wywolania++;
if (b == 0) return a;
return nwd(b, a % b);
}
public static void main(String[] args) {
int[][] pary = {{56, 72}, {72, 56}};
for (int[] p : pary) {
wywolania = 0;
nwd(p[0], p[1]);
System.out.println(p[0] + " " + p[1] + " " + wywolania);
}
}
}Odpowiedź: dla a = 56, b = 72 – 5 wywołań; dla a = 72, b = 56 – 4 wywołania
↑Arkusz I
3b
Treść zadania
Podaj nierekurencyjny algorytm obliczania nwd(a, b) (a, b — liczby naturalne, z których co najmniej jedna jest większa od 0) wraz ze specyfikacją.
# Dane: liczby naturalne a i b, z których co najmniej jedna jest większa od 0
# Wynik: największy wspólny dzielnik liczb a i b
def nwd(a, b):
while b > 0:
reszta = a % b
a = b
b = reszta
return a
print(nwd(16, 12), nwd(56, 72))#include <print>
// Dane: liczby naturalne a i b, z których co najmniej jedna jest większa od 0
// Wynik: największy wspólny dzielnik liczb a i b
int nwd(int a, int b) {
while (b > 0) {
int reszta = a % b;
a = b;
b = reszta;
}
return a;
}
int main() {
std::println("{} {}", nwd(16, 12), nwd(56, 72));
}public class Zadanie {
// Dane: liczby naturalne a i b, z których co najmniej jedna jest większa od 0
// Wynik: największy wspólny dzielnik liczb a i b
static int nwd(int a, int b) {
while (b > 0) {
int reszta = a % b;
a = b;
b = reszta;
}
return a;
}
public static void main(String[] args) {
System.out.println(nwd(16, 12) + " " + nwd(56, 72));
}
}Odpowiedź: dopóki b > 0: reszta := a mod b, a := b, b := reszta; wynikiem jest a (np. nwd(16, 12) = 4)
↑Arkusz II
4
Zadanie na arkusz kalkulacyjny — rozwiązanie w Pythonie. Podpunkty korzystają z tych samych wylosowanych punktów, dlatego są w jednym programie. Wykres (b) zapisywany jest jako smok.svg bez dodatkowych bibliotek.
Treść zadania
Zadanie 4 (iteracje). Dwa przekształcenia punktu (x, y), stosowane wielokrotnie w losowej kolejności (każde z prawdopodobieństwem 1/2), dają obraz smoka Heighwaya:
- x' = −0,4x − 1, y' = −0,4y + 0,1;
- x' = 0,76x − 0,4y, y' = 0,4x + 0,76y.
Wyniki podpunktów a, c, d zapisz w pliku zad_4.txt, poprzedzając je literą podpunktu:
- a) zaczynając od x = 1, y = 1, oblicz pierwsze 5000 wartości (x, y) kolejnych iteracji;
- b) sporządź obraz smoka (pomiń 100 pierwszych iteracji) i zapisz go w pliku
smok.*; - c) oblicz środek masy smoka — średnie wartości x i y (zaokrąglone do 0,1), pomijając 100 pierwszych iteracji;
- d) podaj minimalne i maksymalne wartości x oraz y (zaokrąglone do 0,1), pomijając 100 pierwszych iteracji.
from random import randint
x, y = 1, 1
punkty = []
# a) 5000 iteracji, za każdym razem losowy układ równań
for i in range(5000):
if randint(0, 1) == 0:
x, y = -0.4 * x - 1, -0.4 * y + 0.1
else:
x, y = 0.76 * x - 0.4 * y, 0.4 * x + 0.76 * y
punkty.append((x, y))
smok = punkty[100:] # pomijamy 100 pierwszych iteracji
xs = [p[0] for p in smok]
ys = [p[1] for p in smok]
with open("zad_4.txt", "w") as wynik:
wynik.write("a)\n")
for x, y in punkty:
wynik.write(f"{x} {y}\n")
# c) środek masy
wynik.write(f"c) {round(sum(xs) / len(xs), 1)} {round(sum(ys) / len(ys), 1)}\n")
# d) rozmiary smoka
wynik.write(f"d) xmin={round(min(xs), 1)} xmax={round(max(xs), 1)} "
f"ymin={round(min(ys), 1)} ymax={round(max(ys), 1)}\n")
print("c)", round(sum(xs) / len(xs), 1), round(sum(ys) / len(ys), 1))
print("d)", round(min(xs), 1), round(max(xs), 1), round(min(ys), 1), round(max(ys), 1))
# b) obraz smoka jako plik SVG
skala = 300
with open("smok.svg", "w") as obraz:
obraz.write('<svg xmlns="http://www.w3.org/2000/svg" width="600" height="400" '
'style="background:white">\n')
for x, y in smok:
px = (x + 1.2) * skala
py = 400 - (y + 0.5) * skala
obraz.write(f'<circle cx="{px:.1f}" cy="{py:.1f}" r="0.8" fill="green"/>\n')
obraz.write("</svg>\n")#include <algorithm>
#include <charconv>
#include <cmath>
#include <format>
#include <fstream>
#include <print>
#include <random>
#include <string>
#include <utility>
#include <vector>
// liczba rzeczywista zapisana tak jak w Pythonie: najkrótszy dokładny zapis,
// np. 2.0, -0.123, 1.5e-05 (std::format("{}") pisze 2 zamiast 2.0)
std::string jak_python(double x) {
if (x == 0) return std::signbit(x) ? "-0.0" : "0.0";
char bufor[64];
auto koniec = std::to_chars(bufor, bufor + sizeof bufor, std::fabs(x), std::chars_format::scientific).ptr;
std::string s(bufor, koniec); // np. "1.2345e-05"
size_t e = s.find('e');
int wykladnik = std::stoi(s.substr(e + 1));
std::string cyfry = s.substr(0, e);
std::erase(cyfry, '.'); // np. "12345"
std::string znak = x < 0 ? "-" : "";
if (wykladnik < -4 || wykladnik >= 16) {
std::string mantysa = cyfry.substr(0, 1) + (cyfry.size() > 1 ? "." + cyfry.substr(1) : "");
return std::format("{}{}e{}{:02}", znak, mantysa, wykladnik < 0 ? '-' : '+', std::abs(wykladnik));
}
if (wykladnik < 0) return znak + "0." + std::string(-wykladnik - 1, '0') + cyfry;
if ((int)cyfry.size() <= wykladnik + 1)
return znak + cyfry + std::string(wykladnik + 1 - cyfry.size(), '0') + ".0";
return znak + cyfry.substr(0, wykladnik + 1) + "." + cyfry.substr(wykladnik + 1);
}
// round(x, 1) z Pythona
double zaokraglij1(double x) { return std::stod(std::format("{:.1f}", x)); }
int main() {
std::mt19937 generator(std::random_device{}());
std::uniform_int_distribution<int> los(0, 1);
double x = 1, y = 1;
std::vector<std::pair<double, double>> punkty;
// a) 5000 iteracji, za każdym razem losowy układ równań
for (int i = 0; i < 5000; i++) {
double nowy_x, nowy_y;
if (los(generator) == 0) {
nowy_x = -0.4 * x - 1;
nowy_y = -0.4 * y + 0.1;
} else {
nowy_x = 0.76 * x - 0.4 * y;
nowy_y = 0.4 * x + 0.76 * y;
}
x = nowy_x;
y = nowy_y;
punkty.push_back({x, y});
}
// pomijamy 100 pierwszych iteracji
std::vector<std::pair<double, double>> smok(punkty.begin() + 100, punkty.end());
std::vector<double> xs, ys;
for (auto [px, py] : smok) {
xs.push_back(px);
ys.push_back(py);
}
double suma_x = 0, suma_y = 0;
for (double v : xs) suma_x += v;
for (double v : ys) suma_y += v;
std::string srodek_x = jak_python(zaokraglij1(suma_x / xs.size()));
std::string srodek_y = jak_python(zaokraglij1(suma_y / ys.size()));
std::string xmin = jak_python(zaokraglij1(std::ranges::min(xs)));
std::string xmax = jak_python(zaokraglij1(std::ranges::max(xs)));
std::string ymin = jak_python(zaokraglij1(std::ranges::min(ys)));
std::string ymax = jak_python(zaokraglij1(std::ranges::max(ys)));
std::ofstream wynik("zad_4.txt");
wynik << "a)\n";
for (auto [px, py] : punkty)
wynik << jak_python(px) << " " << jak_python(py) << "\n";
// c) środek masy
wynik << "c) " << srodek_x << " " << srodek_y << "\n";
// d) rozmiary smoka
wynik << "d) xmin=" << xmin << " xmax=" << xmax << " ymin=" << ymin << " ymax=" << ymax << "\n";
wynik.close();
std::println("c) {} {}", srodek_x, srodek_y);
std::println("d) {} {} {} {}", xmin, xmax, ymin, ymax);
// b) obraz smoka jako plik SVG
const int skala = 300;
std::ofstream obraz("smok.svg");
obraz << "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"600\" height=\"400\" style=\"background:white\">\n";
for (auto [sx, sy] : smok) {
double px = (sx + 1.2) * skala;
double py = 400 - (sy + 0.5) * skala;
obraz << std::format("<circle cx=\"{:.1f}\" cy=\"{:.1f}\" r=\"0.8\" fill=\"green\"/>\n", px, py);
}
obraz << "</svg>\n";
}import java.io.PrintWriter;
import java.math.*;
import java.util.*;
public class Zadanie {
// liczba rzeczywista zapisana tak jak w Pythonie: np. 2.0, -0.123, 1.5e-05
// (Java pisze małe liczby inaczej, np. 1.5E-5)
static String jakPython(double x) {
if (x == 0) return (1 / x < 0) ? "-0.0" : "0.0";
var bd = new BigDecimal(Double.toString(Math.abs(x))).stripTrailingZeros();
String cyfry = bd.unscaledValue().toString();
int wykladnik = cyfry.length() - 1 - bd.scale();
String znak = x < 0 ? "-" : "";
if (wykladnik < -4 || wykladnik >= 16) {
String mantysa = cyfry.length() > 1 ? cyfry.charAt(0) + "." + cyfry.substring(1) : cyfry;
return znak + mantysa + "e" + (wykladnik < 0 ? "-" : "+") + String.format("%02d", Math.abs(wykladnik));
}
String s = bd.toPlainString();
return znak + (s.contains(".") ? s : s + ".0");
}
// f"{v:.1f}" z Pythona (dokładne zaokrąglenie wartości binarnej)
static String jedenMiejsce(double v) {
String s = new BigDecimal(v).setScale(1, RoundingMode.HALF_EVEN).toPlainString();
return (v < 0 && !s.startsWith("-")) ? "-" + s : s;
}
// round(v, 1) z Pythona
static double zaokraglij1(double v) {
return Double.parseDouble(jedenMiejsce(v));
}
public static void main(String[] args) throws Exception {
var los = new Random();
double x = 1, y = 1;
var punkty = new ArrayList<double[]>();
// a) 5000 iteracji, za każdym razem losowy układ równań
for (int i = 0; i < 5000; i++) {
double nowyX, nowyY;
if (los.nextInt(2) == 0) {
nowyX = -0.4 * x - 1;
nowyY = -0.4 * y + 0.1;
} else {
nowyX = 0.76 * x - 0.4 * y;
nowyY = 0.4 * x + 0.76 * y;
}
x = nowyX;
y = nowyY;
punkty.add(new double[]{x, y});
}
var smok = punkty.subList(100, punkty.size()); // pomijamy 100 pierwszych iteracji
double sumaX = 0, sumaY = 0;
double minX = Double.MAX_VALUE, maxX = -Double.MAX_VALUE, minY = Double.MAX_VALUE, maxY = -Double.MAX_VALUE;
for (double[] p : smok) {
sumaX += p[0];
sumaY += p[1];
minX = Math.min(minX, p[0]);
maxX = Math.max(maxX, p[0]);
minY = Math.min(minY, p[1]);
maxY = Math.max(maxY, p[1]);
}
String srodekX = jakPython(zaokraglij1(sumaX / smok.size()));
String srodekY = jakPython(zaokraglij1(sumaY / smok.size()));
String xmin = jakPython(zaokraglij1(minX)), xmax = jakPython(zaokraglij1(maxX));
String ymin = jakPython(zaokraglij1(minY)), ymax = jakPython(zaokraglij1(maxY));
try (var wynik = new PrintWriter("zad_4.txt")) {
wynik.println("a)");
for (double[] p : punkty)
wynik.println(jakPython(p[0]) + " " + jakPython(p[1]));
// c) środek masy
wynik.println("c) " + srodekX + " " + srodekY);
// d) rozmiary smoka
wynik.println("d) xmin=" + xmin + " xmax=" + xmax + " ymin=" + ymin + " ymax=" + ymax);
}
System.out.println("c) " + srodekX + " " + srodekY);
System.out.println("d) " + xmin + " " + xmax + " " + ymin + " " + ymax);
// b) obraz smoka jako plik SVG
final int skala = 300;
try (var obraz = new PrintWriter("smok.svg")) {
obraz.println("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"600\" height=\"400\" style=\"background:white\">");
for (double[] p : smok) {
double px = (p[0] + 1.2) * skala;
double py = 400 - (p[1] + 0.5) * skala;
obraz.println("<circle cx=\"" + jedenMiejsce(px) + "\" cy=\"" + jedenMiejsce(py) + "\" r=\"0.8\" fill=\"green\"/>");
}
obraz.println("</svg>");
}
}
}Odpowiedź: wyniki są losowe, klucz nie podaje wartości; przykładowo: c) środek masy ≈ (−0,6; −0,1), d) x od −1,2 do 0,4, y od −0,7 do 0,4
↑Arkusz II
5a
Treść zadania
Zadanie 5 (para słów). Plik dane.txt zawiera w każdym wierszu parę słów A i B z cyfr 0 i 1, oddzielonych spacją; |A| ≥ |B|. Dla pary szukamy najkrótszego słowa C zawierającego A i B (B może być zawarte w A albo słowa mogą się nakładać sufiksem i prefiksem, w przeciwnym razie C to sklejenie A i B). Odpowiedzi do a–c zapisz w zad_5.txt, poprzedzając je literą podpunktu.
Podaj, ile spośród wszystkich słów w pliku dane.txt to palindromy.
palindromy = 0
with open("dane.txt") as file:
for line in file:
for slowo in line.split():
if slowo == slowo[::-1]:
palindromy += 1
print(palindromy)#include <fstream>
#include <print>
#include <string>
int main() {
int palindromy = 0;
std::ifstream plik("dane.txt");
std::string slowo;
while (plik >> slowo)
if (slowo == std::string(slowo.rbegin(), slowo.rend())) palindromy++;
std::println("{}", palindromy);
}import java.nio.file.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
int palindromy = 0;
for (String linia : Files.readAllLines(Path.of("dane.txt")))
for (String slowo : linia.trim().split("\\s+"))
if (!slowo.isEmpty() && slowo.equals(new StringBuilder(slowo).reverse().toString()))
palindromy++;
System.out.println(palindromy);
}
}Odpowiedź: 46
↑Arkusz II
5b
Treść zadania
Podaj, ile par (A, B) z pliku dane.txt ma tę własność, że słowo B jest zawarte wewnątrz słowa A. Odpowiedź zapisz w zad_5.txt.
licznik = 0
with open("dane.txt") as file:
for line in file:
a, b = line.split()
if b in a:
licznik += 1
print(licznik)#include <fstream>
#include <print>
#include <string>
int main() {
int licznik = 0;
std::ifstream plik("dane.txt");
std::string a, b;
while (plik >> a >> b)
if (a.find(b) != std::string::npos) licznik++; // czy b jest fragmentem a
std::println("{}", licznik);
}import java.nio.file.*;
public class Zadanie {
public static void main(String[] args) throws Exception {
int licznik = 0;
for (String linia : Files.readAllLines(Path.of("dane.txt"))) {
if (linia.isBlank()) continue;
String[] slowa = linia.trim().split("\\s+");
String a = slowa[0], b = slowa[1];
if (a.contains(b)) licznik++;
}
System.out.println(licznik);
}
}Odpowiedź: 35
↑Arkusz II
5c
Treść zadania
Podaj, ile par (A, B) z pliku dane.txt ma tę własność, że jedynym sposobem utworzenia najkrótszego słowa C zawierającego oba słowa jest sklejenie A i B (B nie jest zawarte w A i żaden sufiks jednego słowa nie jest prefiksem drugiego). Odpowiedź zapisz w zad_5.txt.
def nakladka(a, b):
# długość najdłuższego sufiksu słowa a, który jest prefiksem słowa b
for k in range(min(len(a), len(b)), 0, -1):
if a[-k:] == b[:k]:
return k
return 0
licznik = 0
with open("dane.txt") as file:
for line in file:
a, b = line.split()
if b not in a and nakladka(a, b) == 0 and nakladka(b, a) == 0:
licznik += 1
print(licznik)#include <algorithm>
#include <fstream>
#include <print>
#include <string>
int nakladka(const std::string& a, const std::string& b) {
// długość najdłuższego sufiksu słowa a, który jest prefiksem słowa b
for (int k = (int)std::min(a.size(), b.size()); k > 0; k--)
if (a.substr(a.size() - k) == b.substr(0, k)) return k;
return 0;
}
int main() {
int licznik = 0;
std::ifstream plik("dane.txt");
std::string a, b;
while (plik >> a >> b)
if (a.find(b) == std::string::npos && nakladka(a, b) == 0 && nakladka(b, a) == 0)
licznik++;
std::println("{}", licznik);
}import java.nio.file.*;
public class Zadanie {
static int nakladka(String a, String b) {
// długość najdłuższego sufiksu słowa a, który jest prefiksem słowa b
for (int k = Math.min(a.length(), b.length()); k > 0; k--)
if (a.substring(a.length() - k).equals(b.substring(0, k))) return k;
return 0;
}
public static void main(String[] args) throws Exception {
int licznik = 0;
for (String linia : Files.readAllLines(Path.of("dane.txt"))) {
if (linia.isBlank()) continue;
String[] slowa = linia.trim().split("\\s+");
String a = slowa[0], b = slowa[1];
if (!a.contains(b) && nakladka(a, b) == 0 && nakladka(b, a) == 0) licznik++;
}
System.out.println(licznik);
}
}Odpowiedź: 13
↑Arkusz II
5d
Treść zadania
Dla każdej pary (A, B) z pliku dane.txt utwórz najkrótsze słowo C zawierające oba słowa (np. dla A = 10011101: z B = 111 → C = A; z B = 1100 nakładamy 3-znakowy sufiks B na prefiks A; z B = 1010 nakładamy 3-znakowy sufiks A na prefiks B). Słowa C zapisz w pliku slowa.txt, każde w osobnym wierszu, w kolejności par z pliku.
def nakladka(a, b):
# długość najdłuższego sufiksu słowa a, który jest prefiksem słowa b
for k in range(min(len(a), len(b)), 0, -1):
if a[-k:] == b[:k]:
return k
return 0
def slowo_c(a, b):
if b in a:
return a
k1 = nakladka(a, b) # najpierw A, potem B
k2 = nakladka(b, a) # najpierw B, potem A
if k1 >= k2:
return a + b[k1:]
return b + a[k2:]
with open("dane.txt") as file, open("slowa.txt", "w") as wynik:
for line in file:
a, b = line.split()
wynik.write(slowo_c(a, b) + "\n")#include <algorithm>
#include <fstream>
#include <string>
int nakladka(const std::string& a, const std::string& b) {
// długość najdłuższego sufiksu słowa a, który jest prefiksem słowa b
for (int k = (int)std::min(a.size(), b.size()); k > 0; k--)
if (a.substr(a.size() - k) == b.substr(0, k)) return k;
return 0;
}
std::string slowo_c(const std::string& a, const std::string& b) {
if (a.find(b) != std::string::npos) return a;
int k1 = nakladka(a, b); // najpierw A, potem B
int k2 = nakladka(b, a); // najpierw B, potem A
if (k1 >= k2) return a + b.substr(k1);
return b + a.substr(k2);
}
int main() {
std::ifstream plik("dane.txt");
std::ofstream wynik("slowa.txt");
std::string a, b;
while (plik >> a >> b)
wynik << slowo_c(a, b) << "\n";
}import java.io.PrintWriter;
import java.nio.file.*;
public class Zadanie {
static int nakladka(String a, String b) {
// długość najdłuższego sufiksu słowa a, który jest prefiksem słowa b
for (int k = Math.min(a.length(), b.length()); k > 0; k--)
if (a.substring(a.length() - k).equals(b.substring(0, k))) return k;
return 0;
}
static String slowoC(String a, String b) {
if (a.contains(b)) return a;
int k1 = nakladka(a, b); // najpierw A, potem B
int k2 = nakladka(b, a); // najpierw B, potem A
if (k1 >= k2) return a + b.substring(k1);
return b + a.substring(k2);
}
public static void main(String[] args) throws Exception {
try (var wynik = new PrintWriter("slowa.txt")) {
for (String linia : Files.readAllLines(Path.of("dane.txt"))) {
if (linia.isBlank()) continue;
String[] slowa = linia.trim().split("\\s+");
wynik.println(slowoC(slowa[0], slowa[1]));
}
}
}
}Odpowiedź: plik slowa.txt: 0001100111101010111, 1100001101, 11000100, …
↑