В матрице заменить последний элемент каждой строки на сумму предыдущих
элементов той же строки.
**Алгоритм решения основной части задачи** (только сложение и замена):
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]