Python | LeetCode

#medium Задача: 322. Coin Change Дан целочисленный массив coins, представляющий монеты разных номиналов, и целое число amount, представляющее общую сумму денег. Верните минимальное количество монет, необходимых для составления этой суммы. Если эту сумму невозможно составить с помощью комбинации монет, верните -1. Вы можете предположить, что у вас есть неограниченное количество монет каждого типа. Пример:

Input: coins = [1,2,5], amount = 11
Output: 3
Explanation: 11 = 5 + 5 + 1

👨‍💻 Алгоритм: 1⃣Инициализация и вызов функции backtracking Инициализируйте переменные для хранения минимального количества монет и вызовите функцию backtracking с начальными параметрами. 2⃣Функция backtracking Внутри функции backtracking для каждой монеты из массива coins: Проверьте все возможные количества монет данного номинала (от 0 до максимального количества, которое можно использовать без превышения amount). Для каждой комбинации монет обновите сумму и вызовите функцию рекурсивно для проверки оставшейся суммы. Если текущая комбинация дает меньшую сумму монет, обновите минимальное количество монет. 3⃣Возврат результата Если комбинация, дающая сумму amount, найдена, верните минимальное количество монет, иначе верните -1. 😎 Решение:

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        return self._coinChange(0, coins, amount)

    def _coinChange(self, idxCoin: int, coins: List[int], amount: int) -> int:
        if amount == 0:
            return 0
        if idxCoin < len(coins) and amount > 0:
            maxVal = amount // coins[idxCoin]
            minCost = float('inf')
            for x in range(maxVal + 1):
                if amount >= x * coins[idxCoin]:
                    res = self._coinChange(idxCoin + 1, coins, amount - x * coins[idxCoin])
                    if res != -1:
                        minCost = min(minCost, res + x)
            return -1 if minCost == float('inf') else minCost
        return -1

Ставь 👍 и забирай 📚 Базу знаний

5 причин, почему вам нужен Битрикс24 Мессенджер + AI 1) Ничего личного. Никаких Алена-ноготочки и любимая жена 2) Только рабочее. Общение с коллегами в чатах, каналах и тредах. 3) Слова становятся делами. Задачи и встречи ставятся прямо из переписки в чате. 4) Синки. Мгновенные видеоколлы до 100 человек из чата в один клик. 5) Нейросеть. Можно прямо в групповом чате штурмить идеи с AI-помощником. А, последняя причина – пользоваться можно бесплатно. Забирайте бесплатный мессенджер для работы компании — Битрикс24 Попробовать #реклама 16+ bitrix24.ru О рекламодателе

#easy Задача: 543. Diameter of Binary Tree Учитывая корень бинарного дерева, вернуть длину диаметра дерева. Диаметр бинарного дерева — это длина самого длинного пути между любыми двумя узлами в дереве. Этот путь может проходить или не проходить через корень. Длина пути между двумя узлами представлена числом ребер между ними. Пример:

Input: root = [1,2]
Output: 1

👨‍💻 Алгоритм: 1⃣Инициализируйте целочисленную переменную diameter для отслеживания самого длинного пути, найденного с помощью DFS. 2⃣Реализуйте рекурсивную функцию longestPath, которая принимает TreeNode в качестве входных данных и рекурсивно исследует дерево: Если узел равен None, вернуть 0. Рекурсивно исследовать левые и правые дочерние узлы, возвращая длины путей leftPath и rightPath. Если сумма leftPath и rightPath больше текущего diameter, обновить diameter. Вернуть большее из leftPath и rightPath плюс 1. 3⃣Вызвать longestPath с root. 😎 Решение:

class Solution:
    def __init__(self):
        self.diameter = 0
        
    def diameterOfBinaryTree(self, root):
        self.diameter = 0
        self.longestPath(root)
        return self.diameter
    
    def longestPath(self, node):
        if not node:
            return 0
        
        leftPath = self.longestPath(node.left)
        rightPath = self.longestPath(node.right)
        
        self.diameter = max(self.diameter, leftPath + rightPath)
        
        return max(leftPath, rightPath) + 1

Ставь 👍 и забирай 📚 Базу знаний

#easy Задача: 405. Convert a Number to Hexadecimal Если задано целое число num, верните строку, представляющую его шестнадцатеричное представление. Для отрицательных целых чисел используется метод дополнения до двух. Все буквы в строке ответа должны быть строчными, и в ответе не должно быть никаких ведущих нулей, кроме самого нуля. Примечание: Вам не разрешается использовать какие-либо встроенные библиотечные методы для непосредственного решения этой задачи. Пример:

Input: num = 26
Output: "1a"

👨‍💻 Алгоритм: 1⃣Определите, является ли число отрицательным. Если да, преобразуйте его в положительное число с помощью метода дополнения до двух. Для этого прибавьте к числу 2^32 и используйте битовую операцию И с маской 0xFFFFFFFF. 2⃣Создайте строку с шестнадцатеричными символами. Последовательно делите число на 16 и добавляйте соответствующий символ к результату, пока число не станет равным нулю. 3⃣Переверните строку результата и удалите ведущие нули, если они есть. Если строка пустая, верните "0". 😎 Решение:

def to_hex(num):
    if num == 0:
        return "0"
    hex_chars = "0123456789abcdef"
    if num < 0:
        num += 2 ** 32
    result = []
    while num > 0:
        result.append(hex_chars[num % 16])
        num //= 16
    return ''.join(result[::-1])

Ставь 👍 и забирай 📚 Базу знаний

Запустите рекламу в телеграм-каналах с Яндекс Директом Перфоманс-реклама теперь в телеграм-каналах ⚡ Яндекс Директ знает, как привлечь целевую аудиторию 💰👌 Попробовать #реклама yandex.ru О рекламодателе

#medium Задача: 320. Generalized Abbreviation Обобщенная аббревиатура слова может быть построена путем замены любых неперекрывающихся и несмежных подстрок на их соответствующие длины. Например, "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

Ставь 👍 и забирай 📚 Базу знаний

#medium Задача: 319. Bulb Switcher Есть n лампочек, которые изначально выключены. Сначала вы включаете все лампочки, затем выключаете каждую вторую лампочку. На третьем раунде вы переключаете каждую третью лампочку (включаете, если она выключена, или выключаете, если она включена). На i-ом раунде вы переключаете каждую i-ую лампочку. На n-ом раунде вы переключаете только последнюю лампочку. Верните количество лампочек, которые будут включены после n раундов. Пример:

Input: n = 3
Output: 1
Explanation: At first, the three bulbs are [off, off, off].
After the first round, the three bulbs are [on, on, on].
After the second round, the three bulbs are [on, off, on].
After the third round, the three bulbs are [on, off, off]. 
So you should return 1 because there is only one bulb is on.
Explanation: The two words can be "abcw", "xtfn".

👨‍💻 Алгоритм: 1⃣Инициализация Лампочка остается включенной, если она переключалась нечетное количество раз. Лампочка будет переключаться на каждом делителе её номера. 2⃣Определение состояния лампочки Лампочка останется включенной только в том случае, если у нее нечетное количество делителей, что возможно только для квадратных чисел. 3⃣Подсчет включенных лампочек Количество лампочек, которые будут включены после n раундов. 😎 Решение:

class Solution:
    def bulbSwitch(self, n: int) -> int:
        return int(n ** 0.5)

Ставь 👍 и забирай 📚 Базу знаний

#medium Задача: 318. Maximum Product of Word Lengths Дан массив строк words, верните максимальное значение произведения длины word[i] на длину word[j], где два слова не имеют общих букв. Если таких двух слов не существует, верните 0. Пример:

Input: words = ["abcw","baz","foo","bar","xtfn","abcdef"]
Output: 16
Explanation: The two words can be "abcw", "xtfn".

👨‍💻 Алгоритм: 1⃣Предварительная обработка масок и длин Вычислите битовые маски для всех слов и сохраните их в массиве masks. Сохраните длины всех слов в массиве lens. 2⃣Сравнение слов и проверка общих букв Сравните каждое слово с каждым последующим словом. Если два слова не имеют общих букв (проверка с использованием масок: (masks[i] & masks[j]) == 0), обновите максимальное произведение maxProd. 3⃣Возврат результата Верните максимальное значение произведения maxProd. 😎 Решение:

class Solution:
    def maxProduct(self, words: List[str]) -> int:
        n = len(words)
        masks = [0] * n
        lens = [0] * n
        bit_number = lambda ch : ord(ch) - ord('a')
        
        for i in range(n):
            bitmask = 0
            for ch in words[i]:
                bitmask |= 1 << bit_number(ch)
            masks[i] = bitmask
            lens[i] = len(words[i])
            
        max_val = 0
        for i in range(n):
            for j in range(i + 1, n):
                if masks[i] & masks[j] == 0:
                    max_val = max(max_val, lens[i] * lens[j])
        return max_val

Ставь 👍 и забирай 📚 Базу знаний

Учишь Python, но как дело доходит до собственного кода — всё, кирдык? 😥 Знакомо! На форумах только одно: «Больше практиковаться!» А толку? Ноль понимания и никакой поддержки от профи… Плавали - знаем)) Поэтому специально для тебя - чат для Python-щиков 🤝 Что получишь? 1️⃣ Сможешь задавать любые вопросы без страха и осуждения и получать ответы за минуты, а не часы поиска в инете 2️⃣ Регулярные плюшки в виде стримов от препода с 15-ти летним опытом 3️⃣ Общение с единомышленниками и заряд мотивации ➡️ А еще, забирай в закрепе БЕСПЛАТНЫЙ вводный курс по Python Короче, всё для прокачки! Залетай к нам — ссылка на чат (тык)

#hard Задача: 317. Shortest Distance from All Buildings Дана сетка m x n, содержащая значения 0, 1 или 2, где: каждое 0 обозначает пустую землю, по которой можно свободно проходить, каждое 1 обозначает здание, через которое нельзя пройти, каждое 2 обозначает препятствие, через которое нельзя пройти. Вы хотите построить дом на пустой земле, чтобы он достиг всех зданий с минимальным суммарным расстоянием. Можно перемещаться только вверх, вниз, влево и вправо. Верните минимальное суммарное расстояние для такого дома. Если построить такой дом невозможно согласно указанным правилам, верните -1. Суммарное расстояние — это сумма расстояний между домами друзей и точкой встречи. Пример:

Input: grid = [[1,0,2,0,1],[0,0,0,0,0],[0,0,1,0,0]]
Output: 7

👨‍💻 Алгоритм: 1⃣Инициализация и запуск BFS Для каждой пустой ячейки (0) в сетке grid запустите BFS, обходя все соседние ячейки в 4 направлениях, которые не заблокированы и не посещены, отслеживая расстояние от начальной ячейки. 2⃣Обработка BFS и обновление расстояний При достижении здания (1) увеличьте счетчик достигнутых домов housesReached и суммарное расстояние distanceSum на текущее расстояние. Если housesReached равно общему количеству зданий, верните суммарное расстояние. Если BFS не может достигнуть всех домов, установите значение каждой посещенной пустой ячейки в 2, чтобы не запускать новый BFS из этих ячеек, и верните INT_MAX. 3⃣Обновление и возврат минимального расстояния Обновите минимальное расстояние (minDistance) после каждого вызова BFS. Если возможно достигнуть все дома из любой пустой ячейки, верните найденное минимальное расстояние. В противном случае, верните -1. 😎 Решение:

from collections import deque

class Solution:
    def bfs(self, grid, row, col, totalHouses):
        directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
        rows, cols = len(grid), len(grid[0])
        distanceSum, housesReached = 0, 0
        q = deque([(row, col)])
        visited = [[False] * cols for _ in range(rows)]
        visited[row][col] = True
        steps = 0

        while q and housesReached != totalHouses:
            for _ in range(len(q)):
                r, c = q.popleft()
                if grid[r][c] == 1:
                    distanceSum += steps
                    housesReached += 1
                    continue

                for dr, dc in directions:
                    nr, nc = r + dr, c + dc
                    if 0 <= nr < rows and 0 <= nc < cols and not visited[nr][nc] and grid[nr][nc] != 2:
                        visited[nr][nc] = True
                        q.append((nr, nc))
            steps += 1

        if housesReached != totalHouses:
            for r in range(rows):
                for c in range(cols):
                    if grid[r][c] == 0 and visited[r][c]:
                        grid[r][c] = 2
            return float('inf')

        return distanceSum

    def shortestDistance(self, grid):
        rows, cols = len(grid), len(grid[0])
        minDistance, totalHouses = float('inf'), 0

        for r in range(rows):
            for c in range(cols):
                if grid[r][c] == 1:
                    totalHouses += 1

        for r in range(rows):
            for c in range(cols):
                if grid[r][c] == 0:
                    minDistance = min(minDistance, self.bfs(grid, r, c, totalHouses))

        return -1 if minDistance == float('inf') else minDistance

Ставь 👍 и забирай 📚 Базу знаний

Помощь в трудоустройстве в IT-сфере! В России из-за дефицита айтишников запустили бесплатную программу по обучению IT-специалистов. Теперь любой желающий может попробовать себя в IT с полного нуля и начать обучение бесплатно! Узнайте про дальнейшее трудоустройство в ведущие IT-компании для восполнения кадрового дефицита. Для этого нужно: - Перейти по ссылке - Заполнить анкету и ответить на вопросы (занимает менее 3 минут) - На основании ваших ответов вы сразу узнаете, подходит ли вам сфера IT и сможете ли вы в ней работать Перейти на сайт #реклама 16+ urban-university.ru О рекламодателе

#medium Задача: 316. Remove Duplicate Letters Дана строка s, удалите повторяющиеся буквы так, чтобы каждая буква появилась один раз и только один раз. Вы должны сделать так, чтобы результат был наименьшим в лексикографическом порядке среди всех возможных результатов. Пример:

Input: s = "bcabc"
Output: "abc"

👨‍💻 Алгоритм: 1⃣Инициализация стека Создайте стек, который будет хранить результат, построенный по мере итерации строки. 2⃣Итерация по строке На каждой итерации добавляйте текущий символ в стек, если он еще не был использован. Перед добавлением текущего символа удаляйте как можно больше символов из вершины стека, если это возможно и улучшает лексикографический порядок. 3⃣Удаление символов Удаляйте символы с вершины стека при выполнении следующих условий: Символ на вершине стека больше текущего символа. Символ может быть удален, так как он встречается позже в строке. На каждом этапе итерации по строке жадно минимизируйте содержимое стека. 😎 Решение:

class Solution:
    def removeDuplicateLetters(self, s) -> str:
        stack = []
        seen = set()
        last_occurrence = {c: i for i, c in enumerate(s)}

        for i, c in enumerate(s):
            if c not in seen:
                while stack and c < stack[-1] and i < last_occurrence[stack[-1]]:
                    seen.discard(stack.pop())
                seen.add(c)
                stack.append(c)
        return ''.join(stack)

Ставь 👍 и забирай 📚 Базу знаний

#easy Задача: 404. Sum of Left Leaves Если задан корень бинарного дерева, верните сумму всех левых листьев. Лист - это узел, не имеющий детей. Левый лист - это лист, который является левым ребенком другого узла. Пример:

Input: root = [3,9,20,null,null,15,7]
Output: 24

👨‍💻 Алгоритм: 1⃣Рекурсивный обход дерева Обходите дерево с помощью рекурсивной функции, которая принимает текущий узел и флаг, указывающий, является ли узел левым ребенком. 2⃣Проверка листьев Если текущий узел является листом и флаг указывает, что это левый ребенок, добавьте значение узла к сумме. 3⃣Рекурсивный вызов для детей Рекурсивно вызовите функцию для левого и правого детей текущего узла, передавая соответствующий флаг. 😎 Решение:

class Solution:
    def sumOfLeftLeaves(self, root: TreeNode) -> int:
        def dfs(node, is_left):
            if not node:
                return 0
            if not node.left and not node.right:
                return node.val if is_left else 0
            return dfs(node.left, True) + dfs(node.right, False)
        
        return dfs(root, False)

Ставь 👍 и забирай 📚 Базу знаний

Москвич 3 – надежно для вас и ваших увлечений Современный городской кроссовер Москвич 3. Ежемесячный платеж 17 500 рублей. Подробности уточняйте на официальном сайте moskvich.ru. Перейти на сайт Финансовые услуги оказывает: АО "Авто Финанс Банк", ПАО "Совкомбанк". #реклама moskvich.ru О рекламодателе

#hard Задача: 403. Frog Jump Если задана строка num, представляющая неотрицательное целое число num, и целое число k, верните наименьшее возможное целое число после удаления k цифр из num. Пример:

Input: stones = [0,1,3,5,6,8,12,17]
Output: true

👨‍💻 Алгоритм: 1⃣Инициализация и структура данных Создайте набор для хранения всех камней для быстрого доступа. Используйте динамическое программирование с помощью словаря для отслеживания достижимых позиций и возможных прыжков. 2⃣Итерация по камням Пройдитесь по каждому камню и для каждого возможного прыжка (k-1, k, k+1) проверьте, если он ведет на существующий камень. Если такой камень существует, добавьте его в набор возможных прыжков. 3⃣Проверка достижения последнего камня Если можно достичь последний камень с помощью одного из возможных прыжков, верните True. Если после всех итераций последний камень не достигнут, верните False.Формирование результата: Постройте итоговое число из цифр в стеке и удалите ведущие нули. 😎 Решение:

class Solution:
    def canCross(self, stones: List[int]) -> bool:
        stone_set = set(stones)
        dp = {stone: set() for stone in stones}
        dp[0].add(0)
        
        for stone in stones:
            for jump in dp[stone]:
                for step in range(jump-1, jump+2):
                    if step > 0 and stone + step in stone_set:
                        dp[stone + step].add(step)
        
        return bool(dp[stones[-1]])

Ставь 👍 и забирай 📚 Базу знаний

#medium Задача: 402. Remove K Digits Если задана строка num, представляющая неотрицательное целое число num, и целое число k, верните наименьшее возможное целое число после удаления k цифр из num. Пример:

Input: num = "1432219", k = 3
Output: "1219"

👨‍💻 Алгоритм: 1⃣Инициализация: Создайте стек для хранения цифр, которые будут образовывать минимальное число. 2⃣Обработка каждой цифры: Перебирайте каждую цифру в строке num. Если текущая цифра меньше верхней цифры в стеке и у вас есть еще возможность удалить цифры (k > 0), удалите верхнюю цифру из стека. Добавьте текущую цифру в стек. Удаление оставшихся цифр: Если после прохождения всей строки k еще больше нуля, удалите оставшиеся цифры из конца стека 3⃣Формирование результата: Постройте итоговое число из цифр в стеке и удалите ведущие нули. 😎 Решение:

class Solution:
    def removeKdigits(self, num: str, k: int) -> str:
        stack = []
        for digit in num:
            while k > 0 and stack and stack[-1] > digit:
                stack.pop()
                k -= 1
            stack.append(digit)
        final_stack = stack[:-k] if k else stack
        return ''.join(final_stack).lstrip('0') or '0'

Ставь 👍 и забирай 📚 Базу знаний

Новые бесплатные курсы в канале Selectel Newsfeed. Подойдут всем: от новичков до продвинутых айтишников. Вас ждут обзоры, инструкции и статьи, которые помогут разобраться в темах структурно и последовательно. Вступайте в сообщество IT-специалистов в Telegram от Selectel. Подписаться #реклама 16+ О рекламодателе

#easy Задача: 401. Binary Watch Бинарные часы имеют 4 светодиода сверху для представления часов (0-11) и 6 светодиодов снизу для представления минут (0-59). Каждый светодиод представляет ноль или единицу, при этом младший разряд находится справа. Пример:

Input: turnedOn = 1
Output: ["0:01","0:02","0:04","0:08","0:16","0:32","1:00","2:00","4:00","8:00"]

👨‍💻 Алгоритм: 1⃣Генерация всех возможных комбинаций: Переберите все возможные значения для часов и минут. Используйте битовые операции для подсчета количества единиц в бинарном представлении числа. 2⃣Проверка количества горящих светодиодов: Для каждой комбинации проверьте, соответствует ли сумма единиц в бинарном представлении часов и минут заданному количеству горящих светодиодов. 3⃣Форматирование результата: Если комбинация часов и минут соответствует условию, отформатируйте их в виде строки "часы:минуты" и добавьте в список результатов. 😎 Решение:

class Solution:
    def readBinaryWatch(self, turnedOn: int) -> List[str]:
        results = []
        for h in range(12):
            for m in range(60):
                if bin(h).count('1') + bin(m).count('1') == turnedOn:
                    results.append(f"{h}:{m:02d}")
        return results

Ставь 👍 и забирай 📚 Базу знаний

#medium Задача: 400. Nth Digit Дано целое число n, вернуть n-ю цифру бесконечной последовательности чисел [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]. Пример:

Input: n = 3
Output: 3

👨‍💻 Алгоритм: 1⃣Определение диапазона: Начните с определения количества цифр в числах текущего диапазона (1-9, 10-99, 100-999 и т.д.). Уменьшайте значение n, вычитая количество цифр в текущем диапазоне, пока не найдете диапазон, в который попадает n-я цифра. 2⃣Нахождение конкретного числа: Когда определите диапазон, найдите точное число, содержащее n-ю цифру. Определите индекс цифры в этом числе. 3⃣Возвращение n-й цифры: Извлеките и верните n-ю цифру из найденного числа. 😎 Решение:

class Solution:
    def findNthDigit(self, n: int) -> int:
        length = 1
        count = 9
        start = 1
        
        while n > length * count:
            n -= length * count
            length += 1
            count *= 10
            start *= 10
        
        start += (n - 1) // length
        s = str(start)
        return int(s[(n - 1) % length])

Ставь 👍 и забирай 📚 Базу знаний

Продажи на автопилоте: настройка триггерных цепочек Как создать триггерные цепочки, которые сами работают на увеличение ваших продаж? 4 декабря CEO REES46 Михаил Кечинов проведёт вебинар для маркетологов и владельцев интернет-магазинов. Он поделится практическими советами и кейсами, как эффективно использовать автоматизацию маркетинга для повышения выручки и лояльности клиентов. 📚 Что вас ждёт на вебинаре: - Какие триггеры работают лучше всего в 2024 году. - Как настроить автоматические цепочки писем и сообщений. - Как измерить эффективность триггерных кампаний. Бонус для всех участников: готовые шаблоны триггерных цепочек и чек-лист для их быстрого внедрения. 📅 Дата: 4 декабря 2024 года ⚡ Время: 19:00 по МСК Не упустите шанс вывести свой бизнес на новый уровень — зарегистрируйтесь на вебинар прямо сейчас! Зарегистрироваться #реклама 16+ rees46.ru О рекламодателе