lab 4

CMakeLists.txt

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

Lab2CPP/CMakeLists.txt

@@ -0,0 +1,5 @@
+#add_executable(Lab2CPP lab2.cpp)
+#target_include_directories(Lab2CPP PUBLIC ../LibraryCPP)
+#target_link_libraries(Lab2CPP LibraryCPP)
+
+#add_test(NAME TestLab2CPP COMMAND Lab2CPP ${CMAKE_CURRENT_SOURCE_DIR}/input.txt)

Lab2CPP/input.txt

@@ -0,0 +1,7 @@
+1+2*3-1
+(2+2)*3
+4+1-
+2*3+(4+4
+3/3*(2+5))+1
+4*2+1)
+)

Lab2CPP/lab2.cpp

@@ -0,0 +1,127 @@
+#include <iostream>
+#include <fstream>
+#include <stdexcept>
+#include "stack.h"  
+#include "vector.h" 
+#include <string>
+
+int precedence(char op) {
+    if (op == '+' || op == '-') return 1;
+    if (op == '*' || op == '/') return 2;
+    return 0;
+}
+
+int apply_operator(int a, int b, char op) {
+    switch (op) {
+    case '+': return a + b;
+    case '-': return a - b;
+    case '*': return a * b;
+    case '/':
+        if (b == 0) throw std::runtime_error("Division by zero");
+        return a / b;
+    default:
+        throw std::invalid_argument("Invalid operator");
+    }
+}
+
+int evaluate_example(const std::string& example) {
+    Stack* values = stack_create();
+    Stack* operators = stack_create();
+
+    for (size_t i = 0; i < example.length(); i++) {
+        if (example[i] == ' ') continue; 
+
+        if (isdigit(example[i])) {
+            int value = 0;
+            while (i < example.length() && isdigit(example[i])) {
+                value = value * 10 + (example[i] - '0');
+                i++;
+            }
+            i--;
+            stack_push(values, value);
+        }
+        else if (example[i] == '(') {
+            stack_push(operators, example[i]);
+        }
+        else if (example[i] == ')') {
+            while ( stack_get(operators) != '(') {
+
+                int val2 = stack_get(values);
+                stack_pop(values);
+
+
+                int val1 = stack_get(values);
+                stack_pop(values);
+
+
+                char op = (char)stack_get(operators);
+                stack_pop(operators);
+
+                stack_push(values, apply_operator(val1, val2, op));
+            }
+            if (!stack_empty(operators)) {
+                stack_pop(operators); 
+            }
+            else {
+                throw std::runtime_error("Mismatched parentheses: no matching '(' found");
+            }
+        }
+        else if (example[i] == '+' || example[i] == '-' || example[i] == '*' || example[i] == '/') {
+            while (!stack_empty(operators) && precedence((char)stack_get(operators)) >= precedence(example[i])) {
+
+                int val2 = stack_get(values);
+                stack_pop(values);
+
+                int val1 = stack_get(values);
+                stack_pop(values);
+
+
+                char op = (char)stack_get(operators);
+                stack_pop(operators);
+
+                stack_push(values, apply_operator(val1, val2, op));
+            }
+            stack_push(operators, example[i]);
+        }
+    }
+
+    while (!stack_empty(operators)) {
+
+        int val2 = stack_get(values);
+        stack_pop(values);
+
+
+        int val1 = stack_get(values);
+        stack_pop(values);
+
+
+        char op = (char)stack_get(operators);
+        stack_pop(operators);
+
+        stack_push(values, apply_operator(val1, val2, op));
+    }
+
+
+        int result = stack_get(values);
+        stack_delete(values);
+        stack_delete(operators);
+        return result;
+
+}
+
+int main() {
+    std::ifstream inputFile("input.txt");
+    std::string example;
+
+    while (std::getline(inputFile, example)) {
+        try {
+            int result = evaluate_example(example);
+            std::cout << "Result: " << result << std::endl;
+        }
+        catch (const std::exception& e) {
+            std::cerr << "Error: " << e.what() << std::endl;
+        }
+    }
+
+    return 0;
+}

Lab3CPP/CMakeLists.txt

@@ -0,0 +1,7 @@
+#file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/input.txt
+ #    DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+#add_executable(Lab3CPP lab3.cpp)
+#target_include_directories(Lab3CPP PUBLIC ../LibraryCPP)
+#target_link_libraries(Lab3CPP LibraryCPP)
+
+#add_test(NAME Test1Lab3CPP COMMAND Lab3CPP ${CMAKE_CURRENT_SOURCE_DIR}/input.txt)

Lab3CPP/input.txt

@@ -0,0 +1,5 @@
+######
+#...X#
+#.#.##
+#3.4.#
+######

Lab3CPP/lab3.cpp

@@ -0,0 +1,149 @@
+#include <iostream>
+#include <fstream>
+#include <stdexcept>
+#include <string>
+#include "queue.h"
+#include <vector>
+
+struct Point {
+    int x, y;
+};
+void Readout(std::ifstream& file, std::vector<char>& labyrinth, size_t* w, size_t* h);
+Point Start_search(size_t w, size_t h, const std::vector<char>& labyrinth);
+bool Range_and_Wall(int x, int y, size_t w, size_t h, const std::vector<char>& labyrinth, bool* flag_was_here);
+Point Number_closest_to_the_starting_position(const std::vector<char>& labyrinth, Point start, size_t w, size_t h);
+
+
+void Readout(std::ifstream& file, std::vector<char>& labyrinth, size_t* w, size_t* h) {
+    char simvol;
+    bool first = true;
+    int character_counter = 0;
+
+    while (file.read(&simvol, 1)) {
+        if (simvol != '\n') {
+            labyrinth.push_back(simvol);
+            character_counter++;
+        }
+        if (simvol == '\n') {
+            if (first) {
+                *w = character_counter;
+                first = false;
+            }
+            character_counter = 0; 
+        }
+    }
+    file.close();
+    if (*w == 0) {
+        throw std::runtime_error("The width of the maze is zero");
+
+    }
+    else {
+        *h = static_cast<int>(labyrinth.size() / *w);
+    }
+}
+
+
+
+
+Point Start_search(size_t w, size_t h, const std::vector<char>& labyrinth) {
+    for (size_t y = 0; y < h; y++) {
+        for (size_t x = 0; x < w; x++) {
+            if (labyrinth[y * w + x] == 'X') {
+                return {(int) x,(int) y };
+            }
+        }
+    }
+    return { -1, -1 };
+}
+
+
+bool Range_and_Wall(int x, int y, size_t w, size_t h, const std::vector<char>& labyrinth, bool* flag_was_here) {
+    if (x < 0 || y < 0 || (size_t)x >= w ||(size_t) y >= h) {
+        return false;
+    }
+    if (flag_was_here[y * w + x]) {
+        return false;
+    }
+    if (labyrinth[y * w + x] == '#') {
+        return false;
+    }
+
+    return true;
+}
+
+Point Number_closest_to_the_starting_position(const std::vector<char>& labyrinth, Point start, size_t w, size_t h) {
+    Queue* queue = queue_create();
+    bool* flag_was_here = new bool[w * h]();
+    Point four_directions[4] = { {1, 0}, {0, 1}, {-1, 0}, {0, -1} };
+    queue_insert(queue, Data(start.y * w + start.x)); 
+    flag_was_here[start.y * w + start.x] = true;
+
+    while (!queue_empty(queue)) {
+        int current = queue_get(queue);
+        queue_remove_one(queue);
+        int currentX = int(current % w);
+        int currentY = int(current / w);
+        char simvol = labyrinth[currentY * w + currentX];
+
+        if (simvol >= '0' && simvol <= '9') {
+            delete[]flag_was_here;
+            queue_delete(queue);
+            return { currentX, currentY };
+        }
+
+        for (int i = 0; i < 4; ++i) {
+            int newX = currentX + four_directions[i].x;
+            int newY = currentY + four_directions[i].y;
+            if (Range_and_Wall(newX, newY, w, h, labyrinth, flag_was_here)) {
+                flag_was_here[newY * w + newX] = true;
+                queue_insert(queue, Data(newY * w + newX));
+            }
+        }
+
+    }
+
+    queue_delete(queue);
+    delete[]flag_was_here;
+    return { -1, -1 };
+}
+
+
+int main(int argc, char** argv) {
+    std::vector<char> labyrinth;
+    std::string filepath = argv[1];
+    std::ifstream file(filepath);
+
+
+    if (!file)
+    {
+        std::cout << "the file did not open\n";
+        return 1;
+    }
+    try {
+        size_t w = 0, h = 0;
+        Readout(file, labyrinth, &w, &h);
+
+        Point start = Start_search(w, h, labyrinth);
+        if (start.x != -1) {
+            Point result = Number_closest_to_the_starting_position(labyrinth, start, w, h);
+            if (result.x != -1) {
+                std::cout << labyrinth[result.y * w + result.x] << std::endl;
+            }
+            else {
+                std::cout << "The endpoint was not found." << std::endl;
+            }
+        }
+        else {
+            std::cout << "The starting point was not found." << std::endl;
+        }
+
+    }
+    catch (const std::exception& e) {
+        std::cerr << "Error: " << e.what() << std::endl;
+        return 1;
+    }
+
+    return 0;
+}
+
+

Lab4CPP/CMakeLists.txt

@@ -0,0 +1,7 @@
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/input.txt
+ DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+add_executable(Lab4CPP lab4.cpp)
+include_directories(${CMAKE_SOURCE_DIR}/LibraryCPPTemplate)
+
+
+add_test(NAME Test1Lab4CPP COMMAND Lab4CPP ${CMAKE_CURRENT_SOURCE_DIR}/input.txt)