Задача о подстроке

Получаем две строки s и t . Напишите функцию проверки: является ли s подстрокой t.

Подстрока формируется из исходной строки путём удаления некоторых символов (может быть, ни одного) без нарушения положения остальных. "ace" является подстрокой "abcde", а "aec" — нет.

Ограничения:

0 <= len(s) <= 100
0 <= len(t) <= 10^4

s и t состоят только из строчных английских букв.

В качестве теста:

s = "abc"
t = "ahbgdc"

>>> is_substring(s, t) 
... true

#задача

@zen_of_python

Поздравляем победителей

Задачу об инверсии строки верно решили:

— Cool and Fun Python (@Python3k);
— Лев Выскубов;
— @sidor0912;
— @lomserman;
— @HackingSection;
— @VasilTerekin (засчитываю, хотя запрошена функция);
— @patriarch_chesslovo;
— @IvanImmortal;
— @Sentiago.

Кратчайшие верные решения предложили @patriarch_chesslovo:

VOWELS_LOWERCASE = set('aeoiuаоыуэяёиюе')

def invert_vowels(strng):
  reversed_vowels = (i for i in strng[::-1] if i.lower() in VOWELS_LOWERCASE)
  return ''.join([i if i.lower() not in VOWELS_LOWERCASE else next(reversed_vowels) for i in strng])

и @HackingSection:

def invert_vowels(s, vowels = "аяоёиыуюеэ"):
  vowelsInText = [j for j in s if j in vowels]
  return [vowelsInText.pop(-1) if i in vowels else i for i in s]

Отдельный респект Cool and Fun Python за разбор своего решения:

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

У решения линейная асимптотика. Но если очень хочется, можно повысить быстродействие, превратив vowels в множество строк односимвольников: vowels = {'а', 'я', ...}

И преобразование строки в список и обратно - вынужденная мера. Строка в Python неизменяемая. Впрочем, на сохранение асимптотики O(N) это не влияет.

Кстати, если бы постановщик задачи гарантировал наличие гласных (всё же предлоги "в", "с" тоже считаются словами), можно было бы убрать проверки left < right в двух внутренних циклах.

Отдельная благодарность @lomserman за создание тестирующей функции:

def test(original: str, expected: str):
  result = invert_vowels(original)
  print(result)
  assert result == expected

p.s. Админ подписывается на всех ребятушек, что решают задачи. Если «провалиться» в профили решивших, там полно питонической годноты.

#задача

@zen_of_python

Поздравляем победителей

Задачу о подстроке верно решили:

— @GeorKu;
— @StSav012;
— @IPyth0n (@X_Python);
— @stalker1337;
— @HackingSection;
— @Shihiyev;
— @sidor0912
— @patriarch_chesslovo.

Кратчайшие верные решения предложили @HackingSection:

def is_substring(s, t, nxt = 0):
  return len(s) == [nxt := nxt + 1 for i in t if i == s[nxt]][-1]

и @SmirnGreg:

def is_substring(s: str, t: str):
  return bool(re.match('.*' + '.*'.join(s) + '.*', t)) 

Отдельное спасибо @SmirnGreg за замер скорости исполнения функций (!)

NB! Учитывайте повторяющиеся буквы в подстроке s. Для некоторых решений следующая пара строк отдаёт True, что явно неверно:

s = "agggc"
t = "cgxggxxgxxa"

Присоединяйтесь: раз в неделю задачу решить — это вполне оптимальная нагрузка для занятого кодера.

#задача

@zen_of_python

Задача о комбинировании подстрок

Впрочем, почему бы и нет! Задача от подписчика @StSav012:

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

>>> merge('acfg', 'bcht') 
... 'abcfght'

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

#задача

@zen_of_python

Поздравляем победителей

Задачу о клумбе верно решили:

— Cool and Fun Python (@Python3k);
— @Cheshir78;
— Лев Выскубов;
— @patriarch_chesslovo;
— @vsugoyak;
— @sidor0912;

Кратчайшие верные решения предложили Лев Выскубов:

def is_fitting(flowerbed, n):
  flowerbed = [0] + flowerbed + [0]  # Чтобы на краю можно было цветочек посадить :-)
  k = 0
  for slot in range(1, len(flowerbed) - 1):
    if not any(flowerbed[(slot - 1) : (slot + 2)]):
      flowerbed[slot] = 1
      k += 1
  return k >= n

и @patriarch_chesslovo:

def is_fitting(flowerbed, required_slots):
  is_prev_slot_filled = sum(flowerbed[0:2]) == 0
  vacant_slots = int(is_prev_slot_filled)
  for i in range(1, len(flowerbed)):
    is_curr_slot_filled = not is_prev_slot_filled and sum(flowerbed[i-1:i+2]) == 0
    vacant_slots += int(is_curr_slot_filled)
    is_prev_slot_filled = is_curr_slot_filled
    if vacant_slots >= required_slots:
      return True
  return vacant_slots >= required_slots

Отдельное спасибо @patriarch_chesslovo за описание пограничных случаев (одноместная клумба) и проверку некоторых решений.

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

#задача

@zen_of_python

Поздравляем победителей

Задачу про комбинирование строк верно решили:
— @beibarysm;
— Лев Выскубов;
— @impreza555;
— @sidor0912;
— @vsugoyak

Кратчайшие верные решения предложили Лев Выскубов:

def merge(str1, str2):
  return ''.join(sorted(set(list(str1) + list(str2))))

и @impreza555:

def merge(str1: str, str2: str) -> str:
  return "".join(sorted(set(str1) | set(str2)))

#задача

@zen_of_python

Задача про поворот изображения

На вход подаётся двоичная матрица n x n из нулей и единиц. Наша задача — перевернуть изображение по горизонтали, затем инвертировать его значения.

— Переворот [1,1,0] по горизонтали приводит к [0,1,1].
— Инвертирование изображения означает, что каждый 0 заменяется 1, а каждая 1 заменяется 0.

>>> image = [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
>>> flip(image)
... [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]] 

1. Переворот по горизонтали: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]]
2. Инверсия: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]

#задача

@zen_of_python

​​Поздравляем победителей

Задачу о драгоценностях верно решили:

— Cool and Fun Python (@Python3k);
— @v1ktoriia_romanova;
— @leo5051;
— @lomserman;
— @vsugoyak;
— @sidor0912;
— @ganrre.

Тот редкий случай, когда кратчайшие верные решения в две строки предложили все: @Python3k, @v1ktoriia_romanova, @leo5051, @lomserman, @vsugoyak, @sidor0912, @ganrre.

#задача

@zen_of_python

Задача о горном массиве

Вам даётся массив целых чисел arr. Напишите функцию check_mountain(), которая проверит ряд на последовательное увеличение, затем снижение (смотри картинку).

Существует некий i при условии 0 < i < arr.length - 1, чтобы:

- arr[0] < arr[1] < ... < arr[i - 1] < arr[i] 
- arr[i] > arr[i + 1] > ... > arr[arr.length - 1]

Дополнительное условие:arr.length >= 3

Для проверки:

>>> arr = [3,5,5]
>>> check_mountain(arr)
... False

#задача

@zen_of_python

Поздравляем победителей

Задачу про поворот изображения верно решили:

— @Cheshir78;
— @ipipe_host;
— @savelevgeo;
— @vsugoyak;
— Cool and Fun Python (@Python3k).

Кратчайшие верные решения предложили @Cheshir78:

def flip(image):
   return [[1 - x for x in row[::-1]] for row in image]

и @ipipe_host:

def flip(image):
    return [[abs(j - 1) for j in i[::-1]] for i in image]

Отдельный респект @Python3k за решение, которое понятно на любом уровне Py-знания:

def flip(image: list[list[int]]) -> list[list[int]]:
  """Поворот изображения."""
  n = len(image)
  for row in image:
    row.reverse()
    for i in range(n):
      row[i] = 1 - row[i]
  return image

# пример работы
image = [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
flipped_image = flip(image)
for row in flipped_image:
  print(row)

#задача

@zen_of_python

Задача об email

Адрес электронной почты состоит из локального и доменного имён, разделённых знаком «@». Помимо строчных букв, электронное письмо может содержать один или несколько символов «.» (точка) или «+» (плюс).

Например, в «alice@tproger.ru» alice — это локальное имя, а tproger.ru — доменное. Если вы добавите точки '.' в локальное имя (например, al.ice), почта все равно полетит на тот же адрес alice.

Если вы добавите + в локальное имя, все, что находится после первого такого плюса, будет игнорироваться. Это позволяет фильтровать определённые письма. Например, письмо на m.y+name@email.com будет перенаправлено на my@email.com».

NB! эти правила не распространяются на доменные имена. Возможно использование обоих этих правил одновременно.

Напишите функцию, которая принимает список почт и рассчитывает количество различных адресов, которые фактически получают почту.

>>> emails = ["test.email+alex@tproger.com","test.e.mail+bob.cathy@tproger.ru","testemail+david@t.proger.ru"]
>>> count_emails()
... 2

Объяснение: из перечисленных адресов только testemail@tproger.ru и "testemail@tproger.ru" действительно получат письма.

#задача

@zen_of_python

Поздравляем победителей

Задачу о горном массиве верно решили:

— @ganrre;
— Sergey;
— @v1ktoriia_romanova;
— @sidor0912;
— @vsugoyak.

Кратчайшие верные решения предложили @sidor0912:

check_mountain = lambda a: all((len(i)>1 and i == sorted(set(i)) for i in (a[:a.index(max(a))+1], a[len(a)-1:a.index(max(a))-1:-1])))

и @vsugoyak:

def check_mountain(arr):
  return all([arr[nm-1]<arr[nm] for nm in range(1,len(arr))])

#задача

@zen_of_python

Поздравляем победителей

Задачу про email верно решили:
—@Indiv06;
— @nxiqns;
— @vsugoyak;
— @flydzen;
— @sidor0912.

Кратчайшее верное решение предложил @@flydzen:

def count_emails(emails: list[str]) -> int:
  return len({(sp[0].replace('.', '').split('+')[0], sp[1]) for m in emails if (sp := m.split('@'))})

#задача

@zen_of_python

Задача о частом числе

На входе — массив целых чисел, отсортированный в порядке возрастания, и в нем есть ровно одно целое число, которое встречается чаще в 25% случаев. Напишите функцию find_frequent_num(), которая найдёт это число.

>>> arr = [1,2,2,6,6,6,6,7,10]
>>> find_frequent_num(arr)
... 6

#задача

@zen_of_python

Задача о счастливом числе

На входе матрица m x n различных чисел. Создайте функцию find_luckiest_number(), которая вернет счастливое число — такой элемент, который является минимальным в своей строке и максимальным в своём столбце.

>>> matrix = [[1,10,4,2],[9,3,8,7],[15,16,17,12]]
>>> find_luckiest_number(matrix)
... 12

Объяснение: 12 — минимальное число в своем ряду № 4 и максимальное в столбце № 4.


#задача

@zen_of_python

Поздравляем победителей

Задачу о счастливом числе верно решили:

— @Metimol;
— @longcompetition;
— Sergey;
— @xpos587;
— @vsugoyak;

Кратчайшее верное решение предложил @vsugoyak:

def find_luckiest_number(matrix):
  return ls[0] if len(ls:=[mn for arr in matrix if (mn:=min(arr)) == max(matrix[el][arr.index(mn)] for el in range(len(matrix)))])>0 else None

Отдельный респект @longcompetition за решения с учётом временной сложности алгоритма. Самое то для новичков в этой теме.

#задача

@zen_of_python

Задача о Р̶о̶с̶с̶т̶а̶т̶е̶ зарплатах

Вам дан массив уникальных целых чисел, где salary[i] — это зарплата i-го сотрудника.

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

Для теста:

>>> salaries = [4000,3000,1000,2000]
>>> get_mean_salary(salaries)
... 2500

#задача

@zen_of_python

Поздравляем победителей

Задачу  о повороте матрицы верно решили:
— @Python3k;
— @erg_y;
— @vsugoyak.

Кратчайшее верное решение предложил @vsugoyak:

def turn_matrix(grid, k):
  return [[grid[(place:=(_n+(n:=len(grid[0]))*_m-k))%(n*len(grid))//n][place%n] for _n in range(len(grid[0]))] for _m in range(len(grid))]

#задача

@zen_of_python

Задача о расстоянии между массивами

На входе два массива arr1 и arr2 и целое число d. Напишите функцию find_arr_distance(), которая вернёт расстояние между двумя массивами.

Расстояния определяется как количество элементов arr1[i] таких, что не существует элемента arr2[j], где arr1[i] - arr2[j]| <= d.

Для проверки:

>>> arr1 = [4,5,8], 
>>> arr2 = [10,9,1,8]
>>> d = 2
>>> find_arr_distance(arr1, arr2, d)
... 2

Объяснение:

Для arr1[0]=4 имеем:
|4-10|=6 > d=2
|4-9|=5 > d=2
|4-1|=3 > d=2
|4-8|=4 > d=2

Для arr1[1]=5 имеем:
|5-10|=5 > d=2
|5-9|=4 > d=2
|5-1|=4 > d=2
|5-8|=3 > d=2

Для arr1[2]=8 имеем:
|8-10|=2 <= d=2
|8-9|=1 <= d=2
|8-1|=7 > d=2
|8-8|=0 <= d=2

#задача

@zen_of_python

Задача о Рокфеллере

Вам дан тензор с суммами на счетах, где account[i][j] — это сумма денег, которую имеет i​​​​​​​​​​-й​​​ клиент в j​​​​​​​-м банке.

accounts = [[1,2,5],[3,6,1]] 
У 1-го клиента два счета на сумму 4 (1 + 3)
У 2-го — 8 (2 + 6)
У 3-го — 6 (5 + 1)

Напишите функцию find_richest(), которая найдет Рокфеллера — самого богатого клиента.

Для проверки:

>>> accounts = [[1,2,5],[3,6,1]] 
>>> find_richest(accounts)
... 2

#задача

@zen_of_python