From 7154dec118ff52f21f02e22ba7eab1fb2a80ce16 Mon Sep 17 00:00:00 2001 From: Radiy Date: Fri, 21 Nov 2025 17:19:07 +0500 Subject: [PATCH 01/37] add (solution): add addition task --- .gitignore | 2 ++ 01_week/tasks/addition/addition.cpp | 4 ++-- 2 files changed, 4 insertions(+), 2 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..cec5a363 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +/build +/build-asan diff --git a/01_week/tasks/addition/addition.cpp b/01_week/tasks/addition/addition.cpp index 92872802..cf0b78cf 100644 --- a/01_week/tasks/addition/addition.cpp +++ b/01_week/tasks/addition/addition.cpp @@ -3,5 +3,5 @@ int64_t Addition(int a, int b) { - throw std::runtime_error{"Not implemented"}; -} \ No newline at end of file + return static_cast(a) + static_cast(b); +} From 4141f23ff6a9c850cd2933433e37ee5110dec93c Mon Sep 17 00:00:00 2001 From: Radiy Date: Mon, 24 Nov 2025 18:26:38 +0500 Subject: [PATCH 02/37] wip (solution): wip char_changer task --- 01_week/tasks/char_changer/char_changer.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/01_week/tasks/char_changer/char_changer.cpp b/01_week/tasks/char_changer/char_changer.cpp index 3a7344d9..fef06932 100644 --- a/01_week/tasks/char_changer/char_changer.cpp +++ b/01_week/tasks/char_changer/char_changer.cpp @@ -3,5 +3,14 @@ size_t CharChanger(char array[], size_t size, char delimiter = ' ') { + size_t convertedSymbol = 0; currentSybmol + + for (size_t i = 0; i < size; ++i) { + if (!isalpha(array[])) { + + } + } + + throw std::runtime_error{"Not implemented"}; } From 16fe4e3cf5026c292170c7d31ab7f35aaf2114ad Mon Sep 17 00:00:00 2001 From: Radiy Date: Tue, 25 Nov 2025 18:01:54 +0500 Subject: [PATCH 03/37] add (solution): add char_changer task --- 01_week/tasks/char_changer/char_changer.cpp | 77 +++++++++++++++++++-- 1 file changed, 72 insertions(+), 5 deletions(-) diff --git a/01_week/tasks/char_changer/char_changer.cpp b/01_week/tasks/char_changer/char_changer.cpp index fef06932..bb92525d 100644 --- a/01_week/tasks/char_changer/char_changer.cpp +++ b/01_week/tasks/char_changer/char_changer.cpp @@ -1,16 +1,83 @@ #include #include +// Есть ощущение, что это можно решить как-то более лаконично и просто + +/** + * @brief Получить длину последовательности из одинаковых знаков. + * @param array указатель на элемент массива, с которого начнется проверка. + * @return Длина последовательности. + * @note Все символы будут сравниваться с первым из переданного массива. + */ +size_t GetIdenticalCharSequenceLen(char *array) { + size_t sequenceLen = 0; + + if (array[0] == '\0') { + return 0; + } + + while (array[0] == array[sequenceLen]) { + ++sequenceLen; + } + + return sequenceLen; +} + +/** + * @brief Сконвертировать одинаковые символы. + * @param array указатель на начало обрабатываемого массива. + * @param convertedSymIdx ссылка на индекс последнего сконвертированного символа. + * @param currentSymIdx ссылка на индекс текущего обрабатываемого символа. + * @param swapChar знак, на который будет произведена замена array[convertedSymIdx]. + * @return none + */ +void ConvertIdenticalCharacters(char array[], size_t& convertedSymIdx, size_t& currentSymIdx, char swapChar) { + size_t sequenceLen = GetIdenticalCharSequenceLen(&array[currentSymIdx]); + + array[convertedSymIdx++] = swapChar; + + if (sequenceLen == 1) { + currentSymIdx += sequenceLen; + return; + } + + if (sequenceLen >= 10) { + array[convertedSymIdx++] = '0'; + } else { + array[convertedSymIdx++] = sequenceLen + '0'; + } + + currentSymIdx += sequenceLen; +} size_t CharChanger(char array[], size_t size, char delimiter = ' ') { - size_t convertedSymbol = 0; currentSybmol + size_t convertedSymbolIdx = 0, currentSymbolIdx = 0; + + while(currentSymbolIdx < size && convertedSymbolIdx < size) { + if (array[currentSymbolIdx] == '\0') { + break; + } - for (size_t i = 0; i < size; ++i) { - if (!isalpha(array[])) { + if (isspace(array[currentSymbolIdx])) { + currentSymbolIdx += GetIdenticalCharSequenceLen(&array[currentSymbolIdx]); + + array[convertedSymbolIdx++] = delimiter; + continue; + } + + if (isalnum(array[currentSymbolIdx])) { + if (isdigit(array[currentSymbolIdx])) { + ConvertIdenticalCharacters(array, convertedSymbolIdx, currentSymbolIdx, '*'); + continue; + } + ConvertIdenticalCharacters(array, convertedSymbolIdx, currentSymbolIdx, toupper(array[currentSymbolIdx])); + continue; } - } + ConvertIdenticalCharacters(array, convertedSymbolIdx, currentSymbolIdx, '_'); + } - throw std::runtime_error{"Not implemented"}; + array[convertedSymbolIdx] = '\0'; + return convertedSymbolIdx; } From e6233b86c16e514cbdaa67dee96b644f777ec869 Mon Sep 17 00:00:00 2001 From: Radiy Date: Wed, 26 Nov 2025 11:57:47 +0500 Subject: [PATCH 04/37] add (solution): add check_flags task --- 01_week/tasks/check_flags/check_flags.cpp | 45 ++++++++++++++++++++++- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/01_week/tasks/check_flags/check_flags.cpp b/01_week/tasks/check_flags/check_flags.cpp index 75e7c652..a9a5f1f0 100644 --- a/01_week/tasks/check_flags/check_flags.cpp +++ b/01_week/tasks/check_flags/check_flags.cpp @@ -1,6 +1,6 @@ #include #include - +#include enum class CheckFlags : uint8_t { NONE = 0, @@ -13,6 +13,47 @@ enum class CheckFlags : uint8_t { ALL = TIME | DATE | USER | CERT | KEYS | DEST }; +// В данном случае можно было использовать map, но с ним придется использовать +// static_cast. Так же map отсортирует значения по возрасанию, соответственно +// использовать enum написанный иначе будет невозможно. +const std::vector> checkNames = { + {CheckFlags::TIME, "TIME"}, + {CheckFlags::DATE, "DATE"}, + {CheckFlags::USER, "USER"}, + {CheckFlags::CERT, "CERT"}, + {CheckFlags::KEYS, "KEYS"}, + {CheckFlags::DEST, "DEST"}, +}; + void PrintCheckFlags(CheckFlags flags) { - throw std::runtime_error{"Not implemented"}; + if (flags > CheckFlags::ALL) { + return; + } + + std::string needed_checks = "["; + + if (flags == CheckFlags::NONE) { + needed_checks += "]"; // Такая модификация происходит inplace, не + // создавая дорогостоящие копии + std::cout << needed_checks; + return; + } + + bool first = true; + for (const auto& [key, val] : checkNames) { + if (static_cast(flags) & static_cast(key)) { + if (!first) { + needed_checks += ","; // добавляем запятую перед элементом, а не после, + // проверяя на первый элемент, это гарантирует, что лишних + // запятых не будет + } + + needed_checks += val; + first = false; + } + } + + needed_checks += "]"; + + std::cout << needed_checks; } From 520f1f21379097428f059ecf8d1b40cfc2b7a325 Mon Sep 17 00:00:00 2001 From: Radiy Date: Wed, 26 Nov 2025 17:04:16 +0500 Subject: [PATCH 05/37] add (solution): add length_lit task --- 01_week/tasks/length_lit/length_lit.cpp | 51 +++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/01_week/tasks/length_lit/length_lit.cpp b/01_week/tasks/length_lit/length_lit.cpp index e69de29b..a5bfb87c 100644 --- a/01_week/tasks/length_lit/length_lit.cpp +++ b/01_week/tasks/length_lit/length_lit.cpp @@ -0,0 +1,51 @@ +constexpr long double METER_IN_FOOT = 0.3048; +constexpr long double INCH_IN_FOOT = 12; +constexpr long double METER_IN_INCH = 0.0254; + +constexpr long double operator""_ft_to_m(long double foot) { + return foot * METER_IN_FOOT; +} + +constexpr long double operator""_m_to_ft(long double meter) { + return meter / METER_IN_FOOT; +} + +constexpr long double operator""_ft_to_cm(long double foot) { + return foot * METER_IN_FOOT * 100; +} + +constexpr long double operator""_cm_to_ft(long double cm) { + return cm / (METER_IN_FOOT * 100); +} + +constexpr long double operator""_ft_to_in(long double foot) { + return foot * INCH_IN_FOOT; +} + +constexpr long double operator""_in_to_ft(long double inch) { + return inch / INCH_IN_FOOT; +} + +constexpr long double operator""_in_to_m(long double inch) { + return inch * METER_IN_INCH; +} + +constexpr long double operator""_m_to_in(long double meter) { + return meter / METER_IN_INCH; +} + +constexpr long double operator""_in_to_cm(long double inch) { + return inch * METER_IN_INCH * 100; +} + +constexpr long double operator""_cm_to_in(long double inch) { + return inch / (METER_IN_INCH * 100); +} + +constexpr long double operator""_m_to_cm(long double meter) { + return meter * 100; +} + +constexpr long double operator""_cm_to_m(long double cm) { + return cm / 100; +} From 057cea08900b18fc14fa4817032f33437ac647df Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 27 Nov 2025 14:39:30 +0500 Subject: [PATCH 06/37] add (solution): add print_bits task --- 01_week/tasks/print_bits/print_bits.cpp | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/01_week/tasks/print_bits/print_bits.cpp b/01_week/tasks/print_bits/print_bits.cpp index a48a43c1..3db2d6ab 100644 --- a/01_week/tasks/print_bits/print_bits.cpp +++ b/01_week/tasks/print_bits/print_bits.cpp @@ -1,7 +1,17 @@ #include #include - +#include void PrintBits(long long value, size_t bytes) { - throw std::runtime_error{"Not implemented"}; + std::string byteForm = "0b"; + // i < bytes * 8 сработает, потому что 0ULL - 1 переполняется в ULL_MAX + for (size_t i = (bytes * 8 - 1); i < bytes * 8; --i) { + byteForm += ((value >> i) & 0x01U) + '0'; + + if (i != 0 && i % 4 == 0) { + byteForm += "'"; + } + } + + std::cout << byteForm << std::endl; } From 5af29501a016fb7a69ca33d08cfbe63bdabd1c94 Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 27 Nov 2025 16:05:30 +0500 Subject: [PATCH 07/37] add (solution): add rms task --- 01_week/tasks/quadratic/quadratic.cpp | 64 +++++++++++++++++++++++++-- 01_week/tasks/rms/rms.cpp | 17 +++++-- 2 files changed, 74 insertions(+), 7 deletions(-) diff --git a/01_week/tasks/quadratic/quadratic.cpp b/01_week/tasks/quadratic/quadratic.cpp index abf7d632..9d3d58ba 100644 --- a/01_week/tasks/quadratic/quadratic.cpp +++ b/01_week/tasks/quadratic/quadratic.cpp @@ -1,6 +1,64 @@ #include +#include +#include +// Уверен, что это можно сделать значительно качественнее, но дедлайн близко, +// поэтому спагетти код >:) -void SolveQuadratic(int a, int b, int c) { - throw std::runtime_error{"Not implemented"}; -} \ No newline at end of file +void SolveQuadratic(int a, int b, int c) { + if (!a && !b && !c) { + std::cout << "infinite solutions"; + return; + } + + if (!a && !b) { + std::cout << "no solutions"; + return; + } + + std::cout << std::setprecision(6); + + if (!a) { + std::cout << (static_cast(-c) / b); + return; + } + + if (!b) { + if (static_cast(-c) / a < 0) { + std::cout << "no solutions"; + return; + } + + double root = std::sqrt(static_cast(-c) / a); + + if (root == 0) { + std::cout << root; + } else { + std::cout << -root << " " << root; + } + + return; + } + + double d = static_cast(b) * b - 4.0 * a * c; + double x1 = 0.0, x2 = 0.0; + + if (d < 0) { + std::cout << "no solutions"; + return; + } + + if (d > 0) { + x1 = ((-b - std::sqrt(d)) / (2.0 * a)); + x2 = ((-b + std::sqrt(d)) / (2.0 * a)); + + if (x1 > x2) { + std::cout << x2 << " " << x1; + } else { + std::cout << x1 << " " << x2; + } + return; + } + + std::cout << -b / (2.0 * a); +} diff --git a/01_week/tasks/rms/rms.cpp b/01_week/tasks/rms/rms.cpp index 6882f0a9..64cf032f 100644 --- a/01_week/tasks/rms/rms.cpp +++ b/01_week/tasks/rms/rms.cpp @@ -1,7 +1,16 @@ -#include +#include #include - +#include double CalculateRMS(double values[], size_t size) { - throw std::runtime_error{"Not implemented"}; -} \ No newline at end of file + if (size == 0 || values == NULL) { + return 0.0; + } + + double sum = 0.0; + for (size_t i = 0; i < size; ++i) { + sum += values[i] * values[i]; + } + + return std::sqrt(sum / static_cast(size)); +} From 706b6093330a8d2381f9dff61c22e273a525eb5d Mon Sep 17 00:00:00 2001 From: Radiy Date: Fri, 5 Dec 2025 17:00:05 +0500 Subject: [PATCH 08/37] add (solution): add swap_ptr task --- 02_week/tasks/swap_ptr/swap_ptr.cpp | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/02_week/tasks/swap_ptr/swap_ptr.cpp b/02_week/tasks/swap_ptr/swap_ptr.cpp index 93db625d..ffaf09dc 100644 --- a/02_week/tasks/swap_ptr/swap_ptr.cpp +++ b/02_week/tasks/swap_ptr/swap_ptr.cpp @@ -1,6 +1,21 @@ #include +template +void SwapPtr(T &ptr1, T &ptr2) { + T tmp = ptr1; + ptr1 = ptr2; + ptr2 = tmp; +} -void SwapPtr(/* write arguments here */) { - throw std::runtime_error{"Not implemented"}; -} \ No newline at end of file +// Можно сделать перегрузкой, но мы же любим компактность :) +//void SwapPtr(const int* &ptr1, const int* &ptr2) { +// const int* tmp = ptr1; +// ptr1 = ptr2; +// ptr2 = tmp; +//} + +//void SwapPtr(int** &ptr1, int** &ptr2) { +// int** tmp = ptr1; +// ptr1 = ptr2; +// ptr2 = tmp; +//} From 6d51ad2a5cf8d376590e7536ef9680128391fe89 Mon Sep 17 00:00:00 2001 From: Radiy Date: Fri, 5 Dec 2025 17:33:41 +0500 Subject: [PATCH 09/37] add (solution): add last_of_us task --- 02_week/tasks/last_of_us/last_of_us.cpp | 26 ++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/02_week/tasks/last_of_us/last_of_us.cpp b/02_week/tasks/last_of_us/last_of_us.cpp index c7bf1a25..fa59bff9 100644 --- a/02_week/tasks/last_of_us/last_of_us.cpp +++ b/02_week/tasks/last_of_us/last_of_us.cpp @@ -1,6 +1,26 @@ #include +typedef bool (*predicate_func_t)(int); -/* return_type */ FindLastElement(/* ptr_type */ begin, /* ptr_type */ end, /* func_type */ predicate) { - throw std::runtime_error{"Not implemented"}; -} \ No newline at end of file +const int* FindLastElement(const int* begin, const int* end, predicate_func_t predicate) { + if (begin == nullptr || end == nullptr) { + return end; + } + + if (begin >= end) { + return end; + } + + const int* result = end; + + // begin и end передаются by copy, так что инкремент указателя + // не повлияет на переданный указатель + while (begin != end) { + if (predicate(*begin)) { + result = begin; + } + ++begin; + } + + return result; +} From 6a457164378f774241a97aec331365782bf097f0 Mon Sep 17 00:00:00 2001 From: Radiy Date: Sat, 6 Dec 2025 15:34:39 +0500 Subject: [PATCH 10/37] add (solution): add func_array task --- 02_week/tasks/func_array/func_array.cpp | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/02_week/tasks/func_array/func_array.cpp b/02_week/tasks/func_array/func_array.cpp index b327e68d..68b25cef 100644 --- a/02_week/tasks/func_array/func_array.cpp +++ b/02_week/tasks/func_array/func_array.cpp @@ -1,6 +1,19 @@ #include +typedef double(*operations_t)(double, double); -double ApplyOperations(double a, double b /* other arguments */) { - throw std::runtime_error{"Not implemented"}; -} \ No newline at end of file +double ApplyOperations(double a, double b, operations_t mathOperations[], size_t size) { + if (size == 0 || mathOperations == nullptr) { + return 0.0; + } + + double sum = 0.0; + + for (size_t i = 0; i < size; ++i) { + if (mathOperations[i] != nullptr) { + sum += mathOperations[i](a, b); + } + } + + return sum; +} From 3febd0641b6d4e05a55ad4f32d760951101816fe Mon Sep 17 00:00:00 2001 From: Radiy Date: Sat, 6 Dec 2025 16:28:16 +0500 Subject: [PATCH 11/37] add (solution): add longest task --- 02_week/tasks/longest/longest.cpp | 41 +++++++++++++++++++++++++++++-- 1 file changed, 39 insertions(+), 2 deletions(-) diff --git a/02_week/tasks/longest/longest.cpp b/02_week/tasks/longest/longest.cpp index 04b3c354..12b87b36 100644 --- a/02_week/tasks/longest/longest.cpp +++ b/02_week/tasks/longest/longest.cpp @@ -1,6 +1,43 @@ #include -/* return_type */ FindLongestSubsequence(/* ptr_type */ begin, /* ptr_type */ end, /* type */ count) { - throw std::runtime_error{"Not implemented"}; +const char* FindLongestSubsequence(const char* begin, const char* end, size_t& count) { + if (begin == nullptr || end == nullptr) { + count = 0; + return nullptr; + } + + if (begin >= end) { + count = 0; + return nullptr; + } + + size_t currSequenseLen = 0; + const char* longestSequenceStart = begin; + + while (begin != end) { + currSequenseLen++; + + if (*begin != *(begin + 1)) { + if (currSequenseLen > count) { + count = currSequenseLen; + longestSequenceStart = begin - (currSequenseLen - 1); + } + currSequenseLen = 0; + } + + ++begin; + } + + return longestSequenceStart; +} + +char* FindLongestSubsequence(char* begin, char* end, size_t& count) { + const char* result = FindLongestSubsequence( + static_cast(begin), + static_cast(end), + count + ); + + return const_cast(result); } From cc1236417d6faa77199514336d3a2fc9d5cee6f5 Mon Sep 17 00:00:00 2001 From: Radiy Date: Mon, 8 Dec 2025 15:11:37 +0500 Subject: [PATCH 12/37] add (solution): add little_big task --- 02_week/tasks/little_big/little_big.cpp | 33 +++++++++++++++++++------ 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/02_week/tasks/little_big/little_big.cpp b/02_week/tasks/little_big/little_big.cpp index abe24379..2506fe16 100644 --- a/02_week/tasks/little_big/little_big.cpp +++ b/02_week/tasks/little_big/little_big.cpp @@ -1,10 +1,29 @@ -#include +#include +#include +template +void PrintMemory(T num, bool isReversed = false) { + std::string output = ""; -void PrintMemory(int /* write arguments here */) { - throw std::runtime_error{"Not implemented"}; -} + // Надеюсь использование memcpy разрешено + unsigned char bytes[sizeof(T)]; + std::memcpy(bytes, &num, sizeof(T)); + + size_t start = isReversed ? (sizeof(T) - 1) : 0; + int step = isReversed ? -1 : 1; + + for (size_t i = start; i < sizeof(T); i += step) { + unsigned char currentByte = bytes[i]; + + for (int j = 4; j >= 0; j -= 4) { + int remainder = (currentByte >> j) & 0xf; + char hexChar = 0; -void PrintMemory(double /* write arguments here */) { - throw std::runtime_error{"Not implemented"}; -} \ No newline at end of file + hexChar = remainder < 10 ? '0' + remainder : 'A' + (remainder - 10); + + output += hexChar; + } + } + output = "0x" + output; + std::cout << output << std::endl; +} From 1aaa0c9991efb803ea229a5f93548386cb211f75 Mon Sep 17 00:00:00 2001 From: Radiy Date: Mon, 8 Dec 2025 15:59:21 +0500 Subject: [PATCH 13/37] add (solution): add pretty_array task --- 02_week/tasks/pretty_array/pretty_array.cpp | 37 +++++++++++++++++++-- 1 file changed, 34 insertions(+), 3 deletions(-) diff --git a/02_week/tasks/pretty_array/pretty_array.cpp b/02_week/tasks/pretty_array/pretty_array.cpp index 48eab341..15895d31 100644 --- a/02_week/tasks/pretty_array/pretty_array.cpp +++ b/02_week/tasks/pretty_array/pretty_array.cpp @@ -1,6 +1,37 @@ +#include #include +#include -void PrintArray(/* write arguments here */) { - throw std::runtime_error{"Not implemented"}; -} \ No newline at end of file +void PrintArray(const int* begin, const int* end, int constrainer = 0) { + if (begin == nullptr || end == nullptr) { + std::cout << "[]" << std::endl; + return; + } + + std::string output = "["; + + size_t size = std::abs(begin - end); + + const int* arr = begin > end ? end + 1 : begin; + size_t startIndex = begin > end ? size - 1 : 0; + int step = begin > end ? -1 : 1; + size_t charCntr = 0; + + for (size_t i = startIndex; i < size; i += step) { + if (i != startIndex) { + output.append(", "); + if ((constrainer > 0) && (charCntr % constrainer == 0)) { + output.append("...\n "); + charCntr = 0; + } + } + + output.append(std::to_string(arr[i])); + charCntr++; + } + + output += "]"; + + std::cout << output << std::endl; +} From 12fe9b938308e705303fe83082393b0b3b9715d5 Mon Sep 17 00:00:00 2001 From: Radiy Date: Sun, 14 Dec 2025 23:04:03 +0500 Subject: [PATCH 14/37] add (solution): add data_stats task --- 03_week/tasks/data_stats/data_stats.cpp | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/03_week/tasks/data_stats/data_stats.cpp b/03_week/tasks/data_stats/data_stats.cpp index b941c211..3a29de14 100644 --- a/03_week/tasks/data_stats/data_stats.cpp +++ b/03_week/tasks/data_stats/data_stats.cpp @@ -1,11 +1,27 @@ -#include - +#include +#include struct DataStats { double avg = 0.0; double sd = 0.0; }; -/* return_type */ CalculateDataStats(/* args */) { - throw std::runtime_error{"Not implemented"}; +struct DataStats CalculateDataStats(const std::vector &v) { + if (v.empty()) { + return {0.0, 0.0}; + } + + long sum = 0; + long sumSq = 0; + + for (auto val : v) { + sum += val; + sumSq += static_cast(val) * val; + } + + auto n = v.size(); + double avg = static_cast(sum) / n; + double variance = (sumSq - (static_cast(sum) * sum) / n) / n; + + return { avg, std::sqrt(variance) }; } From 45ed16c796052db0d8874dcc7e21bd144da196f1 Mon Sep 17 00:00:00 2001 From: Radiy Date: Mon, 15 Dec 2025 16:55:09 +0500 Subject: [PATCH 15/37] add (solution): add easy_compare task --- 03_week/tasks/easy_compare/easy_compare.cpp | 51 ++++++++++++++++++++- 1 file changed, 49 insertions(+), 2 deletions(-) diff --git a/03_week/tasks/easy_compare/easy_compare.cpp b/03_week/tasks/easy_compare/easy_compare.cpp index dd5cb7f6..a84d6e43 100644 --- a/03_week/tasks/easy_compare/easy_compare.cpp +++ b/03_week/tasks/easy_compare/easy_compare.cpp @@ -1,10 +1,38 @@ #include - +#include struct Date { unsigned year; unsigned month; unsigned day; + + bool operator==(const Date& other) const { + return std::tie(year, month, day) == std::tie(other.year, other.month, other.day); + } + + bool operator!=(const Date& other) const { + return !(*this == other); + } + + bool operator<(const Date& other) const { + return std::tie(year, month, day) < std::tie(other.year, other.month, other.day); + } + + bool operator>(const Date& other) const { + if (*this == other) { + return false; + } + + return !(*this < other); + } + + bool operator<=(const Date& other) { + return !(*this > other); + } + + bool operator>=(const Date& other) { + return !(*this < other); + } }; struct StudentInfo { @@ -13,4 +41,23 @@ struct StudentInfo { int score; unsigned course; Date birth_date; -}; \ No newline at end of file + + bool operator==(const StudentInfo& other) const { + return mark == other.mark && score == other.score; + } + + bool operator!=(const StudentInfo& other) const { + return !(*this == other); + } + + bool operator<(const StudentInfo& other) const { + // обратный знак, так как A < Z в таблице символов + return std::tie(other.mark, score, other.course, birth_date) < std::tie(mark, other.score, course, other.birth_date); + // if (mark != other.mark) return mark > other.mark; + // if (score != other.score) return score < other.score; + // if (course != other.course) return course > other.course; + // return birth_date < other.birth_date; + } +}; + + From 44d87621215980b44e13f197e381595e014c8c14 Mon Sep 17 00:00:00 2001 From: Radiy Date: Mon, 15 Dec 2025 17:11:51 +0500 Subject: [PATCH 16/37] add (solution): add find_all task --- 03_week/tasks/find_all/find_all.cpp | 22 +++++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/03_week/tasks/find_all/find_all.cpp b/03_week/tasks/find_all/find_all.cpp index 74f393b2..252f2b15 100644 --- a/03_week/tasks/find_all/find_all.cpp +++ b/03_week/tasks/find_all/find_all.cpp @@ -1,6 +1,22 @@ #include +typedef bool (*Predicate)(int); -/* return_type */ FindAll(/* args */) { - throw std::runtime_error{"Not implemented"}; -} \ No newline at end of file +std::vector FindAll(const std::vector &v, Predicate predicate_func) { + if (v.empty() || predicate_func == nullptr) { + return {}; + } + + std::vector output; + output.reserve(v.size()); + + for (size_t i = 0; i < v.size(); ++i) { + if (predicate_func(v[i])) { + output.push_back(i); + } + } + + output.shrink_to_fit(); + + return output; +} From 8504d0e3b1f5ee1343e641783682a5a2effbe7d2 Mon Sep 17 00:00:00 2001 From: Radiy Date: Mon, 15 Dec 2025 17:31:29 +0500 Subject: [PATCH 17/37] WIP task filter --- 03_week/tasks/filter/filter.cpp | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/03_week/tasks/filter/filter.cpp b/03_week/tasks/filter/filter.cpp index 6648cb39..d9ccd91e 100644 --- a/03_week/tasks/filter/filter.cpp +++ b/03_week/tasks/filter/filter.cpp @@ -1,6 +1,17 @@ #include +typedef bool (*Predicate)(int); -/* return_type */ Filter(/* args */) { - throw std::runtime_error{"Not implemented"}; -} \ No newline at end of file +void Filter(std::vector &v, Predicate predicateFunc) { + if (v.empty() || predicateFunc == nullptr) { + return; + } + + for (auto it = v.begin(); it != v.end();) { + if (predicateFunc(*it)) { + it = v.erase(it); + } else { + ++it; + } + } +} From 6b566ab49004acba0da9066e26aa2feaaaf22a29 Mon Sep 17 00:00:00 2001 From: Radiy Date: Wed, 17 Dec 2025 18:22:22 +0500 Subject: [PATCH 18/37] WIP enum operators --- .../tasks/enum_operators/enum_operators.cpp | 56 +++++++++++++++---- 1 file changed, 44 insertions(+), 12 deletions(-) diff --git a/03_week/tasks/enum_operators/enum_operators.cpp b/03_week/tasks/enum_operators/enum_operators.cpp index a539be38..5a23d1ae 100644 --- a/03_week/tasks/enum_operators/enum_operators.cpp +++ b/03_week/tasks/enum_operators/enum_operators.cpp @@ -1,5 +1,7 @@ -#include -#include +#include +#include +#include +#include enum class CheckFlags : uint8_t { NONE = 0, @@ -12,22 +14,52 @@ enum class CheckFlags : uint8_t { ALL = TIME | DATE | USER | CERT | KEYS | DEST }; -/* return_type */ operator|(/* args */) { - throw std::runtime_error{"Not implemented"}; +// Для GoogleTest +explicit operator bool(CheckFlags f) { + return static_cast>(f) != 0; } -/* return_type */ operator&(/* args */) { - throw std::runtime_error{"Not implemented"}; +bool operator!(const CheckFlags f) { + return static_cast>(f) == 0; } -/* return_type */ operator^(/* args */) { - throw std::runtime_error{"Not implemented"}; +bool operator==(CheckFlags lhs, CheckFlags rhs) { + return static_cast>(lhs) == + static_cast>(rhs); } -/* return_type */ operator~(/* args */) { - throw std::runtime_error{"Not implemented"}; +bool operator!=(CheckFlags lhs, CheckFlags rhs) { + return !(lhs == rhs); } -/* return_type */ operator<<(/* args */) { - throw std::runtime_error{"Not implemented"}; +CheckFlags operator|(CheckFlags lhs, CheckFlags rhs) { + return static_cast( + (static_cast>(lhs) | + static_cast>(rhs)) & static_cast>(CheckFlags::ALL) + ); +} + +CheckFlags operator&(CheckFlags lhs, CheckFlags rhs) { + auto uintLhs = static_cast>(lhs); + auto uintRhs = static_cast>(rhs); + + return static_cast(uintLhs & uintRhs); +} + +CheckFlags operator^(CheckFlags lhs, CheckFlags rhs) { + return static_cast( + static_cast>(lhs) ^ + static_cast>(rhs) + ); +} + +CheckFlags operator~(const CheckFlags& f) { + return static_cast(~static_cast>(f)); +} + +std::ostream& operator<<(std::ostream& os, const CheckFlags& f) { + if (f == CheckFlags::ALL) { + return os; + } + return os; } From d455bf1f1e50dcbf567f678014613600380cabee Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 18 Dec 2025 11:52:37 +0500 Subject: [PATCH 19/37] add (solution): add enum_operators task --- .../tasks/enum_operators/enum_operators.cpp | 71 +++++++++++++------ 1 file changed, 50 insertions(+), 21 deletions(-) diff --git a/03_week/tasks/enum_operators/enum_operators.cpp b/03_week/tasks/enum_operators/enum_operators.cpp index 5a23d1ae..61599cfc 100644 --- a/03_week/tasks/enum_operators/enum_operators.cpp +++ b/03_week/tasks/enum_operators/enum_operators.cpp @@ -1,7 +1,11 @@ +#include #include +#include #include +#include #include #include +#include enum class CheckFlags : uint8_t { NONE = 0, @@ -14,18 +18,26 @@ enum class CheckFlags : uint8_t { ALL = TIME | DATE | USER | CERT | KEYS | DEST }; -// Для GoogleTest -explicit operator bool(CheckFlags f) { - return static_cast>(f) != 0; +const std::vector> checkNames = { + {CheckFlags::TIME, "TIME"}, + {CheckFlags::DATE, "DATE"}, + {CheckFlags::USER, "USER"}, + {CheckFlags::CERT, "CERT"}, + {CheckFlags::KEYS, "KEYS"}, + {CheckFlags::DEST, "DEST"}, +}; + +std::underlying_type_t getVal(CheckFlags f) { + return static_cast>(f) & + static_cast>(CheckFlags::ALL); } bool operator!(const CheckFlags f) { - return static_cast>(f) == 0; + return getVal(f) == 0; } bool operator==(CheckFlags lhs, CheckFlags rhs) { - return static_cast>(lhs) == - static_cast>(rhs); + return getVal(lhs) == getVal(rhs); } bool operator!=(CheckFlags lhs, CheckFlags rhs) { @@ -33,33 +45,50 @@ bool operator!=(CheckFlags lhs, CheckFlags rhs) { } CheckFlags operator|(CheckFlags lhs, CheckFlags rhs) { - return static_cast( - (static_cast>(lhs) | - static_cast>(rhs)) & static_cast>(CheckFlags::ALL) - ); + return static_cast((getVal(lhs) | getVal(rhs)) & getVal(CheckFlags::ALL)); } -CheckFlags operator&(CheckFlags lhs, CheckFlags rhs) { - auto uintLhs = static_cast>(lhs); - auto uintRhs = static_cast>(rhs); +bool operator&(CheckFlags lhs, CheckFlags rhs) { + auto lhsVal = getVal(lhs); + auto rhsVal = getVal(rhs); + + if (lhsVal == 0 || rhsVal == 0) { + return false; + } - return static_cast(uintLhs & uintRhs); + return ((lhsVal & rhsVal) == lhsVal) || ((lhsVal & rhsVal) == rhsVal); } CheckFlags operator^(CheckFlags lhs, CheckFlags rhs) { - return static_cast( - static_cast>(lhs) ^ - static_cast>(rhs) - ); + return static_cast((getVal(lhs) ^ getVal(rhs)) & getVal(CheckFlags::ALL)); } CheckFlags operator~(const CheckFlags& f) { - return static_cast(~static_cast>(f)); + return static_cast((~getVal(f)) & getVal(CheckFlags::ALL)); } std::ostream& operator<<(std::ostream& os, const CheckFlags& f) { - if (f == CheckFlags::ALL) { + std::string needed_checks = ""; + + auto fVal = getVal(f); + + if (f == CheckFlags::NONE) { + os << "NONE"; return os; - } + } + + bool first = true; + for (const auto& [key, val] : checkNames) { + if (fVal & getVal(key)) { + if (!first) { + needed_checks += ", "; + } + + needed_checks += val; + first = false; + } + } + + os << needed_checks; return os; } From 7a87f24679e351e5beb75d302c8fa1db87bc74d1 Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 18 Dec 2025 12:22:23 +0500 Subject: [PATCH 20/37] add (solution): add unique task --- 03_week/tasks/unique/unique.cpp | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/03_week/tasks/unique/unique.cpp b/03_week/tasks/unique/unique.cpp index 9d2545bb..bec3950b 100644 --- a/03_week/tasks/unique/unique.cpp +++ b/03_week/tasks/unique/unique.cpp @@ -1,6 +1,18 @@ -#include #include -/* return_type */ Unique(/* args */) { - throw std::runtime_error{"Not implemented"}; +std::vector Unique(const std::vector& v) { + std::vector uniqueElem{}; + + uniqueElem.reserve(v.size()); + + + for (auto val : v) { + if (uniqueElem.empty() || (uniqueElem.back() != val)) { + uniqueElem.push_back(val); + } + } + + uniqueElem.shrink_to_fit(); + + return uniqueElem; } From 5afec6c6656b25ccafd210a95afb5a3adaff4266 Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 18 Dec 2025 13:15:27 +0500 Subject: [PATCH 21/37] add (solution): add range task --- 03_week/tasks/range/range.cpp | 32 +++++++++++++++++++++++++++++--- 1 file changed, 29 insertions(+), 3 deletions(-) diff --git a/03_week/tasks/range/range.cpp b/03_week/tasks/range/range.cpp index d2085495..fe27b102 100644 --- a/03_week/tasks/range/range.cpp +++ b/03_week/tasks/range/range.cpp @@ -1,7 +1,33 @@ -#include +#include +#include +#include #include -std::vector Range(int from, int to, int step) { - throw std::runtime_error{"Not implemented"}; +std::vector Range(int from, int to, int step = 1) { + std::vector range{}; + + if (step == 0) { + return range; + } + + if (step < 0 && from < to) { + return range; + } + + if (step > 0 && from > to) { + return range; + } + + auto absDiff = std::abs(from - to); + + range.reserve(std::ceil(std::abs(absDiff / static_cast(step)))); + + int val = from; + for (size_t i = 0; i < range.capacity(); ++i) { + range.push_back(val); + val += step; + } + + return range; } From 0c21b295324c2423d3ae8d2a62d36360c23052b5 Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 18 Dec 2025 14:20:02 +0500 Subject: [PATCH 22/37] add (solution): add os_overoad task --- 03_week/tasks/os_overload/os_overload.cpp | 64 ++++++++++++++++++++--- 1 file changed, 58 insertions(+), 6 deletions(-) diff --git a/03_week/tasks/os_overload/os_overload.cpp b/03_week/tasks/os_overload/os_overload.cpp index e473418d..b62c77e6 100644 --- a/03_week/tasks/os_overload/os_overload.cpp +++ b/03_week/tasks/os_overload/os_overload.cpp @@ -1,21 +1,73 @@ -#include +#include #include #include struct Coord2D { - int x; - int y; + int x = 0; + int y = 0; }; struct Circle { Coord2D coord; - unsigned radius; + unsigned radius = 1; }; using CircleRegion = std::pair; using CircleRegionList = std::vector; -/* return_type */ operator<<(/* args */) { - throw std::runtime_error{"Not implemented"}; + +std::ostream& operator<<(std::ostream& os, const Coord2D& coord) { + os << '(' << coord.x << ", " << coord.y << ')'; + + return os; +} + +std::ostream& operator<<(std::ostream& os, const Circle& c) { + + if (c.radius == 0) { + os << "circle[]"; + return os; + } + + os << "circle[" << c.coord << ", " << "r = " << c.radius << ']'; + + return os; +} + +std::ostream& operator<<(std::ostream& os, const CircleRegion& r) { + if (r.second == true) { + os << '+'; + } else { + os << '-'; + } + + os << r.first; + + return os; +} + +std::ostream& operator<<(std::ostream& os, const CircleRegionList& lst) { + if (lst.empty()) { + os << "{}"; + return os; + } + + os << "{"; + + bool first = true; + + for (auto val : lst) { + if (!first) { + os << ','; + } + + os << std::endl << '\t' << val; + + first = false; + } + + os << std::endl <<"}"; + + return os; } From 7bc19a16c773ff5920d481f00d31a6e145f7d864 Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 18 Dec 2025 14:48:57 +0500 Subject: [PATCH 23/37] add (solution): add minmax task --- 03_week/tasks/minmax/minmax.cpp | 28 +++++++++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/03_week/tasks/minmax/minmax.cpp b/03_week/tasks/minmax/minmax.cpp index c2869799..c7ddcbce 100644 --- a/03_week/tasks/minmax/minmax.cpp +++ b/03_week/tasks/minmax/minmax.cpp @@ -1,6 +1,28 @@ -#include +#include +#include +#include +std::pair::const_iterator, std::vector::const_iterator> MinMax(const std::vector& v) { + if (v.empty()) { + return {v.end(), v.end()}; + } -/* return_type */ MinMax(/* args */) { - throw std::runtime_error{"Not implemented"}; + auto minIt = v.begin(); + auto maxIt = v.end(); + int min = INT_MAX; + int max = INT_MIN; + + for (auto it = v.begin(); it != v.end(); ++it) { + if (*it < min) { + min = *it; + minIt = it; + } + + if (*it >= max) { + max = *it; + maxIt = it; + } + } + + return {minIt, maxIt}; } From f128b9ca2aefc7b8aa6cfc8c88eea076485ab7b1 Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 18 Dec 2025 14:50:45 +0500 Subject: [PATCH 24/37] removed 04_week tests --- 04_week/CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/04_week/CMakeLists.txt b/04_week/CMakeLists.txt index 0531237e..97b68f15 100644 --- a/04_week/CMakeLists.txt +++ b/04_week/CMakeLists.txt @@ -7,9 +7,9 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON) # Гарантирует использов set(EXAMPLES_DIR examples) # Определим переменную с именем директории set(TASKS_DIR tasks) -add_subdirectory(tasks) +# add_subdirectory(tasks) # Создать исполняемый файл для каждого примера if (BUILD_EXAMPLES_04_WEEK) # add_example(struct_examples ${EXAMPLES_DIR}/struct_examples.cpp) -endif() \ No newline at end of file +endif() From 42b81c6930f30131410b372ee0271a4c5befc9b3 Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 18 Dec 2025 15:08:18 +0500 Subject: [PATCH 25/37] add (solution): add filter task --- 03_week/tasks/filter/filter.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/03_week/tasks/filter/filter.cpp b/03_week/tasks/filter/filter.cpp index d9ccd91e..979f1c1e 100644 --- a/03_week/tasks/filter/filter.cpp +++ b/03_week/tasks/filter/filter.cpp @@ -1,4 +1,4 @@ -#include +#include typedef bool (*Predicate)(int); @@ -8,7 +8,7 @@ void Filter(std::vector &v, Predicate predicateFunc) { } for (auto it = v.begin(); it != v.end();) { - if (predicateFunc(*it)) { + if (!predicateFunc(*it)) { it = v.erase(it); } else { ++it; From 23e327eac06bdf07a0002b4f917ffadbd093efcb Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 18 Dec 2025 15:12:03 +0500 Subject: [PATCH 26/37] add (fix): add easy_compare task --- 03_week/tasks/easy_compare/easy_compare.cpp | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/03_week/tasks/easy_compare/easy_compare.cpp b/03_week/tasks/easy_compare/easy_compare.cpp index a84d6e43..7436856d 100644 --- a/03_week/tasks/easy_compare/easy_compare.cpp +++ b/03_week/tasks/easy_compare/easy_compare.cpp @@ -2,9 +2,9 @@ #include struct Date { - unsigned year; - unsigned month; - unsigned day; + unsigned year = 0; + unsigned month = 0; + unsigned day = 0; bool operator==(const Date& other) const { return std::tie(year, month, day) == std::tie(other.year, other.month, other.day); @@ -53,10 +53,6 @@ struct StudentInfo { bool operator<(const StudentInfo& other) const { // обратный знак, так как A < Z в таблице символов return std::tie(other.mark, score, other.course, birth_date) < std::tie(mark, other.score, course, other.birth_date); - // if (mark != other.mark) return mark > other.mark; - // if (score != other.score) return score < other.score; - // if (course != other.course) return course > other.course; - // return birth_date < other.birth_date; } }; From e81fc9cc1d2f595978393a244f1a52248031761c Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 18 Dec 2025 15:25:08 +0500 Subject: [PATCH 27/37] add (optimisation): add filter task --- 03_week/tasks/filter/filter.cpp | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/03_week/tasks/filter/filter.cpp b/03_week/tasks/filter/filter.cpp index 979f1c1e..64cc2779 100644 --- a/03_week/tasks/filter/filter.cpp +++ b/03_week/tasks/filter/filter.cpp @@ -6,12 +6,18 @@ void Filter(std::vector &v, Predicate predicateFunc) { if (v.empty() || predicateFunc == nullptr) { return; } - - for (auto it = v.begin(); it != v.end();) { - if (!predicateFunc(*it)) { - it = v.erase(it); - } else { - ++it; + + auto secondIt = v.begin(); + size_t newSize = 0; + for (auto it = v.begin(); it != v.end(); ++it) { + if (predicateFunc(*it)) { + if (it != secondIt) { + *secondIt = *it; + } + ++secondIt; + ++newSize; } } + + v.resize(newSize); } From 83f3bcebd2f90382a58aaad5336b616e587da47b Mon Sep 17 00:00:00 2001 From: Radiy Date: Fri, 19 Dec 2025 17:34:40 +0500 Subject: [PATCH 28/37] Removed CMakeLists backups --- 04_week/CMakeLists_BACKUP_1018.txt | 20 -------------------- 04_week/CMakeLists_BACKUP_946.txt | 20 -------------------- 04_week/CMakeLists_BASE_1018.txt | 15 --------------- 04_week/CMakeLists_BASE_946.txt | 15 --------------- 04_week/CMakeLists_LOCAL_1018.txt | 15 --------------- 04_week/CMakeLists_LOCAL_946.txt | 15 --------------- 04_week/CMakeLists_REMOTE_1018.txt | 15 --------------- 04_week/CMakeLists_REMOTE_946.txt | 15 --------------- 8 files changed, 130 deletions(-) delete mode 100644 04_week/CMakeLists_BACKUP_1018.txt delete mode 100644 04_week/CMakeLists_BACKUP_946.txt delete mode 100644 04_week/CMakeLists_BASE_1018.txt delete mode 100644 04_week/CMakeLists_BASE_946.txt delete mode 100644 04_week/CMakeLists_LOCAL_1018.txt delete mode 100644 04_week/CMakeLists_LOCAL_946.txt delete mode 100644 04_week/CMakeLists_REMOTE_1018.txt delete mode 100644 04_week/CMakeLists_REMOTE_946.txt diff --git a/04_week/CMakeLists_BACKUP_1018.txt b/04_week/CMakeLists_BACKUP_1018.txt deleted file mode 100644 index f49b3f42..00000000 --- a/04_week/CMakeLists_BACKUP_1018.txt +++ /dev/null @@ -1,20 +0,0 @@ -cmake_minimum_required(VERSION 3.14) # Минимальная требуемая версия CMake -project(04_week) # Необходим для инициализации cmake - -set(CMAKE_CXX_STANDARD 20) # Версия стандарта C++ -set(CMAKE_CXX_STANDARD_REQUIRED ON) # Гарантирует использование указанной версии стандарта - -set(EXAMPLES_DIR examples) # Определим переменную с именем директории -set(TASKS_DIR tasks) - -# add_subdirectory(tasks) - -# Создать исполняемый файл для каждого примера -if (BUILD_EXAMPLES_04_WEEK) -<<<<<<< HEAD -# add_example(struct_examples ${EXAMPLES_DIR}/struct_examples.cpp) -endif() -======= -# add_example(class_examples ${EXAMPLES_DIR}/class_examples.cpp) -endif() ->>>>>>> 03c8f52452515f446a786675ecaff9cf59a0f216 diff --git a/04_week/CMakeLists_BACKUP_946.txt b/04_week/CMakeLists_BACKUP_946.txt deleted file mode 100644 index f49b3f42..00000000 --- a/04_week/CMakeLists_BACKUP_946.txt +++ /dev/null @@ -1,20 +0,0 @@ -cmake_minimum_required(VERSION 3.14) # Минимальная требуемая версия CMake -project(04_week) # Необходим для инициализации cmake - -set(CMAKE_CXX_STANDARD 20) # Версия стандарта C++ -set(CMAKE_CXX_STANDARD_REQUIRED ON) # Гарантирует использование указанной версии стандарта - -set(EXAMPLES_DIR examples) # Определим переменную с именем директории -set(TASKS_DIR tasks) - -# add_subdirectory(tasks) - -# Создать исполняемый файл для каждого примера -if (BUILD_EXAMPLES_04_WEEK) -<<<<<<< HEAD -# add_example(struct_examples ${EXAMPLES_DIR}/struct_examples.cpp) -endif() -======= -# add_example(class_examples ${EXAMPLES_DIR}/class_examples.cpp) -endif() ->>>>>>> 03c8f52452515f446a786675ecaff9cf59a0f216 diff --git a/04_week/CMakeLists_BASE_1018.txt b/04_week/CMakeLists_BASE_1018.txt deleted file mode 100644 index 0531237e..00000000 --- a/04_week/CMakeLists_BASE_1018.txt +++ /dev/null @@ -1,15 +0,0 @@ -cmake_minimum_required(VERSION 3.14) # Минимальная требуемая версия CMake -project(04_week) # Необходим для инициализации cmake - -set(CMAKE_CXX_STANDARD 20) # Версия стандарта C++ -set(CMAKE_CXX_STANDARD_REQUIRED ON) # Гарантирует использование указанной версии стандарта - -set(EXAMPLES_DIR examples) # Определим переменную с именем директории -set(TASKS_DIR tasks) - -add_subdirectory(tasks) - -# Создать исполняемый файл для каждого примера -if (BUILD_EXAMPLES_04_WEEK) -# add_example(struct_examples ${EXAMPLES_DIR}/struct_examples.cpp) -endif() \ No newline at end of file diff --git a/04_week/CMakeLists_BASE_946.txt b/04_week/CMakeLists_BASE_946.txt deleted file mode 100644 index 0531237e..00000000 --- a/04_week/CMakeLists_BASE_946.txt +++ /dev/null @@ -1,15 +0,0 @@ -cmake_minimum_required(VERSION 3.14) # Минимальная требуемая версия CMake -project(04_week) # Необходим для инициализации cmake - -set(CMAKE_CXX_STANDARD 20) # Версия стандарта C++ -set(CMAKE_CXX_STANDARD_REQUIRED ON) # Гарантирует использование указанной версии стандарта - -set(EXAMPLES_DIR examples) # Определим переменную с именем директории -set(TASKS_DIR tasks) - -add_subdirectory(tasks) - -# Создать исполняемый файл для каждого примера -if (BUILD_EXAMPLES_04_WEEK) -# add_example(struct_examples ${EXAMPLES_DIR}/struct_examples.cpp) -endif() \ No newline at end of file diff --git a/04_week/CMakeLists_LOCAL_1018.txt b/04_week/CMakeLists_LOCAL_1018.txt deleted file mode 100644 index 97b68f15..00000000 --- a/04_week/CMakeLists_LOCAL_1018.txt +++ /dev/null @@ -1,15 +0,0 @@ -cmake_minimum_required(VERSION 3.14) # Минимальная требуемая версия CMake -project(04_week) # Необходим для инициализации cmake - -set(CMAKE_CXX_STANDARD 20) # Версия стандарта C++ -set(CMAKE_CXX_STANDARD_REQUIRED ON) # Гарантирует использование указанной версии стандарта - -set(EXAMPLES_DIR examples) # Определим переменную с именем директории -set(TASKS_DIR tasks) - -# add_subdirectory(tasks) - -# Создать исполняемый файл для каждого примера -if (BUILD_EXAMPLES_04_WEEK) -# add_example(struct_examples ${EXAMPLES_DIR}/struct_examples.cpp) -endif() diff --git a/04_week/CMakeLists_LOCAL_946.txt b/04_week/CMakeLists_LOCAL_946.txt deleted file mode 100644 index 97b68f15..00000000 --- a/04_week/CMakeLists_LOCAL_946.txt +++ /dev/null @@ -1,15 +0,0 @@ -cmake_minimum_required(VERSION 3.14) # Минимальная требуемая версия CMake -project(04_week) # Необходим для инициализации cmake - -set(CMAKE_CXX_STANDARD 20) # Версия стандарта C++ -set(CMAKE_CXX_STANDARD_REQUIRED ON) # Гарантирует использование указанной версии стандарта - -set(EXAMPLES_DIR examples) # Определим переменную с именем директории -set(TASKS_DIR tasks) - -# add_subdirectory(tasks) - -# Создать исполняемый файл для каждого примера -if (BUILD_EXAMPLES_04_WEEK) -# add_example(struct_examples ${EXAMPLES_DIR}/struct_examples.cpp) -endif() diff --git a/04_week/CMakeLists_REMOTE_1018.txt b/04_week/CMakeLists_REMOTE_1018.txt deleted file mode 100644 index b15ca37c..00000000 --- a/04_week/CMakeLists_REMOTE_1018.txt +++ /dev/null @@ -1,15 +0,0 @@ -cmake_minimum_required(VERSION 3.14) # Минимальная требуемая версия CMake -project(04_week) # Необходим для инициализации cmake - -set(CMAKE_CXX_STANDARD 20) # Версия стандарта C++ -set(CMAKE_CXX_STANDARD_REQUIRED ON) # Гарантирует использование указанной версии стандарта - -set(EXAMPLES_DIR examples) # Определим переменную с именем директории -set(TASKS_DIR tasks) - -add_subdirectory(tasks) - -# Создать исполняемый файл для каждого примера -if (BUILD_EXAMPLES_04_WEEK) -# add_example(class_examples ${EXAMPLES_DIR}/class_examples.cpp) -endif() \ No newline at end of file diff --git a/04_week/CMakeLists_REMOTE_946.txt b/04_week/CMakeLists_REMOTE_946.txt deleted file mode 100644 index b15ca37c..00000000 --- a/04_week/CMakeLists_REMOTE_946.txt +++ /dev/null @@ -1,15 +0,0 @@ -cmake_minimum_required(VERSION 3.14) # Минимальная требуемая версия CMake -project(04_week) # Необходим для инициализации cmake - -set(CMAKE_CXX_STANDARD 20) # Версия стандарта C++ -set(CMAKE_CXX_STANDARD_REQUIRED ON) # Гарантирует использование указанной версии стандарта - -set(EXAMPLES_DIR examples) # Определим переменную с именем директории -set(TASKS_DIR tasks) - -add_subdirectory(tasks) - -# Создать исполняемый файл для каждого примера -if (BUILD_EXAMPLES_04_WEEK) -# add_example(class_examples ${EXAMPLES_DIR}/class_examples.cpp) -endif() \ No newline at end of file From 55ccf150a1228d8ca1e12db218685c5e16fd83c9 Mon Sep 17 00:00:00 2001 From: Radiy Date: Sun, 21 Dec 2025 14:19:46 +0500 Subject: [PATCH 29/37] add (solution): add stack task --- 04_week/tasks/stack/stack.cpp | 58 ++++++++++++++++++++++++++++++++++- 1 file changed, 57 insertions(+), 1 deletion(-) diff --git a/04_week/tasks/stack/stack.cpp b/04_week/tasks/stack/stack.cpp index 222e4ffc..5f9241ed 100644 --- a/04_week/tasks/stack/stack.cpp +++ b/04_week/tasks/stack/stack.cpp @@ -1,6 +1,62 @@ +#include #include - class Stack { +public: + void Push(int val); + bool Pop(); + int& Top(); + const int& Top() const; + bool Empty() const; + size_t Size() const; + void Clear(); + void Swap(Stack& other); + + bool operator==(const Stack& other) const { + return this->stack_ == other.stack_; + } + bool operator!=(const Stack& other) const { + return !(*this == other); + } + +private: + std::vector stack_{}; }; + +void Stack::Push(int val) { + stack_.push_back(val); +} + +bool Stack::Pop() { + if (stack_.empty()) { + return false; + } + + stack_.pop_back(); + return true; +} + +int& Stack::Top() { + return stack_.back(); +} + +const int& Stack::Top() const { + return stack_.back(); +} + +bool Stack::Empty() const { + return stack_.empty(); +} + +size_t Stack::Size() const { + return stack_.size(); +} + +void Stack::Clear() { + stack_.clear(); +} + +void Stack::Swap(Stack& other) { + stack_.swap(other.stack_); +} From 5b5b649425615f01c47218858caeab283b498d2f Mon Sep 17 00:00:00 2001 From: Radiy Date: Tue, 23 Dec 2025 18:33:48 +0500 Subject: [PATCH 30/37] add (solution): add queue task --- 04_week/tasks/queue/queue.cpp | 127 +++++++++++++++++++++++++++++++++- CMakeLists.txt | 2 +- 2 files changed, 127 insertions(+), 2 deletions(-) diff --git a/04_week/tasks/queue/queue.cpp b/04_week/tasks/queue/queue.cpp index 2a9f8493..526f3706 100644 --- a/04_week/tasks/queue/queue.cpp +++ b/04_week/tasks/queue/queue.cpp @@ -1,6 +1,131 @@ +#include +#include +#include #include - class Queue { +public: + Queue() {}; + + Queue(std::stack s) { + outputV_.reserve(s.size()); + while(!s.empty()) { + outputV_.push_back(s.top()); + s.pop(); + } + }; + + Queue(std::vector v) : outputV_(v.rbegin(), v.rend()){}; + + Queue(std::initializer_list list) : inputV_(list) {}; + + Queue(size_t size) { + inputV_.reserve(size); + outputV_.reserve(size); + } + + void Push(int val); + bool Pop(); + int& Front(); + const int& Front() const; + int& Back(); + const int& Back() const; + bool Empty() const; + size_t Size() const; + void Clear(); + void Swap(Queue& other); + + bool operator==(const Queue& other) const { + if (Size() != other.Size()) { + return false; + } + + return this->GetQueueAsVector() == other.GetQueueAsVector(); + } + bool operator!=(const Queue& other) const { + return !(*this == other); + } + +private: + void CopyIfOutEmpty(); + std::vector GetQueueAsVector() const; + std::vector inputV_{}; + std::vector outputV_{}; }; + +void Queue::CopyIfOutEmpty() { + if (outputV_.empty()) { + outputV_ = std::vector(inputV_.rbegin(), inputV_.rend()); + inputV_.clear(); + } +} + +std::vector Queue::GetQueueAsVector() const { + std::vector tOut = outputV_; + tOut.insert(tOut.end(), inputV_.rbegin(), inputV_.rend()); + return tOut; +} + +void Queue::Push(int val) { + inputV_.push_back(val); +} + +bool Queue::Pop() { + if (outputV_.empty() && inputV_.empty()) { + return false; + } + + CopyIfOutEmpty(); + + outputV_.pop_back(); + + return true; +} + +int& Queue::Front() { + CopyIfOutEmpty(); + return outputV_.back(); +} + +const int& Queue::Front() const { + if (outputV_.empty()) { + return inputV_.front(); + } + + return outputV_.back(); +} + +int& Queue::Back() { + if (!inputV_.empty()) { + return inputV_.back(); + } + + return outputV_.front(); +} + +const int& Queue::Back() const { + if (!inputV_.empty()) { + return inputV_.back(); + } + + return outputV_.front(); +} + +bool Queue::Empty() const { + return (inputV_.empty() && outputV_.empty()); +} + +size_t Queue::Size() const { + return (inputV_.size() + outputV_.size()); +} + +void Queue::Clear() { + inputV_.clear(); + outputV_.clear(); +} + +void Queue::Swap(Queue& other) { + inputV_.swap(other.inputV_); + outputV_.swap(other.outputV_); +} diff --git a/CMakeLists.txt b/CMakeLists.txt index b64ab3cd..fc3d5fa2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,4 +33,4 @@ add_week(06_week) add_week(07_week) add_week(08_week) add_week(09_week) -add_week(10_week) \ No newline at end of file +add_week(10_week) From bd18c29a67537969d8d467528023ab8cc83f2ebd Mon Sep 17 00:00:00 2001 From: Radiy Date: Tue, 23 Dec 2025 18:55:48 +0500 Subject: [PATCH 31/37] fix (solution): add queue fix --- 04_week/tasks/queue/queue.cpp | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/04_week/tasks/queue/queue.cpp b/04_week/tasks/queue/queue.cpp index 526f3706..77bdac17 100644 --- a/04_week/tasks/queue/queue.cpp +++ b/04_week/tasks/queue/queue.cpp @@ -1,4 +1,3 @@ -#include #include #include #include @@ -19,12 +18,17 @@ class Queue { Queue(std::initializer_list list) : inputV_(list) {}; - Queue(size_t size) { + Queue(const size_t size) { inputV_.reserve(size); outputV_.reserve(size); - } + }; + + Queue(const int size) { + inputV_.reserve(size); + outputV_.reserve(size); + }; - void Push(int val); + inline void Push(int val); bool Pop(); int& Front(); const int& Front() const; @@ -62,12 +66,16 @@ void Queue::CopyIfOutEmpty() { } std::vector Queue::GetQueueAsVector() const { - std::vector tOut = outputV_; - tOut.insert(tOut.end(), inputV_.rbegin(), inputV_.rend()); - return tOut; + std::vector result; + + std::copy(outputV_.rbegin(), outputV_.rend(), std::back_inserter(result)); + + std::copy(inputV_.begin(), inputV_.end(), std::back_inserter(result)); + + return result; } -void Queue::Push(int val) { +inline void Queue::Push(int val) { inputV_.push_back(val); } From 0ebcff7ad448609c772c341908ced122cd9553f1 Mon Sep 17 00:00:00 2001 From: Radiy Date: Wed, 24 Dec 2025 17:46:28 +0500 Subject: [PATCH 32/37] wip ring buffer --- 04_week/tasks/ring_buffer/ring_buffer.cpp | 52 ++++++++++++++++++++++- 1 file changed, 51 insertions(+), 1 deletion(-) diff --git a/04_week/tasks/ring_buffer/ring_buffer.cpp b/04_week/tasks/ring_buffer/ring_buffer.cpp index e2b57ba2..520d3758 100644 --- a/04_week/tasks/ring_buffer/ring_buffer.cpp +++ b/04_week/tasks/ring_buffer/ring_buffer.cpp @@ -1,6 +1,56 @@ +#include #include - class RingBuffer { +public: + RingBuffer() { + ringBuff.reserve(1); + frontIt = ringBuff.begin(); + backIt = ringBuff.begin(); + } + + RingBuffer(size_t size) { + ringBuff.reserve(size); + frontIt = ringBuff.begin(); + backIt = ringBuff.begin(); + }; + + RingBuffer(size_t size, int iVal) : ringBuff(size, iVal), \ + frontIt(ringBuff.end() - 1), backIt(ringBuff.begin() - 1) {}; + + RingBuffer(std::initializer_list list) : ringBuff(list), frontIt(ringBuff.end() - 1), backIt(ringBuff.begin()) {}; + void Push(int val); + bool TryPush(int val); + void Pop(); + bool TryPop(); + int& Front(); + const int& Front() const; + int& Back(); + const int& Back() const; + bool Empty() const; + bool Full() const; + size_t Size() const; + size_t Capacity() const; + void Clear(); + void Resize(); + std::vector Vector() const; + + int oldestElement = 0; + + +private: + std::vector ringBuff{}; + std::vector::iterator frontIt; + std::vector::iterator backIt; }; + +void RingBuffer::Push(int val) { + if ((frontIt + 1) != backIt) { + *frontIt = val; + ++frontIt; + } + + +} + From 0a479ebde7e991f4a1b5914ea80c8825e9bccfac Mon Sep 17 00:00:00 2001 From: Radiy Date: Wed, 24 Dec 2025 18:09:01 +0500 Subject: [PATCH 33/37] wip ring_buff 2 --- 04_week/tasks/ring_buffer/ring_buffer.cpp | 62 +++++++++++++++++++++-- 1 file changed, 58 insertions(+), 4 deletions(-) diff --git a/04_week/tasks/ring_buffer/ring_buffer.cpp b/04_week/tasks/ring_buffer/ring_buffer.cpp index 520d3758..814450bf 100644 --- a/04_week/tasks/ring_buffer/ring_buffer.cpp +++ b/04_week/tasks/ring_buffer/ring_buffer.cpp @@ -23,7 +23,7 @@ class RingBuffer { void Push(int val); bool TryPush(int val); void Pop(); - bool TryPop(); + bool TryPop(int& val); int& Front(); const int& Front() const; int& Back(); @@ -46,11 +46,65 @@ class RingBuffer { }; void RingBuffer::Push(int val) { - if ((frontIt + 1) != backIt) { - *frontIt = val; - ++frontIt; + ++frontIt; + + if (frontIt == ringBuff.end()) { + frontIt = ringBuff.begin(); + } + + if (frontIt == backIt) { + ++backIt; + } + + if (backIt == ringBuff.end()) { + backIt = ringBuff.begin(); + } + + *frontIt = val; +} + +bool RingBuffer::TryPush(int val) { + ++frontIt; + + if (frontIt == ringBuff.end()) { + frontIt = ringBuff.begin(); + } + + if (frontIt == backIt) { + --frontIt; + return false; } + *frontIt = val; + return true; +} + +void RingBuffer::Pop() { + if (backIt == frontIt) { + return; + } + + ++backIt; + + if (backIt == ringBuff.end()) { + backIt = ringBuff.begin(); + } +} + +bool RingBuffer::TryPop(int& val) { + if (backIt == frontIt) { + return false; + } + + val = *backIt; + + ++backIt; + + if (backIt == ringBuff.end()) { + backIt = ringBuff.begin(); + } + + return true; } From 270198a315edb818c02a71a7857d9383333366a1 Mon Sep 17 00:00:00 2001 From: Radiy Date: Wed, 24 Dec 2025 18:20:18 +0500 Subject: [PATCH 34/37] wip ring_buffer 3 --- 04_week/tasks/ring_buffer/ring_buffer.cpp | 25 +++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/04_week/tasks/ring_buffer/ring_buffer.cpp b/04_week/tasks/ring_buffer/ring_buffer.cpp index 814450bf..16ecfc1c 100644 --- a/04_week/tasks/ring_buffer/ring_buffer.cpp +++ b/04_week/tasks/ring_buffer/ring_buffer.cpp @@ -107,4 +107,29 @@ bool RingBuffer::TryPop(int& val) { return true; } + +int& RingBuffer::Front() { + return *frontIt; +} + +const int& RingBuffer::Front() const { + return *frontIt; +} +int& RingBuffer::Back() { + return *backIt; +} + +const int& RingBuffer::Back() const { + return *backIt; +} + +bool RingBuffer::Empty() const { + return backIt == frontIt; // will be wrong on circ buffer size of one +} + +bool RingBuffer::Full() const { + return (frontIt + 1) == backIt; // also will be wrong on buffer size of one +} + + From 8f37dc1089c8823b23a144f04f38d0f987ae76ed Mon Sep 17 00:00:00 2001 From: Radiy Date: Wed, 24 Dec 2025 21:07:45 +0500 Subject: [PATCH 35/37] wip ring_buffer 4 --- 04_week/tasks/ring_buffer/ring_buffer.cpp | 214 +++++++++++++++------- 1 file changed, 150 insertions(+), 64 deletions(-) diff --git a/04_week/tasks/ring_buffer/ring_buffer.cpp b/04_week/tasks/ring_buffer/ring_buffer.cpp index 16ecfc1c..f5b2ad5e 100644 --- a/04_week/tasks/ring_buffer/ring_buffer.cpp +++ b/04_week/tasks/ring_buffer/ring_buffer.cpp @@ -1,24 +1,45 @@ +#include #include #include class RingBuffer { public: - RingBuffer() { - ringBuff.reserve(1); - frontIt = ringBuff.begin(); - backIt = ringBuff.begin(); - } + RingBuffer() : ringBuff(1), head(0), tail(0), size(0) {} - RingBuffer(size_t size) { - ringBuff.reserve(size); - frontIt = ringBuff.begin(); - backIt = ringBuff.begin(); - }; + RingBuffer(size_t capacity) : head(0), tail(0), size(0) { + if (capacity == 0) { + ++capacity; + } + ringBuff.reserve(capacity); + } - RingBuffer(size_t size, int iVal) : ringBuff(size, iVal), \ - frontIt(ringBuff.end() - 1), backIt(ringBuff.begin() - 1) {}; + RingBuffer(size_t capacity, int iVal) : head(capacity), tail(0), + isFull(true), isEmpty(false) { + + if (capacity == 0) { + ++capacity; + } + size = capacity; + ringBuff.resize(capacity); + std::fill(ringBuff.begin(), ringBuff.end(), iVal); + } - RingBuffer(std::initializer_list list) : ringBuff(list), frontIt(ringBuff.end() - 1), backIt(ringBuff.begin()) {}; + RingBuffer(std::initializer_list list) : tail(0), isFull(true), isEmpty(false) { + if (list.size() != 0) { + size = list.size(); + head = size; + ringBuff.resize(size); + std::copy(list.begin(), list.end(), ringBuff.begin()); + return; + } + + size = 0; + head = 0; + ringBuff.resize(1); + ringBuff[0] = 0; + isFull = false; + isEmpty = true; + } void Push(int val); bool TryPush(int val); @@ -33,103 +54,168 @@ class RingBuffer { size_t Size() const; size_t Capacity() const; void Clear(); - void Resize(); + void Resize(size_t newSize); std::vector Vector() const; - - int oldestElement = 0; - + int& operator[](size_t idx) { + return ringBuff[(tail + idx) % ringBuff.size()]; + } + + const int& operator[](size_t idx) const { + return ringBuff[(tail + idx) % ringBuff.size()]; + } + private: std::vector ringBuff{}; - std::vector::iterator frontIt; - std::vector::iterator backIt; + size_t head = 0; + size_t tail = 0; + size_t size = 0; + bool isFull = false; + bool isEmpty = true; }; void RingBuffer::Push(int val) { - ++frontIt; - - if (frontIt == ringBuff.end()) { - frontIt = ringBuff.begin(); - } - - if (frontIt == backIt) { - ++backIt; + size_t cap = ringBuff.capacity(); + + isEmpty = false; + ringBuff[head] = val; + // при head = buff.capacity(), head снова станет = 0 + head = (head + 1) % cap; + + if (size < cap) { + ++size; + } else { + // аналогично head + tail = (tail + 1) % ringBuff.capacity(); } - if (backIt == ringBuff.end()) { - backIt = ringBuff.begin(); + if (size == cap) { + isFull = true; } - - *frontIt = val; } bool RingBuffer::TryPush(int val) { - ++frontIt; + size_t cap = ringBuff.capacity(); - if (frontIt == ringBuff.end()) { - frontIt = ringBuff.begin(); + if (isFull) { + return false; } + + isEmpty = false; + ringBuff[head] = val; + // при head = buff.capacity(), head снова станет = 0 + head = (head + 1) % cap; - if (frontIt == backIt) { - --frontIt; - return false; + ++size; + + if (size == cap) { + isFull = true; } - *frontIt = val; - - return true; + return true; } void RingBuffer::Pop() { - if (backIt == frontIt) { - return; - } - - ++backIt; + isFull = false; - if (backIt == ringBuff.end()) { - backIt = ringBuff.begin(); + if (size > 0) { + tail = (tail + 1) % ringBuff.capacity(); + --size; + } else { + isEmpty = true; } } bool RingBuffer::TryPop(int& val) { - if (backIt == frontIt) { - return false; - } - - val = *backIt; + isFull = false; - ++backIt; - - if (backIt == ringBuff.end()) { - backIt = ringBuff.begin(); + if (size > 0) { + val = ringBuff[tail]; + tail = (tail + 1) % ringBuff.capacity(); + --size; + return true; } - - return true; + + isEmpty = true; + return false; } int& RingBuffer::Front() { - return *frontIt; + return ringBuff[head - 1]; } const int& RingBuffer::Front() const { - return *frontIt; + return ringBuff[head - 1]; } int& RingBuffer::Back() { - return *backIt; + return ringBuff[tail]; } const int& RingBuffer::Back() const { - return *backIt; + return ringBuff[tail]; } bool RingBuffer::Empty() const { - return backIt == frontIt; // will be wrong on circ buffer size of one + return isEmpty; } + bool RingBuffer::Full() const { - return (frontIt + 1) == backIt; // also will be wrong on buffer size of one + return isFull; +} + +size_t RingBuffer::Size() const { + return size; +} + +size_t RingBuffer::Capacity() const { + return ringBuff.capacity(); +} + +void RingBuffer::Clear() { + head = 0; + tail = 0; + size = 0; + isFull = false; + isEmpty = true; +} + +void RingBuffer::Resize(size_t newSize) { + if (newSize == ringBuff.capacity()) { + return; + } + + size_t sz = std::min(size, newSize); + + if (sz == 0) { + ++sz; + } + + std::vector tempV; + tempV.reserve(sz); + + for (size_t i = 0; i < sz; ++i) { + tempV.push_back(ringBuff[(tail + i) % ringBuff.size()]); + } + + ringBuff.resize(newSize); + + for (size_t i = 0; i < sz; ++i) { + ringBuff[i] = std::move(tempV[i]); + } + + tail = 0; + head = sz; + size = sz; } +std::vector RingBuffer::Vector() const { + std::vector v; + v.reserve(size); + for (size_t i = 0; i < size; ++i) { + v.push_back(ringBuff[(tail + i) % ringBuff.size()]); + } + return v; + } From d05dff0d30b37183490bdc670b6782eb073e19f3 Mon Sep 17 00:00:00 2001 From: Radiy Date: Thu, 25 Dec 2025 14:37:34 +0500 Subject: [PATCH 36/37] add (solution): add ring_buffer task --- 04_week/tasks/ring_buffer/ring_buffer.cpp | 174 +++++++++------------- 1 file changed, 71 insertions(+), 103 deletions(-) diff --git a/04_week/tasks/ring_buffer/ring_buffer.cpp b/04_week/tasks/ring_buffer/ring_buffer.cpp index f5b2ad5e..6e798755 100644 --- a/04_week/tasks/ring_buffer/ring_buffer.cpp +++ b/04_week/tasks/ring_buffer/ring_buffer.cpp @@ -4,41 +4,18 @@ class RingBuffer { public: - RingBuffer() : ringBuff(1), head(0), tail(0), size(0) {} + RingBuffer() : ringBuff_(1), head_(0), tail_(0), size_(0) {} - RingBuffer(size_t capacity) : head(0), tail(0), size(0) { - if (capacity == 0) { - ++capacity; - } - ringBuff.reserve(capacity); - } + RingBuffer(size_t capacity) : ringBuff_(capacity > 0 ? capacity : 1), head_(0), tail_(0), size_(0) {} - RingBuffer(size_t capacity, int iVal) : head(capacity), tail(0), - isFull(true), isEmpty(false) { - - if (capacity == 0) { - ++capacity; - } - size = capacity; - ringBuff.resize(capacity); - std::fill(ringBuff.begin(), ringBuff.end(), iVal); - } + RingBuffer(size_t capacity, const int iVal) : ringBuff_(capacity > 0 ? capacity : 1, iVal), head_(capacity), tail_(0), + size_(capacity > 0 ? capacity : 1) {} - RingBuffer(std::initializer_list list) : tail(0), isFull(true), isEmpty(false) { - if (list.size() != 0) { - size = list.size(); - head = size; - ringBuff.resize(size); - std::copy(list.begin(), list.end(), ringBuff.begin()); - return; + RingBuffer(std::initializer_list list) : ringBuff_(list), head_(0), tail_(0), size_(list.size()) { + if (list.size() == 0) { + ringBuff_.reserve(1); + size_ = 0; } - - size = 0; - head = 0; - ringBuff.resize(1); - ringBuff[0] = 0; - isFull = false; - isEmpty = true; } void Push(int val); @@ -58,163 +35,154 @@ class RingBuffer { std::vector Vector() const; int& operator[](size_t idx) { - return ringBuff[(tail + idx) % ringBuff.size()]; + return ringBuff_[(tail_ + idx) % ringBuff_.size()]; } const int& operator[](size_t idx) const { - return ringBuff[(tail + idx) % ringBuff.size()]; + return ringBuff_[(tail_ + idx) % ringBuff_.size()]; } private: - std::vector ringBuff{}; - size_t head = 0; - size_t tail = 0; - size_t size = 0; - bool isFull = false; - bool isEmpty = true; + std::vector ringBuff_{}; + size_t head_ = 0; + size_t tail_ = 0; + size_t size_ = 0; }; void RingBuffer::Push(int val) { - size_t cap = ringBuff.capacity(); + size_t cap = ringBuff_.capacity(); - isEmpty = false; - ringBuff[head] = val; + ringBuff_[head_] = val; // при head = buff.capacity(), head снова станет = 0 - head = (head + 1) % cap; + head_ = (head_ + 1) % cap; - if (size < cap) { - ++size; + if (size_ < cap) { + ++size_; } else { // аналогично head - tail = (tail + 1) % ringBuff.capacity(); - } - - if (size == cap) { - isFull = true; + tail_ = (tail_ + 1) % ringBuff_.capacity(); } } bool RingBuffer::TryPush(int val) { - size_t cap = ringBuff.capacity(); + size_t cap = ringBuff_.capacity(); - if (isFull) { + if (size_ == cap) { return false; } - - isEmpty = false; - ringBuff[head] = val; + + ringBuff_[head_] = val; // при head = buff.capacity(), head снова станет = 0 - head = (head + 1) % cap; + head_ = (head_ + 1) % cap; - ++size; - - if (size == cap) { - isFull = true; - } + ++size_; return true; } void RingBuffer::Pop() { - isFull = false; - - if (size > 0) { - tail = (tail + 1) % ringBuff.capacity(); - --size; - } else { - isEmpty = true; + if (size_ > 0) { + tail_ = (tail_ + 1) % ringBuff_.capacity(); + --size_; } } bool RingBuffer::TryPop(int& val) { - isFull = false; - - if (size > 0) { - val = ringBuff[tail]; - tail = (tail + 1) % ringBuff.capacity(); - --size; + if (size_ > 0) { + val = ringBuff_[tail_]; + tail_ = (tail_ + 1) % ringBuff_.capacity(); + --size_; return true; } - isEmpty = true; return false; } int& RingBuffer::Front() { - return ringBuff[head - 1]; + if (head_ == 0) { + return ringBuff_.back(); + } + + return ringBuff_[head_ - 1]; } const int& RingBuffer::Front() const { - return ringBuff[head - 1]; + if (head_ == 0) { + return ringBuff_.back(); + } + + return ringBuff_[head_ - 1]; } int& RingBuffer::Back() { - return ringBuff[tail]; + return ringBuff_[tail_]; } const int& RingBuffer::Back() const { - return ringBuff[tail]; + return ringBuff_[tail_]; } bool RingBuffer::Empty() const { - return isEmpty; + return size_ == 0; } bool RingBuffer::Full() const { - return isFull; + return size_ == ringBuff_.capacity(); } size_t RingBuffer::Size() const { - return size; + return size_; } size_t RingBuffer::Capacity() const { - return ringBuff.capacity(); + return ringBuff_.capacity(); } void RingBuffer::Clear() { - head = 0; - tail = 0; - size = 0; - isFull = false; - isEmpty = true; + head_ = 0; + tail_ = 0; + size_ = 0; } void RingBuffer::Resize(size_t newSize) { - if (newSize == ringBuff.capacity()) { + if (newSize == 0) { + ++newSize; + } + + if (newSize == ringBuff_.size()) { return; } - size_t sz = std::min(size, newSize); - - if (sz == 0) { - ++sz; - } + size_t sz = std::min(size_, newSize); std::vector tempV; tempV.reserve(sz); for (size_t i = 0; i < sz; ++i) { - tempV.push_back(ringBuff[(tail + i) % ringBuff.size()]); + tempV.push_back(ringBuff_[(head_ - 1 - i + ringBuff_.size()) % ringBuff_.size()]); } - ringBuff.resize(newSize); + std::reverse(tempV.begin(), tempV.end()); + ringBuff_.resize(newSize); for (size_t i = 0; i < sz; ++i) { - ringBuff[i] = std::move(tempV[i]); + ringBuff_[i] = tempV[i]; } - tail = 0; - head = sz; - size = sz; + ringBuff_.shrink_to_fit(); + + tail_ = 0; + head_ = sz; + size_ = sz; } std::vector RingBuffer::Vector() const { std::vector v; - v.reserve(size); - for (size_t i = 0; i < size; ++i) { - v.push_back(ringBuff[(tail + i) % ringBuff.size()]); + v.reserve(size_); + + for (size_t i = 0; i < size_; ++i) { + v.push_back(ringBuff_[(tail_ + i) % ringBuff_.size()]); } return v; From 1da7fd812a89cc696ae7253c239d53e07463ac3b Mon Sep 17 00:00:00 2001 From: Radiy Date: Fri, 26 Dec 2025 15:02:32 +0500 Subject: [PATCH 37/37] add (solution): add phasor task --- 04_week/tasks/phasor/phasor.cpp | 250 ++++++++++++++++++++++++++++++++ 1 file changed, 250 insertions(+) diff --git a/04_week/tasks/phasor/phasor.cpp b/04_week/tasks/phasor/phasor.cpp index 3ec1b9ad..3d5874fd 100644 --- a/04_week/tasks/phasor/phasor.cpp +++ b/04_week/tasks/phasor/phasor.cpp @@ -1,4 +1,34 @@ +#include +#include +#include +#include +namespace { + constexpr double EPS_ = 1e-12; +} + + +double DegToRad(double deg) { + return deg * M_PI / 180.0; +} + +double RadToDeg(double rad){ + return rad * 180 / M_PI; +} + +double NormalizePhase(double phase) { + phase = std::fmod(phase, 2.0 * M_PI); + + if (phase > M_PI) { + phase -= 2.0 * M_PI; + } + + if (phase <= -M_PI) { + phase += 2.0 * M_PI; + } + + return phase; +} struct ExpTag {}; struct DegTag {}; @@ -6,5 +36,225 @@ struct AlgTag {}; class Phasor { +public: + Phasor() = default; + Phasor(double A, double rad) { + if (A < 0) { + A = -A; + rad += M_PI; + } + + rad = NormalizePhase(rad); + + real_ = A * std::cos(rad); + imag_ = A * std::sin(rad); + }; + Phasor(double A, double rad, ExpTag) : Phasor(A, rad) {}; + Phasor(double A, double deg, DegTag) : Phasor(A, DegToRad(deg)) {}; + Phasor(double real, double imag, AlgTag) : real_(real), imag_(imag) {}; + + void SetPolar(double A, double rad); + void SetCartesian(double real, double imag); + double Magnitude() const; + double Phase() const; + double PhaseDeg() const; + double Real() const; + double Imag() const; + double Abs() const; + double Angle() const; + double AngleDeg() const; + Phasor Conj() const; + Phasor Inv() const; + + Phasor& operator+=(const Phasor& other) { + real_ += other.real_; + imag_ += other.imag_; + return *this; + } + + Phasor& operator-=(const Phasor& other) { + real_ -= other.real_; + imag_ -= other.imag_; + return *this; + } + Phasor& operator*=(const Phasor& other) { + SetPolar(Magnitude() * other.Magnitude(), Phase() + other.Phase()); + return *this; + } + + Phasor& operator/=(const Phasor& other) { + SetPolar(Magnitude() / other.Magnitude(), Phase() - other.Phase()); + return *this; + } + + Phasor& operator+=(double real) { + real_ += real; + return *this; + } + + Phasor& operator-=(double real) { + real_ -= real; + return *this; + } + + Phasor& operator*=(double real) { + real_ *= real; + imag_ *= real; + return *this; + } + + Phasor& operator/=(double real) { + real_ /= real; + imag_ /= real; + return *this; + } + + Phasor operator-() const { + return Phasor(-real_, -imag_, AlgTag{}); + } + +private: + double real_ = 0.0; + double imag_ = 0.0; }; + +Phasor operator+(const Phasor& lhs, const Phasor& rhs) { + double real = lhs.Real() + rhs.Real(); + double imag = lhs.Imag() + rhs.Imag(); + return Phasor(real, imag, AlgTag{}); +} + +Phasor operator-(const Phasor& lhs, const Phasor& rhs) { + double real = lhs.Real() - rhs.Real(); + double imag = lhs.Imag() - rhs.Imag(); + return Phasor(real, imag, AlgTag{}); +} + +Phasor operator*(const Phasor& lhs, const Phasor& rhs) { + double A = lhs.Magnitude() * rhs.Magnitude(); + double rad = lhs.Phase() + rhs.Phase(); + + return Phasor(A, NormalizePhase(rad)); +} + +Phasor operator/(const Phasor& lhs, const Phasor& rhs) { + double A = lhs.Magnitude() / rhs.Magnitude(); + double rad = lhs.Phase() - rhs.Phase(); + + return Phasor(A, NormalizePhase(rad)); +} + +bool operator==(const Phasor& lhs, const Phasor& rhs) { + return (std::abs(lhs.Real() - rhs.Real()) < EPS_ && + std::abs(lhs.Imag() - rhs.Imag()) < EPS_); +} + +bool operator!=(const Phasor& lhs, const Phasor& rhs) { + return !(lhs == rhs); +} + +Phasor operator+(const Phasor& lhs, double rhs) { + return Phasor(lhs.Real() + rhs, lhs.Imag(), AlgTag{}); +} + +// Сложение коммутативно +Phasor operator+(double rhs, const Phasor& lhs) { + return Phasor(lhs.Real() + rhs, lhs.Imag(), AlgTag{}); +} + +Phasor operator-(const Phasor& lhs, double rhs) { + return Phasor(lhs.Real() - rhs, lhs.Imag(), AlgTag{}); +} + +Phasor operator-(double lhs, const Phasor& rhs) { + return (lhs + (-rhs)); +} + + +Phasor operator*(const Phasor& lhs, double rhs) { + return Phasor(lhs.Real() * rhs, lhs.Imag() * rhs, AlgTag{}); +} + +// Умножение тоже коммутативно +Phasor operator*(double rhs, const Phasor& lhs) { + return Phasor(lhs.Real() * rhs, lhs.Imag() * rhs, AlgTag{}); +} + +Phasor operator/(const Phasor& lhs, double rhs) { + return Phasor(lhs.Real() / rhs, lhs.Imag() / rhs, AlgTag{}); +} + +Phasor operator/(double lhs, const Phasor& rhs) { + double A = std::abs(lhs) / rhs.Magnitude(); + double rad = ((lhs >= 0) ? 0.0 : M_PI) - rhs.Phase(); + return Phasor(A, NormalizePhase(rad)); +} + +std::ostream& operator<<(std::ostream& os, const Phasor& p) { + os << std::fixed << std::setprecision(3) + << p.Magnitude() << "*e(j*" << p.PhaseDeg() << ") [" + << p.Real() << " + j*" << p.Imag() << ']'; + return os; +} + +void Phasor::SetPolar(double A, double rad) { + *this = Phasor(A, rad); +} + +void Phasor::SetCartesian(double real, double imag) { + real_ = real; + imag_ = imag; +} + +double Phasor::Magnitude() const { + return std::hypot(real_, imag_); +} + +double Phasor::Phase() const { + return std::atan2(imag_, real_); +} + +double Phasor::PhaseDeg() const { + return RadToDeg(Phase()); +} + +double Phasor::Real() const { + return real_; +} + +double Phasor::Imag() const { + return imag_; +} + +double Phasor::Abs() const { + return Magnitude(); +} + +double Phasor::Angle() const { + return Phase(); +} + +double Phasor::AngleDeg() const { + return PhaseDeg(); +} + +Phasor Phasor::Conj() const { + return Phasor(real_, -imag_, AlgTag{}); +} + +Phasor Phasor::Inv() const { + return 1.0 / (*this); +} + +Phasor MakePhasorCartesian(double real, double imag) { + return Phasor(real, imag, AlgTag{}); +} + +Phasor MakePhasorPolar(double A, double rad) { + return Phasor(A, rad); +} + +Phasor MakePhasorPolarDeg(double A, double deg) { + return Phasor(A, deg, DegTag{}); +}