diff --git a/README.md b/README.md
new file mode 100644
index 00000000..c5ba8967
--- /dev/null
+++ b/README.md
@@ -0,0 +1 @@
+# Java Course HSE AMI '28
diff --git a/commander/dependency-reduced-pom.xml b/commander/dependency-reduced-pom.xml
new file mode 100644
index 00000000..5405c3c1
--- /dev/null
+++ b/commander/dependency-reduced-pom.xml
@@ -0,0 +1,88 @@
+
+
+ 4.0.0
+ hse.java
+ commander
+ commander
+ 1.0-SNAPSHOT
+
+
+
+ maven-compiler-plugin
+ 3.13.0
+
+ 25
+ 25
+
+
+
+ org.openjfx
+ javafx-maven-plugin
+ 0.0.8
+
+
+ default-cli
+
+ hse.java.commander/hse.java.commander.CommanderApplication
+ app
+ app
+ app
+ true
+ true
+ true
+
+
+
+
+
+
+
+
+ org.openjfx
+ javafx
+ 21.0.6
+ pom
+ compile
+
+
+ org.junit.jupiter
+ junit-jupiter-api
+ 5.12.1
+ test
+
+
+ opentest4j
+ org.opentest4j
+
+
+ junit-platform-commons
+ org.junit.platform
+
+
+ apiguardian-api
+ org.apiguardian
+
+
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ 5.12.1
+ test
+
+
+ junit-platform-engine
+ org.junit.platform
+
+
+ apiguardian-api
+ org.apiguardian
+
+
+
+
+
+ UTF-8
+ 5.12.1
+
+
diff --git a/commander/src/main/java/hse/java/commander/MainController.java b/commander/src/main/java/hse/java/commander/MainController.java
index 5de3b66d..ab4d7070 100644
--- a/commander/src/main/java/hse/java/commander/MainController.java
+++ b/commander/src/main/java/hse/java/commander/MainController.java
@@ -2,18 +2,125 @@
import javafx.fxml.FXML;
import javafx.scene.control.Button;
+import javafx.scene.control.Label;
import javafx.scene.control.ListView;
+<<<<<<< HEAD
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+=======
import java.nio.file.Path;
public class MainController {
+>>>>>>> 1c195628027c24a0d2a677be0bd75b5381ae77e5
+public class MainController {
@FXML
+<<<<<<< HEAD
+ public Button move;
+ @FXML
+=======
+>>>>>>> 1c195628027c24a0d2a677be0bd75b5381ae77e5
public ListView left;
-
@FXML
public ListView right;
+ @FXML
+ public Label leftPathLabel;
+ @FXML
+ public Label rightPathLabel;
+
+<<<<<<< HEAD
+ private File leftDirectory = new File(System.getProperty("user.home"));
+ private File rightDirectory = new File(System.getProperty("user.home"));
+
+ public void initialize() {
+ refresh(left, leftDirectory);
+ refresh(right, rightDirectory);
+
+ left.setOnMouseClicked(event -> {
+ if (event.getClickCount() == 2) {
+ handleNavigation(left, true);
+ }
+ });
+
+ right.setOnMouseClicked(event -> {
+ if (event.getClickCount() == 2) {
+ handleNavigation(right, false);
+ }
+ });
+
+ move.setOnAction(event -> moveFile());
+ }
+
+ private void refresh(ListView list, File directory) {
+ list.getItems().clear();
+ list.getItems().add("..");
+ File[] files = directory.listFiles();
+ if (files != null) {
+ for (File file : files) {
+ list.getItems().add(file.isDirectory() ? "[" + file.getName() + "]" : file.getName());
+ }
+ }
+ if (list == left) {
+ leftPathLabel.setText(directory.getAbsolutePath());
+ } else {
+ rightPathLabel.setText(directory.getAbsolutePath());
+ }
+ }
+
+ private void handleNavigation(ListView list, boolean isLeft) {
+ String selected = list.getSelectionModel().getSelectedItem();
+ if (selected == null) return;
+
+ File currentDir = isLeft ? leftDirectory : rightDirectory;
+ File nextDirectory;
+
+ if (selected.equals("..")) {
+ nextDirectory = currentDir.getParentFile();
+ } else {
+ String name = selected.replace("[", "").replace("]", "");
+ nextDirectory = new File(currentDir, name);
+ }
+ if (nextDirectory != null && nextDirectory.isDirectory()) {
+ if (isLeft) {
+ leftDirectory = nextDirectory;
+ } else {
+ rightDirectory = nextDirectory;
+ }
+ refresh(list, nextDirectory);
+ }
+ }
+
+ private void moveFile() {
+ boolean moveFromLeft = left.getSelectionModel().getSelectedItem() != null;
+ ListView fromList = moveFromLeft ? left : right;
+ File fromDirectory = moveFromLeft ? leftDirectory : rightDirectory;
+ File toDirectory = moveFromLeft ? rightDirectory : leftDirectory;
+
+ String selected = fromList.getSelectionModel().getSelectedItem();
+
+ if (selected == null || selected.equals("..")) {
+ return;
+ }
+
+ String name = selected.replace("[", "").replace("]", "");
+ Path source = new File(fromDirectory, name).toPath();
+ Path destination = new File(toDirectory, name).toPath();
+
+ try {
+ Files.move(source, destination, StandardCopyOption.REPLACE_EXISTING);
+ refresh(left, leftDirectory);
+ refresh(right, rightDirectory);
+ } catch (IOException e) {
+ System.err.println("Анлак, не удалось перенести: " + e.getMessage());
+ }
+ }
+}
+=======
@FXML
public Button move;
@@ -43,3 +150,4 @@ public void initialize() {
});
}
}
+>>>>>>> 1c195628027c24a0d2a677be0bd75b5381ae77e5
diff --git a/commander/src/main/resources/hse/java/commander/commander-ui.fxml b/commander/src/main/resources/hse/java/commander/commander-ui.fxml
index 724bbc8a..3eaf10f9 100644
--- a/commander/src/main/resources/hse/java/commander/commander-ui.fxml
+++ b/commander/src/main/resources/hse/java/commander/commander-ui.fxml
@@ -2,7 +2,31 @@
+
+<<<<<<< HEAD
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+=======
@@ -14,3 +38,4 @@
+>>>>>>> 1c195628027c24a0d2a677be0bd75b5381ae77e5
diff --git a/pom.xml b/pom.xml
index bb6d9b8a..54ba403b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -15,6 +15,8 @@
UTF-8
5.10.0
3.1.2
+
+ 1.18.38
@@ -61,6 +63,11 @@
${lombok.version}
+ ${maven.compiler.source}
+ ${maven.compiler.target}
+
+ -parameters
+
diff --git a/src/main/java/hse/java/lectures/lecture3/practice/randomSet/Node.java b/src/main/java/hse/java/lectures/lecture3/practice/randomSet/Node.java
new file mode 100644
index 00000000..d613e287
--- /dev/null
+++ b/src/main/java/hse/java/lectures/lecture3/practice/randomSet/Node.java
@@ -0,0 +1,32 @@
+package hse.java.lectures.lecture3.practice.randomSet;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+public class Node {
+ @Setter
+ private T value;
+ @Setter
+ private Node left;
+ @Setter
+ private Node right;
+ private int size;
+
+ public Node(T value) {
+ size = 1;
+ this.value = value;
+ this.left = null;
+ this.right = null;
+ }
+
+ public void recalculateSize() {
+ size = 1;
+ if (left != null) {
+ size += left.getSize();
+ }
+ if (right != null) {
+ size += right.getSize();
+ }
+ }
+}
diff --git a/src/main/java/hse/java/lectures/lecture3/practice/randomSet/Pair.java b/src/main/java/hse/java/lectures/lecture3/practice/randomSet/Pair.java
new file mode 100644
index 00000000..5e8b9193
--- /dev/null
+++ b/src/main/java/hse/java/lectures/lecture3/practice/randomSet/Pair.java
@@ -0,0 +1,4 @@
+package hse.java.lectures.lecture3.practice.randomSet;
+
+public record Pair(L left, R right) {
+}
diff --git a/src/main/java/hse/java/lectures/lecture3/practice/randomSet/RandomSet.java b/src/main/java/hse/java/lectures/lecture3/practice/randomSet/RandomSet.java
index 8af477b5..51e61ac1 100644
--- a/src/main/java/hse/java/lectures/lecture3/practice/randomSet/RandomSet.java
+++ b/src/main/java/hse/java/lectures/lecture3/practice/randomSet/RandomSet.java
@@ -1,21 +1,32 @@
package hse.java.lectures.lecture3.practice.randomSet;
-public class RandomSet {
+import java.util.Random;
+
+public class RandomSet> {
+ private final Treap treap;
+ private final Random random = new Random();
+
+ public RandomSet() {
+ treap = new Treap<>();
+ }
public boolean insert(T value) {
- throw new UnsupportedOperationException("Not implemented");
+ return treap.tryInsert(value);
}
public boolean remove(T value) {
- throw new UnsupportedOperationException("Not implemented");
+ return treap.tryRemove(value);
}
public boolean contains(T value) {
- throw new UnsupportedOperationException("Not implemented");
+ return treap.contains(value);
}
public T getRandom() {
- throw new UnsupportedOperationException("Not implemented");
+ if (treap.getSize() == 0) {
+ throw new EmptySetException("Set is empty");
+ }
+ int randomIndex = random.nextInt(treap.getSize());
+ return treap.get(randomIndex);
}
-
}
diff --git a/src/main/java/hse/java/lectures/lecture3/practice/randomSet/Treap.java b/src/main/java/hse/java/lectures/lecture3/practice/randomSet/Treap.java
new file mode 100644
index 00000000..3e133b13
--- /dev/null
+++ b/src/main/java/hse/java/lectures/lecture3/practice/randomSet/Treap.java
@@ -0,0 +1,110 @@
+package hse.java.lectures.lecture3.practice.randomSet;
+
+import java.util.Optional;
+import java.util.Random;
+
+public class Treap> {
+ private Node root;
+ private final Random random;
+
+ public Treap() {
+ root = null;
+ random = new Random();
+ }
+
+ private boolean findByValue(Node node, T value) {
+ if (node == null) {
+ return false;
+ }
+ int compareResult = node.getValue().compareTo(value);
+ if (compareResult == 0) {
+ return true;
+ }
+ if (compareResult > 0) {
+ return findByValue(node.getLeft(), value);
+ }
+ return findByValue(node.getRight(), value);
+ }
+
+ private Optional findByIndex(Node currentNode, int index) {
+ if (currentNode == null) {
+ return Optional.empty();
+ }
+ int leftSize = currentNode.getLeft() != null ? currentNode.getLeft().getSize() : 0;
+ if (index < leftSize) {
+ return findByIndex(currentNode.getLeft(), index);
+ } else if (index == leftSize) {
+ return Optional.of(currentNode.getValue());
+ } else {
+ return findByIndex(currentNode.getRight(), index - leftSize - 1);
+ }
+ }
+
+ private Pair, Node> split(Node currentNode, T value) {
+ if (currentNode == null) {
+ return new Pair<>(null, null);
+ }
+ int compareResult = currentNode.getValue().compareTo(value);
+ if (compareResult == 0) {
+ return new Pair<>(currentNode.getLeft(), currentNode.getRight());
+ } else if (compareResult < 0) {
+ var splitResult = split(currentNode.getRight(), value);
+ currentNode.setRight(splitResult.left());
+ currentNode.recalculateSize();
+ return new Pair<>(currentNode, splitResult.right());
+ } else {
+ var splitResult = split(currentNode.getLeft(), value);
+ currentNode.setLeft(splitResult.right());
+ currentNode.recalculateSize();
+ return new Pair<>(splitResult.left(), currentNode);
+ }
+ }
+
+ private Node merge(Node leftNode, Node rightNode) {
+ if (leftNode == null) {
+ return rightNode;
+ }
+ if (rightNode == null) {
+ return leftNode;
+ }
+ if (random.nextInt(leftNode.getSize() + rightNode.getSize()) < leftNode.getSize()) {
+ leftNode.setRight(merge(leftNode.getRight(), rightNode));
+ leftNode.recalculateSize();
+ return leftNode;
+ } else {
+ rightNode.setLeft(merge(leftNode, rightNode.getLeft()));
+ rightNode.recalculateSize();
+ return rightNode;
+ }
+ }
+
+ public int getSize() {
+ return root != null ? root.getSize() : 0;
+ }
+
+ public boolean contains(T value) {
+ return findByValue(root, value);
+ }
+
+ public boolean tryInsert(T value) {
+ if (contains(value)) {
+ return false;
+ }
+ var splitResult = split(root, value);
+ root = merge(merge(splitResult.left(), new Node<>(value)), splitResult.right());
+ return true;
+ }
+
+ public boolean tryRemove(T value) {
+ if (!contains(value)) {
+ return false;
+ }
+ var splitResult = split(root, value);
+ root = merge(splitResult.left(), splitResult.right());
+ return true;
+ }
+
+ public T get(int index) {
+ return findByIndex(root, index).orElseThrow(() -> new IllegalArgumentException("Index out of bounds"));
+ }
+}
diff --git a/src/main/java/hse/java/lectures/lecture3/tasks/atm/Atm.java b/src/main/java/hse/java/lectures/lecture3/tasks/atm/Atm.java
index 08f551e4..af541449 100644
--- a/src/main/java/hse/java/lectures/lecture3/tasks/atm/Atm.java
+++ b/src/main/java/hse/java/lectures/lecture3/tasks/atm/Atm.java
@@ -1,6 +1,11 @@
package hse.java.lectures.lecture3.tasks.atm;
-import java.util.*;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
public class Atm {
public enum Denomination {
@@ -19,27 +24,87 @@ public enum Denomination {
int value() {
return value;
}
+ }
+
+ private Map banknotes = new EnumMap<>(Denomination.class);
- public static Denomination fromInt(int value) {
- return Arrays.stream(values()).filter(v -> v.value == value)
- .findFirst()
- .orElse(null);
+ private Denomination getDenominationByValue(int value) {
+ for (Denomination denomination : Denomination.values()) {
+ if (denomination.value() == value) {
+ return denomination;
+ }
}
+ throw new IllegalArgumentException("Invalid denomination value: " + value);
}
- private final Map banknotes = new EnumMap<>(Denomination.class);
-
public Atm() {
}
- public void deposit(Map banknotes){}
+ public void deposit(Map bills) {
+ if (bills == null) {
+ throw new InvalidDepositException("Bills map cannot be null");
+ }
+
+ for (Map.Entry entry : bills.entrySet()) {
+ int denominationValue = entry.getKey();
+ int count = entry.getValue();
+
+ if (count <= 0) {
+ throw new InvalidDepositException("Count must be positive for denomination: " + denominationValue);
+ }
- public Map withdraw(int amount) {
- return Map.of();
+ Denomination denomination;
+ try {
+ denomination = getDenominationByValue(denominationValue);
+ } catch (IllegalArgumentException e) {
+ throw new InvalidDepositException("Invalid denomination: " + denominationValue);
+ }
+
+ banknotes.put(denomination, banknotes.getOrDefault(denomination, 0) + count);
+ }
}
- public int getBalance() {
- return 0;
+ public Map withdraw(int amount) {
+ if (amount <= 0) {
+ throw new InvalidAmountException("Amount must be positive");
+ }
+
+ if (amount > getBalance()) {
+ throw new InsufficientFundsException("Not enough funds in the ATM");
+ }
+
+ Map result = new HashMap<>();
+ var banknoteCopy = new EnumMap<>(banknotes);
+
+
+ for (int i = Denomination.values().length - 1; i >= 0; i--) {
+ Denomination denomination = Denomination.values()[i];
+ int availableCount = banknotes.getOrDefault(denomination, 0);
+ int neededCount = amount / denomination.value();
+ int countToDispense = Math.min(availableCount, neededCount);
+
+ if (countToDispense > 0) {
+ result.put(denomination.value(), countToDispense);
+ amount -= countToDispense * denomination.value();
+ banknotes.put(denomination, availableCount - countToDispense);
+ }
+ }
+
+ if (amount != 0) {
+ banknotes = banknoteCopy;
+ throw new CannotDispenseException("Not enough funds in the ATM");
+ }
+
+ return result;
}
-}
+ public int getBalance() {
+ int result = 0;
+ for (Map.Entry entry : banknotes.entrySet()) {
+ Denomination denomination = entry.getKey();
+ int count = entry.getValue();
+ result += count * denomination.value();
+ }
+ return result;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/hse/java/lectures/lecture3/tasks/html/HtmlDocument.java b/src/main/java/hse/java/lectures/lecture3/tasks/html/HtmlDocument.java
index 1ddf27bf..b82e54fc 100644
--- a/src/main/java/hse/java/lectures/lecture3/tasks/html/HtmlDocument.java
+++ b/src/main/java/hse/java/lectures/lecture3/tasks/html/HtmlDocument.java
@@ -4,12 +4,18 @@
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
-import java.util.ArrayDeque;
-import java.util.Deque;
-import java.util.Set;
+import java.util.*;
public class HtmlDocument {
+ private static final Map allowedTags = Map.of(
+ "", "",
+ "", "",
+ "", "",
+ "", "
",
+ "", "
"
+ );
+
public HtmlDocument(String filePath) {
this(Path.of(filePath));
}
@@ -27,6 +33,135 @@ private String readFile(Path filePath) {
}
}
- private void validate(String content){}
+ private String ignoreAttributes(String tag) {
+ String lowerTag = tag.toLowerCase();
+ for (String allowed : allowedTags.keySet()) {
+ var expected = allowed.substring(1, allowed.length() - 1);
+ if (lowerTag.startsWith("<" + expected)) {
+ return "<" + expected + ">";
+ }
+ if (lowerTag.startsWith("";
+ }
+ }
+ return null;
+ }
+
+ private List extractRootTags(String content) {
+ List rootTags = new ArrayList<>();
+ int pos = 0;
+ int depth = 0;
+
+ while (pos < content.length()) {
+ int open = content.indexOf('<', pos);
+ if (open == -1) break;
+
+ int close = content.indexOf('>', open);
+ if (close == -1) break;
+
+ String tag = content.substring(open, close + 1).toLowerCase();
+ pos = close + 1;
+
+ if (tag.startsWith("");
+ int htmlClosePos = content.indexOf("