Ruslan515 · Dec 6, 2025
diff --git a/...src/main/java/io/github/javaasasecondlanguage/homework01/compressor/StringCompressor.java b/...src/main/java/io/github/javaasasecondlanguage/homework01/compressor/StringCompressor.java
@@ -1,9 +1,12 @@
 package io.github.javaasasecondlanguage.homework01.compressor;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+
 public class StringCompressor {
     /**
      * Given an array of characters, compress it using the following algorithm:
-     *
+     * <p>
      * Begin with an empty string s.
      * For each group of consecutive repeating characters in chars:
      * If the group's length is 1, append the character to s.
@@ -29,6 +32,34 @@ public class StringCompressor {
      * @throws IllegalArgumentException if any char is not in range 'a'..'z'
      */
     public char[] compress(char[] str) {
-        throw new RuntimeException("Not implemented");
+        if (str == null) {
+            throw new IllegalArgumentException("str is null");
+        }
+        int n = str.length;
+        int i = 0;
+        int start;
+        int cnt;
+        int idxInsert = 0;
+        while (i < n) {
+            start = i;
+            while (i < n && str[i] == str[start]) {
+                if (!(str[i] >= 'a' && str[i] <= 'z')) {
+                    throw new IllegalArgumentException("str contains illegal characters");
+                }
+                ++i;
+            }
+            str[idxInsert++] = str[start];
+            cnt = i - start;
+            if (cnt != 1) {
+                String cntStr = String.valueOf(cnt);
+                for (int j = 0; j < cntStr.length(); ++j) {
+                    str[idxInsert] = cntStr.charAt(j);
+                    ++idxInsert;
+                }
+            }
+
+        }
+
+        return Arrays.copyOf(str, idxInsert);
     }
 }
diff --git a/.../java/io/github/javaasasecondlanguage/homework01/compressor/StringCompressorLeetcode.java b/.../java/io/github/javaasasecondlanguage/homework01/compressor/StringCompressorLeetcode.java
@@ -0,0 +1,58 @@
+package io.github.javaasasecondlanguage.homework01.compressor;
+
+import java.util.Arrays;
+
+public class StringCompressorLeetcode {
+    /**
+     * Given an array of characters, compress it using the following algorithm:
+     * <p>
+     * Begin with an empty string s.
+     * For each group of consecutive repeating characters in chars:
+     * If the group's length is 1, append the character to s.
+     * Otherwise, append the character followed by the group's length.
+     * Return a compressed string.
+     * </p>
+     * Follow up:
+     * Could you solve it using only O(1) extra space?
+     * </p>
+     * Examples:
+     * a -> a
+     * aa -> a2
+     * aaa -> a3
+     * aaabb -> a3b2
+     * "" -> ""
+     * null -> Illegal argument
+     * 234 sdf -> Illegal argument
+     *
+     * @param chars nullable array of chars to compress
+     *              str may contain illegal characters
+     * @return a compressed array
+     * @throws IllegalArgumentException if str is null
+     * @throws IllegalArgumentException if any char is not in range 'a'..'z'
+     */
+    public int compress(char[] chars) {
+        int n = chars.length;
+        int i = 0;
+        int start;
+        int cnt;
+        int idxInsert = 0;
+        while (i < n) {
+            start = i;
+            while (i < n && chars[i] == chars[start]) {
+                ++i;
+            }
+            chars[idxInsert++] = chars[start];
+            cnt = i - start;
+            if (cnt != 1) {
+                String cntStr = String.valueOf(cnt);
+                for (int j = 0; j < cntStr.length(); ++j) {
+                    chars[idxInsert] = cntStr.charAt(j);
+                    ++idxInsert;
+                }
+            }
+
+        }
+
+        return idxInsert;
+    }
+}
diff --git a/.../main/java/io/github/javaasasecondlanguage/homework01/mergeintervals/IntervalsMerger.java b/.../main/java/io/github/javaasasecondlanguage/homework01/mergeintervals/IntervalsMerger.java
@@ -1,8 +1,13 @@
 package io.github.javaasasecondlanguage.homework01.mergeintervals;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+
 public class IntervalsMerger {
     /**
-     * Given array of intervals, merge overlapping intervals and sort them by start in ascending order
+     * Given array of intervals, merge overlapping
+     * intervals and sort them by start in ascending order
      * Interval is defined as [start, end] where start < end
      * <p>
      * Examples:
@@ -16,6 +21,53 @@ public class IntervalsMerger {
      * @throws IllegalArgumentException if intervals is null
      */
     public int[][] merge(int[][] intervals) {
-        throw new RuntimeException("Not implemented");
+        if (intervals == null) {
+            throw new IllegalArgumentException("Intervals cannot be null");
+        }
+        if (intervals.length == 0) {
+            return new int[][]{};
+        }
+        ArrayList<ArrayList<Integer>> mergedIntervals = new ArrayList<>();
+
+        Arrays.sort(
+                intervals,
+                new Comparator<int[]>() {
+                    @Override
+                    public int compare(int[] a, int[] b) {
+                        int firstCompare = Integer.compare(a[0], b[0]);
+                        if (firstCompare != 0) {
+                            return firstCompare;
+                        } else {
+                            return Integer.compare(a[1], b[1]);
+                        }
+                    }
+                }
+        );
+
+        int left;
+        int right;
+        int currLeft = intervals[0][0];
+        int currRight = intervals[0][1];
+        for (int[] interval : intervals) {
+            left = interval[0];
+            right = interval[1];
+            if (left <= currRight && left >= currLeft) {
+                currRight = Math.max(currRight, right);
+            } else {
+                mergedIntervals.add(new ArrayList<>(Arrays.asList(currLeft, currRight)));
+                currLeft = left;
+                currRight = right;
+            }
+
+        }
+        mergedIntervals.add(new ArrayList<>(Arrays.asList(currLeft, currRight)));
+
+        int[][] answer = new int[mergedIntervals.size()][2];
+        for (int i = 0; i < mergedIntervals.size(); i++) {
+            answer[i][0] = mergedIntervals.get(i).get(0);
+            answer[i][1] = mergedIntervals.get(i).get(1);
+        }
+
+        return answer;
     }
 }
diff --git a/...a/io/github/javaasasecondlanguage/homework01/compressor/StringCompressorTestLeetcode.java b/...a/io/github/javaasasecondlanguage/homework01/compressor/StringCompressorTestLeetcode.java
@@ -0,0 +1,77 @@
+package io.github.javaasasecondlanguage.homework01.compressor;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+
+class StringCompressorTestLeetcode {
+    StringCompressorLeetcode compressor;
+
+    @BeforeEach
+    void setup() {
+        compressor = new StringCompressorLeetcode();
+    }
+
+
+    @Test
+    void noCompressionForSingleChar() {
+        var subject = "a".toCharArray();
+        assert subject.length == compressor.compress(subject) : "No compression for single char";
+    }
+
+    @Test
+    void noCompressionForSimpleString() {
+        var subject = "abc".toCharArray();
+        assert subject.length == compressor.compress(subject) : "No compression for simple string";
+    }
+
+    @Test
+    void sample1() {
+        var subject = "aabbccc".toCharArray();
+        assert "a2b2c3".length() == compressor.compress(subject) : "Sample 1";
+    }
+
+    @Test
+    void sample2() {
+        var subject = "mcobtwwwwaokzngssaox".toCharArray();
+        assert "mcobtw4aokzngs2aox".length() == compressor.compress(subject) : "Sample 2";
+    }
+
+    @Test
+    void sample3() {
+        var subject = "abbbbbbbbbbbb".toCharArray();
+        assert "ab12".length() == compressor.compress(subject) : "Sample 3";
+    }
+
+    @Test
+    void maxTest500() {
+
+        var subject = (
+                "ubejrewmdnujlnrsqfrtrwnscangpjkbocajvsqdevtxifpbdddsxlrggcqhyevuxhrwxfqvjkhwmqoydt"
+                + "yuocfvljxiiwsdhuxhryuwnjvckjjowffdusiourttfiiocudlukbyqfnnavbetjtfmlzbcppdjbjhts"
+                + "pcaeotbnucazkazzysaxlpsrkpbzxwygksyozmidrpvcdjbvpjkkcgcobhsojawgeozwohwzeglpkveh"
+                + "wehepadbzlueayltfdcrayscrcokggdglanvcustfolobekqteqpmabghvkedjaupghhiikdjdizarky"
+                + "ndxzlxcmuivxlayajsclfxyzumczqfzsvysquenftinkburtsassumpkghajevjgiqzebrgnhtggfwcf"
+                + "qwmokceesaynxetpmaqodzwiulnhnevtlappgpbwxpmyxpnhwmjmzzzpjjzijilltyrnwqosfrqzaytr"
+                + "lbgzzoxafianxvwcbl"
+        ).toCharArray();
+
+        var result = (
+                "ubejrewmdnujlnrsqfrtrwnscangpjkbocajvsqdevtxifpbd3sxlrg2cqhyevuxhrwxfqvjkhwmqoydty"
+                + "uocfvljxi2wsdhuxhryuwnjvckj2owf2dusiourt2fi2ocudlukbyqfn2avbetjtfmlzbcp2djbjhtsp"
+                + "caeotbnucazkaz2ysaxlpsrkpbzxwygksyozmidrpvcdjbvpjk2cgcobhsojawgeozwohwzeglpkvehw"
+                + "ehepadbzlueayltfdcrayscrcokg2dglanvcustfolobekqteqpmabghvkedjaupgh2i2kdjdizarkyn"
+                + "dxzlxcmuivxlayajsclfxyzumczqfzsvysquenftinkburtsas2umpkghajevjgiqzebrgnhtg2fwcfq"
+                + "wmokce2saynxetpmaqodzwiulnhnevtlap2gpbwxpmyxpnhwmjmz3pj2zijil2tyrnwqosfrqzaytrlb"
+                + "gz2oxafianxvwcbl").toCharArray();
+
+        assert result.length == compressor.compress(subject) : "no equal";
+    }
+
+    @Test
+    void emptyArrayIsAlreadyCompressed() {
+        var emptyCharArray = new char[]{};
+        var result = compressor.compress(emptyCharArray);
+        assert emptyCharArray.length == result : "empty array is already compressed";
+    }
+}