Жамбакиев Радий

.gitignore

@@ -0,0 +1,2 @@
+/build
+/build-asan

01_week/tasks/addition/addition.cpp

@@ -1,7 +1,5 @@
 #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,71 @@
+#include <cctype>
 #include <cstddef>
-#include <stdexcept>
 
+// Есть ощущение, что это можно решить как-то более лаконично и просто
+
+/**
+ * @brief Получить длину последовательности из одинаковых знаков.
+ * @param array указатель на элемент массива, с которого начнется проверка.
+ * @return Длина последовательности.
+ * @note Все символы будут сравниваться с первым из переданного массива.
+ */
+size_t GetIdenticalCharSequenceLen(char *array) {
+    size_t sequenceLen = 0;
+    if (array[0] == '\0') return 0;
+    while (array[0] == array[sequenceLen]) ++sequenceLen;
+    return sequenceLen;
+}
+
+/**
+ * @brief Сконвертировать одинаковые символы.
+ * @param array указатель на начало обрабатываемого массива.
+ * @param convertedSymIdx ссылка на индекс последнего сконвертированного символа.
+ * @param currentSymIdx ссылка на индекс текущего обрабатываемого символа.
+ * @param swapChar символ, на который будет произведена замена array[convertedSymIdx].
+ * @return none
+ */
+void ConvertIdenticalCharacters(char array[], size_t& convertedSymIdx, size_t& currentSymIdx, char swapChar) {  
+    size_t sequenceLen = GetIdenticalCharSequenceLen(&array[currentSymIdx]);
+
+    array[convertedSymIdx++] = swapChar;
+
+    if (sequenceLen == 1) {
+        currentSymIdx += sequenceLen;
+        return;    
+    }
+
+    array[convertedSymIdx++] = sequenceLen >= 10 ? '0' : sequenceLen + '0';
+
+    currentSymIdx += sequenceLen;
+}
 
 size_t CharChanger(char array[], size_t size, char delimiter = ' ') {
-    throw std::runtime_error{"Not implemented"};
+    size_t convertedSymbolIdx = 0, currentSymbolIdx = 0;
+
+    while(currentSymbolIdx < size && convertedSymbolIdx < size) {
+        if (array[currentSymbolIdx] == '\0') {
+            break;
+        }
+
+        if (isspace(array[currentSymbolIdx])) {
+            currentSymbolIdx += GetIdenticalCharSequenceLen(&array[currentSymbolIdx]);
+            array[convertedSymbolIdx++] = delimiter;
+            continue;
+        }
+
+        if (isalnum(array[currentSymbolIdx])) {
+            if (isdigit(array[currentSymbolIdx])) {
+                ConvertIdenticalCharacters(array, convertedSymbolIdx, currentSymbolIdx, '*');
+                continue;
+            }
+
+            ConvertIdenticalCharacters(array, convertedSymbolIdx, currentSymbolIdx, toupper(array[currentSymbolIdx]));
+            continue;
+        }
+
+        ConvertIdenticalCharacters(array, convertedSymbolIdx, currentSymbolIdx, '_');    
+    }
+
+    array[convertedSymbolIdx] = '\0';
+    return convertedSymbolIdx;
 }

01_week/tasks/check_flags/check_flags.cpp

@@ -1,6 +1,7 @@
 #include <cstdint>
-#include <stdexcept>
-
+#include <iostream>
+#include <string>
+#include <vector>
 
 enum class CheckFlags : uint8_t {
     NONE = 0,
@@ -13,6 +14,43 @@ enum class CheckFlags : uint8_t {
     ALL = TIME | DATE | USER | CERT | KEYS | DEST
 };
 
+namespace {
+    const std::vector<std::pair<CheckFlags, std::string_view>> checkNames = {
+        {CheckFlags::TIME, "TIME"},
+        {CheckFlags::DATE, "DATE"},
+        {CheckFlags::USER, "USER"},
+        {CheckFlags::CERT, "CERT"},
+        {CheckFlags::KEYS, "KEYS"},
+        {CheckFlags::DEST, "DEST"},
+    };    
+}
+
+
 void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
+    if (flags > CheckFlags::ALL) { 
+        return;
+    }
+
+    if (flags == CheckFlags::NONE) {
+        std::cout << "[]";
+        return;
+    }
+
+    std::string needed_checks = "[";
+
+    bool first = true;
+    for (const auto& [key, val] : checkNames) {
+        if (static_cast<uint8_t>(flags) & static_cast<uint8_t>(key)) {
+            if (!first) {
+                needed_checks += ","; 
+            }
+
+            needed_checks += val;
+            first = false;
+        } 
+    }
+
+    needed_checks += "]";
+
+    std::cout << needed_checks;
 }

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,51 @@
+constexpr long double METER_IN_FOOT = 0.3048;
+constexpr long double INCH_IN_FOOT = 12;
+constexpr long double METER_IN_INCH = 0.0254;
+
+constexpr long double operator""_ft_to_m(long double foot) {
+    return foot * METER_IN_FOOT;
+}
+
+constexpr long double operator""_m_to_ft(long double meter) {
+    return meter / METER_IN_FOOT;
+}
+
+constexpr long double operator""_ft_to_cm(long double foot) {
+    return foot * METER_IN_FOOT * 100;
+}
+
+constexpr long double operator""_cm_to_ft(long double cm) {
+    return cm / (METER_IN_FOOT * 100);
+}
+
+constexpr long double operator""_ft_to_in(long double foot) {
+    return foot * INCH_IN_FOOT;
+}
+
+constexpr long double operator""_in_to_ft(long double inch) {
+    return inch / INCH_IN_FOOT;
+}
+
+constexpr long double operator""_in_to_m(long double inch) {
+    return inch * METER_IN_INCH;
+}
+
+constexpr long double operator""_m_to_in(long double meter) {
+    return meter / METER_IN_INCH;
+}
+
+constexpr long double operator""_in_to_cm(long double inch) {
+    return inch * METER_IN_INCH * 100;
+}
+
+constexpr long double operator""_cm_to_in(long double inch) {
+    return inch / (METER_IN_INCH * 100);
+}
+
+constexpr long double operator""_m_to_cm(long double meter) {
+    return meter * 100;
+}
+
+constexpr long double operator""_cm_to_m(long double cm) {
+    return cm / 100;
+}

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,17 @@
 #include <cstddef>
 #include <stdexcept>
-
+#include <string>
 
 void PrintBits(long long value, size_t bytes) {
-    throw std::runtime_error{"Not implemented"};
+    std::string byteForm = "0b";
+    // i < bytes * 8 сработает, потому что 0ULL - 1 переполняется в ULL_MAX
+    for (size_t i = (bytes * 8 - 1); i < bytes * 8; --i) {
+       byteForm += ((value >> i) & 0x01U) + '0';
+
+       if (i != 0 && i % 4 == 0) {
+            byteForm += "'";    
+       }
+    }
+
+    std::cout << byteForm << std::endl;
 }

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,61 @@
-#include <stdexcept>
+#include <cmath>
+#include <iomanip>
+#include <iostream>
 
+// Уверен, что это можно сделать значительно качественнее, но дедлайн близко,
+// поэтому спагетти код >:)
 
-void SolveQuadratic(int a, int b, int c) {
-    throw std::runtime_error{"Not implemented"};
-}
+void SolveQuadratic(int a, int b, int c) { 
+    if (a == 0 && b == 0 && c == 0) {
+        std::cout << "infinite solutions";
+        return;
+    }
+
+    if (a == 0 && b == 0) {
+        std::cout << "no solutions";
+        return;
+    }
+
+    std::cout << std::setprecision(6);
+
+    if (a == 0) {
+        std::cout << static_cast<double>(-c) / b;
+        return;
+    }
+
+    if (b == 0) {
+        if (static_cast<double>(-c) / a < 0) {
+            std::cout << "no solutions";
+            return;
+        }
+
+        double root = std::sqrt(static_cast<double>(-c) / a);
+
+        if (root == 0) {
+            std::cout << root;
+        } else {
+            std::cout << -root << " " << root;
+        }
+
+        return;
+    }
+
+    double discriminant = static_cast<double>(b) * b - 4.0 * a * c;
+    double root1 = 0.0, root2 = 0.0;
+
+    if (discriminant == 0) {
+        std::cout << -b / (2.0 * a);
+        return;   
+    }
+
+    if (discriminant < 0) {
+        std::cout << "no solutions";
+        return;
+    }
+
+    root1 = ((-b - std::sqrt(discriminant)) / (2.0 * a));
+    root2 = ((-b + std::sqrt(discriminant)) / (2.0 * a));
+
+    root1 > root2 ? std::cout << root2 << " " << root1 :
+                  std:: cout << root1 << " " << root2;
+}

01_week/tasks/rms/rms.cpp

@@ -1,7 +1,15 @@
-#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) {
+        return 0.0;
+    }
+
+    double sum = 0.0;
+    for (size_t i = 0; i < size; ++i) {
+       sum += values[i] * values[i];
+    }
+
+    return std::sqrt(sum / static_cast<double>(size));
+}

02_week/tasks/func_array/func_array.cpp

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

02_week/tasks/last_of_us/last_of_us.cpp

@@ -1,6 +1,17 @@
-#include <stdexcept>
+typedef bool (*predicate_func_t)(int);
 
+const int* FindLastElement(const int* begin, const int* end, predicate_func_t predicate) {
+    if (!begin || !end || begin >= end) {
+        return end;
+    }
+
+    const int* result = end;
+    while (begin != end) {
+        if (predicate(*begin)) {
+            result = begin;
+        }
+        ++begin;
+    }
 
-/* return_type */ FindLastElement(/* ptr_type */ begin, /* ptr_type */ end, /* func_type */ predicate) {
-    throw std::runtime_error{"Not implemented"};
-}
+    return result;
+}

02_week/tasks/little_big/little_big.cpp

@@ -1,10 +1,29 @@
-#include <stdexcept>
+#include <cstring>
+#include <iostream>
 
+template<typename T>
+void PrintMemory(T num, bool isReversed = false) {
+    std::string output = "";
 
-void PrintMemory(int /* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
-}
+    // Надеюсь использование memcpy разрешено
+    unsigned char bytes[sizeof(T)];
+    std::memcpy(bytes, &num, sizeof(T));
+
+    size_t start = isReversed ? (sizeof(T) - 1) : 0;
+    int step = isReversed ? -1 : 1;
+
+    for (size_t i = start; i < sizeof(T); i += step) {
+        unsigned char currentByte = bytes[i];
+
+        for (int j = 4; j >= 0; j -= 4) {
+            int remainder = (currentByte >> j) & 0xf;
+            char hexChar = 0;
 
-void PrintMemory(double /* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
-}
+            hexChar = remainder < 10 ? '0' + remainder : 'A' + (remainder - 10);
+
+            output += hexChar;
+        }
+    }
+    output = "0x" + output;
+    std::cout << output << std::endl;
+}