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

.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,5 @@
 
 
 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,54 @@
 #include <cstddef>
-#include <stdexcept>
+#include <cctype>
 
 
 size_t CharChanger(char array[], size_t size, char delimiter = ' ') {
-    throw std::runtime_error{"Not implemented"};
+    //Массив для подстановки кол-ва повторений
+    char intToChar[10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
+
+    size_t i = 0;                  
+    size_t j = 1;
+    size_t str_end = 0;
+
+    int reps = 1;                  // кол-во повторений символа
+    while (j < size) {
+        if (array[i] == array[j]) {
+            ++reps;
+            ++j;           
+            continue;
+        }
+
+        array[str_end] = array[i];
+        if (reps != 1 && array[i] != ' ') {
+            array[str_end+1] = reps < 10 ? intToChar[reps] : intToChar[0];
+        }
+
+        if (char c = array[str_end]; std::isalpha(c) && std::islower(c)) {
+            array[str_end] = std::toupper(c);
+        }
+        else if (array[str_end] == ' ') {
+            array[str_end] = delimiter;
+            ++str_end;
+            i = j++;
+            reps = 1;
+            continue;
+        }
+        else if (std::isdigit(array[str_end])) {
+            array[str_end] = '*';
+        }
+        else if (!(std::isalpha(array[str_end]))) {
+            array[str_end] = '_';
+        }
+
+        if (reps == 1) {
+            ++str_end;
+        }
+        else {
+            str_end+= 2;
+            reps = 1;
+        }
+        i = j++;
+    }
+    array[str_end] = '\0';
+    return str_end;
 }

01_week/tasks/check_flags/check_flags.cpp

@@ -1,6 +1,6 @@
 #include <cstdint>
-#include <stdexcept>
-
+#include <iostream>
+#include <string>
 
 enum class CheckFlags : uint8_t {
     NONE = 0,
@@ -14,5 +14,27 @@ enum class CheckFlags : uint8_t {
 };
 
 void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
+    uint8_t flags_uint8 = static_cast<uint8_t>(flags);
+
+    //Массив с именами флагов
+    std::string flagStr[6] = {"TIME", "DATE", "USER", "CERT", "KEYS", "DEST"};
+    //Если флаг больше ALL значит он выходит из диапазона значений флагов
+    if (static_cast<uint8_t>(flags) > static_cast<uint8_t>(CheckFlags::ALL)) {
+        std::cout << "";
+        return;
+    }
+    //В остальных случаях флаги перебираются и добавляюся в строку если присутствуют 
+    uint8_t flag = 1;
+    bool str_write = false;
+    std::cout << "[";
+    for (size_t i = 0; flag < static_cast<uint8_t>(CheckFlags::ALL); ++i) {
+        if (flags_uint8 & flag) {
+            std::cout <<  (str_write ? "," : "");
+            std::cout << flagStr[i];
+            str_write = true;
+        }
+        flag *= 2;
+    }
+
+    std::cout << "]";
 }

01_week/tasks/length_lit/length_lit.cpp

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

01_week/tasks/print_bits/print_bits.cpp

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

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,42 @@
-#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};
+    if (a == 0 && b == 0 && c != 0) {
+        std::cout << "no solutions";
+        return;
+    }
+    if (a == 0 && b == 0 && c == 0) {
+        std::cout << "infinite solutions";
+        return;
+    }
+    if(b != 0 && a == 0){
+        x1 = -c / static_cast<double>(b);
+        std::cout << x1;
+        return;
+    }
+
+    long long d = static_cast<long long>(b) * b - 4 * static_cast<long long>(a) * c;
+    if(d < 0){
+        std::cout << "no solutions";
+        return;
+    }
+
+    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;
+    }
 }

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 std::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] ? 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(const int* current = (end-1); current != begin-1; --current){
+        if(predicate(*current)) return current;
+    }
+    return end;
 }

02_week/tasks/little_big/little_big.cpp

@@ -1,10 +1,28 @@
-#include <stdexcept>
+#include <iostream>
+#include <cstddef>
+#include <iomanip>
 
+void PrintHex(const unsigned char* ptr, const size_t size, bool inverse) {
+    for (size_t i = 0; i < size; ++i) {
+        std::cout << std::uppercase << std::hex << std::setw(2) << std::setfill('0') 
+                  << (!inverse ? static_cast<unsigned int>(ptr[i]) : static_cast<unsigned int>(ptr[size - 1 - i]));
+    }
+}
 
-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";
+    PrintHex(ptr, size, inverse);
+    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";
+    PrintHex(ptr, size, inverse);
+    std::cout << std::endl;
 }

02_week/tasks/longest/longest.cpp

@@ -1,6 +1,29 @@
-#include <stdexcept>
+#include <cstddef>
 
+const char* FindLongestSubsequence(const char* begin, const char* end, size_t& count) {
+    const char* res{nullptr};
+    count = 0;
 
-/* return_type */ FindLongestSubsequence(/* ptr_type */ begin, /* ptr_type */ end, /* type */ count) {
-    throw std::runtime_error{"Not implemented"};
+    if(begin == nullptr || end == nullptr) return nullptr;
+
+    size_t curLen{1};
+    const char* curBegin{begin};
+    for(const char* curent = begin; curent < end; ++curent){
+        if(curent+1 != end && *curent == *(curent+1)){
+            curBegin = curLen == 1 ? curent : curBegin;
+            ++curLen;
+            continue;
+        }
+
+        res = count < curLen ? curBegin : res;
+        count = count < curLen ? curLen : count;
+        curLen = 1;
+    }
+
+    return res;
 }
+
+char* FindLongestSubsequence(char* begin, char* end, size_t& count) {
+    const char* const_res = FindLongestSubsequence(const_cast<const char*>(begin), const_cast<const char*>(end), count);
+    return const_cast<char*>(const_res);
+}

02_week/tasks/pretty_array/pretty_array.cpp

@@ -1,6 +1,25 @@
-#include <stdexcept>
+#include <iostream>
 
 
-void PrintArray(/* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
+void PrintArray(const int* begin, const int* end, size_t limit = 0) {
+    if(begin == nullptr || end == nullptr) {
+        std::cout << "[]\n";
+        return;
+    }
+
+    std::cout << "[";
+    int step = begin > end ? -1 : 1;
+    size_t i = 1;
+    for(const int* curent = begin; curent != end; curent += step) {
+        if(limit != 0 && i > limit) {
+            std::cout << "...\n " << *curent << (curent+step == end ? "" : ", ");
+            i = 1;
+        }
+        else {
+            std::cout << *curent << (curent+step == end ? "" : ", ");
+        }
+        ++i;
+    }
+
+    std::cout << "]\n";
 }