[TOC]
----------------------------------------------------------------------------------------------------
# Деление пирога на равные части
В Институте биоинформатики между информатиками и биологами устраивается соревнование. Победителям
соревнования достанется большой и вкусный пирог. В команде биологов `a` человек, а в команде
информатиков — `b` человек.
Нужно заранее разрезать пирог таким образом, чтобы можно было раздать кусочки пирога любой команде,
выигравшей соревнование, при этом каждому участнику этой команды должно достаться одинаковое число
кусочков пирога. И так как не хочется резать пирог на слишком мелкие кусочки, нужно найти
минимальное подходящее число.
Напишите программу, которая помогает найти это число.
Программа должна считывать размеры команд (два положительных целых числа `a` и `b`, каждое число
вводится на отдельной строке) и выводить наименьшее число dd, которое делится на оба этих числа без
остатка.
````code
a = int(input())
b = int(input())
ma = 1
mb = 1
Pa = a * ma
Pb = b * mb
while Pa != Pb:
if Pa < Pb:
ma = ma + 1
Pa = a * ma
else:
mb = mb + 1
Pb = b * mb
print(Pa)
````
````shell
>(echo 6 & echo 8) | python devide_pie.py
24
````
----------------------------------------------------------------------------------------------------
# Обработка вводимых чисел
Напишите программу, которая считывает целые числа с консоли по одному числу в строке.
Для каждого введённого числа проверить:
- если число меньше 10, то пропускаем это число;
- если число больше 100, то прекращаем считывать числа;
- в остальных случаях вывести это число обратно на консоль в отдельной строке.
````code
while True:
i = int(input())
if i < 10:
continue
elif i > 100:
break
print(i)
````
Выполнение. Входные данные:
````
0
-1
10
100
101
````
````shell
>python process_input.py < process_input_input.txt
10
100
````
----------------------------------------------------------------------------------------------------
# Таблица умножения
Напишите программу, на вход которой даются четыре числа a, b, c и d, каждое в своей строке.
Программа должна вывести фрагмент таблицы умножения для всех чисел отрезка [a; b] на все
числа отрезка [c;d].
Числа a, b, c и d являются натуральными и не превосходят 10, a ≤ b, c ≤ d.
Следуйте формату вывода из примера, для разделения элементов внутри строки используйте
'\t' — символ табуляции. Заметьте, что левым столбцом и верхней строкой выводятся сами числа из
заданных отрезков — заголовочные столбец и строка таблицы.
````code
# a = int(input())
# b = int(input())
# c = int(input())
# d = int(input())
a, b, c, d = 3, 6, 5, 7
print('\t', end='')
for i in range(c, d + 1):
print(i, end='\t')
print()
for i in range(a, b + 1):
print(i, end='')
for j in range(c, d + 1):
print('\t', i * j, sep='', end='')
print()
````
Входные данные:
````
7
10
5
6
````
````shell
5 6
7 35 42
8 40 48
9 45 54
10 50 60
````
----------------------------------------------------------------------------------------------------
# Средне-арифметическое
Напишите программу, которая считывает с клавиатуры два числа a и b, считает и выводит на консоль
среднее арифметическое всех чисел из отрезка [a; b], которые кратны числу 3.
В приведенном ниже примере среднее арифметическое считается для чисел на отрезке [-5; 12].
На вход программе подаются интервалы, внутри которых всегда есть хотя бы одно число, которое
делится на 3.
````code
a = int(input())
b = int(input())
s = 0
n = 0
r = a % 3
if r > 0:
a += 3 - r
for i in range(a, b + 1, 3):
s += i
n += 1
print(s / n)
````
Входные данные:
````
-5
12
````
````shell
4.5
````
----------------------------------------------------------------------------------------------------
# Процентное содержание символов
Напишите программу, которая вычисляет процентное содержание символов G (гуанин) и C (цитозин) в
введенной строке (программа не должна зависеть от регистра вводимых символов).
Например, в строке "acggtgttat" процентное содержание символов G и C равно 4 // 10 * 100 = 40.0 ,
где 4 -- это количество символов G и C, а 10 -- это длина строки.
````code
# g = input().lower()
g = "acAcCcagggf"
print(g)
g = g.lower()
cnt = 0
for n in g:
if n == 'c' or n == 'g':
cnt += 1
print(cnt / len(g) * 100)
````
Входные данные:
````
acggtgttat
````
````shell
40.0
````
----------------------------------------------------------------------------------------------------
# Сумма чисел
Напишите программу, на вход которой подается одна строка с целыми числами. Программа должна вывести
сумму этих чисел.
Используйте метод `split` строки.
````code
s = 0
for i in input().split():
s += int(i)
print(s)
````
Входные данные:
````
4 -1 9 3
````
````shell
15
````
Для решения подобной задачи можно использовать *list comprehension*. Здесь вводится 5 чисел,
каждое на отдельной строке, и требуется вывести сумму модулей этих чисел.
````code
print(sum([abs(float(input())) for _ in range(5)]))
````
Функция `sum()` возвращает сумму элементов списка.
----------------------------------------------------------------------------------------------------
# Сумма соседей
Напишите программу, на вход которой подаётся список чисел одной строкой. Программа должна для
каждого элемента этого списка вывести сумму двух его соседей. Для элементов списка, являющихся
крайними, одним из соседей считается элемент, находящий на противоположном конце этого списка.
Если на вход пришло только одно число, надо вывести его же.
Вывод должен содержать одну строку с числами нового списка, разделёнными пробелом.
````code
a = [int(i) for i in input().split()]
l = len(a)
if l == 1:
print(a[0])
else:
for i in range(l):
if i == 0:
print(a[1] + a[-1], end=' ')
elif i == l-1:
print(a[0] + a[l-2])
else:
print(a[i+1] + a[i-1], end=' ')
````
Входные данные:
````
1 3 5 6 10
````
````shell
13 6 9 15 7
````
----------------------------------------------------------------------------------------------------
# Повторяющиеся числа
Напишите программу, которая принимает на вход список чисел в одной строке и выводит на экран в одну
строку значения, которые встречаются в нём более одного раза.
Для решения задачи может пригодиться метод `sort` списка.
Выводимые числа не должны повторяться, порядок их вывода может быть произвольным.
````code
a = [int(i) for i in input().split()]
a.sort()
printed = False
for i in range(1, len(a)):
if a[i] == a[i - 1]:
if not printed:
print(a[i], end=" ")
printed = True
else:
printed = False
````
Входные данные:
````
4 8 0 3 4 2 0 3
````
````shell
0 3 4
````
----------------------------------------------------------------------------------------------------
# Сумма квадратов
Напишите программу, которая считывает с консоли числа (по одному в строке) до тех пор, пока сумма
введённых чисел не будет равна 0 и сразу после этого выводит сумму квадратов всех считанных чисел.
Гарантируется, что в какой-то момент сумма введённых чисел окажется равной 0, после этого считывание
продолжать не нужно.
В примере мы считываем числа 1, -3, 5, -6, -10, 13; в этот момент замечаем, что сумма этих чисел
равна нулю и выводим сумму их квадратов, не обращая внимания на то, что остались ещё не прочитанные
значения.
````code
s = 0
sq = 0
while True:
a = int(input())
s += a
sq += a * a
if s == 0:
print(sq)
break
````
Входные данные:
````
1
-3
5
-6
-10
13
4
-8
````
````shell
340
````
----------------------------------------------------------------------------------------------------
# Последовательность чисел
Напишите программу, которая выводит часть последовательности 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 ...
(число повторяется столько раз, чему равно). На вход программе передаётся неотрицательное целое
число n — столько элементов последовательности должна отобразить программа. На выходе ожидается
последовательность чисел, записанных через пробел в одну строку.
````code
n = int(input())
d = 1
nd = 0
for i in range(n):
if nd >= d:
nd = 0
d += 1
print(d, end=" ")
nd += 1
````
Входные данные:
````
7
````
````shell
1 2 2 3 3 3 4
````
----------------------------------------------------------------------------------------------------
# Выводит индекс числа
Напишите программу, которая считывает список чисел `lst` из первой строки и число `x` из второй
строки, которая выводит все позиции, на которых встречается число `x` в переданном списке `lst`.
Позиции нумеруются с нуля, если число `x` не встречается в списке, вывести строку "Отсутствует"
(без кавычек, с большой буквы).
Позиции должны быть выведены в одну строку, по возрастанию абсолютного значения.
````code
lst = [int(i) for i in input().split()]
x = int(input())
printed = False
for i in range(len(lst)):
if lst[i] == x:
print(i, end=' ')
printed = True
if not printed:
print("Отсутствует")
````
Входные данные:
````
5 8 2 7 8 8 2 4
8
````
````shell
1 4 5
````
Функция для поиска индекса в строке:
````code
# объявление функции
def find_all(target, symbol):
return [c for c in range(len(target)) if target[c] == symbol]
# считываем данные
s = input()
char = input()
# вызываем функцию
print(find_all(s, char))
````
----------------------------------------------------------------------------------------------------
# Сумма крестиком (матрица)
Напишите программу, на вход которой подаётся прямоугольная матрица в виде последовательности строк.
После последней строки матрицы идёт строка, содержащая только строку "end"
(без кавычек, см. Sample Input).
Программа должна вывести матрицу того же размера, у которой каждый элемент в позиции i, j равен
сумме элементов первой матрицы на позициях (i-1, j), (i+1, j), (i, j-1), (i, j+1). У крайних
символов соседний элемент находится с противоположной стороны матрицы.
В случае одной строки/столбца элемент сам себе является соседом по соответствующему направлению.
````code
m = []
while True:
s = input()
if s == 'end':
break
m.append([int(i) for i in s.split()])
M = len(m)
for i in range(M):
R = len(m[i])
for j in range(R):
print(m[i - 1][j] + m[(i + 1) % M][j] + m[i][j - 1] + m[i][(j + 1) % R], end=' ')
print()
````
Входные данные:
````
inp = [
'9 5 3',
'0 7 -1',
'-5 2 9',
'end'
]
````
````shell
3 21 22
10 6 19
20 16 -1
````
----------------------------------------------------------------------------------------------------
# Нахождение нечетных чисел
Программа находит нечетные числа в списке и выводит их.
````shell
def modify_list(l): # Функция удаляет нечетные числа и деля на 2
L = len(l)
i = 0
while i < L:
if l[i] % 2 == 1:
del l[i]
L -= 1
else:
l[i] = l[i] // 2
i += 1
l = [1, 2, 3, 4, 5, 6]
# l = [11, 2, 13, 14, 5, 6]
l = [10, 2, 8, 5, 7]
# print(l)
# modify_list(l)
````
````code
>python hello.py
[10, 2, 8, 5, 7]
[5, 1, 4]
````
----------------------------------------------------------------------------------------------------
# Упорядочить строки по длине
Даны названия трех городов. Напишите программу, которая определяет самое короткое и самое длинное
название города.
На вход программе подаётся названия трех городов, каждое на отдельной строке.
Программа должна вывести самое короткое и длинное название города, каждое на отдельной строке.
Метод списка `sort()` сортирует список "на месте", т.е. изменяет сам список и ничего не возвращает.
В данном случае *натуральная* сортировка нам не подходит, поскольку она сортирует строки
*лексикографически* (т.е. по алфавиту), а нам требуется по длине строки. Поэтому используем
пользовательскую функцию сравнения, в которую передаем через именованный аргумент `key`. Данная
функция должна принимать элемент списка, а возвращать значение по которому его следует сортировать.
Этим значением является длина строки. Используем анонимную функцию в виде *lambda*-выражения.
Данное выражение состоит из вызова единственной функции `len()`, поэтому можно упростить запись
передав саму функцию `len()` вместо *lambda*-выражения: `citys.sort(len)`. Обратим внимание, что
функция `len()` здесь не вызывается, а передается как функция, которая будет вызвана внутри функции
`sort()`.
Также см. [здесь](#function)
````code
citys = [input() for _ in range(3)]
citys.sort(key=lambda x: len(x))
print(citys[0])
print(citys[2])
````
print(floor(float(input())) + ceil(float(input())))
````code
a, b, c = str(input()), str(input()), str(input())
print(min(a, b, c, key=len ))
print(max(a, b, c, key=len ))
````
---------------------------------------------------------------------------------------------------
# Число в двоичной системе счисления
На вход программе подается натуральное число, записанное в десятичной системе счисления.
Напишите программу, которая переводит данное число в двоичную систему счисления.
````code
n = int(input())
s = []
while n > 0:
s.append(str(n % 2))
n = n // 2
s.reverse()
print(''.join(s))
````
````
5
````
````
101
````
Теоретическая часть для решения данной задачи изложена
[здесь](#positional_number_system).
Но можно использовать готовую функцию для получения бинарного представления числа, так:
````shell
>>> n = 6
>>> print (f'{n:b}')
110
````
---------------------------------------------------------------------------------------------------
# Быстрое возведение в степень
Тривиальный алгоритм возведения целого положительного числа в целую положительную степень
достаточно прост:
````code
def power(base, exponent):
result = 1
for _ in range(exponent):
result *= base
return result
````
Однако математические свойства степеней позволяет существенно повысить производительность данной
операции. Известно что
Хy = (X2)y/2, например:
24 = (22)2
Одно такое преобразование
сокращает количество умножений почти вдвое. Эти преобразования можно продолжить до тех пор, пока
показатель степени не станет равным нулю. Для нечетных показателей степени используем следующее
свойство:
Хy = (Xy-1) * X, например:
23 = (22) * 2
Это будет выглядеть так:
````code
def quick_power(base, exponent):
if exponent == 0:
return 1
elif exponent % 2 == 0:
return quick_power(base * base, exponent / 2)
else:
return quick_power(base, exponent - 1) * base
````
Проверочный код:
````code
def print_power(base, exponent):
print(f"{base} ^ {exponent} = {power(base, exponent)}")
def print_quick_power(base, exponent):
print(f"{base} ^ {exponent} = {quick_power(base, exponent)}")
print('------------- normal power --------------')
print_power(2, 0)
print_power(2, 2)
print_power(2, 3)
print_power(3, 1)
print_power(3, 2)
print_power(2, 10)
print('------------- quick power --------------')
print_quick_power(2, 0)
print_quick_power(2, 2)
print_quick_power(2, 3)
print_quick_power(3, 1)
print_quick_power(3, 2)
print_quick_power(2, 10)
````
Результат:
````shell
>python power.py
------------- normal power --------------
2 ^ 0 = 1
2 ^ 2 = 4
2 ^ 3 = 8
3 ^ 1 = 3
3 ^ 2 = 9
2 ^ 10 = 1024
------------- quick power --------------
2 ^ 0 = 1
2 ^ 2 = 4
2 ^ 3 = 8
3 ^ 1 = 3
3 ^ 2 = 9
2 ^ 10 = 1024
````