diff --git a/students/23K0690/23K0690-p21/pom.xml b/students/23K0690/23K0690-p21/pom.xml new file mode 100644 index 000000000..8b206bf61 --- /dev/null +++ b/students/23K0690/23K0690-p21/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p21 + 21 работа + diff --git a/students/23K0690/23K0690-p21/src/main/java/ru/mirea/practice/s23k0690/Task1.java b/students/23K0690/23K0690-p21/src/main/java/ru/mirea/practice/s23k0690/Task1.java new file mode 100644 index 000000000..d081524cc --- /dev/null +++ b/students/23K0690/23K0690-p21/src/main/java/ru/mirea/practice/s23k0690/Task1.java @@ -0,0 +1,30 @@ +package ru.mirea.practice.s23k0690; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public abstract class Task1 { + + public static List convertArrayToList(T[] array) { + return new ArrayList<>(Arrays.asList(array)); + } + + public static void main(String[] args) { + + String[] names = {"Сигарета", + "Пафнутий", + "Мемема"}; + List nameList = convertArrayToList(names); + System.out.println("Список Имена: " + nameList); + + Integer[] numbers = {1, + 35, + 228, + 93, + 1488}; + List numberList = convertArrayToList(numbers); + System.out.println("Список Числа: " + numberList); + + } +} diff --git a/students/23K0690/23K0690-p21/src/main/java/ru/mirea/practice/s23k0690/Task2.java b/students/23K0690/23K0690-p21/src/main/java/ru/mirea/practice/s23k0690/Task2.java new file mode 100644 index 000000000..1878b4bbf --- /dev/null +++ b/students/23K0690/23K0690-p21/src/main/java/ru/mirea/practice/s23k0690/Task2.java @@ -0,0 +1,62 @@ +package ru.mirea.practice.s23k0690; + +import java.util.Arrays; + +public class Task2 { + private T[] array; + private int size; + + @SuppressWarnings("unchecked") + public Task2(int capacity) { + array = (T[]) new Object[capacity]; + size = 0; + } + + public void add(T element) { + if (size >= array.length) { + resize(); + } + array[size++] = element; + } + + public T get(int index) { + if (index < 0 || index >= size) { + throw new IndexOutOfBoundsException("Вне диапазона: " + index); + } + return array[index]; + } + + public int size() { + return size; + } + + @SuppressWarnings("unchecked") + private void resize() { + T[] newArray = (T[]) new Object[array.length * 2]; + System.arraycopy(array, 0, newArray, 0, size); + array = newArray; + } + + @Override + public String toString() { + return Arrays.toString(Arrays.copyOf(array, size)); + } + + public static void main(String[] args) { + Task2 intArray = new Task2<>(5); + intArray.add(1); + intArray.add(2); + intArray.add(3); + System.out.println("Integer массив: " + intArray); + + Task2 stringArray = new Task2<>(5); + stringArray.add("Hello"); + stringArray.add("Сигарета!"); + System.out.println("String массив: " + stringArray); + + Task2 doubleArray = new Task2<>(5); + doubleArray.add(1.1); + doubleArray.add(2.2); + System.out.println("Double массив: " + doubleArray); + } +} diff --git a/students/23K0690/23K0690-p22/pom.xml b/students/23K0690/23K0690-p22/pom.xml new file mode 100644 index 000000000..2d4eb97d1 --- /dev/null +++ b/students/23K0690/23K0690-p22/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p22 + 22 работа + diff --git a/students/23K0690/23K0690-p22/src/main/java/ru/mirea/practice/s23k0690/Task1.java b/students/23K0690/23K0690-p22/src/main/java/ru/mirea/practice/s23k0690/Task1.java new file mode 100644 index 000000000..89e5f116e --- /dev/null +++ b/students/23K0690/23K0690-p22/src/main/java/ru/mirea/practice/s23k0690/Task1.java @@ -0,0 +1,72 @@ +package ru.mirea.practice.s23k0690; + +import java.util.Stack; + +public final class Task1 { + + private Task1() { + throw new UnsupportedOperationException("Utility class"); + } + + public static double evaluaterpn(String expression) throws Exception { + Stack stack = new Stack<>(); + String[] tokens = expression.split(" "); + + for (String token : tokens) { + if (isOperator(token)) { + if (stack.size() < 2) { + throw new Exception("Недостаточно операндов"); + } + double b = stack.pop(); + double a = stack.pop(); + double result = applyOperator(token, a, b); + stack.push(result); + } else { + try { + double number = Double.parseDouble(token); + stack.push(number); + } catch (NumberFormatException e) { + throw new Exception("Неверный формат числа: " + token, e); + } + } + } + + if (stack.size() != 1) { + throw new Exception("Некорректное выражение"); + } + + return stack.pop(); + } + + private static boolean isOperator(String token) { + return "+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token); + } + + private static double applyOperator(String operator, double a, double b) throws Exception { + switch (operator) { + case "+": + return a + b; + case "-": + return a - b; + case "*": + return a * b; + case "/": + if (b == 0) { + throw new Exception("Деление на ноль"); + } + return a / b; + default: + throw new Exception("Неверный оператор: " + operator); + } + } + + public static void main(String[] args) { + String expression = "3 4 + 2 * 7 /"; + try { + double result = evaluaterpn(expression); + System.out.println("Результат: " + result); + } catch (Exception e) { + System.out.println("Ошибка: " + e.getMessage()); + } + } +} diff --git a/students/23K0690/23K0690-p22/src/main/java/ru/mirea/practice/s23k0690/Task2.java b/students/23K0690/23K0690-p22/src/main/java/ru/mirea/practice/s23k0690/Task2.java new file mode 100644 index 000000000..fa6578517 --- /dev/null +++ b/students/23K0690/23K0690-p22/src/main/java/ru/mirea/practice/s23k0690/Task2.java @@ -0,0 +1,156 @@ +package ru.mirea.practice.s23k0690; + +import javax.swing.JButton; +import javax.swing.JFrame; +import javax.swing.JPanel; +import javax.swing.JTextField; +import javax.swing.WindowConstants; +import java.awt.BorderLayout; +import java.awt.GridLayout; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.util.Stack; + +public class Task2 extends JFrame { + private JTextField displayField; + + public Task2() { + setTitle("Калькулятор"); + setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); + setSize(500, 500); + + displayField = new JTextField(); + add(displayField, BorderLayout.NORTH); + + JPanel buttonPanel = new JPanel(); + buttonPanel.setLayout(new GridLayout(4, 4)); + + String[] buttonLabels = {"7", "8", "9", "/", "4", "5", "6", "*", "1", "2", "3", "-", "0", ".", "+", "="}; + for (String label : buttonLabels) { + JButton button = new JButton(label); + button.addActionListener(new ButtonClickHandler()); + buttonPanel.add(button); + } + + add(buttonPanel, BorderLayout.CENTER); + setVisible(true); + } + + private class ButtonClickHandler implements ActionListener { + @Override + public void actionPerformed(ActionEvent e) { + String command = e.getActionCommand(); + if ("=".equals(command)) { + try { + String expression = displayField.getText().replaceAll("\\s+", ""); + String postfixExpression = convertToPostfix(expression); + System.out.println("Постфиксное выражение: " + postfixExpression); + + double calculationResult = evaluatePostfix(postfixExpression); + displayField.setText(String.valueOf(calculationResult)); + } catch (Exception ex) { + displayField.setText("Ошибка"); + System.out.println("Ошибка: " + ex.getMessage()); + } + } else { + String currentText = displayField.getText(); + displayField.setText(currentText + " " + command); + } + } + } + + public static double evaluatePostfix(String expression) { + Stack numberStack = new Stack<>(); + String[] tokens = expression.trim().split(" "); + System.out.println("Токены: " + String.join(", ", tokens)); + + for (String token : tokens) { + if (isNumeric(token)) { + double number = Double.parseDouble(token); + numberStack.push(number); + } else { + if (numberStack.size() < 2) { + throw new IllegalArgumentException("Недостаточно операндов для операции"); + } + double secondOperand = numberStack.pop(); + double firstOperand = numberStack.pop(); + double operationResult = 0; + if ("+".equals(token)) { + operationResult = firstOperand + secondOperand; + } else if ("-".equals(token)) { + operationResult = firstOperand - secondOperand; + } else if ("*".equals(token)) { + operationResult = firstOperand * secondOperand; + } else if ("/".equals(token)) { + operationResult = firstOperand / secondOperand; + } else { + throw new IllegalArgumentException("Недопустимая операция: " + token); + } + numberStack.push(operationResult); + } + } + + if (numberStack.size() != 1) { + throw new IllegalArgumentException("Недопустимое выражение"); + } + return numberStack.pop(); + } + + private static boolean isNumeric(String str) { + try { + Double.parseDouble(str); + return true; + } catch (NumberFormatException e) { + return false; + } + } + + private String convertToPostfix(String expression) { + StringBuilder result = new StringBuilder(); + Stack operatorStack = new Stack<>(); + + for (int i = 0; i < expression.length(); i++) { + char character = expression.charAt(i); + + if (Character.isDigit(character)) { + result.append(character).append(" "); + } else if (character == '(') { + operatorStack.push(character); + } else if (character == ')') { + while (!operatorStack.isEmpty() && operatorStack.peek() != '(') { + result.append(operatorStack.pop()).append(" "); + } + operatorStack.pop(); + } else if (isOperator(character)) { + while (!operatorStack.isEmpty() && precedence(operatorStack.peek()) >= precedence(character)) { + result.append(operatorStack.pop()).append(" "); + } + operatorStack.push(character); + } + } + + while (!operatorStack.isEmpty()) { + result.append(operatorStack.pop()).append(" "); + } + + return result.toString().trim(); + } + + private boolean isOperator(char character) { + return character == '+' || character == '-' || character == '*' || character == '/'; + } + + private int precedence(char operator) { + if (operator == '+' || operator == '-') { + return 1; + } + if (operator == '*' || operator == '/') { + return 2; + } + return -1; + } + + public static void main(String[] args) { + new Task2(); + } +} diff --git a/students/23K0690/23K0690-p23/pom.xml b/students/23K0690/23K0690-p23/pom.xml new file mode 100644 index 000000000..6d6037ded --- /dev/null +++ b/students/23K0690/23K0690-p23/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p23 + 23 работа + diff --git a/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/AbstractQueue.java b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/AbstractQueue.java new file mode 100644 index 000000000..6ff55212a --- /dev/null +++ b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/AbstractQueue.java @@ -0,0 +1,20 @@ +package ru.mirea.practice.s23k0690; + +public abstract class AbstractQueue implements Queue { + protected int size; // Размер очереди + + @Override + public boolean isEmpty() { + return size == 0; + } + + @Override + public int size() { + return size; + } + + @Override + public void clear() { + size = 0; + } +} diff --git a/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/ArrayQueue.java b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/ArrayQueue.java new file mode 100644 index 000000000..487a0fbc4 --- /dev/null +++ b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/ArrayQueue.java @@ -0,0 +1,41 @@ +package ru.mirea.practice.s23k0690; + +public class ArrayQueue { + private Object[] elements; + private int head; + private int tail; + + public ArrayQueue(int capacity) { + elements = new Object[capacity]; + head = 0; + tail = 0; + } + + public void enqueue(Object element) { + elements[tail] = element; + tail = (tail + 1) % elements.length; + } + + public Object dequeue() { + Object element = elements[head]; + head = (head + 1) % elements.length; + return element; + } + + public Object element() { + return elements[head]; + } + + public int size() { + return (tail - head + elements.length) % elements.length; + } + + public boolean isEmpty() { + return head == tail; + } + + public void clear() { + head = 0; + tail = 0; + } +} diff --git a/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/ArrayQueueModule.java b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/ArrayQueueModule.java new file mode 100644 index 000000000..b1a6d629c --- /dev/null +++ b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/ArrayQueueModule.java @@ -0,0 +1,35 @@ +package ru.mirea.practice.s23k0690; + +abstract class ArrayQueueModule { + private static Object[] elements = new Object[10]; + private static int head = 0; + private static int tail = 0; + + public static void enqueue(Object element) { + elements[tail] = element; + tail = (tail + 1) % elements.length; + } + + public static Object dequeue() { + Object element = elements[head]; + head = (head + 1) % elements.length; + return element; + } + + public static Object element() { + return elements[head]; + } + + public static int size() { + return (tail - head + elements.length) % elements.length; + } + + public static boolean isEmpty() { + return head == tail; + } + + public static void clear() { + head = 0; + tail = 0; + } +} diff --git a/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/ArrayqueueAdt.java b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/ArrayqueueAdt.java new file mode 100644 index 000000000..280c4b96d --- /dev/null +++ b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/ArrayqueueAdt.java @@ -0,0 +1,41 @@ +package ru.mirea.practice.s23k0690; + +public class ArrayqueueAdt { + private Object[] elements; + private int head; + private int tail; + + public ArrayqueueAdt(int capacity) { + elements = new Object[capacity]; + head = 0; + tail = 0; + } + + public void enqueue(Object element) { + elements[tail] = element; + tail = (tail + 1) % elements.length; + } + + public Object dequeue() { + Object element = elements[head]; + head = (head + 1) % elements.length; + return element; + } + + public Object element() { + return elements[head]; + } + + public int size() { + return (tail - head + elements.length) % elements.length; + } + + public boolean isEmpty() { + return head == tail; + } + + public void clear() { + head = 0; + tail = 0; + } +} diff --git a/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/LinkedQueue.java b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/LinkedQueue.java new file mode 100644 index 000000000..25e6fdcd1 --- /dev/null +++ b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/LinkedQueue.java @@ -0,0 +1,56 @@ +package ru.mirea.practice.s23k0690; + +public class LinkedQueue extends AbstractQueue { + private static class Node { + E value; + Node next; + + Node(E value) { + this.value = value; + } + } + + private Node head; + private Node tail; + + public LinkedQueue() { + head = null; + tail = null; + size = 0; + } + + @Override + public void enqueue(E element) { + Node newNode = new Node<>(element); + if (tail != null) { + tail.next = newNode; + } + tail = newNode; + if (head == null) { + head = tail; + } + size++; + } + + @Override + public E dequeue() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + final E value = head.value; // Declare value as final here + head = head.next; + if (head == null) { + tail = null; + } + size--; + return value; + } + + @Override + public E element() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + return head.value; + } +} diff --git a/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/Queue.java b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/Queue.java new file mode 100644 index 000000000..ba4d3145c --- /dev/null +++ b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/Queue.java @@ -0,0 +1,16 @@ +package ru.mirea.practice.s23k0690; + +public interface Queue { + + void enqueue(E element); + + E dequeue(); + + E element(); + + int size(); + + boolean isEmpty(); + + void clear(); +} diff --git a/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/Task1.java b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/Task1.java new file mode 100644 index 000000000..98fc7867f --- /dev/null +++ b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/Task1.java @@ -0,0 +1,60 @@ +package ru.mirea.practice.s23k0690; + +public final class Task1 { + + private Task1() {} + + public static void main(String[] args) { + ArrayQueue queue = new ArrayQueue(10); + + if (queue.isEmpty()) { + System.out.println("Тест 1 пройден: Очередь пуста."); + } else { + System.out.println("Тест 1 не пройден: Очередь не пуста."); + } + + queue.enqueue(1); + queue.enqueue(2); + + if (queue.size() == 2) { + System.out.println("Тест 2 пройден: Размер очереди равен 2."); + } else { + System.out.println("Тест 2 не пройден: Размер очереди не равен 2."); + } + + if (queue.element().equals(1)) { + System.out.println("Тест 3 пройден: Первый элемент равен 1."); + } else { + System.out.println("Тест 3 не пройден: Первый элемент не равен 1."); + } + + if (queue.dequeue().equals(1)) { + System.out.println("Тест 4 пройден: Удаленный элемент равен 1."); + } else { + System.out.println("Тест 4 не пройден: Удаленный элемент не равен 1."); + } + + if (queue.size() == 1) { + System.out.println("Тест 5 пройден: Размер очереди равен 1 после удаления."); + } else { + System.out.println("Тест 5 не пройден: Размер очереди не равен 1 после удаления."); + } + + queue.clear(); + + if (queue.isEmpty()) { + System.out.println("Тест 6 пройден: Очередь пуста после очистки."); + } else { + System.out.println("Тест 6 не пройден: Очередь не пуста после очистки."); + } + } +} + + + + + + + + + diff --git a/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/Task2.java b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/Task2.java new file mode 100644 index 000000000..2d3c9a428 --- /dev/null +++ b/students/23K0690/23K0690-p23/src/main/java/ru/mirea/practice/s23k0690/Task2.java @@ -0,0 +1,30 @@ +package ru.mirea.practice.s23k0690; + + +public final class Task2 { + + private Task2() {} + + public static void main(String[] args) { + + LinkedQueue queue = new LinkedQueue<>(); + + System.out.println("Тест 1: Очередь пуста? " + (queue.isEmpty() ? "Да" : "Нет")); + + queue.enqueue(1); + queue.enqueue(2); + queue.enqueue(3); + System.out.println("Тест 2: Добавлено 3 элемента. Текущий размер очереди: " + queue.size()); + + System.out.println("Тест 3: Первый элемент очереди: " + queue.element()); + + System.out.println("Тест 4: Удаленный элемент: " + queue.dequeue()); + System.out.println("Текущий размер очереди после удаления: " + queue.size()); + + System.out.println("Тест 5: Очередь пуста? " + (queue.isEmpty() ? "Да" : "Нет")); + + queue.clear(); + System.out.println("Тест 6: Очередь очищена. Текущий размер очереди: " + queue.size()); + System.out.println("Тест 7: Очередь пуста? " + (queue.isEmpty() ? "Да" : "Нет")); + } +} diff --git a/students/23K0690/23K0690-p24/pom.xml b/students/23K0690/23K0690-p24/pom.xml new file mode 100644 index 000000000..0d7fb6fa2 --- /dev/null +++ b/students/23K0690/23K0690-p24/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p24 + 24 задание + diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Chair.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Chair.java new file mode 100644 index 000000000..866dc0f9c --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Chair.java @@ -0,0 +1,5 @@ +package ru.mirea.practice.s23k0690; + +interface Chair { + void sit(); +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/ChairFactory.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/ChairFactory.java new file mode 100644 index 000000000..f1136b2ec --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/ChairFactory.java @@ -0,0 +1,5 @@ +package ru.mirea.practice.s23k0690; + +abstract class ChairFactory { + public abstract Chair createChair(); +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Client.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Client.java new file mode 100644 index 000000000..38b0f6f06 --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Client.java @@ -0,0 +1,13 @@ +package ru.mirea.practice.s23k0690; + +class Client { + private Chair chair; + + public Client(ChairFactory factory) { + this.chair = factory.createChair(); + } + + public void sit() { + chair.sit(); + } +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Complex.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Complex.java new file mode 100644 index 000000000..5a7f83569 --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Complex.java @@ -0,0 +1,24 @@ +package ru.mirea.practice.s23k0690; + +public class Complex { + private int real; + private int imaginary; + + public Complex(int real, int imaginary) { + this.real = real; + this.imaginary = imaginary; + } + + public int getReal() { + return real; + } + + public int getImaginary() { + return imaginary; + } + + @Override + public String toString() { + return real + " + " + imaginary + "i"; + } +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/ComplexAbstractFactory.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/ComplexAbstractFactory.java new file mode 100644 index 000000000..a91edbde1 --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/ComplexAbstractFactory.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0690; + +public interface ComplexAbstractFactory { + + Complex createComplex(); + + Complex createComplex(int real, int imaginary); +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/ConcreteFactory.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/ConcreteFactory.java new file mode 100644 index 000000000..bcc1e1ee4 --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/ConcreteFactory.java @@ -0,0 +1,14 @@ +package ru.mirea.practice.s23k0690; + +public class ConcreteFactory implements ComplexAbstractFactory { + + @Override + public Complex createComplex() { + return new Complex(0, 0); + } + + @Override + public Complex createComplex(int real, int imaginary) { + return new Complex(real, imaginary); + } +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MagicalChair.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MagicalChair.java new file mode 100644 index 000000000..9bf6770e7 --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MagicalChair.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0690; + +class MagicalChair implements Chair { + @Override + public void sit() { + System.out.println("Сидите на магическом стуле."); + } +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MagicalChairFactory.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MagicalChairFactory.java new file mode 100644 index 000000000..5c6256ef5 --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MagicalChairFactory.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0690; + +class MagicalChairFactory extends ChairFactory { + @Override + public Chair createChair() { + return new MagicalChair(); + } +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MultifunctionalChair.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MultifunctionalChair.java new file mode 100644 index 000000000..f7feda88d --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MultifunctionalChair.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0690; + +class MultifunctionalChair implements Chair { + @Override + public void sit() { + System.out.println("Сидите на многофункциональном стуле."); + } +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MultifunctionalChairFactory.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MultifunctionalChairFactory.java new file mode 100644 index 000000000..688c8a144 --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/MultifunctionalChairFactory.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0690; + +class MultifunctionalChairFactory extends ChairFactory { + @Override + public Chair createChair() { + return new MultifunctionalChair(); + } +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Task1.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Task1.java new file mode 100644 index 000000000..89700c46d --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Task1.java @@ -0,0 +1,15 @@ +package ru.mirea.practice.s23k0690; + + +public abstract class Task1 { + public static void main(String[] args) { + ComplexAbstractFactory factory = new ConcreteFactory(); + + Complex defaultComplex = factory.createComplex(); + System.out.println("Def n: " + defaultComplex); + + Complex customComplex = factory.createComplex(2, 2); + System.out.println("Cut n: " + customComplex); + } +} + diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Task2.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Task2.java new file mode 100644 index 000000000..2db44193c --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/Task2.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0690; + +public final class Task2 { + + private Task2() {} + + public static void main(String[] args) { + ChairFactory victorianFactory = new VictorianChairFactory(); + Client client1 = new Client(victorianFactory); + client1.sit(); + ChairFactory multifunctionalFactory = new MultifunctionalChairFactory(); + Client client2 = new Client(multifunctionalFactory); + client2.sit(); + ChairFactory magicalFactory = new MagicalChairFactory(); + Client client3 = new Client(magicalFactory); + client3.sit(); + } +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/VictorianChair.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/VictorianChair.java new file mode 100644 index 000000000..e6d641087 --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/VictorianChair.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0690; + +class VictorianChair implements Chair { + @Override + public void sit() { + System.out.println("Сидите на викторианском стуле."); + } +} diff --git a/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/VictorianChairFactory.java b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/VictorianChairFactory.java new file mode 100644 index 000000000..670a33dc4 --- /dev/null +++ b/students/23K0690/23K0690-p24/src/main/java/ru/mirea/practice/s23k0690/VictorianChairFactory.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0690; + +class VictorianChairFactory extends ChairFactory { + @Override + public Chair createChair() { + return new VictorianChair(); + } +} diff --git a/students/23K0690/23K0690-p25/pom.xml b/students/23K0690/23K0690-p25/pom.xml new file mode 100644 index 000000000..2dc887bec --- /dev/null +++ b/students/23K0690/23K0690-p25/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p25 + 25 задание + diff --git a/students/23K0690/23K0690-p25/src/main/java/ru/mirea/practice/s23k0690/Task1.java b/students/23K0690/23K0690-p25/src/main/java/ru/mirea/practice/s23k0690/Task1.java new file mode 100644 index 000000000..8f83b587a --- /dev/null +++ b/students/23K0690/23K0690-p25/src/main/java/ru/mirea/practice/s23k0690/Task1.java @@ -0,0 +1,57 @@ +package ru.mirea.practice.s23k0690; + +import java.util.Scanner; +import java.util.regex.Pattern; + +public final class Task1 { + + private Task1() {} + + private String inputString; + + public void inputString() { + try (Scanner scanner = new Scanner(System.in)) { + System.out.print("Введите строку: "); + this.inputString = scanner.nextLine(); + } + } + + public String[] splitString(String regex) { + return inputString.split(regex); + } + + public void printElements(String[] elements) { + System.out.println("Разделенные элементы:"); + for (String element : elements) { + System.out.println(element); + } + } + + public void findMatches(String regex) { + Pattern pattern = Pattern.compile(regex); + String[] elements = splitString("\\s+"); + + System.out.println("Найденные совпадения:"); + for (String element : elements) { + if (pattern.matcher(element).matches()) { + System.out.println(element); + } + } + } + + public static void main(String[] args) { + Task1 stringManipulator = new Task1(); + + stringManipulator.inputString(); + + String[] elements = stringManipulator.splitString("\\s+"); + stringManipulator.printElements(elements); + + try (Scanner scanner = new Scanner(System.in)) { + System.out.print("Введите регулярное выражение для поиска совпадений: "); + String regex = scanner.nextLine(); + stringManipulator.findMatches(regex); + + } + } +} diff --git a/students/23K0690/23K0690-p25/src/main/java/ru/mirea/practice/s23k0690/Task4.java b/students/23K0690/23K0690-p25/src/main/java/ru/mirea/practice/s23k0690/Task4.java new file mode 100644 index 000000000..8c5abde55 --- /dev/null +++ b/students/23K0690/23K0690-p25/src/main/java/ru/mirea/practice/s23k0690/Task4.java @@ -0,0 +1,26 @@ +package ru.mirea.practice.s23k0690; + +import java.util.Scanner; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public final class Task4 { + + private Task4() {} + + public static void main(String[] args) { + try (Scanner scanner = new Scanner(System.in)) { + System.out.print("Введите текст: "); + String inputText = scanner.nextLine(); + String regex = "\\b\\d+\\b(?!\\s*\\+)"; + Pattern pattern = Pattern.compile(regex); + Matcher matcher = pattern.matcher(inputText); + if (matcher.find()) { + System.out.println("В тексте есть цифры, за которыми не стоит знак «+»."); + } else { + System.out.println("Все цифры в тексте корректны."); + } + + } + } +} diff --git a/students/23K0690/23K0690-p26/pom.xml b/students/23K0690/23K0690-p26/pom.xml new file mode 100644 index 000000000..8d58eb8ed --- /dev/null +++ b/students/23K0690/23K0690-p26/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p26 + 26 задание + diff --git a/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/MyArrayList.java b/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/MyArrayList.java new file mode 100644 index 000000000..e237e8b8d --- /dev/null +++ b/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/MyArrayList.java @@ -0,0 +1,43 @@ +package ru.mirea.practice.s23k0690; + +class MyArrayList implements MyList { + private Object[] elements; + private int size; + + public MyArrayList() { + elements = new Object[10]; + size = 0; + } + + @Override + public void add(T element) { + if (size >= elements.length) { + resize(); + } + elements[size++] = element; + } + + @Override + public T get(int index) { + if (index < 0 || index >= size) { + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); + } + return (T) elements[index]; + } + + @Override + public int size() { + return size; + } + + @Override + public MyListIterator iterator() { + return new MyListIterator<>(this); + } + + private void resize() { + Object[] newArray = new Object[elements.length * 2]; + System.arraycopy(elements, 0, newArray, 0, elements.length); + elements = newArray; + } +} diff --git a/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/MyList.java b/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/MyList.java new file mode 100644 index 000000000..1da9726d2 --- /dev/null +++ b/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/MyList.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0690; + +interface MyList { + + void add(T element); + + T get(int index); + + int size(); + + MyListIterator iterator(); +} diff --git a/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/MyListIterator.java b/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/MyListIterator.java new file mode 100644 index 000000000..b62f83f81 --- /dev/null +++ b/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/MyListIterator.java @@ -0,0 +1,24 @@ +package ru.mirea.practice.s23k0690; + +import java.util.NoSuchElementException; + +class MyListIterator { + private MyArrayList list; + private int currentIndex; + + public MyListIterator(MyArrayList list) { + this.list = list; + this.currentIndex = 0; + } + + public boolean hasNext() { + return currentIndex < list.size(); + } + + public T next() { + if (!hasNext()) { + throw new NoSuchElementException("No more elements in the list."); + } + return list.get(currentIndex++); + } +} diff --git a/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/Task1.java b/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/Task1.java new file mode 100644 index 000000000..7bbf624fd --- /dev/null +++ b/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/Task1.java @@ -0,0 +1,36 @@ +package ru.mirea.practice.s23k0690; + +import java.util.Stack; + +public final class Task1 { + + private Task1() {} + + public static int[] invertArray(int[] array) { + Stack stack = new Stack<>(); + + for (int num : array) { + stack.push(num); + } + + for (int i = 0; i < array.length; i++) { + array[i] = stack.pop(); + } + + return array; + } + + public static void main(String[] args) { + int[] originalArray = {1, 2, 3, 4, 5}; + System.out.println("Исходный массив:"); + for (int num : originalArray) { + System.out.print(num + " "); + } + + int[] invertedArray = invertArray(originalArray); + System.out.println("\nИнвертированный массив:"); + for (int num : invertedArray) { + System.out.print(num + " "); + } + } +} diff --git a/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/Task2.java b/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/Task2.java new file mode 100644 index 000000000..d9059e3a9 --- /dev/null +++ b/students/23K0690/23K0690-p26/src/main/java/ru/mirea/practice/s23k0690/Task2.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0690; + + +public final class Task2 { + + private Task2() {} + + public static void main(String[] args) { + MyArrayList myList = new MyArrayList<>(); + myList.add("Сигарета"); + myList.add("Банан"); + myList.add("Камень"); + MyListIterator iterator = myList.iterator(); + while (iterator.hasNext()) { + System.out.println(iterator.next()); + } + } +} diff --git a/students/23K0690/23K0690-p27/pom.xml b/students/23K0690/23K0690-p27/pom.xml new file mode 100644 index 000000000..dc359d1e8 --- /dev/null +++ b/students/23K0690/23K0690-p27/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p27 + 27 задание + diff --git a/students/23K0690/23K0690-p27/src/main/java/ru/mirea/practice/s23k0690/HashTable.java b/students/23K0690/23K0690-p27/src/main/java/ru/mirea/practice/s23k0690/HashTable.java new file mode 100644 index 000000000..33a0deab3 --- /dev/null +++ b/students/23K0690/23K0690-p27/src/main/java/ru/mirea/practice/s23k0690/HashTable.java @@ -0,0 +1,71 @@ +package ru.mirea.practice.s23k0690; + +import java.util.LinkedList; + +class HashTable { + private static class Entry { + String key; + String value; + + Entry(String key, String value) { + this.key = key; + this.value = value; + } + } + + private LinkedList[] table; + private int size; + + public void hashtabInit(int capacity) { + table = new LinkedList[capacity]; + for (int i = 0; i < capacity; i++) { + table[i] = new LinkedList<>(); + } + size = 0; + } + + private int hashtabHash(String key) { + return Math.abs(key.hashCode() % table.length); + } + + public void hashtabAdd(String key, String value) { + int index = hashtabHash(key); + for (Entry entry : table[index]) { + if (entry.key.equals(key)) { + entry.value = value; + return; + } + } + table[index].add(new Entry(key, value)); + size++; + } + + public String hashtabLookup(String key) { + int index = hashtabHash(key); + for (Entry entry : table[index]) { + if (entry.key.equals(key)) { + return entry.value; + } + } + return null; + } + + public void hashtabDelete(String key) { + int index = hashtabHash(key); + Entry toRemove = null; + for (Entry entry : table[index]) { + if (entry.key.equals(key)) { + toRemove = entry; + break; + } + } + if (toRemove != null) { + table[index].remove(toRemove); + size--; + } + } + + public int size() { + return size; + } +} diff --git a/students/23K0690/23K0690-p27/src/main/java/ru/mirea/practice/s23k0690/Task1and2.java b/students/23K0690/23K0690-p27/src/main/java/ru/mirea/practice/s23k0690/Task1and2.java new file mode 100644 index 000000000..75bfa5e45 --- /dev/null +++ b/students/23K0690/23K0690-p27/src/main/java/ru/mirea/practice/s23k0690/Task1and2.java @@ -0,0 +1,34 @@ +package ru.mirea.practice.s23k0690; + +public final class Task1and2 { + + private Task1and2() {} + + public static void main(String[] args) { + HashTable hashTable = new HashTable(); + hashTable.hashtabInit(10); + hashTable.hashtabAdd("key1", "value1"); + hashTable.hashtabAdd("key2", "value2"); + hashTable.hashtabAdd("key3", "value3"); + hashTable.hashtabAdd("key4", "value4"); + hashTable.hashtabAdd("key5", "value5"); + hashTable.hashtabAdd("key6", "value6"); + hashTable.hashtabAdd("key7", "value7"); + hashTable.hashtabAdd("key8", "value8"); + hashTable.hashtabAdd("key9", "value9"); + hashTable.hashtabAdd("key10", "value10"); + + System.out.println("Проверка добавленных элементов:"); + for (int i = 1; i <= 10; i++) { + String key = "key" + i; + System.out.println(key + " : " + hashTable.hashtabLookup(key)); + } + + System.out.println("\nУдаление key5..."); + hashTable.hashtabDelete("key5"); + + System.out.println("Проверка значения для key5 после удаления: " + hashTable.hashtabLookup("key5")); //должно вернуть null + + System.out.println("Текущий размер хеш-таблицы: " + hashTable.size()); + } +} diff --git a/students/23K0690/23K0690-p28/pom.xml b/students/23K0690/23K0690-p28/pom.xml new file mode 100644 index 000000000..7ff0733d0 --- /dev/null +++ b/students/23K0690/23K0690-p28/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p28 + 28 задание + diff --git a/students/23K0690/23K0690-p28/src/main/java/ru/mirea/practice/s23k0690/Main.java b/students/23K0690/23K0690-p28/src/main/java/ru/mirea/practice/s23k0690/Main.java new file mode 100644 index 000000000..e4323ce52 --- /dev/null +++ b/students/23K0690/23K0690-p28/src/main/java/ru/mirea/practice/s23k0690/Main.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0690; + +import java.util.HashSet; +import java.util.TreeSet; + +public final class Main { + + private Main() {} + + public static void main(String[] args) { + HashSet hashSet = new HashSet<>(); + hashSet.add("Сигарета"); + hashSet.add("Банан"); + hashSet.add("Камень"); + TreeSet treeSet = new TreeSet<>(hashSet); + System.out.println("TreeSet: " + treeSet); + } +} diff --git a/students/23K0690/23K0690-p29/pom.xml b/students/23K0690/23K0690-p29/pom.xml new file mode 100644 index 000000000..1b4f0f66e --- /dev/null +++ b/students/23K0690/23K0690-p29/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p29 + 29 задание + diff --git a/students/23K0690/23K0690-p29/src/main/java/ru/mirea/practice/s23k0690/Main.java b/students/23K0690/23K0690-p29/src/main/java/ru/mirea/practice/s23k0690/Main.java new file mode 100644 index 000000000..29aa2320c --- /dev/null +++ b/students/23K0690/23K0690-p29/src/main/java/ru/mirea/practice/s23k0690/Main.java @@ -0,0 +1,22 @@ +package ru.mirea.practice.s23k0690; + +import java.util.Scanner; + +public final class Main { + + private Main() {} + + public static void main(String[] args) { + try (Scanner con = new Scanner(System.in)) { + int n = con.nextInt(); + int res = 0; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + res += con.nextInt(); + } + } + res /= 2; + System.out.println(res); + } + } +} diff --git a/students/23K0690/23K0690-p30/pom.xml b/students/23K0690/23K0690-p30/pom.xml new file mode 100644 index 000000000..65dd159d4 --- /dev/null +++ b/students/23K0690/23K0690-p30/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p30 + 30 задание + diff --git a/students/23K0690/23K0690-p30/src/main/java/ru/mirea/practice/s23k0690/HuffmanNode.java b/students/23K0690/23K0690-p30/src/main/java/ru/mirea/practice/s23k0690/HuffmanNode.java new file mode 100644 index 000000000..17cb00c97 --- /dev/null +++ b/students/23K0690/23K0690-p30/src/main/java/ru/mirea/practice/s23k0690/HuffmanNode.java @@ -0,0 +1,14 @@ +package ru.mirea.practice.s23k0690; + +public class HuffmanNode { + char ch; + int frequency; + HuffmanNode left; + HuffmanNode right; + + public HuffmanNode(char ch, int frequency) { + this.ch = ch; + this.frequency = frequency; + this.left = this.right = null; + } +} diff --git a/students/23K0690/23K0690-p30/src/main/java/ru/mirea/practice/s23k0690/Task1.java b/students/23K0690/23K0690-p30/src/main/java/ru/mirea/practice/s23k0690/Task1.java new file mode 100644 index 000000000..cbb3845b5 --- /dev/null +++ b/students/23K0690/23K0690-p30/src/main/java/ru/mirea/practice/s23k0690/Task1.java @@ -0,0 +1,127 @@ +package ru.mirea.practice.s23k0690; + +public final class Task1 { + + static class TreeNode { + int value; + TreeNode leftChild; + TreeNode rightChild; + + public TreeNode(int value) { + this.value = value; + leftChild = rightChild = null; + } + } + + private TreeNode rootNode; + + public Task1() { + rootNode = null; + } + + public void addNode(int value) { + rootNode = addNodeRecursively(rootNode, value); + } + + private TreeNode addNodeRecursively(TreeNode rootNode, int value) { + if (rootNode == null) { + rootNode = new TreeNode(value); + return rootNode; + } + + if (value < rootNode.value) { + rootNode.leftChild = addNodeRecursively(rootNode.leftChild, value); + } else if (value > rootNode.value) { + rootNode.rightChild = addNodeRecursively(rootNode.rightChild, value); + } + + return rootNode; + } + + public boolean contains(int value) { + return containsRecursively(rootNode, value); + } + + private boolean containsRecursively(TreeNode rootNode, int value) { + if (rootNode == null) { + return false; + } + if (value == rootNode.value) { + return true; + } + if (value < rootNode.value) { + return containsRecursively(rootNode.leftChild, value); + } else { + return containsRecursively(rootNode.rightChild, value); + } + } + + public void removeNode(int value) { + rootNode = removeNodeRecursively(rootNode, value); + } + + private TreeNode removeNodeRecursively(TreeNode rootNode, int value) { + if (rootNode == null) { + return rootNode; + } + + if (value < rootNode.value) { + rootNode.leftChild = removeNodeRecursively(rootNode.leftChild, value); + } else if (value > rootNode.value) { + rootNode.rightChild = removeNodeRecursively(rootNode.rightChild, value); + } else { + if (rootNode.leftChild == null) { + return rootNode.rightChild; + } else if (rootNode.rightChild == null) { + return rootNode.leftChild; + } + + rootNode.value = findMinValue(rootNode.rightChild); + rootNode.rightChild = removeNodeRecursively(rootNode.rightChild, rootNode.value); + } + + return rootNode; + } + + private int findMinValue(TreeNode rootNode) { + int minValue = rootNode.value; + while (rootNode.leftChild != null) { + rootNode = rootNode.leftChild; + minValue = rootNode.value; + } + return minValue; + } + + public void printInOrder() { + printInOrderRecursively(rootNode); + } + + private void printInOrderRecursively(TreeNode rootNode) { + if (rootNode != null) { + printInOrderRecursively(rootNode.leftChild); + System.out.print(rootNode.value + " "); + printInOrderRecursively(rootNode.rightChild); + } + } + + public static void main(String[] args) { + Task1 tree = new Task1(); + tree.addNode(10); + tree.addNode(20); + tree.addNode(30); + tree.addNode(40); + tree.addNode(50); + tree.addNode(60); + tree.addNode(70); + tree.addNode(80); + tree.addNode(90); + tree.addNode(100); + System.out.println("В порядке возрастания:"); + tree.printInOrder(); + System.out.println("\nЕсть ли 10?: " + tree.contains(10)); + System.out.println("Есть ли 0?: " + tree.contains(0)); + tree.removeNode(100); + System.out.println("После удаления 100:"); + tree.printInOrder(); + } +} diff --git a/students/23K0690/23K0690-p30/src/main/java/ru/mirea/practice/s23k0690/Task2.java b/students/23K0690/23K0690-p30/src/main/java/ru/mirea/practice/s23k0690/Task2.java new file mode 100644 index 000000000..93a4e8cfc --- /dev/null +++ b/students/23K0690/23K0690-p30/src/main/java/ru/mirea/practice/s23k0690/Task2.java @@ -0,0 +1,71 @@ +package ru.mirea.practice.s23k0690; + +import java.util.PriorityQueue; +import java.util.HashMap; +import java.util.Map; + +public final class Task2 { + + private Task2() {} + + public static void buildHuffmanTree(String text) { + Map frequencyMap = new HashMap<>(); + for (char ch : text.toCharArray()) { + frequencyMap.put(ch, frequencyMap.getOrDefault(ch, 0) + 1); + } + PriorityQueue priorityQueue = new PriorityQueue<>( + (a, b) -> a.frequency - b.frequency + ); + + for (Map.Entry entry : frequencyMap.entrySet()) { + priorityQueue.offer(new HuffmanNode(entry.getKey(), entry.getValue())); + } + + while (priorityQueue.size() > 1) { + HuffmanNode left = priorityQueue.poll(); + HuffmanNode right = priorityQueue.poll(); + + assert right != null; + HuffmanNode newNode = new HuffmanNode('\0', left.frequency + right.frequency); + newNode.left = left; + newNode.right = right; + + priorityQueue.offer(newNode); + } + + HuffmanNode root = priorityQueue.poll(); + + Map huffmanCodeMap = new HashMap<>(); + generateHuffmanCodes(root, "", huffmanCodeMap); + + for (Map.Entry entry : huffmanCodeMap.entrySet()) { + System.out.println(entry.getKey() + ": " + entry.getValue()); + } + + StringBuilder compressedText = new StringBuilder(); + for (char ch : text.toCharArray()) { + compressedText.append(huffmanCodeMap.get(ch)); + } + + System.out.println("Сжатый текст: " + compressedText.toString()); + } + + private static void generateHuffmanCodes(HuffmanNode root, String code, Map huffmanCodeMap) { + if (root == null) { + return; + } + + if (root.left == null && root.right == null) { + huffmanCodeMap.put(root.ch, code); + } + + generateHuffmanCodes(root.left, code + "0", huffmanCodeMap); + generateHuffmanCodes(root.right, code + "1", huffmanCodeMap); + } + + public static void main(String[] args) { + String text = "Hello, world!"; + buildHuffmanTree(text); + } +} + diff --git a/students/23K0690/23K0690-p30p2/pom.xml b/students/23K0690/23K0690-p30p2/pom.xml new file mode 100644 index 000000000..5d10f5161 --- /dev/null +++ b/students/23K0690/23K0690-p30p2/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p30p2 + 30 задание 2 часть + diff --git a/students/23K0690/23K0690-p30p2/src/main/java/ru/mirea/practice/s23k0690/Task1.java b/students/23K0690/23K0690-p30p2/src/main/java/ru/mirea/practice/s23k0690/Task1.java new file mode 100644 index 000000000..256b35b55 --- /dev/null +++ b/students/23K0690/23K0690-p30p2/src/main/java/ru/mirea/practice/s23k0690/Task1.java @@ -0,0 +1,103 @@ +package ru.mirea.practice.s23k0690; + +public class Task1 { + + static class TreeNode { + int key; + + TreeNode leftChild; + + TreeNode rightChild; + + public TreeNode(int key) { + this.key = key; + leftChild = rightChild = null; + } + } + + private TreeNode root; + + public Task1() { + root = null; + } + + public void add(int key) { + root = addRecursively(root, key); + } + + private TreeNode addRecursively(TreeNode current, int key) { + if (current == null) { + return new TreeNode(key); + } + + if (key < current.key) { + current.leftChild = addRecursively(current.leftChild, key); + } else if (key > current.key) { + current.rightChild = addRecursively(current.rightChild, key); + } + return current; + } + + public void traverseInOrder() { + traverseInOrderRecursively(root); + } + + private void traverseInOrderRecursively(TreeNode current) { + if (current != null) { + traverseInOrderRecursively(current.leftChild); + System.out.print(current.key + " "); + traverseInOrderRecursively(current.rightChild); + } + } + + public void remove(int key) { + root = removeRecursively(root, key); + } + + private TreeNode removeRecursively(TreeNode current, int key) { + if (current == null) { + return current; + } + if (key < current.key) { + current.leftChild = removeRecursively(current.leftChild, key); + } else if (key > current.key) { + current.rightChild = removeRecursively(current.rightChild, key); + } else { + if (current.leftChild == null) { + return current.rightChild; + } else if (current.rightChild == null) { + return current.leftChild; + } + current.key = findMinValue(current.rightChild); + current.rightChild = removeRecursively(current.rightChild, current.key); + } + return current; + } + + private int findMinValue(TreeNode current) { + int minValue = current.key; + while (current.leftChild != null) { + minValue = current.leftChild.key; + current = current.leftChild; + } + return minValue; + } + + public void clear() { + root = null; + } + + public static void main(String[] args) { + Task1 tree = new Task1(); + int[] values = {10, 30, 20, 40, 60, 50, 80, 70, 90, 100}; + for (int value : values) { + tree.add(value); + } + tree.traverseInOrder(); + System.out.println(); + tree.remove(100); + tree.traverseInOrder(); + System.out.println(); + tree.clear(); + } +} diff --git a/students/23K0690/23K0690-p31/pom.xml b/students/23K0690/23K0690-p31/pom.xml new file mode 100644 index 000000000..5913b9f7d --- /dev/null +++ b/students/23K0690/23K0690-p31/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p31 + 31 задание + diff --git a/students/23K0690/23K0690-p31/src/main/java/ru/mirea/practice/s23k0690/Node.java b/students/23K0690/23K0690-p31/src/main/java/ru/mirea/practice/s23k0690/Node.java new file mode 100644 index 000000000..ba9a79feb --- /dev/null +++ b/students/23K0690/23K0690-p31/src/main/java/ru/mirea/practice/s23k0690/Node.java @@ -0,0 +1,15 @@ +package ru.mirea.practice.s23k0690; + +public class Node { + int value; + Node left; + Node middle; + Node right; + + public Node(int value) { + this.value = value; + this.left = null; + this.middle = null; + this.right = null; + } +} diff --git a/students/23K0690/23K0690-p31/src/main/java/ru/mirea/practice/s23k0690/Task1.java b/students/23K0690/23K0690-p31/src/main/java/ru/mirea/practice/s23k0690/Task1.java new file mode 100644 index 000000000..6d494e226 --- /dev/null +++ b/students/23K0690/23K0690-p31/src/main/java/ru/mirea/practice/s23k0690/Task1.java @@ -0,0 +1,33 @@ +package ru.mirea.practice.s23k0690; + +public final class Task1 { + + private Task1() {} + + public static void printTree(Node node, int level) { + if (node == null) { + return; + } + + printTree(node.left, level + 1); + printTree(node.middle, level + 1); + printTree(node.right, level + 1); + + System.out.println("Знач: " + node.value + ", Ур: " + level); + } + + public static void main(String[] args) { + final Node root = new Node(1); + final Node node2 = new Node(3); + final Node node3 = new Node(2); + final Node node4 = new Node(4); + final Node node5 = new Node(6); + final Node node6 = new Node(5); + root.left = node2; + root.middle = node3; + root.right = node4; + node2.left = node5; + node2.right = node6; + printTree(root, 0); + } +} diff --git a/students/23K0690/23K0690-p32/pom.xml b/students/23K0690/23K0690-p32/pom.xml new file mode 100644 index 000000000..af06adb3e --- /dev/null +++ b/students/23K0690/23K0690-p32/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0690 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0690-p32 + 32 задание + diff --git a/students/23K0690/23K0690-p32/src/main/java/ru/mirea/practice/s23k0690/Task1.java b/students/23K0690/23K0690-p32/src/main/java/ru/mirea/practice/s23k0690/Task1.java new file mode 100644 index 000000000..c857dad95 --- /dev/null +++ b/students/23K0690/23K0690-p32/src/main/java/ru/mirea/practice/s23k0690/Task1.java @@ -0,0 +1,63 @@ +package ru.mirea.practice.s23k0690; + +import java.util.Arrays; + +public final class Task1 { + + private Task1() {} + + public static void generatePermutations(int n) { + int[] pA = new int[n]; + int[] dA = new int[n]; + + for (int i = 0; i < n; i++) { + pA[i] = i + 1; + dA[i] = -1; + } + + printPermutation(pA); + + while (true) { + int max = -1; + int maxIdx = -1; + + for (int i = 0; i < n; i++) { + if (dA[i] == -1 && i > 0 && pA[i] > pA[i - 1] || dA[i] == 1 && i < n - 1 && pA[i] < pA[i + 1]) { + if (pA[i] > max) { + max = pA[i]; + maxIdx = i; + } + } + } + + if (max == -1) { + break; + } + + dA[maxIdx] = -dA[maxIdx]; + + if (dA[maxIdx] == -1 && maxIdx > 0) { + swap(pA, maxIdx, maxIdx - 1); + } else if (dA[maxIdx] == 1 && maxIdx < n - 1) { + swap(pA, maxIdx, maxIdx + 1); + } + + printPermutation(pA); + } + } + + private static void swap(int[] permutationArray, int i, int j) { + int temp = permutationArray[i]; + permutationArray[i] = permutationArray[j]; + permutationArray[j] = temp; + } + + private static void printPermutation(int[] permutationArray) { + System.out.println(Arrays.toString(permutationArray)); + } + + public static void main(String[] args) { + int n = 3; + generatePermutations(n); + } +} diff --git a/students/23K0690/pom.xml b/students/23K0690/pom.xml index fd813f76f..d4e8a0762 100644 --- a/students/23K0690/pom.xml +++ b/students/23K0690/pom.xml @@ -34,5 +34,18 @@ 23K0690-p18 23K0690-p19 23K0690-p20 + 23K0690-p21 + 23K0690-p22 + 23K0690-p23 + 23K0690-p24 + 23K0690-p25 + 23K0690-p26 + 23K0690-p27 + 23K0690-p28 + 23K0690-p29 + 23K0690-p30 + 23K0690-p30p2 + 23K0690-p31 + 23K0690-p32