#  Функции
vit01 (mira, 1) → All  –  00:13:43 2015-12-04

Дана квадратная матрица. Необходимо из всех строк матрицы, кроме последней,
вычесть последнюю строку. Следует написать программу с использованием функций.
В Python нельзя обратиться по индексу к элементу списка, которого еще не
существует. Поэтому при заполнении матрицы можно сначала создавать одномерный
список-массив (очередную строку матрицы), а затем добавить его в основной
список-матрицу. Таким образом, при заполнении двумерного списка также
используется метод append(), как и при заполнении одномерного.
В Python в функции передаются "указатели" на списки, а не сами списки. Поэтому
в функциях отсутствует оператор return.
====
import random
def make_matrix(m,n):
for i in range(0,n):
a = []
for j in range(0,n):


>> Читать далее
#  Списки, кортежи
vit01 (mira, 1) → All  –  00:13:43 2015-12-04

Необходимо определить индексы элементов списка, значение которых не меньше
заданного минимума и не больше заданного максимума.
Пусть исследуемый массив (список в 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: '))


>> Читать далее
#  Линейные алгоритмы
vit01 (mira, 1) → All  –  00:13:43 2015-12-04

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


>> Читать далее
#  Циклы
vit01 (mira, 1) → All  –  00:13:43 2015-12-04

Гипотеза Сиракуз гласит, что любое натуральное число сводимо к единице при
следующих действиях над ним: а) если число четное, то разделить его пополам,
б) если нечетное - умножить на 3, прибавить 1 и результат разделить на 2. Над
вновь полученным числом вновь повторить действия a) или б) в зависимости от
его четности. Рано или поздно число станет равным 1.
Напишем программу, проверяющую гипотезу Сиракуз. Пусть пользователь вводит
любое натуральное число. Будем выполнять в цикле над ним вышеуказанные
действия, пока оно не станет равным 1. Если гипотеза верна, то рано или позно
цикл закончится, а если нет - то произойдет зацикливание программы.
====
n = int(input())
while n != 1:
if n % 2 == 0:
n = n // 2
else:


>> Читать далее
#  Списки, кортежи
vit01 (mira, 1) → All  –  00:13:42 2015-12-04

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


>> Читать далее
#  Условный оператор
vit01 (mira, 1) → All  –  00:13:42 2015-12-04

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


>> Читать далее
#  Списки, кортежи
vit01 (mira, 1) → All  –  00:13:42 2015-12-04

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


>> Читать далее
#  Линейные алгоритмы
vit01 (mira, 1) → All  –  00:13:41 2015-12-04

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

>> Читать далее
#  Циклы
vit01 (mira, 1) → All  –  00:13:41 2015-12-04

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


>> Читать далее
#  Линейные алгоритмы
vit01 (mira, 1) → All  –  00:13:40 2015-12-04

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


>> Читать далее
#  Циклы
vit01 (mira, 1) → All  –  00:13:40 2015-12-04

Определить количество простых чисел введенных пользователем.
**Алгоритм решения задачи:**
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:


>> Читать далее
#  Линейные алгоритмы
vit01 (mira, 1) → All  –  00:13:40 2015-12-04

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


>> Читать далее
#  Строки
vit01 (mira, 1) → All  –  00:13:40 2015-12-04

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


>> Читать далее
#  Списки, кортежи
vit01 (mira, 1) → All  –  00:13:39 2015-12-04

Дан список-массив, заполненный случайным образом нулями и единицами. Найти
самую длинную непрерывную последовательность единиц и определить индексы
первого и последнего элементов в ней.
**Решение задачи:**
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()


>> Читать далее
#  Списки, кортежи
vit01 (mira, 1) → All  –  00:13:39 2015-12-04

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


>> Читать далее