diff --git a/students/23K0135/23K0135-p21/pom.xml b/students/23K0135/23K0135-p21/pom.xml new file mode 100644 index 000000000..d3c8b45ac --- /dev/null +++ b/students/23K0135/23K0135-p21/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p21 + diff --git a/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task1/Task1.java b/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task1/Task1.java new file mode 100644 index 000000000..8ed5f1c1c --- /dev/null +++ b/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task1/Task1.java @@ -0,0 +1,14 @@ +package ru.mirea.practice.s23k0135.task1; + +import java.util.ArrayList; +import java.util.List; + +public abstract class Task1 { + public static List convertArrayToList(E[] elements) { + List resultList = new ArrayList<>(elements.length); + for (E element : elements) { + resultList.add(element); + } + return resultList; + } +} diff --git a/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task1/Test.java b/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task1/Test.java new file mode 100644 index 000000000..04ea73e60 --- /dev/null +++ b/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task1/Test.java @@ -0,0 +1,15 @@ +package ru.mirea.practice.s23k0135.task1; + +import java.util.List; + +import static ru.mirea.practice.s23k0135.task1.Task1.convertArrayToList; + +public abstract class Test { + public static void main(String[] args) { + Integer[] numbers = {5, 6, 8, 3, 2, 1}; + List numberList = convertArrayToList(numbers); + System.out.println(numberList); + + Integer[] emptyArray = new Integer[15]; + } +} diff --git a/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task2and3/Task2and3.java b/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task2and3/Task2and3.java new file mode 100644 index 000000000..0dda1e608 --- /dev/null +++ b/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task2and3/Task2and3.java @@ -0,0 +1,26 @@ +package ru.mirea.practice.s23k0135.task2and3; + +import java.util.Arrays; + +public class Task2and3 { + private final T[] array; + private final int length; + + Task2and3(T[] array) { + this.array = array; + this.length = array.length; + } + + public T get(int index) { + return array[index]; + } + + public int getLength() { + return length; + } + + @Override + public String toString() { + return Arrays.toString(array); + } +} diff --git a/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task2and3/Test.java b/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task2and3/Test.java new file mode 100644 index 000000000..0f780879b --- /dev/null +++ b/students/23K0135/23K0135-p21/src/main/java/ru/mirea/practice/s23k0135/task2and3/Test.java @@ -0,0 +1,9 @@ +package ru.mirea.practice.s23k0135.task2and3; + +public abstract class Test { + public static void main(String[] args) { + Integer[] arr = {5, 6, 8, 3, 2, 1}; + Task2and3 array = new Task2and3<>(arr); + System.out.println(array); + } +} diff --git a/students/23K0135/23K0135-p22/pom.xml b/students/23K0135/23K0135-p22/pom.xml new file mode 100644 index 000000000..a6565a00c --- /dev/null +++ b/students/23K0135/23K0135-p22/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p22 + + diff --git a/students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/RpnCalculator.java b/students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/RpnCalculator.java new file mode 100644 index 000000000..f9318d1f3 --- /dev/null +++ b/students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/RpnCalculator.java @@ -0,0 +1,61 @@ +package ru.mirea.practice.s23k0135; + +import java.util.StringTokenizer; + +public class RpnCalculator { + private Stack stack; + + public RpnCalculator(int size) { + stack = new Stack(size); + } + + public double evaluate(String expression) { + StringTokenizer tokenizer = new StringTokenizer(expression); + + while (tokenizer.hasMoreTokens()) { + String token = tokenizer.nextToken(); + + if (isNumeric(token)) { + stack.push(Double.parseDouble(token)); + } else { + performOperation(token); + } + } + + return stack.pop(); + } + + private void performOperation(String operator) { + double secondOperand = stack.pop(); + double firstOperand = stack.pop(); + + switch (operator) { + case "+": + stack.push(firstOperand + secondOperand); + break; + case "-": + stack.push(firstOperand - secondOperand); + break; + case "*": + stack.push(firstOperand * secondOperand); + break; + case "/": + if (secondOperand == 0) { + throw new ArithmeticException("Ошибка: Деление на ноль"); + } + stack.push(firstOperand / secondOperand); + break; + default: + throw new IllegalArgumentException("Недопустимый оператор: " + operator); + } + } + + private boolean isNumeric(String str) { + try { + Double.parseDouble(str); + return true; + } catch (NumberFormatException e) { + return false; + } + } +} diff --git a/students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/Stack.java b/students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/Stack.java new file mode 100644 index 000000000..50d01713b --- /dev/null +++ b/students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/Stack.java @@ -0,0 +1,40 @@ +package ru.mirea.practice.s23k0135; + +import java.util.EmptyStackException; + +public class Stack { + private int maxSize; + private double[] stackArray; + private int top; + + public Stack(int size) { + this.maxSize = size; + this.stackArray = new double[maxSize]; + this.top = -1; + } + + public void push(double value) { + if (top >= maxSize - 1) { + throw new StackOverflowError("Стек переполнен"); + } + stackArray[++top] = value; + } + + public double pop() { + if (isEmpty()) { + throw new EmptyStackException(); + } + return stackArray[top--]; + } + + public double peek() { + if (isEmpty()) { + throw new EmptyStackException(); + } + return stackArray[top]; + } + + public boolean isEmpty() { + return top == -1; + } +} diff --git a/students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/Test.java b/students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/Test.java new file mode 100644 index 000000000..b2cc20bc3 --- /dev/null +++ b/students/23K0135/23K0135-p22/src/main/java/ru/mirea/practice/s23k0135/Test.java @@ -0,0 +1,33 @@ +package ru.mirea.practice.s23k0135; + +import java.util.EmptyStackException; + +public abstract class Test { + public static void main(String[] args) { + RpnCalculator calculator = new RpnCalculator(10); + + System.out.println("7 3 + = " + calculator.evaluate("7 3 +")); + System.out.println("4 9 - = " + calculator.evaluate("4 9 -")); + System.out.println("6 8 * = " + calculator.evaluate("6 8 *")); + System.out.println("2 4 / = " + calculator.evaluate("2 4 /")); + System.out.println("9 2 + 3 * = " + calculator.evaluate("9 2 + 3 *")); + + try { + System.out.println("10 0 / = " + calculator.evaluate("10 0 /")); + } catch (ArithmeticException e) { + System.out.println(e.getMessage()); + } + + try { + System.out.println("1 + = " + calculator.evaluate("1 +")); + } catch (EmptyStackException e) { + System.out.println("Невозможно убрать элемент в начале пустого стека"); + } + + try { + System.out.println("18 9 % = " + calculator.evaluate("18 9 %")); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + } + } +} diff --git a/students/23K0135/23K0135-p23/pom.xml b/students/23K0135/23K0135-p23/pom.xml new file mode 100644 index 000000000..29db156b0 --- /dev/null +++ b/students/23K0135/23K0135-p23/pom.xml @@ -0,0 +1,15 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p23 + + + diff --git a/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQue.java b/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQue.java new file mode 100644 index 000000000..4535b6514 --- /dev/null +++ b/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQue.java @@ -0,0 +1,65 @@ +package ru.mirea.practice.s23k0135.task1; + +public class ArrQue { + private Object[] elements; + private int size; + private int head; + private int tail; + + public ArrQue() { + elements = new Object[10]; + size = 0; + head = 0; + tail = 0; + } + + public void enqueue(Object element) { + assert element != null : "Element cannot be null"; + ensureCapacity(size + 1); + elements[tail] = element; + tail = (tail + 1) % elements.length; + size++; + } + + public Object element() { + assert size > 0 : "Queue is empty"; + return elements[head]; + } + + public Object dequeue() { + assert size > 0 : "Queue is empty"; + Object result = elements[head]; + elements[head] = null; + head = (head + 1) % elements.length; + Object ans = result; + size--; + return ans; + } + + public int size() { + return size; + } + + public boolean isEmpty() { + return size == 0; + } + + public void clear() { + elements = new Object[10]; + size = 0; + head = 0; + tail = 0; + } + + private void ensureCapacity(int capacity) { + if (capacity > elements.length) { + Object[] newElements = new Object[2 * elements.length]; + for (int i = 0; i < size; i++) { + newElements[i] = elements[(head + i) % elements.length]; + } + elements = newElements; + head = 0; + tail = size; + } + } +} diff --git a/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQueAdt.java b/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQueAdt.java new file mode 100644 index 000000000..e53e99f48 --- /dev/null +++ b/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQueAdt.java @@ -0,0 +1,65 @@ +package ru.mirea.practice.s23k0135.task1; + +public class ArrQueAdt { + private Object[] elements; + private int size; + private int head; + private int tail; + + public ArrQueAdt() { + elements = new Object[10]; + size = 0; + head = 0; + tail = 0; + } + + public static void enqueue(ArrQueAdt queue, Object element) { + assert queue != null && element != null : "Queue or element is null"; + ensureCapacity(queue, queue.size + 1); + queue.elements[queue.tail] = element; + queue.tail = (queue.tail + 1) % queue.elements.length; + queue.size++; + } + + public static Object element(ArrQueAdt queue) { + assert queue != null && queue.size > 0 : "Queue is empty"; + return queue.elements[queue.head]; + } + + public static Object dequeue(ArrQueAdt queue) { + assert queue != null && queue.size > 0 : "Queue is empty"; + Object result = queue.elements[queue.head]; + queue.elements[queue.head] = null; + queue.head = (queue.head + 1) % queue.elements.length; + Object ans = result; + queue.size--; + return ans; + } + + public static int size(ArrQueAdt queue) { + return queue.size; + } + + public static boolean isEmpty(ArrQueAdt queue) { + return queue.size == 0; + } + + public static void clear(ArrQueAdt queue) { + queue.elements = new Object[10]; + queue.size = 0; + queue.head = 0; + queue.tail = 0; + } + + private static void ensureCapacity(ArrQueAdt queue, int capacity) { + if (capacity > queue.elements.length) { + Object[] newElements = new Object[2 * queue.elements.length]; + for (int i = 0; i < queue.size; i++) { + newElements[i] = queue.elements[(queue.head + i) % queue.elements.length]; + } + queue.elements = newElements; + queue.head = 0; + queue.tail = queue.size; + } + } +} diff --git a/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQueMod.java b/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQueMod.java new file mode 100644 index 000000000..bb7a41863 --- /dev/null +++ b/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/ArrQueMod.java @@ -0,0 +1,58 @@ +package ru.mirea.practice.s23k0135.task1; + +public abstract class ArrQueMod { + private static int size = 0; + private static int head = 0; + private static int tail = 0; + private static Object[] elements = new Object[10]; + + 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"; + Object result = elements[head]; + elements[head] = null; + head = (head + 1) % elements.length; + Object ans = result; + size--; + return ans; + } + + 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) { + 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/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/Tester.java b/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/Tester.java new file mode 100644 index 000000000..f83b745ca --- /dev/null +++ b/students/23K0135/23K0135-p23/src/main/java/ru/mirea/practice/s23k0135/task1/Tester.java @@ -0,0 +1,34 @@ +package ru.mirea.practice.s23k0135.task1; + +public abstract class Tester { + public static void main(String[] args) { + ArrQueMod.enqueue(1); + ArrQueMod.enqueue(2); + ArrQueMod.enqueue(3); + System.out.println(ArrQueMod.element()); + System.out.println(ArrQueMod.dequeue()); + System.out.println(ArrQueMod.size()); + ArrQueMod.clear(); + System.out.println(ArrQueMod.isEmpty()); + + ArrQueAdt adtQueue = new ArrQueAdt(); + ArrQueAdt.enqueue(adtQueue, 1); + ArrQueAdt.enqueue(adtQueue, 2); + ArrQueAdt.enqueue(adtQueue, 3); + System.out.println(ArrQueAdt.element(adtQueue)); + System.out.println(ArrQueAdt.dequeue(adtQueue)); + System.out.println(ArrQueAdt.size(adtQueue)); + ArrQueAdt.clear(adtQueue); + System.out.println(ArrQueAdt.isEmpty(adtQueue)); + + ArrQue queue = new ArrQue(); + queue.enqueue(1); + queue.enqueue(2); + queue.enqueue(3); + System.out.println(queue.element()); + System.out.println(queue.dequeue()); + System.out.println(queue.size()); + queue.clear(); + System.out.println(queue.isEmpty()); + } +} diff --git a/students/23K0135/23K0135-p24/pom.xml b/students/23K0135/23K0135-p24/pom.xml new file mode 100644 index 000000000..fd9c607e7 --- /dev/null +++ b/students/23K0135/23K0135-p24/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p24 + + diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/Complex.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/Complex.java new file mode 100644 index 000000000..b4325ef26 --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/Complex.java @@ -0,0 +1,24 @@ +package ru.mirea.practice.s23k0135.task1; + +public class Complex { + private int real; + private int img; + + public Complex(int real, int img) { + this.real = real; + this.img = img; + } + + public int getReal() { + return real; + } + + public int getImaginary() { + return img; + } + + @Override + public String toString() { + return real + " + " + img + "i"; + } +} diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/ComplexAbst.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/ComplexAbst.java new file mode 100644 index 000000000..f44844fc7 --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/ComplexAbst.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0135.task1; + +public interface ComplexAbst { + + Complex createComplex(); + + Complex createComplex(int real, int imaginary); +} diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/ConcFactrory.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/ConcFactrory.java new file mode 100644 index 000000000..5fc9f43c9 --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/ConcFactrory.java @@ -0,0 +1,14 @@ +package ru.mirea.practice.s23k0135.task1; + +public class ConcFactrory implements ComplexAbst { + + @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/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/Test.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/Test.java new file mode 100644 index 000000000..327df5959 --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task1/Test.java @@ -0,0 +1,13 @@ +package ru.mirea.practice.s23k0135.task1; + +public abstract class Test { + public static void main(String[] args) { + ComplexAbst factory = new ConcFactrory(); + + Complex defaultComplex = factory.createComplex(); + System.out.println("Комплексное число: " + defaultComplex); + + Complex customComplex = factory.createComplex(2, 1); + System.out.println("Комплексное число: " + customComplex); + } +} diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/Chair.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/Chair.java new file mode 100644 index 000000000..d9c000335 --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/Chair.java @@ -0,0 +1,5 @@ +package ru.mirea.practice.s23k0135.task2; + +public interface Chair { + void sit(); +} diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/ChairFactory.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/ChairFactory.java new file mode 100644 index 000000000..6a18cbcdd --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/ChairFactory.java @@ -0,0 +1,10 @@ +package ru.mirea.practice.s23k0135.task2; + +public interface ChairFactory { + + Chair createVictorianChair(); + + Chair createFunctionalChair(); + + Chair createMagicalChair(); +} diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/Client.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/Client.java new file mode 100644 index 000000000..36f9f6c16 --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/Client.java @@ -0,0 +1,7 @@ +package ru.mirea.practice.s23k0135.task2; + +public class Client { + public void sit(Chair chair) { + chair.sit(); + } +} diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/ConcreteChairFactory.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/ConcreteChairFactory.java new file mode 100644 index 000000000..ed5afc860 --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/ConcreteChairFactory.java @@ -0,0 +1,16 @@ +package ru.mirea.practice.s23k0135.task2; + +public class ConcreteChairFactory implements ChairFactory { + + public Chair createVictorianChair() { + return new VictorianChair(); + } + + public Chair createFunctionalChair() { + return new FunctionalChair(); + } + + public Chair createMagicalChair() { + return new MagicalChair(); + } +} diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/FunctionalChair.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/FunctionalChair.java new file mode 100644 index 000000000..f6593d1fc --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/FunctionalChair.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0135.task2; + +public class FunctionalChair implements Chair { + @Override + public void sit() { + System.out.println("Вы сидите на функциональном стуле. Он может сделать вам массаж."); + } +} diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/MagicalChair.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/MagicalChair.java new file mode 100644 index 000000000..3a5b48efb --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/MagicalChair.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0135.task2; + +public class MagicalChair implements Chair { + @Override + public void sit() { + System.out.println("Вы сидите на магическом стуле. Он дает возможность перемещаться во времени."); + } +} diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/Test.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/Test.java new file mode 100644 index 000000000..873a8365c --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/Test.java @@ -0,0 +1,17 @@ +package ru.mirea.practice.s23k0135.task2; + +public abstract class Test { + public static void main(String[] args) { + ChairFactory factory = new ConcreteChairFactory(); + Client client = new Client(); + + Chair victorianChair = factory.createVictorianChair(); + client.sit(victorianChair); + + Chair functionalChair = factory.createFunctionalChair(); + client.sit(functionalChair); + + Chair magicalChair = factory.createMagicalChair(); + client.sit(magicalChair); + } +} diff --git a/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/VictorianChair.java b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/VictorianChair.java new file mode 100644 index 000000000..1a69eb98e --- /dev/null +++ b/students/23K0135/23K0135-p24/src/main/java/ru/mirea/practice/s23k0135/task2/VictorianChair.java @@ -0,0 +1,8 @@ +package ru.mirea.practice.s23k0135.task2; + +public class VictorianChair implements Chair { + @Override + public void sit() { + System.out.println("Вы сидите на Викторианском стуле."); + } +} diff --git a/students/23K0135/23K0135-p25/pom.xml b/students/23K0135/23K0135-p25/pom.xml new file mode 100644 index 000000000..fded66fa0 --- /dev/null +++ b/students/23K0135/23K0135-p25/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p25 + + diff --git a/students/23K0135/23K0135-p25/src/main/java/ru/mirea/practice/s23k0135/task1/StringManipulator.java b/students/23K0135/23K0135-p25/src/main/java/ru/mirea/practice/s23k0135/task1/StringManipulator.java new file mode 100644 index 000000000..717782783 --- /dev/null +++ b/students/23K0135/23K0135-p25/src/main/java/ru/mirea/practice/s23k0135/task1/StringManipulator.java @@ -0,0 +1,108 @@ +package ru.mirea.practice.s23k0135.task1; + + +import java.util.Scanner; +import java.util.regex.Pattern; +import java.util.regex.Matcher; + +public abstract class StringManipulator { + public static void main(String[] args) { + try (Scanner scanner = new Scanner(System.in)) { + + System.out.println("Добро пожаловать в приложение для работы со строками!"); + System.out.println("Введите строку, которую хотите обработать:"); + String input = scanner.nextLine(); + + + while (true) { + System.out.println("\nВыберите действие:"); + System.out.println("1. Разбить строку на слова (по пробелам)"); + System.out.println("2. Разбить строку по регулярному выражению"); + System.out.println("3. Найти совпадения по регулярному выражению"); + System.out.println("4. Заменить подстроки по регулярному выражению"); + System.out.println("5. Выход"); + System.out.print("Введите номер действия: "); + int choice = Integer.parseInt(scanner.nextLine()); + + switch (choice) { + case 1: + splitByWhitespace(input); + break; + case 2: + System.out.print("Введите регулярное выражение для разделения строки: "); + String splitRegex = scanner.nextLine(); + splitByRegex(input, splitRegex); + break; + case 3: + System.out.print("Введите регулярное выражение для поиска совпадений: "); + String matchRegex = scanner.nextLine(); + findMatches(input, matchRegex); + break; + case 4: + System.out.print("Введите регулярное выражение для замены: "); + String replaceRegex = scanner.nextLine(); + System.out.print("Введите строку для замены: "); + String replacement = scanner.nextLine(); + replaceByRegex(input, replaceRegex, replacement); + break; + case 5: + System.out.println("Спасибо за использование приложения!"); + scanner.close(); + break; + default: + System.out.println("Некорректный выбор. Попробуйте еще раз."); + break; + } + } + } + } + + private static void splitByWhitespace(String input) { + System.out.println("\nРазбиение строки на слова:"); + String[] words = input.split("\\s+"); + for (String word : words) { + System.out.println(word); + } + } + + private static void splitByRegex(String input, String regex) { + System.out.println("\nРазбиение строки по регулярному выражению:"); + try { + String[] parts = input.split(regex); + for (String part : parts) { + System.out.println(part); + } + } catch (Exception e) { + System.out.println("Ошибка в регулярном выражении: " + e.getMessage()); + } + } + + private static void findMatches(String input, String regex) { + System.out.println("\nПоиск совпадений по регулярному выражению:"); + try { + Pattern pattern = Pattern.compile(regex); + Matcher matcher = pattern.matcher(input); + boolean found = false; + while (matcher.find()) { + System.out.println("Совпадение: " + matcher.group() + + " (с " + matcher.start() + " по " + matcher.end() + ")"); + found = true; + } + if (!found) { + System.out.println("Совпадений не найдено."); + } + } catch (Exception e) { + System.out.println("Ошибка в регулярном выражении: " + e.getMessage()); + } + } + + private static void replaceByRegex(String input, String regex, String replacement) { + System.out.println("\nЗамена подстрок по регулярному выражению:"); + try { + String result = input.replaceAll(regex, replacement); + System.out.println("Результат замены: " + result); + } catch (Exception e) { + System.out.println("Ошибка в регулярном выражении: " + e.getMessage()); + } + } +} diff --git a/students/23K0135/23K0135-p25/src/main/java/ru/mirea/practice/s23k0135/task2/StringValidator.java b/students/23K0135/23K0135-p25/src/main/java/ru/mirea/practice/s23k0135/task2/StringValidator.java new file mode 100644 index 000000000..c8e9662ac --- /dev/null +++ b/students/23K0135/23K0135-p25/src/main/java/ru/mirea/practice/s23k0135/task2/StringValidator.java @@ -0,0 +1,20 @@ +package ru.mirea.practice.s23k0135.task2; + + +import java.util.regex.Pattern; + +public abstract class StringValidator { + public static void main(String[] args) { + String regex = "^abcdefghijklmnopqrstuv18340$"; + String[] testStrings = { + "abcdefghijklmnopqrstuv18340", // правильная + "abcdefghijklmnoasdfasdpqrstuv18340", // неправильная + "abcdefghijklmnopqrstuv18340abc" // неправильная + }; + + for (String test : testStrings) { + boolean matches = Pattern.matches(regex, test); + System.out.println("Строка \"" + test + "\" " + (matches ? "соответствует" : "не соответствует") + " шаблону."); + } + } +} diff --git a/students/23K0135/23K0135-p25/src/main/java/ru/mirea/practice/s23k0135/task3/PriceExtractor.java b/students/23K0135/23K0135-p25/src/main/java/ru/mirea/practice/s23k0135/task3/PriceExtractor.java new file mode 100644 index 000000000..42c0180ff --- /dev/null +++ b/students/23K0135/23K0135-p25/src/main/java/ru/mirea/practice/s23k0135/task3/PriceExtractor.java @@ -0,0 +1,21 @@ +package ru.mirea.practice.s23k0135.task3; + + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public abstract class PriceExtractor { + public static void main(String[] args) { + String text = "The price is 25.98 USD, another one is 44.0 RUB, and there is also 100.00 EU. Incorrect: 44 ERR, 0.004 EU."; + + String regex = "\\b\\d+(\\.\\d{1,2})?\\s?(USD|RUB|EU)\\b"; + + Pattern pattern = Pattern.compile(regex); + Matcher matcher = pattern.matcher(text); + + System.out.println("Найденные цены:"); + while (matcher.find()) { + System.out.println(matcher.group()); + } + } +} diff --git a/students/23K0135/23K0135-p26/pom.xml b/students/23K0135/23K0135-p26/pom.xml new file mode 100644 index 000000000..aa15fcbd9 --- /dev/null +++ b/students/23K0135/23K0135-p26/pom.xml @@ -0,0 +1,15 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p26 + + + diff --git a/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task1/ArrayInverter.java b/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task1/ArrayInverter.java new file mode 100644 index 000000000..ab3670be1 --- /dev/null +++ b/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task1/ArrayInverter.java @@ -0,0 +1,34 @@ +package ru.mirea.practice.s23k0135.task1; + +import java.util.Stack; + +public abstract class ArrayInverter { + public static void invertArray(int[] array) { + Stack stack = new Stack<>(); + + // Поместим все элементы массива в стек + for (int num : array) { + stack.push(num); + } + + // Восстановим элементы из стека обратно в массив в обратном порядке + for (int i = 0; i < array.length; i++) { + array[i] = stack.pop(); + } + } + + 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/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task2/MyListIterator.java b/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task2/MyListIterator.java new file mode 100644 index 000000000..72dfbe09c --- /dev/null +++ b/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task2/MyListIterator.java @@ -0,0 +1,26 @@ +package ru.mirea.practice.s23k0135.task2; + +import java.util.Iterator; +import java.util.NoSuchElementException; + +public class MyListIterator implements Iterator { + private final E[] elements; + private int currentIndex = 0; + + public MyListIterator(E[] elements) { + this.elements = elements; + } + + @Override + public boolean hasNext() { + return currentIndex < elements.length; + } + + @Override + public E next() { + if (!hasNext()) { + throw new NoSuchElementException("Элементов больше нет."); + } + return elements[currentIndex++]; + } +} diff --git a/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task2/Test.java b/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task2/Test.java new file mode 100644 index 000000000..0f6fce5fd --- /dev/null +++ b/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task2/Test.java @@ -0,0 +1,13 @@ +package ru.mirea.practice.s23k0135.task2; + +public abstract class Test { + public static void main(String[] args) { + Integer[] array = {30, 40, 65, 12}; + MyListIterator iterator = new MyListIterator<>(array); + + System.out.println("Перебор элементов с помощью итератора:"); + while (iterator.hasNext()) { + System.out.println(iterator.next()); + } + } +} diff --git a/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task3/MyList.java b/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task3/MyList.java new file mode 100644 index 000000000..6d6dcbf53 --- /dev/null +++ b/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task3/MyList.java @@ -0,0 +1,52 @@ +package ru.mirea.practice.s23k0135.task3; + +import java.util.Iterator; +import java.util.NoSuchElementException; + +class MyList implements Iterable { + private final E[] elements; + private int size; + + public MyList(int capacity) { + this.elements = (E[]) new Object[capacity]; + this.size = 0; + } + + public void add(E element) { + if (size >= elements.length) { + throw new IllegalStateException("Список переполнен"); + } + elements[size++] = element; + } + + public E get(int index) { + if (index < 0 || index >= size) { + throw new IndexOutOfBoundsException("Неверный индекс: " + index); + } + return elements[index]; + } + + public int size() { + return size; + } + + @Override + public Iterator iterator() { + return new Iterator<>() { + private int currentIndex = 0; + + @Override + public boolean hasNext() { + return currentIndex < size; + } + + @Override + public E next() { + if (!hasNext()) { + throw new NoSuchElementException("Элементов больше нет."); + } + return elements[currentIndex++]; + } + }; + } +} diff --git a/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task3/Test.java b/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task3/Test.java new file mode 100644 index 000000000..7b565946a --- /dev/null +++ b/students/23K0135/23K0135-p26/src/main/java/ru/mirea/practice/s23k0135/task3/Test.java @@ -0,0 +1,15 @@ +package ru.mirea.practice.s23k0135.task3; + +public abstract class Test { + public static void main(String[] args) { + MyList list = new MyList<>(10); + list.add("Заяц"); + list.add("Волк"); + list.add("Лиса"); + + System.out.println("Перебор элементов с помощью итератора:"); + for (String fruit : list) { + System.out.println(fruit); + } + } +} diff --git a/students/23K0135/23K0135-p27/pom.xml b/students/23K0135/23K0135-p27/pom.xml new file mode 100644 index 000000000..f07626f37 --- /dev/null +++ b/students/23K0135/23K0135-p27/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p27 + + diff --git a/students/23K0135/23K0135-p27/src/main/java/ru/mirea/practice/s23k0135/HashTable.java b/students/23K0135/23K0135-p27/src/main/java/ru/mirea/practice/s23k0135/HashTable.java new file mode 100644 index 000000000..b61f4833a --- /dev/null +++ b/students/23K0135/23K0135-p27/src/main/java/ru/mirea/practice/s23k0135/HashTable.java @@ -0,0 +1,74 @@ +package ru.mirea.practice.s23k0135; + +import java.util.LinkedList; + +public class HashTable { + + private static class Entry { + String key; + String value; + + Entry(String key, String value) { + this.key = key; + this.value = value; + } + } + + private static final int TABLE_SIZE = 16; + private LinkedList[] table; + + public void hashtabInit() { + table = new LinkedList[TABLE_SIZE]; + for (int i = 0; i < TABLE_SIZE; i++) { + table[i] = new LinkedList<>(); + } + } + + private int hashtabHash(String key) { + return Math.abs(key.hashCode() % TABLE_SIZE); + } + + public void hashtabAdd(String key, String value) { + int index = hashtabHash(key); + LinkedList bucket = table[index]; + + for (Entry entry : bucket) { + if (entry.key.equals(key)) { + entry.value = value; + return; + } + } + + bucket.add(new Entry(key, value)); + } + + public String hashtabLookup(String key) { + int index = hashtabHash(key); + LinkedList bucket = table[index]; + + for (Entry entry : bucket) { + if (entry.key.equals(key)) { + return entry.value; + } + } + + return null; + } + + public void hashtabDelete(String key) { + int index = hashtabHash(key); + LinkedList bucket = table[index]; + + bucket.removeIf(entry -> entry.key.equals(key)); + } + + public void printTable() { + for (int i = 0; i < TABLE_SIZE; i++) { + System.out.print("Bucket " + i + ": "); + for (Entry entry : table[i]) { + System.out.print("[" + entry.key + " -> " + entry.value + "] "); + } + System.out.println(); + } + } +} diff --git a/students/23K0135/23K0135-p27/src/main/java/ru/mirea/practice/s23k0135/Test.java b/students/23K0135/23K0135-p27/src/main/java/ru/mirea/practice/s23k0135/Test.java new file mode 100644 index 000000000..bf93ff6ee --- /dev/null +++ b/students/23K0135/23K0135-p27/src/main/java/ru/mirea/practice/s23k0135/Test.java @@ -0,0 +1,26 @@ +package ru.mirea.practice.s23k0135; + +public abstract class Test { + public static void main(String[] args) { + HashTable hashtab = new HashTable(); + hashtab.hashtabInit(); + hashtab.hashtabAdd("apple", "fruit"); + hashtab.hashtabAdd("carrot", "vegetable"); + hashtab.hashtabAdd("banana", "fruit"); + hashtab.hashtabAdd("kiwi", "fruit"); + hashtab.hashtabAdd("tomato", "vegetable"); + hashtab.hashtabAdd("grape", "fruit"); + hashtab.hashtabAdd("onion", "vegetable"); + hashtab.hashtabAdd("pineapple", "fruit"); + hashtab.hashtabAdd("lettuce", "vegetable"); + hashtab.hashtabAdd("mango", "fruit"); + System.out.println("Хэш-таблица после добавления элементов:"); + hashtab.printTable(); + System.out.println("\nПоиск по ключу 'banana': " + hashtab.hashtabLookup("banana")); + System.out.println("Поиск по ключу 'onion': " + hashtab.hashtabLookup("onion")); + System.out.println("Поиск по ключу 'peach': " + hashtab.hashtabLookup("peach")); + System.out.println("\nУдаление элемента с ключом 'kiwi'."); + hashtab.hashtabDelete("kiwi"); + hashtab.printTable(); + } +} diff --git a/students/23K0135/23K0135-p28/pom.xml b/students/23K0135/23K0135-p28/pom.xml new file mode 100644 index 000000000..87e10a850 --- /dev/null +++ b/students/23K0135/23K0135-p28/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p28 + + diff --git a/students/23K0135/23K0135-p28/src/main/java/ru/mirea/practice/s23k0135/task1/SetConversion.java b/students/23K0135/23K0135-p28/src/main/java/ru/mirea/practice/s23k0135/task1/SetConversion.java new file mode 100644 index 000000000..564a37883 --- /dev/null +++ b/students/23K0135/23K0135-p28/src/main/java/ru/mirea/practice/s23k0135/task1/SetConversion.java @@ -0,0 +1,16 @@ +package ru.mirea.practice.s23k0135.task1; + +import java.util.HashSet; +import java.util.TreeSet; + +public abstract class SetConversion { + 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: " + treeSet); + } +} diff --git a/students/23K0135/23K0135-p28/src/main/java/ru/mirea/practice/s23k0135/task2/NameCounter.java b/students/23K0135/23K0135-p28/src/main/java/ru/mirea/practice/s23k0135/task2/NameCounter.java new file mode 100644 index 000000000..30137cab4 --- /dev/null +++ b/students/23K0135/23K0135-p28/src/main/java/ru/mirea/practice/s23k0135/task2/NameCounter.java @@ -0,0 +1,54 @@ +package ru.mirea.practice.s23k0135.task2; + +import java.util.HashMap; +import java.util.Map; + +public abstract class NameCounter { + + public static Map createMap() { + Map map = new HashMap<>(); + + map.put("Ivanov", "Ivan"); + map.put("Petrov", "Petr"); + map.put("Sidorov", "Ivan"); + map.put("Smirnov", "Alex"); + map.put("Kuznetsov", "Alex"); + map.put("Popov", "Igor"); + map.put("Vasiliev", "Petr"); + map.put("Mikhailov", "Ivan"); + map.put("Fedorov", "Semen"); + map.put("Novikov", "Alex"); + + return map; + } + + public static int getSameFirstNameCount(Map map) { + Map firstNameCount = new HashMap<>(); + for (String firstName : map.values()) { + firstNameCount.put(firstName, firstNameCount.getOrDefault(firstName, 0) + 1); + } + int sameFirstNameCount = 0; + for (int count : firstNameCount.values()) { + if (count > 1) { + sameFirstNameCount++; + } + } + + return sameFirstNameCount; + } + + public static int getSameLastNameCount(Map map) { + Map lastNameCount = new HashMap<>(); + for (String lastName : map.keySet()) { + lastNameCount.put(lastName, lastNameCount.getOrDefault(lastName, 0) + 1); + } + int sameLastNameCount = 0; + for (int count : lastNameCount.values()) { + if (count > 1) { + sameLastNameCount++; + } + } + + return sameLastNameCount; + } +} diff --git a/students/23K0135/23K0135-p28/src/main/java/ru/mirea/practice/s23k0135/task2/Test.java b/students/23K0135/23K0135-p28/src/main/java/ru/mirea/practice/s23k0135/task2/Test.java new file mode 100644 index 000000000..4ee189d31 --- /dev/null +++ b/students/23K0135/23K0135-p28/src/main/java/ru/mirea/practice/s23k0135/task2/Test.java @@ -0,0 +1,18 @@ +package ru.mirea.practice.s23k0135.task2; + + +import java.util.Map; + +import static ru.mirea.practice.s23k0135.task2.NameCounter.createMap; +import static ru.mirea.practice.s23k0135.task2.NameCounter.getSameFirstNameCount; +import static ru.mirea.practice.s23k0135.task2.NameCounter.getSameLastNameCount; + +public abstract class Test { + public static void main(String[] args) { + Map peopleMap = createMap(); + int sameFirstNameCount = getSameFirstNameCount(peopleMap); + int sameLastNameCount = getSameLastNameCount(peopleMap); + System.out.println("Количество людей с одинаковыми именами: " + sameFirstNameCount); + System.out.println("Количество людей с одинаковыми фамилиями: " + sameLastNameCount); + } +} diff --git a/students/23K0135/23K0135-p29/pom.xml b/students/23K0135/23K0135-p29/pom.xml new file mode 100644 index 000000000..b08412525 --- /dev/null +++ b/students/23K0135/23K0135-p29/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p29 + + diff --git a/students/23K0135/23K0135-p29/src/main/java/ru/mirea/practice/s23k0135/Test.java b/students/23K0135/23K0135-p29/src/main/java/ru/mirea/practice/s23k0135/Test.java new file mode 100644 index 000000000..051e4433d --- /dev/null +++ b/students/23K0135/23K0135-p29/src/main/java/ru/mirea/practice/s23k0135/Test.java @@ -0,0 +1,27 @@ +package ru.mirea.practice.s23k0135; + +import java.util.Scanner; + +public abstract class Test { + public static void main(String[] args) { + + try (Scanner scanner = new Scanner(System.in)) { + int n = scanner.nextInt(); + 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/23K0135/23K0135-p30/pom.xml b/students/23K0135/23K0135-p30/pom.xml new file mode 100644 index 000000000..b1f06e562 --- /dev/null +++ b/students/23K0135/23K0135-p30/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p30 + + diff --git a/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task1/BinaryTree.java b/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task1/BinaryTree.java new file mode 100644 index 000000000..f806a4f6c --- /dev/null +++ b/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task1/BinaryTree.java @@ -0,0 +1,108 @@ +package ru.mirea.practice.s23k0135.task1; + +public class BinaryTree { + Node rootNode; + + int calculateHeight(Node node) { + if (node == null) { + return 0; + } else { + int leftHeight = calculateHeight(node.left); + int rightHeight = calculateHeight(node.right); + return Math.max(leftHeight, rightHeight) + 1; + } + } + + boolean search(Node node, int target) { + if (node == null) { + return false; + } else if (node.data == target) { + return true; + } else if (target < node.data) { + return search(node.left, target); + } else { + return search(node.right, target); + } + } + + int getSize(Node node) { + if (node == null) { + return 0; + } else { + return getSize(node.left) + 1 + getSize(node.right); + } + } + + int findMaxWidth(Node root) { + int maxWidth = 0; + int treeHeight = this.calculateHeight(root); + for (int i = 1; i <= treeHeight; i++) { + int levelWidth = getWidthAtLevel(root, i); + if (levelWidth > maxWidth) { + maxWidth = levelWidth; + } + } + return maxWidth; + } + + int getWidthAtLevel(Node root, int level) { + if (root == null) { + return 0; + } + if (level == 1) { + return 1; + } else { + return getWidthAtLevel(root.left, level - 1) + getWidthAtLevel(root.right, level - 1); + } + } + + boolean areTreesIdentical(Node a, Node b) { + if (a == null && b == null) { + return true; + } else if (a != null && b != null) { + return a.data == b.data && areTreesIdentical(a.left, b.left) && areTreesIdentical(a.right, b.right); + } else { + return false; + } + } + + void performInorderTraversal(Node node) { + if (node != null) { + performInorderTraversal(node.left); + System.out.print(node.data + " "); + performInorderTraversal(node.right); + } + } + + public static void main(String[] args) { + BinaryTree tree = new BinaryTree(); + tree.rootNode = new Node(5); + tree.rootNode.left = new Node(3); + tree.rootNode.right = new Node(8); + tree.rootNode.left.left = new Node(2); + tree.rootNode.left.right = new Node(4); + tree.rootNode.right.left = new Node(7); + tree.rootNode.right.right = new Node(9); + + System.out.println("Обход бинарного дерева в порядке убывания:"); + tree.performInorderTraversal(tree.rootNode); + + System.out.println("\nВысота дерева: " + tree.calculateHeight(tree.rootNode)); + System.out.println("Размер дерева: " + tree.getSize(tree.rootNode)); + System.out.println("Максимальная ширина дерева: " + tree.findMaxWidth(tree.rootNode)); + + int target = 4; + System.out.println("Поиск " + target + ": " + tree.search(tree.rootNode, target)); + + BinaryTree tree2 = new BinaryTree(); + tree2.rootNode = new Node(5); + tree2.rootNode.left = new Node(3); + tree2.rootNode.right = new Node(8); + tree2.rootNode.left.left = new Node(2); + tree2.rootNode.left.right = new Node(4); + tree2.rootNode.right.left = new Node(7); + tree2.rootNode.right.right = new Node(9); + + System.out.println("Являются ли эти два дерева одинаковыми? " + tree.areTreesIdentical(tree.rootNode, tree2.rootNode)); + } +} diff --git a/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task1/Node.java b/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task1/Node.java new file mode 100644 index 000000000..0db1f0149 --- /dev/null +++ b/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task1/Node.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0135.task1; + +public class Node { + int data; + Node left; + Node right; + + Node(int value) { + data = value; + left = right = null; + } +} diff --git a/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task2/HuffmanEncoding.java b/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task2/HuffmanEncoding.java new file mode 100644 index 000000000..0c45757fe --- /dev/null +++ b/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task2/HuffmanEncoding.java @@ -0,0 +1,112 @@ +package ru.mirea.practice.s23k0135.task2; + + +import java.util.PriorityQueue; +import java.util.HashMap; +import java.util.Map; + +public abstract class HuffmanEncoding { + private static Map encodingMap = new HashMap<>(); + + public static HuffmanTreeNode buildHuffmanTree(char[] characters, int[] frequencies) { + PriorityQueue queue = new PriorityQueue<>(characters.length, new HuffmanTreeComparator()); + + for (int i = 0; i < characters.length; i++) { + queue.add(new HuffmanTreeNode(characters[i], frequencies[i])); + } + + while (queue.size() > 1) { + HuffmanTreeNode leftChild = queue.poll(); + HuffmanTreeNode rightChild = queue.poll(); + HuffmanTreeNode combinedNode = new HuffmanTreeNode('\0', leftChild.freq + rightChild.freq); + combinedNode.left = leftChild; + combinedNode.right = rightChild; + queue.add(combinedNode); + } + + return queue.poll(); + } + + public static void generateEncoding(HuffmanTreeNode node, String currentCode) { + if (node == null) { + return; + } + + if (node.left == null && node.right == null) { + encodingMap.put(node.character, currentCode); + } + + generateEncoding(node.left, currentCode + "0"); + generateEncoding(node.right, currentCode + "1"); + } + + public static String encodeText(String inputText) { + Map charFrequency = new HashMap<>(); + for (char character : inputText.toCharArray()) { + charFrequency.put(character, charFrequency.getOrDefault(character, 0) + 1); + } + + char[] characterArray = new char[charFrequency.size()]; + int[] frequencyArray = new int[charFrequency.size()]; + int idx = 0; + + for (Map.Entry entry : charFrequency.entrySet()) { + characterArray[idx] = entry.getKey(); + frequencyArray[idx] = entry.getValue(); + idx++; + } + + HuffmanTreeNode rootNode = buildHuffmanTree(characterArray, frequencyArray); + generateEncoding(rootNode, ""); + + StringBuilder encodedString = new StringBuilder(); + for (char character : inputText.toCharArray()) { + encodedString.append(encodingMap.get(character)); + } + + return encodedString.toString(); + } + + public static String decodeText(HuffmanTreeNode rootNode, String encodedText) { + StringBuilder decodedString = new StringBuilder(); + HuffmanTreeNode currentNode = rootNode; + + for (char bit : encodedText.toCharArray()) { + currentNode = (bit == '0') ? currentNode.left : currentNode.right; + + if (currentNode.left == null && currentNode.right == null) { + decodedString.append(currentNode.character); + currentNode = rootNode; + } + } + + return decodedString.toString(); + } + + public static void main(String[] args) { + String inputText = "hello huffman"; + System.out.println("Original text: " + inputText); + + String encodedText = encodeText(inputText); + System.out.println("Encoded string: " + encodedText); + + Map frequencyMap = new HashMap<>(); + for (char c : inputText.toCharArray()) { + frequencyMap.put(c, frequencyMap.getOrDefault(c, 0) + 1); + } + + char[] characters = new char[frequencyMap.size()]; + int[] frequencies = new int[frequencyMap.size()]; + int idx = 0; + for (Map.Entry entry : frequencyMap.entrySet()) { + characters[idx] = entry.getKey(); + frequencies[idx] = entry.getValue(); + idx++; + } + + HuffmanTreeNode rootNode = buildHuffmanTree(characters, frequencies); + + String decodedText = decodeText(rootNode, encodedText); + System.out.println("Decoded string: " + decodedText); + } +} diff --git a/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task2/HuffmanTreeComparator.java b/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task2/HuffmanTreeComparator.java new file mode 100644 index 000000000..3ca60f633 --- /dev/null +++ b/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task2/HuffmanTreeComparator.java @@ -0,0 +1,9 @@ +package ru.mirea.practice.s23k0135.task2; + +import java.util.Comparator; + +class HuffmanTreeComparator implements Comparator { + public int compare(HuffmanTreeNode node1, HuffmanTreeNode node2) { + return node1.freq - node2.freq; + } +} diff --git a/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task2/HuffmanTreeNode.java b/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task2/HuffmanTreeNode.java new file mode 100644 index 000000000..5ba3de22a --- /dev/null +++ b/students/23K0135/23K0135-p30/src/main/java/ru/mirea/practice/s23k0135/task2/HuffmanTreeNode.java @@ -0,0 +1,14 @@ +package ru.mirea.practice.s23k0135.task2; + +public class HuffmanTreeNode { + int freq; + char character; + HuffmanTreeNode left; + HuffmanTreeNode right; + + HuffmanTreeNode(char character, int freq) { + this.character = character; + this.freq = freq; + left = right = null; + } +} diff --git a/students/23K0135/23K0135-p30_1/pom.xml b/students/23K0135/23K0135-p30_1/pom.xml new file mode 100644 index 000000000..cfe59ba61 --- /dev/null +++ b/students/23K0135/23K0135-p30_1/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p30_1 + + diff --git a/students/23K0135/23K0135-p30_1/src/main/java/ru/mirea/practice/s23k0135/BinarySearchTree.java b/students/23K0135/23K0135-p30_1/src/main/java/ru/mirea/practice/s23k0135/BinarySearchTree.java new file mode 100644 index 000000000..44554ab00 --- /dev/null +++ b/students/23K0135/23K0135-p30_1/src/main/java/ru/mirea/practice/s23k0135/BinarySearchTree.java @@ -0,0 +1,96 @@ +package ru.mirea.practice.s23k0135; + +public class BinarySearchTree { + Node root; + + // Вставка узла в дерево + 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 inorder() { + inorderRec(root); + } + + private void inorderRec(Node root) { + if (root != null) { + inorderRec(root.left); + System.out.print(root.data + " "); + inorderRec(root.right); + } + } + + // Удаление узла из дерева + public void delete(int key) { + root = deleteRec(root, key); + } + + private Node deleteRec(Node root, int key) { + if (root == null) { + return root; + } + + if (key < root.data) { + root.left = deleteRec(root.left, key); + } else if (key > root.data) { + root.right = deleteRec(root.right, key); + } 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 clear() { + root = clearRec(root); + } + + private Node clearRec(Node root) { + if (root != null) { + root.left = clearRec(root.left); + root.right = clearRec(root.right); + root = null; // Удаляем узел + } + return root; + } +} diff --git a/students/23K0135/23K0135-p30_1/src/main/java/ru/mirea/practice/s23k0135/Node.java b/students/23K0135/23K0135-p30_1/src/main/java/ru/mirea/practice/s23k0135/Node.java new file mode 100644 index 000000000..6390c2c1a --- /dev/null +++ b/students/23K0135/23K0135-p30_1/src/main/java/ru/mirea/practice/s23k0135/Node.java @@ -0,0 +1,12 @@ +package ru.mirea.practice.s23k0135; + +public class Node { + int data; + Node left; + Node right; + + public Node(int item) { + data = item; + left = right = null; + } +} diff --git a/students/23K0135/23K0135-p30_1/src/main/java/ru/mirea/practice/s23k0135/Test.java b/students/23K0135/23K0135-p30_1/src/main/java/ru/mirea/practice/s23k0135/Test.java new file mode 100644 index 000000000..b6fa3f0a9 --- /dev/null +++ b/students/23K0135/23K0135-p30_1/src/main/java/ru/mirea/practice/s23k0135/Test.java @@ -0,0 +1,26 @@ +package ru.mirea.practice.s23k0135; + +public abstract class Test { + public static void main(String[] args) { + BinarySearchTree tree = new BinarySearchTree(); + + int[] nodes = {10, 20, 5, 6, 3, 30, 25, 15, 8, 18}; + for (int node : nodes) { + tree.insert(node); + } + + System.out.println("Дерево после вставки узлов:"); + tree.inorder(); + System.out.println(); + + System.out.println("Удаляем узел 20:"); + tree.delete(20); + tree.inorder(); + System.out.println(); + + System.out.println("Удаляем все узлы:"); + tree.clear(); + tree.inorder(); + System.out.println(); + } +} diff --git a/students/23K0135/23K0135-p31/pom.xml b/students/23K0135/23K0135-p31/pom.xml new file mode 100644 index 000000000..be021a327 --- /dev/null +++ b/students/23K0135/23K0135-p31/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p31 + + diff --git a/students/23K0135/23K0135-p31/src/main/java/ru/mirea/practice/s23k0135/Node.java b/students/23K0135/23K0135-p31/src/main/java/ru/mirea/practice/s23k0135/Node.java new file mode 100644 index 000000000..1eb87b5ac --- /dev/null +++ b/students/23K0135/23K0135-p31/src/main/java/ru/mirea/practice/s23k0135/Node.java @@ -0,0 +1,11 @@ +package ru.mirea.practice.s23k0135; + +class Node { + int value; + Node leftChild; + Node rightChild; + + public Node(int value) { + this.value = value; + } +} diff --git a/students/23K0135/23K0135-p31/src/main/java/ru/mirea/practice/s23k0135/Test.java b/students/23K0135/23K0135-p31/src/main/java/ru/mirea/practice/s23k0135/Test.java new file mode 100644 index 000000000..fa56addfd --- /dev/null +++ b/students/23K0135/23K0135-p31/src/main/java/ru/mirea/practice/s23k0135/Test.java @@ -0,0 +1,68 @@ +package ru.mirea.practice.s23k0135; + +import java.util.Scanner; + +public final class Test { + private Test() { + throw new UnsupportedOperationException("Утилитный класс"); + } + + public static void main(String[] args) { + TreeProcessor tree = new TreeProcessor(); + + try (Scanner scanner = new Scanner(System.in)) { + while (true) { + System.out.println("Меню:"); + System.out.println("1 - Добавить узел"); + System.out.println("2 - Удалить узел"); + System.out.println("3 - Вывести вариант 1 (снизу вверх, слева направо)"); + System.out.println("4 - Вывести вариант 2 (сверху вниз, слева направо)"); + System.out.println("5 - Вывести вариант 3 (левый, корень, правый)"); + System.out.println("6 - Вывести вариант 6 (уровни с номерами уровней)"); + System.out.println("7 - Выход"); + System.out.print("Введите команду: "); + int command = scanner.nextInt(); + + switch (command) { + case 1: + System.out.print("Введите значение для добавления: "); + int valueToAdd = scanner.nextInt(); + tree.insert(valueToAdd); + break; + + case 2: + System.out.print("Введите значение для удаления: "); + int valueToRemove = scanner.nextInt(); + tree.remove(valueToRemove); + break; + + case 3: + tree.printMethod1(); + break; + + case 4: + tree.printMethod2(); + break; + + case 5: + tree.printMethod3(); + break; + + case 6: + tree.printMethod6(); + break; + + case 7: + System.out.println("Выход из программы."); + return; + + default: + System.out.println("Неверная команда."); + break; + } + } + } catch (Exception e) { + System.out.println("Произошла ошибка: " + e.getMessage()); + } + } +} diff --git a/students/23K0135/23K0135-p31/src/main/java/ru/mirea/practice/s23k0135/TreeProcessor.java b/students/23K0135/23K0135-p31/src/main/java/ru/mirea/practice/s23k0135/TreeProcessor.java new file mode 100644 index 000000000..c84a2ce94 --- /dev/null +++ b/students/23K0135/23K0135-p31/src/main/java/ru/mirea/practice/s23k0135/TreeProcessor.java @@ -0,0 +1,125 @@ +package ru.mirea.practice.s23k0135; + +public class TreeProcessor { + private Node rootNode; + + public void insert(int value) { + rootNode = insertRecursively(rootNode, value); + } + + private Node insertRecursively(Node node, int value) { + if (node == null) { + return new Node(value); + } + if (value < node.value) { + node.leftChild = insertRecursively(node.leftChild, value); + } else if (value > node.value) { + node.rightChild = insertRecursively(node.rightChild, value); + } else { + System.out.println("Значение " + value + " уже существует."); + } + return node; + } + + public void remove(int value) { + rootNode = removeRecursively(rootNode, value); + } + + private Node removeRecursively(Node node, int value) { + if (node == null) { + System.out.println("Значение " + value + " не найдено."); + return null; + } + if (value < node.value) { + node.leftChild = removeRecursively(node.leftChild, value); + } else if (value > node.value) { + node.rightChild = removeRecursively(node.rightChild, value); + } else { + if (node.leftChild == null && node.rightChild == null) { + return null; + } else if (node.leftChild == null) { + return node.rightChild; + } else if (node.rightChild == null) { + return node.leftChild; + } else { + Node smallestNode = findMinValue(node.rightChild); + node.value = smallestNode.value; + node.rightChild = removeRecursively(node.rightChild, smallestNode.value); + } + } + return node; + } + + private Node findMinValue(Node node) { + return node.leftChild == null ? node : findMinValue(node.leftChild); + } + + public void printMethod1() { + if (rootNode == null) { + System.out.println("Дерево пусто."); + return; + } + int depth = calculateHeight(rootNode); + for (int level = depth; level >= 1; level--) { + printLevelNodes(rootNode, level); + } + System.out.println(); + } + + public void printMethod2() { + if (rootNode == null) { + System.out.println("Дерево пусто."); + return; + } + int depth = calculateHeight(rootNode); + for (int level = 1; level <= depth; level++) { + printLevelNodes(rootNode, level); + } + System.out.println(); + } + + public void printMethod3() { + printInOrderRecursive(rootNode); + System.out.println(); + } + + private void printInOrderRecursive(Node node) { + if (node != null) { + printInOrderRecursive(node.leftChild); + System.out.print(node.value + " "); + printInOrderRecursive(node.rightChild); + } + } + + public void printMethod6() { + if (rootNode == null) { + System.out.println("Дерево пусто."); + return; + } + int depth = calculateHeight(rootNode); + for (int level = 1; level <= depth; level++) { + System.out.print("Уровень " + level + ": "); + printLevelNodes(rootNode, level); + System.out.println(); + } + } + + private int calculateHeight(Node node) { + if (node == null) { + return 0; + } + return Math.max(calculateHeight(node.leftChild), calculateHeight(node.rightChild)) + 1; + } + + private void printLevelNodes(Node node, int level) { + if (node == null) { + return; + } + if (level == 1) { + System.out.print(node.value + " "); + } else if (level > 1) { + printLevelNodes(node.leftChild, level - 1); + printLevelNodes(node.rightChild, level - 1); + } + } +} diff --git a/students/23K0135/23K0135-p32/pom.xml b/students/23K0135/23K0135-p32/pom.xml new file mode 100644 index 000000000..d18ae327c --- /dev/null +++ b/students/23K0135/23K0135-p32/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + ru.mirea.practice + 23K0135 + 2024.1 + + + 23K0135-p32 + + diff --git a/students/23K0135/23K0135-p32/src/main/java/ru/mirea/practice/s23k0135/LexicographicalPermutations.java b/students/23K0135/23K0135-p32/src/main/java/ru/mirea/practice/s23k0135/LexicographicalPermutations.java new file mode 100644 index 000000000..466497fcc --- /dev/null +++ b/students/23K0135/23K0135-p32/src/main/java/ru/mirea/practice/s23k0135/LexicographicalPermutations.java @@ -0,0 +1,48 @@ +package ru.mirea.practice.s23k0135; + +public abstract class LexicographicalPermutations { + + public static void printPermutation(int[] arr) { + for (int num : arr) { + System.out.print(num + " "); + } + System.out.println(); + } + + 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); + reverse(arr, i + 1, n - 1); + + return true; + } + + public static void swap(int[] arr, int i, int j) { + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } + + public static void reverse(int[] arr, int i, int j) { + while (i < j) { + swap(arr, i, j); + i++; + j--; + } + } +} diff --git a/students/23K0135/23K0135-p32/src/main/java/ru/mirea/practice/s23k0135/Test.java b/students/23K0135/23K0135-p32/src/main/java/ru/mirea/practice/s23k0135/Test.java new file mode 100644 index 000000000..6a99137bb --- /dev/null +++ b/students/23K0135/23K0135-p32/src/main/java/ru/mirea/practice/s23k0135/Test.java @@ -0,0 +1,19 @@ +package ru.mirea.practice.s23k0135; + +import static ru.mirea.practice.s23k0135.LexicographicalPermutations.printPermutation; +import static ru.mirea.practice.s23k0135.LexicographicalPermutations.nextPermutation; + +public abstract class Test { + public static void main(String[] args) { + int n = 5; + int[] arr = new int[n]; + + for (int i = 0; i < n; i++) { + arr[i] = i + 1; + } + + do { + printPermutation(arr); + } while (nextPermutation(arr)); + } +} diff --git a/students/23K0135/pom.xml b/students/23K0135/pom.xml index a048d213d..faf9477fb 100644 --- a/students/23K0135/pom.xml +++ b/students/23K0135/pom.xml @@ -33,6 +33,5 @@ 23K0135-p18 23K0135-p19 23K0135-p20 - 23K0135-p17