Logo
TGCATALOG
Catalog Collections Blog
Java | LeetCode

Java | LeetCode

LeetCode задачи и решения на Java.

No ratings
26
09.09.2026
26
09.09.2026
No ratings
26
09.09.2026
Safe redirect via bot
О канале

LeetCode задачи и решения на Java.

Подписчиков 6,497
Тематика Technology
Язык English
Ссылка t.me/easy_java_task

We also recommend

Kekaton AI | Voiceover and voice clone
Kekaton AI | Voiceover and voice clone
Bot

AI bot for text-to-speech and voice cloning in Telegram. Create audio using neural network quickly and easily.

Description

Решения задач LeetCode на Java с акцентом на чистый код и оптимизацию. Темы: массивы, деревья, графы, динамика. Идеально для технической подготовки.

Latest posts

Java | LeetCode
Java | LeetCode
🔒Открыть пост
и посмотреть медиа
Задача: 772. Basic Calculator III Сложность: medium Реализуйте базовый калькулятор для вычисления простого строкового выражения. Строка выражения содержит только неотрицательные целые числа, операторы '+', '-', '*', '/' и открывающие '(' и закрывающие скобки ')'. Целочисленное деление должно округляться к нулю. Предполагается, что данное выражение всегда корректно. Все промежуточные результаты будут находиться в диапазоне [-2^31, 2^31 - 1]. Примечание: нельзя использовать встроенные функции для вычисления строк как математических выражений, такие как eval(). Пример: Input: s = "1+1" Output: 2 👨💻 Алгоритм: 1⃣Определите вспомогательную функцию evaluate, которая принимает оператор и числовые аргументы. Заметьте, что эта функция идентична той, что представлена в подходе "Basic Calculator II". Инициализируйте несколько переменных: стек для хранения промежуточных результатов, curr для отслеживания текущего числа, которое мы строим, и previousOperator для отслеживания предыдущего оператора. Добавьте в строку s случайный символ, который не будет появляться во входных данных, например "@". 2⃣Итерация по входным данным. Для каждого символа c: если c является цифрой, добавьте его к curr. В противном случае, если c == '(', мы начинаем вычисление нового изолированного выражения. В этом случае сохраните previousOperator в стек и установите previousOperator = "+". 3⃣Если c является оператором, то необходимо вычислить значение curr. Используйте функцию evaluate, чтобы применить previousOperator к curr, и добавьте результат в стек. Затем сбросьте curr до нуля и обновите previousOperator = c. Если c == ')', это означает, что мы находимся в конце изолированного выражения и должны полностью его вычислить. Извлекайте из стека до тех пор, пока не достигнете оператора, суммируя все извлеченные числа в curr. Как только достигнете оператора, обновите previousOperator = stack.pop(). Верните сумму всех чисел в стеке. 😎 Решение: class Solution { private String evaluate(char operator, String first, String second) { int x = Integer.parseInt(first); int y = Integer.parseInt(second); int res = 0; if (operator == '+') { res = x; } else if (operator == '-') { res = -x; } else if (operator == '*') { res = x * y; } else { res = x / y; } return Integer.toString(res); } public int calculate(String s) { Stack stack = new Stack(); String curr = ""; char previousOperator = '+'; s += "@"; Set operators = new HashSet(Arrays.asList("+", "-", "*", "/")); for (char c: s.toCharArray()) { if (Character.isDigit(c)) { curr += c; } else if (c == '(') { stack.push("" + previousOperator); previousOperator = '+'; } else { if (previousOperator == '*' || previousOperator == '/') { stack.push(evaluate(previousOperator, stack.pop(), curr)); } else { stack.push(evaluate(previousOperator, curr, "0")); } curr = ""; previousOperator = c; if (c == ')') { int currentTerm = 0; while (!operators.contains(stack.peek())) { currentTerm += Integer.parseInt(stack.pop()); } curr = Integer.toString(currentTerm); previousOperator = stack.pop().charAt(0); } } } int ans = 0; for (String num: stack) { ans += Integer.parseInt(num); } return ans; } } Ставь 👍 и забирай 📚 Базу знаний
Java | LeetCode
Java | LeetCode
🔒Открыть пост
и посмотреть медиа
Задача: 126.Word Ladder II Сложность: hard Последовательность преобразований от слова beginWord до слова endWord с использованием словаря wordList — это последовательность слов beginWord -> s1 -> s2 -> ... -> sk, для которой выполняются следующие условия: Каждая пара соседних слов отличается ровно одной буквой. Каждое si для 1 "dot" -> "dog" -> "cog" "hit" -> "hot" -> "lot" -> "log" -> "cog" 👨💻 Алгоритм: 1⃣Сохранение слов из списка слов (wordList) в хэш-таблицу (unordered set) для эффективного удаления слов в процессе поиска в ширину (BFS). 2⃣Выполнение BFS, добавление связей в список смежности (adjList). После завершения уровня удалять посещенные слова из wordList. 3⃣Начать с beginWord и отслеживать текущий путь как currPath, просматривать все возможные пути, и когда путь ведет к endWord, сохранять путь в shortestPaths. 😎 Решение: class Solution { Map adjList = new HashMap(); List currPath = new ArrayList(); List • > shortestPaths = new ArrayList(); private List findNeighbors(String word, Set wordList) { List neighbors = new ArrayList(); char[] charList = word.toCharArray(); for (int i = 0; i < word.length(); i++) { char oldChar = charList[i]; for (char c = 'a'; c 0) { String currentWord = queue.poll(); for (String neighbor : findNeighbors(currentWord, wordList)) { adjList.computeIfAbsent(neighbor, k -> new ArrayList()).add(currentWord); if (wordList.remove(neighbor)) queue.add(neighbor); } } } } public List • > findLadders(String beginWord, String endWord, List wordList) { bfs(beginWord, new HashSet(wordList)); currPath.add(endWord); backtrack(endWord, beginWord); return shortestPaths; } } Ставь 👍 и забирай 📚 Базу знаний
Java | LeetCode
Java | LeetCode
🔒Открыть пост
и посмотреть медиа
Задача: 146. LRU Cache Сложность: medium Реализуйте класс LRUCache: LRUCache(int capacity) - инициализирует LRU-кэш с положительным размером capacity. int get(int key) - возвращает значение по ключу, если ключ существует, в противном случае возвращает -1. void put(int key, int value) - обновляет значение по ключу, если ключ существует. В противном случае добавляет пару ключ-значение в кэш. Если количество ключей превышает установленную емкость после этой операции, удаляет наименее недавно использованный ключ. Функции get и put должны выполняться за среднее время O(1). Пример: Input ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"] [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]] Output [null, null, null, 1, null, -1, null, -1, 3, 4] 👨💻 Алгоритм: 1⃣Метод добавления узла в конец связного списка (add): Получите текущий узел в конце списка, это "реальный" хвост: tail.prev, обозначим его как previousEnd. Вставьте node после previousEnd, установив previousEnd.next = node. Настройте указатели узла: node.prev = previousEnd и node.next = tail. Обновите tail.prev = node, делая node новым "реальным" хвостом списка. 2⃣Метод удаления узла из связного списка (remove): Узел node должен быть удален из списка. Для этого определите узлы nextNode = node.next и prevNode = node.prev. Чтобы удалить node, переназначьте prevNode.next = nextNode и nextNode.prev = prevNode, эффективно исключая node из списка. Это превратит, например, последовательность A B C в A C, где prevNode = A и nextNode = C. 3⃣Методы get и put: get(int key): Проверьте, существует ли ключ в хэш-карте. Если нет, верните -1. Иначе, получите узел, связанный с ключом, переместите его в конец списка с помощью remove(node) и add(node). Верните node.val. put(int key, int value): Если ключ уже существует, найдите соответствующий узел и удалите его методом remove. Создайте новый узел с key и value, добавьте его в хэш-карту и в конец списка методом add(node). Если размер кэша превышает установленную емкость после добавления, удалите самый редко используемый узел (который находится в голове списка после фиктивного узла head), затем удалите соответствующий ключ из хэш-карты. 😎 Решение: class ListNode { int key; int val; ListNode next; ListNode prev; public ListNode(int key, int val) { this.key = key; this.val = val; } } class LRUCache { int capacity; Map dic; ListNode head; ListNode tail; public LRUCache(int capacity) { this.capacity = capacity; dic = new HashMap(); head = new ListNode(-1, -1); tail = new ListNode(-1, -1); head.next = tail; tail.prev = head; } public int get(int key) { if (!dic.containsKey(key)) { return -1; } ListNode node = dic.get(key); remove(node); add(node); return node.val; } public void put(int key, int value) { if (dic.containsKey(key)) { ListNode oldNode = dic.get(key); remove(oldNode); } ListNode node = new ListNode(key, value); dic.put(key, node); add(node); if (dic.size() > capacity) { ListNode nodeToDelete = head.next; remove(nodeToDelete); dic.remove(nodeToDelete.key); } } public void add(ListNode node) { ListNode previousEnd = tail.prev; previousEnd.next = node; node.prev = previousEnd; node.next = tail; tail.prev = node; } public void remove(ListNode node) { node.prev.next = node.next; node.next.prev = node.prev; } } Ставь 👍 и забирай 📚 Базу знаний
Java | LeetCode
Java | LeetCode
🔒Открыть пост
и посмотреть медиа
Задача: 1006. Clumsy Factorial Сложность: medium Факториал целого положительного числа n - это произведение всех целых положительных чисел, меньших или равных n. Например, факториал(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1. Мы составляем неуклюжий факториал, используя целые числа в порядке убывания, заменяя операции умножения на фиксированную последовательность операций с умножением "*", делением "/", сложением "+" и вычитанием "-" в этом порядке. Например, clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1. Однако эти операции по-прежнему применяются с использованием обычного порядка операций арифметики. Мы выполняем все шаги умножения и деления перед шагами сложения и вычитания, а шаги умножения и деления выполняются слева направо. Кроме того, деление, которое мы используем, является делением с полом, так что 10 * 9 / 8 = 90 / 8 = 11. Учитывая целое число n, верните неуклюжий факториал n. Пример: Input: nums = [4,2,3], k = 1 Output: 5 👨💻 Алгоритм: 1⃣Инициализация переменных и обработка первых трех чисел: Создайте переменные для хранения результата и текущего значения. Если n меньше или равен 3, обработайте случай отдельно, выполняя операции в порядке убывания, и верните результат. 2⃣Выполнение операций в цикле: Создайте цикл, который будет обрабатывать числа от n до 1 в порядке убывания. В цикле выполняйте операции *, /, +, и - последовательно. Обновляйте текущий результат на каждом шаге в зависимости от остатка от деления текущего индекса на 4. 3⃣Учет оставшихся операций и возврат результата: После завершения цикла добавьте или вычтите оставшиеся числа (если есть) к результату. Верните окончательный результат. 😎 Решение: public class Solution { public int clumsy(int n) { if (n == 0) return 0; if (n == 1) return 1; if (n == 2) return 2 * 1; if (n == 3) return 3 * 2 / 1; int res = n * (n - 1) / (n - 2); n -= 3; if (n > 0) res += n--; while (n > 0) { res -= n * (n - 1) / (n - 2); n -= 3; if (n > 0) res += n--; } return res; } } Ставь 👍 и забирай 📚 Базу знаний
Java | LeetCode
Java | LeetCode
🔒Открыть пост
и посмотреть медиа
Задача: 1238. Circular Permutation in Binary Representation Сложность: medium Даны 2 целых числа n и start. Ваша задача - вернуть любую перестановку p из (0,1,2.....,2^n -1) такую, что : p[0] = start p[i] и p[i+1] отличаются только одним битом в их двоичном представлении. p[0] и p[2^n -1] также должны отличаться только одним битом в их двоичном представлении. Пример: Input: n = 2, start = 3 Output: [3,2,0,1] 👨💻 Алгоритм: 1⃣Генерация Грей-кода: Генерация Грей-кода для чисел от 0 до 2𝑛−1 2⃣Определение начальной позиции: Находим индекс числа start в последовательности Грей-кода. 3⃣Построение перестановки: Формируем перестановку, начиная с числа start и следуя по циклическому Грей-коду. 😎 Решение: import java.util.*; public class Solution { public List circularPermutation(int n, int start) { List gray = grayCode(n); int startIndex = gray.indexOf(start); List result = new ArrayList(); result.addAll(gray.subList(startIndex, gray.size())); result.addAll(gray.subList(0, startIndex)); return result; } private List grayCode(int n) { List result = new ArrayList(); int numElements = 1 > 1)); } return result; } } Ставь 👍 и забирай 📚 Базу знаний
Java | LeetCode
Java | LeetCode
🔒Открыть пост
и посмотреть медиа
Задача: 477. Total Hamming Distance Сложность: medium Хэммингово расстояние между двумя целыми числами — это количество позиций, в которых соответствующие биты отличаются. Дан целочисленный массив nums, верните сумму Хэмминговых расстояний между всеми парами чисел в nums. Пример: Input: nums = [4,14,2] Output: 6 Explanation: In binary representation, the 4 is 0100, 14 is 1110, and 2 is 0010 (just showing the four bits relevant in this case). The answer will be: HammingDistance(4, 14) + HammingDistance(4, 2) + HammingDistance(14, 2) = 2 + 2 + 2 = 6. 👨💻 Алгоритм: 1⃣Для каждой уникальной пары элементов из массива вычисляем битовое XOR, чтобы найти позиции, где биты различаются. Бит, равный 1 в результате, указывает на различие. 2⃣Для каждой пары элементов используем XOR, чтобы получить битовую разницу, и подсчитываем количество битов, равных 1, чтобы определить Хэммингово расстояние между парой. 3⃣Суммируем все Хэмминговы расстояния для всех пар, чтобы получить общую сумму Хэмминговых расстояний. 😎 Решение: public class Solution { public int totalHammingDistance(int[] nums) { int ans = 0; if (nums.length == 0) { return ans; } for (int i = 0; i < nums.length - 1; i++) { for (int j = i + 1; j < nums.length; j++) { ans += Integer.bitCount(nums[i] ^ nums[j]); } } return ans; } } Ставь 👍 и забирай 📚 Базу знаний
Java | LeetCode
Java | LeetCode
🔒Открыть пост
и посмотреть медиа
Задача: 846. Hand of Straights Сложность: medium У Алисы есть некоторое количество карт, и она хочет переставить карты в группы так, чтобы каждая группа была размером groupSize и состояла из groupSize последовательных карт. Дан целочисленный массив hand, где hand[i] — это значение, написанное на i-й карте, и целое число groupSize. Верните true, если она может переставить карты, или false в противном случае. Пример: Input: hand = [1,2,3,6,2,3,4,7,8], groupSize = 3 Output: true Explanation: Alice's hand can be rearranged as [1,2,3],[2,3,4],[6,7,8] 👨💻 Алгоритм: 1⃣Проверьте, делится ли длина массива hand на groupSize. Если нет, верните false. 2⃣Создайте карту cardCount для хранения количества каждой карты в массиве hand. 3⃣Итерируйте по массиву hand и обновляйте карту cardCount. Затем итерируйте снова для создания групп: Найдите начальную карту startCard для потенциальной последовательности, уменьшая startCard, пока не найдёте карту, которая отсутствует в карте cardCount. Попробуйте сформировать последовательность из groupSize карт, начиная с startCard. Если какая-либо карта в потенциальной последовательности отсутствует в карте cardCount, верните false. Если последовательность можно сформировать, уменьшите количество каждой карты в последовательности в карте cardCount. 😎 Решение: class Solution { public boolean isNStraightHand(int[] hand, int groupSize) { if (hand.length % groupSize != 0) { return false; } HashMap cardCount = new HashMap(); for (int card : hand) { int count = cardCount.getOrDefault(card, 0); cardCount.put(card, count + 1); } for (int card : hand) { int startCard = card; while (cardCount.getOrDefault(startCard - 1, 0) > 0) { startCard--; } while (startCard 0) { for ( int nextCard = startCard; nextCard < startCard + groupSize; nextCard++ ) { if (cardCount.getOrDefault(nextCard, 0) == 0) { return false; } cardCount.put(nextCard, cardCount.get(nextCard) - 1); } } startCard++; } } return true; } } Ставь 👍 и забирай 📚 Базу знаний
Java | LeetCode
Java | LeetCode
🔒Открыть пост
и посмотреть медиа
Задача: №29. Divide Two Integers Сложность: medium Даны два целых числа dividend и divisor. Выполните деление без использования операторов *, /, %. Результат должен быть усечён до целого и находиться в пределах 32-битного целого числа. Пример: Input: dividend = 10, divisor = 3 Output: 3 Input: dividend = 7, divisor = -3 Output: -2 👨💻 Алгоритм: 1⃣Определить знак результата и привести dividend и divisor к положительным значениям типа long, чтобы избежать переполнения и упростить работу с отрицательными числами. 2⃣Найти максимальное кратное делителя (удваивая divisor и счётчик divide), не превышающее dividend. 3⃣Рекурсивно вызвать деление для остатка dividend - sum, сложить с текущим divide и вернуть результат с учётом знака. 😎 Решение: public class Solution { public int divide(int dividend, int divisor) { long result = divideLong(dividend, divisor); return result > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int)result; } private long divideLong(long dividend, long divisor) { boolean negative = dividend < 0 != divisor < 0; dividend = Math.abs(dividend); divisor = Math.abs(divisor); if (dividend < divisor) return 0; long sum = divisor; long divide = 1; while ((sum + sum)
Java | LeetCode
Java | LeetCode
🔒Открыть пост
и посмотреть медиа
Задача: 1220. Count Vowels Permutation Сложность: hard Дано целое число n, ваша задача состоит в том, чтобы посчитать, сколько строк длины n можно сформировать по следующим правилам: Каждый символ является строчной гласной буквой ('a', 'e', 'i', 'o', 'u') Каждая гласная 'a' может быть только перед 'e'. Каждая гласная 'e' может быть только перед 'a' или 'i'. Каждая гласная 'i' не может быть перед другой 'i'. Каждая гласная 'o' может быть только перед 'i' или 'u'. Каждая гласная 'u' может быть только перед 'a'. Так как ответ может быть слишком большим, верните его по модулю 10^9 + 7. Пример: Input: n = 2 Output: 10 Explanation: All possible strings are: "ae", "ea", "ei", "ia", "ie", "io", "iu", "oi", "ou" and "ua". 👨💻 Алгоритм: 1⃣Инициализация массивов и начальных условий: Инициализируйте пять одномерных массивов размером n для хранения количества строк, оканчивающихся на каждую гласную. Установите первый элемент в каждом массиве равным 1, так как для строк длиной 1 существует только одна возможная строка для каждой гласной. 2⃣Заполнение массивов в соответствии с правилами: Проходите по длине строки от 1 до n. Обновляйте значения массивов, следуя правилам для каждой гласной, учитывая предыдущие значения. 3⃣Суммирование и возврат результата: Возьмите сумму последних элементов всех пяти массивов. Верните результат по модулю 10^9 + 7. 😎 Решение: class Solution { public int countVowelPermutation(int n) { long[] aVowelPermutationCount = new long[n]; long[] eVowelPermutationCount = new long[n]; long[] iVowelPermutationCount = new long[n]; long[] oVowelPermutationCount = new long[n]; long[] uVowelPermutationCount = new long[n]; aVowelPermutationCount[0] = 1L; eVowelPermutationCount[0] = 1L; iVowelPermutationCount[0] = 1L; oVowelPermutationCount[0] = 1L; uVowelPermutationCount[0] = 1L; int MOD = 1000000007; for (int i = 1; i < n; i++) { aVowelPermutationCount[i] = (eVowelPermutationCount[i - 1] + iVowelPermutationCount[i - 1] + uVowelPermutationCount[i - 1]) % MOD; eVowelPermutationCount[i] = (aVowelPermutationCount[i - 1] + iVowelPermutationCount[i - 1]) % MOD; iVowelPermutationCount[i] = (eVowelPermutationCount[i - 1] + oVowelPermutationCount[i - 1]) % MOD; oVowelPermutationCount[i] = iVowelPermutationCount[i - 1] % MOD; uVowelPermutationCount[i] = (iVowelPermutationCount[i - 1] + oVowelPermutationCount[i - 1]) % MOD; } long result = 0L; result = (aVowelPermutationCount[n - 1] + eVowelPermutationCount[n - 1] + iVowelPermutationCount[n - 1] + oVowelPermutationCount[n - 1] + uVowelPermutationCount[n - 1]) % MOD; return (int)result; } } Ставь 👍 и забирай 📚 Базу знаний
Java | LeetCode
Subscriber dynamics
+-0.1% last 30 days
Current
6,497
Month ago
6,504
Average growth
+0 / day
Updated
7 hours ago

Reviews for channel Java | LeetCode

Log in to leave a review

Only registered users can share their opinion.

No reviews yet

Be the first to share your impression of this resource!

Similar resources

A channel with free crypto signals, news and educational content.

Channel

INFORKSOLshareITInformatics and solutions for professionalsTICsTelegram.

Channel

Yachting in St. Petersburg: master classes, training, regattas and corporate events ZIGZAG CLUB.

Channel
Switch to Light Theme
Home Catalog Collections Blog Login