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

students/23K0186/23K0186-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>23K0186</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0186-p21</artifactId>
+    <description>21 практика</description>
+</project>

students/23K0186/23K0186-p21/src/main/java/ru/mirea/practice/s23k0186/Main.java

@@ -0,0 +1,12 @@
+package ru.mirea.practice.s23k0145;
+
+public final class Main {
+
+    private Main() {
+
+    }
+
+    public static void main(String[] args) {
+        System.out.println("двадцать первая практическая работа!");
+    }
+}

students/23K0186/23K0186-p21/src/main/java/ru/mirea/practice/s23k0186/lab1/ArrayToListConverter.java

@@ -0,0 +1,28 @@
+package ru.mirea.practice.s23k0145.lab1;
+
+import java.util.Arrays;
+import java.util.List;
+
+public abstract class ArrayToListConverter {
+
+    public static <T> List<T> toList(T[] array) {
+        if (array == null || array.length == 0) {
+            throw new IllegalArgumentException("Массив не должен быть пустым или null");
+        }
+        return Arrays.asList(array);
+    }
+
+    public static void main(String[] args) {
+        String[] fruits = {"слон", "мышь", "заяц"};
+        List<String> fruitList = toList(fruits);
+        System.out.println("Список фруктов: " + fruitList);
+
+        Double[] numbers = {1.1, 2.2, 3.3, 4.4};
+        List<Double> numberList = toList(numbers);
+        System.out.println("Список чисел: " + numberList);
+
+        Character[] letters = {'A', 'B', 'C'};
+        List<Character> letterList = toList(letters);
+        System.out.println("Список букв: " + letterList);
+    }
+}

students/23K0186/23K0186-p21/src/main/java/ru/mirea/practice/s23k0186/lab2/FlexibleArray.java

@@ -0,0 +1,57 @@
+package ru.mirea.practice.s23k0145.lab2;
+
+import java.util.Arrays;
+
+public class FlexibleArray<T> {
+    private Object[] data;
+    private int count;
+
+    public FlexibleArray(int initialCapacity) {
+        if (initialCapacity <= 0) {
+            throw new IllegalArgumentException("Начальный размер должен быть положительным");
+        }
+        data = new Object[initialCapacity];
+        count = 0;
+    }
+
+    public void add(T element) {
+        ensureCapacity();
+        data[count++] = element;
+    }
+
+    @SuppressWarnings("unchecked")
+    public T get(int index) {
+        if (index < 0 || index >= count) {
+            throw new IndexOutOfBoundsException("Индекс: " + index + ", Размер: " + count);
+        }
+        return (T) data[index];
+    }
+
+    public int size() {
+        return count;
+    }
+
+    private void ensureCapacity() {
+        if (count == data.length) {
+            data = Arrays.copyOf(data, data.length * 2);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.toString(Arrays.copyOf(data, count));
+    }
+
+    public static void main(String[] args) {
+        FlexibleArray<Object> array = new FlexibleArray<>(5);
+
+        array.add(42);
+        array.add(123456789L);
+        array.add("Привет");
+        array.add(3.1415);
+
+        System.out.println("Содержимое массива: " + array);
+        System.out.println("Элемент по индексу 1: " + array.get(1));
+        System.out.println("Размер массива: " + array.size());
+    }
+}

students/23K0186/23K0186-p21/src/main/java/ru/mirea/practice/s23k0186/lab3/ElementRetriever.java

@@ -0,0 +1,29 @@
+package ru.mirea.practice.s23k0145.lab3;
+
+import java.util.Objects;
+
+public abstract class ElementRetriever {
+
+    // Обобщенный метод для получения элемента массива
+    public static <T> T fetchElement(T[] array, int index) {
+        Objects.requireNonNull(array, "Массив не должен быть null");
+        if (index < 0 || index >= array.length) {
+            throw new IllegalArgumentException("Некорректный индекс: " + index);
+        }
+        return array[index];
+    }
+
+    public static void main(String[] args) {
+        // Пример с массивом строк
+        String[] fruits = {"яблоко", "банан", "вишня"};
+        System.out.println("Элемент на позиции 1: " + fetchElement(fruits, 1));
+
+        // Пример с массивом чисел
+        Integer[] numbers = {10, 20, 30, 40};
+        System.out.println("Элемент на позиции 2: " + fetchElement(numbers, 2));
+
+        // Пример с массивом символов
+        Character[] letters = {'A', 'B', 'C'};
+        System.out.println("Элемент на позиции 0: " + fetchElement(letters, 0));
+    }
+}

students/23K0186/23K0186-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>23K0186</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0186-p22</artifactId>
+    <description>22 практика</description>
+</project>

students/23K0186/23K0186-p22/src/main/java/ru/mirea/practice/s23k0186/Main.java

@@ -0,0 +1,12 @@
+package ru.mirea.practice.s23k0145;
+
+public final class Main {
+
+    private Main() {
+
+    }
+
+    public static void main(String[] args) {
+        System.out.println("двадцать вторая практическая работа!");
+    }
+}

students/23K0186/23K0186-p22/src/main/java/ru/mirea/practice/s23k0186/lab1/FactorialCalculator.java

@@ -0,0 +1,18 @@
+package ru.mirea.practice.s23k0145.lab1;
+
+public abstract class FactorialCalculator {
+    public static void main(String[] args) {
+        int number = 5;  // Пример числа для вычисления факториала
+        long factorial = calculateFactorial(number);
+        System.out.println("Факториал числа " + number + " = " + factorial);
+    }
+
+    // Метод для вычисления факториала с использованием цикла
+    public static long calculateFactorial(int num) {
+        long result = 1;
+        for (int i = 2; i <= num; i++) {
+            result *= i;
+        }
+        return result;
+    }
+}

students/23K0186/23K0186-p22/src/main/java/ru/mirea/practice/s23k0186/lab1/HarmonicSeries.java

@@ -0,0 +1,11 @@
+package ru.mirea.practice.s23k0145.lab1;
+
+public abstract class HarmonicSeries {
+    public static void main(String[] args) {
+        // Печать первых 10 чисел гармонического ряда
+        for (int i = 1; i <= 10; i++) {
+            double harmonicNumber = 1.0 / i;
+            System.out.printf("Гармоническое число(%d) = %.3f\n", i, harmonicNumber);
+        }
+    }
+}

students/23K0186/23K0186-p22/src/main/java/ru/mirea/practice/s23k0186/lab1/RpnCalculator.java

@@ -0,0 +1,82 @@
+package ru.mirea.practice.s23k0145.lab1;
+
+import java.util.Scanner;
+import java.util.Deque;
+import java.util.ArrayDeque;
+
+public final class RpnCalculator {
+
+    private RpnCalculator() {
+        throw new UnsupportedOperationException("Utility class");
+    }
+
+    public static void main(String[] args) {
+        try (Scanner scanner = new Scanner(System.in)) {
+            System.out.println("Введите выражение в обратной польской записи (например, '2 3 +'):");
+            String input = scanner.nextLine();
+
+            try {
+                double result = calculateRpn(input);
+                System.out.println("Результат: " + result);
+            } catch (Exception e) {
+                System.out.println("Ошибка: " + e.getMessage());
+            }
+        }
+    }
+
+    public static double calculateRpn(String expression) {
+        Deque<Double> stack = new ArrayDeque<>();
+        String[] tokens = expression.trim().split("\\s+");
+
+        for (String token : tokens) {
+            switch (token) {
+                case "+":
+                    checkStackSize(stack, 2);
+                    stack.push(stack.pop() + stack.pop());
+                    break;
+                case "-":
+                    checkStackSize(stack, 2);
+                    double b = stack.pop();
+                    double a = stack.pop();
+                    stack.push(a - b);
+                    break;
+                case "*":
+                    checkStackSize(stack, 2);
+                    stack.push(stack.pop() * stack.pop());
+                    break;
+                case "/":
+                    checkStackSize(stack, 2);
+                    double divisor = stack.pop();
+                    if (divisor == 0) {
+                        throw new ArithmeticException("Деление на ноль.");
+                    }
+                    double dividend = stack.pop();
+                    stack.push(dividend / divisor);
+                    break;
+                default:
+                    stack.push(parseNumber(token));
+                    break;
+            }
+        }
+
+        if (stack.size() != 1) {
+            throw new IllegalArgumentException("Некорректное выражение.");
+        }
+        return stack.pop();
+    }
+
+    private static double parseNumber(String token) {
+        try {
+            return Double.parseDouble(token);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Неверный ввод: '" + token + "'.", e);
+        }
+    }
+
+    private static void checkStackSize(Deque<Double> stack, int requiredSize) {
+        if (stack.size() < requiredSize) {
+            throw new IllegalArgumentException("Недостаточно операндов в стеке для выполнения операции.");
+        }
+    }
+}
+

students/23K0186/23K0186-p22/src/main/java/ru/mirea/practice/s23k0186/lab2/Main.java

@@ -0,0 +1,9 @@
+package ru.mirea.practice.s23k0145.lab2;
+
+public abstract class Main {
+    public static void main(String[] args) {
+        RpnCalculatorView view = new RpnCalculatorView();
+        RpnCalculatorModel model = new RpnCalculatorModel();
+        new RpnCalculatorController(view, model);
+    }
+}

students/23K0186/23K0186-p22/src/main/java/ru/mirea/practice/s23k0186/lab2/RpnCalculatorController.java

@@ -0,0 +1,47 @@
+package ru.mirea.practice.s23k0145.lab2;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class RpnCalculatorController {
+    private final RpnCalculatorView view;
+    private final RpnCalculatorModel model;
+
+    public RpnCalculatorController(RpnCalculatorView view, RpnCalculatorModel model) {
+        this.view = view;
+        this.model = model;
+        this.view.addButtonListener(new ButtonClickListener());
+    }
+
+    private class ButtonClickListener implements ActionListener {
+        public void actionPerformed(ActionEvent e) {
+            String command = e.getActionCommand();
+            if ("=".equals(command)) {
+                handleCalculation();
+            } else {
+                appendToInput(command);
+            }
+        }
+
+        private void handleCalculation() {
+            String input = view.getInput().trim();
+            if (input.isEmpty()) {
+                view.setResult("Ошибка: пустой ввод.");
+                return;
+            }
+            try {
+                double result = model.evaluateExpression(input);
+                view.updateHistory(input);
+                view.setResult("Результат: " + result);
+                view.clearInput();
+            } catch (Exception ex) {
+                view.setResult("Ошибка: " + ex.getMessage());
+            }
+        }
+
+        private void appendToInput(String command) {
+            String currentInput = view.getInput();
+            view.setInput(currentInput + (currentInput.isEmpty() ? "" : " ") + command);
+        }
+    }
+}

students/23K0186/23K0186-p22/src/main/java/ru/mirea/practice/s23k0186/lab2/RpnCalculatorModel.java

@@ -0,0 +1,52 @@
+package ru.mirea.practice.s23k0145.lab2;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class RpnCalculatorModel {
+
+    public double evaluateExpression(String expression) {
+        Deque<Double> stack = new ArrayDeque<>();
+        String[] tokens = expression.trim().split("\\s+");
+
+        for (String token : tokens) {
+            switch (token) {
+                case "+":
+                    stack.push(stack.pop() + stack.pop());
+                    break;
+                case "-":
+                    double b = stack.pop();
+                    double a = stack.pop();
+                    stack.push(a - b);
+                    break;
+                case "*":
+                    stack.push(stack.pop() * stack.pop());
+                    break;
+                case "/":
+                    double divisor = stack.pop();
+                    if (divisor == 0) {
+                        throw new ArithmeticException("Деление на ноль.");
+                    }
+                    double dividend = stack.pop();
+                    stack.push(dividend / divisor);
+                    break;
+                default:
+                    stack.push(parseNumber(token));
+                    break;
+            }
+        }
+
+        if (stack.size() != 1) {
+            throw new IllegalArgumentException("Некорректное выражение.");
+        }
+        return stack.pop();
+    }
+
+    private double parseNumber(String token) {
+        try {
+            return Double.parseDouble(token);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Неверный ввод: '" + token + "'.", e);
+        }
+    }
+}