Они используют эти вопросы собеседования 15+ Python, чтобы потерпеть неудачу … (А также Что вы можете сделать с этим)

Автор оригинала: Chris.

Бояться вашего кодирования интервью? Эта статья показывает, как сделать ваше кодирование интервью успехом.

Общие советы, чтобы подготовить интервью

• Смотреть Советы по собеседованию Google Отказ
• Читать Советы профессора Philip Guo Отказ
• Практика кодирования в Google Docs. Не используйте редактор выделения кода для вашего времени обучения.
• Решить хотя бы 50+ кода головоломки Отказ
• И самое главное: Не паникуйте Отказ

Следите за следующим постом Instagram и узнайте о популярных вопросах собеседования Python (Swipe Left, Swipe верно):

[Задача] Сколько из трех вопросов вы можете ответить? Отказ Отказ Отказ #coffeebreakpython #python # python3 #pythonprogmamming #pythoncoding #pythoncode # learning #computerscience # Coding #dasccatitience #puzzles #improves # learncomputerningers learncomputerscience # learningpyphon # learncomplife #dAscientister #education #pythonista #code #brainfood

Ein Beitrag Geteilt Von Блог Python (@ finxter.com_) am 1 ноября 2019 гм 4:00 PDT

Какие вопросы программирования вы должны подготовить?

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

• Вопрос 1: Получите отсутствующий номер из целочисленного списка 1-100.
• Вопрос 2: Найдите дубликат числа в целочисленном списке.
• Вопрос 3: Проверьте, содержит ли список INTEGER X.
• Вопрос 4: Найти самый большой и наименьшее число в несортированном списке.
• Вопрос 5: Найдите пары целых чисел в списке, чтобы их сумма равна целого числу X.
• Вопрос 6: Удалите все дубликаты из целочисленного списка.
• Вопрос 7: Сортируйте список с помощью алгоритма Quicksort.
• Вопрос 8: Сортируйте список с алгоритмом Mergeort.
• Вопрос 9: Проверьте, являются ли две струны анаграммы.
• Вопрос 10: вычислить пересечение двух списков.
• Вопрос 11: обратная строка с использованием рекурсии.
• Вопрос 12: Найти все перестановки строки.
• Вопрос 13: Проверьте, является ли строка палиндром.
• Вопрос 14: Вычислить первые n фибоначчи.
• Вопрос 15: Используйте список как стек, массив и очередь.
• Вопрос 16: Поиск сортированного списка в O (log n).

Чтобы вы могли легко узнать эти вопросы, я создал это Собеседование Python Cheat С 14 вопросами собеседования из этой статьи.

Я отправлю вам этот (и другие) Python Cheat Steets как Загружаемые PDF S в моем Бесплатный адрес электронной почты Отказ Не волнуйтесь, я не буду спамировать вас. Вы просто станете лучшим кодером Python на автопилоте.

Вопрос 1: Получите отсутствующий номер из целочисленного списка 1-100.

def get_missing_number(l):
    nxt = 1
    while nxt < len(l):
        if nxt != l[nxt-1]:
            return nxt
        nxt = nxt + 1

Есть много других способов решить эту проблему (и более краткие). Например, вы можете создать набор номеров от 1 до 100 и удалить все элементы в списке сразу Это элегантное решение, так как он возвращается не один, а все номера, которые отсутствуют в последовательности. Вот это решение:

set(range(l[len(l)-1])[1:]) - set(l)

Альтернативное решение является следующим:

lst = list(range(1, 101))
lst.remove(55)

total = sum(range(max(lst) + 1))
print(total - sum(lst))

Вопрос 2: Найдите дубликат числа в целочисленном списке.

Скажем, у нас есть список целочисленных чисел под названием Элементы Отказ Цель состоит в том, чтобы создать функцию, которая находит все целочисленные элементы в этом списке, которые являются дублированными, то есть, которые существуют как минимум два раза в списке. Например, при применении нашей функции в список Элементы = [2, 2, 3, 4, 3], он возвращает новый список [2, 3], так как целочисленные элементы 2 и 3 дублируются в списке элементы . В интервью, прежде чем даже начать с «программирования на бумаге», вы всегда должны обратиться к интервьюеру обратно с конкретными примерами, чтобы показать, что вы поняли вопрос.

Так что давайте начнем кодировать. Вот моя первая попытка:

def find_duplicates(elements):
    duplicates = set()
    seen = set() 

    for element in elements:
            if element in seen: # O(1) operation
                    duplicates.add(element)
            seen.add(element)
    return list(duplicates)


l = [2, 2, 2, 3, 4, 3, 6, 4, 3]
print(find_duplicates(l))
# [2, 3, 4]

Обратите внимание, что сложность времени выполнения довольно хорошая. Мы повторяем все элементы один раз в основной цикле. Тело основной петли имеет постоянное время выполнения, потому что я выбрал набор для обоих переменных «дубликатов» и «видел». Проверка, находится ли элемент набором, а также добавление элемента на множество имеет постоянное время выполнения (O (1)). Следовательно, общая сложность времени выполнения является линейной в размере ввода.

Finxter Mostafa Представлял следующее блестящее решение:

u = [1,2,2,3,4,5,4]
[u.remove(x) for x in list(set(u))]
print(list(set(u)))
# [2, 4]

Вопрос 3: Проверьте, содержит ли список INTEGER X.

Это очень простая проблема. Я не знаю, почему интервьюер запрашивает такие простые вопросы – может быть, это первый вопрос «разогретый» вопрос, чтобы сделать интервью более удобным. Тем не менее, многие люди сообщили, что это один из своих вопросов интервью.

Чтобы проверить, содержит ли список Python элемент x в Python, может быть выполнен путем итерации по всему списку и проверки того, равен ли элемент элемента текущего итерации. На самом деле, это будет мой выбор, если элементы списка были сложными объектами, которые не являются одновременномами.

Однако легкий путь часто является лучшим. Вопрос собеседования явно просит одержание целочисленного значения x. Поскольку целочисленные значения усугубляются, вы можете просто использовать ключевое слово Python “в” следующим образом.

l = [3, 3, 4, 5, 2, 111, 5]
print(111 in l)
# True

Вопрос 4: Найти самый большой и наименьшее число в несортированном списке.

Опять же, этот вопрос – это простой вопрос, который показывает вашему опытному использованию с основными ключевыми словами Python. Помните: у вас нет модного редактора с исходным кодом, подчеркивая! Таким образом, если вы не тренируете кодировку в Google Docs, это может быть серьезным препятствием. Еще хуже: проблема на самом деле легко Но если вы не можете решить это, вы мгновенно не пройдете интервью! Никогда не стоит недооценивать любые проблемы в кодировке!

Вот простое решение для Python:

l = [4, 3, 6, 3, 4, 888, 1, -11, 22, 3]

print(max(l))
# 888

print(min(l))
# -11

Это похоже на обману, не так ли? Но обратите внимание, что мы даже не использовали библиотеку, чтобы решить этот вопрос интервью. Конечно, вы также можете сделать что-то вроде этого:

def find_max(l):
    maxi = l[0]
    for element in l:
        if element > maxi:
            maxi = element
    return maxi


l = [4, 3, 6, 3, 4, 888, 1, -11, 22, 3]
print(max(l))
# 888

Какую версию вы предпочитаете?

Вопрос 5: Найдите пары целых чисел в списке, чтобы их сумма равна целого числу X.

Эта проблема интересна. Простое решение состоит в том, чтобы использовать два вложенных для циклов и проверки каждой комбинации элементов, является ли их сумма равна целым числу X. Вот что я имею в виду:

def find_pairs(l, x):
    pairs = []
    for (i, element_1) in enumerate(l):
        for (j, element_2) in enumerate(l[i+1:]):
            if element_1 + element_2 == x:
                pairs.add((element_1, element_2))
    return pairs


l = [4, 3, 6, 3, 4, 888, 1, -11, 22, 3]
print(find_pairs(l, 9))

Неудача! Это бросает исключение: Объект AttributeError: «Список» не имеет атрибута «Добавить»

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

def find_pairs(l, x):
    pairs = []
    for (i, element_1) in enumerate(l):
        for (j, element_2) in enumerate(l[i+1:]):
            if element_1 + element_2 == x:
                pairs.append((element_1, element_2))
    return pairs


l = [4, 3, 6, 3, 4, 888, 1, -11, 22, 3]
print(find_pairs(l, 9))

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

На самом деле, это также общее вопрос интервью (см. Следующий вопрос).

Вот еще одно красивое одноклассное решение, представленное одним из наших читателей:

# Solution from user Martin 
l = [4, 3, 6, 4, 888, 1, -11, 22, 3] 
match = 9
res = set([(x, match - x) for e, x in enumerate(l) if x >= match / 2 and match - x in l[:e] + l[e+1:]])
print(res) 

Вопрос 6: Удалите все дубликаты из целочисленного списка.

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

Неправильный пример модификации списка во время итерации (Не пытайтесь этого дома):

lst = list(range(10))
for element in lst:
    if element >= 5:
        lst.remove(element)

print(lst)
# [0, 1, 2, 3, 4, 6, 8]

Как видите, модифицируя последовательность, над которой вы итерация вызывает неуточненное поведение. После того, как он удаляет элемент 5 из списка, итератор увеличивает индекс до 6. Итератор предполагает, что это следующий элемент в списке. Однако это не так. Как мы удалили элемент 5, элемент 6 теперь находится в положении 5. Итератор просто игнорирует элемент. Следовательно, вы получаете эту неожиданную семантику.

Тем не менее, есть гораздо лучший способ удаления дубликатов в Python. Вы должны знать, что наборы в Python позволяют только один экземпляр элемента. Поэтому после конвертации списка на набор все дубликаты будут удалены Python. Напротив наивный подход (проверка всех пар элементов, являются ли они дубликатами), этот метод имеет линейную сложность времени выполнения. Причина в том, что создание набора является линейным в количестве установленных элементов. Теперь нам просто приходится преобразовать установку обратно в список и VOILLA, дубликаты удаляются.

lst = list(range(10)) + list(range(10))
lst = list(set(lst))
print(lst)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Does this also work for tuples? Yes!
lst = [(10,5), (10,5), (5,10), (3,2), (3, 4)]
lst = list(set(lst))
print(lst)
# [(3, 4), (10, 5), (5, 10), (3, 2)]

Вопрос 7: Сортируйте список с помощью алгоритма Quicksort.

Это сложная проблема для решения во время кодирования собеседования. На мой взгляд, большинство разработчиков программного обеспечения не могут правильно писать алгоритм Quicksort в документе Google. Тем не менее, мы сделаем это, не так ли?

Основная идея QuickSort Чтобы выбрать элемент поворота, а затем поместить все элементы, которые больше или равны, чем элемент поворота вправо и все элементы, которые меньше, чем элемент поворота влево. Теперь вы разделили большую проблему сортировки списка на две меньшие подпруты: сортировка права и левой раздел списка. То, что вы делаете сейчас, это рекурсивно повторить эту процедуру, пока вы не получите список нулевых элементов. Этот список уже отсортирован, поэтому рекурсион завершается. Вот алгоритм Quicksort в качестве одноклассника Python:

def qsort(L):
    if L == []:
        return []
    return qsort([x for x in L[1:] if x=L[0]])


lst = [44, 33, 22, 5, 77, 55, 999]
print(qsort(lst))
# [5, 22, 33, 44, 55, 77, 999]

Вопрос 8: Сортируйте список с алгоритмом Mergeort.

Это может быть довольно сложно код МЕРГОРТ алгоритм при эмоциональном и временном давлении. Так что возьмите свое время, теперь понимая его правильно.

Идея состоит в том, чтобы разбить список в два сублиста. Для каждого из сублиста вы теперь вызовите слияние сортировки рекурсивной манерой. Предполагая, что оба списка сортируются, вы теперь объединяете два отсортированных списка. Обратите внимание, что это очень эффективно объединить два отсортированных списка: он принимает только линейное время в размере списка.

Вот алгоритм, решение этой проблемы.

def msort(lst):
    if len(lst)<=1:
        return lst
    
    left = msort(lst[:len(lst)//2])
    right = msort(lst[len(lst)//2:])
    return merge(left, right)


def merge(lst1, lst2):
    
    if len(lst1)==0:
        return lst2
    
    if len(lst2)==0:
        return lst1
    
    merged_list = []
    index_lst1 = 0
    index_lst2 = 0
    
    while len(merged_list) < (len(lst1) + len(lst2)):
        if lst1[index_lst1] < lst2[index_lst2]:
            merged_list.append(lst1[index_lst1])
            index_lst1 += 1
            if index_lst1 == len(lst1):
                merged_list += lst2[index_lst2:]
        else:
            merged_list.append(lst2[index_lst2])
            index_lst2 += 1
            if index_lst2 == len(lst2):
                merged_list += lst1[index_lst1:]

    return merged_list


lst = [44, 33, 22, 5, 77, 55, 999]
print(msort(lst))
# [5, 22, 33, 44, 55, 77, 999]

Вопрос 9: Проверьте, являются ли две струны анаграммы.

Вы можете найти этот вопрос на протяжении многих разных мест в Интернете. Это одно из самых популярных вопросов собеседования.

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

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

Так каковы анаграммы? Два слова – это анаграммы, если они состоят из того же символов. Википедия Определяет это немного точнее: «Анаграмма – это слово или фраза, образованную, переставив буквы другого слова или фразы, обычно используя все оригинальные буквы ровно один раз» Отказ

Вот несколько примеров:

• «Слушай» → «молчать»
• «Похороны» → «Реальное веселье»
• «Элвис» → «Живет»

Хорошо, теперь вы точно знаете, что делать, верно? Так что давайте начнем кодировать.

def is_anagram(s1, s2):
    return sorted(s1) == sorted(s2)

s1 = "elvis"
s2 = "lives"
s3 = "not"
s4 = "hello"

print(is_anagram(s1, s2)) # True
print(is_anagram(s2, s3)) # False
print(is_anagram(s2, s4)) # False
print(is_anagram(s2, s1)) # True

Как видите, программа эффективно и правильно решает проблему. Но это была не моя первая попытка. Я пострадал от старой слабости программистов: начиная с кодировать рано. Я использовал подход к практике и создал рекурсивную функцию IS_Anagram (S1, S2). Я использовал наблюдение, что S1 и S2 – это анаграммы IFF (1), у них есть два равных символа и (2) они все еще являются анаграммы, если убрать эти два символа (меньшая проблема). Хотя это решение сработало, он также отсасывает 10 минут моего времени.

Подумав о проблеме, это поразило меня: почему бы не просто сортировать две строки? Две строки – это анаграммы, если у них такая же соисканная последовательность символов. Это так просто.

Я уверен, не глядя на это, что сортируя строки и сравнение отсортированных представлений (как сделано в коде), является самым чистым решением этой проблемы.

Вопрос 10: вычислить пересечение двух списков.

Эта проблема, кажется, легко (будь осторожен!). Конечно, если у вас есть некоторые знания библиотеки (например, numpy), вы можете решить эту проблему с одним вызовом функций. Например, библиотека Python для линейной алгебры (Numpy) имеет реализацию функции пересечения. Тем не менее, мы предполагаем, что у нас нет никаких знаний библиотек в кодирующем интервью (это намного безопасная ставка).

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

Вот пример того, что мы хотим сделать:

• Пересекается ([1, 2, 3], [2, 3]) → [2, 3]
• Пересекается («Привет», «Мой», «Название», «Является», «Slim», «Shady»], [«Я», «Нравится», «Slim»]) → [«Slim»]
• Пересекается ([3, 3, 3], [3, 3]) → [3, 3]

Вы можете использовать следующий код для этого.

def intersect(lst1, lst2):
    res = []
    lst2_copy = lst2[:]
    for el in lst1:
        if el in lst2_copy:
            res.append(el)
            lst2_copy.remove(el)
    return res


# Are the results ok?
print(intersect([1, 2, 3], [2, 3]))
# [2, 3]

print(intersect("hi my name is slim shady".split(" "),
                "i like slim".split(" ")))
# ['slim']

print(intersect([3, 3, 3], [3, 3]))
# [3, 3]

# Are the original lists untouched?
lst1 = [4, 4, 3]
lst2 = [3, 4, 2]
print(intersect(lst1, lst2))
# [4, 3]
      
print(lst1)
# [4, 4, 3]

print(lst2)
# [3, 4, 2]

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

Но действительно ли это самая краткая версия? Я так не думаю! Моя первая идея должна была использовать наборы снова, на которые мы можем выполнять такие операции, как набор пересечений. Но при использовании наборов мы теряем информацию о дублированных записях в списке. Таким образом, простое решение в этом направлении не видно.

Тогда я думал о Понимание списка Отказ Можем ли мы сделать что-то на этих строках? Первая идея состоит в том, чтобы использовать список понятий:

def intersect(lst1, lst2):
    lst2_copy = lst2[:]
    return [x for x in lst1 if lst2.remove(x)]

Тем не менее, вы видите проблему с таким подходом?

Проблема в том, что пересекается ([4, 4, 3], [4, 2]) возвращает [4, 4]. Это ясная ошибка! Это не легко увидеть – я нашел много онлайн-ресурсов, которые просто игнорируют эту проблему …

Number 4 существует дважды в первом списке, но если вы проверяете «4 в [4, 2]», он возвращает True – независимо от того, как часто вы часто проверяете. Вот почему нам нужно удалить целое число № 4 из второго списка после поиска его в первый раз.

Это именно то, что я сделал в вышеуказанном коде. Если у вас есть идеи, как решить это со списком пониманием, пожалуйста, дайте мне знать (admin@finxter.com)! 🙂

Редактировать : Я получил очень умное решение, используя понимание списка с побочными эффектами:

def intersect(lst1, lst2):
    lst2_copy = lst2[:]
    return [(x, lst2_copy.remove(x))[0] for x in lst1 if x in lst2_copy]


lst1 = [4, 4, 3]
lst2 = [3, 4, 2]
print(intersect(lst1, lst2))                               # [4, 3]
print(lst1)                                                # [4, 4, 3]
print(lst2) 

Finxter Мостафа представил следующее одноклассник решение:

intersect = lambda x,y: set(x) - (set(x) - set(y))

Отличная работа!

Вопрос 11: обратная строка с использованием рекурсии

Теперь давайте перейдем к следующей проблеме: обратная строка с помощью рекурсии.

Вот что мы хотим достичь:

• “Здравствуйте” → “olleh”
• «Нет» → «на»
• «Да, мы можем» → «NAC EW Sey»

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

Википедия Объясняет рекурсию по понятным способом:

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

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

Вот код:

def reverse(string):
    if len(string)<=1:
        return string
    else:
        return reverse(string[1:]) + string[0]


phrase1 = "hello"
phrase2 = "no"
phrase3 = "yes we can"

print(reverse(phrase1))
# olleh
print(reverse(phrase2))
# on
print(reverse(phrase3))
# nac ew sey

Программа делает именно то, что я описал ранее: перемещение первого элемента до конца и вызывая функцию рекурсивно на оставшуюся строку.

Вопрос 12: Найти все перестановки строки

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

Что такое перестановка? Вы получаете перестановку из строки, переубивая его символы. Давайте вернемся к проблеме анаграммы. Две анаграммы – это перестановки друг от друга, поскольку вы можете построить один из другого путем переупомянувания символов.

Вот все перестановки из нескольких примерных строк:

• «Hello» → {'Олехл, «Олхе», «Хоел», «Эльхо», «Лхуэль», «Ольхе», «HLLEO», «Lhloe», «Hello», «LHelo», «Hleelo»,' Eohll ', «oellh», «хлоль», «блюб», «Лехо», «Охлель», «Ойч», «Ллеох», «Ольех», «Ллохе», «Эльол», «Леолх», «Эйлдо» , «LOHLE», «EOLHL», «LLHEO», «ELHLO», «OHLLE», «LOHLEL», «ELOHL», «HELOL», «LEELEL», «LHEOL», «HOLLE», «ELLOH», ' LLHOE ', «EOLLH», «OLEHL», «Лето», «Лолех», «Охэль», «Леев», «Лельо», «Олелх», «Хелл», «Элол», «Лолже», «LLOHE» , «Леол», «HOLEL», «HLEOL», «LELOH», «ELOLH», «OELHL», «HLOEL», «LLEHO», «EOLL», «HLLOOE», «LOLHE»}
• «Привет» → {«Привет», «IH»}
• «BYE» → → {'BYE', 'YBE', 'BEY', 'YEB', «EBY», «ЭЙБ»}

Концептуально, вы можете подумать о строке как ведро символов. Скажем, строка имеет длину n. В этом случае у вас есть позиции для заполнения из ведра N символов. Заполнив все зоски, вы получаете перестановку со строки. Вы хотите найти все такие перестановки.

Моя первая идея – это Решить эту проблему рекурсивно Отказ Предположим, мы уже знаем все перестановки из строки с n символов. Теперь мы хотим найти все перестановки с N + 1 символами, добавив символ X. Мы получаем все такие перестановки, вставляя X в каждую позицию существующей перестановки. Мы повторяем это для всех существующих перестановок.

Однако, как правило, Избегайте чрезмерного использования проблемы в кодирующем интервью во всех расходах! Не пытайся быть причудливым! (И не используйте рекурсию – это логическое заключение из предыдущих утверждений …)

Так есть ли более легкое итеративное решение? К сожалению, я не мог найти простое итеративное решение (есть A Johnson-Trotter Algorithm Но это вряд ли решение для представления на кодирующем интервью).

Таким образом, я вернулся к реализации рекурсивного решения, описанного выше. ( * Зубы – Снашивающиеся * )

def get_permutations(word):

    # single word permutations
    if len(word)<=1:
        return set(word)

    # solve smaller problem recursively
    smaller_perms = get_permutations(word[1:])

    # find all permutation by inserting the first character
    # to each position of each smaller permutation
    perms = set()
    for small_perm in smaller_perms:
        for pos in range(0,len(small_perm)+1):
            perm = small_perm[:pos] + word[0] + small_perm[pos:]
            perms.add(perm)
    return perms

        

print(get_permutations("nan"))
print(get_permutations("hello"))
print(get_permutations("coffee"))

# {'nna', 'ann', 'nan'}
# {'olhel', 'olhle', 'hoell', 'ellho', 'lhoel', 'ollhe', 'hlleo', 'lhloe', 'hello', 'lhelo', 'hlelo', 'eohll', 'oellh', 'hlole', 'lhole', 'lehlo', 'ohlel', 'oehll', 'lleoh', 'olleh', 'lloeh', 'elhol', 'leolh', 'ehllo', 'lohle', 'eolhl', 'llheo', 'elhlo', 'ohlle', 'lohel', 'elohl', 'helol', 'loehl', 'lheol', 'holle', 'elloh', 'llhoe', 'eollh', 'olehl', 'lhleo', 'loleh', 'ohell', 'leohl', 'lelho', 'olelh', 'heoll', 'ehlol', 'loelh', 'llohe', 'lehol', 'holel', 'hleol', 'leloh', 'elolh', 'oelhl', 'hloel', 'lleho', 'eholl', 'hlloe', 'lolhe'}
# {'coeeff', 'ceoeff', 'ceofef', 'foecef', 'feecof', 'effeoc', 'eofefc', 'efcfoe', 'fecofe', 'eceoff', 'ceeffo', 'ecfeof', 'coefef', 'effoce', 'fceefo', 'feofce', 'fecefo', 'ocefef', 'ffecoe', 'ofcefe', 'fefceo', 'ffeoce', 'ffoeec', 'oefcfe', 'ofceef', 'efeofc', 'eefcof', 'ceffoe', 'eocfef', 'ceffeo', 'eoffec', 'ceoffe', 'fcoefe', 'cefofe', 'oeeffc', 'oeffec', 'fceeof', 'ecfofe', 'feefoc', 'ffcoee', 'feocef', 'ffceeo', 'fofcee', 'fecfoe', 'fefoec', 'eefcfo', 'eofcfe', 'ffceoe', 'ofcfee', 'ceefof', 'effoec', 'offcee', 'fofeec', 'eecffo', 'cofefe', 'feeofc', 'ecofef', 'effceo', 'cfeefo', 'ffeoec', 'eofcef', 'cffeeo', 'cffoee', 'efcefo', 'efoefc', 'eofecf', 'ffeceo', 'ofefec', 'foeecf', 'oefefc', 'oecffe', 'foecfe', 'eeffoc', 'ofecfe', 'oceeff', 'offece', 'efofce', 'fcoeef', 'fcofee', 'oefecf', 'fcefeo', 'cfefoe', 'cefoef', 'eoceff', 'ffoece', 'feofec', 'offeec', 'oceffe', 'eeoffc', 'cfoeef', 'fefcoe', 'ecoeff', 'oeecff', 'efofec', 'eeffco', 'eeofcf', 'ecfefo', 'feoefc', 'ecefof', 'feceof', 'oeefcf', 'ecffoe', 'efecfo', 'cefeof', 'fceofe', 'effeco', 'ecfoef', 'efeocf', 'ceeoff', 'foceef', 'focfee', 'eoeffc', 'efoecf', 'oefcef', 'oeffce', 'ffocee', 'efceof', 'fcfeeo', 'eoefcf', 'ocffee', 'oeceff', 'fcfeoe', 'fefeoc', 'efefco', 'cefefo', 'fecfeo', 'ffeeco', 'ofefce', 'cfofee', 'cfefeo', 'efcoef', 'ofeecf', 'eecoff', 'ffeeoc', 'eefofc', 'ecoffe', 'coeffe', 'eoecff', 'fceoef', 'foefec', 'cfeeof', 'cfoefe', 'efefoc', 'eeocff', 'eecfof', 'ofeefc', 'effcoe', 'efocef', 'eceffo', 'fefeco', 'cffeoe', 'feecfo', 'ecffeo', 'coffee', 'feefco', 'eefocf', 'fefoce', 'fofece', 'fcefoe', 'ocfeef', 'eoffce', 'efcofe', 'foefce', 'fecoef', 'cfeoef', 'focefe', 'ocfefe', 'eocffe', 'efocfe', 'feoecf', 'efecof', 'cofeef', 'fcfoee', 'oecfef', 'feeocf', 'ofecef', 'cfeofe', 'feocfe', 'efcfeo', 'foeefc'}

Если у вас есть какие-либо вопросы, пожалуйста, дайте мне знать! Я был очень удивлен, обнаружив, что нет никакого решения Python One-Liner для этой проблемы. Если вы знаете, пожалуйста, поделитесь этим со мной (admin@finxter.com)!

Редактировать : Finxter Янос представил решение на основе Тернарный оператор , Понимание списка , лямбда функции и Рекурсия Отказ Ход гения!

# One-Liner Solution By Janos:
text1 = 'bye'
perm = lambda text: list(set([c + txt for c in text for txt in perm(text.replace(c, '', 1))])) if len(text) > 1 else text
print(perm(text1))

Вопрос 13: Проверьте, является ли строка палиндром.

Первые вещи в первую очередь. Что такое палиндром?

«Палиндром – это слово, номер, фраза или другая последовательность персонажей, которая читает то же самое обратно, как вперед, например Madam или RaceCar или номер 10201. “

Вот несколько веселых примеров:

• ” Мистер Сова съел мой металлический червь »
• “Была ли машина или кот, которую я видел?”
• ” Иди повесьте салями, я лазанья свинья »
• ” Крысы живут без злой звезды “
• “Ханна”
• “Анна”
• “Боб”

Теперь это звучит, как есть короткое и лаконичное одноищеное решение в Python!

def is_palindrome(phrase):
    return phrase == phrase[::-1]

print(is_palindrome("anna"))
print(is_palindrome("kdljfasjf"))
print(is_palindrome("rats live on no evil star"))

# True
# False
# True

Вот важный совет: изучите нарезку в Python в сердце для вашего кодирующего интервью. Вы можете скачать мою бесплатную нажавшую книгу, чтобы по-настоящему подготовить вас к нарезной части интервью. Просто Зарегистрируйтесь на мою бесплатную рассылку И я вышлю вам версию, как только она готова и корректируется!

Вопрос 14: Вычислить первые n фибоначчи.

А вот … еще одна игрушечная проблема, которая мгновенно уничтожит ваши шансы на успех, если не решается правильно.

Серия Fibonacci была обнаружена итальянским математиком Leonardo Fibonacci в 1202 году и даже ранее индийских математиков. Серия появляется в неожиданных областях, таких как экономика, математика, искусство и природа.

Серия начинается с чисел фибоначчи ноль и один. Затем вы можете рассчитать следующий элемент серии как сумма обоих последних элементов.

Для этого алгоритм должен отслеживать только последние два элемента в серии. Таким образом, мы поддерживаем две переменные A и B, являющиеся вторым последним и последним элементом в серии соответственно.

# Fibonacci series:
a, b = 0, 1
n = 10 # how many numbers we calculate
for i in range(n):
    print(b)
    a, b = b, a+b

'''
1
1
2
3
5
8
13
21
34
55
'''

Для ясности кода я использовал языковой особенностью нескольких заданий в первой и последней строке.

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

Обратите внимание, что все выражения в правой части сначала оцениваются до того, как они будут назначены. Это важное свойство для нашего алгоритма. Без этого свойства последняя строка была бы неправильной, поскольку выражение «A + B» будет рассмотреть неправильное значение для «A».

Вопрос 15: Используйте список как стек, массив и очередь.

Эта проблема звучит легко. Но я уверен, что это делает то, что предназначено для того, чтобы сделать: отделить опытных программистов от новичков.

Чтобы решить это, вы должны знать синтаксис списков в сердце. И сколько новичков подробно изучили, как получить доступ к списку в Python? Я думаю, не слишком много …

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

Давайте начнем использовать список тремя разными способами: как стек, как массив, а как очередь.

# as a list ...
l = []
l.append(3) # l = [3]
l.append(4) # l = [3, 4]
l +=  [5, 6] # l = [3, 4, 5, 6]
l.pop(0) # l = [4, 5, 6]


# ... as a stack ...
l.append(10) # l = [4, 5, 6, 10]
l.append(11) # l = [4, 5, 6, 10, 11]
l.pop() # l = [4, 5, 6, 10]
l.pop() # l = [4, 5, 6]

# ... and as a queue
l.insert(0, 5) # l = [5, 4, 5, 6]
l.insert(0, 3) # l = [3, 5, 4, 5, 6]
l.pop() # l = [3, 5, 4, 5]
l.pop() # l = [3, 5, 4]

print(l)
# [3, 5, 4]

Если вам нужны какие-то фоновые знания, проверьте Учебник Python И эти статьи о Стекстическая структура данных и Структура данных очереди Отказ

Вопрос 16: Ищите сортированный список в O (log n)

Как найти список в логарифмическом времени выполнения? Эта проблема имеет так много практических применений, которые я могу понять, что кодирующие интервьюеры любят это.

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

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

Подумайте о влиянии эффективного поиска! Вы используете эти структуры данных в каждой нетривиальной программе (а также во многих тривиальных).

График показывает вам двоичный алгоритм поиска на работе. Сортированный список состоит из восьми значений. Предположим, вы хотите найти значение 56 в списке.

Тривиальный алгоритм проходит весь список с первого до последнего элемента, сравнивающего каждое против значений поиска. Если ваш список содержит N элементов, тривиальный алгоритм приводит к n сравнениям. Следовательно, сложность выполнения тривиального алгоритма является O (n).

(Если вы не чувствуете себя комфортно, используя нотацию Big-O, освежите свои знания о символах Ландау здесь .)

Но наша цель – пройти отсортированный список в логарифмическом времени O (log n). Таким образом, мы не можем позволить себе прикоснуться к каждому элементу в списке.

Двоичный алгоритм поиска в графике несколько раз прослеживает элемент в середине списка (округление вниз). Есть три случая:

1. Этот элемент X больше, чем в поисках 55. В этом случае алгоритм игнорирует правильную часть списка, так как все элементы больше 55. Это потому, что список уже отсортирован.
2. Элемент X меньше, чем искомое значение 55. Это так, мы наблюдаем на рисунке. Здесь алгоритм игнорирует левую часть списка, так как они меньше, а также, используя свойство, которое список уже отсортирован).
3. Элемент X равен искому значению 55. Вы можете увидеть этот случай в последней строке на рисунке. Поздравляю, вы нашли элемент в списке!

В каждом этапе алгоритма пространство поиска сводится к половине! Это означает, что после логарифмического числа шагов мы нашли элемент! После понимания алгоритма легко придумать код. Вот моя версия двоичного алгоритма поиска.

def binary_search(lst, value):
    lo, hi = 0, len(lst)-1
    while lo <= hi:
        mid = (lo + hi) // 2
        if lst[mid] < value:
            lo = mid + 1
        elif value < lst[mid]:
            hi = mid - 1
        else:
            return mid
    return -1

    
l = [3, 6, 14, 16, 33, 55, 56, 89]
x = 56
print(binary_search(l,x))
# 6 (the index of the found element)

Поздравляем, вы сделали это через эти 15+ дико популярных вопросов собеседования. Не забудьте решить не менее 50 головоломков Python Code здесь.

Спасибо за прочтение этой статьи. Если у вас есть еще вопросы собеседования (или вы боретесь с одним из вышеперечисленных), пожалуйста, напишите мне письмо на admin@finxter.com.

Я рекомендую вам подписаться на мой бесплатный курс электронной почты Python . Вы получите 5 Super-Simple Python Cheat Sheet Отказ Как бонус Я отправлю тебе 10+ Обужительные Python Mails Отказ Без спама. 100% бесплатно!

Статьи по Теме:

• [Коллекция] 11 Python Cheat Pheets Каждый кодер Python должен иметь
• [ Python OOP Cheat Sheet] Простой обзор объектно-ориентированного программирования
• [Collection] 15 Умение мытья машины Учеба чисных листов для привязки к вашей туалетной стене
• Ваш 8+ бесплатный чит-лист Python [курс]
• Python Beginner Cheat: 19 Ключевые слова каждый кодер Должен знать
• Python Функции и трюки чит
• Питонский чит-лист: 14 Вопросы собеседования
• Красивые чис-листы Pandas
• 10 лучших проблемных читов
• Методы списка Python Cheat [мгновенное PDF скачать]
• [Чит-лист] 6 алгоритмов обучения машины

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

Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python одноклассники (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.

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

Оригинал: “https://blog.finxter.com/python-interview-questions/”