Java | LeetCode

Public

Просмотреть канал

909

1.4K

Не можете присоединиться? @easy_java_task

6.7k Участники

Обновлено: May 16, 2026 at 10:18 AM

Java | LeetCode

Cайт easyoffer.ru Реклама @easyoffer_adv ВП @easyoffer_vp Тесты t.me/+icUwivvbGOkwNWRi Вопросы собесов t.me/+7ESm0VKXC4tjYzky Вакансии t.me/+4pspF5nDjgM4MjQy

@easy_java_task is a growing community focused on easyoffer_vp and tme4pspf5ndjgm4mjqy and related topics

Рейтинг

Глобальный рейтинг

#456

Рейтинг по языку

#45

Рейтинг по категории

#23

-1

Рост участников (Последние 5 дней)

Всего: 6.7K

Рост за 24ч: +0 0%

Рейтинг

Требуется вход

Отзывы пользователей (0)

Пока нет отзывов. Будьте первым, кто поделится своим опытом!

Последние посты

Java | LeetCode

21 мая 2026 г., 15:12

Задача: https://leetcode.com/problems/broken-calculator/
Сложность: medium

Имеется неисправный калькулятор, на экране которого изначально отображается целое число startValue. За одну операцию можно:

Умножить число на экране на 2, или
Вычесть 1 из числа на экране.
Даны два целых числа startValue и target. Верните минимальное количество операций, необходимых для отображения target на калькуляторе.

Пример:
Input: startValue = 2, target = 3
Output: 2
Explanation: Use double operation and then decrement operation {2 -> 4 -> 3}.

👨‍💻 Алгоритм:

1⃣Обратный путь:
Если target больше startValue, то попытайтесь уменьшить target, чтобы привести его к startValue.
Если target четный, разделите его на 2, иначе прибавьте 1.

2⃣Подсчет операций:
Повторяйте шаги, пока target не станет меньше или равен startValue.
После этого вычитайте из startValue оставшееся значение target.

3⃣Возврат результата:
Возвращайте суммарное количество выполненных операций.

😎 Решение:
public class Solution {
public int brokenCalc(int startValue, int target) {
int operations = 0;

while (target > startValue) {
operations++;
if (target % 2 == 0) {
target /= 2;
} else {
target += 1;
}
}

return operations + (startValue - target);
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

652

Java | LeetCode

21 мая 2026 г., 15:12

Задача: https://leetcode.com/problems/k-closest-points-to-origin/description/
Сложность: medium

Дан массив точек, где points[i] = [xi, yi] представляет собой точку на плоскости X-Y, и целое число k. Верните k точек, ближайших к началу координат (0, 0).

Расстояние между двумя точками на плоскости X-Y является евклидовым расстоянием (то есть √((x1 - x2)² + (y1 - y2)²)).

Вы можете вернуть ответ в любом порядке. Гарантируется, что ответ будет уникальным (за исключением порядка).

Пример:
Input: points = [[1,3],[-2,2]], k = 1
Output: [[-2,2]]
Explanation:
The distance between (1, 3) and the origin is sqrt(10).
The distance between (-2, 2) and the origin is sqrt(8).
Since sqrt(8) < sqrt(10), (-2, 2) is closer to the origin.
We only want the closest k = 1 points from the origin, so the answer is just [[-2,2]].

👨‍💻 Алгоритм:

1⃣Отсортируйте массив с помощью функции компаратора.

2⃣Функция компаратора будет использовать уравнение квадратного евклидова расстояния для сравнения двух точек.

3⃣Верните первые k элементов массива.

😎 Решение:
import java.util. Arrays;

class Solution {
public int[][] kClosest(int[][] points, int k) {
Arrays.sort(points, (a, b) -> squaredDistance(a) - squaredDistance(b));
return Arrays.copyOfRange(points, 0, k);
}

private int squaredDistance(int[] point) {
return point[0] * point[0] + point[1] * point[1];
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

21 мая 2026 г., 15:12

Задача: https://leetcode.com/problems/self-dividing-numbers/
Сложность: medium

Вы создаете программу для использования в качестве календаря. Мы можем добавить новое событие, если его добавление не приведет к двойному бронированию. Двойное бронирование происходит, когда два события имеют некоторое непустое пересечение (т.е, Событие можно представить в виде пары целых чисел start и end, которая представляет собой бронирование на полуоткрытом интервале [start, end), диапазоне вещественных чисел x таких, что start <= x < end. Реализация класса MyCalendar: MyCalendar() Инициализирует объект календаря. boolean book(int start, int end) Возвращает true, если событие может быть успешно добавлено в календарь, не вызывая двойного бронирования. В противном случае возвращается false и событие не добавляется в календарь.

Пример:
Input
["MyCalendar", "book", "book", "book"]
[[], [10, 20], [15, 25], [20, 30]]
Output
[null, true, false, true]

👨‍💻 Алгоритм:

1⃣Создайте класс MyCalendar с инициализатором для хранения списка событий.

2⃣Реализуйте метод book(int start, int end) для проверки пересечения нового события с уже существующими событиями.

3⃣Если новое событие не пересекается с существующими событиями, добавьте его в список событий и верните true. В противном случае верните false.

😎 Решение:
import java.util. ArrayList;
import java.util. List;

public class MyCalendar {
private List events;

public MyCalendar() {
events = new ArrayList<>();
}

public boolean book(int start, int end) {
for (int[] event : events) {
if (start < event[1] && end > event[0]) {
return false;
}
}
events.add(new int[] {start, end});
return true;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

21 мая 2026 г., 15:12

Задача: https://leetcode.com/problems/remove-zero-sum-consecutive-nodes-from-linked-list/description/
Сложность: medium
Дан указатель на голову связанного списка. Мы многократно удаляем последовательные последовательности узлов, сумма которых равна 0, до тех пор, пока такие последовательности не исчезнут.

После этого верните голову конечного связанного списка. Вы можете вернуть любой такой ответ.

Пример:
Input: head = [1,2,-3,3,1]
Output: [3,1]
Note: The answer [1,2,1] would also be accepted.

👨‍💻 Алгоритм:

1⃣Инициализируйте новый узел ListNode с именем front со значением 0, у которого поле next указывает на head, и узел start, указывающий на front.

2⃣Обрабатывайте все узлы в связанном списке, пока start != null. Инициализируйте переменную prefixSum значением 0 и узел ListNode с именем end, указывающий на http://start.next/. Обрабатывайте остальные узлы в связанном списке, пока end != null: добавьте значение узла end к prefixSum. Если prefixSum равен 0, установите соединение от узла start к последнему узлу после последовательности с суммой ноль, установив http://start.next/ равным http://end.next/. Установите end равным http://end.next/.

3⃣Установите start равным http://start.next/. Верните http://front.next/. Узел front указывает на голову конечного связанного списка.

😎 Решение:
class ListNode {
int val;
ListNode next;
ListNode(int val) { this.val = val; }
ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}

class Solution {
public ListNode removeZeroSumSublists(ListNode head) {
ListNode front = new ListNode(0, head);
ListNode start = front;

while (start != null) {
int prefixSum = 0;
ListNode end = start.next;

while (end != null) {
prefixSum += end.val;
if (prefixSum == 0) {
start.next = end.next;
}
end = end.next;
}

start = start.next;
}
return front.next;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

21 мая 2026 г., 15:12

Задача: https://leetcode.com/problems/integer-to-english-words/
Сложность: hard

Преобразуйте неотрицательное целое число num в его словесное представление на английском языке.

Пример:
Input: num = 123
Output: "One Hundred Twenty Three"

👨‍💻 Алгоритм:

1⃣Обработка чисел до 20 и кратных 10 до 90:
Создать массивы или словари для чисел от 1 до 19 и для кратных 10 от 20 до 90.
Если число попадает в эти диапазоны, сразу вернуть соответствующее словесное представление.

2⃣Обработка сотен, тысяч, миллионов и миллиардов:
Разделить число на группы по три цифры (единицы, тысячи, миллионы, миллиарды).
Для каждой группы сформировать словесное представление с использованием рекурсивной функции для чисел от 1 до 999.

3⃣Формирование окончательного результата:
Собрать словесное представление всех групп, добавив соответствующие суффиксы (тысячи, миллионы, миллиарды).
Соединить все части в одну строку, удалив лишние пробелы.

😎 Решение:
class Solution {
private final String[] belowTwenty = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
private final String[] tens = {"", "Ten", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};
private final String[] thousands = {"", "Thousand", "Million", "Billion"};

public String numberToWords(int num) {
if (num == 0) return "Zero";
int i = 0;
String result = "";

while (num > 0) {
if (num % 1000 != 0) {
result = helper(num % 1000) + thousands[i] + " " + result;
}
num /= 1000;
i++;
}
return result.trim();
}

private String helper(int num) {
if (num == 0) return "";
else if (num < 20) return belowTwenty[num] + " ";
else if (num < 100) return tens[num / 10] + " " + helper(num % 10);
else return belowTwenty[num / 100] + " Hundred " + helper(num % 100);
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

21 мая 2026 г., 15:12

Задача: https://leetcode.com/problems/binary-gap/description/
Сложность: easy

Дано положительное целое число n, найдите и верните наибольшее расстояние между любыми двумя соседними единицами в двоичном представлении числа n. Если нет двух соседних единиц, верните 0.

Две единицы считаются соседними, если их разделяют только нули (возможно, никаких нулей нет). Расстояние между двумя единицами — это абсолютная разница между их позициями в битовом представлении. Например, две единицы в "1001" имеют расстояние 3.

Пример:
Input: n = 22
Output: 2
Explanation: 22 in binary is "10110".
The first adjacent pair of 1's is "10110" with a distance of 2.
The second adjacent pair of 1's is "10110" with a distance of 1.
The answer is the largest of these two distances, which is 2.
Note that "10110" is not a valid pair since there is a 1 separating the two 1's underlined.

👨‍💻 Алгоритм:

1⃣Создайте список A индексов i, таких что в двоичном представлении числа n i-й бит установлен в 1.

2⃣Используйте список A, чтобы найти максимальное расстояние между соседними значениями. Для этого пройдите по списку и вычислите разницу между каждым соседним элементом.

3⃣Верните найденное максимальное расстояние.

😎 Решение:
class Solution {
public int binaryGap(int N) {
int[] A = new int[32];
int t = 0;
for (int i = 0; i < 32; ++i)
if (((N >> i) & 1) != 0)
A[t++] = i;

int ans = 0;
for (int i = 0; i < t - 1; ++i)
ans = Math.max(ans, A[i+1] - A[i]);
return ans;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

21 мая 2026 г., 15:12

Задача: https://leetcode.com/problems/minimum-size-subarray-sum/ https://leetcode.com/problems/kth-largest-element-in-an-array/description/
Сложность: medium

Дан целочисленный массив nums и целое число k. Верните k-й наибольший элемент в массиве.

Обратите внимание, что это k-й наибольший элемент в отсортированном порядке, а не k-й уникальный элемент.

Пример:
Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
Output: 4

👨‍💻 Алгоритм:

1⃣Отсортируйте массив в порядке убывания:
Используйте стандартную функцию сортировки для сортировки элементов массива nums в порядке убывания. В этом случае самый большой элемент будет первым в массиве, второй по величине - вторым и так далее.

2⃣Найдите k-й по величине элемент:
После сортировки просто верните элемент, который стоит на позиции k-1 (учитывая, что индексация в массиве начинается с 0).

3⃣Верните результат:
Возвратите найденное значение как результат.

😎 Решение:
class Solution {
public String shortestPalindrome(String s) {
int n = s.length();
String rev = new StringBuilder(s).reverse().toString();
for (int i = 0; i < n; i++) {
if (s.substring(0, n - i).equals(rev.substring(i))) {
return rev.substring(0, i) + s;
}
}
return "";
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

468

Java | LeetCode

21 мая 2026 г., 15:12

Задача: https://leetcode.com/problems/permutation-sequence/ https://leetcode.com/problems/integer-replacement/ https://leetcode.com/problems/random-pick-index/
Сложность: medium

Из целочисленного массива nums с возможными дубликатами случайным образом выведите индекс заданного целевого числа. Можно предположить, что заданное целевое число должно существовать в массиве. Реализация класса Solution: Solution(int[] nums) Инициализирует объект с массивом nums. int pick(int target) Выбирает случайный индекс i из nums, где nums[i] == target. Если существует несколько допустимых i, то каждый индекс должен иметь равную вероятность возврата.

Пример:
Input
["Solution", "pick", "pick", "pick"]
[[[1, 2, 3, 3, 3]], [3], [1], [3]]
Output
[null, 4, 0, 2]

👨‍💻 Алгоритм:

1⃣Инициализируйте объект с массивом nums. Сохраните этот массив для дальнейшего использования.

2⃣Реализуйте метод pick(target), который выбирает случайный индекс i из массива nums, где nums[i] равен target. Если таких индексов несколько, каждый из них должен иметь равную вероятность быть выбранным.

3⃣Для реализации метода pick используйте алгоритм reservoir sampling для выбора случайного индекса.

😎 Решение:
import java.util. Random;

class Solution {
private int[] nums;
private Random random;

public Solution(int[] nums) {
this.nums = nums;
this.random = new Random();
}

public int pick(int target) {
int count = 0;
int result = -1;
for (int i = 0; i < nums.length; i++) {
if (nums[i] == target) {
count++;
if (random.nextInt(count) == count - 1) {
result = i;
}
}
}
return result;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

21 мая 2026 г., 15:12

Задача: https://leetcode.com/problems/number-of-recent-calls/
Сложность: easy

У вас есть класс RecentCounter, который подсчитывает количество последних запросов за определенный промежуток времени. Реализуйте класс RecentCounter: RecentCounter() Инициализирует счетчик нулем последних запросов. int ping(int t) Добавляет новый запрос в момент времени t, где t представляет собой некоторое время в миллисекундах, и возвращает количество запросов, произошедших за последние 3000 миллисекунд (включая новый запрос). Точнее, возвращается количество запросов, произошедших в диапазоне [t - 3000, t]. Гарантируется, что каждый вызов ping использует строго большее значение t, чем предыдущий вызов.

Пример:
Input
["RecentCounter", "ping", "ping", "ping", "ping"]
[[], [1], [100], [3001], [3002]]
Output
[null, 1, 2, 3, 3]

👨‍💻 Алгоритм:

1⃣Создать класс RecentCounter с конструктором для инициализации пустой очереди.

2⃣Реализовать метод ping, который принимает время запроса t:
Добавить t в очередь.
Удалить из очереди все запросы, которые не попадают в диапазон [t - 3000, t].

3⃣Вернуть размер очереди.

😎 Решение:
import java.util. LinkedList;
import java.util. Queue;

class RecentCounter {
private Queue q;

public RecentCounter() {
q = new LinkedList<>();
}

public int ping(int t) {
q.add(t);
while (q.peek() < t - 3000) {
q.poll();
}
return q.size();
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

21 мая 2026 г., 15:12

Задача: https://leetcode.com/problems/maximum-length-of-a-concatenated-string-with-unique-characters/
Сложность: medium

Вам дан массив строк arr. Строка s образуется конкатенацией подпоследовательности arr, содержащей уникальные символы. Верните максимально возможную длину s. Подпоследовательность - это массив, который может быть получен из другого массива путем удаления некоторых или ни одного элемента без изменения порядка оставшихся элементов.

Пример:
Input: arr = ["un","iq","ue"]
Output: 4

👨‍💻 Алгоритм:

1⃣Использование рекурсивного подхода:
Для каждой строки в массиве arr проверяем, можем ли мы добавить ее к текущей комбинации уникальных символов.
Если можем, добавляем ее и продолжаем рекурсивный вызов для следующей строки.
Если не можем, пропускаем текущую строку и переходим к следующей.

2⃣Проверка уникальности символов:
Для проверки уникальности символов используем множество (set). Если все символы строки уникальны и не пересекаются с символами текущей комбинации, мы можем добавить строку.

3⃣Поиск максимальной длины:
На каждом шаге обновляем максимальную длину, если текущая комбинация уникальных символов длиннее предыдущей максимальной длины.

😎 Решение:
import java.util.*;

public class Solution {
public int maxLength(List arr) {
return backtrack(arr, 0, "");
}

private boolean isUnique(String s) {
Set charSet = new HashSet<>();
for (char c : s.toCharArray()) {
if (!charSet.add(c)) {
return false;
}
}
return true;
}

private int backtrack(List arr, int index, String current) {
if (!isUnique(current)) return 0;
int maxLength = current.length();
for (int i = index; i < arr.size(); i++) {
maxLength = Math.max(maxLength, backtrack(arr, i + 1, current + arr.get(i)));
}
return maxLength;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

20 апр. 2026 г., 04:07

Задача: https://leetcode.com/problems/minimum-size-subarray-sum/ https://leetcode.com/problems/tag-validator/
Сложность: hard

Дана строка, представляющая фрагмент кода, реализуйте валидатор тегов для разбора кода и определения его корректности.

Фрагмент кода считается корректным, если соблюдаются все следующие правила:
Код должен быть заключен в корректный закрытый тег. В противном случае код некорректен.
Закрытый тег (не обязательно корректный) имеет точно следующий формат: TAG_CONTENT. Среди них  — это начальный тег, а  — конечный тег. TAG_NAME в начальном и конечном тегах должен быть одинаковым. Закрытый тег корректен, если и только если TAG_NAME и TAG_CONTENT корректны.
Корректное TAG_NAME содержит только заглавные буквы и имеет длину в диапазоне [1, 9]. В противном случае TAG_NAME некорректен.
Корректное TAG_CONTENT может содержать другие корректные закрытые теги, cdata и любые символы (см. примечание 1), КРОМЕ неподходящих <, неподходящих начальных и конечных тегов, и неподходящих или закрытых тегов с некорректным TAG_NAME. В противном случае TAG_CONTENT некорректен.
Начальный тег неподходящий, если нет конечного тега с тем же TAG_NAME, и наоборот. Однако нужно также учитывать проблему несбалансированных тегов, когда они вложены.
< неподходящий, если не удается найти последующий >. И когда вы находите < или  должны быть разобраны как TAG_NAME (не обязательно корректный).
cdata имеет следующий формат: . Диапазон CDATA_CONTENT определяется как символы между .
CDATA_CONTENT может содержать любые символы. Функция cdata заключается в том, чтобы запретить валидатору разбирать CDATA_CONTENT, поэтому даже если в нем есть символы, которые могут быть разобраны как тег (корректный или некорректный), вы должны рассматривать их как обычные символы.

Пример:
Input: code = "This is the first line ]]>
"
Output: true

👨‍💻 Алгоритм:

1⃣Инициализируйте стек для отслеживания открытых тегов и флаг для определения наличия тегов. Используйте регулярное выражение для проверки корректности TAG_NAME, TAG_CONTENT и CDATA.

2⃣Пройдитесь по строке, проверяя каждый символ. Если встретите <, определите тип тега (начальный, конечный или CDATA). Обновите стек и индексы в зависимости от найденного типа.

3⃣В конце проверьте, что стек пуст (все теги корректно закрыты) и верните результат.

😎 Решение:
import java.util.regex.*;

public class Solution {
Stack stack = new Stack<>();
boolean containsTag = false;

public boolean isValidTagName(String s, boolean ending) {
if (ending) {
if (!stack.isEmpty() && stack.peek().equals(s)) stack.pop();
else return false;
} else {
containsTag = true;
stack.push(s);
}
return true;
}

public boolean isValid(String code) {
if (! Pattern.matches("<[A-Z]{0,9}>([^<]*(<((\\/?[A-Z]{1,9}>)|(!\\[CDATA\\[(.*?)]]>)))?)*", code))
return false;

for (int i = 0; i < code.length(); i++) {
boolean ending = false;
if (stack.isEmpty() && containsTag) return false;
if (code.charAt(i) == '<') {
if (code.charAt(i + 1) == '!') {
i = code.indexOf("]]>", i + 1);
continue;
}
if (code.charAt(i + 1) == '/') {
i++;
ending = true;
}
int closeIndex = code.indexOf('>', i + 1);
if (closeIndex < 0 || !isValidTagName(code.substring(i + 1, closeIndex), ending))
return false;
i = closeIndex;
}
}
return stack.isEmpty();
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

20 апр. 2026 г., 04:07

Задача: https://leetcode.com/problems/two-sum-iii-data-structure-design/
Сложность: easy

Разработайте структуру данных, которая принимает поток целых чисел и проверяет, есть ли в ней пара чисел, сумма которых равна определенному значению.

Реализуйте класс TwoSum:

- TwoSum() инициализирует объект TwoSum с изначально пустым массивом.
- void add(int number) добавляет число в структуру данных.
- boolean find(int value) возвращает true, если существует хотя бы одна пара чисел, сумма которых равна значению value, в противном случае возвращает false.

Пример:
Input
["TwoSum", "add", "add", "add", "find", "find"]
[[], [1], [3], [5], [4], [7]]
Output
[null, null, null, null, true, false]

👨‍💻 Алгоритм:

1⃣Инициализация указателей:
Инициализируйте два указателя low и high, которые указывают на первый и последний элементы списка соответственно.

2⃣Итерация с использованием двух указателей:
Запустите цикл для итерации по списку. Цикл завершится, когда будет найдено решение с двумя суммами или когда два указателя встретятся.
На каждом шаге цикла перемещайте один из указателей в зависимости от различных условий:
Если сумма элементов, на которые указывают текущие указатели, меньше желаемого значения, то необходимо попытаться увеличить сумму для достижения желаемого значения, то есть переместить указатель low вперёд для получения большего значения.
Если сумма элементов больше желаемого значения, то следует попытаться уменьшить сумму, перемещая указатель high в сторону указателя low.
Если сумма равна желаемому значению, можно сразу выполнить возврат из функции.

3⃣Завершение цикла:
Если цикл завершается тем, что два указателя встречаются, то можно быть уверенным, что решения для желаемого значения не существует.

😎 Решение:
import java.util. Collections;

class TwoSum {
private ArrayList nums;
private boolean is_sorted;
public TwoSum() {
this.nums = new ArrayList();
this.is_sorted = false;
}
public void add(int number) {
this.nums.add(number);
this.is_sorted = false;
}
public boolean find(int value) {
if (!this.is_sorted) {
Collections.sort(this.nums);
this.is_sorted = true;
}
int low = 0, high = this.nums.size() - 1;
while (low < high) {
int twosum = this.nums.get(low) + this.nums.get(high);
if (twosum < value) low += 1;
else if (twosum > value) high -= 1;
else return true;
}
return false;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

20 апр. 2026 г., 04:07

Задача: https://leetcode.com/problems/employee-importance/description/
Сложность: medium

У вас есть структура данных с информацией о сотрудниках, включая уникальный идентификатор сотрудника, значение его важности и идентификаторы его прямых подчиненных.

Вам дан массив сотрудников employees, где:

employees[i].id — это идентификатор i-го сотрудника.
employees[i].importance — значение важности i-го сотрудника.
employees[i].subordinates — список идентификаторов прямых подчиненных i-го сотрудника.
Дан целочисленный id, представляющий идентификатор сотрудника. Верните суммарное значение важности этого сотрудника и всех его прямых и косвенных подчиненных.

Пример:
Input: employees = [[1,5,[2,3]],[2,3,[]],[3,3,[]]], id = 1
Output: 11
Explanation: Employee 1 has an importance value of 5 and has two direct subordinates: employee 2 and employee 3.
They both have an importance value of 3.
Thus, the total importance value of employee 1 is 5 + 3 + 3 = 11.

👨‍💻 Алгоритм:

1⃣Создайте хеш-таблицу emap для быстрого доступа к сотрудникам по их идентификаторам.

2⃣Реализуйте функцию DFS для подсчета общей важности, которая включает важность сотрудника и всех его подчиненных.

3⃣Используйте DFS для вычисления общей важности, начиная с заданного идентификатора сотрудника.

😎 Решение:
class Solution {
Map emap;

public int getImportance(List employees, int queryid) {
emap = new HashMap<>();
for (Employee e : employees) {
emap.put(e.id, e);
}
return dfs(queryid);
}

public int dfs(int eid) {
Employee employee = emap.get(eid);
int ans = employee.importance;
for (Integer subid : employee.subordinates) {
ans += dfs(subid);
}
return ans;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

20 апр. 2026 г., 04:07

Задача: https://leetcode.com/problems/pyramid-transition-matrix/
Сложность: medium

Вы складываете блоки так, чтобы получилась пирамида. Каждый блок имеет цвет, который представлен одной буквой. Каждый ряд блоков содержит на один блок меньше, чем ряд под ним, и располагается по центру сверху. Чтобы пирамида выглядела эстетично, допускаются только определенные треугольные узоры. Треугольный узор состоит из одного блока, уложенного поверх двух блоков. Шаблоны задаются в виде списка допустимых трехбуквенных строк, где первые два символа шаблона представляют левый и правый нижние блоки соответственно, а третий символ - верхний блок. Например, "ABC" представляет треугольный шаблон с блоком 'C', уложенным поверх блоков 'A' (слева) и 'B' (справа). Обратите внимание, что это отличается от "BAC", где "B" находится слева внизу, а "A" - справа внизу. Вы начинаете с нижнего ряда блоков bottom, заданного в виде одной строки, который вы должны использовать в качестве основания пирамиды. Учитывая bottom и allowed, верните true, если вы можете построить пирамиду до самой вершины так, чтобы каждый треугольный узор в пирамиде был в allowed, или false в противном случае.

Пример:
Input: bottom = "BCD", allowed = ["BCC","CDE","CEA","FFF"]
Output: true

👨‍💻 Алгоритм:

1⃣Создайте структуру данных для хранения допустимых треугольных узоров.

2⃣Напишите рекурсивную функцию, которая проверяет возможность построения следующего уровня пирамиды.

3⃣Начните с нижнего уровня пирамиды и используйте рекурсию для построения каждого следующего уровня, проверяя каждый треугольный узор на допустимость.

😎 Решение:
import java.util.*;

public class Solution {
public boolean pyramidTransition(String bottom, List allowed) {
Map> allowedDict = new HashMap<>();

for (String pattern : allowed) {
String key = pattern.substring(0, 2);
char value = pattern.charAt(2);
allowedDict.computeIfAbsent(key, k -> new ArrayList<>()).add(value);
}

return canBuild(bottom, allowedDict);
}

private boolean canBuild(String currentLevel, Map> allowedDict) {
if (currentLevel.length() == 1) return true;

List> nextLevelOptions = new ArrayList<>();
for (int i = 0; i < currentLevel.length() - 1; i++) {
String key = currentLevel.substring(i, i + 2);
if (!allowedDict.containsKey(key)) return false;
nextLevelOptions.add(allowedDict.get(key));
}

return canBuildNextLevel(nextLevelOptions, 0, "", allowedDict);
}

private boolean canBuildNextLevel(List> options, int index, String nextLevel, Map> allowedDict) {
if (index == options.size()) return canBuild(nextLevel, allowedDict);
for (char option : options.get(index)) {
if (canBuildNextLevel(options, index + 1, nextLevel + option, allowedDict)) return true;
}
return false;
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

20 апр. 2026 г., 04:07

Задача: https://leetcode.com/problems/find-permutation/description/
Сложность: medium

Перестановка perm из n целых чисел всех чисел в диапазоне [1, n] может быть представлена в виде строки s длиной n - 1, где:

s[i] == 'I', если perm[i] < perm[i + 1], и
s[i] == 'D', если perm[i] > perm[i + 1].
Дана строка s, восстановите лексикографически наименьшую перестановку perm и верните её.

Пример:
Input: s = "I"
Output: [1,2]
Explanation: [1,2] is the only legal permutation that can represented by s, where the number 1 and 2 construct an increasing relationship.

👨‍💻 Алгоритм:

1⃣Инициализация
Создайте пустой стек stack. Создайте пустой список result для хранения конечной перестановки.

2⃣Для каждого числа i
Если текущий символ в строке s равен 'D', добавьте i в стек. Если текущий символ в строке s равен 'I', добавьте i в стек, затем извлеките все элементы из стека и добавьте их в result.

3⃣Завершение
Добавьте n в стек и извлеките все элементы из стека, добавив их в result. Верните список result, который представляет лексикографически наименьшую перестановку.

😎 Решение:
public class Solution {
public int[] findPermutation(String s) {
int[] res = new int[s.length() + 1];
Stack stack = new Stack<>();
int j = 0;
for (int i = 1; i <= s.length(); i++) {
if (s.charAt(i - 1) == 'I') {
stack.push(i);
while (!stack.isEmpty()) {
res[j++] = stack.pop();
}
} else {
stack.push(i);
}
}
stack.push(s.length() + 1);
while (!stack.isEmpty()) {
res[j++] = stack.pop();
}
return res;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

20 апр. 2026 г., 04:07

Задача: https://leetcode.com/problems/balance-a-binary-search-tree/description/
Сложность: medium

Дан корень бинарного дерева поиска. Верните сбалансированное бинарное дерево поиска с теми же значениями узлов. Если существует более одного ответа, верните любой из них.

Бинарное дерево поиска считается сбалансированным, если глубина двух поддеревьев каждого узла никогда не отличается более чем на 1.

Пример:
Input: root = [1,null,2,null,3,null,4,null,null]
Output: [2,1,3,null,null,null,4]
Explanation: This is not the only correct answer, [3,1,4,null,2] is also correct.

👨‍💻 Алгоритм:

1⃣Инициализация. Создайте пустой список inorder для хранения значений узлов после обхода в порядке возрастания.

2⃣Выполнение обхода в порядке возрастания. Обойдите бинарное дерево поиска (BST) и заполните список inorder значениями узлов в отсортированном порядке.

3⃣Перестроение сбалансированного BST. Определите рекурсивную функцию createBalancedBST, которая принимает список inorder, начальный индекс и конечный индекс в качестве параметров. Если начальный индекс больше конечного, верните null (или эквивалент). Вычислите средний индекс как середину текущего диапазона. Создайте новый узел дерева со значением в среднем индексе. Рекурсивно создайте левое поддерево, используя левую половину текущего диапазона. Рекурсивно создайте правое поддерево, используя правую половину текущего диапазона. Верните корень вновь построенного сбалансированного BST.

😎 Решение:
class Solution {
public TreeNode balanceBST(TreeNode root) {
if (root == null) return null;

TreeNode vineHead = new TreeNode(0);
vineHead.right = root;
TreeNode current = vineHead;

while (current.right != null) {
if (current.right.left != null) {
rightRotate(current, current.right);
} else {
current = current.right;
}
}

int nodeCount = 0;
current = vineHead.right;
while (current != null) {
nodeCount++;
current = current.right;
}

int m = (int) Math.pow(2, Math.floor(Math.log(nodeCount + 1) / Math.log(2))) - 1;
makeRotations(vineHead, nodeCount - m);
while (m > 1) {
m /= 2;
makeRotations(vineHead, m);
}

TreeNode balancedRoot = vineHead.right;
return balancedRoot;
}

private void rightRotate(TreeNode parent, TreeNode node) {
TreeNode tmp = node.left;
node.left = tmp.right;
tmp.right = node;
parent.right = tmp;
}

private void leftRotate(TreeNode parent, TreeNode node) {
TreeNode tmp = node.right;
node.right = tmp.left;
tmp.left = node;
parent.right = tmp;
}

private void makeRotations(TreeNode vineHead, int count) {
TreeNode current = vineHead;
for (int i = 0; i < count; i++) {
TreeNode tmp = current.right;
leftRotate(current, tmp);
current = current.right;
}
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

20 апр. 2026 г., 04:07

Задача: https://leetcode.com/problems/maximum-69-number/description/
Сложность: easy

Дано положительное целое число num, состоящее только из цифр 6 и 9.

Верните максимальное число, которое можно получить, изменив не более одной цифры (6 становится 9, а 9 становится 6).

Пример:
Input: num = 9669
Output: 9969
Explanation:
Changing the first digit results in 6669.
Changing the second digit results in 9969.
Changing the third digit results in 9699.
Changing the fourth digit results in 9666.
The maximum number is 9969.

👨‍💻 Алгоритм:

1⃣Преобразуйте входное целое число num в итерируемый и изменяемый объект num_obj.

2⃣Пройдитесь по num_obj и, если найдете цифру 6, замените её на 9 и прекратите итерацию.

3⃣Верните целое число, преобразованное из измененного num_obj.

😎 Решение:
class Solution {
public int maximum69Number (int num) {
StringBuilder numSB = new StringBuilder();
numSB.append(num);
for (int i = 0; i < numSB.length(); ++i) {
if (numSB.charAt(i) == '6') {
numSB.setCharAt(i, '9');
break;
}
}
return Integer.parseInt(numSB.toString());
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

475

Java | LeetCode

20 апр. 2026 г., 04:07

Задача: https://leetcode.com/problems/minimum-size-subarray-sum/ https://leetcode.com/problems/patching-array/description/
Сложность: hard

Дан отсортированный массив целых чисел nums и целое число n. Добавьте/дополните элементы в массив таким образом, чтобы любое число в диапазоне [1, n] включительно могло быть сформировано как сумма некоторых элементов массива.

Верните минимальное количество дополнений, необходимых для этого.

Пример:
Input: nums = [1,3], n = 6
Output: 1
Explanation:
Combinations of nums are [1], [3], [1,3], which form possible sums of: 1, 3, 4.
Now if we add/patch 2 to nums, the combinations are: [1], [2], [3], [1,3], [2,3], [1,2,3].
Possible sums are 1, 2, 3, 4, 5, 6, which now covers the range [1, 6].
So we only need 1 patch.

👨‍💻 Алгоритм:

1⃣Инициализация переменных:
Создайте переменную miss, представляющую наименьшее пропущенное число, которое еще не покрыто, и установите ее значение на 1. Создайте переменную patches для подсчета необходимых дополнений и переменную i для итерации по массиву nums.

2⃣Основной цикл:
Используйте цикл while, который будет выполняться до тех пор, пока miss не станет больше n.
Внутри цикла проверьте, покрывает ли текущий элемент nums[i] значение miss. Если да, добавьте nums[i] к miss и увеличьте i. Если нет, добавьте значение miss к самому себе (это означает добавление нового элемента в массив) и увеличьте счетчик patches.

3⃣Возврат результата:
После завершения цикла верните значение patches, которое представляет минимальное количество необходимых дополнений.

😎 Решение:
public class Solution {
public int minPatches(int[] nums, int n) {
int patches = 0, i = 0;
long miss = 1;
while (miss <= n) {
if (i < nums.length && nums[i] <= miss)
miss += nums[i++];
else {
miss += miss;
patches++;
}
}
return patches;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

20 апр. 2026 г., 04:07

Задача: https://leetcode.com/problems/reverse-bits/ https://leetcode.com/problems/meeting-rooms/description/
Сложность: easy

Дан массив интервалов времени встреч, где intervals[i] = [starti, endi]. Определите, может ли человек посетить все встречи.

Пример:
Input: intervals = [[0,30],[5,10],[15,20]]
Output: false

👨‍💻 Алгоритм:

1⃣Создайте функцию для проверки перекрытия двух интервалов:
Возвращайте true, если начало одного интервала находится внутри другого интервала.

2⃣Проверьте каждый интервал с каждым другим интервалом:
Если найдено перекрытие, верните false.

3⃣Если все интервалы проверены и перекрытий не найдено, верните true.

😎 Решение:
class Solution {
public boolean canAttendMeetings(int[][] intervals) {
for (int i = 0; i < intervals.length; i++) {
for (int j = i + 1; j < intervals.length; j++) {
if (overlap(intervals[i], intervals[j])) {
return false;
}
}
}
return true;
}

private boolean overlap(int[] interval1, int[] interval2) {
return (interval1[0] >= interval2[0] && interval1[0] < interval2[1])
|| (interval2[0] >= interval1[0] && interval2[0] < interval1[1]);
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

508

Java | LeetCode

20 апр. 2026 г., 04:07

Задача: https://leetcode.com/problems/permutation-sequence/ https://leetcode.com/problems/array-partition/
Сложность: easy

Дан массив целых чисел nums из 2n элементов. Разделите эти числа на n пар (a1, b1), (a2, b2), ..., (an, bn) так, чтобы сумма min(ai, bi) для всех i была максимальной. Верните максимальную сумму.

Пример:
Input: nums = [1,4,3,2]
Output: 4
Explanation: All possible pairings (ignoring the ordering of elements) are:
1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
So the maximum possible sum is 4.

👨‍💻 Алгоритм:

1⃣Отсортируйте массив nums в неубывающем порядке.

2⃣Итерируйте через массив, выбирая каждый второй элемент (начиная с первого).

3⃣Суммируйте выбранные элементы и верните эту сумму.

😎 Решение:
public class Solution {
public int arrayPairSum(int[] nums) {
Arrays.sort(nums);
int sum = 0;
for (int i = 0; i < nums.length; i += 2) {
sum += nums[i];
}
return sum;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

525

Java | LeetCode

7 апр. 2026 г., 12:38

Задача: https://leetcode.com/problems/find-smallest-letter-greater-than-target/
Сложность: easy

Нам дан массив символов letters, отсортированный в неубывающем порядке, и символ target. В массиве letters есть как минимум два разных символа. Возвращается наименьший символ в letters, который лексикографически больше target. Если такого символа не существует, возвращается первый символ в буквах.

Пример:
Input: letters = ["c","f","j"], target = "a"
Output: "c"

👨‍💻 Алгоритм:

1⃣Использовать бинарный поиск для нахождения позиции первого символа в letters, который лексикографически больше target.

2⃣Если найденный символ существует, вернуть его.

3⃣Если такого символа не существует, вернуть первый символ в letters.

😎 Решение:
public class Solution {
public char nextGreatestLetter(char[] letters, char target) {
int left = 0, right = letters.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (letters[mid] > target) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return letters[left % letters.length];
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

395

Java | LeetCode

7 апр. 2026 г., 12:38

Задача: https://leetcode.com/problems/bulb-switcher/ https://leetcode.com/problems/generalized-abbreviation/
Сложность: medium

Обобщенная аббревиатура слова может быть построена путем замены любых неперекрывающихся и несмежных подстрок на их соответствующие длины.

Например, "abcde" можно сократить следующим образом:

"a3e" ("bcd" заменено на "3")
"1bcd1" ("a" и "e" заменены на "1")
"5" ("abcde" заменено на "5")
"abcde" (без замены подстрок)
Однако следующие аббревиатуры недействительны:

"23" ("ab" заменено на "2" и "cde" заменено на "3") недействительно, так как выбранные подстроки смежные.
"22de" ("ab" заменено на "2" и "bc" заменено на "2") недействительно, так как выбранные подстроки перекрываются.
Дано слово word, верните список всех возможных обобщенных аббревиатур слова. Верните ответ в любом порядке.

Пример:
Input: word = "a"
Output: ["1","a"]

👨‍💻 Алгоритм:

1⃣Создание битовых масок
Каждая аббревиатура имеет одно к одному соответствие с n-битным двоичным числом x, где n - длина слова. Используйте эти числа в качестве чертежей для построения соответствующих аббревиатур.

2⃣Генерация аббревиатур
Для числа x просканируйте его бит за битом, чтобы определить, какие символы следует сохранить, а какие - сократить. Если бит равен 1, сохраните соответствующий символ, если 0 - замените его на счетчик.

3⃣Перебор всех комбинаций
Для каждого числа от 0 до 2^n - 1 используйте его битовое представление для создания соответствующей аббревиатуры. Сканируйте число x побитово, извлекая его последний бит с помощью b = x & 1 и сдвигая x вправо на один бит x >>= 1.

😎 Решение:
public class Solution {
public List generateAbbreviations(String word) {
List ans = new ArrayList<>();
for (int x = 0; x < (1 << word.length()); ++x)
ans.add(abbr(word, x));
return ans;
}

private String abbr(String word, int x) {
StringBuilder builder = new StringBuilder();
int k = 0, n = word.length();
for (int i = 0; i < n; ++i, x >>= 1) {
if ((x & 1) == 0) {
if (k != 0) {
builder.append(k);
k = 0;
}
builder.append(word.charAt(i));
} else {
++k;
}
}
if (k != 0) builder.append(k);
return builder.toString();
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

7 апр. 2026 г., 12:38

Задача: https://leetcode.com/problems/longest-consecutive-sequence/description/
Сложность: Medium

Дан несортированный массив целых чисел nums. Верните длину самой длинной последовательности последовательных элементов.

Необходимо написать алгоритм, который работает за время O(n).

Пример:
Input: nums = [100,4,200,1,3,2]
Output: 4
Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.

👨‍💻 Алгоритм:

1⃣Проверка базового случая:
Перед началом работы проверяем базовый случай с пустым массивом.
Самая длинная последовательность в пустом массиве, очевидно, равна 0, поэтому мы можем просто вернуть это значение.

2⃣Обработка чисел в массиве:
Для всех других случаев мы сортируем массив nums и рассматриваем каждое число, начиная со второго (поскольку нам нужно сравнивать каждое число с предыдущим).
Если текущее число и предыдущее равны, то текущая последовательность не удлиняется и не прерывается, поэтому мы просто переходим к следующему числу.
Если числа не равны, то нужно проверить, удлиняет ли текущее число последовательность (т.е. nums[i] == nums[i-1] + 1). Если удлиняет, то мы увеличиваем наш текущий счёт и продолжаем.

3⃣Завершение обработки и возврат результата:
В противном случае последовательность прерывается, и мы записываем нашу текущую последовательность и сбрасываем её до 1 (чтобы включить число, которое прервало последовательность).
Возможно, что последний элемент массива nums является частью самой длинной последовательности, поэтому мы возвращаем максимум из текущей последовательности и самой длинной.

😎 Решение:
class Solution {
private boolean arrayContains(int[] arr, int num) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
return true;
}
}

return false;
}

public int longestConsecutive(int[] nums) {
int longestStreak = 0;

for (int num : nums) {
int currentNum = num;
int currentStreak = 1;

while (arrayContains(nums, currentNum + 1)) {
currentNum += 1;
currentStreak += 1;
}

longestStreak = Math.max(longestStreak, currentStreak);
}

return longestStreak;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

7 апр. 2026 г., 12:38

Задача: https://leetcode.com/problems/reverse-nodes-in-k-group/
Сложность: hard

Учитывая заголовок связанного списка, поменяйте местами узлы списка по k за раз и верните изменённый список.
Если количество узлов не кратно k, то последние остаются без изменений.
*Изменять можно только связи между узлами, а не их значения.*

Пример:
Input: head = [1,2,3,4,5], k = 2 Output: [2,1,4,3,5]

👨‍💻 Алгоритм:

1⃣Создать фиктивный узел dummy, указывающий на head, и использовать указатель pointer для прохода по списку.

2⃣В каждом шаге проверять, есть ли впереди k узлов — если нет, завершить процесс. Иначе — развернуть группу из k узлов.

3⃣После разворота связать конец текущей группы с началом следующей и перейти к следующей группе, сдвинув pointer.

😎 Решение:
public ListNode reverseKGroup(ListNode head, int k) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode pointer = dummy;

while (pointer != null) {
ListNode node = pointer;
for (int i = 0; i < k && node != null; i++) node = node.next;
if (node == null) break;

ListNode prev = null, curr = pointer.next;
for (int i = 0; i < k; i++) {
ListNode next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}

ListNode tail = pointer.next;
tail.next = curr;
pointer.next = prev;
pointer = tail;
}

return dummy.next;
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

7 апр. 2026 г., 12:38

Задача: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
Сложность: medium

Предположим, что массив длиной n, отсортированный в порядке возрастания, повернут от 1 до n раз. Например, массив nums = [0,1,2,4,5,6,7] может стать:

[4,5,6,7,0,1,2], если он был повернут 4 раза.
[0,1,2,4,5,6,7], если он был повернут 7 раз.
Обратите внимание, что поворот массива [a[0], a[1], a[2], ..., a[n-1]] 1 раз приводит к массиву [a[n-1], a[0], a[1], a[2], ..., a[n-2]].

Для данного отсортированного и повернутого массива nums с уникальными элементами верните минимальный элемент этого массива.

Вы должны написать алгоритм, который работает за время O(log n).

Пример:
Input: nums = [3,4,5,1,2]
Output: 1
Explanation: The original array was [1,2,3,4,5] rotated 3 times.
👨‍💻 Алгоритм:

1⃣Нахождение середины массива:
Определите элемент, находящийся посередине массива.

2⃣Определение направления поиска:
Если элемент в середине больше первого элемента массива, это означает, что точка перегиба (минимальный элемент) находится справа от середины.
Если элемент в середине меньше первого элемента массива, это указывает на то, что точка перегиба находится слева от середины.

3⃣Остановка поиска при нахождении точки перегиба:
Поиск прекращается, когда найдена точка перегиба, когда выполняется одно из двух условий:
nums[mid] > nums[mid + 1] – следовательно, mid+1 является наименьшим элементом.
nums[mid - 1] > nums[mid] – следовательно, mid является наименьшим элементом.


😎 Решение:
class Solution {
public int findMin(int[] nums) {
if (nums.length == 1) {
return nums[0];
}
int left = 0, right = nums.length - 1;
if (nums[right] > nums[0]) {
return nums[0];
}

while (right >= left) {

int mid = left + (right - left) / 2;
if (nums[mid] > nums[mid + 1]) {
return nums[mid + 1];
}
if (nums[mid - 1] > nums[mid]) {
return nums[mid];
}
if (nums[mid] > nums[0]) {
left = mid + 1;
} else {
}
}
return Integer. MAX_VALUE;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

7 апр. 2026 г., 12:38

Задача: https://leetcode.com/problems/word-pattern-ii/description/
Сложность: medium

Дан шаблон и строка s, вернуть true, если строка s соответствует шаблону.

Строка s соответствует шаблону, если существует биективное отображение отдельных символов на непустые строки так, что если каждый символ в шаблоне заменить на строку, которой он отображается, то результирующая строка будет равна s. Биективное отображение означает, что ни два символа не отображаются на одну и ту же строку, и ни один символ не отображается на две разные строки.

Пример:
Input: pattern = "abab", s = "redblueredblue"
Output: true
Explanation: One possible mapping is as follows:
'a' -> "red"
'b' -> "blue"

👨‍💻 Алгоритм:

1⃣Инициализация структур данных и определение рекурсивной функции:
Создайте хеш-таблицу symbolMap для отображения символов шаблона на подстроки строки s.
Создайте множество wordSet для хранения уникальных подстрок строки s, которые были отображены на символ.
Определите рекурсивную функцию isMatch, принимающую индексы в строке s (sIndex) и в шаблоне (pIndex), чтобы определить, соответствует ли строка s шаблону.

2⃣Рекурсивная проверка соответствия:
Базовый случай: если pIndex равно длине шаблона, верните true, если sIndex равно длине строки s; иначе верните false.
Получите символ из шаблона по индексу pIndex.
Если символ уже ассоциирован с подстрокой, проверьте, совпадают ли следующие символы в строке s с этой подстрокой. Если нет, верните false. Если совпадают, вызовите isMatch для следующего символа в шаблоне.

3⃣Отображение новых подстрок:
Если символ новый, попробуйте сопоставить его с новыми подстроками строки s, начиная с sIndex и до конца строки.
Для каждой новой подстроки проверьте, существует ли она уже в `

😎 Решение:
import java.util. HashMap;
import java.util. HashSet;

public class Solution {
public boolean wordPatternMatch(String pattern, String s) {
HashMap symbolMap = new HashMap<>();
HashSet wordSet = new HashSet<>();
return isMatch(s, 0, pattern, 0, symbolMap, wordSet);
}

private boolean isMatch(String s, int sIndex, String pattern, int pIndex,
HashMap symbolMap, HashSet wordSet) {
if (pIndex == pattern.length()) {
return sIndex == s.length();
}
char symbol = pattern.charAt(pIndex);
if (symbolMap.containsKey(symbol)) {
String word = symbolMap.get(symbol);
if (!s.startsWith(word, sIndex)) {
return false;
}
return isMatch(s, sIndex + word.length(), pattern, pIndex + 1, symbolMap, wordSet);
}
for (int k = sIndex + 1; k <= s.length(); k++) {
String newWord = s.substring(sIndex, k);
if (wordSet.contains(newWord)) {
continue;
}
symbolMap.put(symbol, newWord);
wordSet.add(newWord);
if (isMatch(s, k, pattern, pIndex + 1, symbolMap, wordSet)) {
return true;
}
symbolMap.remove(symbol);
wordSet.remove(newWord);
}
return false;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

7 апр. 2026 г., 12:38

Задача: https://leetcode.com/problems/numbers-at-most-n-given-digit-set/
Сложность: hard

Дан массив цифр, отсортированный в неубывающем порядке. Вы можете записывать числа, используя каждый digits[i] столько раз, сколько захотите. Например, если digits = ['1','3','5'], мы можем записать такие числа, как '13', '551' и '1351315'. Возвращает количество положительных целых чисел, которые могут быть сгенерированы и которые меньше или равны заданному целому числу n.

Пример:
Input: digits = ["1","3","5","7"], n = 100
Output: 20

👨‍💻 Алгоритм:

1⃣Преобразовать заданное число n в строку для удобного доступа к каждой цифре.

2⃣Реализовать рекурсивную функцию для генерации всех возможных чисел с использованием цифр из массива digits и сравнения с n.

3⃣Начать с каждой цифры в digits и рекурсивно строить числа, отслеживая количество подходящих чисел.

😎 Решение:
class Solution {
public int atMostNGivenDigitSet(String[] digits, int n) {
String s = String.valueOf(n);
int K = s.length();
int[] dp = new int[K + 1];
dp[K] = 1;

for (int i = K - 1; i >= 0; --i) {
for (String d : digits) {
if (d.charAt(0) < s.charAt(i)) {
dp[i] += Math.pow(digits.length, K - i - 1);
} else if (d.charAt(0) == s.charAt(i)) {
dp[i] += dp[i + 1];
}
}
}

for (int i = 1; i < K; ++i) {
dp[0] += Math.pow(digits.length, i);
}

return dp[0];
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

7 апр. 2026 г., 12:38

Задача: https://leetcode.com/problems/minimum-size-subarray-sum/ https://leetcode.com/problems/perfect-number/description/
Сложность: easy

Совершенное число — это положительное целое число, которое равно сумме своих положительных делителей, исключая само число. Делитель целого числа x — это целое число, которое может делить x нацело.

Дано целое число n, верните true, если n является совершенным числом, в противном случае верните false.

Пример:
Input: num = 28
Output: true
Explanation: 28 = 1 + 2 + 4 + 7 + 14
1, 2, 4, 7, and 14 are all divisors of 28.

👨‍💻 Алгоритм:

1⃣Инициализация
Если число num меньше или равно 0, вернуть false. Инициализируйте переменную sum значением 0.

2⃣Поиск делителей и вычисление суммы
Переберите числа от 1 до квадратного корня num. Если число является делителем num, добавьте его к sum. Если делитель не равен квадратному корню num, добавьте к sum также результат деления num на делитель.

3⃣Проверка на совершенное число
Вычтите num из sum. Если результат равен num, вернуть true, иначе вернуть false.

😎 Решение:
public boolean checkPerfectNumber(int num) {
if (num <= 0) {
return false;
}
int sum = 0;
for (int i = 1; i * i <= num; i++) {
if (num % i == 0) {
sum += i;
if (i * i != num) {
sum += num / i;
}

}
}
return sum - num == num;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

7 апр. 2026 г., 12:38

Задача: https://leetcode.com/problems/minimum-size-subarray-sum/ https://leetcode.com/problems/connecting-cities-with-minimum-cost/description/
Сложность: medium

Есть n городов, пронумерованных от 1 до n. Вам даны целое число n и массив connections, где connections[i] = [xi, yi, costi] указывает, что стоимость соединения города xi и города yi (двунаправленное соединение) равна costi.

Верните минимальную стоимость для соединения всех n городов так, чтобы между каждой парой городов был хотя бы один путь. Если невозможно соединить все n городов, верните -1.

Стоимость - это сумма использованных стоимостей соединений.

Пример:
Input: n = 3, connections = [[1,2,5],[1,3,6],[2,3,1]]
Output: 6
Explanation: Choosing any 2 edges will connect all cities so we choose the minimum 2.

👨‍💻 Алгоритм:

1⃣Сортировка рёбер:
Отсортируйте все соединения (рёбра) в графе по их весам (стоимости) в порядке возрастания.

2⃣Итерация по рёбрам и объединение:
Используйте структуру данных Disjoint Set (Union-Find) для проверки циклов и объединения поддеревьев. Для каждого ребра проверьте, принадлежат ли его концы разным поддеревьям, и если да, объедините их, добавив ребро в минимальное остовное дерево (MST).

3⃣Проверка соединённости:
Подсчитайте количество рёбер в MST. Если оно меньше n-1, верните -1, так как соединить все города невозможно. Иначе верните суммарную стоимость рёбер в MST.

😎 Решение:
class DisjointSet {
private int[] parents;

public void Union(int a, int b) {
int rootA = Find(a);
int rootB = Find(b);
if (rootA == rootB) return;
this.parents[rootB] = rootA;
}

public int Find(int a) {
while (a != this.parents[a]) {
a = this.parents[a];
}
return a;
}

public boolean isInSameGroup(int a, int b) {
return Find(a) == Find(b);
}

public DisjointSet(int N) {
this.parents = new int[N + 1];
for (int i = 1; i <= N; ++i) {
this.parents[i] = i;
}
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Java | LeetCode

7 апр. 2026 г., 12:38

Задача: https://leetcode.com/problems/h-index/
Сложность: medium

Дан массив целых чисел citations, где citations[i] — количество цитирований, которое исследователь получил за свою i-ю статью. Верните h-индекс исследователя.
Согласно определению h-индекса на Википедии: h-индекс определяется как максимальное значение h, такое что данный исследователь опубликовал по крайней мере h статей, каждая из которых была процитирована как минимум h раз.

Пример:
Input: citations = [3,0,6,1,5]
Output: 3
Explanation: [3,0,6,1,5] means the researcher has 5 papers in total and each of them had received 3, 0, 6, 1, 5 citations respectively.
Since the researcher has 3 papers with at least 3 citations each and the remaining two with no more than 3 citations each, their h-index is 3.

👨‍💻 Алгоритм:

1⃣Отсортировать массив цитирований по убыванию:
Отсортировать массив citations в порядке убывания, чтобы наибольшее количество цитирований было в начале массива.

2⃣Найти наибольшее значение i, для которого citations[i] > i:
Пройтись по отсортированному массиву и найти наибольшее значение i, для которого выполняется условие citations[i] > i.
Это значение будет индексом, при котором количество цитирований статьи больше индекса.

3⃣Рассчитать h-индекс:
h-индекс будет равен i + 1, где i - наибольшее значение, найденное на предыдущем шаге.

😎 Решение:
public class Solution {
public int hIndex(int[] citations) {
int n = citations.length;
int[] papers = new int[n + 1];
for (int c : citations)
papers[Math.min(n, c)]++;
int k = n;
for (int s = papers[n]; k > s; s += papers[k])
k--;
return k;
}
}

Ставь https://t.me/eo_test_task_bot и забирай https://t.me/eo_test_task_bot

Showing 30 of 30 posts

No more posts

Java | LeetCode

Java | LeetCode

Рейтинг

Рост участников (Последние 5 дней)

Рейтинг

Отзывы пользователей (0)

Похожие каналы Telegram

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Похожие каналы Telegram

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Адреса на продажу #1 - voodoosh, just_ns, manyrin, honeymad, stray228, rostislav_999, ybicanoooobov, tpabomah, ilame, kareykadas

Отзывы пользователей (0)

Последние посты