Возьмем, например, такое уравнение: 5x + 10y + 15z = 100. Какие значения
должны иметь переменные x, y, z, чтобы уравнение было верным (т. е. каковы
корни уравнения)? Они могут быть такими: x = 1, y = 8, z = 1. Или такими: x =
4, y = 2, z = 4. Становится понятно, что корней у подобных уравнений может
быть множество.
Требуется написать программу, выводящую на экран все возможные корни уравнения
вида ax + by + cz = d, где a, b, c, d - коэффициенты (известны), а x, y, z -
переменные (требуется найти). При этом пусть все числа должны быть
натуральными числами (т. е. > 0).
Решается данная задача методом перебора всех возможных значений x, y, z с
учетом их коэффициентов. Так если a = 10 и d = 100, то x может принять
значения от 1 до 10, т.к. 10 * 10 = 100.

    # Найти все возможные корни уравнения вида
    # ax + by + cz = d, где a, b, c, d - задаются,
    # x, y, z - требуется найти.
    # Все числа (коэффициенты и переменные) - натуральные числа (т.е. > 0).
    d = int(input('s = '))
    a = int(input('a = '))
    b = int(input('b = '))
    c = int(input('c = '))
    for i in range(1,d//a):
    	for j in range(1,d//b):
    		for k in range(1,d//c):
    			if i*a + j*b + k*c == d:
    				print("%d*%d + %d*%d + %d*%d = %d" % (a,i,b,j,c,k,d))

Пример выполнения кода:

    s = 20
    a = 2
    b = 4
    c = 6
    2*1 + 4*3 + 6*1 = 20
    2*2 + 4*1 + 6*2 = 20
    2*3 + 4*2 + 6*1 = 20
    2*5 + 4*1 + 6*1 = 20

Обычно данную задачу приводят в ином контексте. Требуется найти, сколько
различных (трех видов) товаров можно купить на определенную сумму.

    summa = int(input("Сколько у вас денег? "))
    subj1 = int(input("Цена экземпляра товара 1: "))
    subj2 = int(input("Цена экземпляра товара 2: "))
    subj3 = int(input("Цена экземпляра товара 3: "))
    for i in range(1, summa // subj1):
    	for j in range(1,summa // subj2):
    		for k in range(1,summa // subj3):
    			if subj1 * (i) + subj2*(j)+subj3*(k) == summa: 
    				print(i,j,k)

Пример выполнения кода:

    Сколько у вас денег? 100
    Цена экземпляра товара 1: 10
    Цена экземпляра товара 2: 20
    Цена экземпляра товара 3: 30
    1 3 1
    2 1 2
    3 2 1
    5 1 1

При этом если ставится условие, чтобы всего количество предметов равнялось
какому-то числу или было не меньше какого-то числа, то в условии инструкции if
следует через логический оператор and добавить второе условие (например, a + b
+ c > 5).

Вводится строка. Необходимо определить в ней проценты прописных (больших) и
строчных (малых) букв.
Как известно в кодировках символы упорядочены, т.е. коды 'a' < 'b'. Поэтому
если очередной символ принадлежит диапазону от 'a' до 'z', значит это строчная
буква; если диапазону от 'A' до 'Z' - то прописная.
Следует использовать ветку elif, а не else, т. к. помимо букв могут быть иные
символы (пробелы, цифры, знаки препинания и др.).
В языке программирования Python можно выполнять "групповое" присваивание. Так
выражение let_s = let_b = 0 является допустимым и означает, что сначала
переменной let_b был присвоен 0, затем значение let_b было присвоено let_s.

    string = input("Введите текст: ")
    length = len(string)
    let_s = let_b = 0
    for i in string:
    	if 'a'<=i<='z':
    		let_s += 1
    	elif 'A'<=i<='Z':
    		let_b += 1
    print("%% строчных букв: %.2f" % (let_s/length * 100))
    print("%% прописных букв: %.2f" % (let_b/length * 100))

Удвоенный знак процента в начале строки вывода стоит для того, чтобы вывести
один знак процента. Иначе одиночный % интерпретируется как начало формата
вывода.
Пример выполнения кода:

    Введите текст: Hello, M!
    % строчных букв: 44.44
    % прописных букв: 22.22

Вывести степени натуральных чисел, не превосходящие данного числа n.
Пользователь задает показатель степени и число n.
**Алгоритм решения задачи:**
1. Ввести показатель степени и присвоить его переменной p.
2. Ввести число n.
3. Пока натуральное число (i) возведенное в степень p меньше или равно n, то
4. выводить на экран i в степени p и
5. увеличивать i на 1 (т.е. переходить к следующему натуральному числу).

    # возведение чисел в заданную степень до заданного предела
    p = int(input("Показатель степени: "))
    n = int(input("Максимальный предел степени: "))
    i = 1
    while i**p <= n:
    	print(i**p, end=' ')
    	i += 1
    print("\nПоследнее число, возводимое в степень:", i-1)

Примеры выполнения кода:

    Показатель степени: 2
    Максимальный предел степени: 100
    1 4 9 16 25 36 49 64 81 100 
    Последнее число, возводимое в степень: 10

    Показатель степени: 3
    Максимальный предел степени: 555
    1 8 27 64 125 216 343 512 
    Последнее число, возводимое в степень: 8

Тема:
Строки

Вводится натуральное число (> 0). Необходимо найти сумму и произведение цифр,
из которых состоит это число. При этом если в числе встречается цифра 0, то ее
не надо учитывать при нахождении произведения.
Алгоритм решения задачи сводится к извлечению последней цифры числа путем
нахождения остатка от деления на 10 и добавлению ее к произведению и сумме.
Далее следует само число разделить нацело на 10, чтобы избавится от последней
цифры. Эти действия следует выполнять до тех пор, пока число больше 0. На
последней итерации цикла однозначное число делится нацело на 10, в результате
чего получается 0 и цикл завершается.
В коде ниже выражение добавления цифры к сумме также можно поместить в ветку if.

    n = int(input())
    mult = 1
    summa = 0
    while n > 0:
    	if n%10 != 0:
    		mult = mult * (n%10)
    	summa = summa + n%10
    	n = n // 10
    print("Сумма цифр:", summa)
    print("Произведение значащих цифр:", mult)

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

    n = input()
    mult = 1
    summa = 0
    for i in n:
    	summa += int(i)
    	if int(i) != 0:
    		mult *= int(i)
    print("Сумма цифр:", summa)
    print("Произведение значащих цифр:", mult)

Примечание. Выражение summa += int(i) - это то же самое, что summa = summa +
int(i). Та же сокращенная форма используется и для умножения.
Через строковое представлениие легко решить и более сложную задачу. Например,
надо посчитать сумму и произведение цифр дробного числа или всех цифр,
встречающихся в строке. В таком случае решение может быть таким:

    n = input()
    mult = 1
    summa = 0
    for i in n:
    	if i in ['1','2','3','4','5','6','7','8','9']: # или '1' <= i <= '9'
    		summa += int(i)
    		if int(i) != 0:
    			mult *= int(i)
    print("Сумма цифр:", summa)
    print("Произведение значащих цифр:", mult)

В прямоугольной системе координат на плоскости выделяют четверти:
![Четверти в прямоугольной системе координат](http://upload.wikimedia.org/wiki
pedia/commons/thumb/d/dd/Descartes_system_2D.png/300px-
Descartes_system_2D.png)
1. I-й четветри соответствуют точки, имеющие обе (x и y) положительные координаты.
2. II-ая четверть: x < 0, y > 0.
3. III-ая четверть: x < 0, y < 0.
4. IV-ая четверть: x > 0, y < 0.

    print("Введите координаты точки:")
    x = float(input("x = "))
    y = float(input("y = "))
    if x > 0 and y > 0:
    	print("Точка находится в I четверти")
    elif x < 0 and y > 0:
    	print("Точка находится в II четверти")
    elif x < 0 and y < 0:
    	print("Точка находится в III четверти")
    elif x > 0 and y < 0:
    	print("Точка находится в IV четверти")
    elif x == 0 and y == 0:
    	print("Точка находится в начале координат")
    elif x == 0:
    	print("Точка находится на оси 'x'")
    elif y == 0:
    	print("Точка находится на оси 'y'")

Задачу можно решить и так:

    if x == 0 and y == 0:
    	print("Точка находится в начале координат")
    elif x == 0:
    	print("Точка находится на оси 'x'")
    elif y == 0:
    	print("Точка находится на оси 'y'") 
    elif x > 0:
    	if y > 0:
    		print("Точка находится в I четверти")
    	elif y < 0:
    		print("Точка находится в IV четверти")
    elif x < 0:
    	if y > 0:
    		print("Точка находится в II четверти")
    	elif y < 0:
    		print("Точка находится в III четверти

Результат:

    Введите координаты точки:
    x = 6
    y = -3
    Точка находится в IV четверти

Определить, принадлежит ли точка с координатами (x;y) кругу радиуса R с
центром в начале координат.
Пользователь вводит координаты точки и радиус круга.
Если выбрать точку на координатной плоскости, то можно увидеть, что проекции
ее координат на оси x и y являются катетами прямоугольного треугольника. А
гипотенуза этого прямоугольного треугольника как раз показывает расстояние от
начала координат до точки. Таким образом, если длина гипотенузы будет меньше
радиуса круга, то точка будет принадлежать кругу; иначе она будет находится за
его пределами.
Длину гипотенузы можно вычислить по теореме Пифагора: квадрат гипотенузы равен
сумме квадратов катетов.

    import math
    print("Введите координаты точки и радиус круга")
    x = float(input("x = "))
    y = float(input("y = "))
    r = float(input("R = "))
    r_xy = math.sqrt(x**2 + y**2)
    if r_xy <= r:
    	print("Точка принадлежит кругу")
    else:
    	print("Точка НЕ принадлежит кругу")

Пример выполнения программы:

    x = 1
    y = -1
    R = 3
    Точка принадлежит кругу

Обратите внимание, можно вводить отрицательные координаты. При возведении в
квадрат все-равно будет получено положительное число.

Определить, сколько в введенном пользотелем числе четных цифр, а сколько
нечетных.
Если число делится без остатка на 2 (т. е. остаток равен нулю), значит оно
четное. Увеличиваем на 1 счетчик четных цифр (even). Иначе число нечетное,
увеличиваем счетчик нечетных цифр (odd). В Python операцию нахождения остатка
от деления выполняет знак %.
Чтобы избавиться от младшего (уже учтенного) разряда число следует разделить
нацело на 10. Деление нацело обозначается так: //.

    a = input()
    a = int(a)
    even = 0
    odd = 0
    while a > 0:
    	if a % 2 == 0:
    		even += 1
    	else:
    		odd += 1
    	a = a // 10
    print("Even: %d, odd: %d" % (even, odd))

Примерный результат:

    65439
    Even: 2, odd: 3

Пользователь вводит либо количество байт, либо килобайт, мегабайт или
гигабайт. Следует перевести значение во все другие единицы измерения.
В 1Кб 1024 байт, 1Мб = 1024Кб и т. д. 1024 - это 210.

    units = input("Выберите единицы измерения:\n \
    \t1 - байты,\n \
    \t2 - килобайты,\n \
    \t3 - мегабайты,\n \
    \t4 - гигабайты.\n№: ")
    qty = float(input("Введите значение: "))
    if units == '1':
    	print("Килобайты: %10.3f" % (qty / 2**10))
    	print("Мегабайты: %10.3f" % (qty / 2**20))
    	print("Гигабайты: %10.3f" % (qty / 2**30))
    elif units == '2':
    	print("Байты: %14d" % (qty * 2**10))
    	print("Мегабайты: %10.3f" % (qty / 2**10))
    	print("Гигабайты: %10.3f" % (qty / 2**20))
    elif units == '3':
    	print("Байты: %14d" % (qty * 2**20))
    	print("Килобайты: %10d" % (qty * 2**10))
    	print("Гигабайты: %10.3f" % (qty / 2**10))
    elif units == '4':
    	print("Байты: %14d" % (qty * 2**30))
    	print("Килобайты: %10d" % (qty * 2**20))
    	print("Мегабайты: %10d" % (qty * 2**10))

Примеры выполнения программы:

    Выберите единицы измерения:
     	1 - байты,
     	2 - килобайты,
     	3 - мегабайты,
     	4 - гигабайты.
    №: 2
    Введите значение: 1679
    Байты:        1719296
    Мегабайты:      1.640
    Гигабайты:      0.002

    Выберите единицы измерения:
     	1 - байты,
     	2 - килобайты,
     	3 - мегабайты,
     	4 - гигабайты.
    №: 4
    Введите значение: 1.345
    Байты:     1444182753
    Килобайты:    1410334
    Мегабайты:       1377

Найти остаток от деления целой части значения функции y = log(x²+ab) на 7 и, в
зависимости от его величины, напечатать сообщение об одном из дней недели.
Значения переменных а, b, x получить случайным образом на указанном
пользователем интервале.
Поскольку три случайных числа вычисляются по одной и той же формуле, то лучше
ее оформить в отдельную функцию.
Функци log модуля math вычисляет натуральный логарифм (если ей не передан
второй аргумент-основание алгоритма).
Для определения дня недели можно было бы использовать условный оператор, но
вариант со списком намного короче.

    import random
    import math
    def rand(s,m):
    	return random.random() * (m - s) + s
    minim = float(input('min: '))
    maxim = float(input('max: '))
    a = rand(minim, maxim)
    b = rand(minim, maxim)
    x = rand(minim, maxim)
    y = math.log(x**2 + a * b)
    n = int(y) % 7
    days = ['пн','вт','ср','чт','пт','сб','вс']
    print(days[n])

    min: 1.6
    max: 9.9
    пт

В списке, состоящем из положительных и отрицательных целых чисел, найти
первый, третий и шестой положительные элементы и вычислить их произведение.
Задача усложнена тем, что, например, третий по счету положительный элемент
может быть далеко не третим в списке, а каким угодно.
**Основная часть алгоритма решения задачи:**
1. Ввести в программу счетчик положительных элементов (j). Присвоить ему значение 1 (т.е. он указывает на первый положительный элемент).
2. Перебирать элементы массива-списка по-очереди. Если очередной элемент положительный и счетчик положительных элементов равен 1 или 3 или 6, то сохранить в соответствующей переменной индекс данного элемента. Кроме того, если шестой положительный элемент найден, то нет смысла продолжать цикл дальше и можно его завершить (оператор `break`).
3. Если в массиве был найден шестой положительный элемент (первый и третий тогда точно найдены), то вычислить произведение.
В программе ниже для заполнения списка используется так называемый генератор.
В данном случае выражение `round(random.random() * 100) - 50` используется в
цикле, который выполняется 20 раз. И на каждой итерации цикла получившееся
число помещается в список a.

    import random
    a = [round(random.random() * 100) - 50 for i in range(20)]
    print(a)
    i = j = 0
    i1 = i3 = i6 = -1
    while i < 20:
    while i < 20:
    	if a[i] > 0:
    		if j == 1:
    			i1 = i
    		elif j == 3:
    			i3 = i
    		elif j == 6:
    			i6 = i
    			break
    		j += 1
    	i += 1
    if i6 > 0:
    	mult = a[i1] * a[i3] * a[i6]
    	print("Индексы элементов:", i1, i3, i6)
    	print("%d * %d * %d = %d" % (a[i1], a[i3], a[i6], mult))

    [-45, 30, 31, -40, 22, -48, -18, -24, -21, 25, -38, 43, 30, 15, -33, -41, -8, 29, 26, 24]
    Индексы элементов: 1 4 12
    30 * 22 * 30 = 19800

В решении данной задачи можно выделить три части:
1. Заполнение квадратной матрицы
2. Вызов функции
3. Функция
#### Заполнение квадратной матрицы
В терминах языка программирования Python матрица - это список с вложенными
списками одинаковой длины. Если говорить о квадратной матрице (а только в этом
случае имеет смысл говорить о ее диагоналях), то количество вложенных списков
и количество элементов в них должно совпадать. Например, список
[[12,45,18][0,3,10][21,18,6]] можно назвать квадратной матрицей.
Пусть квадратная матрица заполняется случайными числами и ее размерность будет
равна 10 (т. е. 10 строк и 10 столбцов). Перед заполнением матрицы, создается
пустой список. Во внешнем цикле осуществляется проход по строкам, которые
представляют собой вложенные списки. Сначала создается пустой вложенный
список, потом во внутреннем цикле он заполняется случайными числами, после
чего уже заполненный добавляется в основной список. При заполнении матрицы
может также осуществляться вывод ее на экран.
#### Вызов функции
Поскольку функция должна уметь по выбору вычислять как сумму главной, так и
побочной диагонали, то в нее необходимо передавать не только список, но и
"сигнал" о том, по какому пути ей идти. Если функция будет возвращать
полученную сумму в основную ветку программы, то вызов функции надо связать с
переменной или поместить как аргумент в функцию `print()`.
Перед вызовом функции надо получить значение переменной-"сигнала". Сумму какой
диагонали вычислять, может выбрать пользователь. Например, если он вводит
символ '1', то вычислять главную диагональ, если '2', то побочную. Так как
пользователь может ввести не только эти символы, а какие угодно, то разумно
заключить вызов функции и вывод результата на экран в конструкцию `if`,
условием выполнения которой будет правильно введенный символ.
#### Функция
При написании функции надо сделать выбор, будет ли она выводить результат на
экран в своем теле или возвращать в основную ветку программы. Пусть функция
возвращает результат, в таком случае она должна содержать оператор return
(обычно, но не обязательно, в конце тела функции), после которого указывается
возвращаемое значение.
Главная диагональ квадратной матрицы идет от левого верхнего угла до нижнего
правого, и, следовательно, каждый элемент такой диагонали имеет совпадающие
первый и второй индексы. При этом индексы следующего элемента диагонали
отличаются от предыдущего на 1. Т.е. первый элемент главной диагонали имеет
индексы [0][0], второй - [1][1] и т.д. Поэтому для нахождения суммы элементов
главной диагонали, надо построчно перебрать матрицу и в каждой строке взять
элемент, номер которого совпадает с номером строки, и добавить его значение в
общую сумму.
Побочная диагональ идет из верхнего правого угла в нижний левый. Индексы ее
элементов обратны. В первой строке это будет последний элемент, во второй -
предпоследний и т.д. Если i - это номер строки, равный в начале 0, то второй
индекс будет вычисляться как (N-1)-i. Выражение (N-1) - это индекс последнего
элемента при индексации с нуля.

    def diagonal(l,c):
        s = 0
        i = 0
        while i < N:
            if c == '1':
                s += l[i][i]
            else:
                s += l[i][N-i-1]
            i += 1
        return s
    from random import random
    N = 10
    a = []
    for i in range(N):
        b = []
        for j in range(N):
            n = int(random()*10)
            b.append(n)
            print("%3d" % n, end='')
        a.append(b)
        print()
    ch = input("Главная (1) или побочная (2): ")
    if ch == '1' or ch == '2':
        summa = diagonal(a,ch)
        print(summa)

Пример выполнения кода:

      1  0  3  6  9  1  6  6  4  1
      2  2  5  2  5  7  0  9  9  0
      4  6  2  1  2  4  0  7  2  8
      6  8  6  3  8  8  5  8  6  9
      0  1  2  1  0  3  8  5  0  1
      5  2  2  7  4  6  4  8  4  1
      1  2  3  9  8  1  1  6  0  6
      9  8  5  3  5  3  6  2  8  7
      8  9  1  4  3  0  0  4  4  1
      3  3  2  2  4  6  1  2  2  4
    Главная (1) или побочная (2): 1
    25

Требуется вычислить, сколько банок краски потребуется, чтобы окрасить
поверхность бака цилиндрической формы. Покрасить надо и снаружи, и изнутри.
Пользователь вводит диаметр и высоту бака, а также какую площадь можно
окрасить одной банкой краски.
Чтобы понять, сколько банок краски потребуется, надо знать площадь цилиндра.
Она представляет собой сумму площадей двух кругов (крышка баки и дно) и
площади непосредственно цилиндрической поверхности. Кроме того, если бак
красится и изнутри, найденную площедь следует умножить на 2.
Площадь круга через диаметр равна pi * d2 / 4.
Площадь цилиндра: pi * d * h (где d и h - диаметр и высота цилиндра).

    d = input("Диаметр бака: ")
    d = float(d)
    h = input("Высота бака: ")
    h = float(h)
    S = input("Окрашиваемая площадь одной банкой: ")
    S = int(S)
    import math
    circle = math.pi * d**2 / 4 
    cylinder = math.pi * d * h
    total = circle * 4 + cylinder * 2 # учитываем и внутреннюю поверхность
    qty = total / S # количество банок краски
    qty = int(qty) + 1 
    print("Количество требуемых банок:", qty)

Выражение `int(qty) + 1` требуется, если надо найти целое значение количества
банок (ведь пол банки не купишь).

Найти сумму и количество элементов последовательности, которые по модулю
больше 0.001. Последовательность: 1/2 - 2/4 + 3/8 - 4/16 + ... - ...
В данной последовательности каждый последующий элемент отличается от
предыдущего:
* знаком,
* числитель увеличен на 1,
* знаменатель увеличен в 2 раза.
Значит каждый следующий элемент ряда вычисляется из текущего по формуле
-(a+1)/(b*2), где a и b \- числитель и знаменатель дроби числа ряда.

    a = 1 # числитель
    b = 2 # знаменатель
    sign = 1 # умножаем на 1 или -1, чтобы поменять знак числа
    n = 0 # количество чисел ряда
    summa = 0 # сумма n-элементов ряда чисел
    while a/b > 0.001:
    	summa += sign * a / b
    	n += 1
    	a = a + 1
    	b = b * 2
    	sign = -sign
    print(summa)
    print(n)

Результат выполнения кода:

    0.2227783203125
    13

Найти расстояние между точками с заданными координатами в n-мерном
пространстве. Расстояние находится по формуле d = sqrt((a1 - b1)2 + (a2 -
b2)^2 + ... + (an - bn)^2), где sqrt - квадратный корень, а1...an -
координаты первой точки, b1..bn - соответствующие координаты второй точки.
#### Особенности решения задачи
Чтобы не вводить каждую координату отдельно, можно запросить сразу все для
каждой точки. Поскольку данные будут иметь строковый тип, то преобразовать их
к списку можно с помощью функции split(). В качестве аргумента функции
передается строка-разделитель, по которому отделяются элементы; если аргумент
отсутствует, то строка разделяется по пробелу. Несмотря на такое разделение,
каждый элемент списка по-прежнему является строкой, а не числом.
Фунция zip() возвращает кортежи соответствующих элементов последовательностей.
Т.е. если ей передать два списка, то на первой итерации будет возвращен кортеж
из первых элементов обоих списков, на второй - из вторых и т. д.

    import math
    n = input("Количество измерений пространства: ")
    print("Через пробел")
    a = input("введите " + n + " координаты 1-ой точки: ")
    b = input("введите " + n + " координаты 2-ой точки: ")
    n = int(n)
    a = a.split()
    b = b.split()
    if len(a) != n or len(b) != n: 
    	print("Неверный ввод!")
    	exit()
    sum_sqr = 0
    for i, j in zip(a,b):
    	sum_sqr += (int(i)-int(j))**2
    distance = math.sqrt(sum_sqr)
    print("Расстояние между точками: %.2f" % distance)

Пример работы программы:

    Количество измерений пространства: 4
    Через пробел
    введите 4 координаты 1-ой точки: 2 3 -7 4
    введите 4 координаты 2-ой точки: 0 0 0 0
    Расстояние между точками: 8.83

Вычислить продолжительность года на двух планетах по введенным их радиусам
орбит и скорости движения по орбитам.
Выяснить, правда ли, что год на первой платете длиннее, чем на второй.
Продолжительность года вычисляется по формуле 2 * радиус_орбиты * пи /
орбитальная_скорость.

    import math
    planet1 = input("Планета №1: ")
    r1 = float(input("Радиус ее орбиты (млн. км): "))
    v1 = float(input("Ее орбитальная скорость (км/с): "))
    r1 = r1 * 1000000 # переводим миллионы км в просто км
    year1 = 2 * math.pi * r1 / v1
    year1 = year1 / (60 * 60 * 24) # переводим секунды в дни
    planet2 = input("Планета №2: ")
    r2 = float(input("Радиус ее орбиты (млн. км): "))
    v2 = float(input("Ее орбитальная скорость (км/с): "))
    r2 = r2 * 1000000 
    year2 = 2 * math.pi * r2 / v2
    year2 = year2 / (60 * 60 * 24) 
    print("Длина года в днях на планете %s: %2.f" % (planet1, year1))
    print("Длина года в днях на планете %s: %2.f" % (planet2, year2))
    print("Длина года на %s больше, чем на %s? %s" % (planet1, planet2, year1 > year2))

Примерные результаты выполнения программы:

    Планета №1: Земля
    Радиус ее орбиты (млн. км): 150
    Ее орбитальная скорость (км/с): 30
    Планета №2: Венера
    Радиус ее орбиты (млн. км): 108
    Ее орбитальная скорость (км/с): 35
    Длина года в днях на планете Земля: 364
    Длина года в днях на планете Венера: 224
    Длина года на Земля больше, чем на Венера? True

    Планета №1: Земля
    Радиус ее орбиты (млн. км): 149.598261
    Ее орбитальная скорость (км/с): 29.783
    Планета №2: Марс
    Радиус ее орбиты (млн. км): 227.94382
    Ее орбитальная скорость (км/с): 24.13
    Длина года в днях на планете Земля: 365
    Длина года в днях на планете Марс: 687
    Длина года на Земля больше, чем на Марс? False

Найти площадь и периметр прямоугольного треугольника по двум заданным катетам.
Площадь прямоугольного треугольника равна половине площади прямоугольника,
стороны которого равны длинам катетов. Периметр же находится путем сложения
длин всех сторон треугольника.
Поскольку известны только катеты, то гипотенузу можно найти по теореме
Пифагора: c2 = a2 \+ b2.
Чтобы извлечь квадратный корень в Python можно воспользоваться функцией sqrt()
из модуля math.

    import math
    AB = input("Длина первого катета: ")
    AC = input("Длина второго катета: ")
    AB = float(AB)
    AC = float(AC)
    BC = math.sqrt(AB**2 + AC**2)
    S = (AB * AC) / 2
    P = AB + AC + BC
    print("Площадь треугольника: %.2f" % S)
    print("Периметр треугольника: %.2f" % P)

Результат:

    Длина первого катета: 5.4
    Длина второго катета: 2.1
    Площадь треугольника: 5.67
    Периметр треугольника: 13.29

Вводится строка, состоящая из слов, разделенных пробелами. Требуется
отсортировать слова в строке так, чтобы наиболее короткие из них были вначале
строки, а наиболее длинные в конце.
**Алгоритм решения задачи:**
1. Преобразуем строку в список слов. Для этого следует воспользоваться методом `split()`.
2. Измерим длину получившегося списка. Это значение показывает количество элементов списка, т.е. количество слов.
3. Используя метод пузырька, отсортируем элементы списка по их длине. Во внутреннем цикле сортировки должны сравниваться не значения элементов, а их длина.
4. Создадим пустую строку. В цикле по элементам списка будем добавлять каждое слово в конец этой новой строки, а также добавлять пробел после каждого слова.

    s = input()
    l = s.split()
    ln = len(l)
    for i in range(ln-1):
        for j in range(ln-1-i):
            if len(l[j]) > len(l[j+1]):
                l[j],l[j+1] = l[j+1],l[j]
    s = ''
    for i in range(ln):
        s += l[i] + ' '
    print(s)

Пример работы программы:

    ab aaab ba baaaaa a aba
    a ab ba aba aaab baaaaa

В зависимости от того, что выберет пользователь, вычислить площадь либо
прямоугольника, либо треугольника, либо круга. Если выбраны прямоугольник или
треугольник, то надо запросить длины сторон, если круг, то его радиус.
Площадь треугольника вычисляется по формуле Герона:
![Формула Герона](http://yandex.st/serp/0xdd2480d/libs/z-math/blocks/z-math/fo
rmula/z-math__formula_for_tri-square-abc-f.png)

    figure = input("Выберите фигуру (1-прямоугольник, 2-треугольник, 3-круг): ")
    if figure == '1':
    	print("Длины сторон прямоугольника:")
    	a = float(input("a = "))
    	b = float(input("b = "))
    	print("Площадь: %.2f" % (a*b))
    elif figure == '2':
    	print("Длины сторон треугольника:")
    	a = float(input("a = "))
    	b = float(input("b = "))
    	c = float(input("c = "))
    	p = (a + b + c) / 2
    	import math
    	s = math.sqrt(p * (p - a) * (p - b) * (p - c))
    	print("Площадь: %.2f" % s)
    elif figure == '3':
    	r = float(input("Радиус круга R = "))
    	import math
    	print("Площадь: %.2f" % (math.pi*r**2))
    else:
    	print("Ошибка ввода")

Пример выполнение программы:

    Выберите фигуру (1-прямоугольник, 2-треугольник, 3-круг): 2
    Длины сторон треугольника:
    a = 4.5
    b = 2.8
    c = 6.1
    Площадь: 5.87

В заданной строке найти самое короткое слово. Слова могут быть разделены
пробелами, несколькими пробелами, знаками препинания.
**Алгоритм решения задачи:**
1. Длина очередного слова будет храниться в переменной w. Вначале присвоим этой переменно 0, т. к. в строке слов может вообще не быть.
2. Длина самого короткого слова будет записана в переменной min_w. Вначале этой переменной присваивается максимально возможная длина слова. Самое длинное слово может быть, если вся строка состоит только из одного слова. Поэтому сначала min_w равна длине строки.
3. Перебираем строку посимвольно в цикле for.
4. Если очередной символ является буквой, то увеличиваем значение w.
5. Иначе проверяем не меньше ли длина только что "измеренного" слова, чем значение min_w. Если это так, то меняем значение min_w на значение w.
6. Также в ветке else (иначе) обнуляем w, т.к. очередное слово закончилось и необходимо будет "измерять" новое.

    s = input()
    w = 0
    min_w = len(s)
    for i in s:
    	if 'a'<=i<='z' or 'A'<=i<='Z' \
    	or 'а'<=i<='я' or 'А'<=i<='Я':
    		w += 1
    	else:
    		if w < min_w and w != 0:
    			min_w = w
    		w = 0
    print(min_w)

Пример работы программы:

    Кто сказал мяу?            3
========
    1   what 
    4

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

    print(10,235)
    print(1000,50)

то результат будет выглядеть так:

    10 235
    1000 50

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

    print("%5d%7d" % (10,235))
    print("%5d%7d" % (1000,50))

Результат:

       10     235
     1000     50

Здесь в кавычках указаны форматы данных и ширина полей. После знака % за
кавычками указаны данные, которые будут подставлены вместо каждого указанного
формата. Если количество форматов не совпадает с количеством данных, то
возникнет ошибка.
Форматы данных могут быть: d - целое число, s - строка, f - вещественное
число.
По умолчанию данные выравниваются по правому краю поля. Чтобы выровнять их по
левому достаточно поставить знак минус перед числом, обозначающим ширину поля.
Пример:

    print("%-5d%7d" % (10,235))
    print("%-5d%7d" % (1000,50))

Вывод:

    10       235
    1000      50

Дан массив слов. Требуется заменить последние три символа слов, имеющих
определенную длину, на символ $.
Если длина очередного слова больше определенной длины, то взять срез от начала
слова и до конца, но без трех последних символов и присоединить к этому срезу
символ $. Далее следует заменить в массиве старую строку на полученную.
Выражение words[i][0:-3] означает, что из массива-списка сначала "берется"
очередная строка, а далее из нее берется указанный срез.

    words = []
    for i in range(10):
    	words.append(input())
    i = 0
    while i < len(words):
    	if len(words[i]) > 5:
    		words[i] = words[i][0:-3] + '$'
    	i += 1
    print(words)

Пример выполнения кода:

    keybord
    display
    processor
    where
    you
    kitchen
    window
    small
    big
    monster
    ['keyb$', 'disp$', 'proces$', 'where', 'you', 'kitc$', 'win$', 'small', 'big', 'mons$']

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

    s = input()
    l = len(s)
    integ = []
    i = 0
    while i < l:
        s_int = ''
        a = s[i]
        while '0' <= a <= '9':
            s_int += a
            i += 1
            if i < l:
                a = s[i]
            else:
                break
        i += 1
        if s_int != '':
            integ.append(int(s_int))
    print(integ)

    5 dkfj78df 9 8 dkfj8
    [5, 78, 9, 8, 8]

Дан ряд чисел 1, -0.5, 0.25, -0.125, ... Требуется найти сумму стольких его
элементов, сколько указал пользователь. Например, если n = 3, то надо сложить
1, -0.5, 0.25, что в результате даст 0.75.
При решении таких задач сначала необходимо определить, в чем заключается
особенность предложенного ряда. В данном случае видим, что каждый последующий
элемент в 2 раза меньше предыдущего по модулю, но взят с противоположным
знаком. Далее следует найти арифметическое действие, которое из предыдущего
элемента дает последующий. Здесь, например, надо предыдущий элемент делить на
-2.
**Алгоритм решения задачи:**
1. Присвоим переменной a первое число ряда.
2. Создадим счетчик суммированных элементов ряда (i).
3. Создадим переменную для накопления суммы элементов ряда.
4. Пока счетчик не отсчитает заданного количества элементов ряда (пока i < n) будем выполнять нижеследующие действия.
5. К сумме будем добавлять значение текущего элемента.
6. Изменим значение текущего элемента на то, которое должно быть следующим (разделим на -2).
7. Увеличим значение счетчика на 1.

    n = input("Количество элементов ряда: ")
    n = int(n)
    a = 1
    i = 0
    summa = 0
    while i < n:
    	summa += a
    	a = a/-2
    	i += 1
    print(summa)

Примеры выполнения:

    Количество элементов ряда: 4
    0.625

    Количество элементов ряда: 10
    0.666015625

Допустим, дана строка слов, разделенных пробелами. Необходимо найти в ней
самое длинное слово и заменить в нем буквы 'a' на буквы 'b'.
Сразу следует оговорить, что в отличие, скажем от Pascal, в Python строки
неизменяемы. Т.е. в Питоне изменить символы в строке в принципе нельзя.
Поэтому есть только один выход: сформировать новую измененую строку, или
просто заменять определенные символы при выводе их на экран. Выберем первый
путь.
Сформировать новую строку также можно двумя способами (как минимум):
* преобразовать исходную в список, выполнить в нем замену, а затем элементы списка соединить в новую строку,
* вырезать из первой строки все символы до самого длинного слова, посимвольно добавить к ней изменяемое длинное слово, досоединить остаток первой строки.
Логически первый способ проще.
Сам алгоритм поиска самого длинного слова выгляд так:
1. Если очередной символ не пробел, то увеличиваем счетчик букв слова.
2. Если все же пробел, то проверяем не самое ли это длинное на данный момент слов. Если это так, то запоминаем длину этого слова (max_w) и индекс начала слова (id_w).
3. Поскольку последнее слово могло быть не проверено в цикле, то делаем еще одну проверку длины слова за пределами цикла.
При замене букв символы слова перебираются, и если встретиться "нужная" буква,
то вместо нее записывается другая.

    s = input()
    s = list(s) # преобразуем в список
    l = len(s)
    max_w = 0
    id_w = 0
    count = 0
    i = 0
    while i < l:
    	if s[i] != ' ':
    		count += 1
    	else:
    		if count > max_w:
    			max_w = count
    			id_w = i - count
    		count = 0
    	i += 1
    if count > max_w: # проверяем последнее слово
    	max_w = count
    	id_w = i - count
    id_w_end = id_w + max_w
    while id_w < id_w_end:
    	if s[id_w] == 'a':
    		s[id_w] = 'b'
    	id_w += 1
    s1 = ''
    for i in s:
    	s1 += i	
    print(s1)

Второй способ - через срезы. Здесь не надо в начале программы преобразовывать
строку к списку.

    # часть кода - только замена символов
    s1 = s[0:id_w]
    id_w_end = id_w + max_w
    while id_w < id_w_end:
    	if s[id_w] == 'a':
    		s1 += 'b'
    	else:
    		s1 += s[id_w]
    	id_w += 1
    s1 += s[id_w:]
    print(s1)

Пример выполнения кода:

    very many variants and variables
    very many variants and vbribbles

В общем случае алгоритм решения данной задачи можно свести к следующему:
1. Если очередной элемент меньше нуля, то увеличиваем счетчик отрицательных элементов и добавляем значение элемента к общей сумме отрицательных элементов.
2. Находим среднее арифметическое среди отрицательных элементов, разделив сумму значений элементов на количество найденных элементов.
3. Находим минимальный элемент в массиве. Определяем его индекс. Заменяем значение по найденному индексу на вычисленное выше среднее арифметическое.
Третью подзадачу (замену минимального элемента) можно решить двумя подходами:
1) написать цикл поиска минимального элемента и его индекса или 2)
воспользоваться фунциями встроенными в язык Python (по-сравнению с тем же
Pascal в Python много "дополнительных инструментов").
Функция min() возвращает минимальный элемент из переданного ей аргумента.
(Передавать можно не только список.)
Метод index() возвращает индекс переданного ему элемента в последовательности,
к которой он применяется.

    arr = []
    count = 0 # количество отрицательных элементов
    summa = 0 # сумма отрицательных элементов
    for i in range(10):
    	item = int(input(str(i) + ' item: '))
    	arr.append(item)
    	if item < 0:
    		count += 1
    		summa += item
    if count != 0:
    	mean = summa/count # среднее арифметическое
    	minimal = min(arr) # значение минимального элемента в списке-массиве
    	min_id = arr.index(minimal) # индекс минимального элемента 
    	arr[min_id] = round(mean)
    	print(mean)
    	print(arr)

Пример выполнения кода:

    0 item: 4
    1 item: 5
    2 item: 6
    3 item: 7
    4 item: 8
    5 item: 9
    6 item: -2
    7 item: -6
    8 item: -3
    9 item: 0
    -3.6666666666666665
    [4, 5, 6, 7, 8, 9, -2, -4, -3, 0]

Решение задачи в "классическом" стиле (без использования функций min() и
index() может выглядеть так:

    arr = []
    count = 0 
    summa = 0 
    min_id = 0 # индекс минимального элемента
    for i in range(10):
    	item = int(input(str(i) + ' item: '))
    	arr.append(item)
    	if item < 0:
    		count += 1
    		summa += item
    		if item < arr[min_id]:
    			min_id = i
    if count != 0:
    	mean = summa/count 
    	arr[min_id] = round(mean)
    	print(mean)
    	print(arr)

Дан список-массив, заполненный случайным образом нулями и единицами. Найти
самую длинную непрерывную последовательность единиц и определить индексы
первого и последнего элементов в ней.
**Решение задачи:**
1. Пусть переменная count содержит текущее значение количества единиц, а max_count - максимально найденное на данный момент. Переменная index хранит индекс последнего элемента в самой длинной на данный момент последовательности единиц.
2. Если очередной элемент 0, то переменная count обнуляется. Однако перед этим ее значение сравнивается с max_count и, если count больше, то max_count перезаписывается на него. В index помещается индекс последнего элемента найденной последовательности единиц.
3. При выводе данных на экран, чтобы получить индекс первого элемента последовательности, надо из последнего вычесть уменьшенную на единицу длину последовательности.

    import random
    a = []
    for i in range(50):
    	n = int(random.random() * 2)
    	a.append(n)
    	print(n,end=' ')
    	if (i+1) % 10 == 0: print()
    count = 0
    max_count = 0
    index = 0
    i = 0 
    while i < len(a):
    	if a[i] == 1:
    		count += 1
    	else:
    		if count > max_count:
    			max_count = count
    			index = i-1 # последовательность закончилась на предыдущем элементе
    		count = 0
    	i += 1
    print("Количество элементов: ", max_count)
    print("id первого элемента: ", index-max_count+1)
    print("id последнего элемента: ", index)

Пример выполнения кода:

    1 0 1 0 0 1 0 1 1 0 
    1 1 0 0 1 1 1 1 1 0 
    1 1 1 1 0 0 1 1 0 1 
    0 0 0 0 1 1 0 1 1 0 
    1 1 0 1 0 0 0 0 0 1 
    Количество элементов:  5
    id первого элемента:  14
    id последнего элемента:  18

В строке заменить пробельные символы знаком звездочки ("*"). Если встречается
подряд несколько пробелов, то их следует заменить одним знаком "*", пробелы в
начале и конце строки удалить.
**Алгоритм решения задачи:**
1. Посимвольно просмотреть строку с ее начала. Запомнить номер первого непробельного символа. Взять срез из строки от первого непробельного символа до ее конца.
2. Просмотреть строку с конца. Запомнить номер первого непробельного символа с конца. Взять срез из строки от ее начала до первого непробельного символа с конца.
3. Присвоить новой строке первый символ старой (он в любом случае не пробел).
4. Посимвольно просматривать старую строку. Если очередной символ не является пробелом, то формировать новую строку добавлением к ней этого символа. В ветку `elif` попадают символы пробела, но здесь проверяется не был ли равен предыдущий символ пробелу. И если это не так (не был равен), то только тогда к новой строке добавляется "*". Лишние пробелы будут просто пропущены и не добавлены к новой строке.

    s = input()
    i = 0
    while s[i] == ' ': i+=1
    s = s[i:]
    i = len(s)
    while s[i-1] == ' ': i-=1
    s = s[:i]
    s1 = s[0]
    i = 1
    while i < len(s):
    	if s[i] != ' ':
    		s1 += s[i]
    	elif s[i-1] != ' ':
    		s1 += '*'
    	i += 1
    print(s1+'!')

Пример выполнения скрипта:

       one    two three four f*ve    six seven      one*two*three*four*f*ve*six*seven!

Однако в языке программирования Python данную задачу проще решить,
преобразовав строку в список или возможно через регулярные выражения.
С помощью метода split() строка разделяется на слова по пробелам. При этом
неважно сколько их. Далее остается только снова собрать слова в строку через
"*":

    s = input()
    l = s.split()
    s1 = ''
    for i in l:
    	s1 += i + '*'
    s1 = s1[:-1] # удаляем последнюю "*"	
    print(s1)

Требуется убедиться, что брать кредиты не выгодно. Т. е. надо вычислить,
сколько придется платить в месяц по займу и сколько всего отдать денег банку
за весь период.
Месячная выплата по займу вычисляется по такой загадочной формуле:
m = (s * p * (1 + p)n) / (12 * ((1 + p)n – 1)).
Мы не будем разбирать ее смысл, т.к. все-равно не осилим.
Достаточно знать, что в этой формуле:
m - размер месячной выплаты;
s - сумма займа (кредита);
p - процент банка, выраженный в долях единицы (т. е. если 20%, то будет 0.2).
n - количество лет, на которые берется займ.
Код решения данной задачи на языке Python может выглядеть так:

    amount = input("Сколько хотите взять денег: ")
    amount = int(amount)
    pct = input("Под какой процент вам их дают: ")
    pct = int(pct)
    years = input("Насколько лет берете: ")
    years = float(years)
    pct = pct / 100 
    month_pay = (amount * pct * (1 + pct)**years) / (12 * ((1 + pct)**years - 1))
    print("Ваш месячный платеж составит: %.2f" % month_pay)
    summa = month_pay * years * 12
    print("За весь период вы заплатите: %.2f" % summa)
    print("Это составит %.2f%% от первоначальной суммы" % ((summa / amount) * 100))

Здесь следует обратить внимание на операции с различными типами данных.
Значение years преобразутеся к вещественному типу, т.к. кредит можно взять не
на целое количество лет. В выражении pct = pct / 100 получается дробное число
(т.е. переменная pct теперь связана с вещественным типом данных).
Примерные результаты:

    Сколько хотите взять денег: 1000000
    Под какой процент вам их дают: 15
    Насколько лет берете: 10
    Ваш месячный платеж составит: 16604.34
    За весь период вы заплатите: 1992520.63
    Это составит 199.25% от первоначальной суммы

    Сколько хотите взять денег: 2000000
    Под какой процент вам их дают: 20
    Насколько лет берете: 20
    Ваш месячный платеж составит: 34226.09
    За весь период вы заплатите: 8214261.23
    Это составит 410.71% от первоначальной суммы

    Сколько хотите взять денег: 35000
    Под какой процент вам их дают: 10
    Насколько лет берете: 0.5
    Ваш месячный платеж составит: 6267.36
    За весь период вы заплатите: 37604.15
    Это составит 107.44% от первоначальной суммы

Определить количество простых чисел введенных пользователем.
**Алгоритм решения задачи:**
1. Пока не будет введено число меньшее или равное 1 (т.к. простым числом может быть только натуральное число большее единицы) будем выполнять нижеследующие действия.
2. Установим флаговую переменную в значение True.
3. Проверим число на простоту путем деления на него всех целых чисел от 2 до корня из него (почему именно до корня см. математику).
4. Если число делится нацело хотя бы на один делитель, то оно не простое. Меняем значение флаговой переменной на False.
5. Если же флаговая переменная не была изменена, то число простое, и мы увеличиваем счетчик количества введенных простых чисел.

    import math
    count = 0
    n = int(input())
    while n > 1:
    	f = True 
    	for i in range(2, round(math.sqrt(n))+1):
    		if n % i == 0:
    			f = False
    	if f:
    		count += 1
    	n = int(input())
    print("Было введено", count, "простых чисел")

Пример выполнения кода:

    35
    18
    10
    11
    197
    3
    17
    1
    Было введено 4 простых чисел

В Python над двумя строками можно выполнить операцию, обозначаемую знаком +.
Однако, в отличие от чисел, выполняетя не сложение (что для строк в принципе
невозможно), а соединение, т. е. к концу первой строки добавляется вторая. По-
другому операция соединения строк называется **конкатенацией**.
Кроме того, в Python есть операция повторения (мультипликации) строки. Она
обозначается знаком * (также как операция умножения для чисел). При повторении
строки с одной стороны от знака * ставится строка, а с другой число,
обозначающее количество повторов. При этом не важно, какой объект с какой
стороны находится (слева от знака можно писать число, а справа - строку).
В одном выражении можно сочетать операции конкатенации и мультипликация. При
этом более высокий приоритет у операции повторения строки. Это видно в примере
ниже: когда опущены скобки, то сначала строка s2 повторяется n раз, а затем
результат присоединяется к s1.

    s1 = input("Введите первую строку: ")
    s2 = input("Введите вторую строку: ")
    n = int(input("Введите количество повторов: "))
    print(s1 + s2 * n)
    print((s1 + s2) * n)
    print(s1 + str(n)) # error if just (s1 + n)
    print('^' * 20)
    print('Hello' + 'world')
    print('Hello','world')

В последней строке кода конкатенации нет. Просто функции print() передано два
аргумента, которые она выводит на экран.
Результат выполнения скрипта:

    Введите первую строку: rt
    Введите вторую строку: -
    Введите количество повторов: 5
    rt-----
    rt-rt-rt-rt-rt-
    rt5
    ^^^^^^^^^^^^^^^^^^^^
    Helloworld
    Hello world

Вывести таблицу значений заданной функции на отрезке и с шагом, которые вводит
пользователь.
Пусть фунция будет такой: y = -3x2 - 4x + 20.
**Алгоритм решения задачи:**
1. Запросить у пользователя точки начала и конца отрезка, а также шаг.
2. Если значение точки начала отрезка больше значения точки конца, то поменять значения.
3. Пока значение первой точки не достигнет второй
4. вычислить значение функции,
5. вывести на экран текущие значения x и y,
6. увеличить значение первой точки на шаг.

    x1 = float(input("Точка начала отрезка: " ))
    x2 = float(input("Точка конца отрезка: " ))
    step = float(input("Шаг: " ))
    if x1 > x2:
    	x1, x2 = x2, x1
    print("Функция: y = -3x**2 - 4x + 20")
    print("   x        y")
    while x1 <= x2:
    	y = -3*x1**2 - 4*x1 + 20
    	print('%5.2f | %7.2f' % (x1, y))
    	x1 += step

Пример выполнения кода:

    Точка начала отрезка: 6
    Точка конца отрезка: 10.5
    Шаг: 0.7
    Функция: y = -3x**2 - 4x + 20
       x        y
     6.00 | -112.00
     6.70 | -141.47
     7.40 | -173.88
     8.10 | -209.23
     8.80 | -247.52
     9.50 | -288.75
    10.20 | -332.92

Обмен значений двух переменных - это "действие", в результате которого одна
переменная принимает значение, равное второй переменной, а вторая - первой.
Понятно, что если попытаться сделать такой обмен "по-простому", т. е. сначала
первой переменной присвоить значение второй, а второй - значение первой, то
ничего не получится. Допустим, есть две переменные a и b. При этом `a = 5` и
`b = 6`. Если выполнить выражение `a = b`, то переменная a будет ссылаться на
число 6, также как и `b`. Число 5 будет утеряно, т. к. на него уже не будет
ссылаться ни одна переменная, и выражение `b = a` бессмысленно, т. к. b будет
присвоено его же текущее значение (6 в данном случае).
Поэтому во многих языках программирования (например, Pascal) приходится
вводить третью переменную, играющую роль буфера (ее иногда называют буферной
переменной). В этой переменной сохраняют значение первой переменной, потом
первой переменной присваивают значение второй, в новое значение для второй
переменной берут из буфера. Поэтому алгоритм обмена значений двух переменных
выглядит примерно так:

    a = 5
    b = 6
    buf = a
    a = b
    b = buf

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

    a = 5
    b = 7
    a = a + b # 12
    b = a - b # 12-7=5
    a = a - b # 12-5=7

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

    >>> a = 10
    >>> b = 20
    >>> a,b = b,a
    >>> a
    20
    >>> b
    10

Почему такое возможно? Это связано с тем, что в Питоне существует такая
структура данных как кортеж.
При выполнении `a,b = b,a` интерпретатор Python сначала получает значения
связанные с переменными b и a (правая часть) и помещает их в кортеж, в данном
случае получится (10, 20). После этого он связывает каждый элемент кортежа в
определенной позиции с переменной в той же позиции, но в кортеже слева
`(a,b)`.
Таким образом можно поменять значения ни только двух переменных, но и трех,
четырех и т. д. Кроме того в Python можно обменять значения переменных разных
типов. Такая возможность связана с тем, что тип данных в Питоне привязан не к
переменной, а к значению:

    >>> a = 14
    >>> b = 18
    >>> c = 16
    >>> a,b,c = c,a,b
    >>> a,b,c
    (16, 14, 18)
    >>> d = 4.56
    >>> e = "hi"
    >>> d,e = e,d
    >>> d
    'hi'
    >>> e
    4.56

Дан список положительных и отрицательных вещественных чисел. Получить из этого
списка другой список, состоящий только из положительных элементов первого,
стоящих на четных местах.
Алгоритм решения задачи достаточно прост. Надо проверять каждый второй элемент
первого списка, и если он больше нуля, то добавлять во второй список.
Особенностью алгоритма для языка Python является то, что индексация начинается
с 0, а значит четные элементы имеют нечетные индексы.
Особенности скрипта ниже. Выражение random.random()*10-5 генерирует
вещественное число от -5 до 5. Выражение round(x, 2) - округляет x до двух
знаков после запятой. Метод append() списка добавляет элемент в конец списка,
к которому применяется.

    import random
    listA = []
    for i in range(20):
    	listA.append(round(random.random()*10-5, 2))
    print("Список A:\n", listA)
    listB = []
    i = 1
    while i < 20:
    	if listA[i] > 0:
    		listB.append(listA[i])
    	i += 2
    print("Список B:\n", listB)

Пример выполнения кода:

    Список A:
     [0.09, 4.56, 2.57, -0.47, 2.78, -4.59, 4.19, 1.68, 2.8, -0.84, 4.72, -1.4, 2.77, 4.64, 0.68, 3.81, -2.09, -3.16, -4.78, 3.88]
    Список B:
     [4.56, 1.68, 4.64, 3.81, 3.88]

У треугольника сумма любых двух сторон должна быть больше третьей. Иначе две
стороны просто "лягут" на третью и треугольника не получится.
Пользователь вводит длины трех сторон. Программа должна определять, может ли
существовать треугольник при таких длинах. Т. е. нужно сравнить суммы двух
любых строн с оставшейся третьей стороной. Чтобы треугольник существовал,
сумма всегда должна быть больше отдельной стороны.
Поскольку всего три стороны, то можно составить три варианта сложения двух
сторон: a + b, b + c, a + c. Первую сумму сравниваем с оставшейся стороной c,
вторую - с a и третью - с b. Если хотя бы в одном случае сумма окажется не
больше третьей стороны, то можно сделать вывод, что треугольник не существует.

    print("Введите длины сторон предполагаемого треугольника:")
    a = float(input("a = "))
    b = float(input("b = "))
    c = float(input("c = "))
    if a + b > c and a + c > b and b + c > a:
    	print("Треугольник существует")
    else:
    	print("Треугольник не существует")

Можно решить задачу сложнее. Если требуется также определить, какая из сторон
больше суммы двух других, то решение может быть таким:

    print("Введите длины сторон предполагаемого треугольника:")
    a = float(input("a = "))
    b = float(input("b = "))
    c = float(input("c = "))
    flag = ''
    if a + b > c:
    	if a + c > b:
    		if b + c > a:
    			print("Треугольник существует")
    		else:
    			flag = 'a'
    	else:
    		flag = 'b'
    else:
    	flag = 'c'
    if flag != '':
    	print("Треугольник НЕ существует. ", end='')
    	print("Сторона '%s' длиннее или равна сумме двух других." % flag)

Особого смысла использовать переменную flag здесь нет. Она просто позволяет
лишний раз не писать в программе строки, информирующие о том, что треугольник
не существует. Большего внимания заслуживает использование вложенных
конструкций if-else.
Примерный результат выполнения программы:

    Введите длины сторон предполагаемого треугольника:
    a = 10
    b = 2
    c = 3
    Треугольник НЕ существует. Сторона 'a' длиннее или равна сумме двух других.

В матрице заменить последний элемент каждой строки на сумму предыдущих
элементов той же строки.
**Алгоритм решения основной части задачи** (только сложение и замена):
1. Для каждой строки присвоить переменной summa значение 0, индексу элемента (i) также значение 0.
2. Пока индекс элемента не дошел до последнего элемента строки, увеличивать значение summa на значение очередного элемента строки матрицы.
3. Иначе (когда индекс элемента указывает на последний элемент строки) изменить значение последнего элемента строки на значение переменной summa.

    import random
    n = 4
    m = 6
    matrix = []
    for i in range(n): # формируем исходную матрицу
    	line = []
    	for j in range(m):
    		line.append(round(random.random() * 10) - 5) # от -5 до 5
    	matrix.append(line)
    for line in matrix: # вывод исходной матрицы
    	for i in line:
    		print('%4d' % i, end='')
    	print()
    print()
    for line in matrix: # изменение матрицы
    	summa = 0 
    	i = 0
    	while i < m-1:
    		summa += line[i]
    		i += 1
    	else:
    		line[m-1] = summa
    for line in matrix: # вывод измененной матрицы
    	for i in line:
    		print('%4d' % i, end='')
    	print()

Пример выполнения кода:

      -5   2   1   2  -4   1
      -3   5  -4  -5   2   1
      -4  -1   2   2   4   4
       3  -4   2  -2  -5   0
      -5   2   1   2  -4  -4
      -3   5  -4  -5   2  -5
      -4  -1   2   2   4   3
       3  -4   2  -2  -5  -6

В данном случае нельзя использовать метод index() списка. Числа в строке
матрицы могут повторяться и поэтому метод вернет индекс первого элемента с
заданным в качестве аргумента значением. Поэтому вот так неправильно (только
основной алгоритм):

    for line in matrix:
    	summa = 0 
    	for i in line:
    		if line.index(i) != m-1:
    			summa += i
    		else:
    			line[m-1] = summa

Гипотеза Сиракуз гласит, что любое натуральное число сводимо к единице при
следующих действиях над ним: а) если число четное, то разделить его пополам,
б) если нечетное - умножить на 3, прибавить 1 и результат разделить на 2. Над
вновь полученным числом вновь повторить действия a) или б) в зависимости от
его четности. Рано или поздно число станет равным 1.
Напишем программу, проверяющую гипотезу Сиракуз. Пусть пользователь вводит
любое натуральное число. Будем выполнять в цикле над ним вышеуказанные
действия, пока оно не станет равным 1. Если гипотеза верна, то рано или позно
цикл закончится, а если нет - то произойдет зацикливание программы.

    n = int(input())
    while n != 1:
    	if n % 2 == 0:
    		n = n // 2
    	else:
    		n = (3*n + 1) // 2
    	print(n, end=' ')

Примеры выполнения кода:

    100
    50 25 38 19 29 44 22 11 17 26 13 20 10 5 8 4 2 1

    9999
    14999 22499 33749 50624 25312 12656 6328 3164 1582 791 1187 1781 2672 1336 668 334 167 251 377 566 283 425 638 319 479 719 1079 1619 2429 3644 1822 911 1367 2051 3077 4616 2308 1154 577 866 433 650 325 488 244 122 61 92 46 23 35 53 80 40 20 10 5 8 4 2 1

Программа зациклится, если ввести отрицательное число. Чтобы этого избежать,
ввод числа можно запрограммировать так:

    n = 0
    while n <= 0:
    	n = int(input())

Пользователь вводит трехзначное число. Программа должна сложить цифры, из
которых состоит это число. Например, если было введено 349, то программа
должна вывести на экран число 16 (т. к. 3 + 4 + 9 = 16).
Как извлечь отдельные цифры из числа? Если число разделить нацело на десять,
то в остатке будет последняя цифра этого числа. Например, если 349 разделить
нацело на 10, то получится частное 34 и остаток 9. Если потом 34 разделить
также, то получится частное 3 и остаток 4; далее при делении 3 на 10 получим
частное 0 и остаток 3.
В языках программирования обычно нет такой арифметической операции, которая бы
давала два результата: частное и остаток. Зато есть две отдельные операции: 1)
нахождение целого при делении нацело и 2) нахождение остатка при делении
нацело. В языке программирования Python v.3 первая операция обозначается //
(двумя знаками деления), а вторая - % (знаком процента). Например:

    >>> 34 // 10
    3
    >>> 34 % 10
    4

Примечание. Необходимо знать, что операции деления нацело и нахождения остатка
с точки зрения арифметики применимы только к целым числам. Но в Python их
можно использовать и по отношению к дробным числам:

    >>> 34.5 % 10
    4.5
    >>> 34.5 // 10
    3.0
    >>> 34.5 // 12.9
    2.0

Итак, алгоритм нахождения суммы цифр трехзначного числа abc (где a - сотни, b - десятки и c - единицы) можно представить в следующем виде:
1. Найти остаток от деления abc на 10, записать его в переменную (d1). Это будет цифра c.
2. Избавиться от цифры c в числе abc, разделив его нацело на 10.
3. Найти остаток от деления ab на 10, записать его в переменную (d2). Это будет цифра b.
4. Избавиться от цифры b в числе ab, разделив его нацело на 10.
5. Найти остаток от деления a на 10, записать его в переменную (d3). Это будет цифра a.
6. Сложить цифры a, b и c.

    n = input("Введите трехзначное число: ")
    n = int(n)
    d1 = n % 10
    n = n // 10
    d2 = n % 10
    n = n // 10
    d3 = n % 10
    print("Сумма цифр числа:", d1 + d2 + d3)

Однако, если уж нам известно количество разрядов (цифр) числа, то можно найти
способ "вычленения" цифр из числа и по-хитрее.
1. Остаток от деления на 10 исходного числа дает последнюю цифру числа.
2. Если найти остаток от деления на 100 исходного числа, то мы получи последние две цифры числа. Далее можно просто разделить полученное двухначное число нацело на 10, и у нас окажется вторая цифра числа.
3. Если исходное трехзначное число разделить нацело на 100, то получится первая цифра числа.

    n = input("Введите трехзначное число: ")
    n = int(n)
    d1 = n % 10
    d2 = n % 100 // 10
    d3 = n // 100
    print("Сумма цифр числа:", d1 + d2 + d3)

Результат работы обоих скриптов одинаков:

    Введите трехзначное число: 742
    Сумма цифр числа: 13

Необходимо определить индексы элементов списка, значение которых не меньше
заданного минимума и не больше заданного максимума.
Пусть исследуемый массив (список в Python) заполняется случайными числами в
диапазоне от 0 до 99 (включительно) и состоит из 100 элементов.
Далее минимум и максимум для поиска значений задается пользователем.

    import random
    arr = []
    for i in range(100):
    	x = int(random.random()*100)  #  0<=x<=99
    	arr.append(x)
    	print("%3d" % x, end='')
    	if (i+1) % 10 == 0:	print()
    minimum = int(input('Min: '))
    maximum = int(input('Max: '))
    index = []
    for i in arr:
    	if minimum <= i <= maximum:
    		index.append(arr.index(i))
    print("Total: ", len(index))
    print("Id: ", index)

      9 96  8 23 41 93 17 88 52 21
     88 60 25 29 14 41 73 60 31  8
     44 51 26 38 79  1 78 11 48 59
     36 64 20 98 31  1 24 75  4 85
     93 46 15 76 35 34  6 72  9 11
     67 60 73 88 69 19 47 67 74 37
     64 35 53 90 56 39 73 83 73 80
     35  0 26 55 27 22 88 14 63 58
     49 95  7 32 34 14 91 55 31 70
     92 61 70 21 25 10 21 60 19 82
    Min: 77
    Max: 85
    Total:  6
    Id:  [24, 26, 39, 67, 69, 99]

Псевдослучайные числа в Python можно сгенерировать, используя функцию random()
одноименного модуля.
Метод append() позволяет добавлять элемент в конец списка; index() определяет
индекс элемента в списке.

Дана квадратная матрица. Необходимо из всех строк матрицы, кроме последней,
вычесть последнюю строку. Следует написать программу с использованием функций.
В Python нельзя обратиться по индексу к элементу списка, которого еще не
существует. Поэтому при заполнении матрицы можно сначала создавать одномерный
список-массив (очередную строку матрицы), а затем добавить его в основной
список-матрицу. Таким образом, при заполнении двумерного списка также
используется метод append(), как и при заполнении одномерного.
В Python в функции передаются "указатели" на списки, а не сами списки. Поэтому
в функциях отсутствует оператор return.

    import random
    def make_matrix(m,n):
    	for i in range(0,n):
    		a = []
    		for j in range(0,n):
    			a.append(int(random.random() * 100))
    		m.append(a)
    def minus_last(m):
    	l = len(m)
    	for i in range(0,l-1):
    		for j in range(0,l):
    			m[i][j] = m[i][j] - m[l-1][j]
    def print_matrix(m):
    	for i in m:
    		print(i)
    	print()
    arr = []
    make_matrix(arr,4)	
    print_matrix(arr)
    minus_last(arr)
    print_matrix(arr)

    [62, 54, 47, 44]
    [84, 84, 64, 83]
    [87, 96, 32, 30]
    [3, 74, 42, 21]
    [59, -20, 5, 23]
    [81, 10, 22, 62]
    [84, 22, -10, 9]
    [3, 74, 42, 21]

Всё, ждём пони-линукс.

Опять линукс-сообщество и опять провокации на эту тему =)

> к линуксам имеет прямое отношение

Переезжаем в ii://vk-news.15

Только что решил обновить сборку с важным обновлением для поддержки ii-ссылок

1. Исправлено падение при открытии ii-ссылок, если клиент не запущен
2. [NEW] ii-ссылки теперь открываются через KDEConnect

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

Теперь это можно устроить одной командой:

$ kdeconnect-cli -d xyzxyzxyzxyz --share "ii://QI58zrmtLUsZAWceUnGA"

Ну или

$ kdeconnect-cli -d xyzxyzxyzxyz --share "ii://ru.humor.14"

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

Команду можно забиндить скриптом в тот же Цезий и быстренько "переключаться" на андроид, например, сочетанием клавиш.

P.S. Трюк для msgid сработает, только если нужное сообщение на андроиде уже зафетчено.

Сборка от 13:56

Обыкновенный фетчер стал чуть более информативным, сообщает о новых файлах

1. Будущее сети. Пока не знаю, что ответить

2. Недостатки
Как минимум, простота развёртывания и гибкость в поддержке разных платформ.
У нас есть несколько репозиториев с нодами, которые работают каждая хрен знает как. Надо перегонять вручную конфиги, следить за базами данных и.т.п. Для разных языков программирования по несколько реализаций протокола.

Ботов (тех же RSS) настраивать надо вручную. Фетч - тоже вручную, с заходом по SSH на сервер и ручной правкой конфигов. Хорошо бы это оптимизировать.

Для python вообще нужна по моему мнению единая IDEC-Lib, которая нивелирует различия между нодами и клиентами и объединит общие усилия по разработке и позволит городить улучшения гораздо проще. Туда же GoLang-реализация и так далее

3. Основной проект - Android клиент. Планирую улучшать интерфейсы для работы с базой данных (как эх, так и фэх), хочу добавить шифрование.

Полное TODO по клиенту здесь: https://github.com/vit1-irk/idec-mobile/projects/1

Второстепенный проект - PHP-нода. Придётся переписать с нуля не меньше половины, пересмотреть конфиг для фетчера, обязательно улучшить админку и добавить фич в веб-интерфейс.

Третьестепенный - CutieFeed. Отсутствует поддержка фэх, многие вещи не поддерживаются. Под винду не собирается. Хоть какая-нибудь, но переработка нужна, потому что эта вещь до сих пор не раскрыла своего потенциала за пределами моего компьютера.

Буду поэтапно реализовывать скрипты для архивации, пересортировки в базе, бэкапов. Мета-скрипты для фетчеров и ботов, которые позволят обуздать большие потоки информации.

> поможет в конкурентной борьбе за девочек, пишущих про котиков (для меня это моя основная целевая аудитория).
Кто о чём, а вшивый о бане =) С девочками точно не помогу, и эта тема себя уже давно исчерпала

4. Что мы можем сделать интересного для людей?
Пока что не очень много. Мода вообще такая штука, что люди становятся её жертвами

> Подача в СМИ и на новостных сайтах.

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

5. Вопросы AB и XAB и дружественная атмосфера.

Я за полную свободу слова. Фидошная бюрократия не нужна, проблемы с дружбомагичностью имеет смысл решать только по мере поступления.

AL> Я окончательно убрал эхи в виде лент за полной ненадобностью и неудобством

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

Вот, почитайте. Вы точно уже видели нечто подобное

https://maple.libertree.org/docs/show/en_GB/philosophy

На тот случай, если кто-то всё-таки соберётся составлять нодлист

1. Моих станций теперь всего 2: это [mira] и [alicorn-archive].
2. Аплинки: tavern, ii.difrex.ru, club.syscall.ru
3. Всех аплинков фетчу раз в 10 минут, список эх для всех одинаковый
4. Список фетч-эх в реальном времени смотреть, например, здесь: https://ii-net.tk/ii/club-fetch.php
6. Личную информацию, адреса и явки смотреть в предыдущем нодлисте, они не изменились.

// на срач ответить нечего

Во время разборок с багами IDEC Mobile возникла проблема с парсингом файл-строк с пустыми описаниями. Казалось бы, баг несерьёзный, и клиент я всё-таки поправил. Сейчас клиент игнорирует такие файлы, считая их за испорченные

Но в стандарте этот момент толком уточнён не был. Делать ли поле description обязательным для файлов в файлэхах или нет? Позволять ли поинтам загружать так файлы?

Моя позиция, что поле лучше сделать обязательным. Потому что по имени файла можно _только примерно_ понять, что внутри. Хоть какое-то описание, но быть должно => коты в мешке не нужны.

Высказывайтесь за то, какое поведение загонять в стандарт.

Снял ii.14 с фетча и со списка эх

// снял с фетча также tyt.bce.hacpem в виду сомнительной нужности