Еремин Даниил

.gitignore

@@ -0,0 +1,7 @@
+build/
+.vs/
+CMakeLists.txt.user
+CMakeSettings.json
+CMakeUserPresets.json
+.vscode/
+*.out

01_week/tasks/addition/addition.cpp

@@ -3,5 +3,6 @@
 
 
 int64_t Addition(int a, int b) {
-    throw std::runtime_error{"Not implemented"};
+    int64_t res = static_cast<int64_t>(a) + b;  //явно преобразуем одно из слагаемых в int64_t
+    return res;
 }

01_week/tasks/char_changer/char_changer.cpp

@@ -1,7 +1,64 @@
 #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 = ' '){
+    //Массив для подстановки кол-ва повторений
+    char intToChar[10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
+    //Индексы
+    size_t i = 0;                  
+    size_t j = 1;
+    size_t k = 0;
+
+    int reps = 1;                  // кол-во повторений символа
+    while(j < size){
+        // Если есть повторы, то сначала считаются они
+        if(array[i] == array[j]){
+            ++reps;
+            j++;           
+            continue;
+        }
+
+        array[k] = array[i];
+        //Если повторы были, то записывается число
+        if(reps != 1 && array[i] != ' '){
+            array[k+1] = reps < 10 ? intToChar[reps] : intToChar[0];
+        }
+
+        //Проверка, что это символ алфавита и он в нижнем регистре
+        if(char c = array[k]; std::isalpha(c) && std::islower(c)){
+            array[k] = std::toupper(c);
+        }
+        //Отдельно обрабатываются пробелы
+        else if(array[k] == ' '){
+            array[k] = delimiter;
+            ++k;
+            i = j++;
+            reps = 1;
+            continue;
+        }
+        //Замена цифр
+        else if(std::isdigit(array[k])){
+            array[k] = '*';
+        }
+        //Замена остальных символов
+        else if(!(std::isalpha(array[k]))){
+            array[k] = '_';
+        }
+
+        //Сдвигаем индексы в зависимости от повторов
+        if(reps == 1){
+            ++k;
+        }
+        else if(reps != 1){
+            k+= 2;
+            reps = 1;
+        }
+        i = j++;
+    }
+
+    //В конце добавляется нуль-терминатор
+    array[k] = '\0';
+
+    return k;
 }

01_week/tasks/check_flags/check_flags.cpp

@@ -1,6 +1,10 @@
 #include <cstdint>
 #include <stdexcept>
-
+#include <unordered_map>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <sstream>
 
 enum class CheckFlags : uint8_t {
     NONE = 0,
@@ -14,5 +18,54 @@ enum class CheckFlags : uint8_t {
 };
 
 void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
+    //Хэш-таблица для быстрого преобразования uint8_t -> string
+    std::unordered_map<uint8_t, std::string> flagStr = {
+        {0b00000001,"TIME"},
+        {0b00000010,"DATE"},
+        {0b00000100,"USER"},
+        {0b00001000,"CERT"},
+        {0b00010000,"KEYS"},
+        {0b00100000,"DEST"}
+    };
+
+    //Вектор с результатом работы функции
+    std::vector<std::string> result = {"["};
+    //Резервирование места под элементы, чтобы не было лишних реаллокаций
+    result.reserve(16);
+
+
+    if(flags == CheckFlags::NONE){
+        std::cout << "[]";
+        return;
+    }
+    else if(flags == CheckFlags::ALL)
+    {
+        std::cout << "[TIME,DATE,USER,CERT,KEYS,DEST]";
+        return;
+    }
+    //Если флаг больше ALL значит он выходит из диапазона значений флагов
+    else if(static_cast<uint8_t>(flags) > static_cast<uint8_t>(CheckFlags::ALL))
+    {
+        std::cout << "";
+        return;
+    }
+    //В остальных случаях флаги перебираются и добавляюся в вектор если присутствуют 
+    else
+    {
+        for(uint8_t flag = 1; flag < static_cast<uint8_t>(CheckFlags::ALL); flag *= 2){
+            if(static_cast<uint8_t>(flags) & flag){
+                result.push_back(flagStr[flag]);
+                result.push_back(",");
+            }
+        }
+    }
+
+
+    result.pop_back();       //Убираем лишнюю запятую
+    result.push_back("]");
+
+    //Вывод результата
+    for(auto& elem : result){
+        std::cout << elem;
+    }
 }

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,59 @@
+//Футы в дюймы
+constexpr double operator""_ft_to_in(long double ft) {
+    return ft * 12.0;
+}
+
+//Футы в сантиметры
+constexpr double operator""_ft_to_cm(long double ft) {
+    return ft * 30.48;
+}
+
+//Футы в метры
+constexpr double operator""_ft_to_m(long double ft) {
+    return ft * 0.3048;
+}
+
+//Дюймы в футы
+constexpr double operator""_in_to_ft(long double in) {
+    return in / 12.0;
+}
+
+//Дюймы в сантиметры
+constexpr double operator""_in_to_cm(long double in) {
+    return in * 2.54;
+}
+
+//Дюймы в метры
+constexpr double operator""_in_to_m(long double in) {
+    return in * 0.0254;
+}
+
+//Сантиметры в футы
+constexpr double operator""_cm_to_ft(long double cm) {
+    return cm / 30.48;
+}
+
+//Сантиметры в дюймы
+constexpr double operator""_cm_to_in(long double cm) {
+    return cm / 2.54;
+}
+
+//Сантиметры в метры
+constexpr double operator""_cm_to_m(long double cm) {
+    return cm * 0.01;
+}
+
+//Метры в футы
+constexpr double operator""_m_to_ft(long double m) {
+    return m / 0.3048;
+}
+
+//Метры в дюймы
+constexpr double operator""_m_to_in(long double m) {
+    return m / 0.0254;
+}
+
+//Метры в сантиметры
+constexpr double operator""_m_to_cm(long double m) {
+    return m * 100;
+}

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,22 @@
 #include <cstddef>
-#include <stdexcept>
-
+#include <vector>
+#include <iostream>
 
 void PrintBits(long long value, size_t bytes) {
-    throw std::runtime_error{"Not implemented"};
+    size_t bitLen = 8 * bytes;
+    std::vector<char> bits(bitLen);
+
+    for(size_t i = 0; i < bitLen; ++i){
+        bits[bitLen-i-1] = value % 2 == 0 ? '0' : '1';
+        value = value >> 1;
+    }
+
+    std::cout << "0b";
+    for(size_t i = 0; i < bitLen; ++i){
+        std::cout << bits[i];
+        if((i+1) % 4 == 0 && (i+1) != bitLen){
+            std::cout << '\'';
+        }
+    }
+    std::cout << "\n";
 }

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,39 @@
-#include <stdexcept>
-
+#include <iostream>
+#include <iomanip>
+#include <cmath>
 
 void SolveQuadratic(int a, int b, int c) {
-    throw std::runtime_error{"Not implemented"};
+    //Установка точности вывода в 6 символов
+    std::cout << std::setprecision(6);
+
+    double eps = 1e-3;     // Погрешность при сравнении double
+    double x1{0}, x2{0};
+    long long d = static_cast<long long>(b) * b - 4 * static_cast<long long>(a) * c;
+    if(d < 0){
+        std::cout << "no solutions";
+    }
+    else if(a == 0 && b == 0 && c != 0){
+        std::cout << "no solutions";
+    }
+    else if(a != 0){
+        x1 = (-b + sqrt(d)) / (2*a);
+        x2 = (-b - sqrt(d)) / (2*a);
+
+        if((x1 - x2) < eps){
+            std::cout << x1;
+        }
+        else{
+            if(x1 > x2){
+                std::swap(x1, x2);
+            }
+            std::cout << x1 << " " << x2;
+        }
+    }
+    else if(a == 0 && b == 0 && c == 0){
+        std::cout << "infinite solutions";
+    }
+    else if(b != 0){
+        x1 = -c / static_cast<double>(b);
+        std::cout << x1;
+    }
 }

01_week/tasks/rms/rms.cpp

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

02_week/tasks/func_array/func_array.cpp

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

02_week/tasks/last_of_us/last_of_us.cpp

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

02_week/tasks/little_big/little_big.cpp

@@ -1,10 +1,47 @@
-#include <stdexcept>
+#include <iostream>
+#include <cstddef>
+#include <iomanip>
 
-
-void PrintMemory(int /* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
+void PrintMemory(int num, bool inverse = false) {
+    const size_t size = sizeof(int);
+    auto ptr = reinterpret_cast<const unsigned char*>(&num);
+
+    std::cout << "0x";
+
+    if (inverse) {
+        // little-endian
+        for (size_t i = size - 1; i < size; --i) {
+            std::cout << std::uppercase <<  std::hex << std::setw(2) << std::setfill('0') 
+                      << static_cast<unsigned int>(ptr[i]);
+        }
+    } else {
+        // big-endian
+        for (size_t i = 0; i < size; ++i) {
+            std::cout << std::uppercase << std::hex << std::setw(2) << std::setfill('0') 
+                      << static_cast<unsigned int>(ptr[i]);
+        }
+    }
+    std::cout << std::endl;
 }
 
-void PrintMemory(double /* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
+void PrintMemory(double num, bool inverse = false) {
+    const size_t size = sizeof(double);
+    auto ptr = reinterpret_cast<const unsigned char*>(&num);
+
+    std::cout << "0x";
+
+    if (inverse) {
+        //little-endian
+        for (size_t i = size - 1; i < size; --i) {
+            std::cout << std::uppercase << std::hex << std::setw(2) << std::setfill('0') 
+                      << static_cast<unsigned int>(ptr[i]);
+        }
+    } else {
+        // big-endian
+        for (size_t i = 0; i < size; ++i) {
+            std::cout << std::uppercase << std::hex << std::setw(2) << std::setfill('0') 
+                      << static_cast<unsigned int>(ptr[i]);
+        }
+    }
+    std::cout << std::endl;
 }