🖥 Вы видите только следующий кусок кода. Что с ним не так? И для чего такой код нужен?

if __debug__:
assert False, ("error")

Пишите свой ответ в комментариях👇

@python_job_interview

🖥 Объясните как такое возможно?

_MangledGlobal__mangled = 23
class MangledGlobal:
def test(self):
return __mangled
>>> MangledGlobal().test()
23

Пишите свой ответ в комментариях👇

@python_job_interview

🖥 Какой результат мы получим, запустив следующий код?

big_num_1 = 1000
big_num_2 = 1000
small_num_1 = 1
small_num_2 = 1
big_num_1 is big_num_2
small_num_1 is small_num_2

Пишите свой ответ в комментариях👇

@python_job_interview

🖥 Возможно ли при наследовании методы объединять, а не заменять?

Дан родительский класс и дочерний, который наследуется от него

class Parent():
def test(self):
print('inside parent')

class Child(Parent):
def test(self):
print('inside child')

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

>>> b1 = Child()
>>> b1.test()
inside child
>>>

Вопрос: можно ли сделать так чтобы дочерний метод не перезаписывал родительский, а добавлялся к нему и они выполнялись бы вместе и поочередно (сначала родительский потом дочерний)? Чтобы получилось вот так:

>>> b1.test()
inside parent
inside child
>>>

Ответ

Для этого можно вызвать функцию в родительском классе при помощи super().

class Parent:
def test(self):
print('inside parent')


class Child(Parent):
def test(self):
super().test()
print('inside child')


b1 = Child()
b1.test()
Вывод:

inside parent
inside child

Подробнее про функцию super() можете почитать в документации.

#junior

@python_job_interview

🖥 Как посчитать уникальные значений с Counter() ?

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

%%time
num_counts = {}
for num in a_long_list:
if num in num_counts:
num_counts[num] += 1
else:
num_counts[num] = 1

# Вывод в консоль
# CPU times: user 448 ms, sys: 1.77 ms, total: 450 ms
# Wall time: 450 ms


Однако более эффективный способ для решения этой задачи – использование Counter() из модуля collections. Весь код при этом уместится в одной строчке:


%%time
num_counts2 = Counter(a_long_list)

# Вывод в консоль
# CPU times: user 40.7 ms, sys: 329 μs, total: 41 ms
# Wall time: 41.2 ms


Этот фрагмент будет работать примерно в 10 раз быстрее, чем предыдущий.

У Counter также есть удобный метод most_common, позволяющий получить самые часто встречающиеся значения:


for number, count in num_counts2.most_common(10):
print(number, count)

# Вывод в консоль
29 19831
47 19811
7 19800
36 19794
14 19761
39 19748
32 19747
16 19737
34 19729
33 19729


Одним словом, collections – это замечательный модуль, который должен быть в базовом наборе инструментов любого Python-разработчика. Не поленитесь прочитать наше руководство по применению модуля.

@python_job_interview

🖥 Задача для новичков на Python.

Задаются месяц и год в виде чисел. Нужно определить, есть ли в этом месяце пятница, 13-е

Пример:
has_friday_13(3, 2023) ➞ True

has_friday_13(10, 2017) ➞ True

has_friday_13(1, 1985) ➞ False

👉 Пишите ваше решение в комментариях👇

@python_job_interview

🖥 Задача. Подготовка экспедиции на Марс

N кандидатов готовятся к двум космическим экспедициям на Марс. Поскольку экспедиции будут продолжаться несколько лет, а их участники окажутся в замкнутом пространстве небольшого объёма, то важное значение приобретает психологическая совместимость членов экипажа.

Путём тестирования были установлены пары кандидатов, присутствие которых в одной и той же экспедиции было бы нежелательным. Результаты тестирования отражены в таблице размера NxN. Если на пересечении -той строки и $j$-го столбца таблицы находится знак «+», то участие -го и $j$-го кандидатов в одной экспедиции нежелательно.

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

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

Программа должна считывать со стандартного потока ввода количество кандидатов и матрицу размера NxN. Например, для входных данных

8
- - + - - - - -
- - - + - - - -
+ - - - - - - +
- + - - - + - -
- - - - - - - -
- - - + - - - -
- - - - - - - +
- - + - - - + -

программа должна выводить

1 2 6 8


👉 Пишите ваше решение в комментариях👇

@python_job_interview

🖥 Задача реализовать алгоритм интерполяционного поиска

Интерполяционный поиск — это еще один алгоритм «разделяй и властвуй», аналогичный бинарному поиску. В отличие от бинарного поиска, он не всегда начинает поиск с середины. Интерполяционный поиск вычисляет вероятную позицию искомого элемента по формуле:

index = low + [(val-lys[low])*(high-low) / (lys[high]-lys[low])]
В этой формуле используются следующие переменные:

lys — наш входной массив.
val — искомый элемент.
index — вероятный индекс искомого элемента. Он вычисляется как более высокое значение, когда значение val ближе по значению к элементу в конце массива (lys[high]), и более низкое, когда значение val ближе по значению к элементу в начале массива (lys[low]).
low — начальный индекс массива.
high — последний индекс массива.
Алгоритм осуществляет поиск путем вычисления значения индекса:

Если значение найдено (когда lys[index] == val), возвращается индекс.
Если значение val меньше lys[index], то значение индекса пересчитывается по формуле для левого подмассива.
Если значение val больше lys[index], то значение индекса пересчитывается по формуле для правого подмассива.


Решение:

def InterpolationSearch(lys, val):
low = 0
high = (len(lys) - 1)
while low <= high and val >= lys[low] and val <= lys[high]:
index = low + int(((float(high - low) / ( lys[high] - lys[low])) * ( val - lys[low])))
if lys[index] == val:
return index
if lys[index] < val:
low = index + 1;
else:
high = index - 1;
return -1
Если мы используем функцию для вычисления:

>>> print(InterpolationSearch([1,2,3,4,5,6,7,8], 6))
Наши начальные значения будут следующими:

val = 6,

low = 0,

high = 7,

lys[low] = 1,

lys[high] = 8,

index = 0 + [(6-1)*(7-0)/(8-1)] = 5

Поскольку lys[5] равно 6, что является искомым значением, мы прекращаем выполнение и возвращаем результат:

5

Если у нас большое количество элементов и наш индекс не может быть вычислен за одну итерацию, то мы продолжаем пересчитывать значение индекса после корректировки значений high и low.

Временная сложность интерполяционного поиска равна O(log log n), когда значения распределены равномерно. Если значения распределены неравномерно, временная сложность для наихудшего случая равна O(n) — так же, как и для линейного поиска.

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

👉 Пишите ваше решение в комментариях👇


@python_job_interview

🖥 Auto-resume-raising – программа для автоматического подъема резюме на HeadHunter каждые 4 часа

Альтернатива платной услуге Продвижение.LITE от HeadHunter

🖥 Github: https://github.com/sergo-code/hh-ru-auto-resume-raising

#github #python

@python_job_interview

🖥 Задача реализовать экспоненциального поиска.

Экспоненциальный поиск — это еще один алгоритм поиска, который может быть достаточно легко реализован на Python, по сравнению с jump search и поиском Фибоначчи, которые немного сложны. Он также известен под названиями galloping search, doubling search и Struzik search.

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

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

Решение

Реализация алгоритма экспоненциального поиска на Python:

def ExponentialSearch(lys, val):
if lys[0] == val:
return 0
index = 1
while index < len(lys) and lys[index] <= val:
index = index * 2
return BinarySearch( lys[:min(index, len(lys))], val)

Используем функцию, чтобы найти значение:

>>> print(ExponentialSearch([1,2,3,4,5,6,7,8],3))

Рассмотрим работу алгоритма пошагово.

Проверяем, соответствует ли первый элемент списка искомому значению: поскольку lys[0] равен 1, а мы ищем 3, мы устанавливаем индекс равным 1 и двигаемся дальше.

Перебираем все элементы в списке, и пока элемент с текущим индексом меньше или равен нашему значению, умножаем значение индекса на 2:
index = 1, lys[1] равно 2, что меньше 3, поэтому значение index умножается на 2 и переменной index присваивается значение 2.
index = 2, lys[2] равно 3, что равно 3, поэтому значение index умножается на 2 и переменной index присваивается значение 4.
index = 4, lys[4] равно 5, что больше 3. Условие выполнения цикла больше не соблюдается и цикл завершает свою работу.
Затем выполняется двоичный поиск в полученном диапазоне (срезе) lys[:4]. В Python это означает, что подсписок будет содержать все элементы до 4-го элемента, поэтому мы фактически вызываем функцию следующим образом:

>>> BinarySearch([1,2,3,4], 3)
Функция вернет следующий результат:

2

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

Экспоненциальный поиск выполняется за время O(log i), где i — индекс искомого элемента. В худшем случае временная сложность равна O(log n), когда искомый элемент — это последний элемент в массиве (n — это длина массива).

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

👉 Пишите ваше решение в комментариях👇

@python_job_interview

🖥 Задача с собеседования | Уровень: #Easy

Условие:

Создать функцию которая принимает число и возвращает "Even" для чётных чисел и "Odd" для нечётных.

Пример:

2 → "Even"
1 → "Odd"
-46 → "Even"
71 → "Odd"
0 → "Even"
-123 → "Odd"


👉 Пишите ваше решение в комментариях👇


@python_job_interview