Петров Николай

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

@@ -3,5 +3,55 @@
 
 
 size_t CharChanger(char array[], size_t size, char delimiter = ' ') {
-    throw std::runtime_error{"Not implemented"};
+    if (size == 0) return 0;
+
+    char* pread = array;
+    char* pwrite = array;
+
+    while (*pread != '\0' && (pread - array) < static_cast<ptrdiff_t>(size - 1)) {
+        char tek_char = *pread;
+        int repeat_count = 1;
+
+        // Ограничиваем подсчет повторений границами массива
+        while (repeat_count < static_cast<int>(size - (pread - array)) && 
+               pread[repeat_count] == tek_char) {
+            repeat_count++;
+        }
+
+        if (tek_char == ' ') {
+            *pwrite = delimiter;
+            pwrite++;
+            pread += repeat_count;
+            continue;
+        }
+
+        char temp;
+        if (std::isdigit(tek_char)) {
+            temp = '*';
+        } else if (std::isupper(tek_char)) {
+            temp = tek_char;
+        } else if (std::islower(tek_char)) {
+            temp = std::toupper(tek_char);
+        } else {
+            temp = '_';
+        }
+
+        *pwrite = temp;
+        pwrite++;
+
+        if (repeat_count > 1) {
+            if (repeat_count >= 10) {
+                *pwrite = '0';
+                pwrite++;
+            } else {
+                *pwrite = '0' + repeat_count;
+                pwrite++;
+            }
+        }
+
+        pread += repeat_count;
+    }
+
+    *pwrite = '\0';
+    return pwrite - array;
 }

01_week/tasks/check_flags/check_flags.cpp

@@ -1,6 +1,6 @@
 #include <cstdint>
 #include <stdexcept>
-
+#include <iostream>
 
 enum class CheckFlags : uint8_t {
     NONE = 0,
@@ -14,5 +14,26 @@ enum class CheckFlags : uint8_t {
 };
 
 void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
+    uint8_t value = static_cast<uint8_t>(flags);
+
+    // Проверяем, что значение находится в допустимом диапазоне
+    if (value > static_cast<uint8_t>(CheckFlags::ALL)) {
+        return;  // значение вне диапазона - ничего не выводим
+    }
+
+    if (value == 0) {
+        std::cout << "[]";  // нет флагов - выводим []
+        return;
+    }
+
+    std::cout << "[";
+
+    if (value & 1) std::cout << "TIME";
+    if (value & 2) std::cout << (value & 1 ? ",DATE" : "DATE");
+    if (value & 4) std::cout << (value & 3 ? ",USER" : "USER");
+    if (value & 8) std::cout << (value & 7 ? ",CERT" : "CERT");
+    if (value & 16) std::cout << (value & 15 ? ",KEYS" : "KEYS");
+    if (value & 32) std::cout << (value & 31 ? ",DEST" : "DEST");
+
+    std::cout << "]";
 }

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,47 @@
+constexpr double operator""_ft_to_m(long double feet) {
+    return feet * 0.3048;
+}
+
+constexpr double operator""_in_to_m(long double inches) {
+    return inches * 0.0254;
+}
+
+constexpr double operator""_cm_to_m(long double centimeters) {
+    return centimeters * 0.01;
+}
+
+constexpr double operator""_m_to_ft(long double meters) {
+    return meters / 0.3048;
+}
+
+constexpr double operator""_m_to_in(long double meters) {
+    return meters / 0.0254;
+}
+
+constexpr double operator""_m_to_cm(long double meters) {
+    return meters / 0.01;
+}
+
+constexpr double operator""_ft_to_cm(long double feet) {
+    return operator""_m_to_cm(operator""_ft_to_m(feet));
+}
+
+constexpr double operator""_ft_to_in(long double feet) {
+    return operator""_m_to_in(operator""_ft_to_m(feet));
+}
+
+constexpr double operator""_in_to_ft(long double inches) {
+    return operator""_m_to_ft(operator""_in_to_m(inches));
+}
+
+constexpr double operator""_in_to_cm(long double inches) {
+    return operator""_m_to_cm(operator""_in_to_m(inches));
+}
+
+constexpr double operator""_cm_to_ft(long double centimeters) {
+    return operator""_m_to_ft(operator""_cm_to_m(centimeters));
+}
+
+constexpr double operator""_cm_to_in(long double centimeters) {
+    return operator""_m_to_in(operator""_cm_to_m(centimeters));
+}

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,30 @@
-#include <cstddef>
 #include <stdexcept>
-
+#include <cstddef>
+#include <iostream>
 
 void PrintBits(long long value, size_t bytes) {
-    throw std::runtime_error{"Not implemented"};
+    if (bytes < 1 || bytes > 8) {
+        return;
+    }
+
+    std::cout << "0b";
+
+    size_t total_bits = bytes * 8;
+    size_t bits_printed = 0;
+
+    // Проходим по всем битам от старшего к младшему
+    for (int byte = bytes - 1; byte >= 0; --byte) {
+        for (int bit = 7; bit >= 0; --bit) {
+            // Получаем текущий бит (сдвигаем и маскируем)
+            long long current_bit = (value >> (byte * 8 + bit)) & 1;
+            std::cout << current_bit;
+            bits_printed++;
+
+            if (bits_printed % 4 == 0 && bits_printed < total_bits) {
+                std::cout << "'";
+            }
+        }
+    }
+
+    std::cout << std::endl;
 }

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,60 @@
+#include <iostream>
+#include <iomanip>
+#include <cmath>
 #include <stdexcept>
 
-
 void SolveQuadratic(int a, int b, int c) {
-    throw std::runtime_error{"Not implemented"};
+    // a,b,c=0
+    if (a == 0 && b == 0 && c == 0) {
+        std::cout << "infinite solutions";
+        return;
+    }
+
+    // a=0
+    if (a == 0) {
+        if (b == 0) {
+            // c=0
+            if (c == 0) {
+                std::cout << "infinite solutions";
+            } else {
+                std::cout << "no solutions";
+            }
+        } else {
+            // b*x+c=0
+            double x = -static_cast<double>(c) / b;
+            // Обработка случая -0.0
+            if (std::abs(x) < 1e-10) x = 0.0;
+            std::cout << std::setprecision(6) << x;
+        }
+        return;
+    }
+
+    // Вычисление D
+    double discriminant = static_cast<double>(b) * b - 4.0 * a * c;
+
+    if (discriminant < 0) {
+        // D<0
+        std::cout << "no solutions";
+    } else if (discriminant == 0) {
+        // D=0
+        double x = -static_cast<double>(b) / (2.0 * a);
+        // Обработка случая -0.0
+        if (std::abs(x) < 1e-10) x = 0.0;
+        std::cout << std::setprecision(6) << x;
+    } else {
+        // D>0
+        double sqrt_d = std::sqrt(discriminant);
+        double x1 = (-b - sqrt_d) / (2.0 * a);
+        double x2 = (-b + sqrt_d) / (2.0 * a);
+
+        // Обработка случая -0.0 для обоих корней
+        if (std::abs(x1) < 1e-10) x1 = 0.0;
+        if (std::abs(x2) < 1e-10) x2 = 0.0;
+
+        if (x1 > x2) {
+            std::swap(x1, x2);
+        }
+
+        std::cout << std::setprecision(6) << x1 << " " << x2;
+    }
 }

01_week/tasks/rms/rms.cpp

@@ -1,7 +1,21 @@
-#include <cstdef>
 #include <stdexcept>
-
+#include <cmath>
+#include <cstddef>
 
 double CalculateRMS(double values[], size_t size) {
-    throw std::runtime_error{"Not implemented"};
+    if (size == 0 || values == nullptr) {
+        return 0.0;
+    }
+
+    // Вычисление суммы квадратов элементов
+    double sum1 = 0.0;
+    for (size_t i = 0; i < size; ++i) {
+        sum1 += values[i] * values[i];
+    }
+
+    // Вычисление среднеквадратического значения
+    double squares = sum1 / size;
+    double rms = std::sqrt(squares);
+
+    return rms;
 }

02_week/tasks/func_array/func_array.cpp

@@ -1,6 +1,17 @@
 #include <stdexcept>
 
 
-double ApplyOperations(double a, double b /* other arguments */) {
-    throw std::runtime_error{"Not implemented"};
+double ApplyOperations(double a, double b, double (**ops)(double, double), size_t size) {
+    if (ops == nullptr || size == 0) {
+        return 0.0;
+    }
+
+    double sum = 0.0;
+    for (size_t i = 0; i < size; ++i) {
+        if (ops[i] != nullptr) {
+            sum += ops[i](a, b);
+        }
+    }
+
+    return sum;
 }

02_week/tasks/last_of_us/last_of_us.cpp

@@ -1,6 +1,17 @@
 #include <stdexcept>
 
 
-/* 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, bool (*predicate)(int)) {
+    if (begin > end || begin == end || end == nullptr || begin == nullptr) {
+        return end;
+    }
+    const int* p_pred = end;
+
+    for (size_t i = 1; (end-i) != (begin-1); ++i) {
+        if (predicate(*(end-i))) {
+            p_pred = end-i;
+            return p_pred;
+        }
+    }
+    return p_pred;
 }

02_week/tasks/little_big/little_big.cpp

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