Бобровских Сергей

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/check_flags/check_flags.cpp

@@ -1,5 +1,6 @@
 #include <cstdint>
 #include <stdexcept>
+#include <iostream>
 
 
 enum class CheckFlags : uint8_t {
@@ -14,5 +15,40 @@ 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 == 0) {
+        std::cout << "[]";
+        return;
+    }
+    if (value > static_cast<uint8_t>(CheckFlags::ALL)) {
+        return;
+    }
+    // Последнее значение
+    if (value == static_cast<uint8_t>(CheckFlags::ALL)) {
+        std::cout << "[TIME,DATE,USER,CERT,KEYS,DEST]";
+        return;
+    }
+
+    std::cout << "[";
+    bool first = true;
+
+    const std::pair<CheckFlags, const char*> flag_names[] = {
+        {CheckFlags::TIME, "TIME"},
+        {CheckFlags::DATE, "DATE"},
+        {CheckFlags::USER, "USER"},
+        {CheckFlags::CERT, "CERT"},
+        {CheckFlags::KEYS, "KEYS"},
+        {CheckFlags::DEST, "DEST"}
+    };
+
+    for (const auto& [flag, name] : flag_names) {
+        if (value & static_cast<uint8_t>(flag)) {
+            if (!first) std::cout << ",";
+            std::cout << name;
+            first = false;
+        }
+    }
+
+    std::cout << "]";
 }

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,55 @@
+double FT_IN_M = 1.0 / 0.3048;
+double FT_IN_INCHES = 12.0;
+double INCH_IN_CM = 2.54;
+
+// Футы в другие величины
+double operator""_ft_to_m(long double ft) {
+    return ft / FT_IN_M;
+}
+
+double operator""_ft_to_cm(long double ft) {
+    return ft / FT_IN_M * 100.0;
+}
+
+double operator""_ft_to_in(long double ft) {
+    return ft * FT_IN_INCHES;
+}
+
+// Дюймы в другие величины
+double operator""_in_to_ft(long double in) {
+    return in / FT_IN_INCHES;
+}
+
+double operator""_in_to_cm(long double in) {
+    return in * INCH_IN_CM;
+}
+
+double operator""_in_to_m(long double inches) {
+    return inches * INCH_IN_CM / 100;
+}
+
+// См в другие величины
+double operator""_cm_to_m(long double centimeters) {
+    return centimeters / 100;
+}
+
+double operator""_cm_to_in(long double centimeters) {
+    return centimeters / INCH_IN_CM;
+}
+
+double operator""_cm_to_ft(long double centimeters) {
+    return centimeters / (FT_IN_INCHES * INCH_IN_CM);
+}
+
+// Метры в другие величины
+double operator""_m_to_ft(long double meters) {
+    return meters * 100 / (INCH_IN_CM * FT_IN_INCHES);
+}
+
+double operator""_m_to_in(long double meters) {
+    return meters * 100 / INCH_IN_CM;
+}
+
+double operator""_m_to_cm(long double meters) {
+    return meters * 100;
+}

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,27 @@
 #include <cstddef>
 #include <stdexcept>
+#include <iostream>
 
 
 void PrintBits(long long value, size_t bytes) {
-    throw std::runtime_error{"Not implemented"};
+    using std::cout;
+    // Проверка корректности размера
+    if (bytes == 0 || bytes > 8) {
+        return;
+    }
+    std::cout << "0b";
+
+    // Проходим по всем битам, начиная со старшего
+    for (size_t pos = bytes * 8; pos > 0; --pos) {        
+        // Получаем значение бита на текущей позиции
+        int bit = (value >> (pos - 1)) & 1;
+        std::cout << bit;
+
+        // Добавляем апостроф между байтами (после каждых 4 бит, кроме последней группы)
+        if ((pos - 1) > 0 && (pos - 1) % 4 == 0) {
+            std::cout << "'";
+        }
+    }
+
+    std::cout << "\n";
 }

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,56 @@
 #include <stdexcept>
+#include <iomanip>
+#include <iostream>
+#include <cmath>
 
+void PrintRoot(double x) {
+    // Для избавления от заведомо небольших значений
+    if (std::abs(x) < 1e-10) {
+        x = 0.0;
+    }
+    std::cout << std::setprecision(6) << x;
+}
 
 void SolveQuadratic(int a, int b, int c) {
-    throw std::runtime_error{"Not implemented"};
+    if(a == 0 && b == 0 && c == 0) {
+        std::cout << "infinite solutions";
+        return;
+    }
+
+    double a_ = static_cast<double>(a);
+    double b_ = static_cast<double>(b);
+    double c_ = static_cast<double>(c);
+
+    if(a_ == 0) {
+        if(b_ == 0) {
+            // Нет решений
+            std::cout << "no solutions";
+        } else {
+            // Один корень линейного уравнения
+            PrintRoot(-c_ / b_);
+        }
+        return;
+    }
+
+    double D = b_*b_ - 4*a_*c_;
+    if (D > 0) {
+        double sqrt_d = std::sqrt(D);
+        double x1 = (-b_ - sqrt_d) / (2.0 * a_);
+        double x2 = (-b_ + sqrt_d) / (2.0 * a_);
+
+        // Гарантируем, что x1 < x2
+        if (x1 > x2) {
+            std::swap(x1, x2);
+        }
+        PrintRoot(x1); 
+        std::cout << " ";
+        PrintRoot(x2);
+    }
+    else if (D == 0) {
+        double x = -b_ / (2.0 * a_);
+        PrintRoot(x);
+    }
+    else {
+        std::cout << "no solutions";
+    }
 }

01_week/tasks/rms/rms.cpp

@@ -1,7 +1,15 @@
-#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 == nullptr) {    // Проверка на отсутствие элементов в массиве и на нулевой указатель
+        return 0.0;
+    }
+    double square_sum = 0.0;
+    for(size_t i = 0; i < size; ++i) {
+        square_sum += values[i] * values[i];
+    }
+    return sqrt(square_sum/size);
 }

02_week/tasks/func_array/func_array.cpp

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

02_week/tasks/last_of_us/last_of_us.cpp

@@ -1,6 +1,11 @@
 #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)(const int)) {
+    if((begin > end) || (begin == nullptr) || (end == nullptr)) return end;
+
+    for(const int* ptr = end - 1; ptr >= begin; --ptr) {
+        if (predicate(*ptr)) {return ptr;}
+    }
+    return end;
 }

02_week/tasks/little_big/little_big.cpp

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

02_week/tasks/longest/longest.cpp

@@ -1,6 +1,34 @@
 #include <stdexcept>
 
 
-/* return_type */ FindLongestSubsequence(/* ptr_type */ begin, /* ptr_type */ end, /* type */ count) {
-    throw std::runtime_error{"Not implemented"};
+char* FindLongestSubsequence(const char* begin, const char* end, size_t& count) {
+    if (begin == nullptr || end == nullptr || begin >= end) {
+        count = 0;
+        return nullptr;
+    }
+
+    const char* longest_ptr = begin;
+    const char* current_ptr = begin;
+    size_t max_count = 1; 
+    size_t current_count = 1;
+
+    for (const char* ptr = begin + 1; ptr < end; ++ptr) {
+        if (*ptr == *(ptr - 1)) {
+            current_count++;
+        } else {
+            if(current_count > max_count) {
+                max_count = current_count;
+                longest_ptr = current_ptr;
+            }
+            current_ptr = ptr;
+            current_count = 1;
+        }
+    }
+
+    if(current_count > max_count) {
+        max_count = current_count;
+        longest_ptr = current_ptr;
+    }
+    count = max_count;
+    return const_cast<char*>(longest_ptr);
 }

02_week/tasks/pretty_array/pretty_array.cpp

@@ -1,6 +1,38 @@
 #include <stdexcept>
+#include <iostream>
 
-
-void PrintArray(/* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
+void PrintArray(const int* begin, const int* end, int constraint = 0) {
+    if (begin == end || begin == nullptr || end == nullptr)
+    {
+        std::cout << "[]\n";
+        return;
+    }
+
+    int count = 0;
+    std::cout << "[";
+    if(begin < end) {
+        for(const int* ptr = begin; ptr < end; ++ptr) {
+            if((count == constraint) && (constraint != 0)) {
+                count = 0;
+                std::cout << "...\n ";
+            }
+            std::cout << *ptr;
+            if(ptr != end - 1) { std::cout << ", "; }
+            ++count;
+        }
+        std::cout << "]\n";
+    } else {
+        ++end;
+        for(const int* ptr = begin; ptr >= end; --ptr) {
+            if((count == constraint) && (constraint != 0)) {
+                count = 0;
+                std::cout << "...\n ";
+            }
+            std::cout << *ptr;
+            if(ptr != end) { std::cout << ", "; }
+            if(ptr == end) { break; }
+            ++count;
+        }
+        std::cout << "]\n";
+    }
 }