Мирошниченко Евгений

.gitignore

@@ -0,0 +1,7 @@
+# Build directories
+build/
+*/build/
+*/build*/
+
+# IDE
+.vscode/

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/README.md

@@ -13,7 +13,7 @@
 1. Строчные латинские символы заменяются на прописные, правило 1 действует
 1. Последовательные пробельные символы, заменяются на один без указания числа
    повторений и преобразуются в заданный извне разделитель `delimeter`. 
-1. Все остальные символы заменяются на символ `_`
+1. Все остальные символы заменяются на символ `_`. Правило 1 действует
 
 Гарантируется, что последний символ в массиве `'\0'`.
 

01_week/tasks/char_changer/char_changer.cpp

@@ -1,7 +1,54 @@
 #include <cstddef>
 #include <stdexcept>
+#include <cctype>
 
+void ProcessOneSymbol(char* array, size_t& pos, char symbol, size_t count){
+    array[pos] = symbol;
+    if (count >= 10){
+        ++pos;
+        array[pos] = '0';
+    }
+    else if (count > 1){
+        ++pos;
+        array[pos] = count + '0';
+    }
+}
 
-size_t CharChanger(char array[], size_t size, char delimiter = ' ') {
-    throw std::runtime_error{"Not implemented"};
+size_t Counter(char array[], size_t size, size_t startIdx){
+    char symbol = array[startIdx];
+    size_t count = 1;
+    for (size_t i = startIdx + 1; i < size - 1; ++i) {
+        if (array[i] == symbol) ++count;
+        else break;
+    }
+    return count;
 }
+
+size_t CharChanger(char array[], size_t size, char delimiter = ' ') {
+    size_t count = 0;
+    size_t new_ar_pos = 0;
+    for (size_t i=0; i<size-1;){
+        count = Counter(array, size, i);
+
+        if (std::isblank(array[i])){
+            array[new_ar_pos] = delimiter;
+        }
+        else if (std::isdigit(array[i])){
+            ProcessOneSymbol(array, new_ar_pos, '*', count);
+        }
+        else if (std::islower(array[i])){
+            ProcessOneSymbol(array, new_ar_pos, std::toupper(array[i]), count);
+        }
+        else if (std::isupper(array[i])){
+            ProcessOneSymbol(array, new_ar_pos, array[i], count);
+        }
+        else{
+            ProcessOneSymbol(array, new_ar_pos, '_', count);
+        }
+        i += count;
+        ++new_ar_pos;
+    }
+
+    array[std::min(new_ar_pos, size - 1)] = '\0';
+    return new_ar_pos;
+}

01_week/tasks/check_flags/check_flags.cpp

@@ -14,5 +14,27 @@ enum class CheckFlags : uint8_t {
 };
 
 void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
+    uint8_t flags_int = static_cast<uint8_t>(flags);
+    if (flags_int > static_cast<uint8_t>(CheckFlags::ALL)) {
+        std::cout << "";
+        return;
+    }
+
+    std::string names[6] = {"TIME", "DATE", "USER", "CERT", "KEYS" , "DEST"};
+    std::string result = "[";
+    bool symbol_added = false;
+
+    uint8_t mask = 1;
+    for (size_t i = 0; i < 6; ++i) {
+        mask = (1 << i);
+        if (flags_int & mask) {
+            if (symbol_added) {
+                result += ",";
+            }
+            result += names[i];
+            symbol_added = true;
+        }
+    }
+
+    std::cout << result + "]";
 }

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,53 @@
+namespace{
+    constexpr double FT_IN_M = 3.280839895;
+    constexpr double IN_IN_FT = 12.0;
+    constexpr double IN_IN_M = IN_IN_FT * FT_IN_M;
+}
+
+constexpr double operator""_m_to_cm(long double meters){
+    return meters * 100;
+}
+
+constexpr double operator""_cm_to_m(long double centimeter){
+    return centimeter / 100.0;
+}
+
+constexpr double operator""_ft_to_m(long double feets){
+    return feets / FT_IN_M;
+}
+
+constexpr double operator""_ft_to_cm(long double feets){
+    return operator""_m_to_cm(operator""_ft_to_m(feets));
+}
+
+constexpr double operator""_ft_to_in(long double feets){
+    return feets * IN_IN_FT;
+}
+
+constexpr double operator""_in_to_m(long double inches){
+    return inches / IN_IN_M;
+}
+
+constexpr double operator""_in_to_cm(long double inches){
+    return operator""_m_to_cm(operator""_in_to_m(inches));
+}
+
+constexpr double operator""_in_to_ft(long double inches){
+    return inches / IN_IN_FT;
+}
+
+constexpr double operator""_m_to_ft(long double meters){
+    return meters * FT_IN_M;
+}
+
+constexpr double operator""_m_to_in(long double meters){
+    return meters * IN_IN_M;
+}
+
+constexpr double operator""_cm_to_ft(long double centimeters){
+    return operator""_cm_to_m(operator""_m_to_ft(centimeters));
+}
+
+constexpr double operator""_cm_to_in(long double centimeters){
+    return operator""_cm_to_m(operator""_m_to_in(centimeters));
+}

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,20 @@
 #include <cstddef>
 #include <stdexcept>
+#include <iostream>
 
 
 void PrintBits(long long value, size_t bytes) {
-    throw std::runtime_error{"Not implemented"};
+    std::string result = "0b";
+    size_t total_bits = bytes * 8;
+    long long mask = 0LL;
+    // Тут надо int, иначе условие бесконечное, потому что будет
+    // происходит переполнение счетчика
+    for (int i = total_bits - 1; i >= 0; --i) {
+        mask = 1LL << i;
+
+        result += (value & mask) ? '1' : '0';
+
+        if (i % 4 == 0 && i != 0) result += '\'';
+    }
+    std::cout << result << "\n";
 }

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,61 @@
 #include <stdexcept>
+#include <cmath>
+#include <iomanip>
+#include <iostream>
 
+bool isLevelLine(int a, int b) {
+    return a == 0 && b == 0;
+}
+
+bool isLinear(int a, int b){
+    if (a == 0 && b != 0) return true;
+    else return false;
+
+}
+
+bool isQuadratic(int a){
+    if (a != 0) return true;
+    else return false;
+
+}
+
+std::string AddRootToStr(double x){
+    std::ostringstream oss;
+    oss << std::setprecision(6);
+    if (std::abs(x - std::round(x)) < 1e-10) {
+        oss << static_cast<int>(std::round(x));
+    } else {
+        oss << x;
+    }
+    return oss.str();
+}
 
 void SolveQuadratic(int a, int b, int c) {
-    throw std::runtime_error{"Not implemented"};
+    std::string result = "";
+    if (isLevelLine(a, b)){
+        result = (c == 0) ? "infinite solutions" : "no solutions";
+    }
+    else if (isLinear(a, b)){
+        double x = -static_cast<double>(c) / b;
+        result = AddRootToStr(x);
+    }
+    else if (isQuadratic(a)){
+        double discr = b * b - 4 * a * c;
+        if (discr < 0) {
+            result = "no solutions";
+        }
+        else if (std::abs(discr) < 1e-10) {
+            double x = -b / (2.0 * a);
+            result = AddRootToStr(x);
+        }
+        else {
+            double x1 = (-b + sqrt(discr)) / (2.0 * a);
+            double x2 = (-b - sqrt(discr)) / (2.0 * a);
+
+            if (x1 > x2) std::swap(x1, x2);
+            result = AddRootToStr(x1) + " " + AddRootToStr(x2);
+        }
+    }
+
+    std::cout << result;
 }

01_week/tasks/rms/rms.cpp

@@ -1,7 +1,12 @@
-#include <cstdef>
-#include <stdexcept>
+#include <cstddef>
+#include <cmath>
 
 
 double CalculateRMS(double values[], size_t size) {
-    throw std::runtime_error{"Not implemented"};
+    double res = 0.0;
+    if (values == nullptr || size == 0) return res;
+    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,14 @@
 #include <stdexcept>
 
 
-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 func_count) {
+    double result = 0.0;
+    const double& a_ref = a;
+    const double& b_ref = b;
+    for (size_t i = 0; i < func_count; ++i){
+        if (functions[i]){
+            result += functions[i](a_ref, b_ref);
+        }
+    }
+    return result;
 }

02_week/tasks/last_of_us/last_of_us.cpp

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

02_week/tasks/little_big/little_big.cpp

@@ -1,10 +1,28 @@
 #include <stdexcept>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
 
+void Print(unsigned char* byte_ptr, size_t bytes, bool shouldInverse){
+    std::ostringstream oss;
+    oss << "0x";
+
+    for (size_t i = 0; i < bytes; ++i) {
+        size_t index = shouldInverse ? (bytes - 1 - i) : i;
+        oss << std::hex << std::uppercase << std::setw(2) << std::setfill('0')
+            << static_cast<int>(byte_ptr[index]);
+    }
+
+    oss << "\n";
+    std::cout << oss.str();
+}
 
-void PrintMemory(int /* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
+void PrintMemory(int number, bool shouldInverse=false) {
+    unsigned char* byte_ptr = reinterpret_cast<unsigned char*>(&number);
+    Print(byte_ptr, sizeof(int), shouldInverse);
 }
 
-void PrintMemory(double /* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
+void PrintMemory(double number, bool shouldInverse=false) {
+    unsigned  char* byte_ptr = reinterpret_cast<unsigned  char*>(&number);
+    Print(byte_ptr, sizeof(double), shouldInverse);
 }

02_week/tasks/longest/longest.cpp

@@ -1,6 +1,37 @@
 #include <stdexcept>
 
 
-/* return_type */ FindLongestSubsequence(/* ptr_type */ begin, /* ptr_type */ end, /* type */ count) {
-    throw std::runtime_error{"Not implemented"};
+const char* FindLongestSubsequence(const char* begin, const char* end, size_t& count) {
+    const char* start_of_longest_seq = nullptr;
+    count = 0;
+    size_t this_seq_count = 0;
+
+    if ((begin == nullptr) || (end==nullptr) || (begin > end)) {
+        return start_of_longest_seq;
+    }
+
+    const char* next_el = nullptr;
+    while(begin != end){
+        this_seq_count = 1;
+        if (begin < end - 1){
+            next_el = begin + 1;
+            for (; next_el != end; ++next_el){
+                if (*next_el != *begin) break;
+                ++this_seq_count;
+            }
+        }
+
+        if (this_seq_count > count){
+            count = this_seq_count;
+            start_of_longest_seq = begin;
+        }
+        begin += this_seq_count;
+    }
+
+    return start_of_longest_seq;
 }
+
+char* FindLongestSubsequence(char* begin, char* end, size_t& count){
+    const char* const_result = FindLongestSubsequence(const_cast<const char*>(begin), const_cast<const char*>(end), count);
+    return const_cast<char*>(const_result);
+}