Рычков Григорий

01_week/tasks/addition/addition.cpp

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

01_week/tasks/check_flags/check_flags.cpp

@@ -1,18 +1,45 @@
-#include <cstdint>
-#include <stdexcept>
-
-
-enum class CheckFlags : uint8_t {
-    NONE = 0,
-    TIME = (1 << 0),
-    DATE = (1 << 1),
-    USER = (1 << 2),
-    CERT = (1 << 3),
-    KEYS = (1 << 4),
-    DEST = (1 << 5),
-    ALL = TIME | DATE | USER | CERT | KEYS | DEST
-};
-
-void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
-}
+#include <cstdint>
+#include <stdexcept>
+
+
+enum class CheckFlags : uint8_t {
+    NONE = 0,
+    TIME = (1 << 0),
+    DATE = (1 << 1),
+    USER = (1 << 2),
+    CERT = (1 << 3),
+    KEYS = (1 << 4),
+    DEST = (1 << 5),
+    ALL = TIME | DATE | USER | CERT | KEYS | DEST
+};
+
+void PrintCheckFlags(CheckFlags flags) {
+    uint8_t value = static_cast<uint8_t>(flags);
+    const uint8_t valid_mask = 0x3F; // 0b00111111
+
+    if (value & ~valid_mask) {
+        std::cout << "";
+        return;
+    }
+
+    std::string output = "[";
+    const char* separator = "";
+
+    auto add_flag = [&](CheckFlags flag, const char* name) {
+        if (value & static_cast<uint8_t>(flag)) {
+            output += separator;
+            output += name;
+            separator = ",";
+        }
+    };
+
+    add_flag(CheckFlags::TIME, "TIME");
+    add_flag(CheckFlags::DATE, "DATE");
+    add_flag(CheckFlags::USER, "USER");
+    add_flag(CheckFlags::CERT, "CERT");
+    add_flag(CheckFlags::KEYS, "KEYS");
+    add_flag(CheckFlags::DEST, "DEST");
+
+    output += "]";
+    std::cout << output;
+}

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,53 @@
+#include <cmath>
+
+constexpr double operator "" _ft_to_m(long double value) {
+    return static_cast<double>(value * 0.3048);
+}
+
+constexpr double operator "" _ft_to_cm(long double value) {
+    return static_cast<double>(value * 30.48);
+}
+
+constexpr double operator "" _ft_to_in(long double value) {
+    return static_cast<double>(value * 12.0);
+}
+
+constexpr double operator "" _in_to_m(long double value) {
+    return static_cast<double>(value * 0.0254);
+}
+
+constexpr double operator "" _in_to_cm(long double value) {
+    return static_cast<double>(value * 2.54);
+}
+
+constexpr double operator "" _in_to_ft(long double value) {
+    return static_cast<double>(value / 12.0);
+}
+
+constexpr double operator "" _m_to_ft(long double value) {
+    return static_cast<double>(value / 0.3048);
+}
+
+constexpr double operator "" _m_to_in(long double value) {
+    return static_cast<double>(value / 0.0254);
+}
+
+constexpr double operator "" _m_to_cm(long double value) {
+    return static_cast<double>(value * 100.0);
+}
+
+constexpr double operator "" _cm_to_m(long double value) {
+    return static_cast<double>(value * 0.01);
+}
+
+constexpr double operator "" _cm_to_ft(long double value) {
+    return static_cast<double>(value / 30.48);
+}
+
+constexpr double operator "" _cm_to_in(long double value) {
+    return static_cast<double>(value / 2.54);
+
+}
+
+
+

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,29 @@
-#include <cstddef>
-#include <stdexcept>
-
-
-void PrintBits(long long value, size_t bytes) {
-    throw std::runtime_error{"Not implemented"};
-}
+#include <iostream>
+
+void PrintBits(long long value, size_t bytes) {
+    if (bytes == 0 || bytes > 8) {
+        return;
+    }
+
+    const size_t total_bits = bytes * 8;
+    unsigned long long unsigned_value = value;
+
+    std::cout << "0b";
+
+    for (size_t i = 0; i < total_bits; ++i) {
+        size_t bit_pos = total_bits - 1 - i;
+        unsigned long long mask = 1ULL << bit_pos;
+
+        if (unsigned_value & mask) {
+            std::cout << '1';
+        } else {
+            std::cout << '0';
+        }
+
+        if ((i + 1) % 4 == 0 && i != total_bits - 1) {
+            std::cout << "'";
+        }
+    }
+
+    std::cout << '\n';
+}

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,56 @@
-#include <stdexcept>
-
-
-void SolveQuadratic(int a, int b, int c) {
-    throw std::runtime_error{"Not implemented"};
+#include <iostream>
+#include <iomanip>
+#include <cmath>
+#include <utility>
+
+void SolveQuadratic(int a, int b, int c) {
+    std::cout << std::setprecision(6);
+
+    if (a == 0 && b == 0 && c == 0) {
+        std::cout << "infinite solutions";
+        return;
+    }
+
+    if (a == 0 && b == 0 && c != 0) {
+        std::cout << "no solutions";
+        return;
+    }
+
+    if (a == 0) {
+        double root = -static_cast<double>(c) / b;
+
+        if (root == 0.0) root = 0.0;
+
+        std::cout << root;
+        return;
+    }
+
+    double discr = static_cast<double>(b) * b - 4.0 * a * c;
+
+    if (discr < 0) {
+        std::cout << "no solutions";
+        return;
+    }
+
+    if (discr == 0) {
+        double root = -static_cast<double>(b) / (2.0 * a);
+
+        if (root == 0.0) root = 0.0;
+
+        std::cout << root;
+        return;
+    }
+
+    double sqrt_d = std::sqrt(discr);
+    double root1 = (-static_cast<double>(b) - sqrt_d) / (2.0 * a);
+    double root2 = (-static_cast<double>(b) + sqrt_d) / (2.0 * a);
+
+    if (root1 > root2) {
+        std::swap(root1, root2);
+    }
+
+    if (root1 == 0.0) root1 = 0.0;
+    if (root2 == 0.0) root2 = 0.0;
+
+    std::cout << root1 << " " << root2;
 }

01_week/tasks/rms/rms.cpp

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

02_week/tasks/func_array/func_array.cpp

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

02_week/tasks/last_of_us/last_of_us.cpp

@@ -1,6 +1,22 @@
 #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 == nullptr || end == nullptr || begin > end) {
+        return end;
+    }
+
+    const int* last_found = end;
+
+    // Проходим по массиву с конца к началу
+    const int* current = end;
+    while (current > begin) {
+        --current; 
+        if (predicate(*current)) {
+            last_found = current;
+            break;
+        }
+    }
+
+    return last_found;
+}

02_week/tasks/longest/longest.cpp

@@ -1,6 +1,48 @@
 #include <stdexcept>
 
+template<typename CharType>
+CharType* FindLongestSubsequenceImpl(CharType* begin, CharType* end, size_t& count) {
+    if (begin == nullptr || end == nullptr || begin > end) {
+        count = 0;
+        return nullptr;
+    }
+
+    if (begin == end) {
+        count = 0;
+        return nullptr;
+    }
+
+    CharType* longest_start = begin;
+    size_t longest_length = 1;
+    CharType* current_start = begin;
+    size_t current_length = 1;
+
+    for (CharType* ptr = begin; ptr < end - 1; ++ptr) {
+        if (*ptr == *(ptr + 1)) {
+            current_length++;
+        } else {
+            if (current_length > longest_length) {
+                longest_length = current_length;
+                longest_start = current_start;
+            }
+            current_start = ptr + 1;
+            current_length = 1;
+        }
+    }
+
+    if (current_length > longest_length) {
+        longest_length = current_length;
+        longest_start = current_start;
+    }
+
+    count = longest_length;
+    return longest_start;
+}
+
+const char* FindLongestSubsequence(const char* begin, const char* end, size_t& count) {
+    return FindLongestSubsequenceImpl(begin, end, count);
+}
 
-/* return_type */ FindLongestSubsequence(/* ptr_type */ begin, /* ptr_type */ end, /* type */ count) {
-    throw std::runtime_error{"Not implemented"};
+char* FindLongestSubsequence(char* begin, char* end, size_t& count) {
+    return FindLongestSubsequenceImpl(begin, end, count);
 }