Жамбакиев Радий

.gitignore

@@ -0,0 +1,2 @@
+/build
+/build-asan

01_week/tasks/addition/addition.cpp

@@ -3,5 +3,5 @@
 
 
 int64_t Addition(int a, int b) {
-    throw std::runtime_error{"Not implemented"};
-}
+    return static_cast<int64_t>(a) + static_cast<int64_t>(b);
+}

01_week/tasks/char_changer/char_changer.cpp

@@ -1,7 +1,83 @@
 #include <cstddef>
 #include <stdexcept>
 
+// Есть ощущение, что это можно решить как-то более лаконично и просто
+
+/**
+ * @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 = ' ') {
-    throw std::runtime_error{"Not implemented"};
+    size_t convertedSymbolIdx = 0, currentSymbolIdx = 0;
+
+    while(currentSymbolIdx < size && convertedSymbolIdx < size) {
+        if (array[currentSymbolIdx] == '\0') {
+            break;
+        }
+
+        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, '_');    
+    }
+
+    array[convertedSymbolIdx] = '\0';
+    return convertedSymbolIdx;
 }

01_week/tasks/check_flags/check_flags.cpp

@@ -1,6 +1,6 @@
 #include <cstdint>
 #include <stdexcept>
-
+#include <string>
 
 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<int>. Так же map отсортирует значения по возрасанию, соответственно
+// использовать enum написанный иначе будет невозможно.
+const std::vector<std::pair<CheckFlags, std::string_view>> 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<uint8_t>(flags) & static_cast<uint8_t>(key)) {
+            if (!first) {
+                needed_checks += ","; // добавляем запятую перед элементом, а не после, 
+                                      // проверяя на первый элемент, это гарантирует, что лишних
+                                      // запятых не будет
+            }
+
+            needed_checks += val;
+            first = false;
+        } 
+    }
+
+    needed_checks += "]";
+
+    std::cout << needed_checks;
 }

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;
+}

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,17 @@
 #include <cstddef>
 #include <stdexcept>
-
+#include <string>
 
 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;
 }

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,64 @@
 #include <stdexcept>
+#include <cmath>
+#include <iomanip>
 
+// Уверен, что это можно сделать значительно качественнее, но дедлайн близко,
+// поэтому спагетти код >:)
 
-void SolveQuadratic(int a, int b, int c) {
-    throw std::runtime_error{"Not implemented"};
-}
+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<double>(-c) / b);
+        return;
+    }
+
+    if (!b) {
+        if (static_cast<double>(-c) / a < 0) {
+            std::cout << "no solutions";
+            return;
+        }
+
+        double root = std::sqrt(static_cast<double>(-c) / a);
+
+        if (root == 0) {
+            std::cout << root;
+        } else {
+            std::cout << -root << " " << root;
+        }
+
+        return;
+    }
+
+    double d = static_cast<double>(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);
+}

01_week/tasks/rms/rms.cpp

@@ -1,7 +1,16 @@
-#include <cstdef>
+#include <cstddef>
 #include <stdexcept>
-
+#include <cmath>
 
 double CalculateRMS(double values[], size_t size) {
-    throw std::runtime_error{"Not implemented"};
-}
+    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<double>(size));
+}

02_week/tasks/func_array/func_array.cpp

@@ -1,6 +1,19 @@
 #include <stdexcept>
 
+typedef double(*operations_t)(double, double); 
 
-double ApplyOperations(double a, double b /* other arguments */) {
-    throw std::runtime_error{"Not implemented"};
-}
+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;
+}

02_week/tasks/last_of_us/last_of_us.cpp

@@ -1,6 +1,26 @@
 #include <stdexcept>
 
+typedef bool (*predicate_func_t)(int);
 
-/* return_type */ FindLastElement(/* ptr_type */ begin, /* ptr_type */ end, /* func_type */ predicate) {
-    throw std::runtime_error{"Not implemented"};
-}
+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;
+}