lab1

CMakeLists.txt

@@ -10,9 +10,11 @@ else()
     add_compile_options(-Wall -Wextra -Wpedantic -Wno-gnu-empty-struct -Wno-unused-parameter)
 endif()
 
-add_subdirectory(LibraryC)
-add_subdirectory(LibraryCPP)
+# add_subdirectory(LibraryC)
+# add_subdirectory(LibraryCPP)
 add_subdirectory(LibraryCPPClass)
-add_subdirectory(LibraryCPPTemplate)
+# add_subdirectory(LibraryCPPTemplate)
+
+# add_subdirectory(Lab1C)
+add_subdirectory(Lab1CPPClass)
 
-add_subdirectory(Lab1C)

Lab1C/CMakeLists.txt

@@ -1,5 +1,5 @@
-add_executable(Lab1C lab1.c)
-target_include_directories(Lab1C PUBLIC ../LibraryC)
-target_link_libraries(Lab1C LibraryC)
+# add_executable(Lab1C lab1.c)
+# target_include_directories(Lab1C PUBLIC ../LibraryC)
+# target_link_libraries(Lab1C LibraryC)
 
-add_test(NAME TestLab1C COMMAND Lab1C ${CMAKE_CURRENT_SOURCE_DIR}/input.txt)
+# add_test(NAME TestLab1C COMMAND Lab1C ${CMAKE_CURRENT_SOURCE_DIR}/input.txt)

Lab1CPPClass/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_executable(Lab1CPPClass lab1.cpp)
+target_include_directories(Lab1CPPClass PUBLIC ../LibraryCPPClass)
+target_link_libraries(Lab1CPPClass LibraryCPPClass)
+
+add_test(NAME TestLab1CPPClass COMMAND Lab1CPPClass ${CMAKE_CURRENT_SOURCE_DIR}/input.txt ${CMAKE_CURRENT_SOURCE_DIR}/output.txt ${CMAKE_CURRENT_SOURCE_DIR}/randomInput.txt) 

Lab1CPPClass/input.txt

@@ -0,0 +1,4 @@
+9
+5 4 3 2 5 4 3 2 5
+7
+1 3 2 3 4 3 5

Lab1CPPClass/lab1.cpp

@@ -0,0 +1,168 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <ctime>
+#include <bits/stdc++.h>
+#include "array.h"
+
+Array* array_create_and_read(std::ifstream& input)
+{
+    size_t n;
+    input >> n;
+
+    Array* arr = new Array(n); 
+
+    for (size_t i = 0; i < n; ++i)
+    {
+        int x;
+        input >> x;
+        arr->set(i, x); 
+    }
+    return arr;
+}
+
+
+Array* array_create_and_random_input(std::ifstream& input, int left, int right) {
+    size_t n;
+    input >> n;
+
+    Array* arr = new Array(n);
+
+    for (size_t i = 0; i < n; ++i) {
+        int random_num = left + rand() % (right - left + 1);
+        arr->set(i, random_num);
+    }
+    return arr;
+}
+
+
+void task1(const Array& arr)
+{
+    Array marks(4); 
+    for(size_t i = 0; i < arr.size(); i++) {
+        marks.set(arr.get(i)-2, marks.get(arr.get(i)-2) + 1); // marks[arr[i] - 2]++;
+    }
+    for(size_t i = 0; i < 4; i++) {
+        std::cout << "Mark " << i+2 << " : " << marks.get(i) << '\t';
+    }
+    std::cout << '\n';
+}
+
+void task2(const Array& arr)
+{
+    int min_value = INT_MAX;
+    int max_value = INT_MIN;
+
+    for (size_t i = 0; i < arr.size(); ++i) {
+        int current = arr.get(i);
+        if (current < min_value) min_value = current;
+        if (current > max_value) max_value = current;
+    }
+
+    size_t frequency_size = max_value - min_value + 1;
+    Array frequency(frequency_size);
+
+    for (size_t i = 0; i < arr.size(); ++i) {
+        int index = arr.get(i) - min_value; 
+        frequency.set(index, frequency.get(index) + 1);
+    }
+
+    int max_frequency = 0;
+    int most_frequent_number = min_value;
+
+    for (size_t i = 0; i < frequency_size; ++i) {
+        if (frequency.get(i) > max_frequency) {
+            max_frequency = frequency.get(i);
+            most_frequent_number = i + min_value; 
+        }
+    }
+
+    std::cout << most_frequent_number << '\n';
+}
+
+
+
+//be work for any nums, not only for the segment [-100, 100]
+void task2_v2(const Array& arr) {
+    std::unordered_map<int, int> mp;
+
+    for(size_t i = 0; i < arr.size(); i++) {
+        int num = arr.get(i);
+        if(mp.find(num) == mp.end()) {
+            mp[num] = 0;
+        } else {
+            mp[num]++;
+        }
+    }
+
+    int max_frequency = 0;
+    int most_frequent_number = INT_MIN;
+
+    for(auto it : mp) {
+        if(it.second > max_frequency) {
+            max_frequency = it.second;
+            most_frequent_number = it.first;
+        }
+    }
+    std::cout << most_frequent_number << '\n';
+}
+
+bool check_output(std::ifstream& output, const Array& arr) {
+    for(size_t i = 0; i < arr.size(); i++) {
+        int num; 
+        output >> num;
+        if(num != arr.get(i)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+int main(int argc, char **argv)
+{
+    //For random     
+    std::srand(std::time(nullptr));
+
+    // With my tests
+    std::ifstream input(argv[1]);
+    std::ifstream output(argv[2]);
+    if (!input.is_open()) {
+        std::cerr << "Failed to open file: " << argv[1] << "\n";
+        return 1;
+    }
+
+    Array* arr = array_create_and_read(input);
+    task1(*arr);
+    if(check_output(output, *arr)) {
+        return 1;
+    }
+    delete arr;
+
+    arr = array_create_and_read(input);
+    task2(*arr);
+    if(check_output(output, *arr)) {
+        return 1;
+    }
+    delete arr;
+    input.close();
+
+    // With random
+    std::ifstream randomInput(argv[3]);
+    if (!randomInput.is_open()) {
+        std::cerr << "Failed to open file: " << argv[3] << "\n";
+        return 1;
+    }
+
+    arr = array_create_and_random_input(randomInput, 2, 5);
+    task1(*arr);
+    delete arr;
+
+    arr = array_create_and_random_input(randomInput, -100, 100);
+    task2(*arr);
+    delete arr;
+
+    randomInput.close();
+
+
+    return 0;
+}

Lab1CPPClass/output.txt

@@ -0,0 +1,2 @@
+2 2 2 3
+3

Lab1CPPClass/randomInput.txt

@@ -0,0 +1,2 @@
+10
+10

LibraryC/Tests/CMakeLists.txt

@@ -1,7 +1,7 @@
-add_executable(TestArrayC array.cpp)
-target_include_directories(TestArrayC PUBLIC ..)
-target_link_libraries(TestArrayC LibraryC)
-add_test(TestArrayC TestArrayC)
+# add_executable(TestArrayC array.cpp)
+# target_include_directories(TestArrayC PUBLIC ..)
+# target_link_libraries(TestArrayC LibraryC)
+# add_test(TestArrayC TestArrayC)
 
 # add_executable(TestListC list.cpp)
 # target_include_directories(TestListC PUBLIC ..)

LibraryCPPClass/Tests/CMakeLists.txt

@@ -1,7 +1,7 @@
-# add_executable(TestArrayCPPClass array.cpp)
-# target_include_directories(TestArrayCPPClass PUBLIC ..)
-# target_link_libraries(TestArrayCPPClass LibraryCPPClass)
-# add_test(TestArrayCPPClass TestArrayCPPClass)
+add_executable(TestArrayCPPClass array.cpp)
+target_include_directories(TestArrayCPPClass PUBLIC ..)
+target_link_libraries(TestArrayCPPClass LibraryCPPClass)
+add_test(TestArrayCPPClass TestArrayCPPClass)
 
 # add_executable(TestListCPPClass list.cpp)
 # target_include_directories(TestListCPPClass PUBLIC ..)

LibraryCPPClass/Tests/array.cpp

@@ -1,5 +1,5 @@
 #include <iostream>
 #include "array.h"
 
 int main()
 {
@@ -26,5 +26,27 @@
         }
     }
 
+    try
+    {
+        arr->set(20, 5);  // error index
+        std::cout << "set() set() does not handle invalid index\n";
+        return 1;
+    }
+    catch (const std::out_of_range& e)
+    {
+        std::cout << "Caught expected out_of_range exception for set() with invalid index\n";
+    }
+
+    try
+    {
+        arr->get(20);  // error index
+        std::cout << "set() set() does not handle invalid index\n";
+        return 1;
+    }
+    catch (const std::out_of_range& e)
+    {
+        std::cout << "Caught expected out_of_range exception for get() with invalid index\n";
+    }
+
     delete arr;
 }

LibraryCPPClass/array.cpp

@@ -1,32 +1,59 @@
 #include "array.h"
 
-Array::Array(size_t size)
+Array::Array(size_t size) : m_size(size), m_data(new Data[size]())
 {
+    for(size_t i = 0; i < m_size; i++) {
+        m_data[i] = 0;
+    }
 }
 
-Array::Array(const Array &a)
+Array::Array(const Array &a) : m_size(a.m_size), m_data(new Data[a.m_size])
 {
+    for (size_t i = 0; i < m_size; ++i) {
+        m_data[i] = a.m_data[i];
+    }
 }
 
 Array &Array::operator=(const Array &a)
 {
+    if (this == &a) {
+        return *this;
+    }
+
+    delete[] m_data;
+
+    m_size = a.m_size;
+    m_data = new Data[m_size];
+
+    for (size_t i = 0; i < m_size; ++i) {
+        m_data[i] = a.m_data[i];
+    }
+
     return *this;
 }
 
 Array::~Array()
 {
+    delete[] m_data;
 }
 
 Data Array::get(size_t index) const
 {
-    return Data(0);
+    if (index >= m_size) {
+        throw std::out_of_range("Index out of range\n");
+    }
+    return m_data[index];
 }
 
 void Array::set(size_t index, Data value)
 {
+    if (index >= m_size) {
+        throw std::out_of_range("Index out of range");
+    }
+    m_data[index] = value;
 }
 
 size_t Array::size() const
 {
-    return 0;
+    return m_size;
 }

LibraryCPPClass/array.h

@@ -1,11 +1,13 @@
 #ifndef ARRAY_H
 #define ARRAY_H
 
 #include <cstddef>
+#include <stdexcept>
+#include <iostream>
 
 typedef int Data;
 
 class Array
 {
 public:
     // create array
@@ -31,6 +33,8 @@
 
 private:
     // private data should be here
+    size_t m_size; //size of array
+    Data* m_data; // pointer
 };
 
 #endif

my_name

@@ -0,0 +1 @@
+Романов Дмитрий Александрович 3092