Stepik: Задания
Подвиг 1. Допишите текст программы для вычисления евклидового расстояния (гипотенузы) по перемещениям a и b. Округлите результат с точностью до сотых. Полученное значение выведите на экран.
a, b = map(int, input().split()) import math a = round((math.sqrt(a ** 2 + b ** 2)), 2) print(a)
Подвиг 2. Допишите программу для нахождения числа сочетаний из n по k (значения вводятся в программе), используя формулу
Выведите результат в консоль в виде целого числа с помощью функции print.
n, k = map(int, input().split()) import math c = math.factorial(n) / (math.factorial(k) * math.factorial(n - k)) print(int(c))
Подвиг 3. В летний лагерь нужно отвести n детей и m вожатых с помощью автобусов. Максимальная вместимость каждого автобуса 20 человек. Допишите программу для вычисления минимального числа автобусов, необходимых для перевозки детей вместе с вожатыми. Результат выведите в консоль в виде целого числа.
n, m = map(int, input().split()) import math bus = math.ceil((m + n) / 20) print(int(bus))
Подвиг 4. Гелевая ручка стоит x рублей. Сегодня магазин предоставляет скидку в 10% на каждую купленную ручку. Какое наибольшее количество таких ручек можно будет купить на 500 рублей? Результат выведите в консоль в виде целого числа.
x = int(input()) import math x_sell = x * 0.9 pens = math.floor(500 / x_sell) print(int(pens))
Подвиг 5. В магазине продается X синих ручек, Y зеленых, черных в два раза больше, чем синих, а красных в четыре раза больше зеленых. Напишите программу, в которой вводятся целые значения X, Y в одну строку через пробел и выводится на экран общее число ручек в виде целого числа.
X, Y = map(int, input().split()) B = 2 * X R = 4 * Y print(int(X + Y + B + R))
Подвиг 6. Вводится вещественное число. Нужно определить, что его целая часть кратна 3. На экран вывести True, если кратно и False - в противном случае. Задача делается без использования условного оператора.
a = float(input()) print(int(a) % 3 == 0)
Подвиг 7. Вводится стоимость книги X рублей (например, X = 435.78) - положительное вещественное число с точностью до сотых (два знака после запятой). Требуется определить, является ли дробное значение (число после запятой) больше 50. На экран вывести True, если больше и False - в противном случае. Задача делается без использования условного оператора.
price = float(input()) price_int = int(price) price_float = price - price_int price_bool = price_float > 0.50 print(price_bool)
Подвиг 8. Вводятся три целых положительных числа. Необходимо определить, можно ли их интерпретировать (воспринимать) как длины сторон треугольника. Напомню, что сумма длин двух произвольных сторон всегда должна быть больше третьей стороны. На экран вывести True, если треугольник формируется и False - в противном случае. Задача делается без использования условного оператора.
a, b, c = map(int, input().split()) print(a + b > c and a + c > b and b + c > a)
Подвиг 9. Вводится вещественное число. Нужно проверить, что оно попадает или в диапазон [0; 2] или в диапазон [10; 20] (включительно). На экран вывести True, если попадает и False - в противном случае. Задача делается без использования условного оператора.
a = float(input()) print(0 <= a <= 2 or 10 <= a <= 20)
Подвиг 10. Напишите программу ввода двух слов через пробел. Сформируйте новую строку, продублировав первое слово дважды, а второе - трижды (все слова в результирующей строке должны идти через пробел). Результат выведите на экран.
s1, s2 = map(str, input().split()) s1, s2 = str(s1 + ' '), str(s2 + ' ') print(s1 * 2 + s2 * 3)
Подвиг 11. Написать программу ввода двух слов (через пробел в одну строчку). Определить булевы значения для оператора in проверки вхождения первого слова во второе. А также для операторов ==, >, <. Все булевы значения объединить в одну строку через пробел и вывести на экран.
s1, s2 = map(str, input().split()) a = s1 in s2 b = s1 == s2 c = s1 > s2 d = s1 < s2 print(a, b, c, d)
Подвиг 12. Напишите программу ввода строки и отображения на экране ее первого и последнего символа в виде одной строки.
string = str(input()) print(string[0] + string[-1])
Подвиг 13. Напишите программу отображения первых четырех символов из введенной строки. Будем полагать, что строка гарантированно длиной не менее четырех символов.
string = str(input()) print(string[:4])
Подвиг 14. Напишите программу отображения всех символов с нечетными индексами из введенной строки.
string = str(input()) print(string[1::2])
Подвиг 15. Из введенной строки отобразить первые пять символов в обратном порядке. Полагается, что введенная строка имеет минимум пять символов.
string = str(input()) print(string[4::-1])
Подвиг 16. Вводятся два слова (через пробел в одной строке). Длина второго слова меньше первого. Из этих слов выделить символы с нечетными индексами с обрезкой первого слова до длины второго. Сравнить полученные строки между собой на равенство и результат (True или False) вывести на экран. Задачу выполнять без использования условного оператора.
s1, s2 = map(str, input().split()) s1 = s1[:len(s2)] srez1, srez2 = s1[1::2], s2[1::2] print(srez1 == srez2)
Подвиг 17. Вводится строка (слаг). Замените в этой строке все двойные дефисы (--) и тройные (---) на одинарные (-). Подумайте, в какой последовательности следует выполнять эти замены. Результат преобразования выведите на экран.
# Input: dobavlyaem---slagi--slug-k--url---adresam
slag = str(input()).replace('-', ' ').split()
slag = '-'.join(slag)
print(slag)
# Output: dobavlyaem-slagi-slug-k-url-adresamПодвиг 18. Вводятся три целых положительных числа (максимум трехзначные) через пробел в одну строчку. Для двухзначных и однозначных чисел нужно добавить слева незначащие нули так, чтобы все числа содержали по три цифры. Вывести на экран полученные числа в столбик.
# Input: 8 11 123
n1, n2, n3 = map(str, input().split())
n1, n2, n3 = n1.rjust(3, '0'), n2.rjust(3, '0'), n3.rjust(3, '0')
print(f'{n1}\n{n2}\n{n3}')
# Output:
#008
#011
#123Подвиг 19. Вводится два слова в одну строку через пробел. Поставьте между этими словами символ обратного слеша (вместо пробела). Результирующую строку отобразите на экране.
P. S. Задачу реализовать без применения F-строк.
string = str(input().replace(' ', '\\'))
print(string)Подвиг 20. Вводится строка со словами, разделенными пробелом. Необходимо первый пробел заменить на одинарную кавычку, а все остальные - на двойные. Результирующую строку отобразить на экране.
string = str(input().replace(' ', '\"'))
string = string.replace('\"', '\'', 1)
print(string)Подвиг 21. Вводится строка из целых чисел через пробел. Если первое число не равно последнему, то нужно добавить значение True, а иначе - значение False. Результирующий список lst вывести на экран командой: print(*lst).
Реализовать задачу без использования условных операторов.
lst = list(map(int, input().split())) a = lst[0] != lst[-1] lst.append(a) print(*lst)
Подвиг 22. Вводится строка с номером телефона в формате: +7(xxx)xxx-xx-xx Необходимо преобразовать ее в список lst (посимвольно, то есть, элементами списка будут являться отдельные символы строки). Затем, удалить первый '+', число 7 заменить на 8 и убрать дефисы. Отобразить полученный список на экране командой: print("".join(lst))
num = str(input().replace('-', ''))
lst = list(num)
lst.remove('+')
lst[0] = '8'
print("".join(lst))Подвиг 23. В одну строчку через пробел вводятся: имя, отчество и фамилия. Необходимо представить эти данные в виде новой строки в формате: Фамилия И.О. (Например, Сергей Михайлович Балакирев -> Балакирев С.М.).
fio = list(map(str, input().split(' ')))
i, o, f = ''.join(fio[0]), ''.join(fio[1]), ''.join(fio[2])
print(f'{f} {i[0]}.{o[0]}.')
# или так
fio = list(map(str, input().split(' ')))
print(f'{fio[2]} {fio[0][0]}.{fio[1][0]}.')Подвиг 24. Дата некоторого дня характеризуется двумя натуральными числами: m (порядковый номер месяца) и n (число). По введенным m и n (в одну строку через пробел) определить:
а) дату предыдущего дня (принять, что m и n не характеризуют 1 января);
б) дату следующего дня (принять, что m и n не характеризуют 31 декабря).
В задаче принять, что год не является високосным. Вывести предыдущую дату и следующую дату (в формате: mm.dd, где m - число месяца; d - номер дня) в одну строчку через пробел.
P.S. Число дней в месяцах не високосного года, начиная с января: 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
Мой первый вариант решения (вечером):
m, d = map(int, input().split())
m_l, d_l, m_f, d_f = 0, 0, 0, 0
if m == 1 or m == 3 or m == 5 or m == 7 or m == 8 or m == 10 or m == 12:
if d == 31:
d_f, m_f = 1, m + 1
d_l, m_l = d - 1, m
elif 2<= d <= 30:
d_f, m_f = d + 1, m
d_l, m_l = d - 1, m
elif d == 1 and m == 3:
d_f, m_f = d + 1, m
d_l, m_l = 28, m - 1
elif d == 1 and m == 8:
d_f, m_f = d + 1, m
d_l, m_l = 31, m - 1
elif d == 1:
d_f, m_f = d + 1, m
d_l, m_l = 30, m - 1
if m == 4 or m == 6 or m == 9 or m == 11:
if d == 30:
d_f, m_f = 1, m + 1
d_l, m_l = d - 1, m
elif 2<= d <= 29:
d_f, m_f = d + 1, m
d_l, m_l = d - 1, m
elif d == 1:
d_f, m_f = d + 1, m
d_l, m_l = 31, m - 1
if m == 2:
if d == 28:
d_f, m_f = 1, m + 1
d_l, m_l = d - 1, m
elif 2<= d <= 27:
d_f, m_f = d + 1, m
d_l, m_l = d - 1, m
elif d == 1:
d_f, m_f = d + 1, m
d_l, m_l = 31, m - 1
m_l, d_l, m_f, d_f = str(m_l), str(d_l), str(m_f), str(d_f)
print(f"{m_l.rjust(2, '0')}.{d_l.rjust(2, '0')} {m_f.rjust(2, '0')}.{d_f.rjust(2, '0')}")Мой второй вариант решения (утром следующего дня):
m, n = map(int, input().split())
year = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
if n == 1:
yesterday_day, yesterday_month = year[m - 1], m - 1
tomorrow_day, tomorrow_month = n + 1, m
elif n == year[m]:
yesterday_day, yesterday_month = n - 1, m
tomorrow_day, tomorrow_month = 1, m + 1
else:
yesterday_day, yesterday_month = n - 1, m
tomorrow_day, tomorrow_month = n + 1, m
print(f'{yesterday_month:02}.{yesterday_day:02} {tomorrow_month:02}.{tomorrow_day:02}') Подвиг 25. Вводится целое число k (1 <= k <= 365). Определить, каким днем недели (понедельник, вторник, среда, четверг, пятница, суббота или воскресенье) является k-й день не високосного года, в котором 1 января является понедельником.
dotw = ['понедельник', 'вторник', 'среда', 'четверг', 'пятница', 'суббота', 'воскресенье'] day = int(input()) print(dotw[day % 7 - 1])
Подвиг 26. Вводится слово. Необходимо определить, является ли это слово палиндромом (одинаково читается вперед и назад, например, АННА). Регистр букв не учитывать. Если введенное слово палиндром, на экран вывести ДА, иначе - НЕТ.
word = input().lower()
print ('ДА' if word == word[::-1] else 'НЕТ')Подвиг 27. Вводятся три целых положительных числа в одну строку через пробел. Убедиться, что первые два числа - это катеты прямоугольного треугольника, а третье - его гипотенуза. Если проверка проходит (истинна), то вывести на экран ДА, иначе - НЕТ.
a, b, c = map(int, input().split())
print('ДА' if a**2 + b**2 == c**2 else 'НЕТ')Подвиг 28. Вводится четырехзначное число. Проверить, что оно оканчивается на цифру 7. Вывести на экран ДА, если это так и НЕТ - в противном случае.
a = int(list(input()).pop())
print('ДА' if a == 7 else 'НЕТ')Подвиг 29. Вводится слово. Проверить, что в этом слове присутствуют все три буквы: t, h и o (в произвольном порядке). Реализовать программу с помощью одного условного оператора. Если проверка проходит, вывести ДА, иначе - НЕТ.
s = input().lower() print(['НЕТ', 'ДА']['t' in s and 'h' in s and 'o' in s])
Подвиг 30. Вводится список городов в одну строку через пробел. Если в этом списке присутствует город Москва, то удалить его. Вывести на экран результирующий список в виде строки с городами через пробел.
cities = input().split()
if 'Москва' in cities:
cities.remove('Москва')
print(*cities)Подвиг 31. Вводятся четыре целых числа a, b, c, d в одну строку через пробел. Определить, войдет ли в конверт с внутренними размерами a и b мм прямоугольная открытка с размерами с и d мм. Для размещения открытки в конверте необходим зазор в 1 мм с каждой стороны. Открытку можно поворачивать на 90 градусов. Вывести ДА, если входит и НЕТ - если не входит.
a, b, c, d = map(int, input().split()) print(['НЕТ', 'ДА'][(a >= c + 2 and b >= d + 2) or (a >= d + 2 and b >= c + 2)])
Подвиг 32. Работа светофора для пешеходов запрограммирована следующим образом: в начале каждого часа в течение трех минут горит зеленый сигнал, затем в течение двух минут – красный, в течение трех минут – опять зеленый и т. д. Дано вещественное число t, означающее время в минутах, прошедшее с начала очередного часа. Определить, сигнал какого цвета горит для пешеходов в этот момент. На экран вывести сообщение (без кавычек) "green" - для зеленого и "red" - для красного.
t = float(input()) print(['green', 'red'][t % 5 >= 3])
Подвиг 33. Вводится слово. Переменной msg присвоить строку "палиндром", если введенное слово является палиндромом (одинаково читается и вперед и назад), а иначе присвоить строку "не палиндром". Проверку проводить без учета регистра. Программу реализовать с помощью тернарного условного оператора. Значение переменной msg отобразить на экране.
word = input().lower() msg = "палиндром" if word == word[::-1] else "не палиндром" print(msg)
Подвиг 34. Вводится текущее время (секунды) в диапазоне [0; 59]. Если значение равно 59, то следующее должно быть 0. И так по кругу. Необходимо вычислить следующее значение с проверкой граничного значения 59. Реализуйте это с помощью тернарного условного оператора. Результат отобразите на экране.
time = int(input()) next_time = 0 if time == 59 else time + 1 print(next_time)
Подвиг 35. Имеется список базовых нот:
m = ['до', 'ре', 'ми', 'фа', 'соль', 'ля', 'си']
Вводятся три целых числа в диапазоне от 1 до 7 - номера нот, в одну строчку через пробел. Необходимо отобразить указанные ноты в виде строки через пробел, но перед нотами до и фа дополнительно ставить символ диеза '#'. Реализовать эту программу с использованием тернарного условного оператора (он может использоваться несколько раз).
m = ['до', 'ре', 'ми', 'фа', 'соль', 'ля', 'си'] a, b, c = map(int, input().split()) note_1 = '#' + m[a-1] if a in (1, 4) else m[a-1] note_2 = '#' + m[b-1] if b in (1, 4) else m[b-1] note_3 = '#' + m[c-1] if c in (1, 4) else m[c-1] print(note_1, note_2, note_3)
Подвиг 36. Имеется одномерный список длиной 10 элементов, состоящий из нулей: p = [0] * 10
На каждой итерации цикла пользователь вводит целое число - индекс элемента списка p, по которому записывается значение 1, если ее там еще нет. Если же 1 уже проставлена, то список не менять и снова запросить у пользователя очередное число. Необходимо расставить так пять единиц в список. (После этого цикл прерывается).
Программу реализовать с помощью цикла while и с использованием оператора continue, когда 1 не может быть добавлена в список. Результат вывести на экран в виде последовательности чисел, записанных через пробел.
p = [0] * 10 x = None while p.count(1) < 5: x = int(input()) if p[x] != 1: p[x] = 1 else: continue print(*p)
Подвиг 37. На каждой итерации цикла вводится целое число. Необходимо подсчитать произведение только положительных чисел, до тех пор, пока не будет введено значение 0. Реализовать пропуск вычислений с помощью оператора continue, а также использовать цикл while. Результат произведения вывести на экран.
p = 1 a = 1 while a != 0: a = int(input()) if a < 0: continue if a == 0: break p = a * p print(p)
Подвиг 38. Вводится натуральное число n (то есть, целое положительное). В цикле перебрать все целые числа в интервале [1; n] и сформировать список из чисел, кратных 3 и 5 одновременно. Вывести полученную последовательность чисел в виде строки через пробел, если значение n меньше 100. Иначе вывести на экран сообщение "слишком большое значение n" (без кавычек). Использовать в программе оператор else после цикла while.
n = int(input())
i = 1
lst = []
if n >= 100:
print('слишком большое значение n')
else:
while i <= n:
if i % 3 == 0 and i % 5 == 0:
lst.append(i)
i += 1
else:
print(*lst)Подвиг 39. (На использование цикла while). Вводятся названия книг (каждое с новой строки). Удалить из введенного списка все названия, состоящие из двух и более слов (слова в названиях разделяются пробелом). Результат вывести на экран в виде строки из оставшихся названий через пробел.
import sys # считывание списка из входного потока lst_in = list(map(str.strip, sys.stdin.readlines())) lst_out = [] i = 0 while i < len(lst_in): if ' ' not in lst_in[i]: lst_out.append(lst_in[i]) i += 1 print(*lst_out)
Подвиг 40. Вводится натуральное число n. С помощью цикла for найти все делители этого числа. Найденные делители выводить сразу в столбик без формирования списка.
n, i = int(input()), 1 for i in range(1, n+1): if n % i == 0: print(i)
Подвиг 41. Вводится натуральное число n. С помощью цикла for определить, является ли оно простым (то есть, делится нацело только на само себя и на 1). Вывести на экран ДА, если n простое и НЕТ - в противном случае.
n = int(input())
lst = []
for x in range(1, n + 1):
if n % x == 0:
lst.append(x)
print('ДА' if len(lst) == 2 else 'НЕТ')Подвиг 42. Вводится строка. Необходимо найти все индексы фрагмента "ра" во введенной строке. Вывести в строку через пробелы найденные индексы. Если этот фрагмент ни разу не будет найден, то вывести значение -1.
string = input().lower() if not 'ра' in string: print(-1) else: for i in range(len(string)-1): if string[i] + string[i+1] == 'ра': print(i, end = ' ')
Большой подвиг 43. В виде строки записано арифметическое выражение, например: "10 + 25 - 12" или "10 + 25 - 12 + 20 - 1 + 3" и т. д. То есть, количество действий может быть разным.
Необходимо выполнить вычисление и результат отобразить на экране. Полагается, что в качестве арифметических операций здесь используется только сложение (+) и вычитание (-), а в качестве операндов - целые неотрицательные числа. Следует учесть, что эти операторы могут быть записаны как с пробелами, так и без них.
problem = list(input().replace('+', ' + ').replace('-', ' - ').split())
res = []
for i, n in enumerate(problem):
if n.isdigit() and problem[i - 1] == '-':
res.append(-1 * int(n))
elif n.isdigit():
res.append(int(n))
print(sum(res))print(eval(input()))
Подвиг 44. Вводится список в виде целых чисел в одну строку через пробел. Сначала нужно сформировать список из введенной строки. Затем, каждый элемент этого списка продублировать один раз. Результат отобразить на экране в виде строки полученных чисел, записанных через пробел.
nums = list(map(int, input().split())) for i, n in enumerate(nums): if i % 2 == 0: nums.insert(i, n) else: continue print(*nums)
Подвиг 45. Вводится список в виде вещественных чисел в одну строку через пробел. С помощью цикла for необходимо найти наименьшее значение в этом списке. Полученный результат вывести на экран. Реализовать программу без использования функции min, max и сортировки.
nums = list(map(float, input().split())) a, i = None, 1 for i, n in enumerate(nums): if n < nums[i-1]: a = n print(a)
Подвиг 46. Вводится список городов в одну строчку через пробел. Необходимо создать итератор для этого списка и с помощью итератора вывести на экран в столбик первые два значения (названия городов).
cities = input().split() c = iter(cities) print(next(c),next(c),sep="\n")
Подвиг 47. Вводится строка. Нужно создать итератор для перебора символов этой строки. Затем, перебрать через созданный итератор все символы до первого пробела. В процессе перебора символы выводить на экран в одну строчку друг за другом (без пробелов). Гарантируется, что во введенной строке имеется хотя бы один пробел.
string = input() i = iter(string) n = next(i) while n != ' ': print(n, end = '') n = next(i)
Подвиг 48. Вводится четырехзначное целое положительное число. Подумайте, как можно определить итератор для перебора его цифр. Выведите цифры этого введенного числа (с помощью итератора) в одну строчку через пробел.
num = list(str(int(input()))) for i in num: print(i, end = ' ')
Подвиг 1. Вводится натуральное число N (то есть, положительное, целое). Требуется создать двумерный (вложенный) список размером N x N элементов, состоящий из всех единиц, а затем, в последний столбец записать пятерки. Вывести этот список на экран в виде таблицы чисел, как показано в примере ниже.
P.S. Будьте внимательны в конце строк пробелов быть не должно!
N = int(input()) res = [] for i in range(N): res.append([1] * N) for i in res: for n in i: i[N-1] = 5 for i in res: print(*i)
Подвиг 2. Вводится список из URL-адресов (каждый с новой строки). Требуется в них заменить все пробелы на символ дефиса (-). Следует учесть, что может быть несколько подряд идущих пробелов. Результат преобразования вывести на экран в виде строк из URL-адресов.
P. S. Для считывания списка целиком в программе уже записаны начальные строчки.
import sys
lst_in = list(map(str.strip, sys.stdin.readlines()))
for string in lst_in:
string.replace('-', ' ') # на случай, если уже есть дефисы
string = list(string.split()) # преобразовываем каждую строку в список, разбиваем по пробелу
string = '-'.join(string) # преобразовываем список в строку, соединяя между собой одним дефисом
print(string)Подвиг 3. Вводится натуральное число n. Необходимо найти все простые числа, которые меньше этого числа n, то есть, в диапазоне [2; n). Результат вывести на экран в строчку через пробел.
n = int(input())
res=[]
for i in range(2, n):
for j in res:
if i % j == 0:
break
else:
res.append(i)
print(*res)Подвиг 4. Вводится двумерный список размерностью 5 х 5 элементов, состоящий из нулей и, в некоторых позициях, единиц (см. пример ввода ниже). Требуется проверить, не касаются ли единицы друг друга по горизонтали, вертикали и диагонали. То есть, вокруг каждой единицы должны быть нули. Если проверка проходит вывести ДА, иначе - НЕТ.
P. S. Для считывания списка целиком в программе уже записаны начальные строчки.
import sys
s = sys.stdin.readlines()
lst_in = [list(map(int, x.strip().split())) for x in s]
flag = True
lst_in = [[0] * len(lst_in)] + (lst_in) + [[0] * len(lst_in)]
for i in lst_in:
i.append(0)
i.insert(0, 0)
for x, lst in enumerate(lst_in):
if flag == True:
for y, num in enumerate(lst):
if num == 1:
if 1 in lst_in[x][y - 1:y + 1:2] or 1 in lst_in[x + 1][y - 1:y + 1] or 1 in lst_in[x - 1][y - 1:y + 1]:
flag = False
break
else:
break
print('ДА' if flag else 'НЕТ')Подвиг 5. Вводится двумерный список размерностью 5 х 5 элементов, состоящий из целых чисел (пример ввода см. ниже). Проверьте, является ли этот двумерный список симметричным относительно главной диагонали. Главная диагональ — та, которая идёт из левого верхнего угла двумерного массива в правый нижний. Выведите на экран ДА, если матрица симметрична и НЕТ - в противном случае.
P. S. Для считывания списка целиком в программе уже записаны начальные строчки.
import sys
s = sys.stdin.readlines()
lst_in = [list(map(int, x.strip().split())) for x in s]
flag = True
for x in range(len(lst_in)):
if flag == True:
for y in range(len(lst_in)):
if lst_in[x][y] != lst_in[y][x]:
flag = False
break
else:
break
print('ДА' if flag == True else 'НЕТ')Большой подвиг 6. Вводится список целых чисел в одну строку через пробел. Необходимо выполнить его сортировку выбором по возрастанию (неубыванию). Идея алгоритма очень проста и проиллюстрирована на рисунке ниже.
Вначале мы рассматриваем первый элемент списка и ищем второй минимальный относительно первого элемента (включая и его). На рисунке - это последний элемент со значением -1. Затем, меняем местами первый и последний элементы. Переходим ко второму элементу списка и повторяем эту же процедуру, но относительно второго элемента (то есть, первый уже не рассматриваем). На рисунке минимальный элемент - это 2, поэтому менять местами здесь ничего не нужно. Переходим к 3-му элементы со значением 6. Относительно него находим минимальный элемент - это 3. Меняем их местами.
Вот идея алгоритма сортировки выбором. Реализуйте его для вводимого списка целых чисел. Результат выведите в виде списка чисел одну строку через пробел.
lst = list(map(int, input().split()))
for i in range(len(lst)):
min_idx = i
for j in range(i+1, len(lst)):
if lst[j] < lst[min_idx]:
min_idx = j
lst[i], lst[min_idx] = lst[min_idx], lst[i]
print(*lst)Большой подвиг 7. Вводится список целых чисел в одну строку через пробел. Необходимо выполнить его сортировку по возрастанию (неубыванию) методом всплывающего пузырька. Идея алгоритма проста и показана на рисунке ниже.
При первом проходе перебираем все соседние пары элементов и если значение предыдущего элемента (слева) больше значения следующего (справа), то они меняются местами. (На рисунке 3 и 2 меняются местами). Следующая пара - это 3 и 6. Они уже выстроены по возрастанию, поэтому ничего не делаем и переходим к следующей паре 6 и -1. Меняем значения местами и видим, что на последнем месте находится максимальное значение 6, что нам и нужно.
При втором проходе делаем все то же самое, но доходим до предпоследнего элемента, так как последнее значение 6 уже отсортировано. На третьем проходе исключаем уже последние два элемента и так далее. То есть, в этом алгоритме достаточно сделать N-1 проходов, где N - длина списка.
Вот идея алгоритма сортировки всплывающего пузырька. Реализуйте его для вводимого списка целых чисел. Результат выведите в виде списка чисел одну строку через пробел.
lst = list(map(int, input().split()))
for i in range(len(lst)):
flag = False
for j in range(0, len(lst)-i-1):
if lst[j] > lst[j+1]:
lst[j], lst[j+1] = lst[j+1], lst[j]
flag = True
if not flag:
break
print(*lst)Подвиг 8. В некоторой стране используются денежные купюры достоинством в 1, 2, 4, 8, 16, 32 и 64. Вводится натуральное число n. Как наименьшим количеством таких денежных купюр можно выплатить сумму n? Вывести на экран список купюр для формирования суммы n (в одну строчку через пробел, начиная с наибольшей и заканчивая наименьшей). Предполагается, что имеется достаточно большое количество купюр всех достоинств.
sum = int(input())
bill = [64, 32, 16, 8, 4, 2, 1]
banks, a = [], []
for n in bill:
p = sum // n
sum = sum % n
banks.append([n] * p)
for q in banks:
for x in q:
a.append(x)
print(*a)Подвиг 3. Вводится натуральное число N. С помощью list comprehension сформировать двумерный список размером N x N, состоящий из нулей, а по главной диагонали - единицы. (Главная диагональ - это элементы, идущие по диагонали от верхнего левого угла матрицы до ее нижнего правого угла). Результат вывести в виде таблицы чисел как показано в примере ниже.
N = int(input()) lst = [[1 if a == b else 0 for a in range(N)] for b in range(N)] lst = [print(*row) for row in lst]
Подвиг 4. Вводятся названия городов в строку через пробел. Необходимо сформировать список с помощью list comprehension, содержащий названия длиной более пяти символов. Результат вывести в строчку через пробел.
cities = input() lst = [city for city in cities.split() if len(city) > 5] print(*lst)
Подвиг 5. Вводится натуральное число n. Необходимо сформировать список с помощью list comprehension, состоящий из делителей числа n (включая и само число n). Результат вывести на экран в одну строку через пробел.
n = int(input()) lst = [x for x in range(1, n + 1) if n % x == 0] print(*lst)
Подвиг 6. Вводится натуральное число N. Необходимо сгенерировать вложенный список с помощью list comprehension, размером N x N, где первая строка содержала бы все нули, вторая - все единицы, третья - все двойки и так до N-й строки. Результат вывести в виде таблицы чисел как показано в примере ниже.
n = int(input()) lst = [[b for a in range(n)] for b in range(n)] [print(*lst_in) for lst_in in lst]
Подвиг 7. Вводится список вещественных чисел. С помощью list comprehension сформировать список, состоящий из элементов введенного списка, имеющих четные индексы (то есть, выбрать все элементы с четными индексами). Результат вывести на экран в одну строку через пробел.
lst = [float(i) for i in input().split()] lst = [num for i, num in enumerate(lst) if i % 2 == 0] print(*lst)
Подвиг 8. Вводятся два списка целых чисел одинаковой длины каждый с новой строки. С помощью list comprehension сформировать третий список, состоящий из суммы соответствующих пар чисел введенных списков. Результат вывести на экран в одну строку через пробел.
lst_1 = [int(d) for d in input().split()] lst_2 = [int(d) for d in input().split()] res = [lst_1[i] + lst_2[i] for i in range(len(lst_1))] print(*res)
Подвиг 1. Вводится двумерный список в виде таблицы целых чисел (см. пример ниже). С помощью list comprehension преобразовать двумерный список в одномерный так, чтобы значения элементов шли в обратном порядке. Результат отобразить в виде строки из чисел, записанных через пробел.
P. S. Для считывания списка целиком в программе уже записаны начальные строчки.
1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2
import sys s = sys.stdin.readlines() lst_in = [list(map(int, x.strip().split())) for x in s] lst = [x for row in lst_in for x in row][::-1] print(*lst)
Подвиг 2. Вводится список целых чисел в строку через пробел. С помощью list comprehension сформировать из них двумерный список lst размером N x N (квадратную таблицу чисел). Гарантируется, что из набора введенных чисел можно сформировать квадратную матрицу (таблицу). Результат отобразить в виде списка командой:
lst_in = [int(x) for x in input().split()] N = int(len(lst_in) ** 0.5) lst = [[ lst_in[N*i+j] for j in range(N)] for i in range(N)] print(lst)