Решайте задачи на Python0 из 90 задач решено
Перейти к задачам
8804 просмотра
От 27 июня

Подборка решений для задач с собеседований Python-разработчиков

1

Проверка на палиндром

Вы справитесь, если вам дадут эту задачу на собеседовании?
Решить задачу

Палиндром — это последовательность символов, которая одинаково читается в обоих направлениях. 1. Метод с использованием индексации Первый и самый простой способ проверить, является ли строка палиндромом, — использовать трюк с индексацией для получения «зеркальной» строки и сравнения её с исходной. s = "radar" if s == s[::-1]: print("Это палиндром") else: print("Это не палиндром") 2. Метод с использованием цикла Мы можем также использовать цикл для определения палиндрома, сравнивая символы на симметричных позициях. s = "radar" is_palindrome = True for i in range(len(s) // 2): if s[i] != s[-i - 1]: is_palindrome = False break if is_palindrome: print("Это палиндром") else: print("Это не палиндром") 3. Использование функции Проверку на палиндром можно также реализовать с помощью рекурсивной функции. def is_palindrome(s): if len(s) < 2: return True if s[0] != s[-1]: return False return is_palindrome(s[1:-1]) 4. Определение палиндрома с учетом пробелов и знаков препинания Если вы хотите проверить, является ли строка палиндромом, игнорируя пробелы, знаки препинания и регистр, вы можете использовать методы lower() и replace(), а также функцию isalnum() для удаления всех небуквенных символов. s = "A man, a plan, a canal: Panama" s = ''.join(c for c in s if c.isalnum()).lower() if s == s[::-1]: print("Это палиндром") else: print("Это не палиндром") 5. Использование стека Этот подход использует структуру данных «стек», чтобы сохранить первую половину строки и затем сравнить ее с обратной половиной. def is_palindrome(s): s = ''.join(c for c in s if c.isalnum()).lower() stack = list() for character in s: stack.append(character) for character in s: if character != stack.pop(): return False return True Алгоритмы для поиска палиндромов Алгоритм поиска самой длинной подстроки-палиндрома АТАТА: распутываем задачу про палиндром

2

Проверка на анаграмму

Вы справитесь, если вам дадут эту задачу на собеседовании?
Решить задачу

Анаграмма — это перестановка букв одного слова для получения нового слова. 1. Решение без оптимизации Для начала рассмотрим простейший способ. Для каждой строки мы создадим словарь, который будет хранить количество вхождений каждого символа. Затем мы сравним словари и выясним, являются ли строки анаграммами. Вот как может выглядеть код для реализации данного алгоритма: def is_anagram(str1, str2): # создаем словарь для первого слова dict1 = {} for char in str1: dict1[char] = dict1.get(char, 0) + 1 # создаем словарь для второго слова dict2 = {} for char in str2: dict2[char] = dict2.get(char, 0) + 1 # сравниваем словари return dict1 == dict2 На этом решение задачи поиска анаграмм без оптимизации можно считать выполненной. Однако этот алгоритм не оптимален. 2. Оптимизация алгоритма Можно заметить, что мы используем два словаря для каждого слова. Это может быть неэффективно, особенно, если слова достаточно длинные. Вместо хранения двух словарей мы можем использовать один словарь и удалять из него ключи, которые мы уже нашли. После этого мы снова сравниваем словари. Если они равны, значит слова являются анаграммами. Вот как может выглядеть оптимизированный код: def is_anagram(str1, str2): # создаем словарь для первого слова dict1 = {} for char in str1: dict1[char] = dict1.get(char, 0) + 1 # проверяем второе слово for char in str2: if char in dict1: dict1[char] -= 1 if dict1[char] == 0: del dict1[char] else: return False # если словарь пуст, значит слова являются анаграммами return not dict1 Теперь код выглядит более эффективно, но он все еще имеет недостатки. 3. Более сложная оптимизация Работа с словарями может быть медленной, особенно если слова достаточно длинные. Мы можем использовать более продвинутые алгоритмы, чтобы ускорить этот процесс. Один из таких алгоритмов — это использование массивов. Мы можем создать два массива фиксированной длины, которые будут хранить количество букв в каждом слове. Затем мы можем проходить по каждой букве в обоих словах и увеличивать счетчики в массиве. По завершении прохода мы можем сравнить массивы. Если они равны, значит слова являются анаграммами. Вот как может выглядеть код для этого алгоритма: def is_anagram(str1, str2): # создаем массивы count1 = [0] * 26 count2 = [0] * 26 # заполняем массивы for char in str1: index = ord(char) - ord('a') count1[index] += 1 for char in str2: index = ord(char) - ord('a') count2[index] += 1 # сравниваем массивы return count1 == count2 Поиск анаграмм и сабанаграмм во всех словах языка

3

Сжатие строки (rle)

Вы справитесь, если вам дадут эту задачу на собеседовании?
Решить задачу

Задача: Необходимо реализовать функцию, принимающую в аргументах строку, состоящую из букв, и возвращающую новую строку, в которой повторяющиеся буквы заменены количеством повторений. # AAAABBCAA --> A4B2C1A2 Решение: def encode_message(message): encoded_string = "" i = 0 while (i <= len(message)-1): count = 1 ch = message[i] j = i while (j < len(message)-1): if (message[j] == message[j + 1]): count = count + 1 j = j + 1 else: break encoded_string = encoded_string + str(count) + ch i = j + 1 return encoded_string Приведенный фрагмент содержит функцию encode_message() с параметром message (строка), подлежащим кодированию. Переменная encoded_string используется для хранения закодированной строки. Цикл while инициализируется с счетчиком с значением 1 и итерируется по всем символам строки. Внутренний цикл while проверяет, совпадает ли символ текущего индекса с символом следующего индекса. Если символы совпадают, то счётчик инкрементируется. Если нет, то счетчик и символ конкатенируются в переменную encoded_string и возвращаются. Алгоритм имеет сложность O (n). Также можно воспользоваться функцией groupby из модуля itertools. Она превратит последовательность элементов в последовательность групп повторяющихся символов. from itertools import groupby def rle_encode(data: str) -> str: return "".join(str(len(list(group_items))) + key for key, group_items in groupby(data)) Простейшие алгоритмы сжатия: RLE и LZ77

4

Подсчёт гласных в строке

Вы справитесь, если вам дадут эту задачу на собеседовании?
Решить задачу

Первый способ — использование цикла for string = "Привет, мир!" count = 0 for char in string: if char in "аеёиоуыэюяАЕЁИОУЫЭЮЯ": count += 1 print("Количество гласных букв:", count) #Количество гласных букв: 3 Второй способ — использование метода count() # Введите строку input_string = "Пример строки на русском языке" # Преобразуем строку к нижнему регистру, чтобы учитывать гласные в верхнем и нижнем регистре input_string = input_string.lower() # Определите гласные для русского языка vowels = "аеёиоуыэюя" # Используйте sum() и count() для подсчета количества каждой гласной vowel_count = sum(input_string.count(vowel) for vowel in vowels) # Выведите результат print(f"Количество гласных в строке: {vowel_count}") #Количество гласных в строке: 10 Третий способ — использование регулярных выражений import re string = "Привет, мир!" count = len(re.findall("[аеёиоуыэюяАЕЁИОУЫЭЮЯ]", string)) print("Количество гласных букв:", count) #Количество гласных букв: 3 Четвертый способ — использование генераторов списков string = "Привет, мир!" vowels = [char for char in string if char in "аеёиоуыэюяАЕЁИОУЫЭЮЯ"] count = len(vowels) print("Количество гласных букв:", count) #Количество гласных букв: 3

5

Бинарный поиск

Бинарный поиск — это алгоритм, используемый для поиска элемента в отсортированном массиве путем многократного деления интервала поиска пополам. Принцип алгоритма бинарного поиска очень прост. Мы всегда имеем дело с упорядоченным массивом. Это позволяет прибегать к хитрости - на каждой итерации цикла, который мы запускаем, мы вычисляем индекс среднего элемента. Этот элемент сравниваем с искомым. Если элемент из середины массива оказался меньше, чем тот, что мы ищем, значит нужный нам находится правее по массиву, ведь массив упорядочен. Соответственно, нам нужно перейти в следующую итерацию цикла, "оставляя" ей лишь правую часть массива - в ней снова будет найден средний элемент и алгоритм повторится. Если же элемент из середины массива оказался больше искомого, то мы переходим к следующей итерации, отбрасывая правую часть массива, а оставляя левую. Если же элемент совпадает с искомым, мы выходим из цикла. def BinarySearch(lys, val): first = 0 last = len(lys)-1 index = -1 while (first <= last) and (index == -1): mid = (first+last)//2 if lys[mid] == val: index = mid else: if val<lys[mid]: last = mid -1 else: first = mid +1 return index Также, вместо цикла мы могли бы обратиться к рекурсии. Я не могу написать бинарный поиск

6

Проверка симметричности двоичного дерева

Постановка: Напишите функцию для проверки симметричности двоичного дерева. Примеры деревьев: Дерево 1: 1 / \ / \ 2 2 / \ / \ 3 4 4 3 Дерево 2: 1 / \ / \ 2 2 / \ / \ 3 5 6 3 Дерево 3: 1 / \ / \ 2 2 / \ 5 5 Первое и третье деревья симметричны, а второе – нет. Решение: В соответствии с условием симметричным деревом считается дерево, которое симметрично и с точки зрения структуры, и с точки зрения значений узлов. Чтобы проверить дерево на симметричность, можно создать его зеркальное отражение и сравнить его с оригиналом. Временная и пространственная сложность такого алгоритма – O(n), где n – число узлов. Проверку можно оптимизировать, если вместо создания отражения целого дерева сравнивать пары поддеревьев – временная сложность такого подхода O(n), а пространственная – O(h), где h – высота дерева: def is_tree_symmetric(tree): def check_symmetric(subtree_0, subtree_1): if not subtree_0 and not subtree_1: return True elif subtree_0 and subtree_1: return (subtree_0.data == subtree_1.data and check_symmetric(subtree_0.left, subtree_1.right) and check_symmetric(subtree_0.right, subtree_1.left)) return False return not tree or check_symmetric(tree.left, tree.right) Пример использования с заданными в условии деревьями: from collections import namedtuple Node = namedtuple('Node', ['data', 'left', 'right']) tree1 = Node(1, Node(2, Node(3, None, None), Node(4, None, None)), Node(2, Node(4, None, None), Node(3, None, None))) tree2 = Node(1, Node(2, Node(3, None, None), Node(5, None, None)), Node(2, Node(6, None, None), Node(3, None, None))) tree3 = Node(1, Node(2, Node(5, None, None), None), Node(2, None, Node(5, None, None))) for t in [tree1, tree2, tree3]: print(is_tree_symmetric(t)) Вывод: True False True Структуры данных: бинарные деревья. Часть 1 Бинарные деревья поиска и рекурсия – это просто

7

Метод двух указателей

Метод двух указателей является эффективным подходом для решения ряда задач на Python и не только. Он заключается в использовании двух указателей, которые движутся по структуре данных в разных направлениях или с разной скоростью. Одним из классических примеров использования метода двух указателей является задача о нахождении пары чисел в упорядоченном массиве, сумма которых равна заданному числу. Для её решения можно использовать следующий алгоритм: left, right = 0, len(nums) - 1 while left < right: if nums[left] + nums[right] == target: return [left + 1, right + 1] elif nums[left] + nums[right] < target: left += 1 else: right -= 1 В этом примере указатели left и right сначала указывают на крайние элементы массива, а затем двигаются в стороны, пока не будет найдена пара, сумма элементов которой равна заданному числу. Если сумма элементов меньше искомого числа, то left увеличивается на 1, иначе уменьшается на 1. Если указатели встречаются, значит, решение не найдено, и можно вернуть None или другой флаг. Кроме этой задачи, метод двух указателей может быть применен, например, для поиска подстроки в строке или для проверки, является ли строка палиндромом.

8

Мемоизация и факториал

Вы справитесь, если вам дадут эту задачу на собеседовании?
Решить задачу

Мемоизация - это метод, используемый для хранения результатов предыдущих вызовов функций для ускорения будущих вычислений. Если повторные вызовы функций выполняются с одинаковыми параметрами, мы можем сохранить предыдущие значения вместо повторения ненужных вычислений. Пример будет базироваться на применении мемоизации для оптимизиации вычисления факториала. Рекурсивная функция, вычисляющая факториал, может выглядеть так: def factorial(input_value): if input_value < 2: return 1 elif input_value >= 2: return input_value * factorial(input_value - 1) Теперь попробуем многократно воспользоваться этой функцией с помощью цикла: for i in range(1, 11): print(f"{i}! = ", factorial(i)) Функция отрабатывает замечательно, но если мы увеличим количество итераций цикла до 5000, то выполнение скрипта прервётся с ошибкой "RecursionError: maximum recursion depth exceeded in comparison". Это происходит потому, что чем больше переданное в функцию число, тем большее количество операций ей необходимо совершить. При этом, на каждой итерации мы заново вычисляем факториал для значений, расчёт которых уже происходил на предшествующих итерациях. Здесь-то и нужна мемоизация, чтобы обеспечить трату ресурсов только на те вычисления, которые еще не производились. Теперь давайте пройдемся по этапам реализации метода мемоизации. Чтобы продолжить, давайте инициализируем словарь: factorial_dict = {} Далее мы определим нашу функцию с применением мемоизации. Сначала мы проверяем, меньше ли введенное значение 2, и возвращаем 1, если это так: def factorial_memo(input_value): if input_value < 2: return 1 Затем мы проверяем, есть ли входное значение в словаре. Если это не так, мы сохраняем значение факториала в словаре и возвращаем значение для ключа ввода. Полная функция выглядит так: def factorial_memo(input_value): if input_value < 2: return 1 if input_value not in factorial_dict: factorial_dict[input_value] = input_value * factorial_memo(input_value - 1) return factorial_dict[input_value] Эта функция уже способна осилить наш цикл в 5000 итераций, но мы могли бы поступить иначе. А именно, импортировать декоратор из модуля functools, называемого lru_cache, который позволяет нам кэшировать наши значения. Мы можем достичь той же производительности, что и с нашим методом factorial_memo, используя этот декоратор: from functools import lru_cache @lru_cache(maxsize = 1000) def factorial(input_value): if input_value < 2: return 1 elif input_value >= 2: return input_value * factorial(input_value - 1) Алгоритмы быстрого вычисления факториала

9

Последовательность Фибоначчи

Вы справитесь, если вам дадут эту задачу на собеседовании?
Решить задачу

Классическая задача, которую можно встретить на собеседованиях самого разного уровня. Стоит напомнить, что последовательность Фибоначчи — это ряд чисел, где каждое последующее является суммой двух предыдущих. Так, первые десять чисел выглядят следующим образом: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34. Замкнутая формула from __future__ import division import math def fib(n): SQRT5 = math.sqrt(5) PHI = (SQRT5 + 1) / 2 return int(PHI ** n / SQRT5 + 0.5) Плюсы: - Быстро и просто для малых n Минусы: - Требуются операции с плавающей запятой, для больших n потребуется большая точность - Использование комплексных чисел для вычисления Fn красиво с математической точки зрения, но уродливо — с компьютерной Рекурсия fib = lambda n: fib(n - 1) + fib(n - 2) if n > 2 else 1 Плюсы: - Очень простая реализация, повторяющая математическое определение Минусы: - Экспоненциальное время выполнения, для больших n очень медленно - Переполнение стека Мемоизация M = {0: 0, 1: 1} def fib(n): if n in M: return M[n] M[n] = fib(n - 1) + fib(n - 2) return M[n] Плюсы: - Просто превратить рекурсию в решение с запоминанием; превращает экспоненциальное время выполнение в линейное, для чего тратит больше памяти Минусы: - Тратит много памяти - Возможно переполнение стека, как и у рекурсии Динамическое программирование def fib(n): a = 0 b = 1 for __ in range(n): a, b = b, a + b return a Плюсы: - Быстро работает для малых n, простой код Минусы: - Всё ещё линейное время выполнения Матричная алгебра def pow(x, n, I, mult): """ Возвращает x в степени n. Предполагает, что I – это единичная матрица, которая перемножается с mult, а n – положительное целое """ if n == 0: return I elif n == 1: return x else: y = pow(x, n // 2, I, mult) y = mult(y, y) if n % 2: y = mult(x, y) return y def identity_matrix(n): """Возвращает единичную матрицу n на n""" r = list(range(n)) return [[1 if i == j else 0 for i in r] for j in r] def matrix_multiply(A, B): BT = list(zip(*B)) return [[sum(a * b for a, b in zip(row_a, col_b)) for col_b in BT] for row_a in A] def fib(n): F = pow([[1, 1], [1, 0]], n, identity_matrix(2), matrix_multiply) return F[0][1] Плюсы: - Фиксированный объём памяти, логарифмическое время Минусы: - Код посложнее - Приходится работать с матрицами, хотя они не так уж и плохи Сравнение быстродействия Сравнивать стоит только вариант динамического программирования и матрицы. Если сравнивать их по количеству знаков в числе n, то получится, что матричное решение линейно, а решение с динамическим программированием – экспоненциально. Практический пример – вычисление fib(10 ** 6), числа, у которого будет больше двухсот тысяч знаков. n = 10 ** 6 Вычисляем fib_matrix: у fib(n) всего 208988 цифр, расчёт занял 0.24993 секунд. Вычисляем fib_dynamic: у fib(n) всего 208988 цифр, расчёт занял 11.83377 секунд. Фибоначчи на собеседовании Трюк из линейной алгебры для быстрого нахождения чисел Фибоначчи

10

Распаковка вложенных списков неопределенной глубины

Вы справитесь, если вам дадут эту задачу на собеседовании?
Решить задачу

Задача Напишите функцию flatten, которая будет принимать на вход список с любой вложенностью (список в списке), а возвращать список, где вложенные элементы всех уровней распакованы, то есть вложенное превращается в плоское. Варианты решения: Вариант 1: def flatten(array: Iterable) -> List: new_array = array[:] ind = 0 while True: try: while isinstance(new_array[ind], list): item = new_array.pop(ind) for inner_item in reversed(item): new_array.insert(ind, inner_item) ind += 1 except IndexError: break return new_array Вариант заключается в том, что мы копируем исходный список (чтобы не изменять его), а далее в цикле while проверяем, пока элемент является списком — проходимся по нему и инсёртим результат в самое начало. Алгоритм не оптимален т.к. каждый раз происходит переиндексирование (т.к. мы добавляем и удаляем из начала списка). Сложность данного алгоритма O(n^3*m) из-за перестройки списка дважды за каждую пройденную итерацию. Вариант 2: def flatten(data: Iterable) -> List: nested = True while nested: new = [] nested = False for i in data: if isinstance(i, list): new.extend(i) nested = True else: new.append(i) data = new return data Данный вариант заключается в том, что внутри цикла while nested идёт перебор по существующему списку с ключом nested = False, и, в случае, если ему хотя бы раз попался лист, он оставляет флаг nested = True и extend'ит этот лист в список. Соответственно, получается, что за каждый прогон он раскладывает один уровень вложенности. Сколько будет уровней вложенности — столько будет и проходов по циклу. Как видно из описания — не самый оптимальный алгоритм, но всё же, является отличным от остальных. Сложность данного алгоритма O(n*m). Вариант 3: def flatten(a: Iterable) -> List: queue, out = [a], [] while queue: elem = queue.pop(-1) if isinstance(elem, list): queue.extend(elem) else: out.append(elem) return out[::-1] Алгоритм является достаточно простым и чистым. Смысл его в том, чтобы в случае, если элемент - это список, мы добавляем результат в конец первоначального списка, а в случае, если нет — добавляем в вывод. Как результат — выводим перевёрнутый полученный результирующий плоский список, чтобы сохранить первоначальный порядок элементов. Сложность данного алгоритма O(n*m). Вариант 4: def recursive_flatten_iterator(arr: Iterable) -> Iterator: for i in arr: if isinstance(i, list): yield from recursion_flatten(i) else: yield i Наверное, самый распространённый вариант решения данной задачи — через рекурсию и yield from. Алгоритм кажется достаточно простым и эффективным, не считая того, что он сделан через рекурсию и, при больших вложенностях, может быть достаточно большой стек вызовов. Сложность данного алгоритма O(n*m). Вариант 5: def recursive_flatten_generator(array: Iterable) -> List: lst = [] for i in array: if isinstance(i, list): lst.extend(recursive_flatten_list(i)) else: lst.append(i) return lst Эта функция похожа на предыдущую, только выполнена не через итератор, а через рекурсивный extend/append механизм. Сложность данного алгоритма O(n*m). Вариант 6: def flatten(seq: Iterable) -> List: stack = [iter(seq)] new = [] while stack: i = stack.pop() try: while True: data = next(i) if isinstance(data, list): stack.append(i) i = iter(data) else: new.append(data) except StopIteration: pass return new Сложность данного алгоритма O(n*m). Распаковка вложенных списков неопределенной глубины

11

Каррирование и частичное применение

Каррирование — это преобразование функции от многих аргументов в набор функций, каждая из которых является функцией от одного аргумента. Мы можем передать часть аргументов в функцию и получить обратно функцию, ожидающую остальные аргументы. Создадим простую функцию greet, которая принимает в качестве аргументов приветствие и имя: def greet(greeting, name): print(greeting + ', ' + name) Небольшое улучшение позволит нам создать новую функцию для любого типа приветствия и передать этой новой функции имя: def greet_curried(greeting): def greet(name): print(greeting + ', ' + name) return greet greet_hello = greet_curried('Hello') greet_hello('German') greet_hello('Ivan') # или напрямую greet_curried greet_curried('Hi')('Roma') А дальше можно сделать это с любым количеством аргументов: def greet_deeply_curried(greeting): def w_separator(separator): def w_emphasis(emphasis): def w_name(name): print(greeting + separator + name + emphasis) return w_name return w_emphasis return w_separator greet = greet_deeply_curried("Hello")("...")(".") greet('German') greet('Ivan') Или вариант с lambda: greet_deeply_curried = lambda greeting: lambda separator: lambda emphasis: lambda name: \ print(greeting + separator + name + emphasis) Частичное применение - это процесс применения функции к части ее аргументов. Другими словами, функция, которая принимает функцию с несколькими параметрами и возвращает функцию с меньшим количеством параметров. Частичное применение преобразует функцию от n аргументов к (x-n), а каррирование создает n функций с 1 аргументом. Такая возможность есть у Python в стандартной библиотеке functools, это функция partial. from functools import partial def greet(greeting, separator, emphasis, name): print(greeting + separator + name + emphasis) newfunc = partial(greet, greeting='Hello', separator=',', emphasis='.') newfunc(name='German') newfunc(name='Ivan') newfunc2 = partial(greet, greeting='Hello', emphasis='.') newfunc2(name='German', separator='...') newfunc2(name='Ivan', separator='..') Еще один пример с partial, решает проблему замыкания в цикле: from functools import partial def makeActions(): acts = [] for i in range(5): def func(x, y): return x * y acts.append(partial(func, y=i)) # acts.append(partial(lambda x, y: x * y, y=i)) # через lambda # return [partial(lambda x, y: x * y, y=i) for i in range(5)] # через генератор списка return acts for act in makeActions(): print(act(1), end=', ') Мемоизация и каррирование (Python) Ненормальное функциональное программирование на python

12

FizzBuzz

Задача Напишите программу, печатающую числа от 1 до 100. Вместо чисел кратных трём, программа должна печатать 'Fizz'. Вместо чисел кратных пяти - 'Buzz'. Если число кратно и трём, и пяти, программа должна печатать 'FizzBuzz'. Решение Начнём со стандартного, классического решения: for i in range(1, 101): if i % 3 == 0 and i % 5 == 0: print('FizzBuzz') elif i % 3 == 0: print('Fizz') elif i % 5 == 0: print('Buzz') else: print(i) Укладываем стандартное решение в стандартный однострочник print('\n'.join('FizzBuzz' if i%3==0 and i%5==0 else 'Fizz' if i%3==0 else 'Buzz' if i%5==0 else str(i) for i in range(1, 101))) Избавляемся от join, приручаем print [print('FizzBuzz' if i%3==0 and i%5==0 else 'Fizz' if i%3==0 else 'Buzz' if i%5==0 else i) for i in range(1, 101)] Добавляем срез, укрощаем if else [print('FizzBuzz'[4 if i%3 else 0:4 if i%5 else 8] or i) for i in range(1, 101)] Оптимизируем срез, избавляемся от if else [print('FizzBuzz'[i*i%3*4:8--i**4%5] or i) for i in range(1, 101)] Сократили неплохо. Но, похоже с этой вариацией дальше не продвинуться. Пробуем иной вариант. Заменяем срез конкатенацией, вертаем оператор modulo [print('Fizz'*(i%3==0)+'Buzz'*(i%5==0) or i) for i in range(1, 101)] Оптимизируем решение. Выравниваем по длине со срезом [print((i%3<1)*'Fizz'+(i%5<1)*'Buzz' or i) for i in range(1, 101)] Уходим в отрыв. Модифицируем окончательный вариант [print(i%3//2*'Fizz'+i%5//4*'Buzz' or i+1) for i in range(100)] А что по скорости? # 2.53 msec print('\n'.join('FizzBuzz' if i%3==0 and i%5==0 else 'Fizz' if i%3==0 else 'Buzz' if i%5==0 else str(i) for i in range(1, 101))) # 8.11 msec [print('FizzBuzz' if i%3==0 and i%5==0 else 'Fizz' if i%3==0 else 'Buzz' if i%5==0 else i) for i in range(1, 101)] # 8.43 msec [print('FizzBuzz'[4 if i%3 else 0:4 if i%5 else 8] or i) for i in range(1, 101)] # 8.31 msec [print('FizzBuzz'[i*i%3*4:8--i**4%5] or i) for i in range(1, 101)] # 8.38 msec [print('Fizz'*(i%3==0)+'Buzz'*(i%5==0) or i) for i in range(1, 101)] # 8.4 msec [print((i%3<1)*'Fizz'+(i%5<1)*'Buzz' or i) for i in range(1, 101)] # 8.49 msec [print(i%3//2*'Fizz'+i%5//4*'Buzz' or i+1) for i in range(100)] Решение Fizzbuzz при помощи теоремы Эйлера Непайтоновый Пайтон

13

Удалить лишние пробелы

Вы справитесь, если вам дадут эту задачу на собеседовании?
Решить задачу

Задача В предложение были добавлены лишние пробелы. Напишите функцию, которая будет принимать такое предложение и возвращать его же в исправленном виде. Все слова должны быть разделены одним пробелом, а в начале и конце предложения пробелов быть не должно. Примеры correct_spacing("The film starts at midnight. ") # ➞ "The film starts at midnight." correct_spacing("The waves were crashing on the shore. ") # ➞ "The waves were crashing on the shore." correct_spacing(" Always look on the bright side of life.") # ➞ "Always look on the bright side of life." Вариант решения def correct_spacing(sentence): return ' '.join(sentence.split())

Логотип ДевстанцииАвторизуйтесь, чтобы просматривать следующий контент
15

Преобразование словаря в список

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
16

Проверить валидность скобок

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
17

Перевернуть каждое слово в предложении

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
18

Найти сумму двух чисел в массиве

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
19

Проверка на число Армстронга

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
20

Проверка на совершенное число

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
21

Найти среднее арифметическое списка чисел

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
22

Вывести первые N простых чисел

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
23

Найти НОК двух чисел

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
24

Найти НОД двух чисел

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
25

Перевести десятичное число в двоичное

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
26

Найти пересечение отрезков

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
27

Определить тип треугольника по длинам сторон

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
28

Определить, високосный ли год

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
29

Найти наименьшее из четырёх чисел

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
30

Проверка на арифметическую прогрессию

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
31

Пересчитать временной интервал в часы и минуты

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
32

Заполнение матрицы по спирали

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
33

Единственный выживший

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
34

Определение магического квадрата

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
35

Разделить список на подсписки

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
36

Ходы шахматного ферзя

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
37

Анонимное письмо

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
38

Кэш для операций над ISBN номерами

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
39

Гипотеза Коллатца

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
40

Решатель судоку

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
41

Интервалы занятости

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
42

Перевернуть число

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
43

Найти индекс первого вхождения

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
44

Алгоритм вычисления расстояния Дамерау-Левенштейна

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
45

Самый длинный палиндром

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
46

Параметры запроса

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
47

Сумма индексов элемента

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
48

Подсчет количества слов

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
49

Число словами

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
50

Первый уникальный символ

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
51

Сумма элементов списка

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
52

Уникальность элементов

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
53

Координатные четверти

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
54

Наибольший общий префикс

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
55

Уродливое число

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
56

Лицензионный ключ

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
57

Награда за посещаемость

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
58

Посадить цветы

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
59

Уникальные имена

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
60

Корни уравнения

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
61

Слово с наибольшими баллами

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
62

Кол-во символов подряд

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
63

Изменить форму матрицы

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
64

Разбиение массива

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
65

Подбор размеров прямоугольника

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
66

Развернуть гласные в строке

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
67

Количество монет

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
68

Объединение перекрывающихся строк

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
69

Постфиксы для дубликатов

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
70

Латинский квадрат

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
71

Найти редкое слово

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
72

Циклический сдвиг массива

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
73

Ядовитая атака

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
74

Спортивные места

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
75

Список адресов Email

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
76

Зигзаг

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
77

Строка треугольника Паскаля

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
78

Номер столбца Excel

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
79

Название столбца Excel

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
80

Сортировка IP адресов

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
81

Римские числа

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
82

Расшифровка шифра Цезаря

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
83

Шифрование шифром Цезаря

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
84

Наибольшая последовательность

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
85

Cкобочная последовательность

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
86

Нажатия клавиш телефона

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
87

Кратчайший путь в матрице

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
88

Количество маршрутов

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
89

Системный путь

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
90

Подъем по ступенькам

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
91

Распределение пирожков

Логотип ДевстанцииАвторизуйтесь, чтобы получить доступ
Хотите стать частью сообщества Девстанции?
Вступайте в наш чат в Telegram

Также в этой категории

Вопросник
  32 вопроса

30 вопросов с собеседований по Python

Ответы на вопросы с собеседований по Python

1176 просмотров
От 4 июня
Викторина
  26 вопросов

Викторина по Python - Junior

Вопросы на собеседовании по Python для Junior-позиции

164 просмотра
От 30 мая 2023
Викторина
  20 вопросов

Викторина по Django - Junior/Middle

Базовые вопросы с собеседования по Django

40 просмотров
От 2 июня 2023
Викторина
  12 вопросов

Викторина по Python - Middle/Senior

Продвинутые вопросы для собеседования Python-разработчика

63 просмотра
От 30 мая 2023

Вам может быть интересно

Задачник
  21 задача

Топ 20 задач с собеседований по Go

Алгоритмические задачи для собеседований Go-разработчиков

4857 просмотров
От 25 февраля
Задачник
  32 задачи

Топ 35 задач с собеседований по C++

Разбор решений для алгоритмических задач с собеседований по C++

1476 просмотров
От 25 февраля
Вопросник
  7 вопросов

Коллекция полезных команд для Docker

Большая шпаргалка по всем командам Docker

512 просмотров
От 12 октября 2023
Вопросник
  17 вопросов

Вопросы с собеседований по C

Ответы на вопросы для собеседования по C

481 просмотр
От 4 июня
Вопросник
  26 вопросов

Вопросы с собеседований по C++

Ответы на вопросы для собеседования C++ разработчика

583 просмотра
От 4 июня
Вопросник
  54 вопроса

Вопросы с собеседований по Go

Ответы на вопросы с собеседований по Golang

1305 просмотров
От 4 июня

Топ тредов

: Предложите идею и получите спонсорский доступ на месяц

Последнее сообщение:
: Ой, не увидела. Круто, спасибо!
8 сообщений
180 просмотров

: Можно добавить таймер на решение задач

Последнее сообщение:
: да, с момента открытия и до успешных тестов. Чтобы трекать время выполнения )
3 сообщения
107 просмотров

Gravatar for 253malvina
Malvina
: Добавьте angular раздел

Последнее сообщение:
: Раздел открыт!
3 сообщения
132 просмотра

Все категории