hw_01

01_week/tasks/addition/addition.cpp

@@ -1,7 +1,8 @@
 #include <cstdint>
 #include <stdexcept>
 
-
 int64_t Addition(int a, int b) {
-    throw std::runtime_error{"Not implemented"};
-}
+    int64_t a_64 = static_cast<int64_t>(a);
+    int64_t b_64 = static_cast<int64_t>(b);
+    return a_64 + b_64;
+}

01_week/tasks/char_changer/char_changer.cpp

@@ -1,7 +1,72 @@
 #include <cstddef>
 #include <stdexcept>
+#include <cctype>
 
+const char a = 'a';
+const char A = 'A';
+const char dif_letters = static_cast<int>(a) - static_cast<int>(A);
 
 size_t CharChanger(char array[], size_t size, char delimiter = ' ') {
-    throw std::runtime_error{"Not implemented"};
+    size_t count = 1, last_ind = size - 1;
+    size_t start_rep_ind, end_rep_ind;
+
+    for (size_t i = 0; i < size; ++i) {
+
+        if (i == size - 1) {
+            return last_ind;
+        }
+
+        if (array[i] == array[i + 1]) {
+            if (count == 1) start_rep_ind = i;
+            count++;
+
+            if (array[i] == ' ') continue;
+        }
+        else if (count != 1) {
+            end_rep_ind = i + 1;
+            i = start_rep_ind;
+
+            size_t ind_next_simbol = i + 2;
+
+            last_ind -= count - 2;
+
+            if (array[i] != ' ') {
+                if (count >= 10) array[++i] = '0';
+                else array[++i] = static_cast<char>(static_cast<size_t>('0') + count);
+            }
+            else {
+                --ind_next_simbol;
+                --last_ind;
+
+                array[i] = delimiter;
+            }
+
+            for (size_t j = end_rep_ind; j < size; ++j) {
+                std::swap(array[ind_next_simbol], array[j]);
+                ++ind_next_simbol;
+            }
+
+            size_t reduct_size = end_rep_ind - start_rep_ind;
+            size -= reduct_size - 2;
+
+            count = 1;
+
+            continue;
+        }
+
+        if (static_cast<bool>(std::isdigit(array[i]))) {
+            array[i] = '*';
+        }
+        else if (static_cast<bool>(std::islower(array[i]))) {
+            array[i] -= dif_letters;
+        }
+        else if (static_cast<bool>(std::ispunct(array[i]))) {
+            array[i] = '_';
+        }
+        else if (static_cast<bool>(std::isspace(array[i]))) {
+            array[i] = delimiter;
+        }
+    }
+
+    return last_ind;
 }

01_week/tasks/check_flags/check_flags.cpp

@@ -1,5 +1,6 @@
 #include <cstdint>
 #include <stdexcept>
+#include <iostream>
 
 
 enum class CheckFlags : uint8_t {
@@ -14,5 +15,45 @@ enum class CheckFlags : uint8_t {
 };
 
 void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
+    if (flags > CheckFlags::ALL) {
+        std::cout << "";
+        return;
+    }
+
+    bool the_first = true;
+    std::string str_flags = "[";
+
+    if (static_cast<int8_t>(flags) &
+        static_cast<int8_t>(CheckFlags::TIME)) {
+        str_flags += "TIME";
+        the_first = false;
+    }
+    if (static_cast<int8_t>(flags) &
+        static_cast<int8_t>(CheckFlags::DATE)) {
+        the_first ? str_flags += "DATE" : str_flags += ",DATE";
+        the_first = false;
+    }
+    if (static_cast<int8_t>(flags) &
+        static_cast<int8_t>(CheckFlags::USER) ) {
+        the_first ? str_flags += "USER" : str_flags += ",USER";
+        the_first = false;
+    }
+    if (static_cast<int8_t>(flags) &
+        static_cast<int8_t>(CheckFlags::CERT)) {
+        the_first ? str_flags += "CERT" : str_flags += ",CERT";
+        the_first = false;
+    }
+    if (static_cast<int8_t>(flags) &
+        static_cast<int8_t>(CheckFlags::KEYS)) {
+        the_first ? str_flags += "KEYS" : str_flags += ",KEYS";
+        the_first = false;
+    }
+    if (static_cast<int8_t>(flags) &
+        static_cast<int8_t>(CheckFlags::DEST)) {
+        the_first ? str_flags += "DEST" : str_flags += ",DEST";
+        the_first = false;
+    }
+
+    str_flags += "]";
+    std::cout << str_flags;
 }

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,68 @@
+constexpr long double operator""_m_to_in(long double m) {
+    return m / 0.0254;
+}
+
+constexpr long double operator""_m_to_ft(long double m) {
+    return m / 0.3048;
+}
+
+constexpr long double operator""_m_to_m(long double m) {
+    return m;
+}
+
+constexpr long double operator""_m_to_cm(long double m) {
+    return m * 100;
+}
+
+// foots
+constexpr long double operator""_ft_to_in(long double ft) {
+    return ft * (0.3048 / 0.0254);
+}
+
+constexpr long double operator""_ft_to_ft(long double ft) {
+    return ft;
+}
+
+constexpr long double operator""_ft_to_m(long double ft) {
+    return ft * 0.3048;
+}
+
+constexpr long double operator""_ft_to_cm(long double ft) {
+    return ft * 30.48;
+}
+
+
+// inch
+constexpr long double operator""_in_to_in(long double in) {
+    return in;
+}
+
+constexpr long double operator""_in_to_ft(long double in) {
+    return in * (0.0254 / 0.3048);
+}
+
+constexpr long double operator""_in_to_m(long double in) {
+    return in * 0.0254;
+}
+
+constexpr long double operator""_in_to_cm(long double in) {
+    return in * 2.54;
+}
+
+
+// cm
+constexpr long double operator""_cm_to_in(long double cm) {
+    return cm / 2.54;
+}
+
+constexpr long double operator""_cm_to_ft(long double cm) {
+    return cm / 30.48;
+}
+
+constexpr long double operator""_cm_to_m(long double cm) {
+    return cm / 100;
+}
+
+constexpr long double operator""_cm_to_cm(long double cm) {
+    return cm;
+}

01_week/tasks/print_bits/print_bits.cpp

@@ -1,7 +1,25 @@
-#include <cstddef>
-#include <stdexcept>
-
+#include <iostream>
+#include <algorithm>
 
 void PrintBits(long long value, size_t bytes) {
-    throw std::runtime_error{"Not implemented"};
+    std::string str_bset = "";
+
+    auto bits = bytes * 8;
+
+    for (size_t i = 0; i < bits; ++i) {
+        auto b_i = (value >> i) & 1u;
+
+        if (static_cast<bool>(b_i)) str_bset += "1";
+        else str_bset += "0";
+
+        if (i % 4 == 3 && i != bits - 1) {
+            str_bset += '\'';
+        }
+    }
+
+    str_bset += "b0";
+
+    std::reverse(str_bset.begin(), str_bset.end());
+
+    std::cout << str_bset << "\n";
 }

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,91 @@
 #include <stdexcept>
-
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <cmath>
 
 void SolveQuadratic(int a, int b, int c) {
-    throw std::runtime_error{"Not implemented"};
-}
+    double x_1, x_2;
+    bool a_is_Zero = (a == 0 ? true : false);
+    bool b_is_Zero = (b == 0 ? true : false);
+    bool c_is_Zero = (c == 0 ? true : false);
+
+    std::cout << std::setprecision(6);
+
+    if (a_is_Zero) {
+        if (b_is_Zero) {
+            if (c_is_Zero) {
+                std::cout << "infinite solutions";
+            }
+            else {
+                std::cout << "no solutions";   
+            } 
+        }
+        else {            
+            if (c_is_Zero){
+                std::cout << c;
+            }
+            else{
+                x_1 = static_cast<double>(-c) / static_cast<double>(b);
+                std::cout << x_1;
+            }
+        }
+
+        return;
+    }
+    else { 
+        if (b_is_Zero){ 
+            if (c_is_Zero) {
+                std::cout << c;
+            }
+            else {
+                if (a * c < 0) {
+                    x_1 = std::sqrt(static_cast<double>(-c) / static_cast<double>(a));
+                    x_2 = -x_1;
+
+                    if (x_1 > x_2) std::swap(x_1, x_2);
+
+                    std::cout << x_1 << " " << x_2;
+                }
+                else std::cout << "no solutions";
+            }
+            return;
+        }
+        else if (c_is_Zero) {
+            x_1 = static_cast<double>(0);
+            x_2 = static_cast<double>(-b) / static_cast<double>(a);
+
+            if (x_1 > x_2) std::swap(x_1, x_2);
+
+            std::cout << x_1 << " " << x_2;
+
+            return;
+        }
+    }
+
+    double b_d = static_cast<double>(b);
+    double a_d = static_cast<double>(a);
+    double c_d = static_cast<double>(c);
+
+    double D_2 = b_d * b_d - 4 * a_d * c_d;
+    double eps = 1e-14;
+
+    if (D_2 < 0) {
+        std::cout << "no solutions";
+        return;
+    } 
+    else if (D_2 < eps) {
+        x_1 = -b_d / (2 * a_d);
+        std::cout << x_1;
+    }
+    else {
+        double D = static_cast<double>(std::sqrt(D_2));
+
+        x_1 = (-b_d + D) / (2 * a_d);
+        x_2 = (-b_d - D) / (2 * a_d);
+
+        if (x_1 > x_2) std::swap(x_1, x_2);
+
+        std::cout << x_1 << " " << x_2;
+    }
+}

01_week/tasks/rms/rms.cpp

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

02_week/tasks/func_array/func_array.cpp

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

02_week/tasks/last_of_us/last_of_us.cpp

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