Дудин Лев

02_week/tasks/func_array/func_array.cpp

@@ -1,6 +1,16 @@
 #include <stdexcept>
 
+double ApplyOperations(double a, double b, double (*func[])(double x, double y), size_t size)
+{
+    long double sum = 0.;
+    if (func)
+    {
+        for (size_t i = 0; i < size; ++i)
+        {
+            if (*(func+i))
+                sum += func[i](a, b);
+        }
+    }
 
-double ApplyOperations(double a, double b /* other arguments */) {
-    throw std::runtime_error{"Not implemented"};
+    return sum;
 }

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"};
+const int* FindLastElement(const int* begin, const int* end, bool predicate(int x))
+{
+    if (predicate && begin && end)
+    {
+        size_t size = end - begin;
+        for (long i = size-1; i>=0; --i)
+        {
+            if (predicate(begin[i]))
+            {
+                return (begin + i);
+            }
+        }
+    }
+    return end;
 }

02_week/tasks/little_big/little_big.cpp

@@ -1,10 +1,70 @@
 #include <stdexcept>
+#include <iostream>
+#include <string>
 
 
-void PrintMemory(int /* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
+void PrintMemory(int num, bool is_inverted = false)
+{
+
+        int size = sizeof(int);
+        unsigned char *conv = reinterpret_cast<unsigned char *>(&num); // указатель на конкретный бит в инте
+        std::string str;                                    // строка, которую мы выведем
+
+        char dict[] = {"0123456789ABCDEF"}; // массив символов, в которые мы будем переводить
+
+        if (is_inverted) //big endian
+        {
+            conv += size-1;
+            for (; conv >= reinterpret_cast<unsigned char *>(&num); --conv)
+            {
+                str.push_back(dict[*conv >> 4]);
+                str.push_back(dict[*conv & 0b00001111]);
+            }
+        }
+
+        else // little endian
+        {
+            for (; conv - reinterpret_cast<unsigned char *>(&num) < size; ++conv)
+            {
+                str.push_back(dict[*conv >> 4]);
+                str.push_back(dict[*conv & 0b00001111]);
+            }
+        }
+        std::cout << "0x" << str << std::endl;
+
+
 }
 
-void PrintMemory(double /* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
-}
+void PrintMemory(double num, bool is_inverted = false)
+{
+
+        int size = sizeof(double);
+        unsigned char *conv = reinterpret_cast<unsigned char *>(&num); // указатель на конкретный бит в дабле
+        std::string str;// строка, которую мы выведем
+
+        char dict[] = {"0123456789ABCDEF"}; // массив символов, в которые мы будем переводить
+
+        if (is_inverted) //big endian
+        {
+            conv += size-1;
+            for (; conv >= reinterpret_cast<unsigned char *>(&num); --conv)
+            {
+                str.push_back(dict[*conv >> 4]);
+                str.push_back(dict[*conv & 0b00001111]);
+            }
+        }
+
+        else // little endian
+        {
+            for (; conv - reinterpret_cast<unsigned char *>(&num) < size; ++conv)
+            {
+                str.push_back(dict[*conv >> 4]);
+                str.push_back(dict[*conv & 0b00001111]);
+            }
+        }
+
+
+        std::cout << "0x" << str << std::endl;
+
+
+}

02_week/tasks/longest/longest.cpp

@@ -1,6 +1,55 @@
 #include <stdexcept>
 
+char *FindLongestSubsequence(char *begin, char *end, size_t &count)
+{
+    count = 0;
+    if (begin && end)
+    {
 
-/* return_type */ FindLongestSubsequence(/* ptr_type */ begin, /* ptr_type */ end, /* type */ count) {
-    throw std::runtime_error{"Not implemented"};
+        char *subsequence = nullptr;
+        for (long i = 0; i < end - begin; ++i)
+        {
+            char *newsequence = begin + i;
+            size_t t = 1;
+            while (*newsequence == *(newsequence + t) && newsequence + t < end)
+            {
+                ++i;
+                ++t;
+            }
+            if (t > count)
+            {
+                count = t;
+                subsequence = newsequence;
+            }
+        }
+        return subsequence;
+    }
+    return nullptr;
+}
+
+const char *FindLongestSubsequence(const char *begin, const char *end, size_t &count)
+{
+    count = 0;
+    size_t pos = 0;
+    if (begin && end)
+    {
+
+        for (long i = 0; i < end - begin; ++i)
+        {
+            size_t t = 1;
+            const char *newsubsequence = begin + i;
+            while (*newsubsequence == *(newsubsequence + t) && i < end - begin - 1)
+            {
+                ++i;
+                ++t;
+            }
+            if (t > count)
+            {
+                count = t;
+                pos = i - t + 1;
+            }
+        }
+        return begin + pos;
+    }
+    return nullptr;
 }

02_week/tasks/pretty_array/pretty_array.cpp

@@ -1,6 +1,51 @@
 #include <stdexcept>
+#include <iostream>
+#include <cmath>
+
+void PrintArray(std::nullptr_t, std::nullptr_t)
+{
+    std::cout<<"[]\n";
+}
+
+
+
+
+template<typename T>
+void PrintArray(T* begin, T* end, size_t limiter = 0)
+{
+    if (begin && end && begin != end)
+    {
+        std::cout << '[';
+
+        size_t len = abs(begin-end);
+        if (begin < end)
+        {
+            for (size_t i = 0; i < len; ++i)
+            {
+                if (limiter && i != 0 && !(i % limiter))
+                    std::cout << "...\n" << ' ';
+
+                i!=(len-1)? ( std::cout << begin[i] << ", "): ( std::cout << begin[i] << "]\n");
+
+            }
+
+        }
+        else
+        {
+            for (size_t i = 0; i < len; ++i)
+            {
+                if (limiter && i != 0 && !(i % limiter))
+                    std::cout << "...\n" << ' ';
+                T *current = begin - i;
+                current == end + 1 ? (std::cout << *current) : (std::cout << *current << ", ");
+            }
+            std::cout<<"]\n";
+        }
+    }
+    else
+    {
+        std::cout<<"[]\n";
+    }
+}
 
 
-void PrintArray(/* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
-}

02_week/tasks/swap_ptr/swap_ptr.cpp

@@ -1,6 +1,34 @@
 #include <stdexcept>
 
 
-void SwapPtr(/* write arguments here */) {
-    throw std::runtime_error{"Not implemented"};
-}
+
+
+void SwapPtr(int*& a, int*& b)
+{
+    int* c = a;
+    a = b;
+    b = c;
+}
+
+void SwapPtr(const int*& a, const int*& b){
+    const int* c = a;
+    a = b;
+    b = c;
+}
+
+void SwapPtr(int**& a, int**& b)
+{
+    int** c = a;
+    a = b;
+    b = c;
+}
+
+
+/* рабочий вариант через template для любого типа данных. на лекции не проходили, просто показать что я нашел и такую штуку
+template<typename T>
+void SwapPtr(T*& a, T*& b){
+    T* c = a;
+    a = b;
+    b = c;
+}
+    */

03_week/tasks/data_stats/data_stats.cpp

@@ -1,11 +1,38 @@
 #include <stdexcept>
-
+#include <vector>
+#include <math.h>
 
 struct DataStats {
     double avg = 0.0;
     double sd = 0.0;
 };
 
-/* return_type */ CalculateDataStats(/* args */) {
-    throw std::runtime_error{"Not implemented"};
+struct DataStats CalculateDataStats(std::vector<int> data) {
+
+    struct DataStats output;
+    if (data.empty()){
+        output.avg = 0.;
+        output.sd = 0.;
+        return output;
+    }
+
+    /*
+    стандартная девиация считается как sqrt(сумма((i - avg)^2)/size)
+    если разложим квадратное уравнение: sqrt(сумма(i^2 - 2*i*avg + avg^2)/size)=>
+    sqrt((сумма(i^2)+ сумма(- 2* i*avg)+сумма(avg^2))/size) - его имплементируем
+    */
+
+    double first_num = 0.;
+    double second_num= 0.;
+
+    for (size_t i=0; i< data.size(); ++i){
+        output.avg+=data[i];
+        first_num += static_cast<double>(data[i])*static_cast<double>(data[i]);
+        second_num+= data[i]; 
+    }
+    output.avg /= data.size();
+    output.sd = first_num - 2. * second_num * output.avg + output.avg * output.avg * data.size();
+    output.sd /= data.size();
+    output.sd = sqrt(output.sd);
+    return output;
 }

03_week/tasks/easy_compare/easy_compare.cpp

@@ -1,16 +1,49 @@
 #include <stdexcept>
+#include <tuple>
 
-
-struct Date {
+struct Date
+{
     unsigned year;
     unsigned month;
     unsigned day;
 };
 
-struct StudentInfo {
+struct StudentInfo
+{
     size_t id;
     char mark;
     int score;
     unsigned course;
     Date birth_date;
-};
+};
+
+bool operator<(const Date &s1, const Date &s2)
+{
+    return std::tie(s1.year, s1.month, s1.day) < std::tie(s2.year, s2.month, s2.day);
+}
+
+bool operator==(const Date &s1, const Date &s2)
+{
+    return std::tie(s1.year, s1.month, s1.day) == std::tie(s2.year, s2.month, s2.day);
+}
+
+bool operator==(const StudentInfo &s1, const StudentInfo &s2)
+{
+    return std::tie(s1.mark, s1.score) == std::tie(s2.mark, s2.score);
+}
+
+bool operator<(const StudentInfo &s1, const StudentInfo &s2)
+{
+    return std::tie(s2.mark, s1.score, s2.course, s1.birth_date) <
+           std::tie(s1.mark, s2.score, s1.course, s2.birth_date);
+}
+
+bool operator!=(const StudentInfo &s1, const StudentInfo &s2) { return !(s1 == s2); }
+bool operator>(const StudentInfo &s1, const StudentInfo &s2) { return s2 < s1; }
+bool operator<=(const StudentInfo &s1, const StudentInfo &s2) { return !(s2 < s1); }
+bool operator>=(const StudentInfo &s1, const StudentInfo &s2) { return !(s1 < s2); }
+
+bool operator!=(const Date &d1, const Date &d2) { return !(d1 == d2); }
+bool operator>(const Date &d1, const Date &d2) { return d2 < d1; }
+bool operator<=(const Date &d1, const Date &d2) { return !(d2 < d1); }
+bool operator>=(const Date &d1, const Date &d2) { return !(d1 < d2); }