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

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

01_week/tasks/char_changer/char_changer.cpp

@@ -1,7 +1,47 @@
 #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 counterRepeatedSymbols = 1; // Счётчик повторяющихся символов
+    int pos_write = 0;   // Индекс для записи обработанного символа
+    char repeating_symbol = array[0]; // В процессе выполнения - предыдущий символ(отслеживаем повторения)
+
+    for (char* ptr = array + 1; repeating_symbol != '\0'; ++ptr) {
+        if (repeating_symbol == *ptr){
+            ++counterRepeatedSymbols;
+            continue;
+        } 
+
+        if (isalpha(repeating_symbol)){
+            array[pos_write] = toupper(repeating_symbol);
+        } else if (isdigit(repeating_symbol)){
+            array[pos_write] = '*';
+        } else if (repeating_symbol == ' '){
+            array[pos_write] = delimiter;
+        } else {
+            array[pos_write] = '_';
+        }
+        ++pos_write;
+
+
+        if (repeating_symbol == ' ') {
+            counterRepeatedSymbols = 1;
+        }
+
+        if (counterRepeatedSymbols >= 10){
+            counterRepeatedSymbols = 0;
+        }
+
+        if (counterRepeatedSymbols != 1){
+            array[pos_write] = static_cast<char>(counterRepeatedSymbols + '0'); // Преобразуем число в символ
+            counterRepeatedSymbols = 1;
+            ++pos_write;
+        }
+
+        repeating_symbol = *ptr;
+    }
+
+    array[pos_write] = '\0';
+    return pos_write;     
 }

01_week/tasks/check_flags/README.md

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

01_week/tasks/check_flags/check_flags.cpp

@@ -1,5 +1,5 @@
 #include <cstdint>
-#include <stdexcept>
+#include <iostream>
 
 
 enum class CheckFlags : uint8_t {
@@ -14,5 +14,47 @@ 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::cout << "[";
+    bool first = true;
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::TIME)) != 0) {
+        if (!first) std::cout << ",";
+        std::cout << "TIME";
+        first = false;
+    }
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::DATE)) != 0) {
+        if (!first) std::cout << ",";
+        std::cout << "DATE";
+        first = false;
+    }
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::USER)) != 0) {
+        if (!first) std::cout << ",";
+        std::cout << "USER";
+        first = false;
+    }
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::CERT)) != 0) {
+        if (!first) std::cout << ",";
+        std::cout << "CERT";
+        first = false;
+    }
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::KEYS)) != 0) {
+        if (!first) std::cout << ",";
+        std::cout << "KEYS";
+        first = false;
+    }
+    if ((static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::DEST)) != 0) {
+        if (!first) std::cout << ",";
+        std::cout << "DEST";
+        first = false;
+    }
+    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/last_of_us.cpp

@@ -1,6 +1,25 @@
-#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 = end;
+
+    while (begin < end)
+    {
+        --end;
+        if (predicate(*end)){
+            return end;
+        }
+    }
+
+    return last_element;
 }

02_week/tasks/little_big/little_big.cpp

@@ -1,10 +1,47 @@
-#include <stdexcept>
+#include <iostream>
+#include <iomanip>
+#include <cstring>
+#include <algorithm>
 
 
-void PrintMemory(int /* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
+void PrintMemory(int number, bool inversion = false) {
+    unsigned char* bytes = reinterpret_cast<unsigned char*>(&number);
+
+    std::cout << "0x";
+    if (inversion) {
+        // Читаем байты в обратном порядке сразу при выводе
+        for (size_t i = sizeof(int); i > 0; --i) {
+            std::cout << std::hex << std::uppercase 
+                      << std::setfill('0') << std::setw(2) 
+                      << static_cast<unsigned int>(bytes[i-1]);
+        }
+    } else {
+        for (size_t i = 0; i < sizeof(int); ++i) {
+            std::cout << std::hex << std::uppercase 
+                      << std::setfill('0') << std::setw(2) 
+                      << static_cast<unsigned int>(bytes[i]);
+        }
+    }
+    std::cout << std::dec << std::endl;
 }
 
-void PrintMemory(double /* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
+void PrintMemory(double number, bool inversion = false) {
+    unsigned char* bytes = reinterpret_cast<unsigned char*>(&number);
+
+    std::cout << "0x";
+    if (inversion) {
+        // Читаем байты в обратном порядке сразу при выводе
+        for (size_t i = sizeof(double); i > 0; --i) {
+            std::cout << std::hex << std::uppercase 
+                      << std::setfill('0') << std::setw(2) 
+                      << static_cast<unsigned int>(bytes[i-1]);
+        }
+    } else {
+        for (size_t i = 0; i < sizeof(double); ++i) {
+            std::cout << std::hex << std::uppercase 
+                      << std::setfill('0') << std::setw(2) 
+                      << static_cast<unsigned int>(bytes[i]);
+        }
+    }
+    std::cout << std::dec << std::endl;
 }