From c1d6b896d54b1d46a21619c41ef07e96607d315f Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 17 Aug 2025 19:46:01 +0300
Subject: [PATCH 01/45] AB

---
 src/main/java/algorithms/sprint0/AB.java      | 27 +++++++++++++++++++
 .../java/algorithms/sprint0/Solution.java     | 24 +++++++++++++++++
 2 files changed, 51 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint0/AB.java
 create mode 100644 src/main/java/algorithms/sprint0/Solution.java

diff --git a/src/main/java/algorithms/sprint0/AB.java b/src/main/java/algorithms/sprint0/AB.java
new file mode 100644
index 0000000..4475457
--- /dev/null
+++ b/src/main/java/algorithms/sprint0/AB.java
@@ -0,0 +1,27 @@
+package algorithms.sprint0;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Scanner;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class AB {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int a = sc.nextInt();
+        int b = sc.nextInt();
+        long sum = sum(a, b);
+        System.out.println(sum);
+    }
+
+    public static long sum(int a, int b) {
+        return a + b;
+    }
+
+    @Test
+    public void test() {
+        assertEquals(5, sum(2, 3));
+        assertEquals(-1, sum(-2, 1));
+    }
+}
diff --git a/src/main/java/algorithms/sprint0/Solution.java b/src/main/java/algorithms/sprint0/Solution.java
new file mode 100644
index 0000000..798ab2a
--- /dev/null
+++ b/src/main/java/algorithms/sprint0/Solution.java
@@ -0,0 +1,24 @@
+package algorithms.sprint0;// Java
+
+import java.io.*;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    public static void main(String[] args) throws IOException {
+        List<Integer> arr;
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
+            int n = Integer.parseInt(reader.readLine().strip());
+            arr = Arrays.stream(reader.readLine().strip().split(" "))
+                    .map(Integer::parseInt)
+                    .toList();
+        }
+        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
+        for (int i : arr) {
+            writer.write(String.valueOf(i));
+            writer.write(" ");
+        }
+        writer.flush();
+    }
+
+}
\ No newline at end of file

From 0670bb476b09a0a2515d8e146f42d7df5c07d0de Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 17 Aug 2025 22:41:28 +0300
Subject: [PATCH 02/45] Zip

---
 src/main/java/algorithms/sprint0/Zip.java | 62 +++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint0/Zip.java

diff --git a/src/main/java/algorithms/sprint0/Zip.java b/src/main/java/algorithms/sprint0/Zip.java
new file mode 100644
index 0000000..fa1ecbf
--- /dev/null
+++ b/src/main/java/algorithms/sprint0/Zip.java
@@ -0,0 +1,62 @@
+package algorithms.sprint0;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class Zip {
+
+    private static List<Integer> zip(List<Integer> a, List<Integer> b, int n) {
+        ArrayList<Integer> integers = new ArrayList<>();
+
+        for (int i = 0; i < n; i++) {
+            integers.add(a.get(i));
+            integers.add(b.get(i));
+        }
+        return integers;
+    }
+
+    public static void main(String[] args) throws IOException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out))) {
+            int n = Integer.parseInt(reader.readLine());
+            List<Integer> a = readList(reader);
+            List<Integer> b = readList(reader);
+            printList(zip(a, b, n), writer);
+        }
+    }
+
+    private static List<Integer> readList(BufferedReader reader) throws IOException {
+        return Arrays.stream(reader.readLine().split(" "))
+                .map(Integer::parseInt)
+                .collect(Collectors.toList());
+    }
+
+    private static <T> void printList(List<T> list, Writer writer) {
+        list.forEach(elem -> {
+                    try {
+                        writer.write(String.valueOf(elem));
+                        writer.write(" ");
+                    } catch (IOException ignored) {
+
+                    }
+                }
+        );
+    }
+
+    @Test
+    void test1() {
+        List<Integer> integers1 = List.of(1, 5, 6);
+        List<Integer> integers2 = List.of(7, 8, 9);
+        List<Integer> actualZip = zip(integers1, integers2, 3);
+
+        List<Integer> expected = List.of(1, 7, 5, 8, 6, 9);
+        assertEquals(expected, actualZip);
+    }
+}

From 602554648303c7f6fcb2d1b72ec41fd727bf847e Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 17 Aug 2025 22:45:55 +0300
Subject: [PATCH 03/45] Zip

---
 src/main/java/algorithms/sprint0/Zip.java | 33 ++++++++++++++---------
 1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/src/main/java/algorithms/sprint0/Zip.java b/src/main/java/algorithms/sprint0/Zip.java
index fa1ecbf..5d6b029 100644
--- a/src/main/java/algorithms/sprint0/Zip.java
+++ b/src/main/java/algorithms/sprint0/Zip.java
@@ -13,9 +13,10 @@
 public class Zip {
 
     private static List<Integer> zip(List<Integer> a, List<Integer> b, int n) {
-        ArrayList<Integer> integers = new ArrayList<>();
+        int min = Math.min(n, Math.min(a.size(), b.size()));
+        ArrayList<Integer> integers = new ArrayList<>(min * 2);
 
-        for (int i = 0; i < n; i++) {
+        for (int i = 0; i < min; i++) {
             integers.add(a.get(i));
             integers.add(b.get(i));
         }
@@ -33,21 +34,19 @@ public static void main(String[] args) throws IOException {
     }
 
     private static List<Integer> readList(BufferedReader reader) throws IOException {
-        return Arrays.stream(reader.readLine().split(" "))
+        return Arrays.stream(reader.readLine().split("\\s+"))
                 .map(Integer::parseInt)
                 .collect(Collectors.toList());
     }
 
     private static <T> void printList(List<T> list, Writer writer) {
-        list.forEach(elem -> {
-                    try {
-                        writer.write(String.valueOf(elem));
-                        writer.write(" ");
-                    } catch (IOException ignored) {
-
-                    }
-                }
-        );
+        for (T elem : list) {
+            try {
+                writer.write(String.valueOf(elem));
+                writer.write(" ");
+            } catch (IOException ignored) {
+            }
+        }
     }
 
     @Test
@@ -59,4 +58,14 @@ void test1() {
         List<Integer> expected = List.of(1, 7, 5, 8, 6, 9);
         assertEquals(expected, actualZip);
     }
+
+    @Test
+    void test2() {
+        List<Integer> integers1 = List.of(1, 5, 6);
+        List<Integer> integers2 = List.of(7, 8, 9);
+        List<Integer> actualZip = zip(integers1, integers2, 0);
+
+        List<Integer> expected = List.of();
+        assertEquals(expected, actualZip);
+    }
 }

From 27e4649c00c14df82da1a47457a0f8c5031c5288 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 17 Aug 2025 23:03:27 +0300
Subject: [PATCH 04/45] Zip

---
 src/main/java/algorithms/sprint0/Zip.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/main/java/algorithms/sprint0/Zip.java b/src/main/java/algorithms/sprint0/Zip.java
index 5d6b029..70b001f 100644
--- a/src/main/java/algorithms/sprint0/Zip.java
+++ b/src/main/java/algorithms/sprint0/Zip.java
@@ -13,6 +13,7 @@
 public class Zip {
 
     private static List<Integer> zip(List<Integer> a, List<Integer> b, int n) {
+        if (n < 0) throw new IllegalArgumentException("n >= 0 required");
         int min = Math.min(n, Math.min(a.size(), b.size()));
         ArrayList<Integer> integers = new ArrayList<>(min * 2);
 
@@ -26,7 +27,7 @@ private static List<Integer> zip(List<Integer> a, List<Integer> b, int n) {
     public static void main(String[] args) throws IOException {
         try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
              BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out))) {
-            int n = Integer.parseInt(reader.readLine());
+            int n = Integer.parseInt(reader.readLine().trim());
             List<Integer> a = readList(reader);
             List<Integer> b = readList(reader);
             printList(zip(a, b, n), writer);
@@ -34,7 +35,7 @@ public static void main(String[] args) throws IOException {
     }
 
     private static List<Integer> readList(BufferedReader reader) throws IOException {
-        return Arrays.stream(reader.readLine().split("\\s+"))
+        return Arrays.stream(reader.readLine().trim().split("\\s+"))
                 .map(Integer::parseInt)
                 .collect(Collectors.toList());
     }

From b5239c3688e8ded48c1cdb21b230a4689c05f7ac Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Mon, 18 Aug 2025 00:04:54 +0300
Subject: [PATCH 05/45] SlidingAverage

---
 .../algorithms/sprint0/SlidingAverage.java    | 112 ++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint0/SlidingAverage.java

diff --git a/src/main/java/algorithms/sprint0/SlidingAverage.java b/src/main/java/algorithms/sprint0/SlidingAverage.java
new file mode 100644
index 0000000..4837a41
--- /dev/null
+++ b/src/main/java/algorithms/sprint0/SlidingAverage.java
@@ -0,0 +1,112 @@
+package algorithms.sprint0;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class SlidingAverage {
+
+    private static List<Double> movingAverage(int n, List<Integer> arr, int windowSize) {
+        int minSize = Math.min(arr.size(), n);
+        int count = minSize - windowSize + 1;
+        if (windowSize <= 0 || count <= 0) return java.util.Collections.emptyList();
+        List<Double> result = new ArrayList<>(count);
+        long sum = 0;
+        for (int i = 0; i < windowSize; i++) sum += arr.get(i);
+        result.add(sum / (double) windowSize);
+        for (int i = windowSize; i < minSize; i++) {
+            sum += arr.get(i) - arr.get(i - windowSize);
+            result.add(sum / (double) windowSize);
+        }
+        return result;
+    }
+
+    public static void main(String[] args) throws IOException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out))) {
+            int n = readInt(reader);
+            List<Integer> arr = readList(reader);
+            int windowSize = readInt(reader);
+            List<Double> result = movingAverage(n, arr, windowSize);
+            for (double elem : result) {
+                writer.write(elem + " ");
+            }
+        }
+    }
+
+
+    private static int readInt(BufferedReader reader) throws IOException {
+        return Integer.parseInt(reader.readLine());
+    }
+
+    private static List<Integer> readList(BufferedReader reader) throws IOException {
+        return Arrays.asList(reader.readLine().split(" "))
+                .stream()
+                .map(elem -> Integer.parseInt(elem))
+                .collect(Collectors.toList());
+    }
+
+    private static void assertListDoubles(List<Double> actual, double... expected) {
+        assertEquals(expected.length, actual.size(), "size");
+        for (int i = 0; i < expected.length; i++) {
+            assertEquals(expected[i], actual.get(i), 1e-9, "idx=" + i);
+        }
+    }
+
+    @Test
+    void test1() {
+        List<Double> actual = movingAverage(7, List.of(1, 2, 3, 4, 5, 6, 7), 4);
+        assertListDoubles(actual, 2.5, 3.5, 4.5, 5.5);
+    }
+
+    @Test
+    void w1_returnsOriginalValues() {
+        List<Double> actual = movingAverage(7, List.of(1,2,3,4,5,6,7), 1);
+        assertListDoubles(actual, 1,2,3,4,5,6,7);
+    }
+
+    @Test
+    void wEqMin_singleAverage() {
+        List<Double> actual = movingAverage(7, List.of(1,2,3,4,5,6,7), 7);
+        assertListDoubles(actual, 4.0);
+    }
+
+    @Test
+    void wGreaterThanMin_empty() {
+        List<Double> actual = movingAverage(5, List.of(1,2,3,4,5,6,7), 6);
+        assertEquals(List.of(), actual);
+    }
+
+    @Test
+    void wZeroOrNegative_empty() {
+        assertEquals(List.of(), movingAverage(5, List.of(1,2,3,4,5), 0));
+        assertEquals(List.of(), movingAverage(5, List.of(1,2,3,4,5), -3));
+    }
+
+    @Test
+    void cutByN_truncatesAndAverages() {
+        List<Double> actual = movingAverage(5, List.of(1,2,3,4,5,6,7), 3);
+        // окна по первым 5 элементам: [1,2,3],[2,3,4],[3,4,5]
+        assertListDoubles(actual, 2.0, 3.0, 4.0);
+    }
+
+    @Test
+    void emptyArray_empty() {
+        List<Double> actual = movingAverage(10, List.of(), 3);
+        assertEquals(List.of(), actual);
+    }
+
+    @Test
+    void largeValues_noOverflowInSum() {
+        int M = Integer.MAX_VALUE;
+        List<Double> actual = movingAverage(4, List.of(M, M, M, M), 2);
+        // три окна: [M,M],[M,M],[M,M] → среднее = M
+        assertListDoubles(actual, M, M, M);
+    }
+}

From 3c8cfaa4fc637cd50dd068f3b13c3b3999d7d7ea Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Mon, 18 Aug 2025 00:16:45 +0300
Subject: [PATCH 06/45] Utils

---
 src/main/java/algorithms/sprint0/AB.java      | 49 +++++++++++-
 .../algorithms/sprint0/SlidingAverage.java    | 30 +++-----
 .../java/algorithms/sprint0/Solution.java     | 24 ------
 src/main/java/algorithms/sprint0/Utils.java   | 34 ++++++++
 src/main/java/algorithms/sprint0/Zip.java     | 77 ++++++++++++-------
 5 files changed, 142 insertions(+), 72 deletions(-)
 delete mode 100644 src/main/java/algorithms/sprint0/Solution.java
 create mode 100644 src/main/java/algorithms/sprint0/Utils.java

diff --git a/src/main/java/algorithms/sprint0/AB.java b/src/main/java/algorithms/sprint0/AB.java
index 4475457..5258660 100644
--- a/src/main/java/algorithms/sprint0/AB.java
+++ b/src/main/java/algorithms/sprint0/AB.java
@@ -1,10 +1,19 @@
 package algorithms.sprint0;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
+import java.util.InputMismatchException;
 import java.util.Scanner;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class AB {
     public static void main(String[] args) {
@@ -16,7 +25,7 @@ public static void main(String[] args) {
     }
 
     public static long sum(int a, int b) {
-        return a + b;
+        return (long) a + b;
     }
 
     @Test
@@ -24,4 +33,42 @@ public void test() {
         assertEquals(5, sum(2, 3));
         assertEquals(-1, sum(-2, 1));
     }
+
+    @ParameterizedTest
+    @CsvSource({
+            "0,0,0",
+            "2,3,5",
+            "-1,4,3",
+            "2147483647,1,2147483648",
+            "2000000000,2000000000,4000000000"
+    })
+    void sum_works(int a, int b, long expected) {
+        assertEquals(expected, AB.sum(a, b));
+    }
+
+    @Test
+    void main_prints_sum_basic() {
+        String in = "2 3\n";
+        InputStream oldIn = System.in;
+        PrintStream oldOut = System.out;
+        try {
+            System.setIn(new ByteArrayInputStream(in.getBytes(StandardCharsets.UTF_8)));
+            ByteArrayOutputStream buf = new ByteArrayOutputStream();
+            System.setOut(new PrintStream(buf, true, StandardCharsets.UTF_8));
+
+            AB.main(new String[0]);
+
+            String nl = System.lineSeparator();
+            assertEquals("5" + nl, buf.toString(StandardCharsets.UTF_8));
+        } finally {
+            System.setIn(oldIn);
+            System.setOut(oldOut);
+        }
+    }
+
+    @Test
+    void main_bad_input_throws() {
+        System.setIn(new ByteArrayInputStream("x y\n".getBytes(StandardCharsets.UTF_8)));
+        assertThrows(InputMismatchException.class, () -> AB.main(new String[0]));
+    }
 }
diff --git a/src/main/java/algorithms/sprint0/SlidingAverage.java b/src/main/java/algorithms/sprint0/SlidingAverage.java
index 4837a41..e5775bd 100644
--- a/src/main/java/algorithms/sprint0/SlidingAverage.java
+++ b/src/main/java/algorithms/sprint0/SlidingAverage.java
@@ -4,10 +4,10 @@
 
 import java.io.*;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
-import java.util.stream.Collectors;
 
+import static algorithms.sprint0.Utils.readInt;
+import static algorithms.sprint0.Utils.readList;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class SlidingAverage {
@@ -40,18 +40,6 @@ public static void main(String[] args) throws IOException {
         }
     }
 
-
-    private static int readInt(BufferedReader reader) throws IOException {
-        return Integer.parseInt(reader.readLine());
-    }
-
-    private static List<Integer> readList(BufferedReader reader) throws IOException {
-        return Arrays.asList(reader.readLine().split(" "))
-                .stream()
-                .map(elem -> Integer.parseInt(elem))
-                .collect(Collectors.toList());
-    }
-
     private static void assertListDoubles(List<Double> actual, double... expected) {
         assertEquals(expected.length, actual.size(), "size");
         for (int i = 0; i < expected.length; i++) {
@@ -67,31 +55,31 @@ void test1() {
 
     @Test
     void w1_returnsOriginalValues() {
-        List<Double> actual = movingAverage(7, List.of(1,2,3,4,5,6,7), 1);
-        assertListDoubles(actual, 1,2,3,4,5,6,7);
+        List<Double> actual = movingAverage(7, List.of(1, 2, 3, 4, 5, 6, 7), 1);
+        assertListDoubles(actual, 1, 2, 3, 4, 5, 6, 7);
     }
 
     @Test
     void wEqMin_singleAverage() {
-        List<Double> actual = movingAverage(7, List.of(1,2,3,4,5,6,7), 7);
+        List<Double> actual = movingAverage(7, List.of(1, 2, 3, 4, 5, 6, 7), 7);
         assertListDoubles(actual, 4.0);
     }
 
     @Test
     void wGreaterThanMin_empty() {
-        List<Double> actual = movingAverage(5, List.of(1,2,3,4,5,6,7), 6);
+        List<Double> actual = movingAverage(5, List.of(1, 2, 3, 4, 5, 6, 7), 6);
         assertEquals(List.of(), actual);
     }
 
     @Test
     void wZeroOrNegative_empty() {
-        assertEquals(List.of(), movingAverage(5, List.of(1,2,3,4,5), 0));
-        assertEquals(List.of(), movingAverage(5, List.of(1,2,3,4,5), -3));
+        assertEquals(List.of(), movingAverage(5, List.of(1, 2, 3, 4, 5), 0));
+        assertEquals(List.of(), movingAverage(5, List.of(1, 2, 3, 4, 5), -3));
     }
 
     @Test
     void cutByN_truncatesAndAverages() {
-        List<Double> actual = movingAverage(5, List.of(1,2,3,4,5,6,7), 3);
+        List<Double> actual = movingAverage(5, List.of(1, 2, 3, 4, 5, 6, 7), 3);
         // окна по первым 5 элементам: [1,2,3],[2,3,4],[3,4,5]
         assertListDoubles(actual, 2.0, 3.0, 4.0);
     }
diff --git a/src/main/java/algorithms/sprint0/Solution.java b/src/main/java/algorithms/sprint0/Solution.java
deleted file mode 100644
index 798ab2a..0000000
--- a/src/main/java/algorithms/sprint0/Solution.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package algorithms.sprint0;// Java
-
-import java.io.*;
-import java.util.Arrays;
-import java.util.List;
-
-public class Solution {
-    public static void main(String[] args) throws IOException {
-        List<Integer> arr;
-        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
-            int n = Integer.parseInt(reader.readLine().strip());
-            arr = Arrays.stream(reader.readLine().strip().split(" "))
-                    .map(Integer::parseInt)
-                    .toList();
-        }
-        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
-        for (int i : arr) {
-            writer.write(String.valueOf(i));
-            writer.write(" ");
-        }
-        writer.flush();
-    }
-
-}
\ No newline at end of file
diff --git a/src/main/java/algorithms/sprint0/Utils.java b/src/main/java/algorithms/sprint0/Utils.java
new file mode 100644
index 0000000..50228a6
--- /dev/null
+++ b/src/main/java/algorithms/sprint0/Utils.java
@@ -0,0 +1,34 @@
+package algorithms.sprint0;
+
+import lombok.experimental.UtilityClass;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@UtilityClass
+public class Utils {
+
+    public static List<Integer> readList(BufferedReader reader) throws IOException {
+        return Arrays.stream(reader.readLine().trim().split("\\s+"))
+                .map(Integer::parseInt)
+                .collect(Collectors.toList());
+    }
+
+    public static <T> void printList(List<T> list, Writer writer) {
+        for (T elem : list) {
+            try {
+                writer.write(String.valueOf(elem));
+                writer.write(" ");
+            } catch (IOException ignored) {
+            }
+        }
+    }
+
+    public static int readInt(BufferedReader reader) throws IOException {
+        return Integer.parseInt(reader.readLine());
+    }
+}
diff --git a/src/main/java/algorithms/sprint0/Zip.java b/src/main/java/algorithms/sprint0/Zip.java
index 70b001f..257ef4a 100644
--- a/src/main/java/algorithms/sprint0/Zip.java
+++ b/src/main/java/algorithms/sprint0/Zip.java
@@ -6,9 +6,10 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.stream.Collectors;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static algorithms.sprint0.Utils.printList;
+import static algorithms.sprint0.Utils.readList;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class Zip {
 
@@ -34,39 +35,63 @@ public static void main(String[] args) throws IOException {
         }
     }
 
-    private static List<Integer> readList(BufferedReader reader) throws IOException {
-        return Arrays.stream(reader.readLine().trim().split("\\s+"))
-                .map(Integer::parseInt)
-                .collect(Collectors.toList());
+    @Test
+    void equalLength_nEqualsSize() {
+        List<Integer> a = Arrays.asList(1, 3, 5);
+        List<Integer> b = Arrays.asList(2, 4, 6);
+        assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), zip(a, b, 3));
     }
 
-    private static <T> void printList(List<T> list, Writer writer) {
-        for (T elem : list) {
-            try {
-                writer.write(String.valueOf(elem));
-                writer.write(" ");
-            } catch (IOException ignored) {
-            }
-        }
+    @Test
+    void nSmallerThanSizes() {
+        List<Integer> a = Arrays.asList(10, 30, 50);
+        List<Integer> b = Arrays.asList(20, 40, 60);
+        assertEquals(Arrays.asList(10, 20, 30, 40), zip(a, b, 2));
+    }
+
+    @Test
+    void nZero_returnsEmpty() {
+        List<Integer> a = Arrays.asList(1, 3, 5);
+        List<Integer> b = Arrays.asList(2, 4, 6);
+        assertTrue(zip(a, b, 0).isEmpty());
+    }
+
+    @Test
+    void nGreaterThanSizes_clampedToMin() {
+        List<Integer> a = Arrays.asList(1, 3, 5);
+        List<Integer> b = Arrays.asList(2, 4, 6);
+        assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), zip(a, b, 10));
+    }
+
+    @Test
+    void oneListShorter_minByShorter() {
+        List<Integer> a = List.of(1);
+        List<Integer> b = Arrays.asList(2, 4, 6);
+        assertEquals(Arrays.asList(1, 2), zip(a, b, 3));
     }
 
     @Test
-    void test1() {
-        List<Integer> integers1 = List.of(1, 5, 6);
-        List<Integer> integers2 = List.of(7, 8, 9);
-        List<Integer> actualZip = zip(integers1, integers2, 3);
+    void emptyLists_anyN_returnsEmpty() {
+        List<Integer> a = List.of();
+        List<Integer> b = List.of();
+        assertTrue(zip(a, b, 5).isEmpty());
+    }
 
-        List<Integer> expected = List.of(1, 7, 5, 8, 6, 9);
-        assertEquals(expected, actualZip);
+    @Test
+    void negativeN_throwsIAE_withMessage() {
+        IllegalArgumentException ex =
+                assertThrows(IllegalArgumentException.class,
+                        () -> zip(List.of(1), List.of(2), -1));
+        assertTrue(ex.getMessage().contains("n >= 0"));
     }
 
     @Test
-    void test2() {
-        List<Integer> integers1 = List.of(1, 5, 6);
-        List<Integer> integers2 = List.of(7, 8, 9);
-        List<Integer> actualZip = zip(integers1, integers2, 0);
+    void nullA_throwsNPE() {
+        assertThrows(NullPointerException.class, () -> zip(null, List.of(2), 1));
+    }
 
-        List<Integer> expected = List.of();
-        assertEquals(expected, actualZip);
+    @Test
+    void nullB_throwsNPE() {
+        assertThrows(NullPointerException.class, () -> zip(List.of(1), null, 1));
     }
 }

From 86d31922f5ad8a2a97d4646da69029bb78cf8b2f Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Mon, 18 Aug 2025 00:29:52 +0300
Subject: [PATCH 07/45] Utils

---
 pom.xml                                     |   1 -
 src/main/java/algorithms/sprint0/Utils.java | 130 ++++++++++++++++++--
 2 files changed, 123 insertions(+), 8 deletions(-)

diff --git a/pom.xml b/pom.xml
index 7fced37..092333f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -17,7 +17,6 @@
                     <source>21</source>
                     <target>17</target>
                     <release>17</release>
-                    <compilerArgs>--enable-preview</compilerArgs>
                 </configuration>
             </plugin>
         </plugins>
diff --git a/src/main/java/algorithms/sprint0/Utils.java b/src/main/java/algorithms/sprint0/Utils.java
index 50228a6..17be8f2 100644
--- a/src/main/java/algorithms/sprint0/Utils.java
+++ b/src/main/java/algorithms/sprint0/Utils.java
@@ -1,19 +1,23 @@
 package algorithms.sprint0;
 
-import lombok.experimental.UtilityClass;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.junit.jupiter.api.Test;
 
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.Writer;
+import java.io.*;
 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 
-@UtilityClass
+import static org.junit.jupiter.api.Assertions.*;
+
+@NoArgsConstructor(access = AccessLevel.PUBLIC)
 public class Utils {
 
     public static List<Integer> readList(BufferedReader reader) throws IOException {
-        return Arrays.stream(reader.readLine().trim().split("\\s+"))
+        String line = reader.readLine();
+        if (line == null) throw new NumberFormatException("EOF");
+        return Arrays.stream(line.trim().split("\\s+"))
                 .map(Integer::parseInt)
                 .collect(Collectors.toList());
     }
@@ -29,6 +33,118 @@ public static <T> void printList(List<T> list, Writer writer) {
     }
 
     public static int readInt(BufferedReader reader) throws IOException {
-        return Integer.parseInt(reader.readLine());
+        String line = reader.readLine();
+        if (line == null) throw new NumberFormatException("EOF");
+        return Integer.parseInt(line);
+    }
+
+    @Test
+    public void readListbasic() throws Exception {
+        BufferedReader br = new BufferedReader(new StringReader("1 2 3"));
+        List<Integer> got = readList(br);
+        assertEquals(Arrays.asList(1, 2, 3), got);
+    }
+
+    @Test
+    void readList_mixedWhitespace_and_signs() throws Exception {
+        BufferedReader br = new BufferedReader(new StringReader("  -1\t0   5  "));
+        List<Integer> got = readList(br);
+        assertEquals(Arrays.asList(-1, 0, 5), got);
+    }
+
+    @Test
+    void readList_emptyLine_throwsNumberFormat() {
+        BufferedReader br = new BufferedReader(new StringReader("\\n"));
+        assertThrows(NumberFormatException.class, () -> readList(br));
+    }
+
+    @Test
+    void readList_EOF_throwsNumberFormat() {
+        BufferedReader br = new BufferedReader(new StringReader(""));
+        assertThrows(NumberFormatException.class, () -> readList(br));
+    }
+
+    @Test
+    void readList_nonIntegerToken_throwsNumberFormat() {
+        BufferedReader br = new BufferedReader(new StringReader("1 a 3"));
+        assertThrows(NumberFormatException.class, () -> readList(br));
+    }
+
+    @Test
+    void readList_overflow_throwsNumberFormat() {
+        BufferedReader br = new BufferedReader(new StringReader("2147483648"));
+        assertThrows(NumberFormatException.class, () -> readList(br));
+    }
+
+    // --- readInt ---
+
+    @Test
+    void readInt_basic() throws Exception {
+        BufferedReader br = new BufferedReader(new StringReader("42"));
+        assertEquals(42, readInt(br));
+    }
+
+    @Test
+    void readInt_negative() throws Exception {
+        BufferedReader br = new BufferedReader(new StringReader("-7"));
+        assertEquals(-7, readInt(br));
+    }
+
+    @Test
+    void readInt_withSpaces_throwsNumberFormat() {
+        BufferedReader br = new BufferedReader(new StringReader(" 42 "));
+        assertThrows(NumberFormatException.class, () -> readInt(br));
+    }
+
+    // --- printList ---
+
+    @Test
+    void printList_integers_trailingSpace_noNewline() throws Exception {
+        StringWriter sw = new StringWriter();
+        printList(Arrays.asList(1, 2, 3), sw);
+        assertEquals("1 2 3 ", sw.toString());
+    }
+
+    @Test
+    void printList_strings_usesToString() throws Exception {
+        StringWriter sw = new StringWriter();
+        printList(Arrays.asList("a", "b"), sw);
+        assertEquals("a b ", sw.toString());
+    }
+
+    @Test
+    void printList_empty_writesNothing() throws Exception {
+        StringWriter sw = new StringWriter();
+        printList(List.of(), sw);
+        assertEquals("", sw.toString());
+    }
+
+    @Test
+    void printList_ioExceptions_areSwallowed() {
+        Writer throwing = new Writer() {
+            @Override
+            public void write(char[] cbuf, int off, int len) throws IOException {
+                throw new IOException("boom");
+            }
+
+            @Override
+            public void flush() {
+            }
+
+            @Override
+            public void close() {
+            }
+
+            @Override
+            public void write(String str) throws IOException {
+                throw new IOException("boom");
+            }
+
+            @Override
+            public void write(int c) throws IOException {
+                throw new IOException("boom");
+            }
+        };
+        assertDoesNotThrow(() -> printList(Arrays.asList(1, 2, 3), throwing));
     }
 }

From ac301e61a61b38f1714623bf003330da213bb787 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Mon, 18 Aug 2025 00:30:34 +0300
Subject: [PATCH 08/45] Utils

---
 src/main/java/algorithms/sprint0/Utils.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/algorithms/sprint0/Utils.java b/src/main/java/algorithms/sprint0/Utils.java
index 17be8f2..37b903b 100644
--- a/src/main/java/algorithms/sprint0/Utils.java
+++ b/src/main/java/algorithms/sprint0/Utils.java
@@ -11,7 +11,7 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 
-@NoArgsConstructor(access = AccessLevel.PUBLIC)
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
 public class Utils {
 
     public static List<Integer> readList(BufferedReader reader) throws IOException {

From 2055d7247b7a545c94f509ff3800400d0cf2d134 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 15 Feb 2026 20:57:04 +0300
Subject: [PATCH 09/45] Solution2

---
 .../java/algorithms/sprint1/Solution2.java    | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint1/Solution2.java

diff --git a/src/main/java/algorithms/sprint1/Solution2.java b/src/main/java/algorithms/sprint1/Solution2.java
new file mode 100644
index 0000000..dcf5542
--- /dev/null
+++ b/src/main/java/algorithms/sprint1/Solution2.java
@@ -0,0 +1,55 @@
+package algorithms.sprint1;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+// <template>
+class Node<V> {
+    public V value;
+    public Node<V> next;
+
+    public Node(V value, Node<V> next) {
+        this.value = value;
+        this.next = next;
+    }
+}
+// <template>
+
+public class Solution2 {
+    public static void solution(Node<String> head) {
+        // Your code
+        // ヽ(´▽`)/
+    }
+
+    private static void test() {
+        Node<String> node3 = new Node<>("node3", null);
+        Node<String> node2 = new Node<>("node2", node3);
+        Node<String> node1 = new Node<>("node1", node2);
+        Node<String> node0 = new Node<>("node0", node1);
+        solution(node0);
+        /*
+        Output is:
+        node0
+        node1
+        node2
+        node3
+        */
+    }
+
+    public static void main(String[] args) throws IOException {
+        StringBuilder output_buffer = new StringBuilder();
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        int num_lines = Integer.parseInt(reader.readLine());
+        for (int i = 0; i < num_lines; ++i) {
+            StringTokenizer tokenizer = new StringTokenizer(reader.readLine());
+            int value_1 = Integer.parseInt(tokenizer.nextToken());
+            int value_2 = Integer.parseInt(tokenizer.nextToken());
+            int result = value_1 + value_2;
+            output_buffer.append(result).append("\n");
+        }
+        System.out.println(output_buffer.toString());
+    }
+    
+}
\ No newline at end of file

From b48ddcb6c1d887673f7f3f03249f9effabd56640 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 15 Feb 2026 20:57:24 +0300
Subject: [PATCH 10/45] Distances

---
 input.txt                                     |   0
 output.txt                                    |   0
 .../java/algorithms/sprint1/Distances.java    | 165 ++++++++++++++++++
 3 files changed, 165 insertions(+)
 create mode 100644 input.txt
 create mode 100644 output.txt
 create mode 100644 src/main/java/algorithms/sprint1/Distances.java

diff --git a/input.txt b/input.txt
new file mode 100644
index 0000000..e69de29
diff --git a/output.txt b/output.txt
new file mode 100644
index 0000000..e69de29
diff --git a/src/main/java/algorithms/sprint1/Distances.java b/src/main/java/algorithms/sprint1/Distances.java
new file mode 100644
index 0000000..6eb879c
--- /dev/null
+++ b/src/main/java/algorithms/sprint1/Distances.java
@@ -0,0 +1,165 @@
+import java.io.*;
+import java.util.Arrays;
+
+public class Distances {
+
+    // -------------------- SOLUTION --------------------
+    static int[] solve(int[] a) {
+        int n = a.length;
+        int[] dist = new int[n];
+
+        int lastZero = -1;
+        for (int i = 0; i < n; i++) {
+            if (a[i] == 0) {
+                lastZero = i;
+                dist[i] = 0;
+            } else if (lastZero != -1) {
+                dist[i] = i - lastZero;
+            } else {
+                dist[i] = -1;
+            }
+        }
+
+        int nextZero = -1;
+        for (int i = n - 1; i >= 0; i--) {
+            if (a[i] == 0) {
+                nextZero = i;
+                dist[i] = 0;
+            } else if (nextZero != -1) {
+                int right = nextZero - i;
+                dist[i] = (dist[i] == -1) ? right : Math.min(dist[i], right);
+            }
+        }
+
+        return dist;
+    }
+
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0, len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+                if (len <= 0) return -1;
+            }
+            return buf[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) throw new EOFException("Unexpected EOF");
+            } while (c <= ' ');
+
+            int sign = 1;
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int val = 0;
+            while (c > ' ') {
+                val = val * 10 + (c - '0');
+                c = read();
+            }
+            return val * sign;
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+        private final byte[] tmp = new byte[12];
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) flush();
+            buf[p++] = (byte) b;
+        }
+
+        void writeInt(int x) throws IOException {
+            if (x == 0) {
+                writeByte('0');
+                return;
+            }
+            if (x < 0) {
+                writeByte('-');
+                x = -x;
+            }
+
+            int k = 0;
+            while (x > 0) {
+                tmp[k++] = (byte) ('0' + (x % 10));
+                x /= 10;
+            }
+            for (int i = k - 1; i >= 0; i--) writeByte(tmp[i]);
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
+    // -------------------- INPUT / OUTPUT --------------------
+    static void run() {
+
+        try (InputStream input = new BufferedInputStream(new FileInputStream("input.txt")); OutputStream output = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
+
+
+            FastIn in = new FastIn(input);
+            FastOut out = new FastOut(output);
+
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = in.nextInt();
+
+            int[] dist = solve(a);
+
+            for (int i = 0; i < n; i++) {
+                if (i > 0) out.writeByte(' ');
+                out.writeInt(dist[i]);
+            }
+            out.writeByte('\n');
+            out.flush();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    // -------------------- TESTS --------------------
+    static void assertEq(int[] exp, int[] act, String name) {
+        if (!Arrays.equals(exp, act)) {
+            throw new AssertionError(name + "\nexp=" + Arrays.toString(exp) + "\nact=" + Arrays.toString(act));
+        }
+    }
+
+    static void test() {
+        assertEq(new int[]{0, 1, 2, 1, 0}, solve(new int[]{0, 1, 4, 9, 0}), "sample1");
+        assertEq(new int[]{0, 1, 2, 3, 4, 5}, solve(new int[]{0, 7, 9, 4, 8, 20}), "sample2");
+        assertEq(new int[]{0}, solve(new int[]{0}), "n=1");
+        assertEq(new int[]{0, 0, 0}, solve(new int[]{0, 0, 0}), "all zeros");
+        assertEq(new int[]{2, 1, 0, 1, 2}, solve(new int[]{5, 6, 0, 7, 8}), "zero in middle");
+        System.out.println("OK");
+    }
+
+    // -------------------- MAIN --------------------
+    public static void main(String[] args) throws Exception {
+        test();
+//        run();
+    }
+}

From 5654158a273a733c0bbbecf97f943ab8c520931a Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 15 Feb 2026 21:48:15 +0300
Subject: [PATCH 11/45] SleightOfHand

---
 .../algorithms/sprint1/SleightOfHand.java     | 236 ++++++++++++++++++
 1 file changed, 236 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint1/SleightOfHand.java

diff --git a/src/main/java/algorithms/sprint1/SleightOfHand.java b/src/main/java/algorithms/sprint1/SleightOfHand.java
new file mode 100644
index 0000000..3b54402
--- /dev/null
+++ b/src/main/java/algorithms/sprint1/SleightOfHand.java
@@ -0,0 +1,236 @@
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class SleightOfHand {
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0, len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+                if (len <= 0) return -1;
+            }
+            return buf[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) throw new EOFException("Unexpected EOF");
+            } while (c <= ' ');
+
+            int sign = 1;
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int val = 0;
+            while (c > ' ') {
+                val = val * 10 + (c - '0');
+                c = read();
+            }
+            return val * sign;
+        }
+
+        String next() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) throw new EOFException("Unexpected EOF");
+            } while (c <= ' ');
+
+            byte[] tmp = new byte[32];
+            int n = 0;
+            while (c > ' ') {
+                if (n == tmp.length) {
+                    byte[] t2 = new byte[tmp.length * 2];
+                    System.arraycopy(tmp, 0, t2, 0, tmp.length);
+                    tmp = t2;
+                }
+                tmp[n++] = (byte) c;
+                c = read();
+                if (c == -1) break;
+            }
+            return new String(tmp, 0, n);
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+        private final byte[] tmp = new byte[12];
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) flush();
+            buf[p++] = (byte) b;
+        }
+
+        void writeInt(int x) throws IOException {
+            if (x == 0) {
+                writeByte('0');
+                return;
+            }
+            if (x < 0) {
+                writeByte('-');
+                x = -x;
+            }
+
+            int k = 0;
+            while (x > 0) {
+                tmp[k++] = (byte) ('0' + (x % 10));
+                x /= 10;
+            }
+            for (int i = k - 1; i >= 0; i--) writeByte(tmp[i]);
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+
+        int k = in.nextInt();
+        int limit = 2 * k;
+        int[] count = new int[10];
+
+        for (int r = 0; r < 4; r++) {
+            String s = in.next();
+            // На всякий случай, если токенайзер разделит строку (обычно не будет)
+            while (s.length() < 4) {
+                s += in.next();
+            }
+            for (int c = 0; c < 4; c++) {
+                char ch = s.charAt(c);
+                if (ch != '.') {
+                    count[ch - '0']++;
+                }
+            }
+        }
+
+        int points = 0;
+        for (int d = 1; d <= 9; d++) {
+            int cnt = count[d];
+            if (cnt != 0 && cnt <= limit) {
+                points++;
+            }
+        }
+
+        out.writeInt(points);
+        out.writeByte('\n');
+        out.flush();
+    }
+
+    private static void test() {
+        // Примеры из условия
+        assertEq(2, solve(3, new int[][]{
+                {1, 2, 3, 1},
+                {2, 0, 0, 2},
+                {2, 0, 0, 2},
+                {2, 0, 0, 2}
+        }));
+
+        assertEq(1, solve(4, new int[][]{
+                {1, 1, 1, 1},
+                {9, 9, 9, 9},
+                {1, 1, 1, 1},
+                {9, 9, 1, 1}
+        }));
+
+        assertEq(0, solve(1, new int[][]{
+                {1, 1, 1, 1},
+                {1, 1, 1, 1},
+                {1, 1, 1, 1},
+                {1, 1, 1, 1}
+        }));
+
+        // Критичный тест: ровно 2*k нажатий — очко должно засчитаться
+        assertEq(1, solve(2, new int[][]{
+                {5, 5, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0},
+                {5, 5, 0, 0}
+        }));
+
+        // Чуть больше лимита — очко не должно засчитаться
+        assertEq(0, solve(2, new int[][]{
+                {6, 6, 6, 0},
+                {6, 6, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0}
+        })); // 6 встречается 5 раз, limit=4
+
+        // Пустое поле
+        assertEq(0, solve(5, new int[][]{
+                {0, 0, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0}
+        }));
+
+        // Несколько цифр в пределах лимита
+        assertEq(2, solve(1, new int[][]{
+                {1, 1, 2, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0}
+        })); // limit=2, cnt(1)=2, cnt(2)=1
+
+        System.out.println("Test OK");
+    }
+
+    static int solve(int k, int[][] a) {
+        int points = 0;
+        final int limit = 2 * k;
+        final int[] count = new int[10];
+
+        for (int[] row : a) {
+            for (int v : row) {
+                if (v != 0) count[v]++;
+            }
+        }
+
+        for (int d = 1; d <= 9; d++) {
+            int cnt = count[d];
+            if (cnt != 0 && cnt <= limit) {
+                points++;
+            }
+        }
+        return points;
+    }
+
+    static void assertEq(int exp, int act) {
+        if (exp != act) {
+            throw new AssertionError("Expected=" + exp + ", actual=" + act);
+        }
+    }
+}

From 93d5c72c4ea497fb51c82c26e5d486eb34c99eaa Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Thu, 19 Feb 2026 22:02:10 +0300
Subject: [PATCH 12/45] Distances

---
 .../java/algorithms/sprint1/Distances.java    | 30 ++++++++-----------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/src/main/java/algorithms/sprint1/Distances.java b/src/main/java/algorithms/sprint1/Distances.java
index 6eb879c..aa8733c 100644
--- a/src/main/java/algorithms/sprint1/Distances.java
+++ b/src/main/java/algorithms/sprint1/Distances.java
@@ -1,6 +1,7 @@
 import java.io.*;
 import java.util.Arrays;
 
+// https://contest.yandex.ru/contest/22450/run-report/157017559/
 public class Distances {
 
     // -------------------- SOLUTION --------------------
@@ -8,29 +9,19 @@ static int[] solve(int[] a) {
         int n = a.length;
         int[] dist = new int[n];
 
-        int lastZero = -1;
+        int lastZero = -n;
         for (int i = 0; i < n; i++) {
             if (a[i] == 0) {
                 lastZero = i;
-                dist[i] = 0;
-            } else if (lastZero != -1) {
-                dist[i] = i - lastZero;
-            } else {
-                dist[i] = -1;
             }
+            dist[i] = i - lastZero;
         }
 
-        int nextZero = -1;
-        for (int i = n - 1; i >= 0; i--) {
-            if (a[i] == 0) {
-                nextZero = i;
-                dist[i] = 0;
-            } else if (nextZero != -1) {
-                int right = nextZero - i;
-                dist[i] = (dist[i] == -1) ? right : Math.min(dist[i], right);
-            }
+        int nextZero = n;
+        for (int i = lastZero; i >= 0; i--) {
+            if (a[i] == 0) nextZero = i;
+            dist[i] = Math.min(dist[i], nextZero - i);
         }
-
         return dist;
     }
 
@@ -159,7 +150,10 @@ static void test() {
 
     // -------------------- MAIN --------------------
     public static void main(String[] args) throws Exception {
-        test();
-//        run();
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
     }
 }

From b3134d4c41adb4b955a1a27b6de49c5a09c71f91 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Thu, 19 Feb 2026 22:03:46 +0300
Subject: [PATCH 13/45] Distances

---
 src/main/java/algorithms/sprint1/Distances.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/java/algorithms/sprint1/Distances.java b/src/main/java/algorithms/sprint1/Distances.java
index aa8733c..ede4bca 100644
--- a/src/main/java/algorithms/sprint1/Distances.java
+++ b/src/main/java/algorithms/sprint1/Distances.java
@@ -17,7 +17,7 @@ static int[] solve(int[] a) {
             dist[i] = i - lastZero;
         }
 
-        int nextZero = n;
+        int nextZero = lastZero;
         for (int i = lastZero; i >= 0; i--) {
             if (a[i] == 0) nextZero = i;
             dist[i] = Math.min(dist[i], nextZero - i);
@@ -25,6 +25,7 @@ static int[] solve(int[] a) {
         return dist;
     }
 
+
     // -------------------- FAST INPUT --------------------
     static final class FastIn {
         private final InputStream in;

From baac4447dce87404a6266b40d05e86bdbdd8fb6e Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Thu, 19 Feb 2026 22:04:15 +0300
Subject: [PATCH 14/45] Distances

---
 src/main/java/algorithms/sprint1/Distances.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/algorithms/sprint1/Distances.java b/src/main/java/algorithms/sprint1/Distances.java
index ede4bca..5392669 100644
--- a/src/main/java/algorithms/sprint1/Distances.java
+++ b/src/main/java/algorithms/sprint1/Distances.java
@@ -1,7 +1,7 @@
 import java.io.*;
 import java.util.Arrays;
 
-// https://contest.yandex.ru/contest/22450/run-report/157017559/
+// https://contest.yandex.ru/contest/22450/run-report/157289807/
 public class Distances {
 
     // -------------------- SOLUTION --------------------

From 96a27e518306af149d2b06c6de01a24e772aefc6 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Thu, 19 Feb 2026 22:04:50 +0300
Subject: [PATCH 15/45] SleightOfHand

---
 src/main/java/algorithms/sprint1/SleightOfHand.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/java/algorithms/sprint1/SleightOfHand.java b/src/main/java/algorithms/sprint1/SleightOfHand.java
index 3b54402..087bdb4 100644
--- a/src/main/java/algorithms/sprint1/SleightOfHand.java
+++ b/src/main/java/algorithms/sprint1/SleightOfHand.java
@@ -3,6 +3,7 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 
+// https://contest.yandex.ru/contest/22450/run-report/157017632/
 public class SleightOfHand {
     // -------------------- FAST INPUT --------------------
     static final class FastIn {

From be663328351420220cb5e72e4049c5a96256f5cd Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Thu, 19 Feb 2026 22:58:28 +0300
Subject: [PATCH 16/45] Deque

---
 src/main/java/algorithms/sprint2/Deque.java | 345 ++++++++++++++++++++
 1 file changed, 345 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint2/Deque.java

diff --git a/src/main/java/algorithms/sprint2/Deque.java b/src/main/java/algorithms/sprint2/Deque.java
new file mode 100644
index 0000000..76f7f3c
--- /dev/null
+++ b/src/main/java/algorithms/sprint2/Deque.java
@@ -0,0 +1,345 @@
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class Deque {
+
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0, len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+            return buf[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            int sign = 1;
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int val = 0;
+            while (c > ' ') {
+                val = val * 10 + (c - '0');
+                c = read();
+            }
+            return val * sign;
+        }
+
+        String next() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            byte[] tmp = new byte[32];
+            int n = 0;
+            while (c > ' ') {
+                if (n == tmp.length) {
+                    byte[] t2 = new byte[tmp.length * 2];
+                    System.arraycopy(tmp, 0, t2, 0, tmp.length);
+                    tmp = t2;
+                }
+                tmp[n++] = (byte) c;
+                c = read();
+                if (c == -1) {
+                    break;
+                }
+            }
+            return new String(tmp, 0, n);
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+        private final byte[] tmp = new byte[12];
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) {
+                flush();
+            }
+            buf[p++] = (byte) b;
+        }
+
+        void writeStr(String s) throws IOException {
+            for (int i = 0; i < s.length(); i++) {
+                writeByte(s.charAt(i));
+            }
+        }
+
+        void writeInt(int x) throws IOException {
+            if (x == 0) {
+                writeByte('0');
+                return;
+            }
+            if (x < 0) {
+                writeByte('-');
+                x = -x;
+            }
+
+            int k = 0;
+            while (x > 0) {
+                tmp[k++] = (byte) ('0' + (x % 10));
+                x /= 10;
+            }
+            for (int i = k - 1; i >= 0; i--) {
+                writeByte(tmp[i]);
+            }
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
+    // -------------------- RING BUFFER DEQUE --------------------
+    static final class RingDeque {
+        private final int[] a;
+        private final int cap;
+        private int head = 0; // индекс первого элемента
+        private int tail = 0; // индекс позиции "после последнего"
+        private int size = 0;
+
+        RingDeque(int cap) {
+            this.cap = cap;
+            this.a = new int[cap];
+        }
+
+        private int next(int i) {
+            i++;
+            if (i == cap) {
+                i = 0;
+            }
+            return i;
+        }
+
+        private int prev(int i) {
+            i--;
+            if (i == -1) {
+                i = cap - 1;
+            }
+            return i;
+        }
+
+        boolean isEmpty() {
+            return size == 0;
+        }
+
+        boolean isFull() {
+            return size == cap;
+        }
+
+        void pushBack(int x) {
+            a[tail] = x;
+            tail = next(tail);
+            size++;
+        }
+
+        void pushFront(int x) {
+            head = prev(head);
+            a[head] = x;
+            size++;
+        }
+
+        int popFront() {
+            int x = a[head];
+            head = next(head);
+            size--;
+            return x;
+        }
+
+        int popBack() {
+            tail = prev(tail);
+            int x = a[tail];
+            size--;
+            return x;
+        }
+    }
+
+    private static void process(FastIn in, FastOut out) throws Exception {
+        int n = in.nextInt();
+        int m = in.nextInt();
+
+        RingDeque dq = new RingDeque(m);
+
+        for (int i = 0; i < n; i++) {
+            String cmd = in.next();
+
+            if ("push_back".equals(cmd)) {
+                int x = in.nextInt();
+                if (dq.isFull()) {
+                    out.writeStr("error\n");
+                } else {
+                    dq.pushBack(x);
+                }
+            } else if ("push_front".equals(cmd)) {
+                int x = in.nextInt();
+                if (dq.isFull()) {
+                    out.writeStr("error\n");
+                } else {
+                    dq.pushFront(x);
+                }
+            } else if ("pop_front".equals(cmd)) {
+                if (dq.isEmpty()) {
+                    out.writeStr("error\n");
+                } else {
+                    out.writeInt(dq.popFront());
+                    out.writeByte('\n');
+                }
+            } else { // pop_back
+                if (dq.isEmpty()) {
+                    out.writeStr("error\n");
+                } else {
+                    out.writeInt(dq.popBack());
+                    out.writeByte('\n');
+                }
+            }
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+        process(in, out);
+        out.flush();
+    }
+
+    // -------------------- TESTS --------------------
+    private static String solveIO(String input) throws Exception {
+        ByteArrayInputStream bin = new ByteArrayInputStream(input.getBytes());
+        ByteArrayOutputStream bout = new ByteArrayOutputStream();
+        FastIn in = new FastIn(bin);
+        FastOut out = new FastOut(bout);
+        process(in, out);
+        out.flush();
+        return bout.toString();
+    }
+
+    private static void test() throws Exception {
+        // Пример 1
+        assertEq(
+                "861\n-819\n",
+                solveIO(
+                        "4\n" +
+                                "4\n" +
+                                "push_front 861\n" +
+                                "push_front -819\n" +
+                                "pop_back\n" +
+                                "pop_back\n"
+                )
+        );
+
+        // Пример 2
+        assertEq(
+                "-855\n0\n844\n",
+                solveIO(
+                        "7\n" +
+                                "10\n" +
+                                "push_front -855\n" +
+                                "push_front 0\n" +
+                                "pop_back\n" +
+                                "pop_back\n" +
+                                "push_back 844\n" +
+                                "pop_back\n" +
+                                "push_back 823\n"
+                )
+        );
+
+        // Пример 3
+        assertEq(
+                "20\n102\n",
+                solveIO(
+                        "6\n" +
+                                "6\n" +
+                                "push_front -201\n" +
+                                "push_back 959\n" +
+                                "push_back 102\n" +
+                                "push_front 20\n" +
+                                "pop_front\n" +
+                                "pop_back\n"
+                )
+        );
+
+        // Емкость 1 + переполнение
+        assertEq(
+                "error\n1\nerror\n",
+                solveIO(
+                        "4\n" +
+                                "1\n" +
+                                "push_front 1\n" +
+                                "push_back 2\n" +
+                                "pop_back\n" +
+                                "pop_front\n"
+                )
+        );
+
+        // Проверка кольцевого перехода (wrap-around)
+        assertEq(
+                "1\n4\n2\n3\n",
+                solveIO(
+                        "8\n" +
+                                "3\n" +
+                                "push_back 1\n" +
+                                "push_back 2\n" +
+                                "push_back 3\n" +
+                                "pop_front\n" +
+                                "push_back 4\n" +
+                                "pop_back\n" +
+                                "pop_front\n" +
+                                "pop_front\n"
+                )
+        );
+
+        System.out.println("Test OK");
+    }
+
+    static void assertEq(String exp, String act) {
+        if (!exp.equals(act)) {
+            throw new AssertionError("Expected:\n" + exp + "\nActual:\n" + act);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+}

From 4aea0f27972adb1f06d3c4ea20b802b46ea8d33b Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Thu, 19 Feb 2026 23:03:29 +0300
Subject: [PATCH 17/45] Deque

---
 src/main/java/algorithms/sprint2/Deque.java | 47 ++++++++++++++++++++-
 1 file changed, 45 insertions(+), 2 deletions(-)

diff --git a/src/main/java/algorithms/sprint2/Deque.java b/src/main/java/algorithms/sprint2/Deque.java
index 76f7f3c..db29013 100644
--- a/src/main/java/algorithms/sprint2/Deque.java
+++ b/src/main/java/algorithms/sprint2/Deque.java
@@ -5,6 +5,49 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 
+/*
+Принцип работы алгоритма
+Используется дек фиксированного размера m, реализованный на массиве как кольцевой буфер.
+Храним:
+- a[] — массив ёмкости m;
+- head — индекс первого элемента дека;
+- tail — индекс позиции "после последнего" элемента дека;
+- size — текущее количество элементов.
+
+Индексы head и tail двигаются по кругу: при выходе за границу массива переходят в начало/конец.
+Операции:
+- push_back(x): записать x в a[tail], сдвинуть tail вперёд по кругу, увеличить size.
+- push_front(x): сдвинуть head назад по кругу, записать x в a[head], увеличить size.
+- pop_front(): взять a[head], сдвинуть head вперёд, уменьшить size.
+- pop_back(): сдвинуть tail назад, взять a[tail], уменьшить size.
+
+Корректность (почему работает)
+Поддерживаются инварианты:
+1) size всегда в диапазоне [0..m].
+2) head указывает на первый элемент (если size > 0).
+3) tail указывает на позицию сразу после последнего элемента (если size > 0).
+4) Элементы дека в порядке обхода лежат в a по циклу, начиная с head и длиной size.
+
+Проверка по операциям:
+- push_back при size < m кладёт новый элемент ровно в позицию tail, затем tail сдвигается на следующую
+  позицию по кругу, поэтому tail снова указывает на "после последнего", а порядок элементов сохраняется.
+- push_front при size < m сначала сдвигает head на предыдущую позицию по кругу и кладёт туда новый элемент,
+  поэтому head начинает указывать на добавленный элемент (он становится первым), а порядок сохраняется.
+- pop_front при size > 0 читает первый элемент из a[head], затем сдвигает head вперёд, уменьшая size:
+  новым первым становится следующий элемент, инварианты сохраняются.
+- pop_back при size > 0 сначала сдвигает tail назад (на позицию последнего элемента), читает его и уменьшает size:
+  tail снова становится "после последнего", инварианты сохраняются.
+
+Ошибки "error" выводятся только когда операция невозможна:
+- push_* при size == m (переполнение),
+- pop_* при size == 0 (пустой дек).
+В этих случаях состояние (head, tail, size) не меняется, что сохраняет инварианты.
+
+Сложность
+Каждая операция дека выполняет константное число действий: O(1) по времени.
+Память: массив из m элементов и несколько целых переменных: O(m) по памяти.
+*/
+
 public class Deque {
 
     // -------------------- FAST INPUT --------------------
@@ -296,7 +339,7 @@ private static void test() throws Exception {
                 )
         );
 
-        // Емкость 1 + переполнение
+        // Емкость 1 + переполнение + попытка pop из пустого
         assertEq(
                 "error\n1\nerror\n",
                 solveIO(
@@ -309,7 +352,7 @@ private static void test() throws Exception {
                 )
         );
 
-        // Проверка кольцевого перехода (wrap-around)
+        // Wrap-around: head/tail должны корректно "перепрыгивать" границу массива
         assertEq(
                 "1\n4\n2\n3\n",
                 solveIO(

From fb3fdda7c9e24511e1fba07e0cd0746dcb52bd74 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Thu, 19 Feb 2026 23:03:41 +0300
Subject: [PATCH 18/45] Calculator

---
 .../java/algorithms/sprint2/Calculator.java   | 234 ++++++++++++++++++
 1 file changed, 234 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint2/Calculator.java

diff --git a/src/main/java/algorithms/sprint2/Calculator.java b/src/main/java/algorithms/sprint2/Calculator.java
new file mode 100644
index 0000000..d77747a
--- /dev/null
+++ b/src/main/java/algorithms/sprint2/Calculator.java
@@ -0,0 +1,234 @@
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/*
+Принцип работы алгоритма:
+- Выражение в обратной польской нотации читается слева направо по токенам (разделитель — пробел).
+- Используется стек целых чисел.
+  * Если токен — число, кладём его в стек.
+  * Если токен — операция (+, -, *, /), достаём два верхних значения b и a (сначала b, потом a),
+    вычисляем a (op) b и результат кладём обратно в стек.
+- После обработки всех токенов ответ — верхний элемент стека (даже если элементов больше одного).
+
+Корректность:
+- Инвариант: после обработки первых i токенов стек содержит значения всех уже полностью вычисленных
+  подвыражений, которые по правилам ОПН должны ждать дальнейших операций.
+- При чтении числа инвариант сохраняется: число становится готовым операндом и помещается в стек.
+- При чтении операции по определению ОПН она применяется к двум ближайшим слева операндам,
+  которые и лежат на вершине стека в нужном порядке добавления. Мы снимаем b и a и кладём результат,
+  тем самым заменяя эти два операнда на значение их подвыражения — инвариант сохраняется.
+- Для деления используется Math.floorDiv(a, b), что соответствует требованию “округление вниз” (floor).
+  По условию деления на отрицательное число нет, но a может быть отрицательным — floorDiv это корректно обрабатывает.
+
+Оценка сложности:
+- Время: O(m), где m — число токенов (каждый токен обрабатывается за O(1)).
+- Память: O(s), где s — максимальный размер стека (в худшем случае O(m)).
+*/
+public class Calculator {
+
+    // -------------------- SOLUTION --------------------
+    static int evalRpn(FastIn in) throws IOException {
+        IntStack st = new IntStack(64);
+
+        String tok;
+        while ((tok = in.nextOrNull()) != null) {
+            if (tok.length() == 1) {
+                char op = tok.charAt(0);
+                if (op == '+' || op == '-' || op == '*' || op == '/') {
+                    int b = st.pop();
+                    int a = st.pop();
+
+                    int r;
+                    if (op == '+') {
+                        r = a + b;
+                    } else if (op == '-') {
+                        r = a - b;
+                    } else if (op == '*') {
+                        r = a * b;
+                    } else {
+                        r = Math.floorDiv(a, b);
+                    }
+
+                    st.push(r);
+                    continue;
+                }
+            }
+            st.push(Integer.parseInt(tok));
+        }
+
+        return st.peek();
+    }
+
+    // -------------------- INT STACK --------------------
+    static final class IntStack {
+        private int[] a;
+        private int sz;
+
+        IntStack(int cap) {
+            this.a = new int[Math.max(2, cap)];
+            this.sz = 0;
+        }
+
+        void push(int v) {
+            if (sz == a.length) {
+                int[] b = new int[a.length << 1];
+                System.arraycopy(a, 0, b, 0, a.length);
+                a = b;
+            }
+            a[sz++] = v;
+        }
+
+        int pop() {
+            return a[--sz];
+        }
+
+        int peek() {
+            return a[sz - 1];
+        }
+    }
+
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0, len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+            return buf[ptr++];
+        }
+
+        String nextOrNull() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    return null;
+                }
+            } while (c <= ' ');
+
+            byte[] tmp = new byte[32];
+            int n = 0;
+
+            while (c > ' ') {
+                if (n == tmp.length) {
+                    byte[] t2 = new byte[tmp.length << 1];
+                    System.arraycopy(tmp, 0, t2, 0, tmp.length);
+                    tmp = t2;
+                }
+                tmp[n++] = (byte) c;
+
+                c = read();
+                if (c == -1) {
+                    break;
+                }
+            }
+
+            return new String(tmp, 0, n);
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+        private final byte[] tmp = new byte[12];
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) {
+                flush();
+            }
+            buf[p++] = (byte) b;
+        }
+
+        void writeInt(int x) throws IOException {
+            if (x == 0) {
+                writeByte('0');
+                return;
+            }
+            if (x < 0) {
+                writeByte('-');
+                x = -x;
+            }
+
+            int k = 0;
+            while (x > 0) {
+                tmp[k++] = (byte) ('0' + (x % 10));
+                x /= 10;
+            }
+            for (int i = k - 1; i >= 0; i--) {
+                writeByte(tmp[i]);
+            }
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+
+        int ans = evalRpn(in);
+
+        out.writeInt(ans);
+        out.writeByte('\n');
+        out.flush();
+    }
+
+    private static void test() throws Exception {
+        assertEq(9, evalFromString("2 1 + 3 *"));
+        assertEq(38, evalFromString("7 2 + 4 * 2 +"));
+
+        // деление “вниз”
+        assertEq(-1, evalFromString("-1 3 /"));
+        assertEq(-2, evalFromString("-4 3 /"));
+
+        // порядок операндов
+        assertEq(2, evalFromString("10 2 4 * -"));
+
+        // одно число
+        assertEq(5, evalFromString("5"));
+
+        System.out.println("Test OK");
+    }
+
+    private static int evalFromString(String s) throws Exception {
+        InputStream is = new java.io.ByteArrayInputStream(
+                s.getBytes(java.nio.charset.StandardCharsets.US_ASCII)
+        );
+        return evalRpn(new FastIn(is));
+    }
+
+    static void assertEq(int exp, int act) {
+        if (exp != act) {
+            throw new AssertionError("Expected=" + exp + ", actual=" + act);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+}

From 8b1fa1dd3d2492389393cdef46c34a8b14fac1db Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Fri, 20 Feb 2026 00:41:12 +0300
Subject: [PATCH 19/45] Calculator

---
 .../java/algorithms/sprint2/Calculator.java   | 111 +++++++-----------
 1 file changed, 40 insertions(+), 71 deletions(-)

diff --git a/src/main/java/algorithms/sprint2/Calculator.java b/src/main/java/algorithms/sprint2/Calculator.java
index d77747a..ebcf59a 100644
--- a/src/main/java/algorithms/sprint2/Calculator.java
+++ b/src/main/java/algorithms/sprint2/Calculator.java
@@ -1,40 +1,43 @@
+import java.io.ByteArrayInputStream;
+import java.io.EOFException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayDeque;
+import java.util.Deque;
 
 /*
-Принцип работы алгоритма:
-- Выражение в обратной польской нотации читается слева направо по токенам (разделитель — пробел).
-- Используется стек целых чисел.
-  * Если токен — число, кладём его в стек.
-  * Если токен — операция (+, -, *, /), достаём два верхних значения b и a (сначала b, потом a),
-    вычисляем a (op) b и результат кладём обратно в стек.
-- После обработки всех токенов ответ — верхний элемент стека (даже если элементов больше одного).
+Принцип:
+- Читаем токены ОПН слева направо.
+- Число -> push в стек.
+- Операция -> pop b, pop a, считаем a op b, push результат.
+- Ответ: верх стека.
 
 Корректность:
-- Инвариант: после обработки первых i токенов стек содержит значения всех уже полностью вычисленных
-  подвыражений, которые по правилам ОПН должны ждать дальнейших операций.
-- При чтении числа инвариант сохраняется: число становится готовым операндом и помещается в стек.
-- При чтении операции по определению ОПН она применяется к двум ближайшим слева операндам,
-  которые и лежат на вершине стека в нужном порядке добавления. Мы снимаем b и a и кладём результат,
-  тем самым заменяя эти два операнда на значение их подвыражения — инвариант сохраняется.
-- Для деления используется Math.floorDiv(a, b), что соответствует требованию “округление вниз” (floor).
-  По условию деления на отрицательное число нет, но a может быть отрицательным — floorDiv это корректно обрабатывает.
-
-Оценка сложности:
-- Время: O(m), где m — число токенов (каждый токен обрабатывается за O(1)).
-- Память: O(s), где s — максимальный размер стека (в худшем случае O(m)).
+- В ОПН операция применяется к двум ближайшим слева операндам; к моменту чтения операции они лежат
+  на вершине стека. Мы заменяем эти два значения на результат, сохраняя корректное состояние.
+- Деление требуется “вниз” (floor), поэтому используем Math.floorDiv(a, b).
+
+Сложность:
+- Время O(m), m — число токенов.
+- Память O(s), s — максимальный размер стека (в худшем O(m)).
 */
 public class Calculator {
 
-    // -------------------- SOLUTION --------------------
-    static int evalRpn(FastIn in) throws IOException {
-        IntStack st = new IntStack(64);
+    private static int eval(FastIn in) throws IOException {
+        Deque<Integer> st = new ArrayDeque<>();
+
+        while (true) {
+            String t;
+            try {
+                t = in.next();
+            } catch (EOFException e) {
+                break;
+            }
 
-        String tok;
-        while ((tok = in.nextOrNull()) != null) {
-            if (tok.length() == 1) {
-                char op = tok.charAt(0);
+            if (t.length() == 1) {
+                char op = t.charAt(0);
                 if (op == '+' || op == '-' || op == '*' || op == '/') {
                     int b = st.pop();
                     int a = st.pop();
@@ -54,45 +57,19 @@ static int evalRpn(FastIn in) throws IOException {
                     continue;
                 }
             }
-            st.push(Integer.parseInt(tok));
-        }
-
-        return st.peek();
-    }
-
-    // -------------------- INT STACK --------------------
-    static final class IntStack {
-        private int[] a;
-        private int sz;
 
-        IntStack(int cap) {
-            this.a = new int[Math.max(2, cap)];
-            this.sz = 0;
+            st.push(Integer.parseInt(t));
         }
 
-        void push(int v) {
-            if (sz == a.length) {
-                int[] b = new int[a.length << 1];
-                System.arraycopy(a, 0, b, 0, a.length);
-                a = b;
-            }
-            a[sz++] = v;
-        }
-
-        int pop() {
-            return a[--sz];
-        }
-
-        int peek() {
-            return a[sz - 1];
-        }
+        return st.peek();
     }
 
     // -------------------- FAST INPUT --------------------
     static final class FastIn {
         private final InputStream in;
         private final byte[] buf = new byte[1 << 16];
-        private int ptr = 0, len = 0;
+        private int ptr = 0;
+        private int len = 0;
 
         FastIn(InputStream in) {
             this.in = in;
@@ -109,12 +86,12 @@ private int read() throws IOException {
             return buf[ptr++];
         }
 
-        String nextOrNull() throws IOException {
+        String next() throws IOException {
             int c;
             do {
                 c = read();
                 if (c == -1) {
-                    return null;
+                    throw new EOFException("EOF");
                 }
             } while (c <= ' ');
 
@@ -187,38 +164,30 @@ private static void run() throws Exception {
         FastIn in = new FastIn(System.in);
         FastOut out = new FastOut(System.out);
 
-        int ans = evalRpn(in);
+        int ans = eval(in);
 
         out.writeInt(ans);
         out.writeByte('\n');
         out.flush();
     }
 
+    // -------------------- LOCAL TESTS --------------------
     private static void test() throws Exception {
         assertEq(9, evalFromString("2 1 + 3 *"));
         assertEq(38, evalFromString("7 2 + 4 * 2 +"));
-
-        // деление “вниз”
         assertEq(-1, evalFromString("-1 3 /"));
         assertEq(-2, evalFromString("-4 3 /"));
-
-        // порядок операндов
         assertEq(2, evalFromString("10 2 4 * -"));
-
-        // одно число
         assertEq(5, evalFromString("5"));
-
         System.out.println("Test OK");
     }
 
     private static int evalFromString(String s) throws Exception {
-        InputStream is = new java.io.ByteArrayInputStream(
-                s.getBytes(java.nio.charset.StandardCharsets.US_ASCII)
-        );
-        return evalRpn(new FastIn(is));
+        InputStream is = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII));
+        return eval(new FastIn(is));
     }
 
-    static void assertEq(int exp, int act) {
+    private static void assertEq(int exp, int act) {
         if (exp != act) {
             throw new AssertionError("Expected=" + exp + ", actual=" + act);
         }

From 57eb1f1fe5ccc722314ec2c17e79bb3bff707260 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sat, 28 Feb 2026 02:59:34 +0300
Subject: [PATCH 20/45] Deque

---
 src/main/java/algorithms/sprint2/Deque.java | 311 ++++++++++----------
 1 file changed, 155 insertions(+), 156 deletions(-)

diff --git a/src/main/java/algorithms/sprint2/Deque.java b/src/main/java/algorithms/sprint2/Deque.java
index db29013..3262fa8 100644
--- a/src/main/java/algorithms/sprint2/Deque.java
+++ b/src/main/java/algorithms/sprint2/Deque.java
@@ -44,132 +44,12 @@
 В этих случаях состояние (head, tail, size) не меняется, что сохраняет инварианты.
 
 Сложность
-Каждая операция дека выполняет константное число действий: O(1) по времени.
+Время: O(n), где n - количество операций. Каждая операция дека выполняется за O(1)
 Память: массив из m элементов и несколько целых переменных: O(m) по памяти.
 */
 
-public class Deque {
-
-    // -------------------- FAST INPUT --------------------
-    static final class FastIn {
-        private final InputStream in;
-        private final byte[] buf = new byte[1 << 16];
-        private int ptr = 0, len = 0;
-
-        FastIn(InputStream in) {
-            this.in = in;
-        }
-
-        private int read() throws IOException {
-            if (ptr >= len) {
-                len = in.read(buf);
-                ptr = 0;
-                if (len <= 0) {
-                    return -1;
-                }
-            }
-            return buf[ptr++];
-        }
-
-        int nextInt() throws IOException {
-            int c;
-            do {
-                c = read();
-                if (c == -1) {
-                    throw new EOFException("Unexpected EOF");
-                }
-            } while (c <= ' ');
 
-            int sign = 1;
-            if (c == '-') {
-                sign = -1;
-                c = read();
-            }
-
-            int val = 0;
-            while (c > ' ') {
-                val = val * 10 + (c - '0');
-                c = read();
-            }
-            return val * sign;
-        }
-
-        String next() throws IOException {
-            int c;
-            do {
-                c = read();
-                if (c == -1) {
-                    throw new EOFException("Unexpected EOF");
-                }
-            } while (c <= ' ');
-
-            byte[] tmp = new byte[32];
-            int n = 0;
-            while (c > ' ') {
-                if (n == tmp.length) {
-                    byte[] t2 = new byte[tmp.length * 2];
-                    System.arraycopy(tmp, 0, t2, 0, tmp.length);
-                    tmp = t2;
-                }
-                tmp[n++] = (byte) c;
-                c = read();
-                if (c == -1) {
-                    break;
-                }
-            }
-            return new String(tmp, 0, n);
-        }
-    }
-
-    // -------------------- FAST OUTPUT --------------------
-    static final class FastOut {
-        private final OutputStream out;
-        private final byte[] buf = new byte[1 << 16];
-        private int p = 0;
-        private final byte[] tmp = new byte[12];
-
-        FastOut(OutputStream out) {
-            this.out = out;
-        }
-
-        void writeByte(int b) throws IOException {
-            if (p == buf.length) {
-                flush();
-            }
-            buf[p++] = (byte) b;
-        }
-
-        void writeStr(String s) throws IOException {
-            for (int i = 0; i < s.length(); i++) {
-                writeByte(s.charAt(i));
-            }
-        }
-
-        void writeInt(int x) throws IOException {
-            if (x == 0) {
-                writeByte('0');
-                return;
-            }
-            if (x < 0) {
-                writeByte('-');
-                x = -x;
-            }
-
-            int k = 0;
-            while (x > 0) {
-                tmp[k++] = (byte) ('0' + (x % 10));
-                x /= 10;
-            }
-            for (int i = k - 1; i >= 0; i--) {
-                writeByte(tmp[i]);
-            }
-        }
-
-        void flush() throws IOException {
-            out.write(buf, 0, p);
-            p = 0;
-        }
-    }
+public class Deque {
 
     // -------------------- RING BUFFER DEQUE --------------------
     static final class RingDeque {
@@ -185,19 +65,11 @@ static final class RingDeque {
         }
 
         private int next(int i) {
-            i++;
-            if (i == cap) {
-                i = 0;
-            }
-            return i;
+            return (i+1) % cap;
         }
 
         private int prev(int i) {
-            i--;
-            if (i == -1) {
-                i = cap - 1;
-            }
-            return i;
+            return (i-1+cap) % cap;
         }
 
         boolean isEmpty() {
@@ -244,33 +116,38 @@ private static void process(FastIn in, FastOut out) throws Exception {
         for (int i = 0; i < n; i++) {
             String cmd = in.next();
 
-            if ("push_back".equals(cmd)) {
-                int x = in.nextInt();
-                if (dq.isFull()) {
-                    out.writeStr("error\n");
-                } else {
-                    dq.pushBack(x);
+            switch (cmd) {
+                case "push_back" -> {
+                    int x = in.nextInt();
+                    if (dq.isFull()) {
+                        out.writeStr("error\n");
+                    } else {
+                        dq.pushBack(x);
+                    }
                 }
-            } else if ("push_front".equals(cmd)) {
-                int x = in.nextInt();
-                if (dq.isFull()) {
-                    out.writeStr("error\n");
-                } else {
-                    dq.pushFront(x);
+                case "push_front" -> {
+                    int x = in.nextInt();
+                    if (dq.isFull()) {
+                        out.writeStr("error\n");
+                    } else {
+                        dq.pushFront(x);
+                    }
                 }
-            } else if ("pop_front".equals(cmd)) {
-                if (dq.isEmpty()) {
-                    out.writeStr("error\n");
-                } else {
-                    out.writeInt(dq.popFront());
-                    out.writeByte('\n');
+                case "pop_front" -> {
+                    if (dq.isEmpty()) {
+                        out.writeStr("error\n");
+                    } else {
+                        out.writeInt(dq.popFront());
+                        out.writeByte('\n');
+                    }
                 }
-            } else { // pop_back
-                if (dq.isEmpty()) {
-                    out.writeStr("error\n");
-                } else {
-                    out.writeInt(dq.popBack());
-                    out.writeByte('\n');
+                case "pop_back" -> {
+                    if (dq.isEmpty()) {
+                        out.writeStr("error\n");
+                    } else {
+                        out.writeInt(dq.popBack());
+                        out.writeByte('\n');
+                    }
                 }
             }
         }
@@ -385,4 +262,126 @@ public static void main(String[] args) throws Exception {
             run();
         }
     }
+
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0, len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+            return buf[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            int sign = 1;
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int val = 0;
+            while (c > ' ') {
+                val = val * 10 + (c - '0');
+                c = read();
+            }
+            return val * sign;
+        }
+
+        String next() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            byte[] tmp = new byte[32];
+            int n = 0;
+            while (c > ' ') {
+                if (n == tmp.length) {
+                    byte[] t2 = new byte[tmp.length * 2];
+                    System.arraycopy(tmp, 0, t2, 0, tmp.length);
+                    tmp = t2;
+                }
+                tmp[n++] = (byte) c;
+                c = read();
+                if (c == -1) {
+                    break;
+                }
+            }
+            return new String(tmp, 0, n);
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+        private final byte[] tmp = new byte[12];
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) {
+                flush();
+            }
+            buf[p++] = (byte) b;
+        }
+
+        void writeStr(String s) throws IOException {
+            for (int i = 0; i < s.length(); i++) {
+                writeByte(s.charAt(i));
+            }
+        }
+
+        void writeInt(int x) throws IOException {
+            if (x == 0) {
+                writeByte('0');
+                return;
+            }
+            if (x < 0) {
+                writeByte('-');
+                x = -x;
+            }
+
+            int k = 0;
+            while (x > 0) {
+                tmp[k++] = (byte) ('0' + (x % 10));
+                x /= 10;
+            }
+            for (int i = k - 1; i >= 0; i--) {
+                writeByte(tmp[i]);
+            }
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
 }

From 419d53b858d8381a5600ace275d63329592c39bf Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sat, 28 Feb 2026 02:59:59 +0300
Subject: [PATCH 21/45] Calculator

---
 .../java/algorithms/sprint2/Calculator.java   | 90 ++++++++++---------
 1 file changed, 46 insertions(+), 44 deletions(-)

diff --git a/src/main/java/algorithms/sprint2/Calculator.java b/src/main/java/algorithms/sprint2/Calculator.java
index ebcf59a..58e955a 100644
--- a/src/main/java/algorithms/sprint2/Calculator.java
+++ b/src/main/java/algorithms/sprint2/Calculator.java
@@ -10,8 +10,8 @@
 /*
 Принцип:
 - Читаем токены ОПН слева направо.
-- Число -> push в стек.
-- Операция -> pop b, pop a, считаем a op b, push результат.
+- Если считанный символ - Число -> push в стек.
+- Если считанный символ - Математическая Операция (+-*\) -> pop b, pop a, считаем a op b, push результат.
 - Ответ: верх стека.
 
 Корректность:
@@ -21,8 +21,10 @@
 
 Сложность:
 - Время O(m), m — число токенов.
-- Память O(s), s — максимальный размер стека (в худшем O(m)).
+- Память - в худшем O(m)
 */
+
+
 public class Calculator {
 
     private static int eval(FastIn in) throws IOException {
@@ -64,6 +66,47 @@ private static int eval(FastIn in) throws IOException {
         return st.peek();
     }
 
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+
+        int ans = eval(in);
+
+        out.writeInt(ans);
+        out.writeByte('\n');
+        out.flush();
+    }
+
+    // -------------------- LOCAL TESTS --------------------
+    private static void test() throws Exception {
+        assertEq(9, evalFromString("2 1 + 3 *"));
+        assertEq(38, evalFromString("7 2 + 4 * 2 +"));
+        assertEq(-1, evalFromString("-1 3 /"));
+        assertEq(-2, evalFromString("-4 3 /"));
+        assertEq(2, evalFromString("10 2 4 * -"));
+        assertEq(5, evalFromString("5"));
+        System.out.println("Test OK");
+    }
+
+    private static int evalFromString(String s) throws Exception {
+        InputStream is = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII));
+        return eval(new FastIn(is));
+    }
+
+    private static void assertEq(int exp, int act) {
+        if (exp != act) {
+            throw new AssertionError("Expected=" + exp + ", actual=" + act);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+
     // -------------------- FAST INPUT --------------------
     static final class FastIn {
         private final InputStream in;
@@ -159,45 +202,4 @@ void flush() throws IOException {
             p = 0;
         }
     }
-
-    private static void run() throws Exception {
-        FastIn in = new FastIn(System.in);
-        FastOut out = new FastOut(System.out);
-
-        int ans = eval(in);
-
-        out.writeInt(ans);
-        out.writeByte('\n');
-        out.flush();
-    }
-
-    // -------------------- LOCAL TESTS --------------------
-    private static void test() throws Exception {
-        assertEq(9, evalFromString("2 1 + 3 *"));
-        assertEq(38, evalFromString("7 2 + 4 * 2 +"));
-        assertEq(-1, evalFromString("-1 3 /"));
-        assertEq(-2, evalFromString("-4 3 /"));
-        assertEq(2, evalFromString("10 2 4 * -"));
-        assertEq(5, evalFromString("5"));
-        System.out.println("Test OK");
-    }
-
-    private static int evalFromString(String s) throws Exception {
-        InputStream is = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII));
-        return eval(new FastIn(is));
-    }
-
-    private static void assertEq(int exp, int act) {
-        if (exp != act) {
-            throw new AssertionError("Expected=" + exp + ", actual=" + act);
-        }
-    }
-
-    public static void main(String[] args) throws Exception {
-        if (System.getProperty("os.name").startsWith("Windows")) {
-            test();
-        } else {
-            run();
-        }
-    }
 }

From 798f3f338250fc35bfe85cdecb074d5be157fa64 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Tue, 7 Apr 2026 23:27:39 +0300
Subject: [PATCH 22/45] sprint3

---
 .../java/algorithms/sprint3/BrokenArray.java  |  79 +++++++
 .../java/algorithms/sprint3/FastSort.java     | 199 ++++++++++++++++++
 2 files changed, 278 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint3/BrokenArray.java
 create mode 100644 src/main/java/algorithms/sprint3/FastSort.java

diff --git a/src/main/java/algorithms/sprint3/BrokenArray.java b/src/main/java/algorithms/sprint3/BrokenArray.java
new file mode 100644
index 0000000..2177add
--- /dev/null
+++ b/src/main/java/algorithms/sprint3/BrokenArray.java
@@ -0,0 +1,79 @@
+// https://contest.yandex.ru/contest/23815/run-report/159759692/
+
+public class BrokenArray {
+
+    /*
+     * Принцип работы алгоритма:
+     * Используем модифицированный бинарный поиск.
+     * На каждом шаге рассматриваем середину отрезка [left, right].
+     * Хотя массив "сломанный" (циклически сдвинутый), хотя бы одна из половин
+     * [left, mid] или [mid, right] обязательно отсортирована по возрастанию.
+     * Определяем, какая именно половина отсортирована, и проверяем, может ли
+     * искомый элемент k лежать внутри неё. Если да — продолжаем поиск в этой
+     * половине, иначе — в другой.
+     *
+     * Почему алгоритм корректен:
+     * 1) В массиве все элементы уникальны, значит для любой середины можно
+     *    однозначно понять, какая половина отсортирована.
+     * 2) Если левая половина отсортирована и k лежит в её диапазоне значений,
+     *    то k может находиться только в ней; правую половину можно отбросить.
+     *    Аналогично для правой половины.
+     * 3) На каждом шаге размер рассматриваемого отрезка строго уменьшается,
+     *    поэтому алгоритм завершится.
+     * 4) Если k есть в массиве, мы не отбросим отрезок, где он расположен,
+     *    значит рано или поздно попадём в его индекс. Если k нет, указатели
+     *    пересекутся, и мы корректно вернём -1.
+     *
+     * Временная сложность: O(log n), где n — количество элементов в массиве
+     * (n = arr.length), так как на каждом шаге отбрасывается примерно
+     * половина массива.
+     *  Пространственная сложность: O(1).
+     */
+    public static int brokenSearch(int[] arr, int k) {
+        int left = 0;
+        int right = arr.length - 1;
+
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+
+            if (arr[mid] == k) {
+                return mid;
+            }
+
+            if (arr[left] <= arr[mid]) {
+                if (arr[left] <= k && k < arr[mid]) {
+                    right = mid - 1;
+                } else {
+                    left = mid + 1;
+                }
+            } else {
+                if (arr[mid] < k && k <= arr[right]) {
+                    left = mid + 1;
+                } else {
+                    right = mid - 1;
+                }
+            }
+        }
+
+        return -1;
+    }
+
+    private static void test() {
+        int[] arr1 = {19, 21, 100, 101, 1, 4, 5, 7, 12};
+        assert 6 == brokenSearch(arr1, 5);
+
+        int[] arr2 = {5, 1};
+        assert 1 == brokenSearch(arr2, 1);
+
+        int[] arr3 = {1, 2, 3, 4, 5, 6};
+        assert 3 == brokenSearch(arr3, 4);
+
+        int[] arr4 = {4, 5, 6, 7, 0, 1, 2};
+        assert 4 == brokenSearch(arr4, 0);
+        assert -1 == brokenSearch(arr4, 3);
+
+        int[] arr5 = {1};
+        assert 0 == brokenSearch(arr5, 1);
+        assert -1 == brokenSearch(arr5, 2);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/algorithms/sprint3/FastSort.java b/src/main/java/algorithms/sprint3/FastSort.java
new file mode 100644
index 0000000..83c66de
--- /dev/null
+++ b/src/main/java/algorithms/sprint3/FastSort.java
@@ -0,0 +1,199 @@
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+
+//https://contest.yandex.ru/contest/23815/run-report/160042811/
+
+public class FastSort {
+
+    /*
+    Принцип работы алгоритма:
+    1) Считываем n участников в массив.
+    2) Сортируем массив in-place быстрой сортировкой.
+    3) Определяем лучше участника методом boolean better(a, b) по правилам задачи:
+        - у A решено больше задач;
+        - при равенстве задач у A меньше штраф;
+        - при равенстве штрафа логин A меньше лексикографически.
+
+    Почему алгоритм корректен:
+    1) Функция better(a, b) задаёт ровно тот порядок, который требуется в условии.
+    2) На каждом шаге quicksort мы делим массив относительно pivot:
+      слева остаются элементы, которые должны идти не позже pivot,
+      справа — элементы, которые должны идти не раньше pivot.
+    3) После этого рекурсивно сортируем обе части.
+    4) База рекурсии — отрезок длины 0 или 1, он уже отсортирован.
+      Значит, весь массив будет отсортирован правильно.
+
+    Временная сложность: в среднем O(n log n), где n количество участников
+
+    Пространственная сложность: O(1) дополнительной памяти на перестановки,
+    O(log n) в среднем на стек рекурсии.
+    */
+
+    static class Participant {
+        String login;
+        int solved;
+        int penalty;
+
+        Participant(String login, int solved, int penalty) {
+            this.login = login;
+            this.solved = solved;
+            this.penalty = penalty;
+        }
+    }
+
+    static boolean better(Participant a, Participant b) {
+        if (a.solved != b.solved) {
+            return a.solved > b.solved;
+        }
+        if (a.penalty != b.penalty) {
+            return a.penalty < b.penalty;
+        }
+        return a.login.compareTo(b.login) < 0;
+    }
+
+    static void swap(Participant[] a, int i, int j) {
+        Participant temp = a[i];
+        a[i] = a[j];
+        a[j] = temp;
+    }
+
+    static void quickSort(Participant[] a, int left, int right) {
+        while (left < right) {
+            int i = left;
+            int j = right;
+            Participant pivot = a[left + (right - left) / 2];
+
+            while (i <= j) {
+                while (better(a[i], pivot)) {
+                    i++;
+                }
+                while (better(pivot, a[j])) {
+                    j--;
+                }
+                if (i <= j) {
+                    swap(a, i, j);
+                    i++;
+                    j--;
+                }
+            }
+
+            if (j - left < right - i) {
+                if (left < j) {
+                    quickSort(a, left, j);
+                }
+                left = i;
+            } else {
+                if (i < right) {
+                    quickSort(a, i, right);
+                }
+                right = j;
+            }
+        }
+    }
+
+    static String solve(Participant[] participants) {
+        if (participants.length > 1) {
+            quickSort(participants, 0, participants.length - 1);
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for (Participant p : participants) {
+            sb.append(p.login).append('\n');
+        }
+        return sb.toString();
+    }
+
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buffer = new byte[1 << 16];
+        private int ptr = 0;
+        private int len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buffer);
+                ptr = 0;
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+            return buffer[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException();
+                }
+            } while (c <= ' ');
+
+            int value = 0;
+            while (c > ' ') {
+                value = value * 10 + (c - '0');
+                c = read();
+            }
+            return value;
+        }
+
+        String next() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException();
+                }
+            } while (c <= ' ');
+
+            StringBuilder sb = new StringBuilder();
+            while (c > ' ') {
+                sb.append((char) c);
+                c = read();
+            }
+            return sb.toString();
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+
+        int n = in.nextInt(); // n — количество участников
+        Participant[] participants = new Participant[n];
+
+        for (int i = 0; i < n; i++) {
+            String login = in.next();
+            int solved = in.nextInt();
+            int penalty = in.nextInt();
+            participants[i] = new Participant(login, solved, penalty);
+        }
+
+        System.out.print(solve(participants));
+    }
+
+    private static void test() {
+        Participant[] a = {new Participant("alla", 4, 100), new Participant("gena", 6, 1000), new Participant("gosha", 2, 90), new Participant("rita", 2, 90), new Participant("timofey", 4, 80)};
+
+        String expected = "gena\ntimofey\nalla\ngosha\nrita\n";
+        String actual = solve(a);
+
+        if (!expected.equals(actual)) {
+            throw new AssertionError("Expected:\n" + expected + "Actual:\n" + actual);
+        }
+
+        System.out.println("Test OK");
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+}
\ No newline at end of file

From 8a42525fdd3ddd9eeb0a17a5073b35ecfef325c2 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Wed, 8 Apr 2026 10:43:49 +0300
Subject: [PATCH 23/45] sprint3 FastSort

---
 src/main/java/algorithms/sprint3/FastSort.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/main/java/algorithms/sprint3/FastSort.java b/src/main/java/algorithms/sprint3/FastSort.java
index 83c66de..ce2459b 100644
--- a/src/main/java/algorithms/sprint3/FastSort.java
+++ b/src/main/java/algorithms/sprint3/FastSort.java
@@ -10,6 +10,13 @@ public class FastSort {
     Принцип работы алгоритма:
     1) Считываем n участников в массив.
     2) Сортируем массив in-place быстрой сортировкой.
+       В качестве опорного элемента (pivot) берём участника из середины текущего отрезка.
+       Далее двумя указателями:
+         - указатель i двигаем слева направо, пока a[i] должен стоять левее pivot;
+         - указатель j двигаем справа налево, пока a[j] должен стоять правее pivot.
+       Когда находятся два элемента не на своих сторонах, меняем их местами.
+       После завершения разбиения рекурсивно сортируем меньшую из двух частей,
+       а большую продолжаем обрабатывать в цикле. Это уменьшает глубину стека.
     3) Определяем лучше участника методом boolean better(a, b) по правилам задачи:
         - у A решено больше задач;
         - при равенстве задач у A меньше штраф;

From bbf32c4da1c5556b49a512aeb8d7226f358cdce1 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Thu, 9 Apr 2026 21:40:50 +0300
Subject: [PATCH 24/45] sprint3 FastSort

---
 src/main/java/algorithms/sprint3/FastSort.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/main/java/algorithms/sprint3/FastSort.java b/src/main/java/algorithms/sprint3/FastSort.java
index ce2459b..50e0079 100644
--- a/src/main/java/algorithms/sprint3/FastSort.java
+++ b/src/main/java/algorithms/sprint3/FastSort.java
@@ -31,10 +31,13 @@ public class FastSort {
     4) База рекурсии — отрезок длины 0 или 1, он уже отсортирован.
       Значит, весь массив будет отсортирован правильно.
 
-    Временная сложность: в среднем O(n log n), где n количество участников
+    Временная сложность: в среднем O(n log n), в худшем случае O(n^2),
+    где n количество участников
 
     Пространственная сложность: O(1) дополнительной памяти на перестановки,
     O(log n) в среднем на стек рекурсии.
+    Это верно и в худшем случае, потому что рекурсивный вызов делается
+    только для меньшей части массива, а большая часть обрабатывается циклом.
     */
 
     static class Participant {

From b55cd57a152d8ed8e315a284c7fc3b48fc8a29d0 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Thu, 9 Apr 2026 21:46:24 +0300
Subject: [PATCH 25/45] sprint3 FastSort

---
 src/main/java/algorithms/sprint3/FastSort.java | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/main/java/algorithms/sprint3/FastSort.java b/src/main/java/algorithms/sprint3/FastSort.java
index 50e0079..fb5c266 100644
--- a/src/main/java/algorithms/sprint3/FastSort.java
+++ b/src/main/java/algorithms/sprint3/FastSort.java
@@ -34,10 +34,13 @@ public class FastSort {
     Временная сложность: в среднем O(n log n), в худшем случае O(n^2),
     где n количество участников
 
-    Пространственная сложность: O(1) дополнительной памяти на перестановки,
-    O(log n) в среднем на стек рекурсии.
-    Это верно и в худшем случае, потому что рекурсивный вызов делается
-    только для меньшей части массива, а большая часть обрабатывается циклом.
+    Пространственная сложность:
+    - O(1) дополнительной памяти на перестановки;
+    - O(log n) на стек вызовов даже в худшем случае,
+      потому что рекурсивный вызов делается только для меньшей части массива.
+      Размер подмассива в следующем рекурсивном вызове не больше половины текущего,
+      поэтому глубина рекурсии не превосходит O(log n).
+      Большая часть обрабатывается итеративно в том же вызове функции.
     */
 
     static class Participant {

From 870b6b31a05aa600f66dea3e5fe0f1958302cba9 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sat, 11 Apr 2026 19:32:07 +0300
Subject: [PATCH 26/45] sprint4

---
 .../java/algorithms/sprint4/FindSystem.java   | 248 ++++++++++++++++++
 src/main/java/algorithms/sprint4/Map.java     | 186 +++++++++++++
 2 files changed, 434 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint4/FindSystem.java
 create mode 100644 src/main/java/algorithms/sprint4/Map.java

diff --git a/src/main/java/algorithms/sprint4/FindSystem.java b/src/main/java/algorithms/sprint4/FindSystem.java
new file mode 100644
index 0000000..feb76df
--- /dev/null
+++ b/src/main/java/algorithms/sprint4/FindSystem.java
@@ -0,0 +1,248 @@
+import java.io.BufferedInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+class FindSystem {
+
+    /*
+     * Принцип работы алгоритма:
+     * 1) Строим обратный индекс:
+     *    для каждого слова храним список документов, где оно встречается,
+     *    и число его вхождений в каждом документе.
+     * 2) Для каждого запроса берём только уникальные слова.
+     * 3) Для каждого такого слова прибавляем его частоту ко всем документам,
+     *    где это слово есть.
+     * 4) Из найденных документов выбираем 5 лучших:
+     *    сначала по убыванию релевантности, потом по возрастанию номера документа.
+     *
+     * Почему алгоритм корректен:
+     * - В индексе для каждого слова хранится точное число его вхождений в документ.
+     * - По условию релевантность — это сумма частот всех уникальных слов запроса.
+     *   Именно такую сумму мы и считаем.
+     * - Повторы слов в запросе не влияют на ответ, потому что мы оставляем только
+     *   уникальные слова запроса.
+     * - После подсчёта релевантностей выбираем 5 лучших документов по правилу из условия,
+     *   значит ответ получается правильным.
+     *
+     * Временная сложность:
+     * - Построение индекса: O(n), где n — общее число слов во всех документах.
+     * - Обработка одного запроса: O(n), где n — суммарная длина списков документов
+     *   для уникальных слов запроса.
+     *
+     * Пространственная сложность:
+     * - O(n), где n — число пар (слово, документ) в индексе.
+     */
+
+    private static HashMap<String, ArrayList<int[]>> buildIndex(String[] docs) {
+        HashMap<String, ArrayList<int[]>> index = new HashMap<>();
+
+        for (int i = 0; i < docs.length; i++) {
+            HashMap<String, Integer> freq = new HashMap<>();
+            StringTokenizer st = new StringTokenizer(docs[i]);
+
+            while (st.hasMoreTokens()) {
+                String word = st.nextToken();
+                freq.put(word, freq.getOrDefault(word, 0) + 1);
+            }
+
+            int docId = i + 1;
+            for (Map.Entry<String, Integer> entry : freq.entrySet()) {
+                index.computeIfAbsent(entry.getKey(), k -> new ArrayList<>())
+                        .add(new int[]{docId, entry.getValue()});
+            }
+        }
+
+        return index;
+    }
+
+    private static String processQuery(String query, HashMap<String, ArrayList<int[]>> index) {
+        HashSet<String> uniqueWords = new HashSet<>();
+        StringTokenizer st = new StringTokenizer(query);
+
+        while (st.hasMoreTokens()) {
+            uniqueWords.add(st.nextToken());
+        }
+
+        HashMap<Integer, Integer> relevance = new HashMap<>();
+
+        for (String word : uniqueWords) {
+            ArrayList<int[]> docs = index.get(word);
+            if (docs == null) {
+                continue;
+            }
+
+            for (int[] pair : docs) {
+                int docId = pair[0];
+                int count = pair[1];
+                relevance.put(docId, relevance.getOrDefault(docId, 0) + count);
+            }
+        }
+
+        ArrayList<int[]> best = new ArrayList<>();
+
+        for (Map.Entry<Integer, Integer> entry : relevance.entrySet()) {
+            int docId = entry.getKey();
+            int score = entry.getValue();
+
+            int pos = 0;
+            while (pos < best.size() && !isBetter(docId, score, best.get(pos)[0], best.get(pos)[1])) {
+                pos++;
+            }
+
+            if (pos < 5) {
+                best.add(pos, new int[]{docId, score});
+                if (best.size() > 5) {
+                    best.remove(5);
+                }
+            }
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < best.size(); i++) {
+            if (i > 0) {
+                sb.append(' ');
+            }
+            sb.append(best.get(i)[0]);
+        }
+
+        return sb.toString();
+    }
+
+    private static boolean isBetter(int docId1, int score1, int docId2, int score2) {
+        if (score1 != score2) {
+            return score1 > score2;
+        }
+        return docId1 < docId2;
+    }
+
+    private static void solve() throws Exception {
+        FastReader reader = new FastReader(System.in);
+
+        int n = reader.nextInt();
+        String[] docs = new String[n];
+        for (int i = 0; i < n; i++) {
+            docs[i] = reader.nextLine();
+        }
+
+        HashMap<String, ArrayList<int[]>> index = buildIndex(docs);
+
+        int m = reader.nextInt();
+        StringBuilder out = new StringBuilder();
+
+        for (int i = 0; i < m; i++) {
+            String query = reader.nextLine();
+            out.append(processQuery(query, index)).append('\n');
+        }
+
+        System.out.print(out);
+    }
+
+    private static void test() {
+        String[] docs1 = {
+                "i love coffee",
+                "coffee with milk and sugar",
+                "free tea for everyone"
+        };
+
+        HashMap<String, ArrayList<int[]>> index1 = buildIndex(docs1);
+        assertEquals("1 2", processQuery("i like black coffee without milk", index1));
+        assertEquals("3", processQuery("everyone loves new year", index1));
+        assertEquals("2 1", processQuery("Mary likes black coffee without milk", index1));
+
+        String[] docs2 = {
+                "buy flat in Moscow",
+                "rent flat in Moscow",
+                "sell flat in Moscow",
+                "want flat in Moscow like crazy",
+                "clean flat in Moscow on weekends",
+                "renovate flat in Moscow"
+        };
+
+        HashMap<String, ArrayList<int[]>> index2 = buildIndex(docs2);
+        assertEquals("4 5 1 2 3", processQuery("flat in Moscow for crazy weekends", index2));
+
+        String[] docs3 = {
+                "i like dfs and bfs",
+                "i like dfs dfs",
+                "i like bfs with bfs and bfs"
+        };
+
+        HashMap<String, ArrayList<int[]>> index3 = buildIndex(docs3);
+        assertEquals("3 1 2", processQuery("dfs dfs dfs dfs bfs", index3));
+        System.out.println("Test OK");
+    }
+
+    private static void assertEquals(String expected, String actual) {
+        if (!expected.equals(actual)) {
+            throw new AssertionError("expected = [" + expected + "], actual = [" + actual + "]");
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            solve();
+        }
+    }
+    private static class FastReader {
+        private final InputStream in;
+        private final byte[] buffer = new byte[1 << 16];
+        private int ptr = 0;
+        private int len = 0;
+
+        FastReader(InputStream in) {
+            this.in = new BufferedInputStream(in);
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buffer);
+                ptr = 0;
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+            return buffer[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException();
+                }
+            } while (c <= ' ');
+
+            int value = 0;
+            while (c > ' ') {
+                value = value * 10 + (c - '0');
+                c = read();
+            }
+            return value;
+        }
+
+        String nextLine() throws IOException {
+            int c = read();
+
+            while (c == '\n' || c == '\r') {
+                c = read();
+            }
+
+            StringBuilder sb = new StringBuilder();
+            while (c != -1 && c != '\n' && c != '\r') {
+                sb.append((char) c);
+                c = read();
+            }
+
+            return sb.toString();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/algorithms/sprint4/Map.java b/src/main/java/algorithms/sprint4/Map.java
new file mode 100644
index 0000000..baa1360
--- /dev/null
+++ b/src/main/java/algorithms/sprint4/Map.java
@@ -0,0 +1,186 @@
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class Map {
+
+    /*
+     * Принцип работы алгоритма:
+     * Делаем свою хеш-таблицу методом цепочек.
+     * Есть массив бакетов. В каждом бакете лежит связный список элементов.
+     *
+     * Для ключа key:
+     * - считаем номер бакета;
+     * - идём по списку этого бакета;
+     * - put: если ключ нашли, обновляем значение, иначе добавляем новый узел;
+     * - get: если нашли, выводим значение, иначе None;
+     * - delete: если нашли, удаляем узел и выводим значение, иначе None.
+     *
+     * Почему алгоритм корректен:
+     * - Каждый ключ всегда попадает в один и тот же бакет.
+     * - Все элементы этого бакета хранятся в одном списке.
+     * - Поэтому, если пройти весь список, мы точно:
+     *   - найдём ключ, если он есть;
+     *   - поймём, что его нет, если не нашли.
+     *
+     * Временная сложность:
+     * - put, get, delete — O(1) в среднем.
+     *
+     * Пространственная сложность:
+     * - O(m + s), где m — число бакетов, s — число элементов в таблице.
+     */
+
+    private static final int SIZE = 100_003;
+
+    static class Node {
+        int key;
+        int value;
+        Node next;
+
+        Node(int key, int value, Node next) {
+            this.key = key;
+            this.value = value;
+            this.next = next;
+        }
+    }
+
+    static class HashTable {
+        Node[] buckets = new Node[SIZE];
+
+        int index(int key) {
+            int x = key % SIZE;
+            if (x < 0) {
+                x += SIZE;
+            }
+            return x;
+        }
+
+        void put(int key, int value) {
+            int i = index(key);
+            Node cur = buckets[i];
+
+            while (cur != null) {
+                if (cur.key == key) {
+                    cur.value = value;
+                    return;
+                }
+                cur = cur.next;
+            }
+
+            buckets[i] = new Node(key, value, buckets[i]);
+        }
+
+        String get(int key) {
+            int i = index(key);
+            Node cur = buckets[i];
+
+            while (cur != null) {
+                if (cur.key == key) {
+                    return String.valueOf(cur.value);
+                }
+                cur = cur.next;
+            }
+
+            return "None";
+        }
+
+        String delete(int key) {
+            int i = index(key);
+            Node cur = buckets[i];
+            Node prev = null;
+
+            while (cur != null) {
+                if (cur.key == key) {
+                    if (prev == null) {
+                        buckets[i] = cur.next;
+                    } else {
+                        prev.next = cur.next;
+                    }
+                    return String.valueOf(cur.value);
+                }
+                prev = cur;
+                cur = cur.next;
+            }
+
+            return "None";
+        }
+    }
+
+    static class Reader {
+        private final InputStream in = new BufferedInputStream(System.in);
+        private final byte[] buffer = new byte[1 << 16];
+        private int ptr = 0;
+        private int len = 0;
+
+        int read() throws IOException {
+            if (ptr == len) {
+                len = in.read(buffer);
+                ptr = 0;
+                if (len == -1) {
+                    return -1;
+                }
+            }
+            return buffer[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+
+            int sign = 1;
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int num = 0;
+            while (c > ' ') {
+                num = num * 10 + (c - '0');
+                c = read();
+            }
+
+            return num * sign;
+        }
+
+        char nextCommand() throws IOException {
+            int c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+
+            char first = (char) c;
+
+            while (c > ' ') {
+                c = read();
+            }
+
+            return first;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        Reader reader = new Reader();
+        HashTable table = new HashTable();
+        StringBuilder out = new StringBuilder();
+
+        int n = reader.nextInt();
+
+        for (int i = 0; i < n; i++) {
+            char command = reader.nextCommand();
+            int key = reader.nextInt();
+
+            if (command == 'p') {
+                int value = reader.nextInt();
+                table.put(key, value);
+            } else if (command == 'g') {
+                out.append(table.get(key)).append('\n');
+            } else {
+                out.append(table.delete(key)).append('\n');
+            }
+        }
+
+        System.out.print(out);
+    }
+}
\ No newline at end of file

From 052a61539b4f3cf3444a00676e0e58bbb0f13230 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sat, 11 Apr 2026 19:33:30 +0300
Subject: [PATCH 27/45] sprint4

---
 src/main/java/algorithms/sprint4/FindSystem.java | 2 ++
 src/main/java/algorithms/sprint4/Map.java        | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/src/main/java/algorithms/sprint4/FindSystem.java b/src/main/java/algorithms/sprint4/FindSystem.java
index feb76df..1ce3d59 100644
--- a/src/main/java/algorithms/sprint4/FindSystem.java
+++ b/src/main/java/algorithms/sprint4/FindSystem.java
@@ -8,6 +8,8 @@
 import java.util.Map;
 import java.util.StringTokenizer;
 
+// https://contest.yandex.ru/contest/24414/run-report/160043341/
+
 class FindSystem {
 
     /*
diff --git a/src/main/java/algorithms/sprint4/Map.java b/src/main/java/algorithms/sprint4/Map.java
index baa1360..419852a 100644
--- a/src/main/java/algorithms/sprint4/Map.java
+++ b/src/main/java/algorithms/sprint4/Map.java
@@ -25,6 +25,8 @@ public class Map {
      *
      * Временная сложность:
      * - put, get, delete — O(1) в среднем.
+     * - В худшем случае — O(s), где s — число элементов в таблице,
+     *   если все ключи попали в один бакет.
      *
      * Пространственная сложность:
      * - O(m + s), где m — число бакетов, s — число элементов в таблице.

From f21d9e52e65cd9f2126b2c0c53d54f31f89af851 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sat, 11 Apr 2026 19:34:05 +0300
Subject: [PATCH 28/45] sprint4

---
 src/main/java/algorithms/sprint4/FindSystem.java | 2 --
 src/main/java/algorithms/sprint4/Map.java        | 2 ++
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/algorithms/sprint4/FindSystem.java b/src/main/java/algorithms/sprint4/FindSystem.java
index 1ce3d59..feb76df 100644
--- a/src/main/java/algorithms/sprint4/FindSystem.java
+++ b/src/main/java/algorithms/sprint4/FindSystem.java
@@ -8,8 +8,6 @@
 import java.util.Map;
 import java.util.StringTokenizer;
 
-// https://contest.yandex.ru/contest/24414/run-report/160043341/
-
 class FindSystem {
 
     /*
diff --git a/src/main/java/algorithms/sprint4/Map.java b/src/main/java/algorithms/sprint4/Map.java
index 419852a..63e54e6 100644
--- a/src/main/java/algorithms/sprint4/Map.java
+++ b/src/main/java/algorithms/sprint4/Map.java
@@ -2,6 +2,8 @@
 import java.io.IOException;
 import java.io.InputStream;
 
+// https://contest.yandex.ru/contest/24414/run-report/160043341/
+
 public class Map {
 
     /*

From 29641ef0c83d6904fecb4b0ce0ff4a412dc4985d Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sat, 11 Apr 2026 19:34:33 +0300
Subject: [PATCH 29/45] sprint4

---
 src/main/java/algorithms/sprint4/FindSystem.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main/java/algorithms/sprint4/FindSystem.java b/src/main/java/algorithms/sprint4/FindSystem.java
index feb76df..1ce3d59 100644
--- a/src/main/java/algorithms/sprint4/FindSystem.java
+++ b/src/main/java/algorithms/sprint4/FindSystem.java
@@ -8,6 +8,8 @@
 import java.util.Map;
 import java.util.StringTokenizer;
 
+// https://contest.yandex.ru/contest/24414/run-report/160043341/
+
 class FindSystem {
 
     /*

From 1846c91ee9842f1c99c3bfb5c59e98a36bb4f662 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Mon, 13 Apr 2026 23:47:36 +0300
Subject: [PATCH 30/45] sprint4

---
 src/main/java/algorithms/sprint4/Map.java | 49 +++++++++++++++--------
 1 file changed, 32 insertions(+), 17 deletions(-)

diff --git a/src/main/java/algorithms/sprint4/Map.java b/src/main/java/algorithms/sprint4/Map.java
index 63e54e6..78bab71 100644
--- a/src/main/java/algorithms/sprint4/Map.java
+++ b/src/main/java/algorithms/sprint4/Map.java
@@ -1,8 +1,9 @@
 import java.io.BufferedInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.OptionalInt;
 
-// https://contest.yandex.ru/contest/24414/run-report/160043341/
+// https://contest.yandex.ru/contest/24414/run-report/160371601/
 
 public class Map {
 
@@ -12,26 +13,38 @@ public class Map {
      * Есть массив бакетов. В каждом бакете лежит связный список элементов.
      *
      * Для ключа key:
-     * - считаем номер бакета;
+     * - считаем номер бакета по формуле key % SIZE;
+     *   если остаток отрицательный, прибавляем SIZE,
+     *   чтобы индекс был в диапазоне от 0 до SIZE - 1;
      * - идём по списку этого бакета;
-     * - put: если ключ нашли, обновляем значение, иначе добавляем новый узел;
+     * - put: если ключ нашли, обновляем значение, иначе
+     *   добавляем новый узел в начало списка бакета:
+     *   buckets[i] = new Node(key, value, buckets[i]);
      * - get: если нашли, выводим значение, иначе None;
-     * - delete: если нашли, удаляем узел и выводим значение, иначе None.
+     * - delete: если нашли, удаляем узел из списка:
+     *   если удаляется голова, делаем buckets[i] = cur.next,
+     *   иначе делаем prev.next = cur.next.
      *
      * Почему алгоритм корректен:
-     * - Каждый ключ всегда попадает в один и тот же бакет.
+     * - Каждый ключ всегда попадает в один и тот же бакет,
+     *   потому что функция index(key) зависит только от key и SIZE.
      * - Все элементы этого бакета хранятся в одном списке.
      * - Поэтому, если пройти весь список, мы точно:
      *   - найдём ключ, если он есть;
      *   - поймём, что его нет, если не нашли.
      *
      * Временная сложность:
-     * - put, get, delete — O(1) в среднем.
-     * - В худшем случае — O(s), где s — число элементов в таблице,
-     *   если все ключи попали в один бакет.
+     * - одна операция put, get или delete в среднем работает за O(1);
+     * - в худшем случае одна операция работает за O(n),
+     *   если все ключи попали в один бакет;
+     * - так как выполняется n команд, суммарная сложность программы
+     *   в среднем O(n), в худшем случае O(n^2).
      *
      * Пространственная сложность:
-     * - O(m + s), где m — число бакетов, s — число элементов в таблице.
+     * - в худшем случае таблица хранит до n элементов,
+     *   поэтому пространственная сложность O(n);
+     * - массив бакетов имеет фиксированный размер SIZE,
+     *   то есть даёт только константную добавку.
      */
 
     private static final int SIZE = 100_003;
@@ -74,21 +87,21 @@ void put(int key, int value) {
             buckets[i] = new Node(key, value, buckets[i]);
         }
 
-        String get(int key) {
+        OptionalInt get(int key) {
             int i = index(key);
             Node cur = buckets[i];
 
             while (cur != null) {
                 if (cur.key == key) {
-                    return String.valueOf(cur.value);
+                    return OptionalInt.of(cur.value);
                 }
                 cur = cur.next;
             }
 
-            return "None";
+            return OptionalInt.empty();
         }
 
-        String delete(int key) {
+        OptionalInt delete(int key) {
             int i = index(key);
             Node cur = buckets[i];
             Node prev = null;
@@ -100,13 +113,13 @@ String delete(int key) {
                     } else {
                         prev.next = cur.next;
                     }
-                    return String.valueOf(cur.value);
+                    return OptionalInt.of(cur.value);
                 }
                 prev = cur;
                 cur = cur.next;
             }
 
-            return "None";
+            return OptionalInt.empty();
         }
     }
 
@@ -179,9 +192,11 @@ public static void main(String[] args) throws Exception {
                 int value = reader.nextInt();
                 table.put(key, value);
             } else if (command == 'g') {
-                out.append(table.get(key)).append('\n');
+                table.get(key).ifPresentOrElse(out::append, () -> out.append("None"));
+                out.append(System.lineSeparator());
             } else {
-                out.append(table.delete(key)).append('\n');
+                table.delete(key).ifPresentOrElse(out::append, () -> out.append("None"));
+                out.append(System.lineSeparator());
             }
         }
 

From efb346cf589e8c806ab037419295777ce570d28a Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Mon, 13 Apr 2026 23:52:44 +0300
Subject: [PATCH 31/45] sprint4

---
 .../java/algorithms/sprint4/FindSystem.java   | 29 +++++++++++++------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/src/main/java/algorithms/sprint4/FindSystem.java b/src/main/java/algorithms/sprint4/FindSystem.java
index 1ce3d59..f6e10ea 100644
--- a/src/main/java/algorithms/sprint4/FindSystem.java
+++ b/src/main/java/algorithms/sprint4/FindSystem.java
@@ -17,11 +17,12 @@ class FindSystem {
      * 1) Строим обратный индекс:
      *    для каждого слова храним список документов, где оно встречается,
      *    и число его вхождений в каждом документе.
-     * 2) Для каждого запроса берём только уникальные слова.
-     * 3) Для каждого такого слова прибавляем его частоту ко всем документам,
-     *    где это слово есть.
-     * 4) Из найденных документов выбираем 5 лучших:
-     *    сначала по убыванию релевантности, потом по возрастанию номера документа.
+     * 2) Для каждого запроса берём только уникальные слова из этого запроса,
+     *    то есть если слово в запросе встретилось несколько раз, учитываем его один раз.
+     * 3) Для каждого такого слова прибавляем к релевантности документа
+     *    частоту этого слова в документе, то есть число его вхождений в документ.
+     * 4) Релевантность документа — это сумма частот всех уникальных слов запроса
+     *    в этом документе. Из найденных документов выбираем 5 лучших.
      *
      * Почему алгоритм корректен:
      * - В индексе для каждого слова хранится точное число его вхождений в документ.
@@ -33,12 +34,22 @@ class FindSystem {
      *   значит ответ получается правильным.
      *
      * Временная сложность:
-     * - Построение индекса: O(n), где n — общее число слов во всех документах.
-     * - Обработка одного запроса: O(n), где n — суммарная длина списков документов
-     *   для уникальных слов запроса.
+     *
+     * Обозначения:
+     * - D — число документов;
+     * - Wd — максимальное число слов в одном документе;
+     * - Q — число запросов;
+     * - Wq — максимальное число слов в одном запросе.
+     *
+     * - Построение индекса: O(D * Wd).
+     * - Обработка одного запроса: O(Wq * D) в худшем случае,
+     *   если каждое уникальное слово запроса встречается во всех документах.
+     * - Обработка всех запросов: O(D * Wd + Q * Wq * D).
      *
      * Пространственная сложность:
-     * - O(n), где n — число пар (слово, документ) в индексе.
+     *
+     * - Индекс: O(D * Wd), так как в худшем случае храним информацию по всем словам документов.
+     * - Дополнительная память на один запрос: O(Wq + D).
      */
 
     private static HashMap<String, ArrayList<int[]>> buildIndex(String[] docs) {

From 0cf4a82d41e2127e64487f1005e57fe07e81f981 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Mon, 13 Apr 2026 23:57:32 +0300
Subject: [PATCH 32/45] sprint4

---
 src/main/java/algorithms/sprint4/FindSystem.java | 4 +++-
 src/main/java/algorithms/sprint4/Map.java        | 3 ++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/main/java/algorithms/sprint4/FindSystem.java b/src/main/java/algorithms/sprint4/FindSystem.java
index f6e10ea..8864bcb 100644
--- a/src/main/java/algorithms/sprint4/FindSystem.java
+++ b/src/main/java/algorithms/sprint4/FindSystem.java
@@ -48,7 +48,9 @@ class FindSystem {
      *
      * Пространственная сложность:
      *
-     * - Индекс: O(D * Wd), так как в худшем случае храним информацию по всем словам документов.
+     * - Индекс: O(P), где P — число пар (слово, документ),
+     *   для которых слово хотя бы один раз встречается в документе.
+     *   В худшем случае P = O(D * Wd).
      * - Дополнительная память на один запрос: O(Wq + D).
      */
 
diff --git a/src/main/java/algorithms/sprint4/Map.java b/src/main/java/algorithms/sprint4/Map.java
index 78bab71..f960990 100644
--- a/src/main/java/algorithms/sprint4/Map.java
+++ b/src/main/java/algorithms/sprint4/Map.java
@@ -34,7 +34,8 @@ public class Map {
      *   - поймём, что его нет, если не нашли.
      *
      * Временная сложность:
-     * - одна операция put, get или delete в среднем работает за O(1);
+     * - одна операция put, get или delete в среднем работает за O(1),
+     *   при достаточно равномерном распределении ключей по бакетам;
      * - в худшем случае одна операция работает за O(n),
      *   если все ключи попали в один бакет;
      * - так как выполняется n команд, суммарная сложность программы

From 4c4e4066194cd8747d433fd28a44e010704b9fa1 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sat, 18 Apr 2026 21:11:37 +0300
Subject: [PATCH 33/45] sprint5

---
 input.txt                                     |   0
 output.txt                                    |   0
 .../java/algorithms/sprint5/PyramidSort.java  | 291 ++++++++++++++++++
 .../algorithms/sprint5/TreePartitioning.java  | 176 +++++++++++
 4 files changed, 467 insertions(+)
 delete mode 100644 input.txt
 delete mode 100644 output.txt
 create mode 100644 src/main/java/algorithms/sprint5/PyramidSort.java
 create mode 100644 src/main/java/algorithms/sprint5/TreePartitioning.java

diff --git a/input.txt b/input.txt
deleted file mode 100644
index e69de29..0000000
diff --git a/output.txt b/output.txt
deleted file mode 100644
index e69de29..0000000
diff --git a/src/main/java/algorithms/sprint5/PyramidSort.java b/src/main/java/algorithms/sprint5/PyramidSort.java
new file mode 100644
index 0000000..c50b545
--- /dev/null
+++ b/src/main/java/algorithms/sprint5/PyramidSort.java
@@ -0,0 +1,291 @@
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class PyramidSort {
+
+    /*
+     * Принцип работы алгоритма:
+     * 1) Считываем всех участников в массив.
+     * 2) Сортируем массив пирамидальной сортировкой.
+     * 3) Для этого сначала строим max-heap, где наверху находится не лучший,
+     *    а худший по условию участник. Это удобно для heapsort: на каждой
+     *    итерации мы ставим корень кучи в конец ещё неотсортированной части.
+     * 4) Участник a считается хуже участника b, если:
+     *    - a решил меньше задач;
+     *    - при равенстве решённых задач у a штраф больше;
+     *    - при равенстве и задач, и штрафа логин a лексикографически больше.
+     * 5) После каждого обмена восстанавливаем свойство кучи просеиванием вниз.
+     *
+     * Почему алгоритм корректен:
+     * 1) Компаратор точно совпадает с порядком из условия, только в обратном
+     *    направлении: "больше" в куче означает "хуже в итоговой таблице".
+     * 2) Поэтому в корне max-heap всегда лежит худший участник среди всех
+     *    элементов текущей кучи.
+     * 3) На каждом шаге heapsort мы меняем корень с последним элементом
+     *    неотсортированной части. Значит, этот худший участник встаёт ровно
+     *    на своё окончательное место.
+     * 4) После просеивания вниз куча снова корректна.
+     * 5) Повторяя этот процесс, получаем массив, отсортированный от лучшего
+     *    участника к худшему.
+     *
+     * Временная сложность:
+     * - построение кучи: O(n);
+     * - n операций извлечения максимума: O(n log n);
+     * - итоговая сложность: O(n log n).
+     *
+     * Пространственная сложность:
+     * - O(n) на хранение массива участников;
+     * - дополнительная память алгоритма сортировки: O(1).
+     */
+
+    static final class Participant {
+        String login;
+        int solved;
+        int penalty;
+
+        Participant(String login, int solved, int penalty) {
+            this.login = login;
+            this.solved = solved;
+            this.penalty = penalty;
+        }
+    }
+
+    static void solve(Participant[] a) {
+        heapSort(a);
+    }
+
+    static int compare(Participant a, Participant b) {
+        if (a.solved != b.solved) {
+            return Integer.compare(b.solved, a.solved);
+        }
+        if (a.penalty != b.penalty) {
+            return Integer.compare(a.penalty, b.penalty);
+        }
+        return a.login.compareTo(b.login);
+    }
+
+    static void heapSort(Participant[] a) {
+        int n = a.length;
+
+        for (int i = n / 2 - 1; i >= 0; i--) {
+            siftDown(a, i, n);
+        }
+
+        for (int end = n - 1; end > 0; end--) {
+            swap(a, 0, end);
+            siftDown(a, 0, end);
+        }
+    }
+
+    static void siftDown(Participant[] a, int i, int size) {
+        while (true) {
+            int left = i * 2 + 1;
+            if (left >= size) {
+                return;
+            }
+
+            int right = left + 1;
+            int worst = left;
+
+            if (right < size && compare(a[right], a[left]) > 0) {
+                worst = right;
+            }
+
+            if (compare(a[worst], a[i]) <= 0) {
+                return;
+            }
+
+            swap(a, i, worst);
+            i = worst;
+        }
+    }
+
+    static void swap(Participant[] a, int i, int j) {
+        Participant tmp = a[i];
+        a[i] = a[j];
+        a[j] = tmp;
+    }
+
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0;
+        private int len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+            return buf[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            int sign = 1;
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int val = 0;
+            while (c > ' ') {
+                val = val * 10 + (c - '0');
+                c = read();
+            }
+            return val * sign;
+        }
+
+        String next() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            byte[] tmp = new byte[32];
+            int n = 0;
+
+            while (c > ' ') {
+                if (n == tmp.length) {
+                    byte[] next = new byte[tmp.length * 2];
+                    System.arraycopy(tmp, 0, next, 0, tmp.length);
+                    tmp = next;
+                }
+                tmp[n++] = (byte) c;
+                c = read();
+                if (c == -1) {
+                    break;
+                }
+            }
+
+            return new String(tmp, 0, n);
+        }
+    }
+
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0;
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (ptr == buf.length) {
+                flush();
+            }
+            buf[ptr++] = (byte) b;
+        }
+
+        void writeString(String s) throws IOException {
+            for (int i = 0; i < s.length(); i++) {
+                writeByte(s.charAt(i));
+            }
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, ptr);
+            ptr = 0;
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+
+        int n = in.nextInt();
+        Participant[] a = new Participant[n];
+
+        for (int i = 0; i < n; i++) {
+            String login = in.next();
+            int solved = in.nextInt();
+            int penalty = in.nextInt();
+            a[i] = new Participant(login, solved, penalty);
+        }
+
+        solve(a);
+
+        for (Participant p : a) {
+            out.writeString(p.login);
+            out.writeByte('\n');
+        }
+        out.flush();
+    }
+
+    private static void test() {
+        Participant[] a1 = new Participant[] {
+                new Participant("alla", 4, 100),
+                new Participant("gena", 6, 1000),
+                new Participant("gosha", 2, 90),
+                new Participant("rita", 2, 90),
+                new Participant("timofey", 4, 80)
+        };
+        solve(a1);
+        assertEq("gena", a1[0].login);
+        assertEq("timofey", a1[1].login);
+        assertEq("alla", a1[2].login);
+        assertEq("gosha", a1[3].login);
+        assertEq("rita", a1[4].login);
+
+        Participant[] a2 = new Participant[] {
+                new Participant("alla", 0, 0),
+                new Participant("gena", 0, 0),
+                new Participant("gosha", 0, 0),
+                new Participant("rita", 0, 0),
+                new Participant("timofey", 0, 0)
+        };
+        solve(a2);
+        assertEq("alla", a2[0].login);
+        assertEq("gena", a2[1].login);
+        assertEq("gosha", a2[2].login);
+        assertEq("rita", a2[3].login);
+        assertEq("timofey", a2[4].login);
+
+        Participant[] a3 = new Participant[] {
+                new Participant("b", 1, 10),
+                new Participant("a", 1, 10),
+                new Participant("c", 2, 100)
+        };
+        solve(a3);
+        assertEq("c", a3[0].login);
+        assertEq("a", a3[1].login);
+        assertEq("b", a3[2].login);
+
+        System.out.println("Test OK");
+    }
+
+    static void assertEq(String expected, String actual) {
+        if (!expected.equals(actual)) {
+            throw new AssertionError("Expected=" + expected + ", actual=" + actual);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+}
+
diff --git a/src/main/java/algorithms/sprint5/TreePartitioning.java b/src/main/java/algorithms/sprint5/TreePartitioning.java
new file mode 100644
index 0000000..03d44e0
--- /dev/null
+++ b/src/main/java/algorithms/sprint5/TreePartitioning.java
@@ -0,0 +1,176 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class TreePartitioning {
+
+
+    /*
+     * Принцип работы алгоритма:
+     * Разбиваем BST по порядковой статистике.
+     * Для текущей вершины считаем размер левого поддерева:
+     * 1) если k <= size(left), то все k наименьших элементов лежат в левом поддереве,
+     *    а текущая вершина должна попасть во второе дерево;
+     * 2) иначе в первое дерево точно входят всё левое поддерево и текущая вершина,
+     *    значит, остаётся отделить ещё k - size(left) - 1 вершин из правого поддерева.
+     *
+     * Чтобы не получить переполнение стека на вырожденном дереве, алгоритм сделан итеративно:
+     * сначала спускаемся вниз по одному пути, запоминая вершины и направление перехода,
+     * затем поднимаемся обратно и собираем два дерева, пересчитывая size.
+     *
+     * Почему алгоритм корректен:
+     * На каждом шаге решение принимается по точному числу вершин, которые меньше текущей,
+     * то есть по size(left). Поэтому мы всегда правильно определяем, должна ли текущая
+     * вершина попасть в первые k элементов.
+     *
+     * При обратной сборке:
+     * - если спускались влево, то текущая вершина и её правое поддерево относятся ко второму дереву;
+     * - если спускались вправо, то текущая вершина и её левое поддерево относятся к первому дереву.
+     *
+     * Так как переподвешиваются только поддеревья вдоль одного пути, свойство BST сохраняется.
+     * В итоге в первом дереве оказывается ровно k наименьших элементов, во втором — остальные.
+     *
+     * Временная сложность: O(h), где h — высота дерева.
+     * Пространственная сложность: O(h) на хранение пути.
+     */
+    public static List<Node> split(Node root, int k) {
+        ArrayList<Node> path = new ArrayList<>();
+        ArrayList<Boolean> wentRight = new ArrayList<>();
+
+        Node current = root;
+        int need = k;
+
+        while (current != null) {
+            int leftSize = size(current.getLeft());
+            if (need <= leftSize) {
+                path.add(current);
+                wentRight.add(false);
+                current = current.getLeft();
+            } else {
+                path.add(current);
+                wentRight.add(true);
+                need -= leftSize + 1;
+                current = current.getRight();
+            }
+        }
+
+        Node first = null;
+        Node second = null;
+
+        for (int i = path.size() - 1; i >= 0; i--) {
+            Node node = path.get(i);
+            if (wentRight.get(i)) {
+                node.setRight(first);
+                updateSize(node);
+                first = node;
+            } else {
+                node.setLeft(second);
+                updateSize(node);
+                second = node;
+            }
+        }
+
+        ArrayList<Node> result = new ArrayList<>(2);
+        result.add(first);
+        result.add(second);
+        return result;
+    }
+
+    private static int size(Node node) {
+        if (node == null) {
+            return 0;
+        }
+        return node.getSize();
+    }
+
+    private static void updateSize(Node node) {
+        node.setSize(size(node.getLeft()) + size(node.getRight()) + 1);
+    }
+
+    // <template>
+    private static class Node {
+        private Node left;
+        private Node right;
+        private int value;
+        private int size;
+
+        Node(Node left, Node right, int value, int size) {
+            this.left = left;
+            this.right = right;
+            this.value = value;
+            this.size = size;
+        }
+
+        public int getValue() {
+            return value;
+        }
+
+        public Node getRight() {
+            return right;
+        }
+
+        public void setRight(Node right) {
+            this.right = right;
+        }
+
+        public Node getLeft() {
+            return left;
+        }
+
+        public void setLeft(Node left) {
+            this.left = left;
+        }
+
+        public void setValue(int value) {
+            this.value = value;
+        }
+
+        public int getSize() {
+            return size;
+        }
+
+        public void setSize(int size) {
+            this.size = size;
+        }
+    }
+    // <template>
+
+    private static void check(boolean condition, String message) {
+        if (!condition) {
+            throw new RuntimeException(message);
+        }
+    }
+
+    public static void test() {
+        Node node1 = new Node(null, null, 3, 1);
+        Node node2 = new Node(null, node1, 2, 2);
+        Node node3 = new Node(null, null, 8, 1);
+        Node node4 = new Node(null, null, 11, 1);
+        Node node5 = new Node(node3, node4, 10, 3);
+        Node node6 = new Node(node2, node5, 5, 6);
+
+        List<Node> res = split(node6, 4);
+        check(res.get(0) != null, "first tree is null");
+        check(res.get(1) != null, "second tree is null");
+        check(res.get(0).getSize() == 4, "first tree size must be 4");
+        check(res.get(1).getSize() == 2, "second tree size must be 2");
+
+        res = split(res.get(0), 0);
+        check(res.get(0) == null, "first tree must be null when k = 0");
+        check(res.get(1) != null, "second tree must not be null when k = 0");
+        check(res.get(1).getSize() == 4, "second tree size must be 4");
+
+        Node a = new Node(null, null, 1, 1);
+        Node b = new Node(a, null, 2, 2);
+        res = split(b, 2);
+        check(res.get(0) != null, "first tree must not be null when k = n");
+        check(res.get(0).getSize() == 2, "first tree size must be 2");
+        check(res.get(1) == null, "second tree must be null when k = n");
+
+        System.out.println("Test OK");
+    }
+
+    public static void main(String[] args) {
+        test();
+    }
+
+}

From a41b5e8ba138933799727e0e9d2fd049be3bb11d Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sat, 18 Apr 2026 21:29:21 +0300
Subject: [PATCH 34/45] sprint5

---
 .../java/algorithms/sprint5/PyramidSort.java  |   2 +
 .../java/algorithms/sprint5/Solution.java     | 154 +++++++++++++++
 .../algorithms/sprint5/TreePartitioning.java  | 176 ------------------
 3 files changed, 156 insertions(+), 176 deletions(-)
 create mode 100644 src/main/java/algorithms/sprint5/Solution.java
 delete mode 100644 src/main/java/algorithms/sprint5/TreePartitioning.java

diff --git a/src/main/java/algorithms/sprint5/PyramidSort.java b/src/main/java/algorithms/sprint5/PyramidSort.java
index c50b545..685e6b4 100644
--- a/src/main/java/algorithms/sprint5/PyramidSort.java
+++ b/src/main/java/algorithms/sprint5/PyramidSort.java
@@ -3,6 +3,8 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 
+//https://contest.yandex.ru/contest/24810/run-report/160623687/
+
 public class PyramidSort {
 
     /*
diff --git a/src/main/java/algorithms/sprint5/Solution.java b/src/main/java/algorithms/sprint5/Solution.java
new file mode 100644
index 0000000..d0f8216
--- /dev/null
+++ b/src/main/java/algorithms/sprint5/Solution.java
@@ -0,0 +1,154 @@
+// https://contest.yandex.ru/contest/24810/run-report/160624033/
+
+// <template>
+class Node {
+    private int value;
+    private Node left;
+    private Node right;
+
+    Node(Node left, Node right, int value) {
+        this.left = left;
+        this.right = right;
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public Node getRight() {
+        return right;
+    }
+
+    public void setRight(Node right) {
+        this.right = right;
+    }
+
+    public Node getLeft() {
+        return left;
+    }
+
+    public void setLeft(Node left) {
+        this.left = left;
+    }
+
+    public void setValue(int value) {
+        this.value = value;
+    }
+}
+// <template>
+
+public class Solution {
+
+    /*
+     * Принцип работы алгоритма:
+     * Используем свойство бинарного дерева поиска.
+     * Если удаляемый ключ меньше значения в текущей вершине,
+     * продолжаем поиск в левом поддереве.
+     * Если больше — в правом.
+     * Когда вершина с нужным ключом найдена, возможны три случая:
+     *
+     * 1) У вершины нет левого ребёнка.
+     *    Тогда на её место должно встать правое поддерево.
+     *
+     * 2) У вершины нет правого ребёнка.
+     *    Тогда на её место должно встать левое поддерево.
+     *
+     * 3) У вершины есть оба ребёнка.
+     *    Тогда берём максимальный элемент из левого поддерева
+     *    (это предшественник текущей вершины в порядке BST),
+     *    записываем его значение в текущую вершину,
+     *    а затем удаляем этот элемент из левого поддерева.
+     *
+     * Почему алгоритм корректен:
+     * 1) По свойству BST искомый ключ может находиться только
+     *    в одном из двух поддеревьев, поэтому рекурсивный спуск
+     *    идёт ровно по нужному пути.
+     *
+     * 2) Если у удаляемой вершины не более одного ребёнка,
+     *    замена вершины её единственным поддеревом
+     *    сохраняет порядок ключей в дереве.
+     *
+     * 3) Если у вершины два ребёнка, максимум левого поддерева:
+     *    - меньше значения любой вершины из правого поддерева;
+     *    - не меньше всех остальных значений из левого поддерева.
+     *    Поэтому после замены текущего ключа на этот максимум
+     *    свойство BST сохраняется.
+     *
+     * 4) После этого мы удаляем из левого поддерева вершину,
+     *    значение которой перенесли вверх. Так как ключи уникальны,
+     *    удаляется ровно одна нужная вершина.
+     *
+     * Временная сложность: O(h), где h — высота дерева,
+     * потому что мы спускаемся только по одному пути вниз.
+     *
+     * Пространственная сложность: O(h) из-за стека рекурсии.
+     */
+
+    public static Node remove(Node root, int key) {
+        if (root == null) {
+            return null;
+        }
+
+        if (key < root.getValue()) {
+            root.setLeft(remove(root.getLeft(), key));
+            return root;
+        }
+
+        if (key > root.getValue()) {
+            root.setRight(remove(root.getRight(), key));
+            return root;
+        }
+
+        if (root.getLeft() == null) {
+            return root.getRight();
+        }
+
+        if (root.getRight() == null) {
+            return root.getLeft();
+        }
+
+        Node predecessor = findMax(root.getLeft());
+        root.setValue(predecessor.getValue());
+        root.setLeft(remove(root.getLeft(), predecessor.getValue()));
+        return root;
+    }
+
+    private static Node findMax(Node node) {
+        while (node.getRight() != null) {
+            node = node.getRight();
+        }
+        return node;
+    }
+
+    private static void test() {
+        Node node1 = new Node(null, null, 2);
+        Node node2 = new Node(node1, null, 3);
+        Node node3 = new Node(null, node2, 1);
+        Node node4 = new Node(null, null, 6);
+        Node node5 = new Node(node4, null, 8);
+        Node node6 = new Node(node5, null, 10);
+        Node node7 = new Node(node3, node6, 5);
+
+        Node newHead = remove(node7, 10);
+        assert newHead.getValue() == 5;
+        assert newHead.getRight() == node5;
+        assert newHead.getRight().getValue() == 8;
+
+        Node root = new Node(
+                new Node(new Node(null, null, 2), new Node(null, null, 4), 3),
+                new Node(new Node(null, null, 7), new Node(null, null, 9), 8),
+                5
+        );
+        Node result = remove(root, 5);
+        assert result.getValue() == 4;
+        assert result.getLeft().getValue() == 3;
+        assert result.getRight().getValue() == 8;
+
+        Node single = new Node(null, null, 1);
+        assert remove(single, 1) == null;
+
+        Node unchanged = new Node(null, null, 1);
+        assert remove(unchanged, 2) == unchanged;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/algorithms/sprint5/TreePartitioning.java b/src/main/java/algorithms/sprint5/TreePartitioning.java
deleted file mode 100644
index 03d44e0..0000000
--- a/src/main/java/algorithms/sprint5/TreePartitioning.java
+++ /dev/null
@@ -1,176 +0,0 @@
-import java.util.ArrayList;
-import java.util.List;
-
-public class TreePartitioning {
-
-
-    /*
-     * Принцип работы алгоритма:
-     * Разбиваем BST по порядковой статистике.
-     * Для текущей вершины считаем размер левого поддерева:
-     * 1) если k <= size(left), то все k наименьших элементов лежат в левом поддереве,
-     *    а текущая вершина должна попасть во второе дерево;
-     * 2) иначе в первое дерево точно входят всё левое поддерево и текущая вершина,
-     *    значит, остаётся отделить ещё k - size(left) - 1 вершин из правого поддерева.
-     *
-     * Чтобы не получить переполнение стека на вырожденном дереве, алгоритм сделан итеративно:
-     * сначала спускаемся вниз по одному пути, запоминая вершины и направление перехода,
-     * затем поднимаемся обратно и собираем два дерева, пересчитывая size.
-     *
-     * Почему алгоритм корректен:
-     * На каждом шаге решение принимается по точному числу вершин, которые меньше текущей,
-     * то есть по size(left). Поэтому мы всегда правильно определяем, должна ли текущая
-     * вершина попасть в первые k элементов.
-     *
-     * При обратной сборке:
-     * - если спускались влево, то текущая вершина и её правое поддерево относятся ко второму дереву;
-     * - если спускались вправо, то текущая вершина и её левое поддерево относятся к первому дереву.
-     *
-     * Так как переподвешиваются только поддеревья вдоль одного пути, свойство BST сохраняется.
-     * В итоге в первом дереве оказывается ровно k наименьших элементов, во втором — остальные.
-     *
-     * Временная сложность: O(h), где h — высота дерева.
-     * Пространственная сложность: O(h) на хранение пути.
-     */
-    public static List<Node> split(Node root, int k) {
-        ArrayList<Node> path = new ArrayList<>();
-        ArrayList<Boolean> wentRight = new ArrayList<>();
-
-        Node current = root;
-        int need = k;
-
-        while (current != null) {
-            int leftSize = size(current.getLeft());
-            if (need <= leftSize) {
-                path.add(current);
-                wentRight.add(false);
-                current = current.getLeft();
-            } else {
-                path.add(current);
-                wentRight.add(true);
-                need -= leftSize + 1;
-                current = current.getRight();
-            }
-        }
-
-        Node first = null;
-        Node second = null;
-
-        for (int i = path.size() - 1; i >= 0; i--) {
-            Node node = path.get(i);
-            if (wentRight.get(i)) {
-                node.setRight(first);
-                updateSize(node);
-                first = node;
-            } else {
-                node.setLeft(second);
-                updateSize(node);
-                second = node;
-            }
-        }
-
-        ArrayList<Node> result = new ArrayList<>(2);
-        result.add(first);
-        result.add(second);
-        return result;
-    }
-
-    private static int size(Node node) {
-        if (node == null) {
-            return 0;
-        }
-        return node.getSize();
-    }
-
-    private static void updateSize(Node node) {
-        node.setSize(size(node.getLeft()) + size(node.getRight()) + 1);
-    }
-
-    // <template>
-    private static class Node {
-        private Node left;
-        private Node right;
-        private int value;
-        private int size;
-
-        Node(Node left, Node right, int value, int size) {
-            this.left = left;
-            this.right = right;
-            this.value = value;
-            this.size = size;
-        }
-
-        public int getValue() {
-            return value;
-        }
-
-        public Node getRight() {
-            return right;
-        }
-
-        public void setRight(Node right) {
-            this.right = right;
-        }
-
-        public Node getLeft() {
-            return left;
-        }
-
-        public void setLeft(Node left) {
-            this.left = left;
-        }
-
-        public void setValue(int value) {
-            this.value = value;
-        }
-
-        public int getSize() {
-            return size;
-        }
-
-        public void setSize(int size) {
-            this.size = size;
-        }
-    }
-    // <template>
-
-    private static void check(boolean condition, String message) {
-        if (!condition) {
-            throw new RuntimeException(message);
-        }
-    }
-
-    public static void test() {
-        Node node1 = new Node(null, null, 3, 1);
-        Node node2 = new Node(null, node1, 2, 2);
-        Node node3 = new Node(null, null, 8, 1);
-        Node node4 = new Node(null, null, 11, 1);
-        Node node5 = new Node(node3, node4, 10, 3);
-        Node node6 = new Node(node2, node5, 5, 6);
-
-        List<Node> res = split(node6, 4);
-        check(res.get(0) != null, "first tree is null");
-        check(res.get(1) != null, "second tree is null");
-        check(res.get(0).getSize() == 4, "first tree size must be 4");
-        check(res.get(1).getSize() == 2, "second tree size must be 2");
-
-        res = split(res.get(0), 0);
-        check(res.get(0) == null, "first tree must be null when k = 0");
-        check(res.get(1) != null, "second tree must not be null when k = 0");
-        check(res.get(1).getSize() == 4, "second tree size must be 4");
-
-        Node a = new Node(null, null, 1, 1);
-        Node b = new Node(a, null, 2, 2);
-        res = split(b, 2);
-        check(res.get(0) != null, "first tree must not be null when k = n");
-        check(res.get(0).getSize() == 2, "first tree size must be 2");
-        check(res.get(1) == null, "second tree must be null when k = n");
-
-        System.out.println("Test OK");
-    }
-
-    public static void main(String[] args) {
-        test();
-    }
-
-}

From 5bd106f2ac211b6cbfa376e8239f27b9e43230fe Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sat, 18 Apr 2026 21:33:32 +0300
Subject: [PATCH 35/45] sprint5

---
 .../java/algorithms/sprint5/PyramidSort.java  |   4 +-
 .../java/algorithms/sprint5/Solution.java     | 110 +++++++-----------
 2 files changed, 42 insertions(+), 72 deletions(-)

diff --git a/src/main/java/algorithms/sprint5/PyramidSort.java b/src/main/java/algorithms/sprint5/PyramidSort.java
index 685e6b4..3d9a159 100644
--- a/src/main/java/algorithms/sprint5/PyramidSort.java
+++ b/src/main/java/algorithms/sprint5/PyramidSort.java
@@ -35,10 +35,10 @@ public class PyramidSort {
      * Временная сложность:
      * - построение кучи: O(n);
      * - n операций извлечения максимума: O(n log n);
-     * - итоговая сложность: O(n log n).
+     * - итоговая сложность: O(n log n), где n количество участников;.
      *
      * Пространственная сложность:
-     * - O(n) на хранение массива участников;
+     * - O(n) на хранение массива участников, где n количество участников;
      * - дополнительная память алгоритма сортировки: O(1).
      */
 
diff --git a/src/main/java/algorithms/sprint5/Solution.java b/src/main/java/algorithms/sprint5/Solution.java
index d0f8216..0f67235 100644
--- a/src/main/java/algorithms/sprint5/Solution.java
+++ b/src/main/java/algorithms/sprint5/Solution.java
@@ -1,42 +1,4 @@
-// https://contest.yandex.ru/contest/24810/run-report/160624033/
-
-// <template>
-class Node {
-    private int value;
-    private Node left;
-    private Node right;
-
-    Node(Node left, Node right, int value) {
-        this.left = left;
-        this.right = right;
-        this.value = value;
-    }
-
-    public int getValue() {
-        return value;
-    }
-
-    public Node getRight() {
-        return right;
-    }
-
-    public void setRight(Node right) {
-        this.right = right;
-    }
-
-    public Node getLeft() {
-        return left;
-    }
-
-    public void setLeft(Node left) {
-        this.left = left;
-    }
-
-    public void setValue(int value) {
-        this.value = value;
-    }
-}
-// <template>
+// https://contest.yandex.ru/contest/24810/run-report/160624089/
 
 public class Solution {
 
@@ -82,7 +44,8 @@ public class Solution {
      * Временная сложность: O(h), где h — высота дерева,
      * потому что мы спускаемся только по одному пути вниз.
      *
-     * Пространственная сложность: O(h) из-за стека рекурсии.
+     * Пространственная сложность: O(h) из-за стека рекурсии,
+     * где h — высота дерева.
      */
 
     public static Node remove(Node root, int key) {
@@ -120,35 +83,42 @@ private static Node findMax(Node node) {
         }
         return node;
     }
+}
+
+// <template>
+class Node {
+    private int value;
+    private Node left;
+    private Node right;
 
-    private static void test() {
-        Node node1 = new Node(null, null, 2);
-        Node node2 = new Node(node1, null, 3);
-        Node node3 = new Node(null, node2, 1);
-        Node node4 = new Node(null, null, 6);
-        Node node5 = new Node(node4, null, 8);
-        Node node6 = new Node(node5, null, 10);
-        Node node7 = new Node(node3, node6, 5);
-
-        Node newHead = remove(node7, 10);
-        assert newHead.getValue() == 5;
-        assert newHead.getRight() == node5;
-        assert newHead.getRight().getValue() == 8;
-
-        Node root = new Node(
-                new Node(new Node(null, null, 2), new Node(null, null, 4), 3),
-                new Node(new Node(null, null, 7), new Node(null, null, 9), 8),
-                5
-        );
-        Node result = remove(root, 5);
-        assert result.getValue() == 4;
-        assert result.getLeft().getValue() == 3;
-        assert result.getRight().getValue() == 8;
-
-        Node single = new Node(null, null, 1);
-        assert remove(single, 1) == null;
-
-        Node unchanged = new Node(null, null, 1);
-        assert remove(unchanged, 2) == unchanged;
+    Node(Node left, Node right, int value) {
+        this.left = left;
+        this.right = right;
+        this.value = value;
     }
-}
\ No newline at end of file
+
+    public int getValue() {
+        return value;
+    }
+
+    public Node getRight() {
+        return right;
+    }
+
+    public void setRight(Node right) {
+        this.right = right;
+    }
+
+    public Node getLeft() {
+        return left;
+    }
+
+    public void setLeft(Node left) {
+        this.left = left;
+    }
+
+    public void setValue(int value) {
+        this.value = value;
+    }
+}
+// <template>
\ No newline at end of file

From 0f038b305b7fca6eb295177d0d6e21d1d9ebd9ee Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 19 Apr 2026 21:01:57 +0300
Subject: [PATCH 36/45] sprint5

---
 src/main/java/algorithms/sprint5/Solution.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/algorithms/sprint5/Solution.java b/src/main/java/algorithms/sprint5/Solution.java
index 0f67235..e1a1bfb 100644
--- a/src/main/java/algorithms/sprint5/Solution.java
+++ b/src/main/java/algorithms/sprint5/Solution.java
@@ -42,10 +42,10 @@ public class Solution {
      *    удаляется ровно одна нужная вершина.
      *
      * Временная сложность: O(h), где h — высота дерева,
-     * потому что мы спускаемся только по одному пути вниз.
+     * что в худшем случае даёт O(n), где n — число узлов в дереве.
      *
-     * Пространственная сложность: O(h) из-за стека рекурсии,
-     * где h — высота дерева.
+     * Дополнительная пространственная сложность: O(h) из-за стека рекурсии,
+     * что в худшем случае даёт O(n).
      */
 
     public static Node remove(Node root, int key) {

From b527396bd4a9feade3e8b8a48764be9e472d2875 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 31 May 2026 07:51:12 +0300
Subject: [PATCH 37/45]  DorogayaSet

---
 .../java/algorithms/sprint6/DorogayaSet.java  | 293 ++++++++++++++++++
 1 file changed, 293 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint6/DorogayaSet.java

diff --git a/src/main/java/algorithms/sprint6/DorogayaSet.java b/src/main/java/algorithms/sprint6/DorogayaSet.java
new file mode 100644
index 0000000..edd1911
--- /dev/null
+++ b/src/main/java/algorithms/sprint6/DorogayaSet.java
@@ -0,0 +1,293 @@
+/*
+ * Принцип работы алгоритма:
+ * Нужно найти максимальное остовное дерево, поэтому используем алгоритм Краскала
+ * в обратном порядке: сортируем все рёбра по убыванию веса и последовательно
+ * добавляем ребро в ответ, если оно соединяет две разные компоненты связности.
+ * Для проверки компонент используем DSU.
+ *
+ * Петли не влияют на ответ: ребро из вершины в саму себя не соединяет разные
+ * компоненты, поэтому DSU его не добавит. Кратные рёбра обрабатываются естественно:
+ * из них раньше будут рассмотрены более тяжёлые.
+ *
+ * Почему алгоритм корректен:
+ * В алгоритме Краскала на каждом шаге выбирается самое тяжёлое ребро, которое
+ * не создаёт цикл. По свойству разреза для максимального остовного дерева такое
+ * ребро можно безопасно добавить в некоторый оптимальный остов. Повторяя этот
+ * шаг, получаем максимальное остовное дерево. Если после обработки всех рёбер
+ * выбрано меньше n - 1 ребра, значит граф несвязный и остовного дерева нет.
+ *
+ * Временная сложность: O(m log m) из-за сортировки рёбер.
+ * Операции DSU работают почти за O(1), точнее O(alpha(n)).
+ * Пространственная сложность: O(n + m), где n — число вершин, m — число рёбер.
+ */
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+public class DorogayaSet {
+
+    static final String FAIL = "Oops! I did it again";
+
+    static long solve(int n, Edge[] edges) {
+        Arrays.sort(edges, (a, b) -> Integer.compare(b.weight, a.weight));
+
+        DSU dsu = new DSU(n);
+        long totalWeight = 0;
+        int usedEdges = 0;
+
+        for (Edge edge : edges) {
+            if (dsu.union(edge.from, edge.to)) {
+                totalWeight += edge.weight;
+                usedEdges++;
+
+                if (usedEdges == n - 1) {
+                    break;
+                }
+            }
+        }
+
+        if (usedEdges != n - 1) {
+            return -1;
+        }
+
+        return totalWeight;
+    }
+
+    static final class Edge {
+        final int from;
+        final int to;
+        final int weight;
+
+        Edge(int from, int to, int weight) {
+            this.from = from;
+            this.to = to;
+            this.weight = weight;
+        }
+    }
+
+    static final class DSU {
+        private final int[] parent;
+        private final int[] size;
+
+        DSU(int n) {
+            parent = new int[n + 1];
+            size = new int[n + 1];
+
+            for (int i = 1; i <= n; i++) {
+                parent[i] = i;
+                size[i] = 1;
+            }
+        }
+
+        int find(int v) {
+            if (parent[v] != v) {
+                parent[v] = find(parent[v]);
+            }
+            return parent[v];
+        }
+
+        boolean union(int a, int b) {
+            int rootA = find(a);
+            int rootB = find(b);
+
+            if (rootA == rootB) {
+                return false;
+            }
+
+            if (size[rootA] < size[rootB]) {
+                int tmp = rootA;
+                rootA = rootB;
+                rootB = tmp;
+            }
+
+            parent[rootB] = rootA;
+            size[rootA] += size[rootB];
+            return true;
+        }
+    }
+
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0;
+        private int len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+
+            return buf[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+
+            do {
+                c = read();
+
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            int sign = 1;
+
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int val = 0;
+
+            while (c > ' ') {
+                val = val * 10 + (c - '0');
+                c = read();
+            }
+
+            return val * sign;
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+        private final byte[] tmp = new byte[20];
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) {
+                flush();
+            }
+
+            buf[p++] = (byte) b;
+        }
+
+        void writeString(String s) throws IOException {
+            for (int i = 0; i < s.length(); i++) {
+                writeByte(s.charAt(i));
+            }
+        }
+
+        void writeLong(long x) throws IOException {
+            if (x == 0) {
+                writeByte('0');
+                return;
+            }
+
+            if (x < 0) {
+                writeByte('-');
+                x = -x;
+            }
+
+            int k = 0;
+
+            while (x > 0) {
+                tmp[k++] = (byte) ('0' + (x % 10));
+                x /= 10;
+            }
+
+            for (int i = k - 1; i >= 0; i--) {
+                writeByte(tmp[i]);
+            }
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+
+        int n = in.nextInt();
+        int m = in.nextInt();
+
+        Edge[] edges = new Edge[m];
+
+        for (int i = 0; i < m; i++) {
+            int from = in.nextInt();
+            int to = in.nextInt();
+            int weight = in.nextInt();
+
+            edges[i] = new Edge(from, to, weight);
+        }
+
+        long answer = solve(n, edges);
+
+        if (answer == -1) {
+            out.writeString(FAIL);
+        } else {
+            out.writeLong(answer);
+        }
+
+        out.writeByte('\n');
+        out.flush();
+    }
+
+    private static void test() {
+        assertEq(19, solve(4, new Edge[]{
+                new Edge(1, 2, 5),
+                new Edge(1, 3, 6),
+                new Edge(2, 4, 8),
+                new Edge(3, 4, 3)
+        }));
+
+        assertEq(3, solve(3, new Edge[]{
+                new Edge(1, 2, 1),
+                new Edge(1, 2, 2),
+                new Edge(2, 3, 1)
+        }));
+
+        assertEq(-1, solve(2, new Edge[]{}));
+
+        assertEq(0, solve(1, new Edge[]{}));
+
+        assertEq(10, solve(2, new Edge[]{
+                new Edge(1, 1, 100),
+                new Edge(1, 2, 10),
+                new Edge(2, 2, 100)
+        }));
+
+        assertEq(0, solve(3, new Edge[]{
+                new Edge(1, 2, 0),
+                new Edge(2, 3, 0)
+        }));
+
+        System.out.println("Test OK");
+    }
+
+    static void assertEq(long exp, long act) {
+        if (exp != act) {
+            throw new AssertionError("Expected=" + exp + ", actual=" + act);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+}
\ No newline at end of file

From 279d2332fa7864396687efd13748d9ef443a0b98 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 31 May 2026 07:53:20 +0300
Subject: [PATCH 38/45] WaterWorld

---
 .../java/algorithms/sprint6/WaterWorld.java   | 288 ++++++++++++++++++
 1 file changed, 288 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint6/WaterWorld.java

diff --git a/src/main/java/algorithms/sprint6/WaterWorld.java b/src/main/java/algorithms/sprint6/WaterWorld.java
new file mode 100644
index 0000000..a0b75af
--- /dev/null
+++ b/src/main/java/algorithms/sprint6/WaterWorld.java
@@ -0,0 +1,288 @@
+/*
+ * Принцип работы алгоритма:
+ * Поле рассматривается как неориентированный граф: каждая клетка земли '#' — вершина,
+ * а рёбра есть между соседними по стороне клетками земли. Идём по всем клеткам поля.
+ * Если встречаем ещё не обработанную землю, значит найден новый остров. Запускаем из неё
+ * итеративный BFS, помечаем все клетки этого острова как воду '.', одновременно считаем
+ * размер острова и обновляем максимум.
+ *
+ * Почему алгоритм корректен:
+ * Остров — это компонента связности клеток земли по четырём направлениям. BFS из любой
+ * клетки такой компоненты посещает ровно все клетки этой компоненты: к каждой достижимой
+ * по сторонам клетке он перейдёт, а за пределы компоненты не выйдет, потому что переходит
+ * только в клетки '#'. После посещения клетки помечаются как '.', поэтому один и тот же
+ * остров не будет посчитан повторно. Значит, каждое новое начало BFS соответствует ровно
+ * одному острову, а посчитанный внутри BFS размер равен количеству клеток этого острова.
+ * Перебор всех клеток гарантирует, что будут найдены все острова.
+ *
+ * Временная сложность: O(n * m), каждая клетка проверяется и обрабатывается не более одного раза.
+ * Пространственная сложность: O(n * m), храним поле и очередь для BFS.
+ */
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class WaterWorld {
+
+    static int[] solve(byte[] map, int n, int m) {
+        int total = n * m;
+        int[] queue = new int[total];
+
+        int islandCount = 0;
+        int maxIslandSize = 0;
+
+        for (int start = 0; start < total; start++) {
+            if (map[start] != '#') {
+                continue;
+            }
+
+            islandCount++;
+            int currentSize = 0;
+            int head = 0;
+            int tail = 0;
+
+            queue[tail++] = start;
+            map[start] = '.';
+
+            while (head < tail) {
+                int v = queue[head++];
+                currentSize++;
+
+                int col = v % m;
+
+                int up = v - m;
+                if (v >= m && map[up] == '#') {
+                    map[up] = '.';
+                    queue[tail++] = up;
+                }
+
+                int down = v + m;
+                if (down < total && map[down] == '#') {
+                    map[down] = '.';
+                    queue[tail++] = down;
+                }
+
+                int left = v - 1;
+                if (col > 0 && map[left] == '#') {
+                    map[left] = '.';
+                    queue[tail++] = left;
+                }
+
+                int right = v + 1;
+                if (col + 1 < m && map[right] == '#') {
+                    map[right] = '.';
+                    queue[tail++] = right;
+                }
+            }
+
+            if (currentSize > maxIslandSize) {
+                maxIslandSize = currentSize;
+            }
+        }
+
+        return new int[]{islandCount, maxIslandSize};
+    }
+
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0;
+        private int len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+            return buf[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            int sign = 1;
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int val = 0;
+            while (c > ' ') {
+                val = val * 10 + (c - '0');
+                c = read();
+            }
+            return val * sign;
+        }
+
+        byte[] nextBytes(int length) throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            byte[] result = new byte[length];
+            for (int i = 0; i < length; i++) {
+                if (c <= ' ') {
+                    throw new EOFException("Unexpected end of token");
+                }
+                result[i] = (byte) c;
+                if (i + 1 < length) {
+                    c = read();
+                }
+            }
+            return result;
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+        private final byte[] tmp = new byte[12];
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) {
+                flush();
+            }
+            buf[p++] = (byte) b;
+        }
+
+        void writeInt(int x) throws IOException {
+            if (x == 0) {
+                writeByte('0');
+                return;
+            }
+            if (x < 0) {
+                writeByte('-');
+                x = -x;
+            }
+
+            int k = 0;
+            while (x > 0) {
+                tmp[k++] = (byte) ('0' + (x % 10));
+                x /= 10;
+            }
+            for (int i = k - 1; i >= 0; i--) {
+                writeByte(tmp[i]);
+            }
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+
+        int n = in.nextInt();
+        int m = in.nextInt();
+        byte[] map = new byte[n * m];
+
+        for (int row = 0; row < n; row++) {
+            byte[] line = in.nextBytes(m);
+            System.arraycopy(line, 0, map, row * m, m);
+        }
+
+        int[] answer = solve(map, n, m);
+        out.writeInt(answer[0]);
+        out.writeByte(' ');
+        out.writeInt(answer[1]);
+        out.writeByte('\n');
+        out.flush();
+    }
+
+    private static void test() {
+        assertAnswer(5, 1, solve(map(
+                "#.#",
+                ".#.",
+                "#.#"
+        ), 3, 3));
+
+        assertAnswer(2, 6, solve(map(
+                "#####",
+                ".#...",
+                "..#..",
+                "#####"
+        ), 4, 5));
+
+        assertAnswer(0, 0, solve(map(
+                "...",
+                "..."
+        ), 2, 3));
+
+        assertAnswer(1, 6, solve(map(
+                "###",
+                "###"
+        ), 2, 3));
+
+        assertAnswer(4, 1, solve(map(
+                "#.#",
+                "...",
+                "#.#"
+        ), 3, 3));
+
+        assertAnswer(2, 3, solve(map(
+                "##.",
+                "#..",
+                "..#"
+        ), 3, 3));
+
+        System.out.println("Test OK");
+    }
+
+    private static byte[] map(String... rows) {
+        int n = rows.length;
+        int m = rows[0].length();
+        byte[] result = new byte[n * m];
+        for (int row = 0; row < n; row++) {
+            for (int col = 0; col < m; col++) {
+                result[row * m + col] = (byte) rows[row].charAt(col);
+            }
+        }
+        return result;
+    }
+
+    private static void assertAnswer(int expectedCount, int expectedMaxSize, int[] actual) {
+        if (actual[0] != expectedCount || actual[1] != expectedMaxSize) {
+            throw new AssertionError(
+                    "Expected=" + expectedCount + " " + expectedMaxSize
+                            + ", actual=" + actual[0] + " " + actual[1]
+            );
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+}
\ No newline at end of file

From 41b1359ac5203ffce8cd19ae148961cde8023eb0 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 31 May 2026 08:05:06 +0300
Subject: [PATCH 39/45] WaterWorld

---
 .../java/algorithms/sprint6/WaterWorld.java   | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/main/java/algorithms/sprint6/WaterWorld.java b/src/main/java/algorithms/sprint6/WaterWorld.java
index a0b75af..09e2dea 100644
--- a/src/main/java/algorithms/sprint6/WaterWorld.java
+++ b/src/main/java/algorithms/sprint6/WaterWorld.java
@@ -24,6 +24,27 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 
+/*
+ * Принцип работы алгоритма:
+ * Поле рассматривается как неориентированный граф: каждая клетка земли '#' — вершина,
+ * а рёбра есть между соседними по стороне клетками земли. Идём по всем клеткам поля.
+ * Если встречаем ещё не обработанную землю, значит найден новый остров. Запускаем из неё
+ * итеративный BFS, помечаем все клетки этого острова как воду '.', одновременно считаем
+ * размер острова и обновляем максимум.
+ *
+ * Почему алгоритм корректен:
+ * Остров — это компонента связности клеток земли по четырём направлениям. BFS из любой
+ * клетки такой компоненты посещает ровно все клетки этой компоненты: к каждой достижимой
+ * по сторонам клетке он перейдёт, а за пределы компоненты не выйдет, потому что переходит
+ * только в клетки '#'. После посещения клетки помечаются как '.', поэтому один и тот же
+ * остров не будет посчитан повторно. Значит, каждое новое начало BFS соответствует ровно
+ * одному острову, а посчитанный внутри BFS размер равен количеству клеток этого острова.
+ * Перебор всех клеток гарантирует, что будут найдены все острова.
+ *
+ * Временная сложность: O(n * m), каждая клетка проверяется и обрабатывается не более одного раза.
+ * Пространственная сложность: O(n * m), храним поле и очередь для BFS.
+ */
+
 public class WaterWorld {
 
     static int[] solve(byte[] map, int n, int m) {

From 0cc6a5bbcdbab8ec941091709d48d51796979318 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 31 May 2026 08:13:37 +0300
Subject: [PATCH 40/45] sprint 6

---
 .../java/algorithms/sprint6/DorogayaSet.java  |  8 +++--
 .../java/algorithms/sprint6/WaterWorld.java   | 29 ++++---------------
 2 files changed, 10 insertions(+), 27 deletions(-)

diff --git a/src/main/java/algorithms/sprint6/DorogayaSet.java b/src/main/java/algorithms/sprint6/DorogayaSet.java
index edd1911..6b12527 100644
--- a/src/main/java/algorithms/sprint6/DorogayaSet.java
+++ b/src/main/java/algorithms/sprint6/DorogayaSet.java
@@ -16,8 +16,10 @@
  * шаг, получаем максимальное остовное дерево. Если после обработки всех рёбер
  * выбрано меньше n - 1 ребра, значит граф несвязный и остовного дерева нет.
  *
- * Временная сложность: O(m log m) из-за сортировки рёбер.
- * Операции DSU работают почти за O(1), точнее O(alpha(n)).
+ * Временная сложность: O(m log m), где m — число рёбер.
+ * Основное время занимает сортировка рёбер. Операции DSU работают почти за O(1),
+ * точнее O(alpha(n)), где n — число вершин, а alpha(n) — обратная функция Аккермана.
+ * Она растёт настолько медленно, что для практических размеров входа считается константой.
  * Пространственная сложность: O(n + m), где n — число вершин, m — число рёбер.
  */
 
@@ -290,4 +292,4 @@ public static void main(String[] args) throws Exception {
             run();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/algorithms/sprint6/WaterWorld.java b/src/main/java/algorithms/sprint6/WaterWorld.java
index 09e2dea..32435b2 100644
--- a/src/main/java/algorithms/sprint6/WaterWorld.java
+++ b/src/main/java/algorithms/sprint6/WaterWorld.java
@@ -15,8 +15,10 @@
  * одному острову, а посчитанный внутри BFS размер равен количеству клеток этого острова.
  * Перебор всех клеток гарантирует, что будут найдены все острова.
  *
- * Временная сложность: O(n * m), каждая клетка проверяется и обрабатывается не более одного раза.
- * Пространственная сложность: O(n * m), храним поле и очередь для BFS.
+ * Временная сложность: O(n * m), где n — количество строк, m — количество столбцов.
+ * Каждая клетка проверяется и обрабатывается не более одного раза.
+ * Пространственная сложность: O(n * m), где n — количество строк, m — количество столбцов.
+ * Храним поле и очередь для BFS.
  */
 
 import java.io.EOFException;
@@ -24,27 +26,6 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 
-/*
- * Принцип работы алгоритма:
- * Поле рассматривается как неориентированный граф: каждая клетка земли '#' — вершина,
- * а рёбра есть между соседними по стороне клетками земли. Идём по всем клеткам поля.
- * Если встречаем ещё не обработанную землю, значит найден новый остров. Запускаем из неё
- * итеративный BFS, помечаем все клетки этого острова как воду '.', одновременно считаем
- * размер острова и обновляем максимум.
- *
- * Почему алгоритм корректен:
- * Остров — это компонента связности клеток земли по четырём направлениям. BFS из любой
- * клетки такой компоненты посещает ровно все клетки этой компоненты: к каждой достижимой
- * по сторонам клетке он перейдёт, а за пределы компоненты не выйдет, потому что переходит
- * только в клетки '#'. После посещения клетки помечаются как '.', поэтому один и тот же
- * остров не будет посчитан повторно. Значит, каждое новое начало BFS соответствует ровно
- * одному острову, а посчитанный внутри BFS размер равен количеству клеток этого острова.
- * Перебор всех клеток гарантирует, что будут найдены все острова.
- *
- * Временная сложность: O(n * m), каждая клетка проверяется и обрабатывается не более одного раза.
- * Пространственная сложность: O(n * m), храним поле и очередь для BFS.
- */
-
 public class WaterWorld {
 
     static int[] solve(byte[] map, int n, int m) {
@@ -306,4 +287,4 @@ public static void main(String[] args) throws Exception {
             run();
         }
     }
-}
\ No newline at end of file
+}

From d06bfff564498fe399e555bf03704fad5cb03c76 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Sun, 31 May 2026 08:15:48 +0300
Subject: [PATCH 41/45] sprint 6

---
 src/main/java/algorithms/sprint6/DorogayaSet.java | 2 ++
 src/main/java/algorithms/sprint6/WaterWorld.java  | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/src/main/java/algorithms/sprint6/DorogayaSet.java b/src/main/java/algorithms/sprint6/DorogayaSet.java
index 6b12527..e7b7fb1 100644
--- a/src/main/java/algorithms/sprint6/DorogayaSet.java
+++ b/src/main/java/algorithms/sprint6/DorogayaSet.java
@@ -29,6 +29,8 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
+// https://contest.yandex.ru/contest/25070/run-report/162675299/
+
 public class DorogayaSet {
 
     static final String FAIL = "Oops! I did it again";
diff --git a/src/main/java/algorithms/sprint6/WaterWorld.java b/src/main/java/algorithms/sprint6/WaterWorld.java
index 32435b2..49d083b 100644
--- a/src/main/java/algorithms/sprint6/WaterWorld.java
+++ b/src/main/java/algorithms/sprint6/WaterWorld.java
@@ -26,6 +26,8 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 
+// https://contest.yandex.ru/contest/25070/run-report/162675302/
+
 public class WaterWorld {
 
     static int[] solve(byte[] map, int n, int m) {

From 2ef9b626d80de3b9c258fdd2ea4daf2dc4cf4196 Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Mon, 1 Jun 2026 11:19:13 +0300
Subject: [PATCH 42/45] sprint 7

---
 .../java/algorithms/sprint7/EqualSums.java    | 205 ++++++++++++++++++
 .../sprint7/LevenshteinDistance.java          | 205 ++++++++++++++++++
 2 files changed, 410 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint7/EqualSums.java
 create mode 100644 src/main/java/algorithms/sprint7/LevenshteinDistance.java

diff --git a/src/main/java/algorithms/sprint7/EqualSums.java b/src/main/java/algorithms/sprint7/EqualSums.java
new file mode 100644
index 0000000..3e1447b
--- /dev/null
+++ b/src/main/java/algorithms/sprint7/EqualSums.java
@@ -0,0 +1,205 @@
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/*
+Принцип работы алгоритма:
+Нужно понять, можно ли выбрать часть партий так, чтобы сумма очков в них была равна половине общей суммы.
+Если общая сумма нечётная, две равные части получить нельзя.
+Иначе решаем задачу о достижимой сумме: храним битовую динамику reachable, где бит s равен 1,
+если некоторым набором уже рассмотренных партий можно набрать сумму s. Изначально достижима сумма 0.
+Для очередного значения x обновляем reachable операцией reachable |= reachable << x.
+После обработки всех значений проверяем достижимость суммы total / 2.
+
+Доказательство корректности:
+После обработки первых i партий инвариант такой: бит s в reachable установлен тогда и только тогда,
+когда из этих i партий можно выбрать подмножество с суммой s.
+База: до обработки партий достижима только сумма 0, это пустое подмножество.
+Переход: для партии с очками x каждая старая достижимая сумма s остаётся достижимой, если не брать эту партию,
+а сумма s + x становится достижимой, если взять её. Именно это делает reachable |= reachable << x.
+По индукции после всех партий reachable содержит ровно все суммы, которые можно набрать подмножеством партий.
+Разбиение на две равные части существует тогда и только тогда, когда общая сумма чётная и достижима сумма total / 2:
+выбранное подмножество даёт первую часть, все остальные партии — вторую с такой же суммой.
+
+Сложность:
+Пусть S — общая сумма очков, S <= 300 * 300 = 90000.
+Временная сложность — O(n * S / 64), потому что суммы хранятся битами в long-блоках.
+Пространственная сложность — O(S / 64).
+*/
+public class EqualSums {
+
+    static boolean solve(int[] points) {
+        int total = 0;
+        for (int point : points) {
+            total += point;
+        }
+
+        if ((total & 1) == 1) {
+            return false;
+        }
+
+        int target = total / 2;
+        long[] reachable = new long[(target >> 6) + 1];
+        reachable[0] = 1L;
+
+        for (int point : points) {
+            if (point <= 0 || point > target) {
+                continue;
+            }
+
+            addPoint(reachable, point);
+
+            if (isReachable(reachable, target)) {
+                return true;
+            }
+        }
+
+        return isReachable(reachable, target);
+    }
+
+    private static void addPoint(long[] reachable, int point) {
+        int wordShift = point >> 6;
+        int bitShift = point & 63;
+
+        for (int word = reachable.length - 1; word >= wordShift; word--) {
+            long shifted = reachable[word - wordShift] << bitShift;
+
+            if (bitShift != 0 && word - wordShift - 1 >= 0) {
+                shifted |= reachable[word - wordShift - 1] >>> (64 - bitShift);
+            }
+
+            reachable[word] |= shifted;
+        }
+    }
+
+    private static boolean isReachable(long[] reachable, int sum) {
+        return (reachable[sum >> 6] & (1L << (sum & 63))) != 0;
+    }
+
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0;
+        private int len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+
+            return buf[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+
+            do {
+                c = read();
+
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            int sign = 1;
+
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int val = 0;
+
+            while (c > ' ') {
+                val = val * 10 + (c - '0');
+                c = read();
+            }
+
+            return val * sign;
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) {
+                flush();
+            }
+
+            buf[p++] = (byte) b;
+        }
+
+        void writeAscii(String s) throws IOException {
+            for (int i = 0; i < s.length(); i++) {
+                writeByte(s.charAt(i));
+            }
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+
+        int n = in.nextInt();
+        int[] points = new int[n];
+
+        for (int i = 0; i < n; i++) {
+            points[i] = in.nextInt();
+        }
+
+        out.writeAscii(solve(points) ? "True" : "False");
+        out.writeByte('\n');
+        out.flush();
+    }
+
+    private static void test() {
+        assertEq(true, solve(new int[]{1, 5, 7, 1}));
+        assertEq(false, solve(new int[]{2, 10, 9}));
+        assertEq(true, solve(new int[]{}));
+        assertEq(true, solve(new int[]{0, 0, 0}));
+        assertEq(false, solve(new int[]{1}));
+        assertEq(true, solve(new int[]{1, 1}));
+        assertEq(true, solve(new int[]{100, 200, 300}));
+        assertEq(false, solve(new int[]{100, 200, 301}));
+
+        System.out.println("Test OK");
+    }
+
+    static void assertEq(boolean exp, boolean act) {
+        if (exp != act) {
+            throw new AssertionError("Expected=" + exp + ", actual=" + act);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/algorithms/sprint7/LevenshteinDistance.java b/src/main/java/algorithms/sprint7/LevenshteinDistance.java
new file mode 100644
index 0000000..1e22c6e
--- /dev/null
+++ b/src/main/java/algorithms/sprint7/LevenshteinDistance.java
@@ -0,0 +1,205 @@
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/*
+Принцип работы алгоритма:
+Используем динамическое программирование по префиксам строк. Пусть dp[i][j] — минимальное
+число операций, чтобы превратить первые i символов первой строки в первые j символов второй.
+Переход берёт минимум из трёх вариантов: удалить символ, вставить символ или заменить символ.
+Если текущие символы равны, замена имеет цену 0. Полную таблицу хранить не нужно: для расчёта
+текущей строки достаточно предыдущей строки и уже посчитанных значений текущей строки.
+
+Доказательство корректности:
+База корректна: пустую строку можно превратить в префикс длины j ровно j вставками, а префикс
+длины i в пустую строку — ровно i удалениями. Для непустых префиксов последняя операция в любом
+оптимальном преобразовании — это либо удаление последнего символа первой строки, либо вставка
+последнего символа второй строки, либо замена/сохранение последнего символа. Алгоритм перебирает
+все эти возможные последние операции и выбирает минимум, значит находит оптимальное значение для
+каждой пары префиксов. По индукции по сумме длин префиксов значение для полных строк тоже
+оптимально.
+
+Временная сложность: O(n * m), где n и m — длины строк.
+Пространственная сложность: O(min(n, m)), потому что хранится только две строки динамики.
+*/
+public class LevenshteinDistance {
+
+    static int solve(String first, String second) {
+        String s = first;
+        String t = second;
+
+        if (t.length() > s.length()) {
+            String tmp = s;
+            s = t;
+            t = tmp;
+        }
+
+        int n = s.length();
+        int m = t.length();
+
+        int[] previous = new int[m + 1];
+        int[] current = new int[m + 1];
+
+        for (int j = 0; j <= m; j++) {
+            previous[j] = j;
+        }
+
+        for (int i = 1; i <= n; i++) {
+            current[0] = i;
+            char fromChar = s.charAt(i - 1);
+
+            for (int j = 1; j <= m; j++) {
+                int deletion = previous[j] + 1;
+                int insertion = current[j - 1] + 1;
+
+                int replacement = previous[j - 1];
+                if (fromChar != t.charAt(j - 1)) {
+                    replacement++;
+                }
+
+                current[j] = Math.min(Math.min(deletion, insertion), replacement);
+            }
+
+            int[] tmp = previous;
+            previous = current;
+            current = tmp;
+        }
+
+        return previous[m];
+    }
+
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0;
+        private int len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+            return buf[ptr++];
+        }
+
+        String nextLine() throws IOException {
+            byte[] tmp = new byte[1024];
+            int size = 0;
+            int c = read();
+
+            if (c == -1) {
+                throw new EOFException("Unexpected EOF");
+            }
+
+            while (c != -1 && c != '\n') {
+                if (c != '\r') {
+                    if (size == tmp.length) {
+                        byte[] grown = new byte[tmp.length * 2];
+                        System.arraycopy(tmp, 0, grown, 0, tmp.length);
+                        tmp = grown;
+                    }
+                    tmp[size++] = (byte) c;
+                }
+                c = read();
+            }
+
+            return new String(tmp, 0, size);
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+        private final byte[] tmp = new byte[12];
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) {
+                flush();
+            }
+            buf[p++] = (byte) b;
+        }
+
+        void writeInt(int x) throws IOException {
+            if (x == 0) {
+                writeByte('0');
+                return;
+            }
+
+            if (x < 0) {
+                writeByte('-');
+                x = -x;
+            }
+
+            int k = 0;
+            while (x > 0) {
+                tmp[k++] = (byte) ('0' + (x % 10));
+                x /= 10;
+            }
+
+            for (int i = k - 1; i >= 0; i--) {
+                writeByte(tmp[i]);
+            }
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+
+        String s = in.nextLine();
+        String t = in.nextLine();
+
+        out.writeInt(solve(s, t));
+        out.writeByte('\n');
+        out.flush();
+    }
+
+    private static void test() {
+        assertEq(2, solve("abacaba", "abaabc"));
+        assertEq(3, solve("innokentiy", "innnokkentia"));
+        assertEq(1, solve("r", "x"));
+
+        assertEq(0, solve("abc", "abc"));
+        assertEq(3, solve("", "abc"));
+        assertEq(3, solve("abc", ""));
+        assertEq(3, solve("kitten", "sitting"));
+        assertEq(1, solve("abc", "ab"));
+        assertEq(1, solve("ab", "abc"));
+
+        System.out.println("Test OK");
+    }
+
+    static void assertEq(int expected, int actual) {
+        if (expected != actual) {
+            throw new AssertionError("Expected=" + expected + ", actual=" + actual);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+}
\ No newline at end of file

From 6a2f0c4c5b9b5a61b6c1fa6452c246e78cf1ab3c Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Mon, 1 Jun 2026 23:01:43 +0300
Subject: [PATCH 43/45] sprint 7

---
 src/main/java/algorithms/sprint7/EqualSums.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/java/algorithms/sprint7/EqualSums.java b/src/main/java/algorithms/sprint7/EqualSums.java
index 3e1447b..e8bb418 100644
--- a/src/main/java/algorithms/sprint7/EqualSums.java
+++ b/src/main/java/algorithms/sprint7/EqualSums.java
@@ -23,7 +23,8 @@
 выбранное подмножество даёт первую часть, все остальные партии — вторую с такой же суммой.
 
 Сложность:
-Пусть S — общая сумма очков, S <= 300 * 300 = 90000.
+Пусть n — количество партий, S — общая сумма очков.
+Так как n <= 300 и каждое значение <= 300, S <= 300 * 300 = 90000.
 Временная сложность — O(n * S / 64), потому что суммы хранятся битами в long-блоках.
 Пространственная сложность — O(S / 64).
 */

From 103177f8acf84bffab2ac7bd4815051e4a3b14cf Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Tue, 2 Jun 2026 22:18:25 +0300
Subject: [PATCH 44/45] sprint 8

---
 src/main/java/algorithms/sprint8/Crib.java    | 259 +++++++++++
 .../java/algorithms/sprint8/PackedPrefix.java | 422 ++++++++++++++++++
 2 files changed, 681 insertions(+)
 create mode 100644 src/main/java/algorithms/sprint8/Crib.java
 create mode 100644 src/main/java/algorithms/sprint8/PackedPrefix.java

diff --git a/src/main/java/algorithms/sprint8/Crib.java b/src/main/java/algorithms/sprint8/Crib.java
new file mode 100644
index 0000000..0e47516
--- /dev/null
+++ b/src/main/java/algorithms/sprint8/Crib.java
@@ -0,0 +1,259 @@
+/*
+Принцип работы алгоритма:
+строим бор по допустимым словам. Затем запускаем динамику по тексту:
+dp[i] означает, что префикс text[0..i) можно разбить на слова из словаря.
+Из каждой достижимой позиции i идём по бору вдоль text[i..]. Каждый раз,
+когда попадаем в терминальную вершину, помечаем позицию после найденного слова
+как достижимую.
+
+Корректность:
+База dp[0] истинна, потому что пустой префикс уже корректно разбит.
+Если dp[i] истинна и из позиции i в боре найдено слово text[i..j), то префикс
+text[0..j) разбивается корректно: сначала берём корректное разбиение text[0..i),
+затем добавляем найденное слово. Поэтому каждый переход алгоритма сохраняет
+корректность.
+Обратно, если текст имеет корректное разбиение на слова w1, w2, ..., wk, то после
+обработки позиции 0 алгоритм отметит конец w1, затем из этой позиции отметит
+конец w2 и так далее. По индукции будет отмечена позиция |text|. Значит,
+алгоритм вернёт YES тогда и только тогда, когда разбиение существует.
+
+Сложность:
+Пусть N = |text|, S — сумма длин слов, L — максимальная длина слова.
+Построение бора занимает O(S). Динамика проходит из каждой достижимой позиции
+не глубже L символов, поэтому работает за O(N * L). Здесь L <= 100.
+Память: O(S * 26 + N) на бор и массив dp.
+*/
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class Crib {
+
+    static boolean solve(String text, String[] words) {
+        int totalLength = 0;
+        for (String word : words) {
+            totalLength += word.length();
+        }
+
+        Trie trie = new Trie(totalLength + 1);
+        for (String word : words) {
+            trie.add(word);
+        }
+
+        char[] chars = text.toCharArray();
+        boolean[] dp = new boolean[chars.length + 1];
+        dp[0] = true;
+
+        for (int start = 0; start < chars.length; start++) {
+            if (!dp[start]) {
+                continue;
+            }
+
+            int node = 0;
+            for (int pos = start; pos < chars.length; pos++) {
+                int letter = chars[pos] - 'a';
+                node = trie.next[node][letter];
+
+                if (node == 0) {
+                    break;
+                }
+
+                if (trie.terminal[node]) {
+                    dp[pos + 1] = true;
+                }
+            }
+
+            if (dp[chars.length]) {
+                return true;
+            }
+        }
+
+        return dp[chars.length];
+    }
+
+    static final class Trie {
+        final int[][] next;
+        final boolean[] terminal;
+        int size = 1;
+
+        Trie(int capacity) {
+            next = new int[capacity][26];
+            terminal = new boolean[capacity];
+        }
+
+        void add(String word) {
+            int node = 0;
+            for (int i = 0; i < word.length(); i++) {
+                int letter = word.charAt(i) - 'a';
+                if (next[node][letter] == 0) {
+                    next[node][letter] = size;
+                    size++;
+                }
+                node = next[node][letter];
+            }
+            terminal[node] = true;
+        }
+    }
+
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0;
+        private int len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+            return buf[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            int sign = 1;
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int val = 0;
+            while (c > ' ') {
+                val = val * 10 + (c - '0');
+                c = read();
+            }
+            return val * sign;
+        }
+
+        String next() throws IOException {
+            int c;
+            do {
+                c = read();
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            byte[] tmp = new byte[128];
+            int n = 0;
+            while (c > ' ') {
+                if (n == tmp.length) {
+                    byte[] resized = new byte[tmp.length * 2];
+                    System.arraycopy(tmp, 0, resized, 0, tmp.length);
+                    tmp = resized;
+                }
+                tmp[n++] = (byte) c;
+                c = read();
+                if (c == -1) {
+                    break;
+                }
+            }
+            return new String(tmp, 0, n);
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) {
+                flush();
+            }
+            buf[p++] = (byte) b;
+        }
+
+        void writeString(String s) throws IOException {
+            for (int i = 0; i < s.length(); i++) {
+                writeByte(s.charAt(i));
+            }
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+
+        String text = in.next();
+        int n = in.nextInt();
+        String[] words = new String[n];
+
+        for (int i = 0; i < n; i++) {
+            words[i] = in.next();
+        }
+
+        out.writeString(solve(text, words) ? "YES" : "NO");
+        out.writeByte('\n');
+        out.flush();
+    }
+
+    private static void test() {
+        assertEq(true, solve("examiwillpasstheexam", new String[]{
+                "will", "pass", "the", "exam", "i"
+        }));
+
+        assertEq(false, solve("abacaba", new String[]{
+                "abac", "caba"
+        }));
+
+        assertEq(true, solve("abacaba", new String[]{
+                "abac", "caba", "aba"
+        }));
+
+        assertEq(true, solve("aaaaaa", new String[]{
+                "a", "aa", "aaa"
+        }));
+
+        assertEq(false, solve("aaaaab", new String[]{
+                "a", "aa", "aaa"
+        }));
+
+        assertEq(true, solve("leetcode", new String[]{
+                "leet", "code"
+        }));
+
+        System.out.println("Test OK");
+    }
+
+    static void assertEq(boolean exp, boolean act) {
+        if (exp != act) {
+            throw new AssertionError("Expected=" + exp + ", actual=" + act);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+}
diff --git a/src/main/java/algorithms/sprint8/PackedPrefix.java b/src/main/java/algorithms/sprint8/PackedPrefix.java
new file mode 100644
index 0000000..843e30c
--- /dev/null
+++ b/src/main/java/algorithms/sprint8/PackedPrefix.java
@@ -0,0 +1,422 @@
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/*
+ * Принцип работы алгоритма:
+ * Сначала распаковываем первую строку: она задаёт максимальную возможную длину ответа.
+ * Для каждой следующей строки генерируем символы её распакованного вида только до текущей
+ * длины общего префикса и сразу сравниваем их с первой распакованной строкой.
+ *
+ * Распаковка сделана итеративно, без рекурсии. Сначала строится массив соответствия
+ * открывающих и закрывающих скобок. Затем стек кадров имитирует рекурсивный обход:
+ * буквы выдаются как есть, а конструкция k[A] обходит содержимое A ровно k раз.
+ * Конструкции 1[A] предварительно заменяются на A, чтобы длинные цепочки единичных
+ * повторов не заставляли многократно проходить одни и те же скобки.
+ *
+ * Почему алгоритм корректен:
+ * Общий префикс уже обработанных строк всегда является префиксом первой строки.
+ * При добавлении очередной строки новый общий префикс не может быть длиннее текущего,
+ * поэтому достаточно сравнить только первые prefixLength символов её распакованного вида.
+ * Итеративный распаковщик выдаёт символы в том же порядке, что и рекурсивное определение ЗС:
+ * конкатенация сохраняет порядок частей, а k[A] повторяет A ровно k раз.
+ * Первая позиция несовпадения даёт новую длину общего префикса. Если строка закончилась
+ * раньше, новая длина равна длине этой строки. По индукции после обработки всех строк
+ * получаем наибольший общий префикс всех распакованных строк.
+ *
+ * Временная сложность:
+ * Для каждой строки: O(m + p), где m — длина запакованной строки, p — число реально
+ * проверенных символов распакованной строки, p <= 100000.
+ * В худшем случае: O(n * L), где L <= 100000.
+ *
+ * Пространственная сложность:
+ * O(L + m), где L — длина первой распакованной строки, m — длина текущей запакованной строки.
+ */
+public class PackedPrefix {
+    private static final int MAX_UNPACKED_LENGTH = 100_000;
+
+    static String solve(String[] packedStrings) {
+        String first = decodePrefix(packedStrings[0], MAX_UNPACKED_LENGTH);
+        int prefixLength = first.length();
+
+        for (int i = 1; i < packedStrings.length; i++) {
+            if (prefixLength == 0) {
+                break;
+            }
+            prefixLength = commonPrefixWithPacked(packedStrings[i], first, prefixLength);
+        }
+
+        return first.substring(0, prefixLength);
+    }
+
+    private static String decodePrefix(String packed, int limit) {
+        if (limit == 0) {
+            return "";
+        }
+
+        packed = removeSingleRepeats(packed);
+
+        int[] matchingBracket = buildMatchingBrackets(packed);
+        int maxFrames = packed.length() + 1;
+        int[] starts = new int[maxFrames];
+        int[] positions = new int[maxFrames];
+        int[] ends = new int[maxFrames];
+        int[] repeatsLeft = new int[maxFrames];
+
+        int top = 0;
+        starts[top] = 0;
+        positions[top] = 0;
+        ends[top] = packed.length();
+        repeatsLeft[top] = 1;
+
+        StringBuilder decoded = new StringBuilder(Math.min(limit, packed.length()));
+
+        while (top >= 0 && decoded.length() < limit) {
+            if (positions[top] >= ends[top]) {
+                repeatsLeft[top]--;
+
+                if (repeatsLeft[top] > 0) {
+                    positions[top] = starts[top];
+                } else {
+                    top--;
+                }
+
+                continue;
+            }
+
+            char current = packed.charAt(positions[top]);
+
+            if (current >= 'a' && current <= 'z') {
+                decoded.append(current);
+                positions[top]++;
+            } else {
+                int repeat = current - '0';
+                int openBracket = positions[top] + 1;
+                int closeBracket = matchingBracket[openBracket];
+
+                positions[top] = closeBracket + 1;
+
+                top++;
+                starts[top] = openBracket + 1;
+                positions[top] = openBracket + 1;
+                ends[top] = closeBracket;
+                repeatsLeft[top] = repeat;
+            }
+        }
+
+        return decoded.toString();
+    }
+
+    private static int commonPrefixWithPacked(String packed, String base, int limit) {
+        if (limit == 0) {
+            return 0;
+        }
+
+        packed = removeSingleRepeats(packed);
+
+        int[] matchingBracket = buildMatchingBrackets(packed);
+        int maxFrames = packed.length() + 1;
+        int[] starts = new int[maxFrames];
+        int[] positions = new int[maxFrames];
+        int[] ends = new int[maxFrames];
+        int[] repeatsLeft = new int[maxFrames];
+
+        int top = 0;
+        starts[top] = 0;
+        positions[top] = 0;
+        ends[top] = packed.length();
+        repeatsLeft[top] = 1;
+
+        int matched = 0;
+
+        while (top >= 0 && matched < limit) {
+            if (positions[top] >= ends[top]) {
+                repeatsLeft[top]--;
+
+                if (repeatsLeft[top] > 0) {
+                    positions[top] = starts[top];
+                } else {
+                    top--;
+                }
+
+                continue;
+            }
+
+            char current = packed.charAt(positions[top]);
+
+            if (current >= 'a' && current <= 'z') {
+                if (base.charAt(matched) != current) {
+                    return matched;
+                }
+
+                matched++;
+                positions[top]++;
+            } else {
+                int repeat = current - '0';
+                int openBracket = positions[top] + 1;
+                int closeBracket = matchingBracket[openBracket];
+
+                positions[top] = closeBracket + 1;
+
+                top++;
+                starts[top] = openBracket + 1;
+                positions[top] = openBracket + 1;
+                ends[top] = closeBracket;
+                repeatsLeft[top] = repeat;
+            }
+        }
+
+        return matched;
+    }
+
+    private static String removeSingleRepeats(String packed) {
+        int length = packed.length();
+        boolean hasSingleRepeat = false;
+
+        for (int i = 0; i + 1 < length; i++) {
+            if (packed.charAt(i) == '1' && packed.charAt(i + 1) == '[') {
+                hasSingleRepeat = true;
+                break;
+            }
+        }
+
+        if (!hasSingleRepeat) {
+            return packed;
+        }
+
+        int[] matchingBracket = buildMatchingBrackets(packed);
+        boolean[] skip = new boolean[length];
+
+        for (int i = 0; i + 1 < length; i++) {
+            if (packed.charAt(i) == '1' && packed.charAt(i + 1) == '[') {
+                int openBracket = i + 1;
+                int closeBracket = matchingBracket[openBracket];
+
+                skip[i] = true;
+                skip[openBracket] = true;
+                skip[closeBracket] = true;
+            }
+        }
+
+        StringBuilder normalized = new StringBuilder(length);
+
+        for (int i = 0; i < length; i++) {
+            if (!skip[i]) {
+                normalized.append(packed.charAt(i));
+            }
+        }
+
+        return normalized.toString();
+    }
+
+    private static int[] buildMatchingBrackets(String packed) {
+        int[] matchingBracket = new int[packed.length()];
+        int[] stack = new int[packed.length()];
+        int top = 0;
+
+        for (int i = 0; i < packed.length(); i++) {
+            char current = packed.charAt(i);
+
+            if (current == '[') {
+                stack[top] = i;
+                top++;
+            } else if (current == ']') {
+                top--;
+                int openBracket = stack[top];
+                matchingBracket[openBracket] = i;
+            }
+        }
+
+        return matchingBracket;
+    }
+
+    // -------------------- FAST INPUT --------------------
+    static final class FastIn {
+        private final InputStream in;
+        private final byte[] buf = new byte[1 << 16];
+        private int ptr = 0;
+        private int len = 0;
+
+        FastIn(InputStream in) {
+            this.in = in;
+        }
+
+        private int read() throws IOException {
+            if (ptr >= len) {
+                len = in.read(buf);
+                ptr = 0;
+
+                if (len <= 0) {
+                    return -1;
+                }
+            }
+
+            return buf[ptr++];
+        }
+
+        int nextInt() throws IOException {
+            int c;
+
+            do {
+                c = read();
+
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            int sign = 1;
+
+            if (c == '-') {
+                sign = -1;
+                c = read();
+            }
+
+            int val = 0;
+
+            while (c > ' ') {
+                val = val * 10 + (c - '0');
+                c = read();
+            }
+
+            return val * sign;
+        }
+
+        String next() throws IOException {
+            int c;
+
+            do {
+                c = read();
+
+                if (c == -1) {
+                    throw new EOFException("Unexpected EOF");
+                }
+            } while (c <= ' ');
+
+            byte[] tmp = new byte[32];
+            int n = 0;
+
+            while (c > ' ') {
+                if (n == tmp.length) {
+                    byte[] resized = new byte[tmp.length * 2];
+                    System.arraycopy(tmp, 0, resized, 0, tmp.length);
+                    tmp = resized;
+                }
+
+                tmp[n] = (byte) c;
+                n++;
+
+                c = read();
+
+                if (c == -1) {
+                    break;
+                }
+            }
+
+            return new String(tmp, 0, n);
+        }
+    }
+
+    // -------------------- FAST OUTPUT --------------------
+    static final class FastOut {
+        private final OutputStream out;
+        private final byte[] buf = new byte[1 << 16];
+        private int p = 0;
+
+        FastOut(OutputStream out) {
+            this.out = out;
+        }
+
+        void writeByte(int b) throws IOException {
+            if (p == buf.length) {
+                flush();
+            }
+
+            buf[p] = (byte) b;
+            p++;
+        }
+
+        void writeStringPrefix(String s, int length) throws IOException {
+            for (int i = 0; i < length; i++) {
+                writeByte(s.charAt(i));
+            }
+        }
+
+        void flush() throws IOException {
+            out.write(buf, 0, p);
+            p = 0;
+        }
+    }
+
+    private static void run() throws Exception {
+        FastIn in = new FastIn(System.in);
+        FastOut out = new FastOut(System.out);
+
+        int n = in.nextInt();
+        String first = decodePrefix(in.next(), MAX_UNPACKED_LENGTH);
+        int prefixLength = first.length();
+
+        for (int i = 1; i < n; i++) {
+            if (prefixLength == 0) {
+                break;
+            }
+
+            String packed = in.next();
+            prefixLength = commonPrefixWithPacked(packed, first, prefixLength);
+        }
+
+        out.writeStringPrefix(first, prefixLength);
+        out.writeByte('\n');
+        out.flush();
+    }
+
+    private static void test() {
+        assertEq("aaa", solve(new String[]{
+                "2[a]2[ab]",
+                "3[a]2[r2[t]]",
+                "a2[aa3[b]]"
+        }));
+
+        assertEq("aba", solve(new String[]{
+                "abacabaca",
+                "2[abac]a",
+                "3[aba]"
+        }));
+
+        assertEq("ab", solve(new String[]{
+                "abcde",
+                "ab"
+        }));
+
+        assertEq("", solve(new String[]{
+                "abc",
+                "2[z]"
+        }));
+
+        assertEq("abcccabccc", solve(new String[]{
+                "2[ab3[c]]",
+                "abcccabcccx"
+        }));
+
+        assertEq("abc", solve(new String[]{
+                "1[1[1[abc]]]"
+        }));
+
+        System.out.println("Test OK");
+    }
+
+    private static void assertEq(String expected, String actual) {
+        if (!expected.equals(actual)) {
+            throw new AssertionError("Expected=" + expected + ", actual=" + actual);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (System.getProperty("os.name").startsWith("Windows")) {
+            test();
+        } else {
+            run();
+        }
+    }
+}

From bff3bb6d7d3931df726ab2b441ebfdd66c04cefe Mon Sep 17 00:00:00 2001
From: "Andrei.Ovcharenko" <Andrei.Ovcharenko@lomt.ru>
Date: Tue, 2 Jun 2026 22:21:24 +0300
Subject: [PATCH 45/45] sprint 6

---
 src/main/java/algorithms/sprint6/DorogayaSet.java | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/main/java/algorithms/sprint6/DorogayaSet.java b/src/main/java/algorithms/sprint6/DorogayaSet.java
index e7b7fb1..51e3fee 100644
--- a/src/main/java/algorithms/sprint6/DorogayaSet.java
+++ b/src/main/java/algorithms/sprint6/DorogayaSet.java
@@ -3,7 +3,14 @@
  * Нужно найти максимальное остовное дерево, поэтому используем алгоритм Краскала
  * в обратном порядке: сортируем все рёбра по убыванию веса и последовательно
  * добавляем ребро в ответ, если оно соединяет две разные компоненты связности.
- * Для проверки компонент используем DSU.
+ * Для проверки компонент используем DSU (Disjoint Set Union, система
+ * непересекающихся множеств). DSU хранит разбиение вершин на компоненты:
+ * parent[v] ведёт к представителю компоненты вершины v, а size[root] хранит
+ * размер компоненты с корнем root. Операция find(v) возвращает корень
+ * компоненты и сжимает путь до него, чтобы следующие запросы были быстрее.
+ * Операция union(a, b) объединяет компоненты вершин a и b, если они разные.
+ * Если find(a) == find(b), значит вершины уже соединены выбранными рёбрами,
+ * и добавление ребра a-b создало бы цикл, поэтому такое ребро пропускаем.
  *
  * Петли не влияют на ответ: ребро из вершины в саму себя не соединяет разные
  * компоненты, поэтому DSU его не добавит. Кратные рёбра обрабатываются естественно: