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

.gitignore

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

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 result = static_cast<int64_t>(a) + static_cast<int64_t>(b);
+    return result;
 }

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,79 @@
 #include <cstddef>
 #include <stdexcept>
+#include <cctype>
 
 
+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 = ' ') {
-    throw std::runtime_error{"Not implemented"};
+    char result[256];
+    size_t count = 0;
+    size_t new_ar_pos = 0;
+    for (size_t i=0; i<size-1;){
+        count = Counter(array, size, i);
+
+        if (array[i] == ' '){
+            result[new_ar_pos] = delimiter;
+        }
+        else if (array[i] >= +'0' && array[i] <= +'9'){
+            result[new_ar_pos] = '*';
+            if (count >= 10){
+                ++new_ar_pos;
+                result[new_ar_pos] = '0';
+            }
+            else if (count > 1){
+                ++new_ar_pos;
+                result[new_ar_pos] = count + '0';
+            }
+        }
+        else if (array[i] >= +'a' && array[i] <= +'z'){
+            result[new_ar_pos] = std::toupper(array[i]);
+            if (count >= 10){
+                ++new_ar_pos;
+                result[new_ar_pos] = '0';
+            }
+            else if (count > 1){
+                ++new_ar_pos;
+                result[new_ar_pos] = count + '0';
+            }
+        }
+        else if (array[i] >= +'A' && array[i] <= +'Z'){
+            result[new_ar_pos] = array[i];
+            if (count >= 10){
+                ++new_ar_pos;
+                result[new_ar_pos] = '0';
+            }
+            else if (count > 1){
+                ++new_ar_pos;
+                result[new_ar_pos] = count + '0';
+            }
+        }
+        else{
+            result[new_ar_pos] = '_';
+            if (count >= 10){
+                ++new_ar_pos;
+                result[new_ar_pos] = '0';
+            }
+            else if (count > 1){
+                ++new_ar_pos;
+                result[new_ar_pos] = count + '0';
+            }
+        }
+        i += count;
+        ++new_ar_pos;
+    }
+    for (size_t i = 0; i < new_ar_pos && i < size - 1; ++i) {
+        array[i] = result[i];
+    }
+    array[std::min(new_ar_pos, size - 1)] = '\0';
+    return new_ar_pos;
 }
+

01_week/tasks/check_flags/check_flags.cpp

@@ -14,5 +14,28 @@ 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,47 @@
+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 * 0.3048;
+}
+
+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 * 12.0;
+}
+
+constexpr double operator""_in_to_m(long double inches){
+    return inches * 0.0254;
+}
+
+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 / 12.0;
+}
+
+constexpr double operator""_m_to_ft(long double meters){
+    return meters * 3.280839895;
+}
+
+constexpr double operator""_m_to_in(long double meters){
+    return meters * 39.37007874;
+}
+
+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,21 @@
 #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;
+
+        if (value & mask) result += '1';
+        else result += '0';
+
+        if (i % 4 == 0 && i != 0) result += '\'';
+    }
+    std::cout << result << "\n";
 }

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,64 @@
 #include <stdexcept>
+#include <cmath>
+#include <iomanip>
+#include <iostream>
 
+bool isLevelLine(int a, int b){
+    if (a == 0 && b == 0) return true;
+    else return false;
+
+}
+
+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)){
+        if (c == 0) result = "infinite solutions";
+        else result = "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 PrintingFunc(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);
+    PrintingFunc(byte_ptr, 4, 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);
+    PrintingFunc(byte_ptr, 8, shouldInverse);
 }