Мананов Данил

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

@@ -1,7 +1,98 @@
 #include <cstddef>
 #include <stdexcept>
+#include <cctype>   // для is функций из https://en.cppreference.com/w/cpp/string/byte.html
+#include <string>
+#include <iostream>
 
+// Пересчёт символов с выводом их кол-ва - есть  . C>10 = C0  
+// Замена непонятных символов (а не букв) на '_' - есть
+// замена цифр на звездочки - есть 
+//22 заменились на звездочки и посчитались, вывелось *2 - есть
+// Пробел заменился на ',' если передать в функцию чем заменяем - есть
+//err: Проблема раннего перевода в верхний регистр. мб сделать поднятие в верхний регистр после того как повторяющиеся буквы заменились на букву+цифру повторения - есть
 
 size_t CharChanger(char array[], size_t size, char delimiter = ' ') {
-    throw std::runtime_error{"Not implemented"};
+    if (size == 0) return 0;
+
+    size_t outputArray = 0;
+    size_t i = 0;
+
+    while (i < size && array[i] != '\0') {
+        char currentSymb = array[i];
+
+        //Смотрим пробелы
+        if (currentSymb == ' ') {
+            size_t spaceCounter = 1;
+            while (i + spaceCounter < size && array[i + spaceCounter] == ' ') {
+                spaceCounter++;
+            }
+            if (outputArray < size) {
+                array[outputArray++] = delimiter;
+            }
+            i += spaceCounter;
+            continue;
+        }
+
+        //Для остальных символов
+        size_t sameSymbCounter = 1;
+        size_t nextSymb = i + 1;
+
+        while (nextSymb < size && array[nextSymb] != '\0') {
+            if (array[nextSymb] == currentSymb) {
+                sameSymbCounter++;
+                nextSymb++;
+            } else {
+                break;
+            }
+        }
+
+        //Преобразование символов
+        char transformed = '0';
+        if (std::isdigit(currentSymb)) {
+            transformed = '*';
+        } else if (std::islower(currentSymb)) {
+            transformed = std::toupper(currentSymb);
+        } else if (std::isupper(currentSymb)) {
+            transformed = currentSymb;
+        } else {
+            transformed = '_';
+        }
+
+        //Перепись великого пассажа 
+        if (outputArray < size) {
+            array[outputArray++] = transformed;
+        }
+
+        if (sameSymbCounter > 1) {
+            if (sameSymbCounter >= 10) {
+                if (outputArray < size) {
+                    array[outputArray++] = '0';
+                }
+            } else {
+                if (outputArray < size) {
+                    array[outputArray++] = '0' + sameSymbCounter;
+                }
+            }
+        }
+
+        i = nextSymb; // Для перехода к след итерации.
+    }
+
+    if (outputArray < size) {
+        array[outputArray] = '\0';
+    } else if (size > 0) {
+        array[size - 1] = '\0';
+        outputArray = size - 1;
+    }
+
+    return outputArray;
 }
+// //Для отладки. И проверки своих выводов
+// int main() {
+
+//     char array[] = "aAaAaA_234_ssssDdd*$$   3333a";
+//     size_t size = 28;
+
+//     CharChanger(array, size, ',');
+//     std::cout << array << std::endl;
+// }

01_week/tasks/check_flags/check_flags.cpp

@@ -1,18 +1,96 @@
 #include <cstdint>
 #include <stdexcept>
-
-
+#include <iostream>
+/* В stdexcept есть
+Класс domain_error	Этот класс служит базовым классом для всех исключений, создаваемых для сообщения об ошибке в домене.
+Класс invalid_argument	Этот класс служит базовым классом для всех исключений, создаваемых для сообщения о недопустимом аргументе.
+Класс length_error	Этот класс служит базовым для всех исключений, создаваемых для сообщения о попытке создания слишком длинного объекта.
+Класс logic_error	Этот класс служит базовым для всех исключений, создаваемых для сообщения об ошибках, которые можно обнаружить до выполнения программы, таких как нарушение логических предварительных условий.
+Класс out_of_range	Этот класс служит базовым для всех исключений, создаваемых для сообщения о том, что аргумент выходит за допустимый диапазон.
+Класс overflow_error	Этот класс служит базовым для всех исключений, создаваемых для сообщения об арифметическом переполнении.
+Класс range_error	Этот класс служит базовым для всех исключений, создаваемых для сообщения об ошибке в диапазоне.
+Класс runtime_error	Этот класс служит базовым для всех исключений, создаваемых для сообщения об ошибках, которые можно обнаружить только при выполнении программы.
+Класс underflow_error	Этот класс служит базовым для всех исключений, создаваемых для сообщения об арифметической неточности.
+*/
 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
+    NONE = 0,                                      // 0 0000000 
+    TIME = (1 << 0),                               // 1 0000001
+    DATE = (1 << 1),                               // 2 0000010
+    USER = (1 << 2),                               // 3 0000100 
+    CERT = (1 << 3),                               // 4 0001000
+    KEYS = (1 << 4),                               // 5 0010000
+    DEST = (1 << 5),                               // 6 0100000
+    ALL = TIME | DATE | USER | CERT | KEYS | DEST  // 7 1000000
 };
 
+//        7    6  5   4  3  2  1   0     номера бит
+//        128 64 32  16  8  4  2   1     степени дваойки , а вообще будет такт 127 макс число, тк 0 еще есть 
+/* 
+Берется битовая маска. напирмер 01010010. это значит что есть TIME, CERT, DEST
+
+// Сначала надо сделать преобразование в число
+// Если число вдруг больше - выйти из проги
+// Если равно нулю - вывести пустые скобки (флаг none)
+// Проверяем каждый класс, если есть совпадение - выводим его
+*/
 void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
+
+    int flagValue = static_cast<uint8_t>(flags) ; 
+    bool isFirst = true; //Проверять первый элемент или нет будем так
+
+
+    if (flagValue > static_cast<uint8_t>(CheckFlags::ALL)) return;
+
+    if (flagValue == 0) {
+        std::cout << "[]";
+        return;
+    }
+
+//Прошла жесткая проверка
+    std::cout << "[";
+
+    if (flagValue & static_cast<uint8_t>(CheckFlags::TIME)) {
+        if (!isFirst) {std::cout << ",";}
+        std::cout << "TIME";
+        isFirst = false;
+    }
+
+
+    if (flagValue & static_cast<uint8_t>(CheckFlags::DATE)) {
+        if (!isFirst) {std::cout << ",";}
+        std::cout << "DATE";
+        isFirst = false;
+    }
+
+
+    if (flagValue & static_cast<uint8_t>(CheckFlags::USER)) {
+        if (!isFirst) {std::cout << ",";}
+        std::cout << "USER";
+        isFirst = false;
+    }
+
+
+    if (flagValue & static_cast<uint8_t>(CheckFlags::CERT)) {
+        if (!isFirst) {std::cout << ",";}
+        std::cout << "CERT";
+        isFirst = false;
+    }
+
+
+    if (flagValue & static_cast<uint8_t>(CheckFlags::KEYS)) {
+        if (!isFirst) {std::cout << ",";}
+        std::cout << "KEYS";
+        isFirst = false;
+    }
+
+    if (flagValue & static_cast<uint8_t>(CheckFlags::DEST)) {
+        if (!isFirst) {std::cout << ",";}
+        std::cout << "DEST";
+        isFirst = false; 
+    }
+
+
+
+    std::cout << "]";
+
 }

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,97 @@
+#include <iomanip>
+// Поскольку литералы - это константы
+// Создание пользовательского литерала начинается с обозначения constexpr - Значение будет констатной и будет вычислено на этапе компиляции
+// (по крайней мере компилятор будет пытаться это сделать:)
+// explicit - запрет на неявный вызов. Если ожидается какой-то литерал, но он не найден - выдаст ошибку, мол я не нашел, не знаю чё делать
+// Далее идет тип данных, который будет возвращать наш литерал
+// Далее идет operator"" и после него название литерала  _name 
+// Далее в скобках пишется принимаемое значение с определенным типом данных 
+
+// необходимо создать 11 пользовательских литератов
+// _ft_to_m
+//_ft_to_cm
+//_ft_to_in
+//_in_to_m
+//_in_to_cm
+//_in_to_ft
+//_m_to_ft
+//_m_to_in
+//_m_to_cm
+//_cm_to_m
+//_cm_to_ft
+//_cm_to_in
+// Прописать их логику подобным образом. необходимо правильно определить точность. Размер принимаемых значений.
+// Причем все преобразования возвращают тип `double`.
+/*
+Параметры типов должны быть только такие:
+const char
+unsigned long long int          // для целочисленного, но и то оно только unsigned типа
+long double                     // просто double не проканает
+char
+wchar_t
+char16_t
+char32_t
+const char'*', std::size_t
+const wchar_t'*', std::size_t
+const char16_t'*', std::size_t
+const char32_t'*', std::size_t
+*/
+
+//1 фут = 0.3048 метра
+//1 дюйм = 2.54 см = 0.0254м 
+// Только к 22 годам понял, что футы - это типо ноги. 30см то примерно стопа:)
+//-----------------------------Футы В куда угодно------------------------
+constexpr long double operator""_ft_to_m(long double val) {
+
+    return static_cast<double>(val * 0.3048);
+}
+
+constexpr long double operator""_ft_to_cm(long double val) {
+    return static_cast<double>(val * 30.48);
+}
+
+constexpr long double operator""_ft_to_in(long double val) {
+    return static_cast<double>(val / 0.083333333);
+}
+
+//-----------------------------Дюймы В куда угодно------------------------
+
+constexpr long double operator""_in_to_m(long double val) {
+    return static_cast<double>(val * 0.0254);
+}
+
+constexpr long double operator""_in_to_cm(long double val) {
+    return static_cast<double>(val * 2.54);
+}
+
+constexpr long double operator""_in_to_ft(long double val) {
+    return static_cast<double>(val / 12);
+}
+
+//-----------------------------Метры В куда угодно------------------------
+
+constexpr long double operator""_m_to_ft(long double val) {
+    return static_cast<double>(val / 0.3048);
+}
+
+constexpr long double operator""_m_to_in(long double val) {
+    return static_cast<double>(val / 0.0254);
+}
+
+constexpr long double operator""_m_to_cm(long double val) {
+    return static_cast<double>(val * 100);
+}
+
+//----------------------Сантиметры В куда угодно---------------------------
+
+constexpr long double operator""_cm_to_m(long double val) {
+    return static_cast<double>(val / 100);
+}
+
+constexpr long double operator""_cm_to_ft(long double val) {
+    return static_cast<double>(val / 30.48);
+}
+
+constexpr long double operator""_cm_to_in(long double val) {
+    return static_cast<double>(val / 2.54);
+}

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,60 @@
 #include <cstddef>
 #include <stdexcept>
+#include <vector>
+#include <iostream>
+#include <cstdint>
 
 
+// Если размер 1 числа - 0b0000'0000
+//       Если размер 2 - 0b0000'0000'00000'000
+//       Если размер 4 - 0b0000'0000'0000'0000'0000'0000'0000'0000
+//       Если размер 8 - 0b0000'0000'0000'0000'0000'0000'0000'0000'0000'0000'0000'0000'0000'0000'0000'0000
+// А если размер другой? например 16? Ограничим возможность представления других размеров, дабы тесты корректно выполнялись
+
+//Как перевести число в двоичную систему счисления?
+//Берется десятичное число, напирмер 42
+// Если число не 10-чное, а например шестнадцатиричное или восьмиричное - приводим к десятичному
+// делится на 2 до тех пор пока число не будет равно одному 
+// Запись остатков от деления ведется в массив
+// Переворачивается задом на перед
+// Выводится на экран в формате 0b[массив]
+//!!!!  При значении размера байт $bytes \notin (0, 8]$ функция ничего не выводит. - есть недопонимание.
+//                                                                         как бы cout << ""; - это вывод, но пустой, считается ли это что функция ничего не выводит?
+// В тестах видно что есть разделитель между разрядами. Надо добавить
+
 void PrintBits(long long value, size_t bytes) {
-    throw std::runtime_error{"Not implemented"};
-}
+    using namespace std;
+
+    if (bytes != 1 && bytes != 2 && bytes != 4 && bytes != 8 ){
+        cout << ""; //Просто return почему-то не работает, пока не могу понять почему. А так все тесты пройдены.
+    }    
+
+    const size_t bitValue = bytes * 8;
+    unsigned long long unsignedValue = 0;
+
+    if (value < 0 && bytes < 8) {
+        switch (bytes) {
+            case 1: unsignedValue = static_cast<uint8_t>(value); break;
+            case 2: unsignedValue = static_cast<uint16_t>(value); break;
+            case 4: unsignedValue = static_cast<uint32_t>(value); break;
+            default: unsignedValue = static_cast<unsigned long long>(value);
+        }
+    } else {
+        unsignedValue = static_cast<unsigned long long>(value);
+    }
+
+    cout << "0b";
+
+    // Идем от старшего бита к младшему
+    for (int i = bitValue - 1; i >= 0; --i) {
+        unsigned long long bit = (unsignedValue >> i) & 1;
+        cout << bit;
+
+        //Без разделителя тесты ругаются, добавим его
+        if (i > 0 && i % 4 == 0) {
+            cout << '\'';
+        }
+    }
+
+    cout << endl;
+}