diff --git a/pom.xml b/pom.xml index b158edcd4..9242450d1 100644 --- a/pom.xml +++ b/pom.xml @@ -82,6 +82,7 @@ students/23K0755 students/23K1292 students/23L0908 + students/23K0342 diff --git a/students/23K0342/23K0342-p30_2/pom.xml b/students/23K0342/23K0342-p30_2/pom.xml new file mode 100644 index 000000000..dd0401e75 --- /dev/null +++ b/students/23K0342/23K0342-p30_2/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-p30_2 + Массивы + diff --git a/students/23K0342/23K0342-p30_2/src/main/java/ru/mirea/practice/s0000001/BinarySearchTree.java b/students/23K0342/23K0342-p30_2/src/main/java/ru/mirea/practice/s0000001/BinarySearchTree.java new file mode 100644 index 000000000..ad14b603c --- /dev/null +++ b/students/23K0342/23K0342-p30_2/src/main/java/ru/mirea/practice/s0000001/BinarySearchTree.java @@ -0,0 +1,115 @@ +package ru.mirea.practice.s0000001; + +class BinarySearchTree { + Node root; + + public BinarySearchTree() { + root = null; + } + + public void insert(int data) { + root = insertRec(root, data); + } + + private Node insertRec(Node root, int data) { + if (root == null) { + root = new Node(data); + return root; + } + + if (data < root.data) { + root.left = insertRec(root.left, data); + } else if (data > root.data) { + root.right = insertRec(root.right, data); + } + + return root; + } + + public void delete(int data) { + root = deleteRec(root, data); + } + + private Node deleteRec(Node root, int data) { + if (root == null) { + return root; + } + + if (data < root.data) { + root.left = deleteRec(root.left, data); + } else if (data > root.data) { + root.right = deleteRec(root.right, data); + } else { + + if (root.left == null) { + return root.right; + } else if (root.right == null) { + return root.left; + } + + root.data = minValue(root.right); + + root.right = deleteRec(root.right, root.data); + } + + return root; + } + + private int minValue(Node root) { + int minValue = root.data; + while (root.left != null) { + minValue = root.left.data; + root = root.left; + } + return minValue; + } + + public void printInOrder() { + printInOrderRec(root); + } + + private void printInOrderRec(Node root) { + if (root != null) { + printInOrderRec(root.left); + System.out.print(root.data + " "); + printInOrderRec(root.right); + } + } + + public void destroy() { + root = destroyRec(root); + } + + private Node destroyRec(Node root) { + if (root == null) { + return null; + } + root.left = destroyRec(root.left); + root.right = destroyRec(root.right); + root = null; + return root; + } + + public Node findMin() { + return findMinRec(root); + } + + private Node findMinRec(Node root) { + if (root == null || root.left == null) { + return root; + } + return findMinRec(root.left); + } + + public Node findMax() { + return findMaxRec(root); + } + + private Node findMaxRec(Node root) { + if (root == null || root.right == null) { + return root; + } + return findMaxRec(root.right); + } +} + diff --git a/students/23K0342/23K0342-p30_2/src/main/java/ru/mirea/practice/s0000001/BinarySearchTreeTest.java b/students/23K0342/23K0342-p30_2/src/main/java/ru/mirea/practice/s0000001/BinarySearchTreeTest.java new file mode 100644 index 000000000..26acdbe8b --- /dev/null +++ b/students/23K0342/23K0342-p30_2/src/main/java/ru/mirea/practice/s0000001/BinarySearchTreeTest.java @@ -0,0 +1,31 @@ +package ru.mirea.practice.s0000001; + +public abstract class BinarySearchTreeTest { + public static void main(String[] args) { + BinarySearchTree tree = new BinarySearchTree(); + + int[] nodes = {20, 8, 22, 4, 12, 10, 14, 25, 3, 7}; + for (int node : nodes) { + tree.insert(node); + } + + System.out.println("Содержимое дерева (in-order):"); + tree.printInOrder(); + System.out.println(); + + System.out.println("\nУдаление узла 10:"); + tree.delete(10); + + System.out.println("Содержимое дерева (in-order) после удаления:"); + tree.printInOrder(); + System.out.println(); + + System.out.println("\nУдаление дерева:"); + tree.destroy(); + + System.out.println("Содержимое дерева после полного удаления:"); + tree.printInOrder(); + System.out.println(); + } +} + diff --git a/students/23K0342/23K0342-p30_2/src/main/java/ru/mirea/practice/s0000001/Node.java b/students/23K0342/23K0342-p30_2/src/main/java/ru/mirea/practice/s0000001/Node.java new file mode 100644 index 000000000..bb5229742 --- /dev/null +++ b/students/23K0342/23K0342-p30_2/src/main/java/ru/mirea/practice/s0000001/Node.java @@ -0,0 +1,13 @@ +package ru.mirea.practice.s0000001; + +class Node { + int data; + Node left; + Node right; + + public Node(int item) { + data = item; + left = right = null; + } +} + diff --git a/students/23K0342/23K0342-p31/pom.xml b/students/23K0342/23K0342-p31/pom.xml new file mode 100644 index 000000000..a3065c748 --- /dev/null +++ b/students/23K0342/23K0342-p31/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-p31 + Массивы + diff --git a/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/FileManager.java b/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/FileManager.java new file mode 100644 index 000000000..194a3d8fe --- /dev/null +++ b/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/FileManager.java @@ -0,0 +1,43 @@ +package ru.mirea.practice.s0000001; + +import java.io.IOException; +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.BufferedWriter; +import java.io.FileWriter; +import java.util.List; +import java.io.File; + +final class FileManager { + private FileManager() { + throw new UnsupportedOperationException("Utility class"); + } + + public static void loadFromFile(String filename, TwoThreeTree tree) throws IOException { + File file = new File(filename); + if (!file.exists()) { + throw new IOException("Файл не найден: " + filename); + } + + try (BufferedReader reader = new BufferedReader(new FileReader(file))) { + String line; + while ((line = reader.readLine()) != null) { + String[] data = line.split(", "); + Processor processor = new Processor(Integer.parseInt(data[0]), data[1], Double.parseDouble(data[2]), + Integer.parseInt(data[3]), Double.parseDouble(data[4]), + Integer.parseInt(data[5]), Integer.parseInt(data[6])); + tree.insert(processor); + } + } + } + + public static void saveToFile(String filename, TwoThreeTree tree) throws IOException { + try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) { + List processors = tree.toList(); + for (Processor processor : processors) { + writer.write(processor.toString()); + writer.newLine(); + } + } + } +} diff --git a/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/Main.java b/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/Main.java new file mode 100644 index 000000000..386e407b2 --- /dev/null +++ b/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/Main.java @@ -0,0 +1,60 @@ +package ru.mirea.practice.s0000001; + +import java.io.IOException; +import java.util.Scanner; + +public abstract class Main { + private static TwoThreeTree tree = new TwoThreeTree(); + + public static void main(String[] args) { + try (Scanner scanner = new Scanner(System.in)) { + try { + FileManager.loadFromFile("/Users/viktoriapermakova/Desktop/PROCS.TXT", tree); + System.out.println("Данные загружены."); + } catch (IOException e) { + System.err.println("Ошибка загрузки данных: " + e.getMessage()); + } + + while (true) { + System.out.print("Введите команду (L, D n, A n, S, E): "); + String command = scanner.nextLine(); + + if ("L".equalsIgnoreCase(command)) { + tree.printTree(); + } else if (command.startsWith("D")) { + try { + int key = Integer.parseInt(command.split(" ")[1]); + tree.delete(key); + System.out.println("Запись с ключом " + key + " удалена."); + } catch (Exception e) { + System.err.println("Ошибка удаления: " + e.getMessage()); + } + } else if (command.startsWith("A")) { + try { + int key = Integer.parseInt(command.split(" ")[1]); + System.out.print("Введите данные процессора (название, тактовая частота, кеш, частота шины, SPECint, SPECfp): "); + String[] data = scanner.nextLine().split(", "); + Processor processor = new Processor(key, data[0], Double.parseDouble(data[1]), Integer.parseInt(data[2]), + Double.parseDouble(data[3]), Integer.parseInt(data[4]), Integer.parseInt(data[5])); + tree.insert(processor); + System.out.println("Запись добавлена: " + processor); + } catch (Exception e) { + System.err.println("Ошибка добавления: " + e.getMessage()); + } + } else if ("S".equalsIgnoreCase(command)) { + try { + FileManager.saveToFile("/Users/viktoriapermakova/Desktop/PROCS.TXT", tree); + System.out.println("Данные сохранены в файл."); + } catch (IOException e) { + System.err.println("Ошибка сохранения данных: " + e.getMessage()); + } + } else if ("E".equalsIgnoreCase(command)) { + break; + } else { + System.out.println("Неизвестная команда."); + } + } + } + } +} + diff --git a/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/Processor.java b/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/Processor.java new file mode 100644 index 000000000..ddba9e3c9 --- /dev/null +++ b/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/Processor.java @@ -0,0 +1,26 @@ +package ru.mirea.practice.s0000001; + +class Processor { + int key; + String name; + double clockSpeed; + int cacheSize; + double busFrequency; + int specInt; + int specFp; + + public Processor(int key, String name, double clockSpeed, int cacheSize, double busFrequency, int specInt, int specFp) { + this.key = key; + this.name = name; + this.clockSpeed = clockSpeed; + this.cacheSize = cacheSize; + this.busFrequency = busFrequency; + this.specInt = specInt; + this.specFp = specFp; + } + + @Override + public String toString() { + return key + ", " + name + ", " + clockSpeed + ", " + cacheSize + ", " + busFrequency + ", " + specInt + ", " + specFp; + } +} diff --git a/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/TwoThreeTree.java b/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/TwoThreeTree.java new file mode 100644 index 000000000..d8eb86faa --- /dev/null +++ b/students/23K0342/23K0342-p31/src/main/java/ru/mirea/practice/s0000001/TwoThreeTree.java @@ -0,0 +1,174 @@ +package ru.mirea.practice.s0000001; + +import java.util.ArrayList; +import java.util.List; + +class TwoThreeTree { + class Node { + List keys = new ArrayList<>(); + List children = new ArrayList<>(); + Processor processor; + boolean isLeaf; + + Node(Processor processor) { + this.processor = processor; + this.keys.add(processor.key); + this.isLeaf = true; + } + + Node(int key) { + this.keys.add(key); + } + + @Override + public String toString() { + if (isLeaf) { + return String.valueOf(keys.get(0)); + } else if (keys.size() == 1) { + return keys.get(0) + " -"; + } else { + return keys.get(0) + " " + keys.get(1); + } + } + } + + Node root; + + public void insert(Processor processor) { + if (root == null) { + root = new Node(processor); + } else { + Node newRoot = insertRecursive(root, processor); + if (newRoot != null) { + Node oldRoot = root; + root = new Node(newRoot.keys.get(0)); + root.children.add(oldRoot); + root.children.add(newRoot); + root.isLeaf = false; + } + } + } + + private Node insertRecursive(Node node, Processor processor) { + if (node.isLeaf) { + node.keys.add(processor.key); + node.keys.sort(Integer::compareTo); + + if (node.keys.size() > 2) { + return splitNode(node); + } + return null; + } else { + int key = processor.key; + + Node child; + if (key < node.keys.get(0)) { + child = node.children.get(0); + } else if (node.keys.size() == 1 || key < node.keys.get(1)) { + child = node.children.get(1); + } else { + child = node.children.get(2); + } + + Node newChild = insertRecursive(child, processor); + if (newChild != null) { + node.keys.add(newChild.keys.get(0)); + node.keys.sort(Integer::compareTo); + node.children.add(node.children.indexOf(child) + 1, newChild); + + if (node.keys.size() > 2) { + return splitNode(node); + } + } + return null; + } + } + + private Node splitNode(Node node) { + Node newNode = new Node(node.keys.get(2)); + newNode.isLeaf = node.isLeaf; + + if (!node.isLeaf) { + newNode.children.add(node.children.remove(2)); + newNode.children.add(node.children.remove(2)); + } + + node.keys.remove(2); + return newNode; + } + + public void printTree() { + if (root == null) { + System.out.println("Дерево пустое."); + return; + } + printTreeRecursively(root); + } + + private void printTreeRecursively(Node node) { + if (node == null) { + return; + } + System.out.println(node); + for (Node child : node.children) { + printTreeRecursively(child); + } + } + + public void delete(int key) { + root = deleteRecursive(root, key); + } + + private Node deleteRecursive(Node node, int key) { + if (node == null) { + System.out.println("Запись с ключом " + key + " не найдена."); + return null; + } + + if (node.isLeaf) { + if (node.keys.contains(key)) { + node.keys.remove(Integer.valueOf(key)); + if (node.keys.isEmpty()) { + return null; + } + } else { + System.out.println("Запись с ключом " + key + " не найдена."); + } + return node; + } + + if (key < node.keys.get(0)) { + Node child = deleteRecursive(node.children.get(0), key); + node.children.set(0, child); + } else if (node.keys.size() == 1 || key < node.keys.get(1)) { + Node child = deleteRecursive(node.children.get(1), key); + node.children.set(1, child); + } else { + Node child = deleteRecursive(node.children.get(2), key); + node.children.set(2, child); + } + return node; + } + + public List toList() { + List result = new ArrayList<>(); + collectProcessors(root, result); + return result; + } + + private void collectProcessors(Node node, List result) { + if (node == null) { + return; + } + + if (node.isLeaf) { + if (node.processor != null) { + result.add(node.processor); + } + } + + for (Node child : node.children) { + collectProcessors(child, result); + } + } +} diff --git a/students/23K0342/23K0342-p32/pom.xml b/students/23K0342/23K0342-p32/pom.xml new file mode 100644 index 000000000..b4d9f689d --- /dev/null +++ b/students/23K0342/23K0342-p32/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-p32 + Массивы + diff --git a/students/23K0342/23K0342-p32/src/main/java/ru/mirea/practice/s0000001/JohnsonTrotter.java b/students/23K0342/23K0342-p32/src/main/java/ru/mirea/practice/s0000001/JohnsonTrotter.java new file mode 100644 index 000000000..702c4b247 --- /dev/null +++ b/students/23K0342/23K0342-p32/src/main/java/ru/mirea/practice/s0000001/JohnsonTrotter.java @@ -0,0 +1,74 @@ +package ru.mirea.practice.s0000001; + +public abstract class JohnsonTrotter { + + public static void printPermutation(int[] permutation) { + for (int num : permutation) { + System.out.print(num + " "); + } + System.out.println(); + } + + public static void generatePermutations(int n) { + int[] permutation = new int[n]; + int[] direction = new int[n]; + + for (int i = 0; i < n; i++) { + permutation[i] = i + 1; + direction[i] = 0; + } + + printPermutation(permutation); + + boolean hasNext = true; + while (hasNext) { + int largestMobile = -1; + int largestMobileIndex = -1; + + for (int i = 0; i < n; i++) { + if (direction[i] == 0 && i > 0 && permutation[i] > permutation[i - 1] + || direction[i] == 1 && i < n - 1 && permutation[i] > permutation[i + 1]) { + + if (permutation[i] > largestMobile) { + largestMobile = permutation[i]; + largestMobileIndex = i; + } + } + } + + if (largestMobile == -1) { + hasNext = false; + } else { + int index = largestMobileIndex; + int temp = permutation[index]; + + + if (direction[index] == 0) { + permutation[index] = permutation[index - 1]; + permutation[index - 1] = temp; + direction[index] = 1; + direction[index - 1] = 0; + } else { + permutation[index] = permutation[index + 1]; + permutation[index + 1] = temp; + direction[index] = 0; + direction[index + 1] = 1; + } + + for (int i = 0; i < n; i++) { + if (permutation[i] > largestMobile) { + direction[i] = 1 - direction[i]; + } + } + + printPermutation(permutation); + } + } + } + + public static void main(String[] args) { + int n = 3; + generatePermutations(n); + } +} + diff --git a/students/23K0342/23K0342-pr21/pom.xml b/students/23K0342/23K0342-pr21/pom.xml new file mode 100644 index 000000000..d7df3bb06 --- /dev/null +++ b/students/23K0342/23K0342-pr21/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-pr21 + Массивы + diff --git a/students/23K0342/23K0342-pr21/src/main/java/ru/mirea/practice/s0000001/Converter.java b/students/23K0342/23K0342-pr21/src/main/java/ru/mirea/practice/s0000001/Converter.java new file mode 100644 index 000000000..338e888f0 --- /dev/null +++ b/students/23K0342/23K0342-pr21/src/main/java/ru/mirea/practice/s0000001/Converter.java @@ -0,0 +1,21 @@ +package ru.mirea.practice.s0000001; + +import java.util.Arrays; +import java.util.List; + +public abstract class Converter { + public static List convertArrayToList(T[] array) { + return Arrays.asList(array); + } + + public static void main(String[] args) { + String[] stringArray = {"a", "b", "c"}; + List stringList = convertArrayToList(stringArray); + System.out.println("Список строк: " + stringList); + + Integer[] intArray = {1, 2, 3}; + List intList = convertArrayToList(intArray); + System.out.println("Список чисел: " + intList); + } +} +// diff --git a/students/23K0342/23K0342-pr21/src/main/java/t2/Array.java b/students/23K0342/23K0342-pr21/src/main/java/t2/Array.java new file mode 100644 index 000000000..8b8ff02f6 --- /dev/null +++ b/students/23K0342/23K0342-pr21/src/main/java/t2/Array.java @@ -0,0 +1,53 @@ +package ru.mirea.practice.s0000001.t2; + +public class Array { + private T[] elements; + + public Array(T[] elements) { + this.elements = elements; + } + + public T get(int index) { + if (index >= 0 && index < elements.length) { + return elements[index]; + } else { + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + elements.length); + } + } + + public void set(int index, T element) { + if (index >= 0 && index < elements.length) { + elements[index] = element; + } else { + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + elements.length); + } + } + + public int size() { + return elements.length; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("["); + for (int i = 0; i < elements.length; i++) { + sb.append(elements[i]); + if (i < elements.length - 1) { + sb.append(", "); + } + } + sb.append("]"); + return sb.toString(); + } + + public static void main(String[] args) { + Integer[] intArray = {1, 2, 3, 4, 5}; + Array intStorage = new Array<>(intArray); + System.out.println("Integer array: " + intStorage); + + String[] stringArray = {"СТОЛ", "СТУЛ", "ЗОНТ"}; + Array stringStorage = new Array<>(stringArray); + System.out.println("String array: " + stringStorage); + } +} +// diff --git a/students/23K0342/23K0342-pr22/pom.xml b/students/23K0342/23K0342-pr22/pom.xml new file mode 100644 index 000000000..9c5ef4d1c --- /dev/null +++ b/students/23K0342/23K0342-pr22/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-pr22 + Массивы + diff --git a/students/23K0342/23K0342-pr22/src/main/java/ru/mirea/practice/s0000001/Calculator.java b/students/23K0342/23K0342-pr22/src/main/java/ru/mirea/practice/s0000001/Calculator.java new file mode 100644 index 000000000..f7dd2a217 --- /dev/null +++ b/students/23K0342/23K0342-pr22/src/main/java/ru/mirea/practice/s0000001/Calculator.java @@ -0,0 +1,63 @@ +package ru.mirea.practice.s0000001; + +import java.util.Stack; + +public class Calculator { + private Stack stack; + + public Calculator() { + stack = new Stack<>(); + } + + public double evaluate(String expression) { + stack.clear(); + String[] tokens = expression.split(" "); + for (String token : tokens) { + if (isOperator(token)) { + if (stack.size() < 2) { + throw new ArrayIndexOutOfBoundsException("Ошибка: недостаточно данных для операции"); + } + double b = stack.pop(); + double a = stack.pop(); + stack.push(applyOperator(a, b, token)); + } else { + try { + stack.push(Double.parseDouble(token)); + } catch (NumberFormatException e) { + throw new IllegalArgumentException("Ошибка: неверный формат числа", e); + } + } + } + if (stack.size() != 1) { + throw new IllegalStateException("Ошибка: выражение некорректно"); + } + return stack.pop(); + } + + private boolean isOperator(String token) { + return "+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token); + } + + private double applyOperator(double a, double b, String operator) { + try { + switch (operator) { + case "+": + return a + b; + case "-": + return a - b; + case "*": + return a * b; + case "/": + if (b == 0) { + throw new ArithmeticException("Ошибка: деление на ноль"); + } + return a / b; + default: + throw new IllegalArgumentException("Ошибка: неизвестная операция " + operator); + } + } catch (ArithmeticException | IllegalArgumentException e) { + throw e; + } + } +} +// diff --git a/students/23K0342/23K0342-pr22/src/main/java/ru/mirea/practice/s0000001/Rpn.java b/students/23K0342/23K0342-pr22/src/main/java/ru/mirea/practice/s0000001/Rpn.java new file mode 100644 index 000000000..7e145a54c --- /dev/null +++ b/students/23K0342/23K0342-pr22/src/main/java/ru/mirea/practice/s0000001/Rpn.java @@ -0,0 +1,94 @@ +package ru.mirea.practice.s0000001; + +import javax.swing.JButton; +import javax.swing.JFrame; +import javax.swing.JPanel; +import javax.swing.JTextField; +import java.awt.BorderLayout; +import java.awt.Dimension; +import java.awt.Font; +import java.awt.GridLayout; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import javax.swing.SwingUtilities; + +public class Rpn extends JFrame { + private JTextField display; + private Calculator calculator; + + public Rpn() { + calculator = new Calculator(); + display = new JTextField(); + display.setEditable(false); + display.setFont(new Font("Arial", Font.PLAIN, 24)); + setLayout(new BorderLayout()); + add(display, BorderLayout.NORTH); + + JPanel panel = new JPanel(new GridLayout(5, 4, 5, 5)); + String[] buttons = { + "7", "8", "9", "/", + "4", "5", "6", "*", + "1", "2", "3", "-", + "0", ".", "=", "+", + "C", "Space", "", "" + }; + + for (String text : buttons) { + JButton button = new JButton(text); + button.setFont(new Font("Arial", Font.PLAIN, 18)); + if ("Space".equals(text)) { // Литерал теперь идет первым + button.setPreferredSize(new Dimension(80, 50)); + } + button.addActionListener(new ButtonClickListener()); + panel.add(button); + } + add(panel, BorderLayout.CENTER); + + setTitle("RPN Calculator"); + setSize(400, 500); + setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + setLocationRelativeTo(null); + } + + private class ButtonClickListener implements ActionListener { + @Override + public void actionPerformed(ActionEvent e) { + String command = e.getActionCommand(); + switch (command) { + case "=": + try { + double result = calculator.evaluate(display.getText().trim()); + display.setText(String.valueOf(result)); + } catch (ArithmeticException ex) { + display.setText("Ошибка: деление на ноль"); + } catch (NumberFormatException ex) { + display.setText("Ошибка: неверный формат числа"); + } catch (ArrayIndexOutOfBoundsException ex) { + display.setText("Ошибка: недостаточно данных для операции"); + } catch (IllegalStateException ex) { + display.setText("Ошибка: выражение некорректно"); + } catch (Exception ex) { + display.setText("Неизвестная ошибка: " + ex.getMessage()); + } + break; + case "C": + display.setText(""); + break; + case "Space": + display.setText(display.getText() + " "); + break; + default: + display.setText(display.getText() + command); + break; + } + } + } + + public static void main(String[] args) { + SwingUtilities.invokeLater(() -> { + Rpn calc = new Rpn(); + calc.setVisible(true); + }); + } +} +// diff --git a/students/23K0342/23K0342-pr23/pom.xml b/students/23K0342/23K0342-pr23/pom.xml new file mode 100644 index 000000000..3cd0dd2cf --- /dev/null +++ b/students/23K0342/23K0342-pr23/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-pr23 + Массивы + diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueue.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueue.java new file mode 100644 index 000000000..83afade3a --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueue.java @@ -0,0 +1,56 @@ +package ru.mirea.practice.s0000001.task1; + +public class ArrayQueue { + private Object[] elements; + private int size; + private int front; + private int rear; + + public ArrayQueue() { + elements = new Object[10]; + size = 0; + front = 0; + rear = 0; + } + + public void enqueue(Object element) { + if (size == elements.length) { + throw new IllegalStateException("Queue is full"); + } + elements[rear] = element; + rear = (rear + 1) % elements.length; + size++; + } + + public Object element() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + return elements[front]; + } + + public Object dequeue() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + Object result = elements[front]; + front = (front + 1) % elements.length; + size--; + return result; + } + + public int size() { + return size; + } + + public boolean isEmpty() { + return size == 0; + } + + public void clear() { + size = 0; + front = 0; + rear = 0; + } +} + diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueAdT.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueAdT.java new file mode 100644 index 000000000..8ce6985cc --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueAdT.java @@ -0,0 +1,57 @@ +package ru.mirea.practice.s0000001.task1; + +public class ArrayQueueAdT { + private Object[] elements; + private int size; + private int front; + private int rear; + + public ArrayQueueAdT() { + elements = new Object[10]; + size = 0; + front = 0; + rear = 0; + } + + public void enqueue(Object element) { + if (size == elements.length) { + throw new IllegalStateException("Queue is full"); + } + elements[rear] = element; + rear = (rear + 1) % elements.length; + size++; + } + + public Object element() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + return elements[front]; + } + + public Object dequeue() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + Object result = elements[front]; + front = (front + 1) % elements.length; + size--; + return result; + } + + public int size() { + return size; + } + + public boolean isEmpty() { + return size == 0; + } + + public void clear() { + size = 0; + front = 0; + rear = 0; + } +} +// + diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueAdTtest.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueAdTtest.java new file mode 100644 index 000000000..41af58adb --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueAdTtest.java @@ -0,0 +1,21 @@ +package ru.mirea.practice.s0000001.task1; + +public abstract class ArrayQueueAdTtest { + public static void main(String[] args) { + ArrayQueueAdT queue = new ArrayQueueAdT(); + + queue.enqueue(1); + queue.enqueue(2); + queue.enqueue(3); + + System.out.println(queue.dequeue()); + System.out.println(queue.element()); + System.out.println(queue.size()); + + queue.clear(); + System.out.println(queue.isEmpty()); + } +} + +// + diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueModule.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueModule.java new file mode 100644 index 000000000..657bde07e --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueModule.java @@ -0,0 +1,58 @@ +package ru.mirea.practice.s0000001.task1; + +public abstract class ArrayQueueModule { + private static final int DEFAULT_CAPACITY = 10; + private static Object[] elements; + private static int size; + private static int front; + private static int rear; + + static { + elements = new Object[DEFAULT_CAPACITY]; + size = 0; + front = 0; + rear = 0; + } + + public static void enqueue(Object element) { + if (size == elements.length) { + throw new IllegalStateException("Queue is full"); + } + elements[rear] = element; + rear = (rear + 1) % elements.length; + size++; + } + + public static Object element() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + return elements[front]; + } + + public static Object dequeue() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + Object result = elements[front]; + front = (front + 1) % elements.length; + size--; + return result; + } + + public static int size() { + return size; + } + + public static boolean isEmpty() { + return size == 0; + } + + public static void clear() { + size = 0; + front = 0; + rear = 0; + } +} +// + diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueModuleTest.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueModuleTest.java new file mode 100644 index 000000000..d29a9568e --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueModuleTest.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s0000001.task1; + +public abstract class ArrayQueueModuleTest { + public static void main(String[] args) { + ArrayQueueModule.enqueue(1); + ArrayQueueModule.enqueue(2); + ArrayQueueModule.enqueue(3); + + System.out.println(ArrayQueueModule.dequeue()); // 1 + System.out.println(ArrayQueueModule.element()); // 2 + System.out.println(ArrayQueueModule.size()); // 2 + + ArrayQueueModule.clear(); + System.out.println(ArrayQueueModule.isEmpty()); // true + } +} +// + diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueTest.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueTest.java new file mode 100644 index 000000000..687725b63 --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task1/ArrayQueueTest.java @@ -0,0 +1,20 @@ +package ru.mirea.practice.s0000001.task1; + +public abstract class ArrayQueueTest { + public static void main(String[] args) { + ArrayQueue queue = new ArrayQueue(); + + queue.enqueue(1); + queue.enqueue(2); + queue.enqueue(3); + + System.out.println(queue.dequeue()); // 1 + System.out.println(queue.element()); // 2 + System.out.println(queue.size()); // 2 + + queue.clear(); + System.out.println(queue.isEmpty()); // true + } +} +// + diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/AbstractQueue.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/AbstractQueue.java new file mode 100644 index 000000000..2b0db4d59 --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/AbstractQueue.java @@ -0,0 +1,22 @@ +package ru.mirea.practice.s0000001.task2; + +public abstract class AbstractQueue implements Queue { + protected int size; + + @Override + public int size() { + return size; + } + + @Override + public boolean isEmpty() { + return size == 0; + } + + @Override + public void clear() { + size = 0; + } +} +// + diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/ArrayQueue.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/ArrayQueue.java new file mode 100644 index 000000000..b1954112b --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/ArrayQueue.java @@ -0,0 +1,47 @@ +package ru.mirea.practice.s0000001.task2; + +public class ArrayQueue extends AbstractQueue { + private Object[] elements; + private int front; + private int rear; + + private static final int DEFAULT_CAPACITY = 10; + + public ArrayQueue() { + elements = new Object[DEFAULT_CAPACITY]; + size = 0; + front = 0; + rear = 0; + } + + @Override + public void enqueue(Object element) { + if (size == elements.length) { + throw new IllegalStateException("Queue is full"); + } + elements[rear] = element; + rear = (rear + 1) % elements.length; + size++; + } + + @Override + public Object dequeue() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + + final Object result = elements[front]; + front = (front + 1) % elements.length; + size--; + return result; + } + + @Override + public Object element() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + return elements[front]; + } +} +// diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/ArrayQueueTest.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/ArrayQueueTest.java new file mode 100644 index 000000000..27a5baf3c --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/ArrayQueueTest.java @@ -0,0 +1,20 @@ +package ru.mirea.practice.s0000001.task2; + +public abstract class ArrayQueueTest { + public static void main(String[] args) { + ArrayQueue queue = new ArrayQueue(); + + queue.enqueue(1); + queue.enqueue(2); + queue.enqueue(3); + + System.out.println(queue.dequeue()); + System.out.println(queue.element()); + System.out.println(queue.size()); + + queue.clear(); + System.out.println(queue.isEmpty()); + } +} +// + diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/LinkedQueue.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/LinkedQueue.java new file mode 100644 index 000000000..7230f3f4f --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/LinkedQueue.java @@ -0,0 +1,53 @@ +package ru.mirea.practice.s0000001.task2; + +public class LinkedQueue extends AbstractQueue { + private Node head; + private Node tail; + + private static class Node { + Object value; + Node next; + + Node(Object value) { + this.value = value; + } + } + + @Override + public void enqueue(Object element) { + Node newNode = new Node(element); + if (tail == null) { + head = newNode; + tail = newNode; + } else { + tail.next = newNode; + tail = newNode; + } + size++; + } + + @Override + public Object dequeue() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + + final Object result = head.value; + head = head.next; + + if (head == null) { + tail = null; + } + size--; + return result; + } + + @Override + public Object element() { + if (isEmpty()) { + throw new IllegalStateException("Queue is empty"); + } + return head.value; + } +} +// diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/LinkedQueueTest.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/LinkedQueueTest.java new file mode 100644 index 000000000..9fd9e6bb9 --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/LinkedQueueTest.java @@ -0,0 +1,20 @@ +package ru.mirea.practice.s0000001.task2; + +public abstract class LinkedQueueTest { + public static void main(String[] args) { + LinkedQueue queue = new LinkedQueue(); + + queue.enqueue(1); + queue.enqueue(2); + queue.enqueue(3); + + System.out.println(queue.dequeue()); + System.out.println(queue.element()); + System.out.println(queue.size()); + + queue.clear(); + System.out.println(queue.isEmpty()); + } +} +// + diff --git a/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/Queue.java b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/Queue.java new file mode 100644 index 000000000..7afe843d0 --- /dev/null +++ b/students/23K0342/23K0342-pr23/src/main/java/ru/mirea/practice/s0000001/task2/Queue.java @@ -0,0 +1,16 @@ +package ru.mirea.practice.s0000001.task2; + +public interface Queue { + void enqueue(Object element); + + Object dequeue(); + + Object element(); + + int size(); + + boolean isEmpty(); + + void clear(); +} +// diff --git a/students/23K0342/23K0342-pr24/pom.xml b/students/23K0342/23K0342-pr24/pom.xml new file mode 100644 index 000000000..babd7f4be --- /dev/null +++ b/students/23K0342/23K0342-pr24/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-pr24 + Массивы + diff --git a/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/Complex.java b/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/Complex.java new file mode 100644 index 000000000..3a9ae3136 --- /dev/null +++ b/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/Complex.java @@ -0,0 +1,26 @@ +package ru.mirea.practice.s0000001.task1; + +public class Complex { + private int real; + private int imaginary; + + public Complex(int real, int imaginary) { + this.real = real; + this.imaginary = imaginary; + } + + public int getReal() { + return real; + } + + public int getImaginary() { + return imaginary; + } + + @Override + public String toString() { + return real + " + " + imaginary + "i"; + } +} +// + diff --git a/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/ComplexAbstractFactory.java b/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/ComplexAbstractFactory.java new file mode 100644 index 000000000..bb04879bc --- /dev/null +++ b/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/ComplexAbstractFactory.java @@ -0,0 +1,10 @@ +package ru.mirea.practice.s0000001.task1; + +public interface ComplexAbstractFactory { + + Complex createComplex(); + + Complex createComplex(int real, int imaginary); +} +// + diff --git a/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/ConcreteFactory.java b/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/ConcreteFactory.java new file mode 100644 index 000000000..64ce90854 --- /dev/null +++ b/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/ConcreteFactory.java @@ -0,0 +1,15 @@ +package ru.mirea.practice.s0000001.task1; + +public class ConcreteFactory implements ComplexAbstractFactory { + + @Override + public Complex createComplex() { + return new Complex(0, 0); + } + + @Override + public Complex createComplex(int real, int imaginary) { + return new Complex(real, imaginary); + } +} +// diff --git a/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/Use.java b/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/Use.java new file mode 100644 index 000000000..fdfae3273 --- /dev/null +++ b/students/23K0342/23K0342-pr24/src/main/java/ru/mirea/practice/s0000001/task1/Use.java @@ -0,0 +1,15 @@ +package ru.mirea.practice.s0000001.task1; + +public abstract class Use { + public static void main(String[] args) { + ComplexAbstractFactory factory = new ConcreteFactory(); + + Complex defaultComplex = factory.createComplex(); + System.out.println("Default complex number: " + defaultComplex); + + Complex customComplex = factory.createComplex(5, 3); + System.out.println("Custom complex number: " + customComplex); + } +} +// + diff --git a/students/23K0342/23K0342-pr25/pom.xml b/students/23K0342/23K0342-pr25/pom.xml new file mode 100644 index 000000000..b4a6bf97c --- /dev/null +++ b/students/23K0342/23K0342-pr25/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-pr25 + Массивы + diff --git a/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/DateValidator.java b/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/DateValidator.java new file mode 100644 index 000000000..42357f407 --- /dev/null +++ b/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/DateValidator.java @@ -0,0 +1,23 @@ +package ru.mirea.practice.s0000001; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public abstract class DateValidator { + 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 dateRegex = "^(0[1-9]|[12][0-9]|3[01])/(0[1-9]|1[0-2])/(19|20)\\d{2}$"; + Pattern pattern = Pattern.compile(dateRegex); + + System.out.println("Проверка дат в формате dd/mm/yyyy:"); + for (String date : dates) { + Matcher matcher = pattern.matcher(date); + System.out.println(date + ": " + matcher.matches()); + } + } +} +// diff --git a/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/EmailChecker.java b/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/EmailChecker.java new file mode 100644 index 000000000..3845ea36c --- /dev/null +++ b/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/EmailChecker.java @@ -0,0 +1,30 @@ +package ru.mirea.practice.s0000001; + +import java.util.regex.Pattern; + +public abstract class EmailChecker { + private static final String EMAIL_REGEX = + "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"; + + private static final Pattern EMAIL_PATTERN = Pattern.compile(EMAIL_REGEX); + + public static boolean isValidEmail(String email) { + if (email == null) { + return false; + } + return EMAIL_PATTERN.matcher(email).matches(); + } + + public static void main(String[] args) { + String[] testEmails = { + "test@mail.ru", + "name.test@gmail.com", + "invalid-email@" + }; + + for (String email : testEmails) { + System.out.printf("Email: %s подходит ли: %b%n", email, isValidEmail(email)); + } + } +} +// diff --git a/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/Main.java b/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/Main.java new file mode 100644 index 000000000..6d75ba81e --- /dev/null +++ b/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/Main.java @@ -0,0 +1,13 @@ +package ru.mirea.practice.s0000001; + +public final class Main { + + private Main() { + + } + + public static void main(String[] args) { + System.out.println("первая практическая работа!"); + } +} +// diff --git a/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/PriceExtractor.java b/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/PriceExtractor.java new file mode 100644 index 000000000..d4a142b5c --- /dev/null +++ b/students/23K0342/23K0342-pr25/src/main/java/ru/mirea/practice/s0000001/PriceExtractor.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s0000001; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public abstract class PriceExtractor { + public static void main(String[] args) { + String text = "Цены: 25.98 USD, 44 ERR, 0.004 EU, 10.00 RUB, 99.95 EUR"; + Pattern pattern = Pattern.compile("\\b\\d{1,3}(\\.\\d{1,2})? (USD|RUB|EUR)\\b"); + Matcher matcher = pattern.matcher(text); + + System.out.println("Цены в USD, RUB, EUR:"); + while (matcher.find()) { + System.out.println(matcher.group()); + } + } +} +// diff --git a/students/23K0342/23K0342-pr26/pom.xml b/students/23K0342/23K0342-pr26/pom.xml new file mode 100644 index 000000000..8a89df219 --- /dev/null +++ b/students/23K0342/23K0342-pr26/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-pr26 + Массивы + diff --git a/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/ArrayInverter.java b/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/ArrayInverter.java new file mode 100644 index 000000000..21fad10ec --- /dev/null +++ b/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/ArrayInverter.java @@ -0,0 +1,34 @@ +package ru.mirea.practice.s0000001; + +import java.util.Stack; + +public abstract class ArrayInverter { + public static void invertArray(int[] array) { + Stack stack = new Stack<>(); + + for (int element : array) { + stack.push(element); + } + + for (int i = 0; i < array.length; i++) { + array[i] = stack.pop(); + } + } + + public static void main(String[] args) { + int[] array = {1, 2, 3, 4, 5}; + + System.out.println("Исходный массив:"); + for (int num : array) { + System.out.print(num + " "); + } + + invertArray(array); + + System.out.println("\nИнвертированный массив:"); + for (int num : array) { + System.out.print(num + " "); + } + } +} +// diff --git a/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/CustomList.java b/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/CustomList.java new file mode 100644 index 000000000..293cc2e51 --- /dev/null +++ b/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/CustomList.java @@ -0,0 +1,53 @@ +package ru.mirea.practice.s0000001; + +import java.util.Arrays; +import java.util.Iterator; +import java.util.NoSuchElementException; + +public class CustomList implements Iterable { + private Object[] elements; + private int size; + + public CustomList() { + elements = new Object[10]; + size = 0; + } + + public void add(T element) { + if (size == elements.length) { + resize(); + } + elements[size++] = element; + } + + private void resize() { + elements = Arrays.copyOf(elements, elements.length * 2); + } + + public int size() { + return size; + } + + @Override + public Iterator iterator() { + return new CustomIterator(); + } + + private class CustomIterator implements Iterator { + private int currentIndex = 0; + + @Override + public boolean hasNext() { + return currentIndex < size; + } + + @Override + public T next() { + if (!hasNext()) { + throw new NoSuchElementException("Нет больше элементов в итераторе."); + } + return (T) elements[currentIndex++]; + } + } +} +// diff --git a/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/Main.java b/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/Main.java new file mode 100644 index 000000000..6d75ba81e --- /dev/null +++ b/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/Main.java @@ -0,0 +1,13 @@ +package ru.mirea.practice.s0000001; + +public final class Main { + + private Main() { + + } + + public static void main(String[] args) { + System.out.println("первая практическая работа!"); + } +} +// diff --git a/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/TestCustomList.java b/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/TestCustomList.java new file mode 100644 index 000000000..2b837d87d --- /dev/null +++ b/students/23K0342/23K0342-pr26/src/main/java/ru/mirea/practice/s0000001/TestCustomList.java @@ -0,0 +1,16 @@ +package ru.mirea.practice.s0000001; + +public abstract class TestCustomList { + public static void main(String[] args) { + CustomList list = new CustomList<>(); + list.add("Первый"); + list.add("Второй"); + list.add("Третий"); + + System.out.println("Элементы списка:"); + for (String item : list) { + System.out.println(item); + } + } +} +// diff --git a/students/23K0342/23K0342-pr27/pom.xml b/students/23K0342/23K0342-pr27/pom.xml new file mode 100644 index 000000000..6744807ab --- /dev/null +++ b/students/23K0342/23K0342-pr27/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-pr27 + Массивы + diff --git a/students/23K0342/23K0342-pr27/src/main/java/ru/mirea/practice/s0000001/HashTab.java b/students/23K0342/23K0342-pr27/src/main/java/ru/mirea/practice/s0000001/HashTab.java new file mode 100644 index 000000000..3b99861e6 --- /dev/null +++ b/students/23K0342/23K0342-pr27/src/main/java/ru/mirea/practice/s0000001/HashTab.java @@ -0,0 +1,67 @@ +package ru.mirea.practice.s0000001; + +import java.util.LinkedList; + +public class HashTab { + private static final int SIZE = 10; + private LinkedList[] table; + + private static class Entry { + String key; + String value; + + Entry(String key, String value) { + this.key = key; + this.value = value; + } + } + + public void hashtabInit() { + table = new LinkedList[SIZE]; + for (int i = 0; i < SIZE; i++) { + table[i] = new LinkedList<>(); + } + } + + private int hashtabHash(String key) { + return Math.abs(key.hashCode() % SIZE); + } + + public void hashtabAdd(String key, String value) { + int index = hashtabHash(key); + for (Entry entry : table[index]) { + if (entry.key.equals(key)) { + entry.value = value; + return; + } + } + table[index].add(new Entry(key, value)); + } + + public String hashtabLookup(String key) { + int index = hashtabHash(key); + for (Entry entry : table[index]) { + if (entry.key.equals(key)) { + return entry.value; + } + } + return null; + } + + public void hashtabDelete(String key) { + int index = hashtabHash(key); + table[index].removeIf(entry -> entry.key.equals(key)); + } + + public void printTable() { + for (int i = 0; i < SIZE; i++) { + System.out.print("Index " + i + ": "); + for (Entry entry : table[i]) { + System.out.print("[" + entry.key + " -> " + entry.value + "] "); + } + System.out.println(); + } + } +} +// + diff --git a/students/23K0342/23K0342-pr27/src/main/java/ru/mirea/practice/s0000001/Main.java b/students/23K0342/23K0342-pr27/src/main/java/ru/mirea/practice/s0000001/Main.java new file mode 100644 index 000000000..266fe472d --- /dev/null +++ b/students/23K0342/23K0342-pr27/src/main/java/ru/mirea/practice/s0000001/Main.java @@ -0,0 +1,24 @@ +package ru.mirea.practice.s0000001; + +public abstract class Main { + public static void main(String[] args) { + HashTab hashtable = new HashTab(); + hashtable.hashtabInit(); + + hashtable.hashtabAdd("апельсин", "фрукты"); + hashtable.hashtabAdd("огурец", "овощи"); + hashtable.hashtabAdd("мандарин", "фрукты"); + + System.out.println("Поиск 'апельсин': " + hashtable.hashtabLookup("апельсин")); + System.out.println("Поиск 'огурец': " + hashtable.hashtabLookup("огурец")); + System.out.println("Поиск 'мандарин': " + hashtable.hashtabLookup("мандарин")); + + hashtable.printTable(); + + hashtable.hashtabDelete("огурец"); + System.out.println("После удаления 'огурец':"); + hashtable.printTable(); + } +} +// + diff --git a/students/23K0342/23K0342-pr28/pom.xml b/students/23K0342/23K0342-pr28/pom.xml new file mode 100644 index 000000000..7739ce79d --- /dev/null +++ b/students/23K0342/23K0342-pr28/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-pr28 + Массивы + diff --git a/students/23K0342/23K0342-pr28/src/main/java/ru/mirea/practice/s0000001/Main.java b/students/23K0342/23K0342-pr28/src/main/java/ru/mirea/practice/s0000001/Main.java new file mode 100644 index 000000000..499aa4a80 --- /dev/null +++ b/students/23K0342/23K0342-pr28/src/main/java/ru/mirea/practice/s0000001/Main.java @@ -0,0 +1,23 @@ +package ru.mirea.practice.s0000001; + +import java.util.HashSet; +import java.util.TreeSet; + +public abstract class Main { + public static void main(String[] args) { + HashSet hashSet = new HashSet<>(); + hashSet.add("апельсин"); + hashSet.add("манадрин"); + hashSet.add("груша"); + hashSet.add("лимон"); + + TreeSet treeSet = new TreeSet<>(hashSet); + + System.out.println("Элементы TreeSet (упорядочены):"); + for (String item : treeSet) { + System.out.println(item); + } + } +} +// + diff --git a/students/23K0342/23K0342-pr29/pom.xml b/students/23K0342/23K0342-pr29/pom.xml new file mode 100644 index 000000000..8e0949765 --- /dev/null +++ b/students/23K0342/23K0342-pr29/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-pr29 + Массивы + diff --git a/students/23K0342/23K0342-pr29/src/main/java/ru/mirea/practice/s0000001/Milky.java b/students/23K0342/23K0342-pr29/src/main/java/ru/mirea/practice/s0000001/Milky.java new file mode 100644 index 000000000..41c50173f --- /dev/null +++ b/students/23K0342/23K0342-pr29/src/main/java/ru/mirea/practice/s0000001/Milky.java @@ -0,0 +1,37 @@ +package ru.mirea.practice.s0000001; + +import java.util.Scanner; + +public abstract class Milky { + public static void main(String[] args) { + try (Scanner scanner = new Scanner(System.in)) { + int n = scanner.nextInt(); + + if (n == 0) { + System.out.println(0); + return; + } + + int[][] matrix = new int[n][n]; + + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + matrix[i][j] = scanner.nextInt(); + } + } + + int roadCount = 0; + for (int i = 0; i < n; i++) { + for (int j = i + 1; j < n; j++) { + if (matrix[i][j] == 1) { + roadCount++; + } + } + } + + System.out.println(roadCount); + } + } +} +// + diff --git a/students/23K0342/23K0342-pr30_1/pom.xml b/students/23K0342/23K0342-pr30_1/pom.xml new file mode 100644 index 000000000..3e106690d --- /dev/null +++ b/students/23K0342/23K0342-pr30_1/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + 23K0342 + ru.mirea.practice + 2024.1 + ../pom.xml + + 23K0342-pr30_1 + Массивы + diff --git a/students/23K0342/23K0342-pr30_1/src/main/java/ru/mirea/practice/s0000001/BinaryTree.java b/students/23K0342/23K0342-pr30_1/src/main/java/ru/mirea/practice/s0000001/BinaryTree.java new file mode 100644 index 000000000..bcd210977 --- /dev/null +++ b/students/23K0342/23K0342-pr30_1/src/main/java/ru/mirea/practice/s0000001/BinaryTree.java @@ -0,0 +1,56 @@ +package ru.mirea.practice.s0000001; + +class BinaryTree { + TreeNode root; + + public int height(TreeNode node) { + if (node == null) { + return 0; + } else { + int leftHeight = height(node.left); + int rightHeight = height(node.right); + return Math.max(leftHeight, rightHeight) + 1; + } + } + + public void reverse(TreeNode node) { + if (node == null) { + return; + } + TreeNode temp = node.left; + node.left = node.right; + node.right = temp; + + reverse(node.left); + reverse(node.right); + } + + public boolean lookup(TreeNode node, int target) { + if (node == null) { + return false; + } + if (node.data == target) { + return true; + } + return target < node.data ? lookup(node.left, target) : lookup(node.right, target); + } + + public int size(TreeNode node) { + if (node == null) { + return 0; + } + return size(node.left) + 1 + size(node.right); + } + + public boolean sameTree(TreeNode a, TreeNode b) { + if (a == null && b == null) { + return true; + } + if (a == null || b == null) { + return false; + } + return a.data == b.data && sameTree(a.left, b.left) && sameTree(a.right, b.right); + } +} +// + diff --git a/students/23K0342/23K0342-pr30_1/src/main/java/ru/mirea/practice/s0000001/TreeNode.java b/students/23K0342/23K0342-pr30_1/src/main/java/ru/mirea/practice/s0000001/TreeNode.java new file mode 100644 index 000000000..65d58fc9c --- /dev/null +++ b/students/23K0342/23K0342-pr30_1/src/main/java/ru/mirea/practice/s0000001/TreeNode.java @@ -0,0 +1,14 @@ +package ru.mirea.practice.s0000001; + +class TreeNode { + int data; + TreeNode left; + TreeNode right; + + public TreeNode(int item) { + data = item; + left = right = null; + } +} + +// diff --git a/students/23K0342/pom.xml b/students/23K0342/pom.xml index 8a36aecc5..55dbbbabc 100644 --- a/students/23K0342/pom.xml +++ b/students/23K0342/pom.xml @@ -33,6 +33,21 @@ 23K0342-p18 23K0342-p19 23K0342-p20 + 23K0342-pr22 + 23K0342-pr21 + 23K0342-pr23 + 23K0342-pr24 + 23K0342-pr25 + 23K0342-pr26 + 23K0342-pr27 + 23K0342-pr28 + 23K0342-pr29 + 23K0342-pr30_1 + 23K0342-p30_2 + 23K0342-p31 + 23K0342-p32 + +