Тутынина Полина

.github/workflows/testing.yml

@@ -28,9 +28,9 @@ jobs:
           echo "$changed_files"
 
           tasks=("addition" "rms" "print_bits" "check_flags" "length_lit" "quadratic" "char_changer"
-                 "swap_ptr" "func_array" "longest" "last_of_us" "little_big" "pretty_array"
-                 "data_stats" "unique" "range" "minmax" "find_all" "os_overload" "easy_compare" "filter" "enum_operators"
-                 "stack" "queue" "ring_buffer" "phasor")
+              "swap_ptr" "func_array" "longest" "last_of_us" "little_big" "pretty_array"
+              "data_stats" "easy_compare" "enum_operators" "filter" "find_all" "minmax" "os_overload" "range" "unique"
+              "phasor" "queue" "ring_buffer" "stack")
 
           declare -i passed_count=0
           declare -i failed_count=0
@@ -75,4 +75,4 @@ jobs:
           else
             echo "✅ All processed tasks passed!"
             exit 0
-          fi
+          fi

.gitignore

@@ -0,0 +1,3 @@
+build-*/
+a.out
+*.out

01_week/tasks/addition/addition.cpp

@@ -1,7 +1,7 @@
 #include <cstdint>
 #include <stdexcept>
 
-
+//Функция, которая суммирует два числа
 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

@@ -1,7 +1,104 @@
 #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 size, char delimiter) {
+    if (size == 0) return 0;
+
+    size_t write_pos = 0;
+    char prev_char = '\0';
+    char current_sequence_char = '\0';
+    size_t count = 0;
+    bool in_space_sequence = false;
+
+    for (size_t read_pos = 0; read_pos < size && array[read_pos] != '\0'; read_pos++) {
+        char current_char = array[read_pos];
+
+        // Обработка пробелов
+        if (current_char == ' ') {
+            // Если у нас есть незаписанная последовательность, записываем ее
+            if (current_sequence_char != '\0') {
+                array[write_pos++] = current_sequence_char;
+                if (count > 1) {
+                    if (count >= 10) {
+                        array[write_pos++] = '0';
+                    } else {
+                        array[write_pos++] = '0' + count;
+                    }
+                }
+                current_sequence_char = '\0';
+                count = 0;
+            }
+
+            // Добавляем разделитель для каждой группы пробелов
+            if (!in_space_sequence) {
+                array[write_pos++] = delimiter;
+                in_space_sequence = true;
+            }
+            continue;
+        }
+
+        // Не пробел - сбрасываем флаг последовательности пробелов
+        in_space_sequence = false;
+
+        // Преобразование символа
+        char transformed_char = current_char;
+
+        if (std::isdigit(current_char)) {
+            transformed_char = '*';
+        } else if (std::isalpha(current_char)) {
+            transformed_char = std::toupper(current_char);
+        } else if (current_char != ' ') {
+            transformed_char = '_';
+        }
+
+        // Обработка последовательностей символов
+        if (current_char == prev_char) {
+            count++;
+        } else {
+            // Запись предыдущей последовательности
+            if (current_sequence_char != '\0') {
+                array[write_pos++] = current_sequence_char;
+                if (count > 1) {
+                    if (count >= 10) {
+                        array[write_pos++] = '0';
+                    } else {
+                        array[write_pos++] = '0' + count;
+                    }
+                }
+            }
+            // Начало новой последовательности
+            prev_char = current_char;
+            current_sequence_char = transformed_char;
+            count = 1;
+        }
+    }
+
+    // Запись последней последовательности (если не пробел)
+    if (current_sequence_char != '\0') {
+        array[write_pos++] = current_sequence_char;
+        if (count > 1) {
+            if (count >= 10) {
+                array[write_pos++] = '0';
+            } else {
+                array[write_pos++] = '0' + count;
+            }
+        }
+    }
+
+    // Завершение строки
+    if (write_pos < size) {
+        array[write_pos] = '\0';
+    } else if (size > 0) {
+        array[size - 1] = '\0';
+    }
+
+    return write_pos;
+}

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,
@@ -14,5 +15,47 @@ 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; // выход за пределы диапазона - оставляем вывод пустым
+    }
+
+    // Если флаг NONE
+    if (flags == CheckFlags::NONE) {
+        std::cout << "[]";
+        return;
+    }
+
+    std::vector<std::string> active_flags;
+
+    // Проверка того, что каждый флаг по порядку
+    if ((value & static_cast<uint8_t>(CheckFlags::TIME)) != 0) {
+        active_flags.push_back("TIME");
+    }
+    if ((value & static_cast<uint8_t>(CheckFlags::DATE)) != 0) {
+        active_flags.push_back("DATE");
+    }
+    if ((value & static_cast<uint8_t>(CheckFlags::USER)) != 0) {
+        active_flags.push_back("USER");
+    }
+    if ((value & static_cast<uint8_t>(CheckFlags::CERT)) != 0) {
+        active_flags.push_back("CERT");
+    }
+    if ((value & static_cast<uint8_t>(CheckFlags::KEYS)) != 0) {
+        active_flags.push_back("KEYS");
+    }
+    if ((value & static_cast<uint8_t>(CheckFlags::DEST)) != 0) {
+        active_flags.push_back("DEST");
+    }
+
+    // Вывод
+    std::cout << "[";
+    for (size_t i = 0; i < active_flags.size(); ++i) {
+        if (i > 0) {
+            std::cout << ",";
+        }
+        std::cout << active_flags[i];
+    }
+    std::cout << "]";
+}

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,68 @@
+#include <cmath>
+
+// Константы для перевода
+constexpr double CM_IN_METER = 100.0;
+constexpr double METERS_IN_FOOT = 0.3048;
+constexpr double INCHES_IN_FOOT = 12.0;
+constexpr double CM_IN_INCH = 2.54;
+
+// Метры в футы
+constexpr double operator"" _m_to_ft(long double meters) {
+    return static_cast<long double>(meters / METERS_IN_FOOT);
+}
+
+// Метры в дюймы
+constexpr double operator"" _m_to_in(long double meters) {
+    return static_cast<double>(meters * CM_IN_METER / CM_IN_INCH);
+}
+
+// Метры в сантиметры
+constexpr double operator"" _m_to_cm(long double meters) {
+    return static_cast<double>(meters * CM_IN_METER);
+}
+
+// Сантиметры в метры
+constexpr double operator"" _cm_to_m(long double centimeters) {
+    return static_cast<long double>(centimeters / CM_IN_METER);
+}
+
+// Сантиметры в футы
+constexpr double operator"" _cm_to_ft(long double centimeters) {
+    return static_cast<double>(centimeters / CM_IN_METER / METERS_IN_FOOT);
+}
+
+// Сантиметры в дюймы
+constexpr double operator"" _cm_to_in(long double centimeters) {
+    return static_cast<double>(centimeters / CM_IN_INCH);
+}
+
+// Футы в метры
+constexpr double operator"" _ft_to_m(long double feet) {
+    return static_cast<double>(feet * METERS_IN_FOOT);
+}
+
+// Футы в сантиметры
+constexpr double operator"" _ft_to_cm(long double feet) {
+    return static_cast<double>(feet * METERS_IN_FOOT * CM_IN_METER);
+}
+
+// Футы в дюймы
+constexpr double operator"" _ft_to_in(long double feet) {
+    return static_cast<double>(feet * INCHES_IN_FOOT);
+}
+
+
+// Дюймы в метры
+constexpr double operator"" _in_to_m(long double inches) {
+    return static_cast<double>(inches * CM_IN_INCH / CM_IN_METER);
+}
+
+// Дюймы в сантиметры
+constexpr double operator"" _in_to_cm(long double inches) {
+    return static_cast<double>(inches * CM_IN_INCH);
+}
+
+// Дюймы в футы
+constexpr double operator"" _in_to_ft(long double inches) {
+    return static_cast<double>(inches / INCHES_IN_FOOT);
+}

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,40 @@
-#include <cstddef>
-#include <stdexcept>
-
+#include <iostream>
 
+/*функцию, преобразующая целое число 
+и размер в байтах и выводит на экран битовое представление числа в формате 0bXXXX'XXXX.*/
 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 byte = bytes - 1; byte >= 0; --byte) {
+
+        // Текущий байт
+        unsigned char current_byte = (value >> (byte * 8)) & 0xFF;
+
+        // Вывод битов текущего байта
+        for (int bit = 7; bit >= 0; --bit) {
+            // Текущий бит (7-й бит - старший)
+            unsigned char current_bit = (current_byte >> bit) & 1;
+            std::cout << (current_bit ? '1' : '0');
+
+            // Добавление апострофа после 4-го бита в каждом байте
+            if (bit == 4) {
+                std::cout << "'";
+            }
+        }
+
+        // Добавление апострофа между байтами (кроме последнего)
+        if (byte > 0) {
+            std::cout << "'";
+        }
+    }
+
+    // Завершение вывода
+    std::cout << "\n";
+}