Danilshilin2005 patch 3

task2/Шилин Задача 2

@@ -0,0 +1,141 @@
+#include "figures.hpp"
+#include <cmath>
+
+static constexpr double PI = 3.14;
+Rect::Rect(double a, double b) : width(a), height(b) {}
+
+FigureType Rect::Type() const {
+    return FigureType::RECTANGLE;
+}
+
+double Rect::Perimeter() const {
+    return 2 * (width + height);
+}
+
+double Rect::Area() const {
+    return width * height;
+}
+
+Triangle::Triangle(double side_a, double side_b, double side_c) 
+    : a(side_a), b(side_b), c(side_c) {}
+
+FigureType Triangle::Type() const {
+    return FigureType::TRIANGLE;
+}
+
+double Triangle::Perimeter() const {
+    return a + b + c;
+}
+
+double Triangle::Area() const {
+    double s = Perimeter() / 2;
+    return std::sqrt(s * (s - a) * (s - b) * (s - c));
+}
+
+Circle::Circle(double r) : radius(r) {}
+
+FigureType Circle::Type() const {
+    return FigureType::CIRCLE;
+}
+
+double Circle::Perimeter() const {
+    return 2 * PI * radius;
+}
+
+double Circle::Area() const {
+    return PI * radius * radius;
+}
+
+
+std::unique_ptr<Figure> make_figure(FigureType type, double a, double b, double c) {
+    if (a < 0 || b < 0 || c < 0) {
+        throw LessThanZeroParam("");
+    }
+
+    switch (type) {
+        case FigureType::RECTANGLE:
+            return std::make_unique<Rect>(a, b);
+
+        case FigureType::TRIANGLE:
+            if (a + b <= c || b + c <= a || a + c <= b) {
+                throw WrongTriangle("");
+            }
+            return std::make_unique<Triangle>(a, b, c);
+
+        case FigureType::CIRCLE:
+            return std::make_unique<Circle>(a);
+
+        default:
+            return nullptr;
+    }
+}
+
+#include <memory>
+#include <stdexcept>
+
+// Make PI accessible to tests and other code
+constexpr double PI = 3.14;
+
+enum class FigureType
+{
+    TRIANGLE,
+@@ -12,30 +15,59 @@ enum class FigureType
+
+class Figure {
+public:
+    virtual ~Figure() = default;  // Add virtual destructor for proper cleanup
+    virtual FigureType Type() const = 0;
+    virtual double Perimeter() const = 0;
+    virtual double Area() const = 0;
+};
+
+class Rect : public Figure
+{
+private:
+    double width;
+    double height;
+
+public:
+    Rect(double a, double b);
+    FigureType Type() const override;
+    double Perimeter() const override;
+    double Area() const override;
+};
+
+class Triangle : public Figure
+{
+private:
+    double a, b, c;
+
+public:
+    Triangle(double side_a, double side_b, double side_c);
+    FigureType Type() const override;
+    double Perimeter() const override;
+    double Area() const override;
+};
+
+class Circle : public Figure
+{
+private:
+    double radius;
+
+public:
+    Circle(double r);
+    FigureType Type() const override;
+    double Perimeter() const override;
+    double Area() const override;
+};
+
+std::unique_ptr<Figure> make_figure(FigureType type, double a, double b = 0, double c = 0);
+
+class WrongTriangle : public std::invalid_argument
+{
+public:
+    using std::invalid_argument::invalid_argument;
+};
+
+class LessThanZeroParam : public std::invalid_argument
+{
+public:
+    using std::invalid_argument::invalid_argument;
+};

task3/Шилин Данила Задача 3

@@ -0,0 +1,100 @@
+#include "circular_queue.hpp"
+#include <vector>
+
+CircularQueue::CircularQueue(size_t size)
+{
+	// your implementation here
+CircularQueue::CircularQueue(size_t size) : capacity(size), size(0), front(0), rear(0) {
+ buffer.resize(size); // Pre-allocate exact size
+}
+
+bool CircularQueue::Push(int value)
+{
+    // your implementation here
+bool CircularQueue::Push(int value) {
+    if (Full()) {
+        return false;
+    }
+ buffer[rear] = value;
+ rear = (rear + 1) % capacity;
+ size++;
+    return true;
+}
+
+bool CircularQueue::Pop()
+{
+    // your implementation here
+bool CircularQueue::Pop() {
+    if (Empty()) {
+        return false;
+    }
+ front = (front + 1) % capacity;
+ size--;
+    return true;
+}
+
+int CircularQueue::Front() const
+{
+    // your implementation here
+int CircularQueue::Front() const {
+    if (Empty()) {
+        return -1;
+    }
+    return buffer[front];
+}
+
+int CircularQueue::Back() const
+{
+    // your implementation here
+int CircularQueue::Back() const {
+    if (Empty()) {
+        return -1;
+    }
+    return buffer[(rear - 1 + capacity) % capacity];
+}
+
+bool CircularQueue::Empty() const
+{
+    // your implementation here
+bool CircularQueue::Empty() const {
+    return size == 0;
+}
+
+bool CircularQueue::Full() const
+{
+    // your implementation here
+bool CircularQueue::Full() const {
+    return size == capacity;
+}
+
+#pragma once
+
+#include <cstddef>
+#include <vector>
+
+class CircularQueue {
+private:
+ std::vector<int> buffer; // Dynamic array to store elements
+    size_t capacity; // Maximum size of the queue
+    size_t size; // Current count of elements
+    size_t front; // Index of the front element
+    size_t rear; // Index of the rear element
+
+public:
+    CircularQueue(size_t size); // создать очередь с определенным размером буффера
+    bool Push(int value); // добавить значение в конец очереди (false, если очередь заполнена)
+    bool Pop(); // удалить значение из начала очереди (false, если очередь пустая)
+    int Front() const; // получить значение из начала очереди (-1, если очередь пустая)
+    int Back() const; // получить значение из конца очереди (-1, если очередь пустая)
+    bool Empty() const; // проверить пустая ли очередь
+    bool Full() const; // проверить заполнена ли очередь
+    CircularQueue(size_t size); // Constructor
+
+    bool Push(int value); // Add value to the end
+    bool Pop(); // Remove value from the front
+    int Front() const; // Get front value
+    int Back() const; // Get back value
+
+    bool Empty() const; // Check if empty
+    bool Full() const; // Check if full
+};