Merge pull request #704 from sunlight28/main

Лабораторные 21-30 + 32

Author: Pastor

students/23K0087/23K0087-p21/pom.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>23K0087</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0087-p21</artifactId>
+    <description>Двадцать первое задание</description>
+</project>

students/23K0087/23K0087-p21/src/main/java/ru/mirea/practice/s23k0087/task1/ArrayToList.java

@@ -0,0 +1,21 @@
+package ru.mirea.practice.s23k0087.task1;
+
+import java.util.Arrays;
+import java.util.List;
+
+public abstract class ArrayToList {
+
+    public static <E> List<E> convertArrayToList(E[] array) {
+        return Arrays.asList(array);
+    }
+
+    public static void main(String[] args) {
+        String[] arrayStr = {"Прибыл", "Сатору", "Годжо"};
+        List<String> listStr = convertArrayToList(arrayStr);
+        System.out.println("List String: " + listStr);
+
+        Integer[] arrayInt = {2, 0, 3, 1};
+        List<Integer> listInt = convertArrayToList(arrayInt);
+        System.out.println("List Integer: " + listInt);
+    }
+}

students/23K0087/23K0087-p21/src/main/java/ru/mirea/practice/s23k0087/tasks2and3/GenericArr.java

@@ -0,0 +1,50 @@
+package ru.mirea.practice.s23k0087.tasks2and3;
+
+public class GenericArr<E> {
+    private final E[] array;
+
+    public GenericArr(E[] elements) {
+        this.array = elements;
+    }
+
+    public E get(int index) {
+
+        if (index >= 0 && index < array.length) {
+            return array[index];
+        } else {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + array.length);
+        }
+    }
+
+    public void set(int index, E element) {
+        if (index >= 0 && index < array.length) {
+            array[index] = element;
+        } else {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + array.length);
+        }
+    }
+
+    public E getElementByIndex(int index) {
+        if (index < 0 || index >= array.length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + array.length);
+        }
+        return array[index];
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("[");
+        for (int i = 0; i < array.length; i++) {
+            sb.append(array[i]);
+            if (i < array.length - 1) {
+                sb.append(", ");
+            }
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+    public int size() {
+        return array.length;
+    }
+}

students/23K0087/23K0087-p21/src/main/java/ru/mirea/practice/s23k0087/tasks2and3/Tester.java

@@ -0,0 +1,17 @@
+package ru.mirea.practice.s23k0087.tasks2and3;
+
+public abstract class Tester {
+    public static void main(String[] args) {
+        String[] arrayStr = {"Volkswagen", "Das", "Auto"};
+        GenericArr<String> stringGenericArr = new GenericArr<>(arrayStr);
+        System.out.println(stringGenericArr);
+
+        Long[] arrayLong = {2031L, 911922L, 1234567890L};
+        GenericArr<Long> longGenericArr = new GenericArr<>(arrayLong);
+        System.out.println(longGenericArr);
+
+        Double[] arrayDouble = {20.31, 0.19293912, 0.41413, 0.221};
+        GenericArr<Double> doubleGenericArr = new GenericArr<>(arrayDouble);
+        System.out.println(doubleGenericArr);
+    }
+}

students/23K0087/23K0087-p22/pom.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>23K0087</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0087-p22</artifactId>
+    <description>Двадцать второе задание</description>
+</project>

students/23K0087/23K0087-p22/src/main/java/ru/mirea/practice/s23k0087/task1/Calculator.java

@@ -0,0 +1,42 @@
+package ru.mirea.practice.s23k0087.task1;
+
+import java.util.Stack;
+
+public abstract class Calculator {
+    private static double applyOperation(double a, double b, String operator) {
+        switch (operator) {
+            case "+":
+                return a + b;
+            case "-":
+                return a - b;
+            case "*":
+                return a * b;
+            case "/":
+                if (b == 0) {
+                    throw new ArithmeticException("Деление на ноль");
+                }
+                return a / b;
+            default:
+                throw new IllegalArgumentException("Недопустимый оператор: " + operator);
+        }
+    }
+
+    private static boolean isOperator(String token) {
+        return "+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token);
+    }
+
+    public static double calculate(String expression) {
+        Stack<Double> stack = new Stack<>();
+        String[] tokens = expression.split("\\s+");
+        for (String token : tokens) {
+            if (isOperator(token)) {
+                double b = stack.pop();
+                double a = stack.pop();
+                stack.push(applyOperation(a, b, token));
+            } else {
+                stack.push(Double.parseDouble(token));
+            }
+        }
+        return stack.pop();
+    }
+}

students/23K0087/23K0087-p22/src/main/java/ru/mirea/practice/s23k0087/task1/Tester.java

@@ -0,0 +1,10 @@
+package ru.mirea.practice.s23k0087.task1;
+
+public abstract class Tester {
+    public static void main(String[] args) {
+        String expression = "4 8 - 2 / 7 *";
+        System.out.println("Calculating ((4 - 8) / 2) * 7");
+        double result = Calculator.calculate(expression);
+        System.out.println("Result: " + result);
+    }
+}

students/23K0087/23K0087-p23/pom.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>23K0087</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0087-p23</artifactId>
+    <description>Двадцать третье задание</description>
+</project>

students/23K0087/23K0087-p23/src/main/java/ru/mirea/practice/s23k0087/task1/ArrayQueue.java

@@ -0,0 +1,58 @@
+package ru.mirea.practice.s23k0087.task1;
+
+public final class ArrayQueue {
+
+    private Object[] queue = new Object[16];
+    private int head = 0;
+    private int tail = 0;
+    private int size = 0;
+
+    public static ArrayQueue createQueue() {
+        return new ArrayQueue();
+    }
+
+    public void enqueue(Object element) {
+        ensureCapacity(size + 1);
+        queue[tail] = element;
+        tail = (tail + 1) % queue.length;
+        size++;
+    }
+
+    public Object getFirstElement() {
+        return queue[head];
+    }
+
+    public Object dequeue() {
+        Object result;
+        result = queue[head];
+        queue[head] = null;
+        head = (head + 1) % queue.length;
+        size--;
+        return result;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public void clear() {
+        queue = new Object[16];
+        head = tail = size = 0;
+    }
+
+    private void ensureCapacity(int capacity) {
+        if (capacity > queue.length) {
+            Object[] newQueue = new Object[queue.length * 2];
+            for (int i = 0; i < size; i++) {
+                newQueue[i] = queue[(head + i) % queue.length];
+            }
+            queue = newQueue;
+            head = 0;
+            tail = size;
+        }
+    }
+}

students/23K0087/23K0087-p23/src/main/java/ru/mirea/practice/s23k0087/task1/ArrayQueueAdt.java

@@ -0,0 +1,54 @@
+package ru.mirea.practice.s23k0087.task1;
+
+public final class ArrayQueueAdt {
+
+    private Object[] queue = new Object[16];
+    private int head = 0;
+    private int tail = 0;
+    private int size = 0;
+
+    public static void enqueue(ArrayQueueAdt queueAdt, Object element) {
+        ensureCapacity(queueAdt, queueAdt.size + 1);
+        queueAdt.queue[queueAdt.tail] = element;
+        queueAdt.tail = (queueAdt.tail + 1) % queueAdt.queue.length;
+        queueAdt.size++;
+    }
+
+    public static Object getFirstElement(ArrayQueueAdt queueAdt) {
+        return queueAdt.queue[queueAdt.head];
+    }
+
+    public static Object dequeue(ArrayQueueAdt queueAdt) {
+        Object result;
+        result = queueAdt.queue[queueAdt.head];
+        queueAdt.queue[queueAdt.head] = null;
+        queueAdt.head = (queueAdt.head + 1) % queueAdt.queue.length;
+        queueAdt.size--;
+        return result;
+    }
+
+    public static int size(ArrayQueueAdt queueAdt) {
+        return queueAdt.size;
+    }
+
+    public static boolean isEmpty(ArrayQueueAdt queueAdt) {
+        return queueAdt.size == 0;
+    }
+
+    public static void clear(ArrayQueueAdt queueAdt) {
+        queueAdt.queue = new Object[16];
+        queueAdt.head = queueAdt.tail = queueAdt.size = 0;
+    }
+
+    private static void ensureCapacity(ArrayQueueAdt queueAdt, int capacity) {
+        if (capacity > queueAdt.queue.length) {
+            Object[] newQueue = new Object[queueAdt.queue.length * 2];
+            for (int i = 0; i < queueAdt.size; i++) {
+                newQueue[i] = queueAdt.queue[(queueAdt.head + i) % queueAdt.queue.length];
+            }
+            queueAdt.queue = newQueue;
+            queueAdt.head = 0;
+            queueAdt.tail = queueAdt.size;
+        }
+    }
+}