Михайлов Илья

01_week/tasks/addition/addition.cpp

@@ -1,7 +1,6 @@
 #include <cstdint>
-#include <stdexcept>
 
 
 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,49 @@
 #include <cstddef>
-#include <stdexcept>
+#include <cctype>
 
 
-size_t CharChanger(char array[], size_t size, char delimiter = ' ') {
-    throw std::runtime_error{"Not implemented"};
-}
+size_t CharChanger(char array[], size_t, char delimiter = ' ') {
+    int counter = 0; // Счётчик повторяющихся символов
+    int write = 0;   // Указатель для записи обработанного символа
+    int read = 0;    // Указатель для чтения следующего элемента из массива
+    char repeating_symbol = array[read]; // В процессе выполнения - редыдущий символ после read(отслеживаем повторения)
+
+    while (repeating_symbol != '\0'){
+        if (repeating_symbol == array[read]){
+            counter++;
+        } else {
+            if (isalpha(repeating_symbol)){
+                array[write] = toupper(repeating_symbol);
+            } else if (isdigit(repeating_symbol)){
+                array[write] = '*';
+            } else if (repeating_symbol == ' '){
+                array[write] = delimiter;
+            } else {
+                array[write] = '_';
+            }
+
+            write++;
+
+            if (repeating_symbol == ' ') {
+                counter = 1;
+            }
+
+            if (counter >= 10){
+                counter = 0;
+            }
+
+            if (counter != 1){
+                array[write] = static_cast<char>(counter + '0'); // Преобразуем число в символ
+                counter = 1;
+                write++;
+            }
+
+            repeating_symbol = array[read];
+        }
+
+        read++;
+    }
+
+    array[write] = '\0';
+    return write;     
+}

01_week/tasks/check_flags/README.md

@@ -8,5 +8,4 @@
 
 Если передан флаг отсутствия проверок, то необходимо вывести пустые `[]`.
 
-Если передано значение выходит из возможного диапазона значений, то вывод
-следует оставить пустым.
+Если переданное значение выходит из возможного диапазона значений, то вывод следует оставить пустым.

01_week/tasks/check_flags/check_flags.cpp

@@ -1,5 +1,7 @@
 #include <cstdint>
-#include <stdexcept>
+#include <iostream>
+#include <vector>
+#include <string>
 
 
 enum class CheckFlags : uint8_t {
@@ -14,5 +16,42 @@ enum class CheckFlags : uint8_t {
 };
 
 void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
-}
+    if (flags == CheckFlags::NONE) {
+        std::cout << "[]";
+        return;
+    }
+
+    if ((static_cast<uint8_t>(flags) & ~static_cast<uint8_t>(CheckFlags::ALL)) != 0) {
+        std::cout << "";
+        return;
+    }
+
+    std::vector<std::string> set_flags;
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::TIME)) != 0) {
+        set_flags.push_back("TIME");
+    }
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::DATE)) != 0) {
+        set_flags.push_back("DATE");
+    }
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::USER)) != 0) {
+        set_flags.push_back("USER");
+    }
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::CERT)) != 0) {
+        set_flags.push_back("CERT");
+    }
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::KEYS)) != 0) {
+        set_flags.push_back("KEYS");
+    }
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::DEST)) != 0) {
+        set_flags.push_back("DEST");
+    }
+
+    std::cout << "[";
+    for (size_t i = 0; i < set_flags.size(); i++) {
+        std::cout << set_flags[i];
+        if (i < set_flags.size() - 1) {
+            std::cout << ",";
+        }
+    }
+    std::cout << "]";
+}

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,67 @@
+#include <string>
+
+
+// Константы для преобразования
+constexpr long double IN_TO_CM = 2.54L;
+constexpr long double FT_TO_IN = 12.0L;
+constexpr long double M_TO_CM = 100.0L;
+
+// ft -> in
+double operator"" _ft_to_in(long double ft_value) {
+    return static_cast<double>(ft_value * FT_TO_IN);
+}
+
+// ft -> cm
+double operator"" _ft_to_cm(long double ft_value) {
+    return static_cast<double>(ft_value * FT_TO_IN * IN_TO_CM);
+}
+
+// ft -> m
+double operator"" _ft_to_m(long double ft_value) {
+    return static_cast<double>(ft_value * FT_TO_IN * IN_TO_CM / M_TO_CM);
+}
+
+// in -> ft
+double operator"" _in_to_ft(long double in_value) {
+    return static_cast<double>(in_value / FT_TO_IN);
+}
+
+// in -> cm
+double operator"" _in_to_cm(long double in_value) {
+    return static_cast<double>(in_value * IN_TO_CM);
+}
+
+// in -> m
+double operator"" _in_to_m(long double in_value) {
+    return static_cast<double>(in_value * IN_TO_CM / M_TO_CM);
+}
+
+// cm -> ft
+double operator"" _cm_to_ft(long double cm_value) {
+    return static_cast<double>(cm_value / IN_TO_CM / FT_TO_IN);
+}
+
+// cm -> in
+double operator"" _cm_to_in(long double cm_value) {
+    return static_cast<double>(cm_value / IN_TO_CM);
+}
+
+// cm -> m
+double operator"" _cm_to_m(long double cm_value) {
+    return static_cast<double>(cm_value / M_TO_CM);
+}
+
+// m -> ft
+double operator"" _m_to_ft(long double m_value) {
+    return static_cast<double>(m_value * M_TO_CM / IN_TO_CM / FT_TO_IN);
+}
+
+// m -> in
+double operator"" _m_to_in(long double m_value) {
+    return static_cast<double>(m_value * M_TO_CM / IN_TO_CM);
+}
+
+// m -> cm
+double operator"" _m_to_cm(long double m_value) {
+    return static_cast<double>(m_value * M_TO_CM);
+}

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,27 @@
 #include <cstddef>
-#include <stdexcept>
+#include <iostream>
+#include <vector>
 
 
 void PrintBits(long long value, size_t bytes) {
-    throw std::runtime_error{"Not implemented"};
-}
+    if (bytes <= 0 || bytes > 8) {
+        return;
+    }
+
+    std::cout << "0b";
+
+    // Выводим биты, начиная со старшего
+    for (int i = bytes * 8 - 1; i >= 0; --i) {
+        // "Выталкиваем" все биты, кроме i-ого, так чтобы i-ый был последним и выводим этот бит
+        if ((value >> i) & 1) {
+            std::cout << 1;
+        } else {
+            std::cout << 0;
+        }
+
+        if (i != 0 && i % 4 == 0) {
+            std::cout << "'";
+        }
+    }
+    std::cout << '\n';
+}

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,35 @@
-#include <stdexcept>
+#include <iostream>
+#include <cmath>
+#include <iomanip>
+#include <algorithm> // Для std::min и std::max
 
 
 void SolveQuadratic(int a, int b, int c) {
-    throw std::runtime_error{"Not implemented"};
+    if (a == 0) {
+        if (b == 0) {
+            if (c == 0) {
+                std::cout << "infinite solutions";
+            } else {
+                std::cout << "no solutions";
+            }
+        } else {
+            double x = static_cast<double>(-c) / b;
+            std::cout << std::defaultfloat << std::setprecision(6) << x;
+        }
+    } else {
+        long long discriminant = static_cast<long long>(b) * b - 4 * static_cast<long long>(a) * c;
+
+        if (discriminant > 0) {
+            double x1 = (-b - std::sqrt(static_cast<double>(discriminant))) / (2 * a);
+            double x2 = (-b + std::sqrt(static_cast<double>(discriminant))) / (2 * a);
+            std::cout << std::defaultfloat << std::setprecision(6) << std::min(x1, x2);
+            std::cout << " ";
+            std::cout << std::defaultfloat << std::setprecision(6) << std::max(x1, x2);
+        } else if (discriminant == 0) {
+            double x = static_cast<double>(-b) / (2 * a);
+            std::cout << std::defaultfloat << std::setprecision(6) << x;
+        } else {
+            std::cout << "no solutions";
+        }
+    }
 }

01_week/tasks/rms/rms.cpp

@@ -1,7 +1,14 @@
-#include <cstdef>
-#include <stdexcept>
+#include <cstddef>
+#include <cmath>
 
 
 double CalculateRMS(double values[], size_t size) {
-    throw std::runtime_error{"Not implemented"};
+    if (size <= 0 || values == nullptr){ return 0.0; }
+
+    double sum = 0;
+    for (size_t i=0; i < size; i++){
+        sum+=std::pow(values[i], 2);
+    }
+
+    return std::sqrt(sum / size);
 }

02_week/tasks/func_array/func_array.cpp

@@ -1,6 +1,19 @@
-#include <stdexcept>
+#include <cstddef>
 
+using funcPtr = double (*)(double, double);
 
-double ApplyOperations(double a, double b /* other arguments */) {
-    throw std::runtime_error{"Not implemented"};
+double ApplyOperations(const double a, const double b, funcPtr* arr, size_t funcArraySize) {
+    if (arr == nullptr || funcArraySize <= 0){
+        return 0.0;
+    }
+
+    double cumulative_result = 0;
+    for (unsigned int i=0; i < funcArraySize; ++i){
+        if (arr[i] == nullptr){
+            continue;
+        }
+        cumulative_result+=arr[i](a, b);
+    }
+
+    return cumulative_result;
 }

02_week/tasks/last_of_us/README.md

@@ -4,7 +4,7 @@
 элемент, удовлетворяющий условию функции предиката. Функция принимает два
 указателя на начало и конец целочисленного массива, а также указатель на 
 функцию предикат, и возвращает указатель на найденный элемент. Если элемент 
-не найден, то возвращается указатель за последний элемент.
+не найден, то возвращается указатель на последний элемент.
 
 Указатели соответствуют диапазону $[begin, end)$.
 

02_week/tasks/last_of_us/last_of_us.cpp

@@ -1,6 +1,30 @@
-#include <stdexcept>
+#include <cstddef>
 
+using funcPtr = bool (*)(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, funcPtr predicate) {
+    if (begin == nullptr || end == nullptr || predicate == nullptr){
+        return end;
+    }
+
+    if (begin >= end){
+        return end;
+    }
+
+    const int* last_element = nullptr;
+
+    while (begin < end)
+    {
+        if (predicate(*begin)){
+            last_element = begin;
+        }
+
+        ++begin;
+    }
+
+    if (last_element == nullptr){
+        return end;
+    }
+
+    return last_element;
 }