Задания Python Flashcards

Question

# res = 5 ан временной ряд с историей изменения стоимости акции по дням. Необходимо выбрать день покупки и день продажи так, чтобы максимизировать профит от такой сделки, и вернуть размер выручки. Если невозможно провернуть сделку с профитом, то вернуть 0. prices = [7,1,5,3,6,4] теги #собес

Answer 1

A

1

def common_elements(list1, list2):
return sorted(set(list1) & set(list2)) # Используем & для нахождения пересечения множеств

пример

a = [1, 3, 5, 7, 9]
b = [2, 3, 6, 7, 10]

print(common_elements(a, b)) # Выведет: [3, 7]

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

def common_elements(list1, list2):
result = []
for num1 in list1:
for num2 in list2:
if num1 == num2 and num1 not in result:
result.append(num1)
print(result)

пример

list1 = [3, 5, 2, 8, 5]
list2 = [9, 2, 3, 7, 3]

common_elements(list1, list2)

Answer 2

A

def two_sum_indices_double_loop(arr, target):
result = []
for i in range(len(arr)):
for j in range(i + 1, len(arr)):
if arr[i] + arr[j] == target:
result.append((i, j))
return result

Пример запуска

arr = [3, 5, 1, 4, -5, -9, -12]
target = 9

pairs = two_sum_indices_double_loop(arr, target)
print(pairs) # Выведет все пары индексов, где arr[i] + arr[j] == 9

2

def two_sum_indices_dict(arr, target):
seen = {} # словарь: число -> индекс
result = []

for i, num in enumerate(arr):
    needed = target - num
    if needed in seen:
        # Это значит, что arr[seen[needed]] + num == target
        j = seen[needed]
        result.append((j, i))  # (индекс найденного ранее числа, текущий индекс)
    
    Добавляем текущий элемент в словарь
    (так как теперь он будет "просмотренным" для следующих итераций)
			
    seen[num] = i

return result

Пример запуска
arr = [3, 5, 1, 4, -5, -9, -12]
target = 9

pairs_dict_approach = two_sum_indices_dict(arr, target)
print(pairs_dict_approach) # Выведет все пары (i, j), где i < j

Answer 3

A

import pandas as pd

Создаем DataFrame из логов
data = {
“дата”: [
“2023-05-01 12:32:33”,
“2023-05-01 15:12:24”,
“2023-05-01 18:45:03”,
“2023-05-02 11:02:13”,
“2023-05-03 12:31:45”
],
“юзеры”: [1, 2, 1, 1, 3]
}

df = pd.DataFrame(data)

Преобразуем столбец с датой в формат datetime
df[“дата”] = pd.to_datetime(df[“дата”])

Оставляем только дату без времени
df[“дата”] = df[“дата”].dt.date

Накапливаем уникальных пользователей
unique_users = set()
cumulative_counts = []

for date in sorted(df[“дата”].unique()):
users_on_date = df[df[“дата”] == date][“юзеры”].unique()
unique_users.update(users_on_date)
cumulative_counts.append((date, len(unique_users)))

Создаем итоговый DataFrame
result_df = pd.DataFrame(cumulative_counts, columns=[“дата”, “накопительное_число_уникальных_пользователей”])

Answer 4

A

def is_palindrome(s: str) -> bool:
left, right = 0, len(s) - 1

while left < right:
    while left < right and not s[left].isalnum():  # Пропускаем неалфанумерные символы
        left += 1
    while left < right and not s[right].isalnum():  # Пропускаем неалфанумерные символы
        right -= 1
    
    if s[left].lower() != s[right].lower():  # Сравниваем символы без учета регистра
        return False
    
    left += 1
    right -= 1

return True

Примеры использования
examples = [
“Казак”,
“А роза упала на лапу Азора”,
“Do geese see God?”,
“Madam, I’m Adam”,
“Hello, world!”
]

for example in examples:
print(f’“{example}” -> {is_palindrome(example)}’)

Answer 5

A

def compress_ranges(nums):
if not nums:
return “”

# Сортируем числа
nums = sorted(set(nums))

# Переменные для хранения диапазонов
ranges = []
start = nums[0]
end = nums[0]

# Проходим по отсортированному списку
for i in range(1, len(nums)):
    if nums[i] == end + 1:
        end = nums[i]
    else:
        ranges.append(f"{start}-{end}" if start != end else f"{start}")
        start = end = nums[i]

# Добавляем последний диапазон
ranges.append(f"{start}-{end}" if start != end else f"{start}")

return ",".join(ranges)

Примеры
example_1 = [1, 4, 5, 2, 3, 9, 8, 11, 10]
example_2 = [1, 4, 3, 2]

Вывод результатов
compress_ranges(example_1), compress_ranges(example_2)

Answer 6

A

1
from collections import Counter

Исходный массив
nums = [5, 7, 3, 9, 4, 9, 8, 3, 1]

Подсчет количества вхождений каждого числа
counts = Counter(nums)

Фильтруем только те числа, которые встречаются один раз
unique_nums = [num for num, count in counts.items() if count == 1]

Находим максимальное число среди уникальных
max_unique = max(unique_nums) if unique_nums else None

Вывод результата
max_unique

2

Исходный массив
nums = [5, 7, 3, 9, 4, 9, 8, 3, 1]

Создаем словарь для подсчета вхождений
frequency = {}

Заполняем словарь количеством вхождений каждого числа
for num in nums:
if num in frequency:
frequency[num] += 1
else:
frequency[num] = 1

Фильтруем только те числа, которые встречаются один раз
unique_nums = [num for num in nums if frequency[num] == 1]

Находим максимальное число среди уникальных
max_unique = max(unique_nums) if unique_nums else None

Вывод результата
max_unique

Answer 7

A

from pyspark.sql import SparkSession
from pyspark.sql.functions import window, count, col
from pyspark.sql.types import StructType, StructField, TimestampType, StringType

Создаём Spark сессию
spark = SparkSession.builder \
.appName(“RealTimeUserEventProcessor”) \
.getOrCreate()

Определяем схему входных данных
schema = StructType([
StructField(“ts”, TimestampType(), True),
StructField(“user_id”, StringType(), True)
])

Читаем поток данных из Kafka
df = spark.readStream \
.format(“kafka”) \
.option(“kafka.bootstrap.servers”, “kafka:9092”) \
.option(“subscribe”, “user_events”) \
.option(“startingOffsets”, “latest”) \
.load()

Преобразуем JSON-сообщения в структуру данных
events = df.selectExpr(“CAST(value AS STRING)”) \
.selectExpr(“from_json(value, ‘ts TIMESTAMP, user_id STRING’) AS data”) \
.select(“data.*”)

Подсчитываем количество событий для каждого пользователя за последние 15 минут
windowed_counts = events \
.groupBy(window(col(“ts”), “15 minutes”), col(“user_id”)) \
.agg(count(“user_id”).alias(“event_count”))

Фильтруем пользователей, у которых больше 1000 событий
high_activity_users = windowed_counts.filter(col(“event_count”) > 1000)

Подсчитываем количество таких пользователей
user_count = high_activity_users.select(count(“user_id”).alias(“active_users”))

Запускаем потоковую обработку с выводом в консоль
query = user_count.writeStream \
.outputMode(“complete”) \
.format(“console”) \
.start()

query.awaitTermination()

Answer 8

A

import itertools

def split_number(n):
“"”Разбивает число на список чисел, сумма которых равна n”””
parts = []
remaining = n

while remaining > 0:
    part = min(remaining, 5)  # Берем части до 5, чтобы разнообразить разбиение
    parts.append(part)
    remaining -= part

return parts

def check_split(n, numbers):
“"”Проверяет, равна ли сумма элементов numbers числу n без использования + и sum”””

def recursive_add(arr, idx=0):
    if idx == len(arr):
        return 0
    return arr[idx] - (-recursive_add(arr, idx + 1))  # Используем двойное отрицание вместо сложения

return n == recursive_add(numbers)

Примеры
num = 16
split_result = split_number(num)
print(f”Разбиение числа {num}: {split_result}”)
print(f”Проверка: {check_split(num, split_result)}”)

num2 = 10
split_result2 = split_number(num2)
print(f”Разбиение числа {num2}: {split_result2}”)
print(f”Проверка: {check_split(num2, split_result2)}”)

Answer 9

A

s = ‘мамы нет Дома’
reversed_s = s[::-1] # O(N) по времени и памяти
print(reversed_s)

def reverse_string(s):
return ‘‘.join(reversed(s)) # O(N) по времени и памяти

print(reverse_string(s))

Answer 10

A

from collections import Counter
from typing import List, Dict, Tuple

def count_unique_combinations(data: List[Dict]) -> Dict[Tuple, int]:
“””
Находит уникальные комбинации значений в списке словарей и подсчитывает частоту их встречаемости.
:param data: Список словарей с одинаковыми ключами.
:return: Словарь, где ключ - кортеж значений, а значение - частота встречаемости.
“””
if not data:
return {}

# Извлекаем только значения и преобразуем их в кортежи для подсчета
value_tuples = [tuple(d.values()) for d in data]

# Подсчитываем частоту встречаемости уникальных комбинаций
combination_counts = Counter(value_tuples)

return dict(combination_counts)

Пример использования
data = [
{“name”: “Alice”, “age”: 25, “city”: “NY”},
{“name”: “Bob”, “age”: 30, “city”: “LA”},
{“name”: “Alice”, “age”: 25, “city”: “NY”},
{“name”: “Alice”, “age”: 27, “city”: “NY”},
{“name”: “Bob”, “age”: 30, “city”: “LA”}
]

result = count_unique_combinations(data)
print(result)

Answer 11

A

1

from collections import Counter

Исходные строки
s_complex = “Abc CbA Vrd bbb cEc Vbv ecC ECC”
s_simple = s_complex.lower()

Подсчет частоты символов
counter_complex = Counter(s_complex.replace(“ “, “”)) # Убираем пробелы
counter_simple = Counter(s_simple.replace(“ “, “”))

Определяем 3 самых частых символа
top3_complex = counter_complex.most_common(3)
top3_simple = counter_simple.most_common(3)

top3_complex, top3_simple

2

Подсчет частоты символов без использования Counter
def count_chars(s):
char_freq = {}
for char in s.replace(“ “, “”): # Убираем пробелы
if char in char_freq:
char_freq[char] += 1
else:
char_freq[char] = 1
return sorted(char_freq.items(), key=lambda x: x[1], reverse=True)[:3]

Анализируем сложный и легкий вариант
top3_complex_no_counter = count_chars(s_complex)
top3_simple_no_counter = count_chars(s_simple)

top3_complex_no_counter, top3_simple_no_counter

Answer 12

A

my_str = “/a /a/bb /a/bb/c /a/d /a/d/e”

Разбиваем строку по пробелам и сортируем по длине строк
my_list = sorted(my_str.split(), key=len)

Вывод результата
print(my_list)

Если нужно учитывать порядок следования родителей и детей при одинаковой длине, можно отсортировать сначала по длине, затем по алфавиту:

my_list = sorted(my_str.split(), key=lambda x: (len(x), x))
print(my_list)

Answer 13

A

def bubble_sort(arr):
“"”Пузырьковая сортировка”””
n = len(arr)
for i in range(n):
swapped = False
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
swapped = True
if not swapped:
break # Если не было обменов, массив уже отсортирован
return arr

def quick_sort(arr):
“"”Быстрая сортировка (с использованием метода Хоара)”””
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)

def merge_sort(arr):
“"”Сортировка слиянием”””
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])

return merge(left, right)

def merge(left, right):
“"”Функция слияния двух отсортированных массивов”””
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result

Пример использования
arr = [64, 34, 25, 12, 22, 11, 90]
print(“Пузырьковая сортировка:”, bubble_sort(arr[:]))
print(“Быстрая сортировка:”, quick_sort(arr[:]))
print(“Сортировка слиянием:”, merge_sort(arr[:]))

Описание алгоритмов:

Пузырьковая сортировка (Bubble Sort) — простой, но неэффективный алгоритм с временной сложностью O(n²), который проходит по массиву и попарно меняет элементы, если они расположены в неправильном порядке.
Быстрая сортировка (Quick Sort) — использует стратегию "разделяй и властвуй", выбирает опорный элемент (pivot) и рекурсивно сортирует элементы слева и справа от него. В среднем работает за O(n log n).
Сортировка слиянием (Merge Sort) — также использует "разделяй и властвуй", разбивая массив на подмассивы, сортируя их рекурсивно и сливая обратно. Гарантированная сложность O(n log n).