Задание 01_week

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

01_week/tasks/char_changer/char_changer.cpp

@@ -1,7 +1,89 @@
 #include <cstddef>
 #include <stdexcept>
+#include <stdlib.h>
+#include <string.h>
 
+size_t CharChanger(char array[], size_t size, char delimiter = ' ')
+{
+    char array_fin[size]={};
 
-size_t CharChanger(char array[], size_t size, char delimiter = ' ') {
-    throw std::runtime_error{"Not implemented"};
+    size_t temp_ptr = 0; // переменная для хранения текущего положения данных  в массиве
+
+    for (size_t i = 0; i < size-1; ++i)
+    {
+
+        if (isalnum(array[i]))
+        { // если это буква-цифра
+            if (isalpha(array[i]))
+            { // если это буква
+                size_t temp = 1;
+                if (i + 1 < size)
+                    while (temp + i < size && array[i] == array[i + temp])
+                        ++temp;
+                array_fin[temp_ptr] = array[i];
+                if (islower(array[i]))
+                { // если она низкая, делаем ее высокой
+                    array_fin[temp_ptr] = toupper(array[i]);
+                }
+                ++temp_ptr;    // счетчик на конец преобразованного массива +1
+                i += temp - 1; // смещаем счетчик рабочий
+
+                if (temp > 1)
+                {                                                                          // если у нас много повторяющихся букоф
+                    temp >= 10 ? (array_fin[temp_ptr] = '0') : (array_fin[temp_ptr] = '0' + temp); // ставим число повторений, либо 0, если повторений больше 10
+                    ++temp_ptr;                                                            // увеличиваем рабочий счетчик
+                }
+            }
+            else
+            { // обрабатываем цифры
+                size_t temp = 1;
+                while (temp + i < size && array[i] == array[i + temp])
+                    ++temp;
+                array_fin[temp_ptr] = '*';
+                ++temp_ptr;
+                i += temp - 1;
+                if (temp > 1)
+                {                                                                          // если у нас много повторяющихся цифр
+                    temp >= 10 ? (array_fin[temp_ptr] = '0') : (array_fin[temp_ptr] = '0' + temp); // ставим число повторений, либо 0, если повторений больше 10
+                    ++temp_ptr;                                                            // увеличиваем рабочий счетчик
+                }
+            }
+        }
+        else
+        {
+            if (array[i] != ' ')
+            {
+                // обрабатываем символы..
+                size_t temp = 1;
+                while (temp + i < size && array[i] == array[i + temp])
+                    ++temp;
+                array_fin[temp_ptr] = '_';
+                ++temp_ptr;
+                i += temp - 1;
+                if (temp > 1)
+                {                                                                          // если у нас много повторяющихся цифр
+                    temp >= 10 ? (array_fin[temp_ptr] = '0') : (array_fin[temp_ptr] = '0' + temp); // ставим число повторений, либо 0, если повторений больше 10
+                    ++temp_ptr;                                                            // увеличиваем рабочий счетчик
+                }
+            }
+            else
+            { //...если это не пробел. если пробел, то все ок, меняем:
+                size_t temp = 1;
+                while (temp + i < size && array[i] == array[i + temp])
+                    ++temp;
+                i += temp-1;
+                array_fin[temp_ptr] = delimiter;
+                ++temp_ptr;
+            }
+        }
+    }
+    for (size_t i = temp_ptr; i < size; ++i)
+    {
+        array[i] = '\0'; // зануляем все оставшееся место в памяти
+    }
+
+    strncpy(array, array_fin, size);
+
+    return temp_ptr;
 }
+

01_week/tasks/check_flags/check_flags.cpp

@@ -1,5 +1,6 @@
 #include <cstdint>
 #include <stdexcept>
+#include <iostream>
 
 
 enum class CheckFlags : uint8_t {
@@ -13,6 +14,67 @@ enum class CheckFlags : uint8_t {
     ALL = TIME | DATE | USER | CERT | KEYS | DEST
 };
 
+
+// побитовое сравнение каждого флага и переданного числа. сравниваем,, приводя все к 8-ми битному инту
+// пробовал сделать через switch, не получилось. удивился, что к CheckFlags обращаемся как к пространству имен
+
+
 void PrintCheckFlags(CheckFlags flags) {
-    throw std::runtime_error{"Not implemented"};
+    uint8_t value = static_cast<uint8_t>(flags);
+
+    if (value > 0b00111111) {  // Если установлены биты вне диапазона 0-5
+        std::cout << "";
+        return;
+    }
+
+    bool first=true;
+
+    std::cout<<'[';
+
+    if (static_cast<uint8_t>(flags)&static_cast<u_int8_t>(CheckFlags::TIME))
+    {
+        std::cout<<"TIME";
+        first=false;
+    }
+
+    if (static_cast<uint8_t>(flags)&static_cast<u_int8_t>(CheckFlags::DATE))
+    {
+        if (!first) std::cout<<",";
+        first = false;
+        std::cout<<"DATE";
+    }
+
+    if (static_cast<uint8_t>(flags)&static_cast<u_int8_t>(CheckFlags::USER))
+    {
+        if (!first) std::cout<<",";
+        first = false;
+        std::cout<<"USER";
+    }
+
+    if (static_cast<uint8_t>(flags)&static_cast<u_int8_t>(CheckFlags::CERT))
+    {
+        if (!first) std::cout<<",";
+        first = false;
+        std::cout<<"CERT";
+    }
+
+    if (static_cast<uint8_t>(flags)&static_cast<u_int8_t>(CheckFlags::KEYS))
+    {
+        if (!first) std::cout<<",";
+        first = false;
+        std::cout<<"KEYS";
+    }
+
+    if (static_cast<uint8_t>(flags)&static_cast<u_int8_t>(CheckFlags::DEST))
+    {
+        if (!first) std::cout<<",";
+        first = false;
+        std::cout<<"DEST";
+    }
+
+        std::cout<<']';
+
+
+
+
 }

01_week/tasks/length_lit/length_lit.cpp

@@ -0,0 +1,41 @@
+constexpr long double operator""_m_to_cm(long double value){
+    return value *100.00L;
+};
+constexpr long double operator""_cm_to_m(long double value){
+    return value * 0.01L;
+};
+
+constexpr long double operator""_m_to_ft(long double value) {
+    return value *3.280839895013123L;
+};
+
+constexpr long double operator""_m_to_in(long double value) {
+    return value *39.37007874015748031496062992L;
+};
+constexpr long double operator""_in_to_m(long double value) {
+    return value*0.0254L;
+};
+constexpr long double operator""_ft_to_m(long double value) {
+    return value *0.3048L;
+};
+constexpr long double operator""_ft_to_in(long double value) {
+    return value *12.0L;
+};
+
+constexpr long double operator""_in_to_ft(long double value) {
+    return value /12.0L;
+};
+
+constexpr long double operator""_cm_to_ft(long double value) {
+    return value *0.03280839895013123359580052493L;
+};
+
+constexpr long double operator""_cm_to_in(long double value) {
+    return value *0.39370078740157480314L;
+};
+constexpr long double operator""_in_to_cm(long double value) {
+    return value* 2.54L;
+};
+constexpr long double operator""_ft_to_cm(long double value) {
+    return value *30.48L;
+};

01_week/tasks/print_bits/print_bits.cpp

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

01_week/tasks/quadratic/quadratic.cpp

@@ -1,6 +1,50 @@
 #include <stdexcept>
+#include <iostream>
+#include <iomanip>
+#include <cmath>
 
 
-void SolveQuadratic(int a, int b, int c) {
-    throw std::runtime_error{"Not implemented"};
+void SolveQuadratic(int a, int b, int c)
+{
+    if (a == 0) {
+        if (b == 0) {
+            if (c == 0) {
+                std::cout << "infinite solutions";
+            } else {
+                std::cout << "no solutions";
+            }
+        } else {
+            std::cout << static_cast<double>(-c) / static_cast<double>(b);
+        }
+        return;
+    }
+
+    double discr = b * b - 4 * a * c;
+
+    if (discr)
+    {
+        if (discr > 0)
+        {
+            double solution1 = 0;
+            double solution2 = 0;
+
+            solution1 = (-b + std::sqrt(discr)) / (a * 2.);
+            solution2 = (-b - std::sqrt(discr)) / (a * 2.);
+
+            if (solution1 > solution2)
+                std::swap(solution1, solution2);
+
+            std::cout << std::setprecision(6) << solution1 << ' ' << solution2;
+        }
+        else
+        {
+            std::cout << "no solutions";
+
+        }
+    }
+    else
+    {
+        std::cout << std::setprecision(6) << (-b - std::sqrt(discr)) / (2.0 * a);
+
+    }
 }

01_week/tasks/rms/rms.cpp

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

02_week/tasks/func_array/func_array.cpp

@@ -0,0 +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);
+        }
+    }
+
+    return sum;
+}

02_week/tasks/last_of_us/last_of_us.cpp

@@ -0,0 +1,17 @@
+#include <stdexcept>
+
+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;
+}