J3112 bezdvernaia polina lab4 lab5 lab6

lab2.cpp

@@ -0,0 +1,101 @@
+#include <cassert>
+#include <iostream>
+#include <string>
+#include <unordered_map>
+
+bool are_isomorph(std::string* line_1, std::string* line_2, std::unordered_map<char, char>* saved_letters) { // 8 + 4 * 2 = 12 ���� (���������) 
+	int length1 = (*line_1).size(); // 4 �����
+	int length2 = (*line_2).size(); // 4 �����
+	if (length2 != length1) { return false; }
+	for (int i = 0; i < length1; i++) { // 24 + 2 * K ���� (max K = 94, ��� K - ���������� ���������� �������� � ������) ��� 24 + 80 ���� ��� K <= 40
+		auto search = (*saved_letters).find((*line_1)[i]); // �� ����� 24 �����
+		if (search != (*saved_letters).end()) {
+			if (search->second != (*line_2)[i]) {
+				return false;
+			}
+		}
+		else {
+			(*saved_letters).insert({ (*line_1)[i], (*line_2)[i] });
+		}
+	}
+	return true;
+}
+//int main(){
+//	std::string line_1,line_2; // 80 ����
+//	std::cin >> line_1 >> line_2; // N + M ���� (max N, M = 10000, ��� N, M - ���������� �������� � �������) ��� 80 ���� ��� N � M <= 40
+//	std::unordered_map<char, char> saved_letters; // 80 ����
+//  std::cout << are_isomorph(&line_1, &line_2, &saved_letters) << std::endl;
+//}
+
+// �������� ������� ������: max(M+N, 80) + 16 + 4 + 4 + max(2*K, 80) + 24 = max(M+N, 80) + max(2*K, 80) + 44 ����
+
+
+// ���� �� �������
+void TEST_1() {
+	std::string line_1{ "foo" }, line_2{ "dff" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 1);
+
+}
+
+// ���� � ������������� ��������
+void TEST_2() {
+	std::string line_1{ "foo" }, line_2{ "dfd" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 0);
+
+}
+
+// ���� �� �������� ������ ����� (a > b)
+void TEST_3() {
+	std::string line_1{ "food" }, line_2{ "dff" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 0);
+
+}
+
+// ���� �� �������� ������ ����� (a < b)
+void TEST_4() {
+	std::string line_1{ "foo" }, line_2{ "dfff" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 0);
+
+}
+
+// ���� � ������� ��������
+void TEST_5() {
+	std::string line_1{ "" }, line_2{ "" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 1);
+
+}
+
+// ���� � ����������� ��������, ����������� ��� ���������� �������
+
+void TEST_6() {
+	std::string line_1{ "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890��������������������������������qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890��������������������������������" };
+	std::string line_2{ "�qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890��������������������������������qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890�������������������������������" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 1);
+
+}
+
+// ���� � ������������� ��������, ����������� ��� ���������� �������
+void TEST_7() {
+	std::string line_1{ "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890��������������������������������qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890��������������������������������" };
+	std::string line_2{ "�qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890��������������������������������qwertyuiopasdfghjkldfcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890�������������������������������" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 0);
+
+}
+
+int main() {
+	TEST_1();
+	TEST_2();
+	TEST_3();
+	TEST_4();
+	TEST_5();
+	TEST_6();
+	TEST_7();
+	std::cout << "All tests completed successfully" << std::endl;
+}

lab2_fixed.cpp

@@ -0,0 +1,77 @@
+#include <cassert>
+#include <iostream>
+#include <string>
+#include <unordered_map>
+
+bool are_isomorph(std::string& line_1, std::string& line_2, std::unordered_map<char, char>& letters_bijection) {
+
+	short int length1 = line_1.length(); // 2 байта
+	short int length2 = line_2.length(); // 2 байта
+	if (length2 != length1) { return false; }
+
+	// Сравниваем длину строк, иначе, если строки имеют разную длину, программа либо выдаёт ошибку (length1 > length2), 
+	// либо не проходит вторую строку полностью (length1 < length2)
+
+	for (int i = 0; i < length1; i++) { // 24 + 2 * K байт (max K = 94, где K - количество уникальных символов в строке) или 24 + 80 байт при K <= 40
+
+		auto search = letters_bijection.find(line_1[i]); // 24 байта
+
+		// unordered_map letters хранит пары вида key = line_1[i], value = line_2[i]
+		// В каждой итерации цикла проверяем, есть ли элемент line_1[i] в качестве ключа
+		// в letters или нет. Если нет - создаём ключ line_1[i] со значением line_2[i],
+		// есть - сравниваем значение с line_2[i]. При несовпадении, возвращаем false, т.к. биекция будет нарушена
+		if (search != letters_bijection.end()) {
+			if (search->second != line_2[i]) {
+				return false;
+			}
+		}
+		else {
+			letters_bijection.insert({ line_1[i], line_2[i] });
+		}
+	}
+
+	return true;
+}
+// итоговые затраты памяти (самой функцией): 2 + 2 + max(2*K, 80) + 24 = max(2*K, 80) + 28 байт
+// итоговые затраты памяти в целом: max(N,80) + max(M, 80) + 2 + 2 + max(2*K, 80) + 24 = max(N,80) + max(M, 80) + max(2*K, 80) + 28 байт (Где N и M - длины строк)
+
+int main() {
+	// Тест из примера
+	std::string line_11{ "foo" }, line_21{ "dff" };
+	std::unordered_map<char, char> letters_bijection1;
+	assert(are_isomorph(line_11, line_21, letters_bijection1) == 1);
+
+	// Тест с неизоморфными строками
+	std::string line_12{ "foo" }, line_22{ "dfd" };
+	std::unordered_map<char, char> letters_bijection2;
+	assert(are_isomorph(line_12, line_22, letters_bijection2) == 0);
+
+	// Тест со строками разной длины (a > b)
+	std::string line_13{ "food" }, line_23{ "dff" };
+	std::unordered_map<char, char> letters_bijection3;
+	assert(are_isomorph(line_13, line_23, letters_bijection3) == 0);
+
+	// Тест со строками разной длины (a < b)
+	std::string line_14{ "foo" }, line_24{ "dfff" };
+	std::unordered_map<char, char> letters_bijection4;
+	assert(are_isomorph(line_14, line_24, letters_bijection4) == 0);
+
+	// Тест с пустыми строками
+	std::string line_15{ "" }, line_25{ "" };
+	std::unordered_map<char, char> letters_bijection5;
+	assert(are_isomorph(line_15, line_25, letters_bijection5) == 1);
+
+	// Тест с изоморфными строками, содержащими все допустимые символы
+	std::string line_16{ "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбюqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбю" };
+	std::string line_26{ "юqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбюqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьб" };
+	std::unordered_map<char, char> letters_bijection6;
+	assert(are_isomorph(line_16, line_26, letters_bijection6) == 1);
+
+	// Тест с неизоморфными строками, содержащими все допустимые символы
+	std::string line_17{ "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбюqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбю" };
+	std::string line_27{ "юqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбюqwertyuiopasdfghjkldfcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьб" };
+	std::unordered_map<char, char> letters_bijection7;
+	assert(are_isomorph(line_17, line_27, letters_bijection7) == 0);
+
+	std::cout << "All tests completed successfully" << std::endl;
+}

lab2fixed.cpp

@@ -0,0 +1,101 @@
+#include <cassert>
+#include <iostream>
+#include <string>
+#include <unordered_map>
+
+bool are_isomorph(std::string* line_1, std::string* line_2, std::unordered_map<char, char>* saved_letters) { // 8 + 4 * 2 = 12 байт (указатели) 
+	int length1 = (*line_1).size(); // 4 байта
+	int length2 = (*line_2).size(); // 4 байта
+	if (length2 != length1) { return false; }
+	for (int i = 0; i < length1; i++) { // 24 + 2 * K байт (max K = 94, где K - количество уникальных символов в строке) или 24 + 80 байт при K <= 40
+		auto search = (*saved_letters).find((*line_1)[i]); // те самые 24 байта
+		if (search != (*saved_letters).end()) {
+			if (search->second != (*line_2)[i]) {
+				return false;
+			}
+		}
+		else {
+			(*saved_letters).insert({ (*line_1)[i], (*line_2)[i] });
+		}
+	}
+	return true;
+}
+//int main(){
+//	std::string line_1,line_2; // 80 байт
+//	std::cin >> line_1 >> line_2; // N + M байт (max N, M = 10000, где N, M - количество символов в строках) или 80 байт при N и M <= 40
+//	std::unordered_map<char, char> saved_letters; // 80 байт
+//  std::cout << are_isomorph(&line_1, &line_2, &saved_letters) << std::endl;
+//}
+
+// итоговые затраты памяти: max(M+N, 80) + 16 + 4 + 4 + max(2*K, 80) + 24 = max(M+N, 80) + max(2*K, 80) + 44 байт
+
+
+// Тест из примера
+void TEST_1() {
+	std::string line_1{ "foo" }, line_2{ "dff" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 1);
+
+}
+
+// Тест с неизоморфными строками
+void TEST_2() {
+	std::string line_1{ "foo" }, line_2{ "dfd" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 0);
+
+}
+
+// Тест со строками разной длины (a > b)
+void TEST_3() {
+	std::string line_1{ "food" }, line_2{ "dff" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 0);
+
+}
+
+// Тест со строками разной длины (a < b)
+void TEST_4() {
+	std::string line_1{ "foo" }, line_2{ "dfff" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 0);
+
+}
+
+// Тест с пустыми строками
+void TEST_5() {
+	std::string line_1{ "" }, line_2{ "" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 1);
+
+}
+
+// Тест с изоморфными строками, содержащими все допустимые символы
+
+void TEST_6() {
+	std::string line_1{ "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбюqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбю" };
+	std::string line_2{ "юqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбюqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьб" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 1);
+
+}
+
+// Тест с неизоморфными строками, содержащими все допустимые символы
+void TEST_7() {
+	std::string line_1{ "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбюqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбю" };
+	std::string line_2{ "юqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьбюqwertyuiopasdfghjkldfcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890йцукенгшщзхъфывапролджэячсмитьб" };
+	std::unordered_map<char, char> saved_letters;
+	assert(are_isomorph(&line_1, &line_2, &saved_letters) == 0);
+
+}
+
+int main() {
+	TEST_1();
+	TEST_2();
+	TEST_3();
+	TEST_4();
+	TEST_5();
+	TEST_6();
+	TEST_7();
+	std::cout << "All tests completed successfully" << std::endl;
+}

lab3_finished.cpp

@@ -0,0 +1,75 @@
+// ����������� �������� ������, ������� �������� ������������������ ���������� �������� �� ����������� � �������� Medium
+#include <cassert>
+#include <iostream>
+#include <string>
+
+std::string compression(const std::string text) {
+
+	// ����������� � ������������:
+	// ����� ������������������ = ��
+	// N - ����� ������, K - ���������� ������������������� �� ���������� ��������
+
+	std::string compressed_text; // O(1), 40 ����
+	short int count{ 0 }; // O(1), 2 �����
+	char left_symbol{ text[0] }; // O(1), 1 ����
+	short int text_length = text.length(); // O(1), 2 ����� (���������������� ��������� O(1) ��������� ������������ ����� ������ 10000 ��������, ��� ������ 2^15-1)
+	compressed_text.reserve(2 * text_length); // O(1)
+
+	for (short int i = 1; i <= text_length; i++) { // O(N); ������ O(K), max(40, 1+log(��_1) + ... + 1+log(��_K)) ����
+
+		count++; // O(1)
+
+		if (text[i] != left_symbol) { // O(1)
+			compressed_text.push_back(left_symbol); // O(1)
+			if (count != 1) {
+				compressed_text += std::to_string(count); // O(1+1) ��� O(M + log(count)) � ������ ������, M - ����� �������������� ������, log(count) - ���������� �������� count.
+			}
+			left_symbol = text[i]; // O(1)
+			count = 0; // O(1)
+
+		}
+	}
+
+	return compressed_text;
+
+}
+// �������� ������� ������ (����� ��������): max(40, 1+log(��_1) + ... + 1+log(��_K)) + 2 + 1 + 2 = max(40, 1+log(��_1) + ... + 1+log(��_K)) + 5 ����
+// �������� ������� ������ � �����: max(40, 1+log(��_1) + ... + 1+log(��_K)) + 2 + 1 + 2 + max(40, N) = max(40, 1+log(��_1) + ... + 1+log(��_K)) + max(40, N) + 5 ����
+// �������� ��������� ��������� O(N), ���������������� - O(K)
+
+int main() {
+	std::string test_str;
+	std::string expected;
+
+	// ���� 1 �� �������
+	test_str = "aaabb";
+	expected = "a3b2";
+	assert(compression(test_str) == expected);
+
+	// ���� 2 
+	test_str = "wwwwtttttssssshhhhhhhhhh";
+	expected = "w4t5s5h10";
+	assert(compression(test_str) == expected);
+
+	// ���� 3 � ���������� ���������
+	test_str = "qwwwwghtttttsssssfhhhhhhq";
+	expected = "qw4ght5s5fh6q";
+	assert(compression(test_str) == expected);
+
+	// ���� 4 ������ � ���������� ���������
+	test_str = "qwertyuiopasdf";
+	expected = "qwertyuiopasdf";
+	assert(compression(test_str) == expected);
+
+	// ���� 5 � ������ �������
+	test_str = "";
+	expected = "";
+	assert(compression(test_str) == expected);
+
+	// ���� 6 � �������������������� ������ ������ 9
+	test_str = "qqqqqqqqqqqyuuuuiiiiiiiiiiiiii";
+	expected = "q11yu4i14";
+	assert(compression(test_str) == expected);
+
+	std::cout << "All tests completed successfully" << std::endl;
+}