diff --git a/pom.xml b/pom.xml index 1b510e5a0..3abccea2f 100644 --- a/pom.xml +++ b/pom.xml @@ -81,7 +81,6 @@ students/23K0186 students/23K0755 students/23K1292 - diff --git a/students/23K0368/23K0368-p21/pom.xml b/students/23K0368/23K0368-p21/pom.xml new file mode 100644 index 000000000..fab73ab0e --- /dev/null +++ b/students/23K0368/23K0368-p21/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p21 + Стирание типов в Java + diff --git a/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog1/Main.java b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog1/Main.java new file mode 100644 index 000000000..ebe2b927a --- /dev/null +++ b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog1/Main.java @@ -0,0 +1,26 @@ +package ru.mirea.practice.s0000001.prog1; + +import java.util.Arrays; +import java.util.List; + +public abstract class Main { + public static List convertArrayToList(String[] array) { + return Arrays.asList(array); + } + + // Метод для конвертации массива чисел в список + public static List convertArrayToList(Integer[] array) { + return Arrays.asList(array); + } + + public static void main(String[] args) { + String[] stringArray = {"apple", "banana", "cherry"}; + Integer[] intArray = {1, 2, 3, 4, 5}; + + List stringList = convertArrayToList(stringArray); + List intList = convertArrayToList(intArray); + + System.out.println("Список строк: " + stringList); + System.out.println("Список чисел: " + intList); + } +} diff --git a/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog2/AllType.java b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog2/AllType.java new file mode 100644 index 000000000..e81fc67a0 --- /dev/null +++ b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog2/AllType.java @@ -0,0 +1,16 @@ +package ru.mirea.practice.s0000001.prog2; + +import java.util.Arrays; + +public class AllType { + private final Object[] array; + + public AllType(Object[] array) { + this.array = array; + } + + @Override + public String toString() { + return Arrays.toString(array); + } +} diff --git a/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog2/Main.java b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog2/Main.java new file mode 100644 index 000000000..143fe18d5 --- /dev/null +++ b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog2/Main.java @@ -0,0 +1,9 @@ +package ru.mirea.practice.s0000001.prog2; + +public abstract class Main { + public static void main(String[] args) { + Integer[] mas1 = {1, 2, 3, 4}; + AllType intmas1 = new AllType(mas1); + System.out.println("Integer array: " + intmas1); + } +} diff --git a/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog3/AllType.java b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog3/AllType.java new file mode 100644 index 000000000..f426d416f --- /dev/null +++ b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog3/AllType.java @@ -0,0 +1,24 @@ +package ru.mirea.practice.s0000001.prog3; + +import java.util.Arrays; + +public class AllType { + private T[] array; + + public AllType(T[] array) { + this.array = array; + } + + public T getElement(int index) { + if (index >= 0 && index < array.length) { + return array[index]; + } else { + throw new IndexOutOfBoundsException("Index is out of bounds"); + } + } + + @Override + public String toString() { + return Arrays.toString(array); + } +} diff --git a/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog3/Main.java b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog3/Main.java new file mode 100644 index 000000000..5eccd762f --- /dev/null +++ b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog3/Main.java @@ -0,0 +1,11 @@ +package ru.mirea.practice.s0000001.prog3; + +public abstract class Main { + public static void main(String[] args) { + AllType intAllType = new AllType<>(new Integer[]{1, 2, 3, 4, 5}); + System.out.println("Integer array: " + intAllType); + + AllType stringAllType = new AllType<>(new String[]{"apple", "banana", "cherry"}); + System.out.println("String array: " + stringAllType); + } +} diff --git a/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog4/AllType.java b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog4/AllType.java new file mode 100644 index 000000000..dabbcf348 --- /dev/null +++ b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog4/AllType.java @@ -0,0 +1,28 @@ +package ru.mirea.practice.s0000001.prog4; + +import java.util.Arrays; + +public class AllType { + private T[] array; + + public AllType(T[] array) { + this.array = array; + } + + public T getElement(int index) { + if (index >= 0 && index < array.length) { + return array[index]; + } else { + throw new IndexOutOfBoundsException("Index is out of bounds"); + } + } + + public int getLength() { + return array.length; + } + + @Override + public String toString() { + return Arrays.toString(array); + } +} diff --git a/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog4/Main.java b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog4/Main.java new file mode 100644 index 000000000..fc98281d5 --- /dev/null +++ b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog4/Main.java @@ -0,0 +1,44 @@ +package ru.mirea.practice.s0000001.prog4; + +import java.io.File; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public abstract class Main { + public static List getDirectoryContents(String directorypath) { + File directory = new File(directorypath); + List contents = new ArrayList<>(); + + if (directory.isDirectory()) { + File[] files = directory.listFiles(); + if (files != null) { + contents.addAll(Arrays.asList(files)); + } + } else { + System.out.println("Указанный путь ошибочен"); + throw new IllegalStateException("Invalid"); + } + + return contents; + } + + public static void print(AllType list) { + System.out.println("Первые 5 элементов содержимого каталога:"); + for (int i = 0; i < Math.min(5, list.getLength()); i++) { + System.out.println((i + 1) + ". " + list.getElement(i)); + } + } + + public static void main(String[] args) { + String path = "Path"; + try { + List content = getDirectoryContents(path); + + AllType directoryContents = new AllType<>(content.toArray()); + print(directoryContents); + } catch (IllegalStateException e) { + System.out.println("Ошибка: " + e.getMessage()); + } + } +} diff --git a/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog5/Main.java b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog5/Main.java new file mode 100644 index 000000000..0c0b81393 --- /dev/null +++ b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog5/Main.java @@ -0,0 +1,23 @@ +package ru.mirea.practice.s0000001.prog5; + +import java.util.List; +import java.util.Map; +import java.util.Set; + +public abstract class Main { + public static void main(String[] args) { + List list = Solution.newArrayList(1, 2, 3, 4); + System.out.println("Integer elements(ArrayList)" + list); + + Set set = Solution.newHashSet("T90", "T80", "T54", "T72Б3"); + System.out.println("String elements(HashSet)" + set); + + Map map = Solution.newHashMap( + new Pair<>("T90", 90), + new Pair<>("T80", 80), + new Pair<>("T54", 54), + new Pair<>("T72Б3", 72) + ); + System.out.println("Map" + map); + } +} diff --git a/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog5/Pair.java b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog5/Pair.java new file mode 100644 index 000000000..6966c2795 --- /dev/null +++ b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog5/Pair.java @@ -0,0 +1,20 @@ +package ru.mirea.practice.s0000001.prog5; + +public class Pair { + private K k; + private V v; + + public Pair(K k, V v) { + this.k = k; + this.v = v; + } + + public K getK() { + return k; + } + + public V getV() { + return v; + } + +} diff --git a/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog5/Solution.java b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog5/Solution.java new file mode 100644 index 000000000..f12b67a52 --- /dev/null +++ b/students/23K0368/23K0368-p21/src/main/java/ru/mirea/practice/s0000001/prog5/Solution.java @@ -0,0 +1,35 @@ +package ru.mirea.practice.s0000001.prog5; + +import java.util.Map; +import java.util.HashMap; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +public abstract class Solution { + public static List newArrayList(T... elements) { + List list = new ArrayList<>(); + for (T element : elements) { + list.add(element); + } + return list; + } + + public static Set newHashSet(T... elements) { + Set set = new HashSet<>(); + for (T element : elements) { + set.add(element); + } + return set; + } + + public static Map newHashMap(Pair... entries) { + Map map = new HashMap<>(); + for (Pair entry : entries) { + map.put(entry.getK(), entry.getV()); + } + return map; + } + +} diff --git a/students/23K0368/23K0368-p22/pom.xml b/students/23K0368/23K0368-p22/pom.xml new file mode 100644 index 000000000..e757e94e9 --- /dev/null +++ b/students/23K0368/23K0368-p22/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p22 + Абстрактные типы данных. Стек + diff --git a/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/Main.java b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/Main.java new file mode 100644 index 000000000..b44850654 --- /dev/null +++ b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/Main.java @@ -0,0 +1,51 @@ +package ru.mirea.practice.s23k0368; + +import java.util.Stack; + +public abstract class Main { + public static double evaluateRpn(String expression) { + Stack stack = new Stack<>(); + String[] tokens = expression.split("\\s+"); // Разделяем выражение по пробелам + + for (String token : tokens) { + switch (token) { + case "+": + stack.push(stack.pop() + stack.pop()); + break; + case "-": + double subtrahend = stack.pop(); + stack.push(stack.pop() - subtrahend); + break; + case "*": + stack.push(stack.pop() * stack.pop()); + break; + case "/": + double divisor = stack.pop(); + if (divisor == 0) { + throw new ArithmeticException("Деление на ноль."); + } + stack.push(stack.pop() / divisor); + break; + default: + stack.push(Double.parseDouble(token)); + break; + } + } + + if (stack.size() != 1) { + throw new IllegalArgumentException("Некорректное выражение."); + } + + return stack.pop(); + } + + 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/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/CalculatorController.java b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/CalculatorController.java new file mode 100644 index 000000000..333de62dd --- /dev/null +++ b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/CalculatorController.java @@ -0,0 +1,22 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; + +// Controller +class CalculatorController implements ActionListener { + private CalculatorView view; + private CalculatorModel model; + + public CalculatorController(CalculatorView view, CalculatorModel model) { + this.view = view; + this.model = model; + } + + @Override + public void actionPerformed(ActionEvent e) { + String expression = view.getInputExpression(); + String result = model.evaluateRpn(expression); + view.setResult(result); + } +} diff --git a/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/CalculatorModel.java b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/CalculatorModel.java new file mode 100644 index 000000000..8bfb5214b --- /dev/null +++ b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/CalculatorModel.java @@ -0,0 +1,44 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.util.Stack; + +// Model +class CalculatorModel { + public String evaluateRpn(String expression) { + Stack stack = new Stack<>(); + String[] tokens = expression.split("\\s+"); + + try { + for (String token : tokens) { + switch (token) { + case "+": + stack.push(stack.pop() + stack.pop()); + break; + case "-": + double subtrahend = stack.pop(); + stack.push(stack.pop() - subtrahend); + break; + case "*": + stack.push(stack.pop() * stack.pop()); + break; + case "/": + double divisor = stack.pop(); + if (divisor == 0) { + return "Ошибка: деление на ноль."; + } + stack.push(stack.pop() / divisor); + break; + default: + stack.push(Double.parseDouble(token)); + break; + } + } + if (stack.size() != 1) { + return "Ошибка: неверное выражение."; + } + return "Результат: " + stack.pop(); + } catch (Exception e) { + return "Ошибка: неверное выражение или операция для пустого стека."; + } + } +} diff --git a/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/CalculatorView.java b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/CalculatorView.java new file mode 100644 index 000000000..16a83782f --- /dev/null +++ b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/CalculatorView.java @@ -0,0 +1,52 @@ +package ru.mirea.practice.s23k0368.prog2; + +import javax.swing.JFrame; +import javax.swing.JTextField; +import javax.swing.JTextArea; +import javax.swing.JButton; +import javax.swing.JPanel; +import javax.swing.JLabel; +import javax.swing.JScrollPane; +import java.awt.BorderLayout; + +// View +class CalculatorView { + private JTextField inputField; + private JTextArea resultArea; + @SuppressWarnings("PMD.SingularField") + private JButton calculateButton; + + + public CalculatorView() { + inputField = new JTextField(20); + resultArea = new JTextArea(5, 20); + resultArea.setEditable(false); + calculateButton = new JButton("Вычислить"); + + JFrame frame = new JFrame("RPN Calculator"); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + + JPanel panel = new JPanel(); + panel.setLayout(new BorderLayout()); + panel.add(new JLabel("Введите выражение в ОПН:"), BorderLayout.NORTH); + panel.add(inputField, BorderLayout.CENTER); + panel.add(calculateButton, BorderLayout.EAST); + panel.add(new JScrollPane(resultArea), BorderLayout.SOUTH); + + frame.getContentPane().add(panel); + frame.pack(); + frame.setLocationRelativeTo(null); + frame.setVisible(true); + + CalculatorController controller = new CalculatorController(this, new CalculatorModel()); // Создаём controller локально + calculateButton.addActionListener(controller); + } + + public String getInputExpression() { + return inputField.getText(); + } + + public void setResult(String result) { + resultArea.setText(result); + } +} diff --git a/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java new file mode 100644 index 000000000..4a02c34d7 --- /dev/null +++ b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java @@ -0,0 +1,9 @@ +package ru.mirea.practice.s23k0368.prog2; + +import javax.swing.SwingUtilities; + +public abstract class Main { + public static void main(String[] args) { + SwingUtilities.invokeLater(CalculatorView::new); + } +} diff --git a/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/Tests.java b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/Tests.java new file mode 100644 index 000000000..d155aaaee --- /dev/null +++ b/students/23K0368/23K0368-p22/src/main/java/ru/mirea/practice/s23k0368/prog2/Tests.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0368.prog2; + +public abstract class Tests { + public static void main(String[] args) { + CalculatorModel model = new CalculatorModel(); + + assert "Результат: 7.0".equals(model.evaluateRpn("3 4 +")); + assert "Результат: 14.0".equals(model.evaluateRpn("5 1 2 + 4 * + 3 -")); + + assert "Ошибка: неверное выражение.".equals(model.evaluateRpn("3 +")); + + assert "Ошибка: деление на ноль.".equals(model.evaluateRpn("4 0 /")); + + assert "Ошибка: неверное выражение или операция для пустого стека.".equals(model.evaluateRpn("1 2 + *")); + + System.out.println("Все тесты пройдены."); + } +} diff --git a/students/23K0368/23K0368-p23/pom.xml b/students/23K0368/23K0368-p23/pom.xml new file mode 100644 index 000000000..fb1959db3 --- /dev/null +++ b/students/23K0368/23K0368-p23/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p23 + Абстрактные типы данных. Очередь + diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/ArrayQueue.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/ArrayQueue.java new file mode 100644 index 000000000..6bd596119 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/ArrayQueue.java @@ -0,0 +1,66 @@ +package ru.mirea.practice.s23k0368; + +public class ArrayQueue { + private Object[] elements; + private int size; + private int head; + private int tail; + + public ArrayQueue() { + 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"; + final Object result = elements[head]; + elements[head] = null; + head = (head + 1) % elements.length; + size--; + return result; + } + + 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) { + return; + } + + 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; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/ArrayQueueadt.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/ArrayQueueadt.java new file mode 100644 index 000000000..54bc613eb --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/ArrayQueueadt.java @@ -0,0 +1,66 @@ +package ru.mirea.practice.s23k0368; + +public class ArrayQueueadt { + private Object[] elements; + private int size; + private int head; + private int tail; + + public ArrayQueueadt() { + elements = new Object[10]; + size = 0; + head = 0; + tail = 0; + } + + public static void enqueue(ArrayQueueadt queue, Object element) { + assert element != null : "element cannot be 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(ArrayQueueadt queue) { + assert queue.size > 0 : "Queue is empty"; + return queue.elements[queue.head]; + } + + public static Object dequeue(ArrayQueueadt queue) { + assert queue.size > 0 : "Queue is empty"; + final Object result = queue.elements[queue.head]; + queue.elements[queue.head] = null; + queue.head = (queue.head + 1) % queue.elements.length; + queue.size--; + return result; + } + + public static int size(ArrayQueueadt queue) { + return queue.size; + } + + public static boolean isEmpty(ArrayQueueadt queue) { + return queue.size == 0; + } + + public static void clear(ArrayQueueadt queue) { + queue.elements = new Object[10]; + queue.size = 0; + queue.head = 0; + queue.tail = 0; + } + + private static void ensureCapacity(ArrayQueueadt queue, int capacity) { + if (capacity <= queue.elements.length) { + return; + } + + 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; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/ArrayQueuemodule.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/ArrayQueuemodule.java new file mode 100644 index 000000000..d5f884e70 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/ArrayQueuemodule.java @@ -0,0 +1,66 @@ +package ru.mirea.practice.s23k0368; + +public abstract class ArrayQueuemodule { + private static Object[] elements = new Object[10]; + private static int size = 0; + private static int head = 0; + private static int tail = 0; + + // Добавить элемент в очередь + public static void enqueue(Object element) { + assert element != null : "element cannot be null"; + ensureCapacity(size + 1); + elements[tail] = element; + tail = (tail + 1) % elements.length; + size++; + } + + // Вернуть первый элемент в очереди + public static Object element() { + assert size > 0 : "Queue is empty"; + return elements[head]; + } + + // Удалить и вернуть первый элемент в очереди + public static Object dequeue() { + assert size > 0 : "Queue is empty"; + final Object result = elements[head]; + elements[head] = null; + head = (head + 1) % elements.length; + size--; + return result; + } + + // Текущий размер очереди + public static int size() { + return size; + } + + // Проверка, пустая ли очередь + public static boolean isEmpty() { + return size == 0; + } + + // Очистить очередь + public static void clear() { + elements = new Object[10]; + size = 0; + head = 0; + tail = 0; + } + + // Увеличить емкость массива при необходимости + private static void ensureCapacity(int capacity) { + if (capacity <= elements.length) { + return; + } + + 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; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/QueueTest.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/QueueTest.java new file mode 100644 index 000000000..6c2b8cf86 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/QueueTest.java @@ -0,0 +1,41 @@ +package ru.mirea.practice.s23k0368; + +public abstract class QueueTest { + public static void main(String[] args) { + testArrayQueueModule(); + testArrayQueueadt(); + testArrayQueue(); + } + + private static void testArrayQueueModule() { + ArrayQueuemodule.enqueue(1); + ArrayQueuemodule.enqueue(2); + System.out.println(ArrayQueuemodule.dequeue()); // 1 + System.out.println(ArrayQueuemodule.size()); // 1 + System.out.println(ArrayQueuemodule.isEmpty()); // false + ArrayQueuemodule.clear(); + System.out.println(ArrayQueuemodule.isEmpty()); // true + } + + private static void testArrayQueueadt() { + ArrayQueueadt queueAdt = new ArrayQueueadt(); + ArrayQueueadt.enqueue(queueAdt, 1); + ArrayQueueadt.enqueue(queueAdt, 2); + System.out.println(ArrayQueueadt.dequeue(queueAdt)); // 1 + System.out.println(ArrayQueueadt.size(queueAdt)); // 1 + System.out.println(ArrayQueueadt.isEmpty(queueAdt)); // false + ArrayQueueadt.clear(queueAdt); + System.out.println(ArrayQueueadt.isEmpty(queueAdt)); // true + } + + private static void testArrayQueue() { + ArrayQueue queue = new ArrayQueue(); + queue.enqueue(1); + queue.enqueue(2); + System.out.println(queue.dequeue()); // 1 + System.out.println(queue.size()); // 1 + System.out.println(queue.isEmpty()); // false + queue.clear(); + System.out.println(queue.isEmpty()); // true + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/AbstractQueue.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/AbstractQueue.java new file mode 100644 index 000000000..985b2f3e3 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/AbstractQueue.java @@ -0,0 +1,29 @@ +package ru.mirea.practice.s23k0368.prog2; + +public abstract class AbstractQueue implements Queue { + protected int size = 0; + + @Override + public int size() { + return size; + } + + @Override + public boolean isEmpty() { + return size == 0; + } + + @Override + public void clear() { + size = 0; + } + + @Override + public abstract void enqueue(T element); + + @Override + public abstract T dequeue(); + + @Override + public abstract T element(); +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/ArrayQueue.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/ArrayQueue.java new file mode 100644 index 000000000..04409daea --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/ArrayQueue.java @@ -0,0 +1,56 @@ +package ru.mirea.practice.s23k0368.prog2; + +public class ArrayQueue extends AbstractQueue { + private T[] array; + private int head = 0; + private int tail = 0; + + @SuppressWarnings("unchecked") + public ArrayQueue() { + array = (T[]) new Object[10]; + } + + @Override + public void enqueue(T element) { + if (element == null) { + throw new IllegalArgumentException("Element cannot be null"); + } + ensureCapacity(); + array[tail] = element; + tail = (tail + 1) % array.length; + size++; + } + + @Override + public T element() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + return array[head]; + } + + @Override + public T dequeue() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + final T result = array[head]; + array[head] = null; + head = (head + 1) % array.length; + size--; + return result; + } + + @SuppressWarnings("unchecked") + private void ensureCapacity() { + if (size == array.length) { + T[] newArray = (T[]) new Object[array.length * 2]; + for (int i = 0; i < size; i++) { + newArray[i] = array[(head + i) % array.length]; + } + array = newArray; + head = 0; + tail = size; + } + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/LinkedQueue.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/LinkedQueue.java new file mode 100644 index 000000000..299108bf7 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/LinkedQueue.java @@ -0,0 +1,71 @@ +package ru.mirea.practice.s23k0368.prog2; + +public class LinkedQueue implements Queue { + private static class Node { + T data; + Node next; + + Node(T data) { + this.data = data; + } + } + + private Node head; + private Node tail; + private int size = 0; + + @Override + public void enqueue(T element) { + if (element == null) { + throw new NullPointerException("Element cannot be null"); + } + Node newNode = new Node<>(element); + if (tail != null) { + tail.next = newNode; + } + tail = newNode; + if (head == null) { + head = tail; + } + size++; + } + + @Override + public T element() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + return head.data; + } + + @Override + public T dequeue() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + final T result = head.data; + head = head.next; + if (head == null) { + tail = null; + } + size--; + return result; + } + + @Override + public int size() { + return size; + } + + @Override + public boolean isEmpty() { + return size == 0; + } + + @Override + public void clear() { + head = null; + tail = null; + size = 0; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/Queue.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/Queue.java new file mode 100644 index 000000000..485b1c3c2 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/Queue.java @@ -0,0 +1,15 @@ +package ru.mirea.practice.s23k0368.prog2; + +public interface Queue { + void enqueue(T element); + + T element(); + + T dequeue(); + + int size(); + + boolean isEmpty(); + + void clear(); +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/Test.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/Test.java new file mode 100644 index 000000000..9e85072ab --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog2/Test.java @@ -0,0 +1,27 @@ +package ru.mirea.practice.s23k0368.prog2; + + +public abstract class Test { + public static void main(String[] args) { + arrayQueueTest(); + } + + static void arrayQueueTest() { + ArrayQueue queue = new ArrayQueue(); + queue.enqueue(1); + queue.enqueue(2); + System.out.println(queue.dequeue()); // 1 + System.out.println(queue.size()); // 1 + System.out.println(queue.isEmpty()); // false + queue.clear(); + System.out.println(queue.isEmpty()); // true + } + + static void testLinkesQueue() { + LinkedQueue queue = new LinkedQueue(); + queue.enqueue(1); + queue.enqueue(2); + System.out.println(queue.dequeue()); // 1 + System.out.println(queue.size()); // 1 + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Add.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Add.java new file mode 100644 index 000000000..b17c0f208 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Add.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog3; + +class Add extends BinaryOperation { + public Add(Expression left, Expression right) { + super(left, right); + } + + @Override + public double evaluate(double x) { + return left.evaluate(x) + right.evaluate(x); + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/BinaryOperation.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/BinaryOperation.java new file mode 100644 index 000000000..0288d824f --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/BinaryOperation.java @@ -0,0 +1,11 @@ +package ru.mirea.practice.s23k0368.prog3; + +abstract class BinaryOperation implements Expression { + protected final Expression left; + protected final Expression right; + + public BinaryOperation(Expression left, Expression right) { + this.left = left; + this.right = right; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Const.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Const.java new file mode 100644 index 000000000..5cf694f2f --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Const.java @@ -0,0 +1,14 @@ +package ru.mirea.practice.s23k0368.prog3; + +class Const implements Expression { + private final double value; + + public Const(double value) { + this.value = value; + } + + @Override + public double evaluate(double x) { + return value; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Divide.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Divide.java new file mode 100644 index 000000000..c1efba8e6 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Divide.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog3; + +class Divide extends BinaryOperation { + public Divide(Expression left, Expression right) { + super(left, right); + } + + @Override + public double evaluate(double x) { + return left.evaluate(x) / right.evaluate(x); + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Expression.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Expression.java new file mode 100644 index 000000000..b48b3c3fd --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Expression.java @@ -0,0 +1,5 @@ +package ru.mirea.practice.s23k0368.prog3; + +interface Expression { + double evaluate(double x); +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java new file mode 100644 index 000000000..4b01ab942 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java @@ -0,0 +1,31 @@ +package ru.mirea.practice.s23k0368.prog3; + +public abstract class Main { + public static void main(String[] args) { + if (args.length < 1) { + System.out.println("Введите значение x, значение по умолчанию х = 1"); + + } + + try { + double x; + if (args.length < 1) { + x = 1; + } else { + x = Double.parseDouble(args[0]); + } + Expression expr = new Add( + new Subtract( + new Multiply(new Variable("x"), new Variable("x")), + new Multiply(new Const(2), new Variable("x")) + ), + new Const(1) + ); + + double result = expr.evaluate(x); + System.out.println("Результат: " + result); + } catch (NumberFormatException e) { + System.out.println("Некорректный ввод: введите числовое значение для x."); + } + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Multiply.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Multiply.java new file mode 100644 index 000000000..a0d4d0fcf --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Multiply.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog3; + +class Multiply extends BinaryOperation { + public Multiply(Expression left, Expression right) { + super(left, right); + } + + @Override + public double evaluate(double x) { + return left.evaluate(x) * right.evaluate(x); + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Subtract.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Subtract.java new file mode 100644 index 000000000..9eae23657 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Subtract.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog3; + +class Subtract extends BinaryOperation { + public Subtract(Expression left, Expression right) { + super(left, right); + } + + @Override + public double evaluate(double x) { + return left.evaluate(x) - right.evaluate(x); + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Variable.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Variable.java new file mode 100644 index 000000000..9aa4d1486 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog3/Variable.java @@ -0,0 +1,15 @@ +package ru.mirea.practice.s23k0368.prog3; + +class Variable implements Expression { + @SuppressWarnings("PMD.SingularField") + private final String name; + + public Variable(String name) { + this.name = name; + } + + @Override + public double evaluate(double x) { + return x; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Add.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Add.java new file mode 100644 index 000000000..a965d0412 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Add.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0368.prog4; + +class Add extends BinaryOperation { + public Add(TripleExpression left, TripleExpression right) { + super(left, right); + } + + @Override + public int evaluate(int x, int y, int z) throws EvaluationException { + int leftValue = left.evaluate(x, y, z); + int rightValue = right.evaluate(x, y, z); + if (rightValue > 0 && leftValue > Integer.MAX_VALUE - rightValue + || rightValue < 0 && leftValue < Integer.MIN_VALUE - rightValue) { + throw new EvaluationException("overflow"); + } + return leftValue + rightValue; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/BinaryOperation.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/BinaryOperation.java new file mode 100644 index 000000000..d89b24f8b --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/BinaryOperation.java @@ -0,0 +1,11 @@ +package ru.mirea.practice.s23k0368.prog4; + +abstract class BinaryOperation implements TripleExpression { + protected final TripleExpression left; + protected final TripleExpression right; + + public BinaryOperation(TripleExpression left, TripleExpression right) { + this.left = left; + this.right = right; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Const.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Const.java new file mode 100644 index 000000000..a12f9fd0d --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Const.java @@ -0,0 +1,14 @@ +package ru.mirea.practice.s23k0368.prog4; + +class Const implements TripleExpression { + private final int value; + + public Const(int value) { + this.value = value; + } + + @Override + public int evaluate(int x, int y, int z) { + return value; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Divide.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Divide.java new file mode 100644 index 000000000..b65c87526 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Divide.java @@ -0,0 +1,20 @@ +package ru.mirea.practice.s23k0368.prog4; + +class Divide extends BinaryOperation { + public Divide(TripleExpression left, TripleExpression right) { + super(left, right); + } + + @Override + public int evaluate(int x, int y, int z) throws EvaluationException { + int leftValue = left.evaluate(x, y, z); + int rightValue = right.evaluate(x, y, z); + if (rightValue == 0) { + throw new EvaluationException("division by zero"); + } + if (leftValue == Integer.MIN_VALUE && rightValue == -1) { + throw new EvaluationException("overflow"); + } + return leftValue / rightValue; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/EvaluationException.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/EvaluationException.java new file mode 100644 index 000000000..eccbce64c --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/EvaluationException.java @@ -0,0 +1,7 @@ +package ru.mirea.practice.s23k0368.prog4; + +class EvaluationException extends Exception { + public EvaluationException(String message) { + super(message); + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/ExpressionParser.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/ExpressionParser.java new file mode 100644 index 000000000..cb58c5a7b --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/ExpressionParser.java @@ -0,0 +1,73 @@ +package ru.mirea.practice.s23k0368.prog4; + +class ExpressionParser { + private String expression; + private int index; + + public TripleExpression parse(String expression) { + this.expression = expression.replaceAll("\\s+", ""); + this.index = 0; + return parseExpression(); + } + + private TripleExpression parseExpression() { + TripleExpression result = parseTerm(); + while (index < expression.length()) { + char operator = expression.charAt(index); + if (operator == '+' || operator == '-') { + index++; + TripleExpression right = parseTerm(); + result = (operator == '+') ? new Add(result, right) : new Subtract(result, right); + } else { + break; + } + } + return result; + } + + private TripleExpression parseTerm() { + TripleExpression result = parseFactor(); + while (index < expression.length()) { + char operator = expression.charAt(index); + if (operator == '*' || operator == '/') { + index++; + TripleExpression right = parseFactor(); + result = (operator == '*') ? new Multiply(result, right) : new Divide(result, right); + } else { + break; + } + } + return result; + } + + private TripleExpression parseFactor() { + if (expression.charAt(index) == '-') { + index++; + return new Negate(parseFactor()); + } else if (expression.charAt(index) == '(') { + index++; + TripleExpression result = parseExpression(); + if (expression.charAt(index) == ')') { + index++; + } else { + throw new IllegalArgumentException("Expected closing parenthesis"); + } + return result; + } else if (Character.isDigit(expression.charAt(index))) { + int start = index; + while (index < expression.length() && Character.isDigit(expression.charAt(index))) { + index++; + } + int value = Integer.parseInt(expression.substring(start, index)); + return new Const(value); + } else if (Character.isLetter(expression.charAt(index))) { + StringBuilder varName = new StringBuilder(); + while (index < expression.length() && Character.isLetter(expression.charAt(index))) { + varName.append(expression.charAt(index++)); + } + return new Variable(varName.toString()); + } else { + throw new IllegalArgumentException("Unexpected character: " + expression.charAt(index)); + } + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Main.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Main.java new file mode 100644 index 000000000..8f2210385 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Main.java @@ -0,0 +1,17 @@ +package ru.mirea.practice.s23k0368.prog4; + +public abstract class Main { + public static void main(String[] args) { + ExpressionParser parser = new ExpressionParser(); + TripleExpression expression = parser.parse("1000000 * x * x * x * x * x / (x - 1)"); + + for (int x = 0; x <= 10; x++) { + try { + int result = expression.evaluate(x, 0, 0); + System.out.println(x + " " + result); + } catch (EvaluationException e) { + System.out.println(x + " " + e.getMessage()); + } + } + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Multiply.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Multiply.java new file mode 100644 index 000000000..e1ea144cd --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Multiply.java @@ -0,0 +1,20 @@ +package ru.mirea.practice.s23k0368.prog4; + +class Multiply extends BinaryOperation { + public Multiply(TripleExpression left, TripleExpression right) { + super(left, right); + } + + @Override + public int evaluate(int x, int y, int z) throws EvaluationException { + int leftValue = left.evaluate(x, y, z); + int rightValue = right.evaluate(x, y, z); + if (leftValue > 0 && rightValue > 0 && leftValue > Integer.MAX_VALUE / rightValue + || leftValue > 0 && rightValue < 0 && rightValue < Integer.MIN_VALUE / leftValue + || leftValue < 0 && rightValue > 0 && leftValue < Integer.MIN_VALUE / rightValue + || leftValue < 0 && rightValue < 0 && leftValue < Integer.MAX_VALUE / rightValue) { + throw new EvaluationException("overflow"); + } + return leftValue * rightValue; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Negate.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Negate.java new file mode 100644 index 000000000..29f201370 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Negate.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0368.prog4; + +class Negate implements TripleExpression { + private final TripleExpression expression; + + public Negate(TripleExpression expression) { + this.expression = expression; + } + + @Override + public int evaluate(int x, int y, int z) throws EvaluationException { + int value = expression.evaluate(x, y, z); + if (value == Integer.MIN_VALUE) { + throw new EvaluationException("overflow"); + } + return -value; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Subtract.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Subtract.java new file mode 100644 index 000000000..a78318cf4 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Subtract.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0368.prog4; + +class Subtract extends BinaryOperation { + public Subtract(TripleExpression left, TripleExpression right) { + super(left, right); + } + + @Override + public int evaluate(int x, int y, int z) throws EvaluationException { + int leftValue = left.evaluate(x, y, z); + int rightValue = right.evaluate(x, y, z); + if (rightValue < 0 && leftValue > Integer.MAX_VALUE + rightValue + || rightValue > 0 && leftValue < Integer.MIN_VALUE + rightValue) { + throw new EvaluationException("overflow"); + } + return leftValue - rightValue; + } +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/TripleExpression.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/TripleExpression.java new file mode 100644 index 000000000..96a35572e --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/TripleExpression.java @@ -0,0 +1,5 @@ +package ru.mirea.practice.s23k0368.prog4; + +interface TripleExpression { + int evaluate(int x, int y, int z) throws EvaluationException; +} diff --git a/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Variable.java b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Variable.java new file mode 100644 index 000000000..378472e88 --- /dev/null +++ b/students/23K0368/23K0368-p23/src/main/java/ru/mirea/practice/s23k0368/prog4/Variable.java @@ -0,0 +1,28 @@ +package ru.mirea.practice.s23k0368.prog4; + +class Variable implements TripleExpression { + private final String name; + + public Variable(String name) { + this.name = name; + } + + @Override + public int evaluate(int x, int y, int z) { + int result; + switch (name) { + case "x": + result = x; + break; + case "y": + result = y; + break; + case "z": + result = z; + break; + default: + throw new IllegalArgumentException("Unknown variable: " + name); + } + return result; + } +} diff --git a/students/23K0368/23K0368-p24/pom.xml b/students/23K0368/23K0368-p24/pom.xml new file mode 100644 index 000000000..d71b70a0a --- /dev/null +++ b/students/23K0368/23K0368-p24/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p24 + Паттерны проектирования + diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/CompexAbstractFactory.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/CompexAbstractFactory.java new file mode 100644 index 000000000..7419ff2f7 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/CompexAbstractFactory.java @@ -0,0 +1,7 @@ +package ru.mirea.practice.s23k0368.prog1; + +public interface CompexAbstractFactory { + Complex createComplex(); + + Complex createComplex(int real, int image); +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/Complex.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/Complex.java new file mode 100644 index 000000000..0e876fc0f --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/Complex.java @@ -0,0 +1,54 @@ +package ru.mirea.practice.s23k0368.prog1; + +public class Complex { + private int real; + private int image; + + Complex(int real, int image) { + this.real = real; + this.image = image; + } + + public int getReal() { + return real; + } + + public void setReal(int real) { + this.real = real; + } + + public int getImage() { + return image; + } + + public void setImage(int image) { + this.image = image; + } + + public Complex add(Complex other) { + return new Complex(this.real + other.real, this.image + other.image); + } + + public Complex subtract(Complex other) { + return new Complex(this.real - other.real, this.image - other.image); + } + + public Complex multiply(Complex other) { + return new Complex(this.real * other.real - this.image * other.image, this.image * other.image + this.image * other.image); + } + + public Complex divide(Complex other) throws ArithmeticException { + int denominator = other.real * other.real + other.image * other.image; + if (denominator == 0) { + throw new ArithmeticException("Division by zero"); + } + int newReal = (this.real * other.real + this.image * other.image) / denominator; + int newImaginary = (this.image * other.real - this.real * other.image) / denominator; + return new Complex(newReal, newImaginary); + } + + @Override + public String toString() { + return "(" + real + " + " + image + "i)"; + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/ConcreateFactory.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/ConcreateFactory.java new file mode 100644 index 000000000..9f843b6ce --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/ConcreateFactory.java @@ -0,0 +1,13 @@ +package ru.mirea.practice.s23k0368.prog1; + +public class ConcreateFactory implements CompexAbstractFactory { + @Override + public Complex createComplex() { + return new Complex(0, 0); + } + + @Override + public Complex createComplex(int real, int image) { + return new Complex(real, image); + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/Mian.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/Mian.java new file mode 100644 index 000000000..e56e7c8e7 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog1/Mian.java @@ -0,0 +1,23 @@ +package ru.mirea.practice.s23k0368.prog1; + +public abstract class Mian { + public static void main(String[] args) { + CompexAbstractFactory factory = new ConcreateFactory(); + + Complex complex1 = factory.createComplex(3, 4); + Complex complex2 = factory.createComplex(1, -2); + + System.out.println("complex1: " + complex1); + System.out.println("complex2: " + complex2); + + System.out.println("Addition: " + complex1.add(complex2)); + System.out.println("Subtraction: " + complex1.subtract(complex2)); + System.out.println("Multiplication: " + complex1.multiply(complex2)); + + try { + System.out.println("Division: " + complex1.divide(complex2)); + } catch (ArithmeticException e) { + System.out.println("Error: " + e.getMessage()); + } + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/AbstractChairFactory.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/AbstractChairFactory.java new file mode 100644 index 000000000..78d1a4d65 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/AbstractChairFactory.java @@ -0,0 +1,9 @@ +package ru.mirea.practice.s23k0368.prog2; + +public interface AbstractChairFactory { + VictorianChair createVictorianChair(int age); + + MagicChair createMagicChair(); + + FunctionalChair createFunctionalChair(); +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/Chair.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/Chair.java new file mode 100644 index 000000000..adc744ca8 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/Chair.java @@ -0,0 +1,5 @@ +package ru.mirea.practice.s23k0368.prog2; + +public interface Chair { + void sit(); +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/ChairFactory.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/ChairFactory.java new file mode 100644 index 000000000..21f2237c6 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/ChairFactory.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0368.prog2; + +public class ChairFactory implements AbstractChairFactory { + @Override + public VictorianChair createVictorianChair(int age) { + return new VictorianChair(age); + } + + @Override + public MagicChair createMagicChair() { + return new MagicChair(); + } + + @Override + public FunctionalChair createFunctionalChair() { + return new FunctionalChair(); + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/Client.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/Client.java new file mode 100644 index 000000000..8e810ae5e --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/Client.java @@ -0,0 +1,17 @@ +package ru.mirea.practice.s23k0368.prog2; + +public class Client { + private Chair chair; + + public void setChair(Chair chair) { + this.chair = chair; + } + + public void sit() { + if (chair != null) { + chair.sit(); + } else { + System.out.println("Выбираем стульчик"); + } + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/FunctionalChair.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/FunctionalChair.java new file mode 100644 index 000000000..dfefc95a8 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/FunctionalChair.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog2; + +public class FunctionalChair implements Chair { + public int sum(int a, int b) { + return a + b; + } + + @Override + public void sit() { + System.out.println("Мы на него сели."); + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/MagicChair.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/MagicChair.java new file mode 100644 index 000000000..935db4f30 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/MagicChair.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog2; + +public class MagicChair implements Chair { + public void doMagic() { + System.out.println("Магический стул превратился в магический шар!"); + } + + @Override + public void sit() { + System.out.println("Мы на него сели."); + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java new file mode 100644 index 000000000..bb676c091 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java @@ -0,0 +1,25 @@ +package ru.mirea.practice.s23k0368.prog2; + +public abstract class Main { + public static void main(String[] args) { + ChairFactory factory = new ChairFactory(); + + VictorianChair victorianChair = factory.createVictorianChair(100); + final MagicChair magicChair = factory.createMagicChair(); + final FunctionalChair functionalChair = factory.createFunctionalChair(); + + Client client = new Client(); + + client.setChair(victorianChair); + client.sit(); + System.out.println("Возраст нашего пенсионерского стола " + victorianChair.getAge()); + + client.setChair(magicChair); + client.sit(); + magicChair.doMagic(); + + client.setChair(functionalChair); + client.sit(); + System.out.println("Сумма " + functionalChair.sum(5, 10)); + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/VictorianChair.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/VictorianChair.java new file mode 100644 index 000000000..cfbc73bbc --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog2/VictorianChair.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0368.prog2; + +public class VictorianChair implements Chair { + private final int age; + + public VictorianChair(int age) { + this.age = age; + } + + public int getAge() { + return age; + } + + @Override + public void sit() { + System.out.println("Ура, стул имеется и мы на него сели."); + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/App.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/App.java new file mode 100644 index 000000000..86fd962f1 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/App.java @@ -0,0 +1,82 @@ +package ru.mirea.practice.s23k0368.prog3; + +import java.util.InputMismatchException; +import java.util.Scanner; + +public class App { + private IDocument currentDocument; + private final ICreateDocument documentFactory; + + public App(ICreateDocument documentFactory) { + this.documentFactory = documentFactory; + } + + public void run() { + try (Scanner scanner = new Scanner(System.in)) { + while (true) { + System.out.println("\nMenu:"); + System.out.println("1. New"); + System.out.println("2. Open"); + System.out.println("3. Save"); + System.out.println("4. Exit"); + System.out.print("Choose an option: "); + int choice = -1; + try { + choice = scanner.nextInt(); + } catch (InputMismatchException e) { + System.out.println("Неверный ввод. Пожалуйста, введите число."); + scanner.next(); + continue; + } + + switch (choice) { + case 1: + try { + newDocument(); + } catch (Exception e) { + System.err.println("Ошибка при создании нового документа: " + e.getMessage()); + } + break; + case 2: + try { + openDocument(); + } catch (Exception e) { + System.err.println("Ошибка при открытии документа: " + e.getMessage()); + } + break; + case 3: + saveDocument(); + break; + case 4: + exitApplication(); + return; + default: + System.out.println("Неверный выбор. Пожалуйста, введите число от 1 до 4."); + break; + } + } + } + } + + private void newDocument() throws Exception { + currentDocument = documentFactory.createNewDocument(); + System.out.println("Новый документ создан."); + } + + private void openDocument() throws Exception { + currentDocument = documentFactory.createOpen(); + System.out.println("Документ открыт."); + } + + private void saveDocument() { + if (currentDocument != null) { + currentDocument.save(); + } else { + System.out.println("Создайте или откройте документ перед сохранением."); + } + } + + private void exitApplication() { + System.out.println("Приложение завершено."); + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/CreateTextDocument.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/CreateTextDocument.java new file mode 100644 index 000000000..b3d5626f5 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/CreateTextDocument.java @@ -0,0 +1,13 @@ +package ru.mirea.practice.s23k0368.prog3; + +public class CreateTextDocument implements ICreateDocument { + @Override + public IDocument createNewDocument() { + return new TextDocument(); + } + + @Override + public IDocument createOpen() { + return new TextDocument(); + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/ICreateDocument.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/ICreateDocument.java new file mode 100644 index 000000000..c3bf063ea --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/ICreateDocument.java @@ -0,0 +1,7 @@ +package ru.mirea.practice.s23k0368.prog3; + +public interface ICreateDocument { + IDocument createNewDocument(); + + IDocument createOpen(); +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/IDocument.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/IDocument.java new file mode 100644 index 000000000..e4e4b37e2 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/IDocument.java @@ -0,0 +1,9 @@ +package ru.mirea.practice.s23k0368.prog3; + +public interface IDocument { + void open(); + + void save(); + + void close(); +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java new file mode 100644 index 000000000..a30e847e0 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java @@ -0,0 +1,11 @@ +package ru.mirea.practice.s23k0368.prog3; + +public abstract class Main { + public static void main(String[] args) { + + ICreateDocument documentFactory = new CreateTextDocument(); + + App app = new App(documentFactory); + app.run(); + } +} diff --git a/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/TextDocument.java b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/TextDocument.java new file mode 100644 index 000000000..2a9ec7e35 --- /dev/null +++ b/students/23K0368/23K0368-p24/src/main/java/ru/mirea/practice/s23k0368/prog3/TextDocument.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0368.prog3; + +public class TextDocument implements IDocument { + @Override + public void open() { + System.out.println("Открываем текстовый документ."); + } + + @Override + public void save() { + System.out.println("Сохраняем текстовый документ."); + } + + @Override + public void close() { + System.out.println("Закрываем текстовый документ."); + } +} diff --git a/students/23K0368/23K0368-p25/pom.xml b/students/23K0368/23K0368-p25/pom.xml new file mode 100644 index 000000000..e63bac071 --- /dev/null +++ b/students/23K0368/23K0368-p25/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p25 + Обработка строк + diff --git a/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/Main.java b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/Main.java new file mode 100644 index 000000000..acfc54d33 --- /dev/null +++ b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/Main.java @@ -0,0 +1,64 @@ +package ru.mirea.practice.s23k0368; + +import java.util.Scanner; + +public abstract class Main { + public static void main(String[] args) { + try (Scanner scanner = new Scanner(System.in)) { + while (true) { + System.out.println("Выберите действие: "); + System.out.println("1 - ввести строку и разбить её по выражению"); + System.out.println("0 - выйти из программы"); + + if (scanner.hasNextInt()) { + int chouse = scanner.nextInt(); + scanner.nextLine(); + + switch (chouse) { + case 1: + System.out.println("Введети строку: "); + String inputString = scanner.nextLine() + ' '; + System.out.println("Введенная строка " + inputString); + System.out.println("Выберите вариатн разбивки строки регулярным выражением"); + System.out.println("1 - разделитель робел, 2 - разделитель запятая, 3 - разделитель тире"); + int chouse2 = scanner.nextInt(); + scanner.nextLine(); + switch (chouse2) { + case 1: + String[] parts = inputString.split("\\s+"); + for (int i = 0; i < parts.length; i++) { + System.out.println("Элемент " + (i + 1) + ": " + parts[i]); + } + break; + case 2: + String[] parts2 = inputString.split("\\s*,"); + for (int i = 0; i < parts2.length; i++) { + System.out.println("Элемент " + (i + 1) + ": " + parts2[i]); + } + break; + case 3: + String[] parts3 = inputString.split("\\s*-\\s*"); + for (int i = 0; i < parts3.length; i++) { + System.out.println("Элемент " + (i + 1) + ": " + parts3[i]); + } + break; + default: + break; + } + break; + case 0: + System.out.println("Выход из программы."); + scanner.close(); + return; + default: + System.out.println("Неверный выбор"); + return; + } + } else { + System.out.println("Введено неверное числло"); + scanner.nextLine(); + } + } + } + } +} diff --git a/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java new file mode 100644 index 000000000..0be552fdf --- /dev/null +++ b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java @@ -0,0 +1,21 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.util.Scanner; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public abstract class Main { + public static void main(String[] args) { + try (Scanner scanner = new Scanner(System.in)) { + System.out.println("Ввдетите строку для сравнения"); + String inputString = scanner.nextLine(); + Pattern pattern = Pattern.compile("abcdefghijklmnopqrstuv18340"); + Matcher matcher = pattern.matcher(inputString); + if (matcher.find()) { + System.out.println("Введенная вами строка является заданной строкой " + matcher.group()); + } else { + System.out.println("Введенная строка не является заданной строкой :("); + } + } + } +} diff --git a/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java new file mode 100644 index 000000000..24bcfaf6e --- /dev/null +++ b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0368.prog3; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public abstract class Main { + public static void main(String[] args) { + String text = "25.98 USD, 44 RUB, 0.004 EUR, 123.50 EUR, 99.99 USD, 1.5 RUB, 0.00 USD."; + + Pattern pattern = Pattern.compile("\\b[1-9]\\d*(\\.\\d{1,2})?\\s+(USD|RUB|EUR)\\b"); + Matcher matcher = pattern.matcher(text); + + System.out.println("Найденные правильные цены:"); + while (matcher.find()) { + System.out.println(matcher.group()); + } + } +} diff --git a/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog4/Main.java b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog4/Main.java new file mode 100644 index 000000000..181093c87 --- /dev/null +++ b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog4/Main.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0368.prog4; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public abstract class Main { + public static void main(String[] args) { + String text = "(1 + 8) – 9 / 4 и 6 / 5 – 2 * 9"; + + Pattern pattern = Pattern.compile("\\b\\d+\\b(?!\\s*\\+)"); + Matcher matcher = pattern.matcher(text); + + System.out.println("Числа, за которыми не стоит знак '+':"); + while (matcher.find()) { + System.out.println(matcher.group()); + } + } +} diff --git a/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog5/Main.java b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog5/Main.java new file mode 100644 index 000000000..72d389fc2 --- /dev/null +++ b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog5/Main.java @@ -0,0 +1,28 @@ +package ru.mirea.practice.s23k0368.prog5; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public abstract class Main { + public static void main(String[] args) { + String[] dates = { + "29/02/2000", "30/04/2003", "01/01/2003", // правильные + "29/02/2001", "30-04-2003", "1/1/1899" // неправильные + }; + + String regex = "^(?:(?:31/(?:0[13578]|1[02]))|(?:30/(?:0[13-9]|1[0-2]))|(?:29/02/(?:(?:19|[2-9]\\d)(?:0[48]|" + + "[2468][048]|[13579][26])|2000))|(?:0[1-9]|1\\d|2[0-8])/(?:0[1-9]|1[0-2]))/(19\\d{2}|[2-9]\\d{3})$"; + + Pattern pattern = Pattern.compile(regex); + + for (String date : dates) { + Matcher matcher = pattern.matcher(date); + if (matcher.matches()) { + System.out.println(date + " is valid."); + } else { + System.out.println(date + " is invalid."); + } + } + } +} + diff --git a/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog6/Main.java b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog6/Main.java new file mode 100644 index 000000000..1bdc020c6 --- /dev/null +++ b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog6/Main.java @@ -0,0 +1,27 @@ +package ru.mirea.practice.s23k0368.prog6; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public abstract class Main { + public static void main(String[] args) { + String[] emails = { + "user@example.com", + "root@localhost", + "myhost@@@com.ru", + "@my.ru", + "Julia String" + }; + + Pattern pattern = Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"); + + for (String email : emails) { + Matcher matcher = pattern.matcher(email); + if (matcher.matches()) { + System.out.println(email + " - правильный e-mail"); + } else { + System.out.println(email + " - неправильный e-mail"); + } + } + } +} diff --git a/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog7/Main.java b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog7/Main.java new file mode 100644 index 000000000..46dd05b62 --- /dev/null +++ b/students/23K0368/23K0368-p25/src/main/java/ru/mirea/practice/s23k0368/prog7/Main.java @@ -0,0 +1,29 @@ +package ru.mirea.practice.s23k0368.prog7; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public abstract class Main { + public static void main(String[] args) { + String[] passwords = { + "F032_Password", + "TrySpy1", + "smart_pass", + "A007", + "SuperSecure1_", + }; + + String regex = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)[A-Za-z\\d_]{8,}$"; + + Pattern pattern = Pattern.compile(regex); + + for (String password : passwords) { + Matcher matcher = pattern.matcher(password); + if (matcher.matches()) { + System.out.println(password + " Этот пароль надёжный"); + } else { + System.out.println(password + " Этот пароль вообще не надежный"); + } + } + } +} diff --git a/students/23K0368/23K0368-p26/pom.xml b/students/23K0368/23K0368-p26/pom.xml new file mode 100644 index 000000000..f93af394c --- /dev/null +++ b/students/23K0368/23K0368-p26/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p26 + Коллекии + diff --git a/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/Convertation.java b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/Convertation.java new file mode 100644 index 000000000..ae4d99878 --- /dev/null +++ b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/Convertation.java @@ -0,0 +1,26 @@ +package ru.mirea.practice.s23k0368; + +import java.util.Stack; + +public abstract class Convertation { + public static void invertArray(int[] array) { + Stack stack = new Stack<>(); + + System.out.println("Исходный массив:"); + for (int num : array) { + System.out.print(stack.push(num) + " "); + } + + System.out.println(); + System.out.println("Инвертированный массив:"); + while (!stack.isEmpty()) { + System.out.print(stack.pop() + " "); + } + } + + public static void main(String[] args) { + int[] array = {1, 2, 3, 4, 5}; + + invertArray(array); + } +} diff --git a/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java new file mode 100644 index 000000000..d3355c519 --- /dev/null +++ b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java @@ -0,0 +1,24 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.util.ArrayList; +import java.util.List; + +public abstract class Main { + public static void main(String[] args) { + List list = new ArrayList<>(); + for (int i = 1; i <= 5; i++) { + list.add(i); + } + + MyIterator iterator = new MyIterator<>(list); + + System.out.println("Итерация по списку"); + while (iterator.hasNext()) { + System.out.println(iterator.next() + " "); + } + + iterator.remove(); + System.out.println("Список после удаления последнего элемента"); + System.out.println(list); + } +} diff --git a/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog2/MyIterator.java b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog2/MyIterator.java new file mode 100644 index 000000000..b1ad46491 --- /dev/null +++ b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog2/MyIterator.java @@ -0,0 +1,35 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.util.Iterator; +import java.util.List; + +public class MyIterator implements Iterator { + private final List list; + private int currentindex; + + public MyIterator(List list) { + this.list = list; + currentindex = 0; + } + + @Override + public boolean hasNext() { + return currentindex < list.size(); + } + + @Override + public T next() { + if (!hasNext()) { + throw new IllegalStateException("Элементы закончились"); + } + return list.get(currentindex++); + } + + @Override + public void remove() { + if (currentindex <= 0) { + throw new UnsupportedOperationException("Нечего удалять из списка"); + } + list.remove(--currentindex); + } +} diff --git a/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java new file mode 100644 index 000000000..1c216f90d --- /dev/null +++ b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java @@ -0,0 +1,16 @@ +package ru.mirea.practice.s23k0368.prog3; + +public abstract class Main { + public static void main(String[] args) { + MyList myList = new MyList<>(10); + + for (int i = 0; i <= 5; i++) { + myList.add(i); + } + + System.out.println("Элементы списка:"); + for (int num : myList) { + System.out.print(num + " "); + } + } +} diff --git a/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog3/MyList.java b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog3/MyList.java new file mode 100644 index 000000000..4b11114af --- /dev/null +++ b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog3/MyList.java @@ -0,0 +1,37 @@ +package ru.mirea.practice.s23k0368.prog3; + +import java.util.Iterator; + +public class MyList implements Iterable { + private final T[] elements; + private int size; + + public MyList(int capacity) { + elements = (T[]) new Object[capacity]; + size = 0; + } + + public void add(T element) { + if (size == elements.length) { + throw new IllegalStateException("List is full."); + } + elements[size++] = element; + } + + public T get(int index) { + if (index < 0 || index >= size) { + throw new IndexOutOfBoundsException("Invalid index."); + } + return elements[index]; + } + + public int size() { + return size; + } + + @Override + public Iterator iterator() { + return new MyListIterator<>(this); + } + +} diff --git a/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog3/MyListIterator.java b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog3/MyListIterator.java new file mode 100644 index 000000000..38a00a1db --- /dev/null +++ b/students/23K0368/23K0368-p26/src/main/java/ru/mirea/practice/s23k0368/prog3/MyListIterator.java @@ -0,0 +1,31 @@ +package ru.mirea.practice.s23k0368.prog3; + +import java.util.Iterator; + +class MyListIterator implements Iterator { + private final MyList list; + private int currentIndex; + + public MyListIterator(MyList list) { + this.list = list; + this.currentIndex = 0; + } + + @Override + public boolean hasNext() { + return currentIndex < list.size(); + } + + @Override + public E next() { + if (!hasNext()) { + throw new IllegalStateException("No more elements."); + } + return list.get(currentIndex++); + } + + @Override + public void remove() { + throw new UnsupportedOperationException("Remove not supported."); + } +} diff --git a/students/23K0368/23K0368-p27/pom.xml b/students/23K0368/23K0368-p27/pom.xml new file mode 100644 index 000000000..2c6684226 --- /dev/null +++ b/students/23K0368/23K0368-p27/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p27 + Хэш + diff --git a/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/HahTab.java b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/HahTab.java new file mode 100644 index 000000000..03de1632f --- /dev/null +++ b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/HahTab.java @@ -0,0 +1,68 @@ +package ru.mirea.practice.s23k0368; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +public abstract class HahTab { + private List> table; + private int capacity; + + private int hashtabHash(String key) { + return Math.abs(key.hashCode() % capacity); + } + + public void hashtabInit(int capacity) { + this.capacity = capacity; + + table = new ArrayList<>(capacity); + for (int i = 0; i < capacity; i++) { + table.add(new LinkedList<>()); + } + } + + public void hashtabAdd(String key, String value) { + int hash = hashtabHash(key); + LinkedList bucket = table.get(hash); + for (Node node : bucket) { + if (node.key.equals(key)) { + node.value = value; + return; + } + } + bucket.add(new Node(key, value)); + } + + public String hashtableLookup(String key) { + int hash = hashtabHash(key); + LinkedList bucket = table.get(hash); + for (Node node : bucket) { + if (node.key.equals(key)) { + return node.value; + } + } + return null; + } + + public boolean hashtabDelete(String key) { + int hash = hashtabHash(key); + LinkedList bucket = table.get(hash); + for (Node node : bucket) { + if (node.key.equals(key)) { + bucket.remove(node); + return true; + } + } + return false; + } + + public void printTable() { + for (int i = 0; i < capacity; i++) { + System.out.println(i + ": "); + for (Node node : table.get(i)) { + System.out.println("(" + node.key + ", " + node.value + ") "); + } + System.out.println(); + } + } +} diff --git a/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/Node.java b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/Node.java new file mode 100644 index 000000000..61c8108ac --- /dev/null +++ b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/Node.java @@ -0,0 +1,11 @@ +package ru.mirea.practice.s23k0368; + +public class Node { + String key; + String value; + + Node(String key, String value) { + this.key = key; + this.value = value; + } +} diff --git a/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog2/HahTab.java b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog2/HahTab.java new file mode 100644 index 000000000..bb4e1e871 --- /dev/null +++ b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog2/HahTab.java @@ -0,0 +1,68 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +public class HahTab { + private List> table; + private int capacity; + + private int hashtabHash(String key) { + return Math.abs(key.hashCode() % capacity); + } + + public void hashtabInit(int capacity) { + this.capacity = capacity; + + table = new ArrayList<>(capacity); + for (int i = 0; i < capacity; i++) { + table.add(new LinkedList<>()); + } + } + + public void hashtabAdd(String key, String value) { + int hash = hashtabHash(key); + LinkedList bucket = table.get(hash); + for (Node node : bucket) { + if (node.key.equals(key)) { + node.value = value; + return; + } + } + bucket.add(new Node(key, value)); + } + + public String hashtableLookup(String key) { + int hash = hashtabHash(key); + LinkedList bucket = table.get(hash); + for (Node node : bucket) { + if (node.key.equals(key)) { + return node.value; + } + } + return null; + } + + public boolean hashtabDelete(String key) { + int hash = hashtabHash(key); + LinkedList bucket = table.get(hash); + for (Node node : bucket) { + if (node.key.equals(key)) { + bucket.remove(node); + return true; + } + } + return false; + } + + public void printTable() { + for (int i = 0; i < capacity; i++) { + System.out.println(i + ": "); + for (Node node : table.get(i)) { + System.out.println("(" + node.key + ", " + node.value + ") "); + } + System.out.println(); + } + } +} diff --git a/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog2/Node.java b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog2/Node.java new file mode 100644 index 000000000..647774cd6 --- /dev/null +++ b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog2/Node.java @@ -0,0 +1,11 @@ +package ru.mirea.practice.s23k0368.prog2; + +public class Node { + String key; + String value; + + Node(String key, String value) { + this.key = key; + this.value = value; + } +} diff --git a/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog2/Test.java b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog2/Test.java new file mode 100644 index 000000000..9e6e7c4cb --- /dev/null +++ b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog2/Test.java @@ -0,0 +1,28 @@ +package ru.mirea.practice.s23k0368.prog2; + + +public abstract class Test { + public static void main(String[] args) { + HahTab hashTable = new HahTab(); + hashTable.hashtabInit(20); + + 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"); + + hashTable.printTable(); + + System.out.println("Поиск элемента по ключу " + hashTable.hashtableLookup("key5")); + + System.out.println("Удаление элемента по ключу " + hashTable.hashtabDelete("key5")); + + hashTable.printTable(); + } +} diff --git a/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog3/HahTab.java b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog3/HahTab.java new file mode 100644 index 000000000..c327ee944 --- /dev/null +++ b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog3/HahTab.java @@ -0,0 +1,68 @@ +package ru.mirea.practice.s23k0368.prog3; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +public abstract class HahTab { + private List> table; + private int capacity; + + private int hashtabHash(String key) { + return Math.abs(key.hashCode() % capacity); + } + + public void hashtabInit(int capacity) { + this.capacity = capacity; + + table = new ArrayList<>(capacity); + for (int i = 0; i < capacity; i++) { + table.add(new LinkedList<>()); + } + } + + public void hashtabAdd(String key, String value) { + int hash = hashtabHash(key); + LinkedList bucket = table.get(hash); + for (Node node : bucket) { + if (node.key.equals(key)) { + node.value = value; + return; + } + } + bucket.add(new Node(key, value)); + } + + public String hashtableLookup(String key) { + int hash = hashtabHash(key); + LinkedList bucket = table.get(hash); + for (Node node : bucket) { + if (node.key.equals(key)) { + return node.value; + } + } + return null; + } + + public boolean hashtabDelete(String key) { + int hash = hashtabHash(key); + LinkedList bucket = table.get(hash); + for (Node node : bucket) { + if (node.key.equals(key)) { + bucket.remove(node); + return true; + } + } + return false; + } + + public void printTable() { + for (int i = 0; i < capacity; i++) { + System.out.println(i + ": "); + for (Node node : table.get(i)) { + System.out.println("(" + node.key + ", " + node.value + ") "); + } + System.out.println(); + } + } +} diff --git a/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog3/Node.java b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog3/Node.java new file mode 100644 index 000000000..87e3bcdb8 --- /dev/null +++ b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog3/Node.java @@ -0,0 +1,11 @@ +package ru.mirea.practice.s23k0368.prog3; + +public class Node { + String key; + String value; + + Node(String key, String value) { + this.key = key; + this.value = value; + } +} diff --git a/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog3/Queue.java b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog3/Queue.java new file mode 100644 index 000000000..578e5a181 --- /dev/null +++ b/students/23K0368/23K0368-p27/src/main/java/ru/mirea/practice/s23k0368/prog3/Queue.java @@ -0,0 +1,21 @@ +package ru.mirea.practice.s23k0368.prog3; + +import java.util.PriorityQueue; + +public abstract class Queue { + public static void main(String[] args) { + PriorityQueue priorityQueue = new PriorityQueue<>(); + + priorityQueue.add(5); + priorityQueue.add(10); + priorityQueue.add(1); + priorityQueue.add(30); + priorityQueue.add(25); + + System.out.println("Очередь с приоритетами:" + priorityQueue); + + while (!priorityQueue.isEmpty()) { + System.out.println(priorityQueue.poll()); + } + } +} diff --git a/students/23K0368/23K0368-p28/pom.xml b/students/23K0368/23K0368-p28/pom.xml new file mode 100644 index 000000000..e7cfbc753 --- /dev/null +++ b/students/23K0368/23K0368-p28/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p28 + Нелинейные структуры данных + diff --git a/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/Main.java b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/Main.java new file mode 100644 index 000000000..eba89e26d --- /dev/null +++ b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/Main.java @@ -0,0 +1,21 @@ +package ru.mirea.practice.s23k0368; + +import java.util.HashSet; +import java.util.TreeSet; + +public abstract class Main { + public static void main(String[] args) { + HashSet hashset = new HashSet(); + hashset.add(0); + hashset.add(2); + hashset.add(3); + hashset.add(4); + hashset.add(3); + + System.out.println("Объект HashSet: " + hashset); + + TreeSet treeSet = new TreeSet<>(hashset); + + System.out.println("Объект TreeSet: " + treeSet); + } +} diff --git a/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/Student.java b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/Student.java new file mode 100644 index 000000000..526babaaa --- /dev/null +++ b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/Student.java @@ -0,0 +1,21 @@ +package ru.mirea.practice.s23k0368; + +public class Student { + private String name; + private int age; + + public Student(String name, int age) { + this.age = age; + this.name = name; + } + + @Override + public String toString() { + return "name=" + name + " age=" + age; + + } + + public int age() { + return age; + } +} diff --git a/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/Translate.java b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/Translate.java new file mode 100644 index 000000000..e45ff3ff5 --- /dev/null +++ b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/Translate.java @@ -0,0 +1,22 @@ +package ru.mirea.practice.s23k0368; + +import java.util.Comparator; +import java.util.HashSet; +import java.util.TreeSet; + +public abstract class Translate { + public static void main(String[] args) { + HashSet hashSet = new HashSet(); + hashSet.add(new Student("Иван", 19)); + hashSet.add(new Student("Олег", 18)); + hashSet.add(new Student("Вадим", 20)); + + Comparator ageComparator = (student1, student2) -> student1.age() - student2.age(); + + TreeSet treeSet = new TreeSet<>(ageComparator); + treeSet.addAll(hashSet); + + System.out.println("Объект TreeSet с сортировкой по возрасту:" + treeSet); + + } +} diff --git a/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java new file mode 100644 index 000000000..ff7503c4c --- /dev/null +++ b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog2/Main.java @@ -0,0 +1,14 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.util.Map; + +public abstract class Main { + public static void main(String[] args) { + Metods metod = new Metods(); + Map map = metod.createMap(); + System.out.println(metod.getSameFirstNamecount(map)); + System.out.println(metod.getSameLastNamecount(map)); + //Важное замечание! Нельзя хранить пару одинаковых ключей, значение будет перезаписано и на экране мы увидем 0 + //Имена могут повторяться (Сразу не заметил) + } +} diff --git a/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog2/Metods.java b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog2/Metods.java new file mode 100644 index 000000000..636faad97 --- /dev/null +++ b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog2/Metods.java @@ -0,0 +1,47 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +public class Metods { + public Map createMap() { + Map map = new HashMap<>(); + map.put("Колесников","Иван"); + map.put("Гребенкин","Олег"); + map.put("Татарченков","Сергей"); + map.put("Киримецких","Вадим"); + map.put("Повторяющийся","Иван"); + map.put("Клейменов","Александр"); + map.put("Шамрай","Владислав"); + map.put("Кузнецов","Даниил"); + map.put("Тимофеев","Всеволод"); + map.put("Филонов","Егор"); + return map; + } + + public int getSameFirstNamecount(Map map) { + Set firstName = new HashSet<>(); + Set duplicate = new HashSet<>(); + + for (String elem : map.values()) { + if (!firstName.add(elem)) { + duplicate.add(elem); + } + } + return duplicate.size(); + } + + public int getSameLastNamecount(Map map) { + Set lastNames = new HashSet<>(); + Set duplicate = new HashSet<>(); + + for (String elem : map.keySet()) { + if (!lastNames.add(elem)) { + duplicate.add(elem); + } + } + return duplicate.size(); + } +} diff --git a/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog3/Entry.java b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog3/Entry.java new file mode 100644 index 000000000..414d9dc77 --- /dev/null +++ b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog3/Entry.java @@ -0,0 +1,11 @@ +package ru.mirea.practice.s23k0368.prog3; + +class Entry { + double key; + V value; + + Entry(double key, V value) { + this.key = key; + this.value = value; + } +} diff --git a/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java new file mode 100644 index 000000000..34264271c --- /dev/null +++ b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog3/Main.java @@ -0,0 +1,13 @@ +package ru.mirea.practice.s23k0368.prog3; + +public abstract class Main { + public static void main(String[] args) { + Table hashTable = new Table<>(); + hashTable.put(3.14159, "pi"); + hashTable.put(2.71828, "e"); + hashTable.put(1.60217, "q"); + System.out.println(hashTable.get(3.14159)); + System.out.println(hashTable.get(2.7)); + System.out.println(hashTable.get(1.6)); + } +} diff --git a/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog3/Table.java b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog3/Table.java new file mode 100644 index 000000000..9172758bc --- /dev/null +++ b/students/23K0368/23K0368-p28/src/main/java/ru/mirea/practice/s23k0368/prog3/Table.java @@ -0,0 +1,74 @@ +package ru.mirea.practice.s23k0368.prog3; + +import java.util.ArrayList; +import java.util.List; + +public class Table { + private static final int defoultCapacity = 17; + private static final double defoultLoad = 0.75; + private static final double multiplier = 1000000; + + private int capacity; + private int size; + private double load; + private List>[] table; + + public Table() { + this(defoultCapacity, defoultLoad); + } + + public Table(int capacity, double load) { + this.capacity = capacity; + this.load = load; + this.table = (ArrayList>[]) new ArrayList[capacity]; + } + + private int hash(double key) { + int iKey = (int) (key * multiplier); + return Math.abs(iKey % capacity); + } + + public void put(double key, V value) { + int index = hash(key); + if (table[index] == null) { + table[index] = new ArrayList<>(); + } + table[index].add(new Entry<>(key, value)); + size++; + + if ((double) size / capacity >= load) { + resize(); + } + } + + public V get(double key) { + int index = hash(key); + if (table[index] != null) { + for (Entry entry : table[index]) { + if (entry.key == key) { + return entry.value; + } + } + } + return null; + } + + private void resize() { + int newCapacity = capacity * 2 + 1; + @SuppressWarnings("unchecked") + List>[] newTable = (List>[]) new ArrayList[newCapacity]; + for (List> list : table) { + if (list != null) { + for (Entry entry : list) { + int index = hash(entry.key); + if (newTable[index] == null) { + newTable[index] = new ArrayList<>(); + } + newTable[index].add(entry); + } + } + } + table = newTable; + capacity = newCapacity; + } +} diff --git a/students/23K0368/23K0368-p29/pom.xml b/students/23K0368/23K0368-p29/pom.xml new file mode 100644 index 000000000..f8e4fd549 --- /dev/null +++ b/students/23K0368/23K0368-p29/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p29 + Граф + diff --git a/students/23K0368/23K0368-p29/src/main/java/ru/mirea/practice/s23k0368/Main.java b/students/23K0368/23K0368-p29/src/main/java/ru/mirea/practice/s23k0368/Main.java new file mode 100644 index 000000000..b6537f28c --- /dev/null +++ b/students/23K0368/23K0368-p29/src/main/java/ru/mirea/practice/s23k0368/Main.java @@ -0,0 +1,32 @@ +package ru.mirea.practice.s23k0368; + +import java.util.Scanner; + +public abstract class Main { + public static void solve() { + int countOfRoad = 0; + try (Scanner scanner = new Scanner(System.in)) { + int size = scanner.nextInt(); + + int[][] matrix = new int[size][size]; + + for (int i = 0; i < size; i++) { + for (int j = 0; j < size; j++) { + matrix[i][j] = scanner.nextInt(); + } + } + for (int i = 0; i < size; i++) { + for (int j = i; j < size; j++) { + if (matrix[i][j] == 1) { + countOfRoad += 1; + } + } + } + } + System.out.println(countOfRoad); + } + + public static void main(String[] args) { + solve(); + } +} diff --git a/students/23K0368/23K0368-p30/pom.xml b/students/23K0368/23K0368-p30/pom.xml new file mode 100644 index 000000000..7759f3485 --- /dev/null +++ b/students/23K0368/23K0368-p30/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p30 + Бинарные деревья + diff --git a/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Comparison.java b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Comparison.java new file mode 100644 index 000000000..da2d59362 --- /dev/null +++ b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Comparison.java @@ -0,0 +1,33 @@ +package ru.mirea.practice.s23k0368.prog1; + +public abstract class Comparison { + public static boolean compare(Node node1, Node node2) { + if (node1 == null && node2 == null) { + return true; + } else if (node1 != null && node2 != null) { + return node1.data == node2.data && compare(node1.left, node2.left) && compare(node1.right, node2.right); + } else { + return false; + } + } + + public static void main(String[] args) { + Node root1 = new Node(1); + root1.left = new Node(2); + root1.right = new Node(3); + root1.left.left = new Node(4); + root1.left.right = new Node(5); + + Node root2 = new Node(1); + root2.left = new Node(2); + root2.right = new Node(3); + root2.left.left = new Node(4); + root2.left.right = new Node(5); + + if (compare(root1, root2)) { + System.out.println("Деревья равны"); + } else { + System.out.println("Деревья разные"); + } + } +} diff --git a/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/CountOfNode.java b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/CountOfNode.java new file mode 100644 index 000000000..b9fd7e8e8 --- /dev/null +++ b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/CountOfNode.java @@ -0,0 +1,21 @@ +package ru.mirea.practice.s23k0368.prog1; + +public abstract class CountOfNode { + public static int countOfNode(Node node) { + if (node == null) { + return 0; + } else { + return countOfNode(node.left) + countOfNode(node.right) + 1; + } + } + + public static void main(String[] args) { + Node root = new Node(1); + root.left = new Node(2); + root.right = new Node(3); + root.left.left = new Node(4); + root.left.right = new Node(5); + + System.out.println("Количество узлов в дереве: " + countOfNode(root)); + } +} diff --git a/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/HeightTree.java b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/HeightTree.java new file mode 100644 index 000000000..d8b40b095 --- /dev/null +++ b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/HeightTree.java @@ -0,0 +1,25 @@ +package ru.mirea.practice.s23k0368.prog1; + +import static java.lang.Math.max; + +public abstract class HeightTree { + public static int heightTree(Node node) { + if (node == null) { + return -1; + } else { + int leftHeight = heightTree(node.left); + int rightHeight = heightTree(node.right); + return max(leftHeight, rightHeight) + 1; + } + } + + public static void main(String[] args) { + Node root = new Node(1); + root.left = new Node(2); + root.right = new Node(3); + root.left.left = new Node(4); + root.left.right = new Node(5); + + System.out.println("Высота бинарного дерева " + heightTree(root)); + } +} diff --git a/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Lookup.java b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Lookup.java new file mode 100644 index 000000000..c36cf5e79 --- /dev/null +++ b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Lookup.java @@ -0,0 +1,34 @@ +package ru.mirea.practice.s23k0368.prog1; + +public abstract class Lookup { + public static int lookup(Node node, int key) { + if (node == null) { + return 0; + } else { + if (key == node.data) { + return 1; + } else { + if (key < node.data) { + return lookup(node.left, key); + } else { + return lookup(node.right, key); + } + } + } + } + + public static void main(String[] args) { + Node root = new Node(1); + root.left = new Node(2); + root.right = new Node(3); + root.left.left = new Node(4); + root.left.right = new Node(5); + + if (lookup(root, 3) == 1) { + System.out.println("Значение найдено"); + } else { + System.out.println("Значение отсутствует"); + } + + } +} diff --git a/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Node.java b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Node.java new file mode 100644 index 000000000..3777bbc6c --- /dev/null +++ b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Node.java @@ -0,0 +1,47 @@ +package ru.mirea.practice.s23k0368.prog1; + +public class Node { + int data; + Node left; + Node right; + + public Node(int data) { + this.data = data; + this.left = null; + this.right = null; + } + + public int getData() { + return data; + } + + public void setData(int data) { + this.data = data; + } + + public Node getLeft() { + return left; + } + + public void setLeft(Node left) { + this.left = left; + } + + public Node getRight() { + return right; + } + + public void setRight(Node right) { + this.right = right; + } + + public void print() { + System.out.print(data + " "); + if (left != null) { + left.print(); + } + if (right != null) { + right.print(); + } + } +} diff --git a/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Reverse.java b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Reverse.java new file mode 100644 index 000000000..e9f79655a --- /dev/null +++ b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Reverse.java @@ -0,0 +1,42 @@ +package ru.mirea.practice.s23k0368.prog1; + +public abstract class Reverse { + public static void reverse(Node node) { + if (node == null) { + return; + } else { + Node temp = node.left; + node.left = node.right; + node.right = temp; + + reverse(node.left); + reverse(node.right); + } + } + + public static void printTree(Node node, String prefix, boolean isLeft) { + if (node != null) { + System.out.println(prefix + (isLeft ? "├── " : "└── ") + node.getData()); + printTree(node.getLeft(), prefix + (isLeft ? "│ " : " "), true); + printTree(node.getRight(), prefix + (isLeft ? "│ " : " "), false); + } + } + + public static void printTree(Node node) { + printTree(node, "", false); + } + + public static void main(String[] args) { + Node root = new Node(1); + root.left = new Node(2); + root.right = new Node(3); + root.left.left = new Node(4); + root.left.right = new Node(5); + + System.out.println("Оригинальное дерево:"); + printTree(root); + reverse(root); + System.out.println("Зеркальное дерево:"); + printTree(root); + } +} diff --git a/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Weight.java b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Weight.java new file mode 100644 index 000000000..cf5618f38 --- /dev/null +++ b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog1/Weight.java @@ -0,0 +1,44 @@ +package ru.mirea.practice.s23k0368.prog1; + +public abstract class Weight { + public static int widht(Node node) { + int maxWidht = 0; + int widht = 0; + int h = height(node); + for (int i = 1; i < h; i++) { + widht = getWidht(node, i); + maxWidht = Math.max(widht, maxWidht); + } + return maxWidht; + } + + public static int getWidht(Node node, int level) { + if (node == null) { + return 0; + } else if (level == 1) { + return 1; + } else { + return getWidht(node.left, level - 1) + getWidht(node.right, level - 1); + } + } + + public static int height(Node node) { + if (node == null) { + return 0; + } else { + int leftHeight = height(node.left); + int rightHeight = height(node.right); + return Math.max(leftHeight + 1, rightHeight + 1); + } + } + + public static void main(String[] args) { + Node root = new Node(1); + root.left = new Node(2); + root.right = new Node(3); + root.left.left = new Node(4); + root.left.right = new Node(5); + + System.out.println("Вес дерева: " + widht(root)); + } +} diff --git a/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog2/Haffman.java b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog2/Haffman.java new file mode 100644 index 000000000..05a04a089 --- /dev/null +++ b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog2/Haffman.java @@ -0,0 +1,55 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.util.HashMap; +import java.util.Map; +import java.util.PriorityQueue; + +public abstract class Haffman { + public static void haffman(Map charFreq) { + PriorityQueue pq = new PriorityQueue<>(); + + for (Map.Entry entry : charFreq.entrySet()) { + pq.add(new Node(entry.getKey(), entry.getValue())); + } + + while (pq.size() > 1) { + Node left = pq.poll(); + Node right = pq.poll(); + + Node parent = new Node('\0', left.getFrequency() + right.getFrequency()); + parent.setLeft(left); + parent.setRight(right); + pq.add(parent); + } + + Node root = pq.peek(); + Map huffmanCodes = new HashMap<>(); + printCodes(root, "", huffmanCodes); + + System.out.println("Символ\tкод"); + for (Map.Entry entry : huffmanCodes.entrySet()) { + System.out.println(entry.getKey() + "\t\t" + entry.getValue()); + } + } + + private static void printCodes(Node root, String currentCode, Map huffmanCodes) { + if (root == null) { + return; + } else if (root.name != '\0') { + huffmanCodes.put(root.name, currentCode); + } + printCodes(root.left, currentCode + "0", huffmanCodes); + printCodes(root.right, currentCode + "1", huffmanCodes); + } + + public static void main(String[] args) { + Map charFrequencies = new HashMap<>(); + charFrequencies.put('A', 1); + charFrequencies.put('B', 2); + charFrequencies.put('C', 3); + charFrequencies.put('D', 4); + charFrequencies.put('E', 5); + + haffman(charFrequencies); + } +} diff --git a/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog2/Node.java b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog2/Node.java new file mode 100644 index 000000000..1058e6080 --- /dev/null +++ b/students/23K0368/23K0368-p30/src/main/java/ru/mirea/practice/s23k0368/prog2/Node.java @@ -0,0 +1,50 @@ +package ru.mirea.practice.s23k0368.prog2; + +public class Node implements Comparable { + char name; + float frequency; + Node left; + Node right; + + public Node(char name, float frequency) { + this.name = name; + this.frequency = frequency; + } + + public char getName() { + return name; + } + + public void setName(char name) { + this.name = name; + } + + public float getFrequency() { + return frequency; + } + + public void setFrequency(float frequency) { + this.frequency = frequency; + } + + public Node getLeft() { + return left; + } + + public void setLeft(Node left) { + this.left = left; + } + + public Node getRight() { + return right; + } + + public void setRight(Node right) { + this.right = right; + } + + @Override + public int compareTo(Node other) { + return (int) (this.frequency - other.frequency); + } +} diff --git a/students/23K0368/23K0368-p31/pom.xml b/students/23K0368/23K0368-p31/pom.xml new file mode 100644 index 000000000..12b99d49f --- /dev/null +++ b/students/23K0368/23K0368-p31/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p31 + 2-3 деревья + diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog1/Node.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog1/Node.java new file mode 100644 index 000000000..78104a447 --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog1/Node.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog1; + +class Node { + int data; + Node left; + Node right; + + Node(int data) { + this.data = data; + left = right = null; + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog1/TreeTwoThree.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog1/TreeTwoThree.java new file mode 100644 index 000000000..34f54a2ee --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog1/TreeTwoThree.java @@ -0,0 +1,71 @@ +package ru.mirea.practice.s23k0368.prog1; + +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.ArrayList; +import java.util.List; + +public abstract class TreeTwoThree { + public static void printTree(Node root) { + if (root == null) { + return; + } + + int height = getHeight(root); + List levels = new ArrayList<>(); + + Deque queue = new ArrayDeque<>(); + queue.offer(root); + + for (int level = 0; level < height; level++) { + int levelSize = queue.size(); + int spacesBefore = (int) Math.pow(2, height - level - 1) - 1; + int spacesBetween = (int) Math.pow(2, height - level) - 1; + + StringBuilder levelString = new StringBuilder(" ".repeat(spacesBefore)); + List currentLevelNodes = new ArrayList<>(); + + for (int i = 0; i < levelSize; i++) { + Node node = queue.poll(); + levelString.append(node.data); + currentLevelNodes.add(node); + + if (i < levelSize - 1) { + levelString.append(" ".repeat(spacesBetween)); + } + if (node.left != null) { + queue.offer(node.left); + } + if (node.right != null) { + queue.offer(node.right); + } + } + levels.add(levelString.toString()); + } + + for (int i = levels.size() - 1; i >= 0; i--) { + System.out.println(levels.get(i)); + } + } + + + private static int getHeight(Node root) { + if (root == null) { + return 0; + } + return 1 + Math.max(getHeight(root.left), getHeight(root.right)); + } + + + public static void main(String[] args) { + Node root = new Node(5); + root.left = new Node(2); + root.right = new Node(6); + root.left.left = new Node(1); + root.left.right = new Node(2); + root.right.left = new Node(5); + root.right.right = new Node(6); + + printTree(root); + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog2/Node.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog2/Node.java new file mode 100644 index 000000000..3d845655d --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog2/Node.java @@ -0,0 +1,13 @@ +package ru.mirea.practice.s23k0368.prog2; + +class Node { + int data; + Node left; + Node middle; + Node right; + + Node(int data) { + this.data = data; + } +} + diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog2/TreeTwoThree.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog2/TreeTwoThree.java new file mode 100644 index 000000000..7b5647d84 --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog2/TreeTwoThree.java @@ -0,0 +1,80 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.util.ArrayDeque; +import java.util.Deque; + +public abstract class TreeTwoThree { + public static void printTree(Node root) { + if (root == null) { + return; + } + + int height = getHeight(root); + Deque queue = new ArrayDeque<>(); + queue.offer(root); + + for (int level = 0; level < height; level++) { + int levelSize = queue.size(); + int spacesBefore = (int) Math.pow(2, height - level - 1) - 1; + int spacesBetween = (int) Math.pow(2, height - level) - 1; + + for (int i = 0; i < levelSize; i++) { + Node node = queue.poll(); + System.out.print(" ".repeat(spacesBefore)); + System.out.print(node.data); + + if (node.middle != null) { + System.out.print(" " + node.middle.data); + if (node.left != null) { + queue.offer(node.left); + } + if (node.middle != null) { + queue.offer(node.middle); + } + if (node.right != null) { + queue.offer(node.right); + } + } else if (node.left != null && node.right != null) { + System.out.print("-"); + if (node.left != null) { + queue.offer(node.left); + } + if (node.right != null) { + queue.offer(node.right); + } + } else { + if (node.left != null) { + queue.offer(node.left); + } + if (node.right != null) { + queue.offer(node.right); + } + } + + if (i < levelSize - 1) { + System.out.print(" ".repeat(spacesBetween)); + } + } + System.out.println(); + } + } + + private static int getHeight(Node root) { + if (root == null) { + return 0; + } + return 1 + Math.max(Math.max(getHeight(root.left), getHeight(root.middle)), getHeight(root.right)); + } + + public static void main(String[] args) { + Node root = new Node(5); + root.left = new Node(2); + root.right = new Node(6); + root.left.left = new Node(1); + root.left.right = new Node(2); + root.right.left = new Node(5); + root.right.right = new Node(6); + + printTree(root); + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog3/Node.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog3/Node.java new file mode 100644 index 000000000..ddba72415 --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog3/Node.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog3; + +class Node { + int data; + Node left; + Node middle; + Node right; + + Node(int data) { + this.data = data; + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog3/Tree.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog3/Tree.java new file mode 100644 index 000000000..19a34dfd8 --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog3/Tree.java @@ -0,0 +1,33 @@ +package ru.mirea.practice.s23k0368.prog3; + +public abstract class Tree { + public static void printTree(Node node) { + if (node == null) { + return; + } + + printTree(node.left); + printTree(node.middle); + printTree(node.right); + System.out.print(node.data); + + if (node.left != null && node.right != null) { + System.out.print("-"); + } + System.out.print(" "); + } + + public static void main(String[] args) { + Node root = new Node(5); + root.left = new Node(2); + root.middle = new Node(3); + root.right = new Node(6); + root.left.left = new Node(1); + root.left.right = new Node(2); + root.middle.left = new Node(4); + root.right.left = new Node(5); + root.right.right = new Node(6); + + printTree(root); + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog3/TreeForExample.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog3/TreeForExample.java new file mode 100644 index 000000000..ede2ef279 --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog3/TreeForExample.java @@ -0,0 +1,69 @@ +package ru.mirea.practice.s23k0368.prog3; + +import java.util.ArrayDeque; +import java.util.Deque; + +public abstract class TreeForExample { + + public static void printTree(Node root) { + if (root == null) { + return; + } + + int height = getHeight(root); + Deque queue = new ArrayDeque<>(); + queue.offer(root); + int level = 0; + + while (!queue.isEmpty()) { + int levelSize = queue.size(); + int spacesBefore = (int) Math.pow(2, height - level - 1) - 1; + int spacesBetween = (int) Math.pow(2, height - level) - 1; + + System.out.print(" ".repeat(spacesBefore)); + + for (int i = 0; i < levelSize; i++) { + Node node = queue.poll(); + System.out.print(node.data); + + if (i < levelSize - 1) { + System.out.print(" ".repeat(spacesBetween)); + } + + if (node.left != null) { + queue.offer(node.left); + } + if (node.middle != null) { + queue.offer(node.middle); + } + if (node.right != null) { + queue.offer(node.right); + } + } + System.out.println(); + level++; + } + } + + //Функция для вычисления высоты дерева + private static int getHeight(Node root) { + if (root == null) { + return 0; + } + return 1 + Math.max(Math.max(getHeight(root.left), getHeight(root.middle)), getHeight(root.right)); + } + + public static void main(String[] args) { + Node root = new Node(5); + root.left = new Node(2); + root.middle = new Node(3); + root.right = new Node(6); + root.left.left = new Node(1); + root.left.right = new Node(2); + root.middle.left = new Node(4); + root.right.left = new Node(5); + root.right.right = new Node(6); + + printTree(root); + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog4/Node.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog4/Node.java new file mode 100644 index 000000000..5e546ba10 --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog4/Node.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog4; + +class Node { + int data; + Node left; + Node middle; + Node right; + + Node(int data) { + this.data = data; + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog4/Tree.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog4/Tree.java new file mode 100644 index 000000000..967dc8089 --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog4/Tree.java @@ -0,0 +1,34 @@ +package ru.mirea.practice.s23k0368.prog4; + +public abstract class Tree { + public static void printTree(Node node) { + if (node == null) { + return; + } + + System.out.print(node.data); + + if (node.left != null && node.right != null) { + System.out.print("-"); + } + + System.out.print(" "); + printTree(node.left); + printTree(node.middle); + printTree(node.right); + } + + public static void main(String[] args) { + Node root = new Node(5); + root.left = new Node(2); + root.middle = new Node(3); + root.right = new Node(6); + root.left.left = new Node(1); + root.left.right = new Node(2); + root.middle.left = new Node(4); + root.right.left = new Node(5); + root.right.right = new Node(6); + + printTree(root); + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog4/TreeForExample.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog4/TreeForExample.java new file mode 100644 index 000000000..441b78c8b --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog4/TreeForExample.java @@ -0,0 +1,69 @@ +package ru.mirea.practice.s23k0368.prog4; + +import java.util.ArrayDeque; +import java.util.Deque; + +public abstract class TreeForExample { + + public static void printTree(Node root) { + if (root == null) { + return; + } + + int height = getHeight(root); + Deque queue = new ArrayDeque<>(); + queue.offer(root); + int level = 0; + + while (!queue.isEmpty()) { + int levelSize = queue.size(); + int spacesBefore = (int) Math.pow(2, height - level - 1) - 1; + int spacesBetween = (int) Math.pow(2, height - level) - 1; + + System.out.print(" ".repeat(spacesBefore)); + + for (int i = 0; i < levelSize; i++) { + Node node = queue.poll(); + System.out.print(node.data); + + if (i < levelSize - 1) { + System.out.print(" ".repeat(spacesBetween)); + } + + if (node.left != null) { + queue.offer(node.left); + } + if (node.middle != null) { + queue.offer(node.middle); + } + if (node.right != null) { + queue.offer(node.right); + } + } + System.out.println(); + level++; + } + } + + //Функция для вычисления высоты дерева + private static int getHeight(Node root) { + if (root == null) { + return 0; + } + return 1 + Math.max(Math.max(getHeight(root.left), getHeight(root.middle)), getHeight(root.right)); + } + + public static void main(String[] args) { + Node root = new Node(5); + root.left = new Node(2); + root.middle = new Node(3); + root.right = new Node(6); + root.left.left = new Node(1); + root.left.right = new Node(2); + root.middle.left = new Node(4); + root.right.left = new Node(5); + root.right.right = new Node(6); + + printTree(root); + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog5/Node.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog5/Node.java new file mode 100644 index 000000000..e85297ed7 --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog5/Node.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog5; + +class Node { + int data; + Node left; + Node middle; + Node right; + + Node(int data) { + this.data = data; + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog5/Tree.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog5/Tree.java new file mode 100644 index 000000000..0414dd349 --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog5/Tree.java @@ -0,0 +1,34 @@ +package ru.mirea.practice.s23k0368.prog5; + +public abstract class Tree { + 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.print(node.data + "-Уровень:" + level); + + if (node.left != null && node.right != null) { + System.out.print("—"); + } + System.out.print(" "); + } + + public static void main(String[] args) { + Node root = new Node(5); + root.left = new Node(2); + root.middle = new Node(3); + root.right = new Node(6); + root.left.left = new Node(1); + root.left.right = new Node(2); + root.middle.left = new Node(4); + root.right.left = new Node(5); + root.right.right = new Node(6); + + int level = 1; + printTree(root, level); + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog6/Node.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog6/Node.java new file mode 100644 index 000000000..1dff6ac8d --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog6/Node.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0368.prog6; + +class Node { + int data; + Node left; + Node middle; + Node right; + + Node(int data) { + this.data = data; + } +} diff --git a/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog6/Tree.java b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog6/Tree.java new file mode 100644 index 000000000..1c1f28b28 --- /dev/null +++ b/students/23K0368/23K0368-p31/src/main/java/ru/mirea/practice/s23k0368/prog6/Tree.java @@ -0,0 +1,35 @@ +package ru.mirea.practice.s23k0368.prog6; + +public abstract class Tree { + public static void printTree(Node node, int level) { + if (node == null) { + return; + } + + System.out.print(node.data + "-Уровень:" + level + " "); + + if (node.left != null && node.right != null) { + System.out.print("—"); + } + + System.out.print(" "); + printTree(node.left, level + 1); + printTree(node.middle, level + 1); + printTree(node.right, level + 1); + } + + public static void main(String[] args) { + Node root = new Node(5); + root.left = new Node(2); + root.middle = new Node(3); + root.right = new Node(6); + root.left.left = new Node(1); + root.left.right = new Node(2); + root.middle.left = new Node(4); + root.right.left = new Node(5); + root.right.right = new Node(6); + + int level = 1; + printTree(root, level); + } +} diff --git a/students/23K0368/23K0368-p32/pom.xml b/students/23K0368/23K0368-p32/pom.xml new file mode 100644 index 000000000..280fffa36 --- /dev/null +++ b/students/23K0368/23K0368-p32/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0368 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0368-p32 + Перестановки + diff --git a/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog1/Permutations.java b/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog1/Permutations.java new file mode 100644 index 000000000..7a42b56db --- /dev/null +++ b/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog1/Permutations.java @@ -0,0 +1,48 @@ +package ru.mirea.practice.s23k0368.prog1; + +public abstract class Permutations { + public static void swap(int[] arr, int i, int j) { + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } + + public static boolean nextPermutation(int[] arr) { + int n = arr.length; + int j = n - 2; + while (j >= 0 && arr[j] >= arr[j + 1]) { + j--; + } + if (j == -1) { + return false; + } + int k = n - 1; + while (arr[j] >= arr[k]) { + k--; + } + swap(arr, j, k); + int r = n - 1; + while (j < r) { + swap(arr, j + 1, r); + j++; + r--; + } + return true; + } + + public static void printPermutation(int[] arr) { + + for (int i = 0; i < arr.length; i++) { + System.out.print(arr[i] + (i == arr.length - 1 ? "" : " ")); + } + System.out.println(); + } + + public static void main(String[] args) { + int[] arr = {1, 2, 3, 4}; + printPermutation(arr); + while (nextPermutation(arr)) { + printPermutation(arr); + } + } +} diff --git a/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog2/Permutations.java b/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog2/Permutations.java new file mode 100644 index 000000000..8052ef4b0 --- /dev/null +++ b/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog2/Permutations.java @@ -0,0 +1,55 @@ +package ru.mirea.practice.s23k0368.prog2; + +import java.util.Arrays; + +public abstract class Permutations { + public static void swap(int[] arr, int i, int j) { + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } + + public static boolean nextPermutation(int[] arr) { + int n = arr.length; + int i = n - 2; + + while (i >= 0 && arr[i] >= arr[i + 1]) { + i--; + } + + if (i == -1) { + return false; + } + + int j = n - 1; + + while (arr[j] <= arr[i]) { + j--; + } + + swap(arr, i, j); + + int l = i + 1; + int r = n - 1; + while (l < r) { + swap(arr, l, r); + l++; + r--; + } + + return true; + } + + public static void printPermutation(int[] arr) { + System.out.println(Arrays.toString(arr)); + } + + + public static void main(String[] args) { + int[] arr = {1, 1, 3, 4}; + printPermutation(arr); + while (nextPermutation(arr)) { + printPermutation(arr); + } + } +} diff --git a/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog3/Node.java b/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog3/Node.java new file mode 100644 index 000000000..259bb35cb --- /dev/null +++ b/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog3/Node.java @@ -0,0 +1,10 @@ +package ru.mirea.practice.s23k0368.prog3; + +class Node { + int data; + Node next; + + Node(int data) { + this.data = data; + } +} diff --git a/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog3/PrologPermutations.java b/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog3/PrologPermutations.java new file mode 100644 index 000000000..f10fde0f0 --- /dev/null +++ b/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog3/PrologPermutations.java @@ -0,0 +1,39 @@ +package ru.mirea.practice.s23k0368.prog3; + +import java.util.ArrayList; +import java.util.List; + +public abstract class PrologPermutations { + public static boolean position(Node head, int x, Node list) { + if (head == null) { + return false; + } + if (head.data == x) { + return true; + } + return position(head.next, x, list.next); + } + + public static void transposition(Node head, List list) { + if (head == null) { + return; + } + transposition(head.next, list); + list.add(head.data); + } + + + public static void main(String[] args) { + Node list = new Node(1); + list.next = new Node(2); + list.next.next = new Node(3); + list.next.next.next = new Node(4); + + System.out.println("Позиция элемента 5: " + position(list, 5, list)); + + + List transposedList = new ArrayList<>(); + transposition(list, transposedList); + System.out.println("Транспонированный список: " + transposedList); // [4,3,2,1] + } +} diff --git a/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog4/JonesTrotter.java b/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog4/JonesTrotter.java new file mode 100644 index 000000000..5b865436c --- /dev/null +++ b/students/23K0368/23K0368-p32/src/main/java/ru/mirea/practice/s23k0368/prog4/JonesTrotter.java @@ -0,0 +1,79 @@ +package ru.mirea.practice.s23k0368.prog4; + +import java.util.Arrays; + +public abstract class JonesTrotter { + private static int[] p; + private static int[] dir; + + public static void jonesTrotter(int n) { + p = new int[n]; + dir = new int[n]; + + for (int i = 0; i < n; i++) { + p[i] = i + 1; + dir[i] = -1; + } + + printPermutation(); + + while (true) { + int mobileIndex = findMaxMobile(n); + + if (mobileIndex == -1) { + break; + } + + int nextIndex = mobileIndex + dir[mobileIndex]; + + swap(mobileIndex, nextIndex); + + for (int i = 0; i < n; i++) { + if (p[i] > p[nextIndex]) { + dir[i] *= -1; + } + } + + printPermutation(); + } + } + + private static int findMaxMobile(int n) { + int maxMobileIndex = -1; + int maxValue = -1; + + for (int i = 0; i < n; i++) { + if (isMobile(i)) { + if (p[i] > maxValue) { + maxValue = p[i]; + maxMobileIndex = i; + } + } + } + return maxMobileIndex; + } + + private static boolean isMobile(int i) { + int nextIndex = i + dir[i]; + return nextIndex >= 0 && nextIndex < p.length && p[i] > p[nextIndex]; + } + + private static void swap(int i, int j) { + int temp = p[i]; + p[i] = p[j]; + p[j] = temp; + + int tempDir = dir[i]; + dir[i] = dir[j]; + dir[j] = tempDir; + } + + private static void printPermutation() { + System.out.println(Arrays.toString(p)); + } + + public static void main(String[] args) { + int n = 3; + jonesTrotter(n); + } +} diff --git a/students/23K0368/pom.xml b/students/23K0368/pom.xml index 12a4dea89..b6d0c8ac1 100644 --- a/students/23K0368/pom.xml +++ b/students/23K0368/pom.xml @@ -32,5 +32,17 @@ 23K0368-p18 23K0368-p19 23K0368-p20 + 23K0368-p21 + 23K0368-p22 + 23K0368-p23 + 23K0368-p24 + 23K0368-p25 + 23K0368-p26 + 23K0368-p27 + 23K0368-p28 + 23K0368-p29 + 23K0368-p30 + 23K0368-p31 + 23K0368-p32