Python | LeetCode

Public

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

909

1.4K

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

9.4k Участники

Обновлено: May 15, 2026 at 1:00 PM

Python | LeetCode

Cайт easyoffer.ru Реклама @easyoffer_adv ВП @easyoffer_vp Тесты t.me/+20tRfhrwPpM4NDQy Вопросы собесов t.me/+cnJC0_ZeZ_I0OGY6 Вакансии t.me/+cXGKkrOY2-w3ZTky

Join @easy_python_task for exclusive tmecnjc0_zez_i0ogy6 and easyoffer_adv content and discussions in 12

Рейтинг

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

#456

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

#45

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

#23

-1

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

Всего: 9.4K

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

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

Python | LeetCode

23 мая 2026 г., 01:40

Задача: https://leetcode.com/problems/minimum-size-subarray-sum/ https://leetcode.com/problems/minimum-value-to-get-positive-step-by-step-sum/description/
Сложность: easy

Дан массив целых чисел nums, вы начинаете с начального положительного значения startValue.

На каждой итерации вы вычисляете поэтапную сумму startValue плюс элементы из nums (слева направо).

Верните минимальное положительное значение startValue, такое что поэтапная сумма никогда не будет меньше 1.

Пример:
Input: nums = [-3,2,-3,4,2]
Output: 5
Explanation: If you choose startValue = 4, in the third iteration your step by step sum is less than 1.
step by step sum
startValue = 4 | startValue = 5 | nums
(4 -3 ) = 1 | (5 -3 ) = 2 | -3
(1 +2 ) = 3 | (2 +2 ) = 4 | 2
(3 -3 ) = 0 | (4 -3 ) = 1 | -3
(0 +4 ) = 4 | (1 +4 ) = 5 | 4
(4 +2 ) = 6 | (5 +2 ) = 7 | 2

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

1⃣Инициализируйте переменные startValue со значением 1 и total со значением startValue.

2⃣Итеративно добавляйте каждый элемент массива nums к total и проверяйте, не опускается ли total ниже 1.

3⃣Если total падает ниже 1, увеличьте startValue на 1 и повторите шаги 2-3. Если total остается не менее 1, верните текущее значение startValue.

😎 Решение:
class Solution:
def minStartValue(self, nums: List[int]) -> int:
startValue = 1
while True:
total = startValue
isValid = True
for num in nums:
total += num
if total < 1:
isValid = False
break
if isValid:
return startValue
startValue += 1

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

698

Python | LeetCode

23 мая 2026 г., 01:40

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

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

Вам даны два различных целочисленных массива с индексами, начинающимися с 0: nums1 и nums2, где nums1 является подмножеством nums2.
Для каждого 0 <= i < nums1.length найдите индекс j, такой что nums1[i] == nums2[j], и определите следующий больший элемент для nums2[j] в nums2. Если следующего большего элемента нет, то ответ для этого запроса — -1.

Верните массив ans длиной nums1.length, где ans[i] — это следующий больший элемент, как описано выше.

Пример:
Input: nums1 = [4,1,2], nums2 = [1,3,4,2]
Output: [-1,3,-1]
Explanation: The next greater element for each value of nums1 is as follows:
- 4 is underlined in nums2 = [1,3,4,2]. There is no next greater element, so the answer is -1.
- 1 is underlined in nums2 = [1,3,4,2]. The next greater element is 3.
- 2 is underlined in nums2 = [1,3,4,2]. There is no next greater element, so the answer is -1.

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

1⃣Инициализация и поиск совпадений
Создайте массив res для хранения результатов. Для каждого элемента nums1[i] найдите его индекс j в массиве nums2.

2⃣Поиск следующего большего элемента
После нахождения индекса j в nums2 начните поиск элемента справа от nums2[j], который больше nums1[i]. Если такой элемент найден, добавьте его в res.

3⃣Заполнение результата
Если следующий больший элемент не найден, добавьте -1 в соответствующую позицию res. Верните массив res.

😎 Решение:
class Solution:
def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
res = [-1] * len(nums1)

for i in range(len(nums1)):
found = False
for j in range(len(nums2)):
if nums2[j] == nums1[i]:
found = True
if found and nums2[j] > nums1[i]:
res[i] = nums2[j]
break

return res

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

Python | LeetCode

23 мая 2026 г., 01:40

Задача: https://leetcode.com/problems/previous-permutation-with-one-swap/
Сложность: medium

Учитывая массив целых положительных чисел arr (не обязательно различных), верните лексикографически наибольшую перестановку, которая меньше arr и может быть сделана ровно с одной подстановкой. Если это невозможно, то верните тот же массив. Обратите внимание, что перестановка меняет местами два числа arr[i] и arr[j].

Пример:
Input: arr = [3,2,1]
Output: [3,1,2]

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

1⃣Определи общее количество покупателей, которые удовлетворены в минуты, когда владелец магазина не ворчлив.

2⃣Пройди по массиву, используя скользящее окно для учета эффекта от техники.

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

😎 Решение:
def prevPermOpt1(arr):
n = len(arr)
for i in range(n - 2, -1, -1):
if arr[i] > arr[i + 1]:
break
else:
return arr

for j in range(n - 1, i, -1):
if arr[j] < arr[i] and (j == n - 1 or arr[j] != arr[j + 1]):
break

arr[i], arr[j] = arr[j], arr[i]

return arr

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

849

Python | LeetCode

23 мая 2026 г., 01:40

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

Дано целое число n, верните все стробограмматические числа длины n. Ответ можно возвращать в любом порядке.

Стробограмматическое число — это число, которое выглядит одинаково при повороте на 180 градусов (если посмотреть вверх ногами).

Пример:
Input: n = 2
Output: ["11","69","88","96"]

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

1️⃣Инициализируйте структуру данных reversiblePairs, которая содержит все пары обратимых цифр. Вызовите и верните результат рекурсивной функции generateStroboNumbers(n, finalLength), где первый аргумент указывает, что текущий вызов создаст все стробограмматические числа длиной n, а второй аргумент указывает длину конечных стробограмматических чисел, которые мы будем генерировать, и будет использоваться для проверки возможности добавления '0' в начало и конец числа.

2️⃣Создайте функцию generateStroboNumbers(n, finalLength), которая вернет все стробограмматические числа длиной n:
Проверьте базовые случаи: если n == 0, верните массив с пустой строкой [""]; если n == 1, верните ["0", "1", "8"].
Вызовите generateStroboNumbers(n - 2, finalLength), чтобы получить все стробограмматические числа длиной (n-2), и сохраните их в subAns.
Инициализируйте пустой массив currStroboNums для хранения стробограмматических чисел длиной n.

3️⃣Для каждого числа в subAns добавьте все reversiblePairs в начало и конец, за исключением случая, когда текущая пара '00' и n == finalLength (потому что нельзя добавить '0' в начало числа), и добавьте это новое число в currStroboNums. В конце функции верните все стробограмматические числа, т.е. currStroboNums.

😎 Решение:
class Solution:
def __init__(self):
self.reversiblePairs = [
('0', '0'), ('1', '1'),
('6', '9'), ('8', '8'), ('9', '6')
]

def generateStroboNumbers(self, n, finalLength):
if n == 0:
return [""]

if n == 1:
return ["0", "1", "8"]

prevStroboNums = self.generateStroboNumbers(n - 2, finalLength)
currStroboNums = []

for prevStroboNum in prevStroboNums:
for a, b in self.reversiblePairs:
if a != '0' or n != finalLength:
currStroboNums.append(a + prevStroboNum + b)

return currStroboNums

def findStrobogrammatic(self, n):
return self.generateStroboNumbers(n, n)

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

Python | LeetCode

23 мая 2026 г., 01:40

Задача: https://leetcode.com/problems/number-of-orders-in-the-backlog/description/
Сложность: medium

Дан двумерный целочисленный массив orders, где каждый элемент orders[i] = [pricei, amounti, orderTypei] обозначает, что было размещено amounti заказов типа orderTypei по цене pricei. Тип заказа orderTypei может быть:

- 0, если это партия заказов на покупку, или
- 1, если это партия заказов на продажу.

Обратите внимание, что orders[i] представляет собой партию из amounti независимых заказов с одинаковой ценой и типом. Все заказы, представленные orders[i], будут размещены перед всеми заказами, представленными orders[i+1] для всех допустимых i.

Существует список невыполненных заказов (backlog), который изначально пуст. При размещении заказа происходит следующее:

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

Верните общее количество заказов в списке невыполненных заказов после размещения всех заказов из входных данных. Поскольку это число может быть большим, верните его по модулю 10^9 + 7.

Пример:
Input: orders = [[10,5,0],[15,2,1],[25,1,1],[30,4,0]]
Output: 6

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

1⃣Обрабатывайте каждый заказ в orders. Для заказа на покупку сравните с самыми дешевыми заказами на продажу в списке и выполняйте их при возможности, иначе добавьте в список.

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

3⃣Подсчитайте общее количество оставшихся заказов в списке и верните его по модулю 10^9 + 7.

😎 Решение:
class Solution:
def getNumberOfBacklogOrders(self, orders: List[List[int]]) -> int:
buyOrders, sellOrders = [], []
MOD = 1_000_000_007

for price, amount, orderType in orders:
if orderType == 0:
while amount > 0 and sellOrders and sellOrders[0][0] <= price:
sellOrder = heapq.heappop(sellOrders)
executedAmount = min(amount, sellOrder[1])
amount -= executedAmount
if sellOrder[1] > executedAmount:
heapq.heappush(sellOrders, (sellOrder[0], sellOrder[1] - executedAmount))
if amount > 0:
heapq.heappush(buyOrders, (-price, amount))
else:
while amount > 0 and buyOrders and -buyOrders[0][0] >= price:
buyOrder = heapq.heappop(buyOrders)
executedAmount = min(amount, buyOrder[1])
amount -= executedAmount
if buyOrder[1] > executedAmount:
heapq.heappush(buyOrders, (buyOrder[0], buyOrder[1] - executedAmount))
if amount > 0:
heapq.heappush(sellOrders, (price, amount))

return sum(amount for _, amount in buyOrders + sellOrders) % MOD

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

Python | LeetCode

23 мая 2026 г., 01:40

Задача: https://leetcode.com/problems/number-of-steps-to-reduce-a-number-to-zero/description/
Сложность: easy

Дано целое число num, вернуть количество шагов, необходимых для его сокращения до нуля.

На каждом шаге, если текущее число четное, его нужно разделить на 2, в противном случае, вы должны вычесть из него 1.

Пример:
Input: num = 14
Output: 6
Explanation:
Step 1) 14 is even; divide by 2 and obtain 7.
Step 2) 7 is odd; subtract 1 and obtain 6.
Step 3) 6 is even; divide by 2 and obtain 3.
Step 4) 3 is odd; subtract 1 and obtain 2.
Step 5) 2 is even; divide by 2 and obtain 1.
Step 6) 1 is odd; subtract 1 and obtain 0.

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

1⃣На каждом шаге проверяйте, четное ли текущее число, используя оператор остатка от деления (%). Если число четное (number % 2 == 0), разделите его на 2.

2⃣Если число нечетное (number % 2 == 1), вычтите из него 1.

3⃣После выполнения каждого из этих действий увеличивайте счетчик шагов на 1, чтобы в конце вернуть его значение.

😎 Решение:
def numberOfSteps(num):
steps = 0
while num != 0:
if num % 2 == 0:
num //= 2
else:
num -= 1
steps += 1
return steps

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

648

Python | LeetCode

23 мая 2026 г., 01:40

Задача: https://leetcode.com/problems/binary-prefix-divisible-by-5/
Сложность: medium

Вам дана голова связного списка с n узлами. Для каждого узла в списке найдите значение следующего большего узла. То есть для каждого узла найдите значение первого узла, который находится рядом с ним и имеет строго большее значение, чем он. Верните целочисленный массив answer, где answer[i] - это значение следующего большего узла ith-узла (с индексацией по 1). Если у узла ith нет следующего большего узла, установите answer[i] = 0.

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

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

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

2⃣Поиск следующего большего элемента:
Итерируйте по массиву значений узлов.
Для каждого элемента, пока стек не пуст и текущий элемент больше, чем элемент на вершине стека, обновите массив ответов значением текущего элемента и удалите элемент из стека.
Добавьте текущий индекс в стек.

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

😎 Решение:
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next

class Solution:
def nextLargerNodes(self, head: ListNode) -> List[int]:
values = []
while head:
values.append(head.val)
head = head.next

answer = [0] * len(values)
stack = []

for i, value in enumerate(values):
while stack and values[stack[-1]] < value:
answer[stack.pop()] = value
stack.append(i)

return answer

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

Python | LeetCode

23 мая 2026 г., 01:40

Задача: https://leetcode.com/problems/permutation-sequence/ https://leetcode.com/problems/repeated-substring-pattern/description/
Сложность: easy

Дана строка s, проверьте, может ли она быть построена путем взятия подстроки и добавления нескольких копий этой подстроки друг за другом.

Пример:
Input: heights = [2,1,5,6,2,3]
Output: 10
Explanation: The above is a histogram where width of each bar is 1.
The largest rectangle is shown in the red area, which has an area = 10 units.

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

1⃣Создайте целочисленную переменную n, равную длине строки s.

2⃣Итерация по всем префиксным подстрокам длины i от 1 до n/2:
Если i делит n, объявите пустую строку pattern. Используйте внутренний цикл, который выполняется n/i раз для конкатенации подстроки, сформированной из первых i символов строки s.
Если pattern равен s, вернуть true.

3⃣Если нет подстроки, которую можно повторить для формирования s, вернуть false.

😎 Решение:
class Solution:
def repeatedSubstringPattern(self, s: str) -> bool:
n = len(s)
for i in range(1, n // 2 + 1):
if n % i == 0:
pattern = s[:i] * (n // i)
if s == pattern:
return True
return False

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

779

Python | LeetCode

23 мая 2026 г., 01:40

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

Есть ряд из m домов в маленьком городе, каждый дом должен быть покрашен одним из n цветов (обозначены от 1 до n), некоторые дома, которые были покрашены прошлым летом, не должны быть перекрашены.

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

Например: дома = [1,2,2,3,3,2,1,1] содержат 5 соседств [{1}, {2,2}, {3,3}, {2}, {1,1}].
Дан массив домов, матрица m x n стоимости и целое число target, где:
houses[i]: цвет дома i, и 0, если дом ещё не покрашен.
cost[i][j]: стоимость покраски дома i в цвет j + 1.
Верните минимальную стоимость покраски всех оставшихся домов таким образом, чтобы было ровно target соседств. Если это невозможно, верните -1.

Пример:
Input: houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
Output: 9
Explanation: Paint houses of this way [1,2,2,1,1]
This array contains target = 3 neighborhoods, [{1}, {2,2}, {1,1}].
Cost of paint all houses (1 + 1 + 1 + 1 + 5) = 9.

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

1⃣Инициализация и базовые случаи:
Создайте класс Solution и массив memo для мемоизации результатов. Установите MAX_COST как максимально возможную стоимость плюс 1.
Создайте метод findMinCost, который проверяет базовые случаи:
- если все дома пройдены, возвращайте 0, если количество соседств равно target, иначе возвращайте MAX_COST.
- если количество соседств больше target, возвращайте MAX_COST.
Если результат уже вычислен, возвращайте его из memo.

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

3⃣Метод minCost:
Запустите метод findMinCost с начальными параметрами и верните результат. Если результат равен MAX_COST, верните -1.

😎 Решение:
class Solution:
def __init__(self):
self. MAX_COST = 1000001
self.memo = {}

def findMinCost(self, houses, cost, targetCount, currIndex, neighborhoodCount, prevHouseColor):
if currIndex == len(houses):
return 0 if neighborhoodCount == targetCount else self. MAX_COST

if neighborhoodCount > targetCount:
return self. MAX_COST

if (currIndex, neighborhoodCount, prevHouseColor) in self.memo:
return self.memo[(currIndex, neighborhoodCount, prevHouseColor)]

minCost = self. MAX_COST

if houses[currIndex] != 0:
newNeighborhoodCount = neighborhoodCount + (houses[currIndex] != prevHouseColor)
minCost = self.findMinCost(houses, cost, targetCount, currIndex + 1, newNeighborhoodCount, houses[currIndex])
else:
for color in range(1, len(cost[0]) + 1):
newNeighborhoodCount = neighborhoodCount + (color != prevHouseColor)
currCost = cost[currIndex][color - 1] + self.findMinCost(houses, cost, targetCount, currIndex + 1, newNeighborhoodCount, color)
minCost = min(minCost, currCost)

self.memo[(currIndex, neighborhoodCount, prevHouseColor)] = minCost
return minCost

def minCost(self, houses, cost, m, n, target):
answer = self.findMinCost(houses, cost, target, 0, 0, 0)
return -1 if answer == self. MAX_COST else answer

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

Python | LeetCode

23 мая 2026 г., 01:40

Задача: https://leetcode.com/problems/design-log-storage-system/description/
Сложность: medium

Вам дается несколько журналов, где каждый журнал содержит уникальный идентификатор и временную метку. Временная метка - это строка, имеющая следующий формат: Год:Месяц:День:Час:Минута:Секунда, например, 2017:01:01:23:59:59. Все домены - десятичные числа с нулевым добавлением. Реализация класса LogSystem: LogSystem() Инициализирует объект LogSystem. void put(int id, string timestamp) Сохраняет заданный журнал (id, timestamp) в вашей системе хранения.
int[] retrieve(string start, string end, string granularity) Возвращает идентификаторы журналов, временные метки которых находятся в диапазоне от start до end включительно. start и end имеют тот же формат, что и timestamp, а granularity означает, насколько точным должен быть диапазон (т. е. с точностью до дня, минуты и т. д.). Например, start = "2017:01:01:23:59:59", end = "2017:01:02:23:59:59", а granularity = "Day" означает, что нам нужно найти журналы в диапазоне от 1 января 2017 года до 2 января 2017 года включительно, а час, минуту и секунду для каждой записи журнала можно игнорировать.

Пример:
Input
["LogSystem", "put", "put", "put", "retrieve", "retrieve"]
[[], [1, "2017:01:01:23:59:59"], [2, "2017:01:01:22:59:59"], [3, "2016:01:01:00:00:00"], ["2016:01:01:01:01:01", "2017:01:01:23:00:00", "Year"], ["2016:01:01:01:01:01", "2017:01:01:23:00:00", "Hour"]]
Output
[null, null, null, null, [3, 2, 1], [2, 1]]

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

1⃣Инициализация и хранение журналов
Реализуйте метод put, который будет сохранять журнал с заданным id и timestamp в системе хранения.

2⃣Формирование диапазона
Реализуйте метод retrieve, который будет формировать диапазон временных меток на основе заданного start, end и granularity.

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

😎 Решение:
class LogSystem:
def __init__(self):
self.logs = []

def put(self, id: int, timestamp: str) -> None:
self.logs.append((id, timestamp))

def retrieve(self, start: str, end: str, granularity: str) -> [int]:
index = {
'Year': 4,
'Month': 7,
'Day': 10,
'Hour': 13,
'Minute': 16,
'Second': 19
}[granularity]

start = start[:index]
end = end[:index]

result = []
for id, timestamp in self.logs:
if start <= timestamp[:index] <= end:
result.append(id)
return result

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

Python | LeetCode

8 мая 2026 г., 15:57

Задача: https://leetcode.com/problems/minimum-size-subarray-sum/ https://leetcode.com/problems/check-if-a-number-is-majority-element-in-a-sorted-array/description/
Сложность: easy

Дан целочисленный массив nums, отсортированный в неубывающем порядке, и целое число target. Верните true, если target является элементом большинства, или false в противном случае.

Элемент большинства в массиве nums — это элемент, который встречается в массиве более чем nums.length / 2 раз.

Пример:
Input: nums = [2,4,5,5,5,5,5,6,6], target = 5
Output: true
Explanation: The value 5 appears 5 times and the length of the array is 9.
Thus, 5 is a majority element because 5 > 9/2 is true.

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

1⃣Инициализация переменной count:
Инициализируйте переменную count значением 0..

2⃣Итерация по списку nums:
Пройдите по каждому элементу списка nums.
Если элемент num равен target, увеличьте значение переменной count.

3⃣Проверка условия мажоритарного элемента:
Если count больше чем половина длины списка nums, верните true.
В противном случае верните false.

😎 Решение:
class Solution:
def isMajorityElement(self, nums: List[int], target: int) -> bool:
count = 0
for num in nums:
if num == target:
count += 1
return count > len(nums) // 2

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

593

Python | LeetCode

22 апр. 2026 г., 01:31

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

Изображение представлено в виде целочисленной сетки m x n, где image[i][j] - значение пикселя изображения. Вам также даны три целых числа sr, sc и color. Вы должны выполнить заливку изображения, начиная с пикселя image[sr][sc]. Чтобы выполнить заливку, рассмотрите начальный пиксель, плюс все пиксели, соединенные по 4-м направлениям с начальным пикселем, того же цвета, что и начальный пиксель, плюс все пиксели, соединенные по 4-м направлениям с этими пикселями (также того же цвета), и так далее. Замените цвет всех вышеупомянутых пикселей на цвет. Верните измененное изображение после выполнения заливки.

Пример:
Input: image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, color = 2
Output: [[2,2,2],[2,2,0],[2,0,1]]

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

1⃣Получите цвет начального пикселя.

2⃣Используйте обход в глубину (DFS) или обход в ширину (BFS) для замены цвета всех пикселей, которые соединены с начальным пикселем и имеют тот же цвет.

3⃣Обновите изображение и верните его.

😎 Решение:
def floodFill(image, sr, sc, color):
original_color = image[sr][sc]
if original_color == color:
return image

def dfs(x, y):
if x < 0 or x >= len(image) or y < 0 or y >= len(image[0]) or image[x][y] != original_color:
return
image[x][y] = color
dfs(x + 1, y)
dfs(x - 1, y)
dfs(x, y + 1)
dfs(x, y - 1)

dfs(sr, sc)
return image

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

Python | LeetCode

22 апр. 2026 г., 01:31

Задача: https://leetcode.com/problems/minimum-size-subarray-sum/ https://leetcode.com/problems/delete-n-nodes-after-m-nodes-of-a-linked-list/description/
Сложность: easy

Вам дано начало связанного списка и два целых числа m и n.

Пройдите по связанному списку и удалите некоторые узлы следующим образом:
Начните с головы как текущего узла.
Сохраните первые m узлов, начиная с текущего узла.
Удалите следующие n узлов.
Продолжайте повторять шаги 2 и 3, пока не достигнете конца списка.
Верните голову изменённого списка после удаления указанных узлов.

Пример:
Input: head = [1,2,3,4,5,6,7,8,9,10,11,12,13], m = 2, n = 3
Output: [1,2,6,7,11,12]
Explanation: Keep the first (m = 2) nodes starting from the head of the linked List (1 ->2) show in black nodes.
Delete the next (n = 3) nodes (3 -> 4 -> 5) show in read nodes.
Continue with the same procedure until reaching the tail of the Linked List.
Head of the linked list after removing nodes is returned.

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

1⃣Инициализация указателей:
Инициализируйте currentNode на голову связанного списка. Этот указатель будет использоваться для линейного прохода по каждому узлу списка.
Инициализируйте lastMNode на голову связанного списка.

2⃣Итерация по списку:
Итеративно удаляйте n узлов после m узлов, продолжая до конца списка.
Проходите m узлов, обновляя lastMNode на текущий узел. После m итераций lastMNode указывает на m-й узел.
Продолжайте итерацию по n узлам.

3⃣Удаление узлов:
Чтобы удалить n узлов, измените указатель next у lastMNode, чтобы он указывал на currentNode после пропуска n узлов.

😎 Решение:
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next

class Solution:
def deleteNodes(self, head: ListNode, m: int, n: int) -> ListNode:
currentNode = head
lastMNode = head

while currentNode:
mCount, nCount = m, n

while currentNode and mCount > 0:
lastMNode = currentNode
currentNode = currentNode.next
mCount -= 1

while currentNode and nCount > 0:
currentNode = currentNode.next
nCount -= 1

lastMNode.next = currentNode

return head

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

Python | LeetCode

22 апр. 2026 г., 01:31

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

Пиковым элементом называется элемент, который строго больше своих соседей.

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

Вы можете представить, что nums[-1] = nums[n] = -∞. Другими словами, элемент всегда считается строго большим, чем сосед, находящийся за пределами массива.

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

Пример:
Input: nums = [1,2,3,1]
Output: 2
Explanation: 3 is a peak element and your function should return the index number 2.

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

1️⃣Начальная проверка:
Определяем средний элемент массива mid как mid = low + (high - low) / 2. Это помогает предотвратить возможное переполнение при больших значениях индексов.

2️⃣Определение направления поиска:
Сравниваем элемент nums[mid] с его правым соседом nums[mid + 1]. Если nums[mid] меньше nums[mid + 1], это указывает на наличие восходящей последовательности, и мы двигаемся вправо, устанавливая low = mid + 1. Это потому, что пик гарантированно находится в правой части.
Если nums[mid] больше nums[mid + 1], это указывает на наличие нисходящей последовательности, и пик находится либо в mid, либо слева от него, тогда устанавливаем high = mid.

3️⃣Завершение поиска:
Процесс продолжается до тех пор, пока low не станет равным high, что означает сужение поисковой области до одного элемента, который и является пиком, поскольку мы исключили все другие возможности.

😎 Решение:
class Solution:
def findPeakElement(self, nums: List[int]) -> int:
return self.search(nums, 0, len(nums) - 1)

def search(self, nums: List[int], l: int, r: int) -> int:
if l == r:
return l
mid = (l + r) // 2
if nums[mid] > nums[mid + 1]:
return self.search(nums, l, mid)
return self.search(nums, mid + 1, r)

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

Python | LeetCode

6 апр. 2026 г., 21:54

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

Задав массив целых чисел arr, верните true тогда и только тогда, когда он является допустимым горным массивом. Напомним, что arr является горным массивом тогда и только тогда, когда: arr.length >= 3 Существует некоторое i с 0 < i < arr.length - 1 такое, что: arr[0] < arr[1] < ... < arr[i - 1] < arr[i] arr[i] > arr[i + 1] > ... > arr[arr.length - 1]

Пример:
Input: arr = [2,1]
Output: false

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

1⃣Убедиться, что длина массива не меньше 3.

2⃣Найти вершину горы, которая удовлетворяет условиям горного массива.
Проверить, что все элементы слева от вершины строго возрастают.
Проверить, что все элементы справа от вершины строго убывают.

3⃣Вернуть true, если оба условия выполнены, иначе вернуть false.

😎 Решение:
def validMountainArray(arr):
if len(arr) < 3:
return False

i = 1
while i < len(arr) and arr[i] > arr[i - 1]:
i += 1

if i == 1 or i == len(arr):
return False

while i < len(arr) and arr[i] < arr[i - 1]:
i += 1

return i == len(arr)

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

532

Python | LeetCode

6 апр. 2026 г., 21:54

Задача: https://leetcode.com/problems/k-empty-slots/description/
Сложность: hard

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

Вам дан массив bulbs длины n, где bulbs[i] = x означает, что в (i+1)-й день мы включим лампочку в позиции x, где i индексируется с 0, а x индексируется с 1.

Дано целое число k, верните минимальный номер дня, такой что существует две включенные лампочки, между которыми ровно k выключенных лампочек. Если такого дня не существует, верните -1.

Пример:
Input: bulbs = [1,3,2], k = 1
Output: 2
Explanation:
On the first day: bulbs[0] = 1, first bulb is turned on: [1,0,0]
On the second day: bulbs[1] = 3, third bulb is turned on: [1,0,1]
On the third day: bulbs[2] = 2, second bulb is turned on: [1,1,1]
We return 2 because on the second day, there were two on bulbs with one off bulb between them.

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

1⃣Поддерживайте active, отсортированную структуру данных, содержащую каждую лампочку, которая в данный момент включена. Это позволит быстро находить соседей для вновь добавленных лампочек и проверять условия задачи.

2⃣Когда вы добавляете лампочку в active, проверьте ее нижних и верхних соседей. Для этого найдите ближайшие включенные лампочки с обеих сторон и проверьте количество выключенных лампочек между ними.

3⃣Если какой-то сосед удовлетворяет условию (ровно k выключенных лампочек между двумя включенными), значит, условие впервые произошло в этот день, и вы можете вернуть номер этого дня. Если такого дня не существует после включения всех лампочек, верните -1.

😎 Решение:
from sortedcontainers import SortedList

class Solution:
def kEmptySlots(self, flowers: List[int], k: int) -> int:
active = SortedList()
day = 0

for flower in flowers:
day += 1
active.add(flower)
idx = active.index(flower)

if idx > 0 and flower - active[idx - 1] - 1 == k:
return day
if idx < len(active) - 1 and active[idx + 1] - flower - 1 == k:
return day

return -1

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

Python | LeetCode

6 апр. 2026 г., 21:54

Задача: 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.

😎 Решение:
class Solution:
def generateAbbreviations(self, word: str):
def abbr(word, x):
builder = []
k = 0
for i in range(len(word)):
if x & 1 == 0:
if k != 0:
builder.append(str(k))
k = 0
builder.append(word[i])
else:
k += 1
x >>= 1
if k != 0:
builder.append(str(k))
return ''.join(builder)

ans = []
for x in range(1 << len(word)):
ans.append(abbr(word, x))
return ans

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

Python | LeetCode

6 апр. 2026 г., 21:54

📷 Photo

Завтра последний день!

Успей купить пожизненный easyoffer PRO - по цене 1 года

Покупаешь один раз — пользуешься всю жизнь.

👉 Акция до 31 марта: https://easyoffer.ru/pro

642

Python | LeetCode

6 апр. 2026 г., 21:54

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

Дан массив интервалов, где intervals[i] = [starti, endi] и каждый starti уникален.

Правый интервал для интервала i - это интервал j, такой что startj >= endi и startj минимален. Обратите внимание, что i может быть равен j.

Верните массив индексов правых интервалов для каждого интервала i. Если правого интервала для интервала i не существует, то поставьте -1 в индекс i.

Пример:
Input: intervals = [[1,2]]
Output: [-1]
Explanation: There is only one interval in the collection, so it outputs -1.

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

1⃣Интуиция за этим подходом такова: если мы будем поддерживать два массива - intervals, который отсортирован по начальным точкам, и endIntervals, который отсортирован по конечным точкам. Когда мы выбираем первый интервал (или, скажем, i-ый интервал) из массива endIntervals, мы можем определить подходящий интервал, удовлетворяющий критериям правого интервала, просматривая интервалы в массиве intervals слева направо, так как массив intervals отсортирован по начальным точкам. Допустим, индекс выбранного элемента из массива intervals окажется j.

2⃣Теперь, когда мы выбираем следующий интервал (скажем, (i+1)-ый интервал) из массива endIntervals, нам не нужно начинать сканирование массива intervals с первого индекса. Вместо этого мы можем начать прямо с индекса j, где мы остановились в последний раз в массиве intervals. Это потому, что конечная точка, соответствующая endIntervals[i+1], больше, чем та, которая соответствует endIntervals[i], и ни один из интервалов из intervals[k], таких что 0 < k < j, не удовлетворяет критериям правого соседа с endIntervals[i], а значит, и с endIntervals[i+1] тоже.

3⃣Если в какой-то момент мы достигнем конца массива, т.е. j = intervals.length, и ни один элемент, удовлетворяющий критериям правого интервала, не будет доступен в массиве intervals, мы ставим -1 в соответствующую запись res. То же самое касается всех оставшихся элементов массива endIntervals, конечные точки которых даже больше, чем у предыдущего интервала. Также мы используем хеш-таблицу hash изначально, чтобы сохранить индексы, соответствующие интервалам, даже после сортировки.

😎 Решение:
class Solution:
def findRightInterval(self, intervals):
endIntervals = intervals[:]
hash = {tuple(interval): i for i, interval in enumerate(intervals)}
intervals.sort(key=lambda x: x[0])
endIntervals.sort(key=lambda x: x[1])
j = 0
res = [-1] * len(intervals)
for i in range(len(endIntervals)):
while j < len(intervals) and intervals[j][0] < endIntervals[i][1]:
j += 1
res[hash[tuple(endIntervals[i])]] = -1 if j == len(intervals) else hash[tuple(intervals[j])]
return res

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

Python | LeetCode

6 апр. 2026 г., 21:54

Задача: 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:
def findKthLargest(self, nums, k):
nums.sort(reverse=True)
return nums[k - 1]

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

1,020

Python | LeetCode

6 апр. 2026 г., 21:54

Задача: https://leetcode.com/problems/flip-equivalent-binary-trees/
Сложность: medium

Для бинарного дерева T мы можем определить операцию переворота следующим образом: выбираем любой узел и меняем местами левое и правое дочерние поддеревья. Бинарное дерево X эквивалентно бинарному дереву Y тогда и только тогда, когда мы можем сделать X равным Y после некоторого количества операций переворота. Учитывая корни двух бинарных деревьев root1 и root2, верните true, если эти два дерева эквивалентны перевороту, или false в противном случае.

Пример:
Input: root1 = [1,2,3,4,5,6,null,null,null,7,8], root2 = [1,3,2,null,6,4,5,null,null,null,null,8,7]
Output: true

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

1⃣Если оба дерева пусты, они эквивалентны, вернуть true. Если одно дерево пустое, а другое нет, они не эквивалентны, вернуть false.

2⃣Если значения корней деревьев не совпадают, вернуть false.
Проверить два условия:
Левое поддерево первого дерева эквивалентно левому поддереву второго дерева и правое поддерево первого дерева эквивалентно правому поддереву второго дерева.
Левое поддерево первого дерева эквивалентно правому поддереву второго дерева и правое поддерево первого дерева эквивалентно левому поддереву второго дерева.

3⃣Вернуть true, если выполняется хотя бы одно из этих условий.

😎 Решение:
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right

def flipEquiv(root1, root2):
if not root1 and not root2:
return True
if not root1 or not root2 or root1.val != root2.val:
return False

return (flipEquiv(root1.left, root2.left) and flipEquiv(root1.right, root2.right)) or \
(flipEquiv(root1.left, root2.right) and flipEquiv(root1.right, root2.left))

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

Python | LeetCode

6 апр. 2026 г., 21:54

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

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

Дан целочисленный массив nums, верните длину его самой длинной гармоничной подпоследовательности среди всех возможных подпоследовательностей.

Подпоследовательность массива - это последовательность, которую можно получить из массива, удалив некоторые или никакие элементы, не изменяя порядок оставшихся элементов.

Пример:
Input: nums = [1,3,2,2,5,2,3,7]
Output: 5
Explanation: The longest harmonious subsequence is [3,2,2,2,3].

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

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

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

3⃣Верните максимальную длину гармоничной подпоследовательности.

😎 Решение:
class Solution:
def findLHS(self, nums: List[int]) -> int:
count = {}
res = 0

for num in nums:
count[num] = count.get(num, 0) + 1
if num + 1 in count:
res = max(res, count[num] + count[num + 1])
if num - 1 in count:
res = max(res, count[num] + count[num - 1])

return res

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

Python | LeetCode

6 апр. 2026 г., 21:54

Задача: https://leetcode.com/problems/surface-area-of-3d-shapes/description/
Сложность: easy

Вам дана сетка n x n, на которой вы разместили несколько кубиков 1 x 1 x 1. Каждое значение v = grid[i][j] представляет собой башню из v кубиков, размещенных на вершине ячейки (i, j). После размещения кубиков вы решили склеить все непосредственно прилегающие кубики друг с другом, образовав несколько неправильных 3D-фигур. Верните общую площадь поверхности получившихся фигур. Примечание: нижняя грань каждой фигуры учитывается в площади ее поверхности.

Пример:
Input: grid = [[1,2],[3,4]]
Output: 34

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

1⃣Пройти по всей сетке и для каждой башни (ячейки) посчитать начальную площадь поверхности: добавить площадь верхней и нижней граней, а также четыре боковые грани.

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

3⃣Просуммировать все значения площадей для получения итоговой площади поверхности.

😎 Решение:
def surfaceArea(grid):
n = len(grid)
area = 0
for i in range(n):
for j in range(n):
if grid[i][j] > 0:
area += (grid[i][j] * 4) + 2
if i > 0:
area -= min(grid[i][j], grid[i-1][j]) * 2
if j > 0:
area -= min(gri

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

849

Python | LeetCode

6 апр. 2026 г., 21:54

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

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

Формат пути - это одна или несколько конкатенированных строк в форме: /, за которой следует одна или несколько строчных английских букв. Например, "/leetcode" и "/leetcode/problems" - допустимые пути, в то время как пустая строка "" и "/" не допустимы.

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

- bool createPath(string path, int value) создает новый путь и связывает с ним значение, если это возможно, и возвращает true. Возвращает false, если путь уже существует или его родительский путь не существует.
- int get(string path) возвращает значение, связанное с путем, или возвращает -1, если путь не существует.

Пример:
Input:
["FileSystem","createPath","get"]
[[],["/a",1],["/a"]]
Output:
[null,true,1]
Explanation:
FileSystem fileSystem = new FileSystem();

fileSystem.createPath("/a", 1); // return true
fileSystem.get("/a"); // return 1

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

1⃣Инициализируйте словарь или HashMap под названием paths, который будет использовать ключ в виде пути, переданного в нашу функцию create, и значение, переданное этой функции.

2⃣Для функции create выполняем три шага. Сначала выполняем базовую проверку валидности пути. Проверяем, является ли путь пустым, "/" или если путь уже существует в нашем словаре. Если любое из этих условий выполнено, просто возвращаем false. Затем получаем родительский путь предоставленного пути и проверяем его наличие в словаре. Если родительский путь не существует, возвращаем false, иначе продолжаем.

3⃣Наконец, вставляем предоставленный путь и значение в словарь и возвращаем true. Для функции get просто возвращаем значение по умолчанию -1, если путь не существует в словаре. В противном случае возвращаем фактическое значение.

😎 Решение:
class FileSystem:

def __init__(self):
self.paths = {}

def createPath(self, path: str, value: int) -> bool:
if not path or (len(path) == 1 and path == "/") or path in self.paths:
return False

delim_index = path.rfind("/")
parent = path[:delim_index]

if len(parent) > 1 and parent not in self.paths:
return False

self.paths[path] = value
return True

def get(self, path: str) -> int:
return self.paths.get(path, -1)

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

Python | LeetCode

6 апр. 2026 г., 01:49

Задача: https://leetcode.com/problems/minimum-size-subarray-sum/ https://leetcode.com/problems/hand-of-straights/description/
Сложность: 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.

😎 Решение:
from collections import Counter

class Solution:
def isNStraightHand(self, hand: List[int], groupSize: int) -> bool:
if len(hand) % groupSize != 0:
return False

cardCount = Counter(hand)
for card in sorted(hand):
if cardCount[card] == 0:
continue

for nextCard in range(card, card + groupSize):
if cardCount[nextCard] == 0:
return False
cardCount[nextCard] -= 1

return True

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

Python | LeetCode

6 апр. 2026 г., 01:49

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

Сообщение, содержащее буквы от A до Z, можно закодировать в числа с использованием следующего соответствия:
- 'A' -> "1"
- 'B' -> "2"
- ...
- 'Z' -> "26"
Для декодирования закодированного сообщения все цифры должны быть сгруппированы и затем отображены обратно в буквы с использованием обратного соответствия (существует несколько способов). Например, "11106" можно представить как:
- "AAJF" с группировкой (1 1 10 6)
- "KJF" с группировкой (11 10 6)
Обратите внимание, что группировка (1 11 06) недопустима, потому что "06" не может быть преобразовано в 'F', так как "6" отличается от "06". Для данной строки s, содержащей только цифры, верните количество способов декодирования. Тестовые случаи сформированы таким образом, что ответ укладывается в 32-битное целое число.

Пример:
Input: s = "12"
Output: 2
Explanation: "12" could be decoded as "AB" (1 2) or "L" (12).

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

1️⃣Входим в рекурсию с данной строкой, начиная с индекса 0.

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

3️⃣Мемоизация помогает снизить сложность, которая иначе была бы экспоненциальной. Мы проверяем словарь memo, чтобы увидеть, существует ли уже результат для данной подстроки. Если результат уже находится в memo, мы возвращаем этот результат. В противном случае количество способов для данной строки определяется путем рекурсивного вызова функции с индексом +1 для следующей подстроки и индексом +2 после проверки на валидность двузначного декодирования. Результат также сохраняется в memo с ключом как текущий индекс, чтобы сохранить его для будущих пересекающихся подзадач.

😎 Решение:
class Solution(object):
def valid(self, s, start, length):
return length == 1 or (
s[start] != "0"
and (length < 3 or s[start : start + length] <= "255")
)

def helper(self, s, startIndex, dots, ans):
remainingLength = len(s) - startIndex
remainingNumberOfIntegers = 4 - len(dots)
if (
remainingLength > remainingNumberOfIntegers * 3
or remainingLength < remainingNumberOfIntegers
):
return
if len(dots) == 3:
if self.valid(s, startIndex, remainingLength):
temp = ""
last = 0
for dot in dots:
temp += s[last : last + dot] + "."
last += dot
temp += s[startIndex:]
ans.append(temp)
return
for curPos in range(1, min(4, remainingLength + 1)):
dots.append(curPos)
if self.valid(s, startIndex, curPos):
self.helper(s, startIndex + curPos, dots, ans)
dots.pop()

def restoreIpAddresses(self, s):
answer = []
self.helper(s, 0, [], answer)
return answer

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

Python | LeetCode

6 апр. 2026 г., 01:49

Задача: https://leetcode.com/problems/minimum-size-subarray-sum/ https://leetcode.com/problems/smallest-string-with-a-given-numeric-value/description/
Сложность: medium

Числовое значение строчной буквы определяется ее позицией (начиная с 1) в алфавите, поэтому числовое значение a равно 1, числовое значение b равно 2, числовое значение c равно 3 и так далее.

Числовое значение строки, состоящей из строчных букв, определяется как сумма числовых значений ее символов. Например, числовое значение строки "abe" равно 1 + 2 + 5 = 8.

Вам даны два целых числа n и k. Верните лексикографически наименьшую строку длиной n с числовым значением, равным k.

Обратите внимание, что строка x лексикографически меньше строки y, если x идет перед y в словарном порядке, то есть либо x является префиксом y, либо, если i - первая позиция, где x[i] != y[i], то x[i] идет перед y[i] в алфавитном порядке.

Пример:
Input: n = 3, k = 27
Output: "aay"
Explanation: The numeric value of the string is 1 + 1 + 25 = 27, and it is the smallest string with such a value and length equal to 3.

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

1⃣Построить строку или массив символов result для хранения выбранных символов для каждой позиции.

2⃣Итерация от позиции 1 до n и заполнение символом каждой позиции:
Найти позиции, которые нужно заполнить, исключая текущую позицию, задаваемую переменной positionsLeft как n - position - 1.
Если значение k больше, чем positionsLeft * 26, зарезервировать числовое значение 26 (символ z) для всех оставшихся позиций positionsLeft. Вычислить значение текущей позиции, заданное переменной add, как k - (positionsLeft * 26). Вычесть рассчитанное значение add из k, чтобы найти оставшееся значение k после заполнения текущей позиции.
Иначе, заполнить текущую позицию символом a, имеющим числовое значение 1. Вычесть 1 из k, чтобы найти оставшееся значение k после заполнения текущей позиции.

3⃣Повторять процесс, пока все позиции не будут заполнены.

😎 Решение:
class Solution:
def getSmallestString(self, n: int, k: int) -> str:
result = ['a'] * n

for position in range(n):
positionsLeft = (n - position - 1)
if k > positionsLeft * 26:
add = k - (positionsLeft * 26)
result[position] = chr(ord('a') + add - 1)
k -= add
else:
k -= 1

return ''.join(result

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

Showing 27 of 27 posts

No more posts

Рейтинг

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

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

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

Python | LeetCode

Python | LeetCode

Рейтинг

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

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

Рейтинг

Отзывы пользователей (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)

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