Кайгородов Александр

01_week/tasks/addition/addition.cpp

@@ -3,5 +3,7 @@
 
 
 int64_t Addition(int a, int b) {
-    throw std::runtime_error{"Not implemented"};
+    int64_t c = static_cast<int64_t>(a);
+    int64_t d = static_cast<int64_t>(b);
+    return c + d;
 }

01_week/tasks/check_flags/check_flags.cpp

@@ -1,18 +1,66 @@
 #include <cstdint>
 #include <stdexcept>
+#include <iostream>
 
 
 enum class CheckFlags : uint8_t {
-    NONE = 0,
-    TIME = (1 << 0),
-    DATE = (1 << 1),
-    USER = (1 << 2),
-    CERT = (1 << 3),
-    KEYS = (1 << 4),
-    DEST = (1 << 5),
+    NONE = 0,         //0
+    TIME = (1 << 0),  //1
+    DATE = (1 << 1),  //2
+    USER = (1 << 2),  //4
+    CERT = (1 << 3),  //8
+    KEYS = (1 << 4),  //16
+    DEST = (1 << 5),  //32
     ALL = TIME | DATE | USER | CERT | KEYS | DEST
 };
 
 void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
+    if (flags <= CheckFlags::ALL && flags >= CheckFlags::NONE){
+        std::cout << "[";
+        bool prev_print = 0;
+        if (static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::TIME)){
+            if (prev_print == 1){
+                std::cout << ",";
+            }
+            std::cout << "TIME";
+            prev_print = 1;
+        }
+        if (static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::DATE)){
+            if (prev_print == 1){
+                std::cout << ",";
+            }
+            std::cout << "DATE";
+            prev_print = 1;
+        }
+        if (static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::USER)){
+            if (prev_print == 1){
+                std::cout << ",";
+            }
+            std::cout << "USER";
+            prev_print = 1;
+        }
+        if (static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::CERT)){
+            if (prev_print == 1){
+                std::cout << ",";
+            }
+            std::cout << "CERT";
+            prev_print = 1;
+        }
+        if (static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::KEYS)){
+            if (prev_print == 1){
+                std::cout << ",";
+            }
+            std::cout << "KEYS";
+            prev_print = 1;
+        }
+        if (static_cast<uint8_t>(flags) & static_cast<uint8_t>(CheckFlags::DEST)){
+            if (prev_print == 1){
+                std::cout << ",";
+            }
+            std::cout << "DEST";
+            prev_print = 1;
+        }
+        std::cout << "]";
+    }
+
 }

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,41 @@
+double operator""_cm_to_m(long double x) {
+    return x / 100.0;
+}
+double operator""_m_to_cm(long double x) {
+    return x* 100.0;
+}
+
+double operator""_in_to_ft(long double x) {
+    return x / 12.0;
+}
+double operator""_ft_to_in(long double x) {
+    return x * 12.0;
+}
+
+double operator""_m_to_ft(long double x) {
+    return x / 0.3048;
+}
+double operator""_ft_to_m(long double x) {
+    return x * 0.3048;
+}
+
+double operator""_cm_to_ft(long double x) {
+    return x / 30.48;
+}
+double operator""_ft_to_cm(long double x) {
+    return x * 30.48;
+}
+
+double operator""_cm_to_in(long double x) {
+    return x / 30.48 * 12.0;
+}
+
+double operator""_m_to_in(long double x) {
+    return x* 100.0 / 30.48 * 12.0;
+}
+double operator""_in_to_cm(long double x) {
+    return x / 12.0 * 30.48;
+}
+double operator""_in_to_m(long double x) {
+    return x / 12.0 * 30.48 / 100;
+}

01_week/tasks/print_bits/print_bits.cpp

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

01_week/tasks/rms/rms.cpp

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

02_week/tasks/func_array/func_array.cpp

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

02_week/tasks/last_of_us/last_of_us.cpp

@@ -1,6 +1,17 @@
 #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 (begin == nullptr or end == nullptr or begin >= end){
+        return const_cast<int*>(end);
+    }
+    int* result = const_cast<int*>(end);
+    int* p = const_cast<int*>(begin);
+    while (p < end){
+        if(predicate(*p)){
+            result = p;
+        }
+        p++;
+    }
+    return result;
 }

02_week/tasks/longest/longest.cpp

@@ -1,6 +1,30 @@
 #include <stdexcept>
 
 
-/* return_type */ FindLongestSubsequence(/* ptr_type */ begin, /* ptr_type */ end, /* type */ count) {
-    throw std::runtime_error{"Not implemented"};
+char* FindLongestSubsequence(const char* begin, const char* end, size_t& count) {
+    count = 0;
+    if ((begin >= end) or (begin == nullptr) or (end == nullptr)){
+        return nullptr;
+    }
+    char* long_begin = const_cast<char*>(begin);
+    //char long_char = *begin;
+    size_t len = 0;
+    char* char0 = const_cast<char*>(begin);
+    while (begin <= end){
+        if(*char0 == *begin){
+            len++;
+        }
+        else{
+            if (len > count){
+                count = len;
+                //long_char = char0;
+                long_begin = const_cast<char*>(char0);
+            }
+            char0 = const_cast<char*>(begin);
+            len = 1;
+        }
+
+        begin++;
+    }
+    return long_begin;
 }

02_week/tasks/pretty_array/pretty_array.cpp

@@ -1,6 +1,50 @@
 #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 ogr = 0) {
+    /*if (begin == nullptr or end == nullptr){
+        return;
+    }*/
+
+    size_t i_ogr = 1;
+    std::cout <<"[";
+
+    if (end >= begin){
+        int* p = const_cast<int*>(begin);
+        while (p < end){
+            std::cout << *p;
+            if (p + 1 != end){
+                std::cout <<", ";
+                if (ogr != 0 and i_ogr == ogr){
+                    std::cout << "..." << std::endl << " ";
+                    i_ogr = 0;
+                }
+            }
+
+            p++;
+            i_ogr++;
+        }
+    }
+    else{
+        int* p = const_cast<int*>(end);
+        p--;
+        while (p >= begin){
+            std::cout << *p;
+            if (p != begin){
+                std::cout <<", ";
+                if (ogr != 0 and i_ogr == ogr){
+                    std::cout << "..." << std::endl << " ";
+                    i_ogr = 0;
+                }
+            }
+
+            p--;
+            i_ogr++;
+        }
+    }
+
+
+    std::cout << "]" << std::endl;
 }

02_week/tasks/swap_ptr/swap_ptr.cpp

@@ -1,6 +1,19 @@
 #include <stdexcept>
 
 
-void SwapPtr(/* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
-}
+void SwapPtr(int*& ptr1, int*& ptr2) {
+    int* ptr0 = ptr1;
+    ptr1 = ptr2;
+    ptr2 = ptr0;
+}
+void SwapPtr(const int*& ptr1, const int*& ptr2) {
+    const int* ptr0 = ptr1;
+    ptr1 = ptr2;
+    ptr2 = ptr0;
+}
+void SwapPtr(int**& ptr1, int**& ptr2) {
+    int** ptr0 = ptr1;
+    ptr1 = ptr2;
+    ptr2 = ptr0;
+}
+

03_week/tasks/data_stats/data_stats.cpp

@@ -1,11 +1,49 @@
+#include <cmath>
 #include <stdexcept>
+#include <vector>
 
 
 struct DataStats {
     double avg = 0.0;
     double sd = 0.0;
 };
 
-/* return_type */ CalculateDataStats(/* args */) {
-    throw std::runtime_error{"Not implemented"};
+DataStats CalculateDataStats(std::vector<int>& vect) {
+    int n = 0;
+
+    DataStats rezult = {0, 0};
+    if (vect.begin() == vect.end()){
+        return rezult;
+    }
+    for (auto it = vect.begin(); it != vect.end(); ++it) {
+        ++n;
+        rezult.avg += *it;
+    }
+    rezult.avg /= n;
+    for (auto it = vect.begin(); it != vect.end(); ++it) {
+        rezult.sd += pow((*it - rezult.avg), 2);
+    }
+    rezult.sd /= n;
+    rezult.sd = sqrt(rezult.sd);
+    return rezult;
+}
+
+DataStats CalculateDataStats(const std::vector<int>& vect) {
+    int n = 0;
+
+    DataStats rezult = {0, 0};
+    if (vect.begin() == vect.end()){
+        return rezult;
+    }
+    for (auto it = vect.begin(); it != vect.end(); ++it) {
+        ++n;
+        rezult.avg += *it;
+    }
+    rezult.avg /= n;
+    for (auto it = vect.begin(); it != vect.end(); ++it) {
+        rezult.sd += pow((*it - rezult.avg), 2);
+    }
+    rezult.sd /= n;
+    rezult.sd = sqrt(rezult.sd);
+    return rezult;
 }