Features/lab1

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

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         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>
+        <groupId>ru.mirea.practice</groupId>
+        <artifactId>23K0135</artifactId>
+        <version>2024.1</version>
+    </parent>
+
+    <artifactId>23K0135-p21</artifactId>
+</project>

students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task1/Task1.java

@@ -0,0 +1,14 @@
+package ru.mirea.practice.s23k0135.task1;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class Task1 {
+    public static <E> List<E> convertArrayToList(E[] elements) {
+        List<E> resultList = new ArrayList<>(elements.length);
+        for (E element : elements) {
+            resultList.add(element);
+        }
+        return resultList;
+    }
+}

students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task1/Test.java

@@ -0,0 +1,15 @@
+package ru.mirea.practice.s23k0135.task1;
+
+import java.util.List;
+
+import static ru.mirea.practice.s23k0135.task1.Task1.convertArrayToList;
+
+public abstract class Test {
+    public static void main(String[] args) {
+        Integer[] numbers = {5, 6, 8, 3, 2, 1};
+        List<Integer> numberList = convertArrayToList(numbers);
+        System.out.println(numberList);
+
+        Integer[] emptyArray = new Integer[15];
+    }
+}

students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task2and3/Task2and3.java

@@ -0,0 +1,26 @@
+package ru.mirea.practice.s23k0135.task2and3;
+
+import java.util.Arrays;
+
+public class Task2and3<T> {
+    private final T[] array;
+    private final int length;
+
+    Task2and3(T[] array) {
+        this.array = array;
+        this.length = array.length;
+    }
+
+    public T get(int index) {
+        return array[index];
+    }
+
+    public int getLength() {
+        return length;
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.toString(array);
+    }
+}

students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task2and3/Test.java

@@ -0,0 +1,9 @@
+package ru.mirea.practice.s23k0135.task2and3;
+
+public abstract class Test {
+    public static void main(String[] args) {
+        Integer[] arr = {5, 6, 8, 3, 2, 1};
+        Task2and3<Integer> array = new Task2and3<>(arr);
+        System.out.println(array);
+    }
+}

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

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         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>
+        <groupId>ru.mirea.practice</groupId>
+        <artifactId>23K0135</artifactId>
+        <version>2024.1</version>
+    </parent>
+
+    <artifactId>23K0135-p22</artifactId>
+
+</project>

students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/RpnCalculator.java

@@ -0,0 +1,61 @@
+package ru.mirea.practice.s23k0135;
+
+import java.util.StringTokenizer;
+
+public class RpnCalculator {
+    private Stack stack;
+
+    public RpnCalculator(int size) {
+        stack = new Stack(size);
+    }
+
+    public double evaluate(String expression) {
+        StringTokenizer tokenizer = new StringTokenizer(expression);
+
+        while (tokenizer.hasMoreTokens()) {
+            String token = tokenizer.nextToken();
+
+            if (isNumeric(token)) {
+                stack.push(Double.parseDouble(token));
+            } else {
+                performOperation(token);
+            }
+        }
+
+        return stack.pop();
+    }
+
+    private void performOperation(String operator) {
+        double secondOperand = stack.pop();
+        double firstOperand = stack.pop();
+
+        switch (operator) {
+            case "+":
+                stack.push(firstOperand + secondOperand);
+                break;
+            case "-":
+                stack.push(firstOperand - secondOperand);
+                break;
+            case "*":
+                stack.push(firstOperand * secondOperand);
+                break;
+            case "/":
+                if (secondOperand == 0) {
+                    throw new ArithmeticException("Ошибка: Деление на ноль");
+                }
+                stack.push(firstOperand / secondOperand);
+                break;
+            default:
+                throw new IllegalArgumentException("Недопустимый оператор: " + operator);
+        }
+    }
+
+    private boolean isNumeric(String str) {
+        try {
+            Double.parseDouble(str);
+            return true;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+}

students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/Stack.java

@@ -0,0 +1,40 @@
+package ru.mirea.practice.s23k0135;
+
+import java.util.EmptyStackException;
+
+public class Stack {
+    private int maxSize;
+    private double[] stackArray;
+    private int top;
+
+    public Stack(int size) {
+        this.maxSize = size;
+        this.stackArray = new double[maxSize];
+        this.top = -1;
+    }
+
+    public void push(double value) {
+        if (top >= maxSize - 1) {
+            throw new StackOverflowError("Стек переполнен");
+        }
+        stackArray[++top] = value;
+    }
+
+    public double pop() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        return stackArray[top--];
+    }
+
+    public double peek() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        return stackArray[top];
+    }
+
+    public boolean isEmpty() {
+        return top == -1;
+    }
+}

students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/Test.java

@@ -0,0 +1,33 @@
+package ru.mirea.practice.s23k0135;
+
+import java.util.EmptyStackException;
+
+public abstract class Test {
+    public static void main(String[] args) {
+        RpnCalculator calculator = new RpnCalculator(10);
+
+        System.out.println("7 3 + = " + calculator.evaluate("7 3 +"));
+        System.out.println("4 9 - = " + calculator.evaluate("4 9 -"));
+        System.out.println("6 8 * = " + calculator.evaluate("6 8 *"));
+        System.out.println("2 4 / = " + calculator.evaluate("2 4 /"));
+        System.out.println("9 2 + 3 * = " + calculator.evaluate("9 2 + 3 *"));
+
+        try {
+            System.out.println("10 0 / = " + calculator.evaluate("10 0 /"));
+        } catch (ArithmeticException e) {
+            System.out.println(e.getMessage());
+        }
+
+        try {
+            System.out.println("1 + = " + calculator.evaluate("1 +"));
+        } catch (EmptyStackException e) {
+            System.out.println("Невозможно убрать элемент в начале пустого стека");
+        }
+
+        try {
+            System.out.println("18 9 % = " + calculator.evaluate("18 9 %"));
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         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>
+        <groupId>ru.mirea.practice</groupId>
+        <artifactId>23K0135</artifactId>
+        <version>2024.1</version>
+    </parent>
+
+    <artifactId>23K0135-p23</artifactId>
+
+
+</project>

students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQue.java

@@ -0,0 +1,65 @@
+package ru.mirea.practice.s23k0135.task1;
+
+public class ArrQue {
+    private Object[] elements;
+    private int size;
+    private int head;
+    private int tail;
+
+    public ArrQue() {
+        elements = new Object[10];
+        size = 0;
+        head = 0;
+        tail = 0;
+    }
+
+    public void enqueue(Object element) {
+        assert element != null : "Element cannot be null";
+        ensureCapacity(size + 1);
+        elements[tail] = element;
+        tail = (tail + 1) % elements.length;
+        size++;
+    }
+
+    public Object element() {
+        assert size > 0 : "Queue is empty";
+        return elements[head];
+    }
+
+    public Object dequeue() {
+        assert size > 0 : "Queue is empty";
+        Object result = elements[head];
+        elements[head] = null;
+        head = (head + 1) % elements.length;
+        Object ans = result;
+        size--;
+        return ans;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public void clear() {
+        elements = new Object[10];
+        size = 0;
+        head = 0;
+        tail = 0;
+    }
+
+    private void ensureCapacity(int capacity) {
+        if (capacity > elements.length) {
+            Object[] newElements = new Object[2 * elements.length];
+            for (int i = 0; i < size; i++) {
+                newElements[i] = elements[(head + i) % elements.length];
+            }
+            elements = newElements;
+            head = 0;
+            tail = size;
+        }
+    }
+}

students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQueAdt.java

@@ -0,0 +1,65 @@
+package ru.mirea.practice.s23k0135.task1;
+
+public class ArrQueAdt {
+    private Object[] elements;
+    private int size;
+    private int head;
+    private int tail;
+
+    public ArrQueAdt() {
+        elements = new Object[10];
+        size = 0;
+        head = 0;
+        tail = 0;
+    }
+
+    public static void enqueue(ArrQueAdt queue, Object element) {
+        assert queue != null && element != null : "Queue or element is null";
+        ensureCapacity(queue, queue.size + 1);
+        queue.elements[queue.tail] = element;
+        queue.tail = (queue.tail + 1) % queue.elements.length;
+        queue.size++;
+    }
+
+    public static Object element(ArrQueAdt queue) {
+        assert queue != null && queue.size > 0 : "Queue is empty";
+        return queue.elements[queue.head];
+    }
+
+    public static Object dequeue(ArrQueAdt queue) {
+        assert queue != null && queue.size > 0 : "Queue is empty";
+        Object result = queue.elements[queue.head];
+        queue.elements[queue.head] = null;
+        queue.head = (queue.head + 1) % queue.elements.length;
+        Object ans = result;
+        queue.size--;
+        return ans;
+    }
+
+    public static int size(ArrQueAdt queue) {
+        return queue.size;
+    }
+
+    public static boolean isEmpty(ArrQueAdt queue) {
+        return queue.size == 0;
+    }
+
+    public static void clear(ArrQueAdt queue) {
+        queue.elements = new Object[10];
+        queue.size = 0;
+        queue.head = 0;
+        queue.tail = 0;
+    }
+
+    private static void ensureCapacity(ArrQueAdt queue, int capacity) {
+        if (capacity > queue.elements.length) {
+            Object[] newElements = new Object[2 * queue.elements.length];
+            for (int i = 0; i < queue.size; i++) {
+                newElements[i] = queue.elements[(queue.head + i) % queue.elements.length];
+            }
+            queue.elements = newElements;
+            queue.head = 0;
+            queue.tail = queue.size;
+        }
+    }
+}