<?xml version="1.0" encoding="UTF-8"?>
	<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:media="http://search.yahoo.com/mrss/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:georss="http://www.georss.org/georss">
	<channel>
	<title>fox :: echo/8mwNfmdlbMMcsJ5lpxey</title>
	<link>https://idec.foxears.su/echo/8mwNfmdlbMMcsJ5lpxey</link>
	<description>
	fox :: echo/8mwNfmdlbMMcsJ5lpxey
	</description>
	<language>ru</language>
<item><title>Функции</title><guid>ZzIYKa9Ck0yFoS4CIIuU</guid><pubDate>2015-12-04 04:13:43</pubDate><author>vit01</author><link>https://idec.foxears.su/ZzIYKa9Ck0yFoS4CIIuU#ZzIYKa9Ck0yFoS4CIIuU</link>
		<description>
		Дана квадратная матрица. Необходимо из всех строк матрицы, кроме последней,
вычесть последнюю строку. Следует написать программу с использованием функций.
В Python нельзя обратиться по индексу к элементу списка, которого еще не
существует. Поэтому при заполнении матрицы можно сна...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Дана квадратная матрица. Необходимо из всех строк матрицы, кроме последней,<br>
вычесть последнюю строку. Следует написать программу с использованием функций.<br>
В Python нельзя обратиться по индексу к элементу списка, которого еще не<br>
существует. Поэтому при заполнении матрицы можно сначала создавать одномерный<br>
список-массив (очередную строку матрицы), а затем добавить его в основной<br>
список-матрицу. Таким образом, при заполнении двумерного списка также<br>
используется метод append(), как и при заполнении одномерного.<br>
В Python в функции передаются "указатели" на списки, а не сами списки. Поэтому<br>
в функциях отсутствует оператор return.<br>
<pre class="code">
    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)
</pre>
<pre class="code">
    [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]
</pre>

]]>
</content:encoded></item>
<item><title>Списки, кортежи</title><guid>mXYcoxeA226TuB628wnI</guid><pubDate>2015-12-04 04:13:43</pubDate><author>vit01</author><link>https://idec.foxears.su/mXYcoxeA226TuB628wnI#mXYcoxeA226TuB628wnI</link>
		<description>
		Необходимо определить индексы элементов списка, значение которых не меньше
заданного минимума и не больше заданного максимума.
Пусть исследуемый массив (список в Python) заполняется случайными числами в
диапазоне от 0 до 99 (включительно) и состоит из 100 элементов.
Далее минимум...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Необходимо определить индексы элементов списка, значение которых не меньше<br>
заданного минимума и не больше заданного максимума.<br>
Пусть исследуемый массив (список в Python) заполняется случайными числами в<br>
диапазоне от 0 до 99 (включительно) и состоит из 100 элементов.<br>
Далее минимум и максимум для поиска значений задается пользователем.<br>
<pre class="code">
    import random
    arr = []
    for i in range(100):
    	x = int(random.random()*100)  #  0&lt;=x&lt;=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 &lt;= i &lt;= maximum:
    		index.append(arr.index(i))
    print("Total: ", len(index))
    print("Id: ", index)
</pre>
<pre class="code">
      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]
</pre>
Псевдослучайные числа в Python можно сгенерировать, используя функцию random()<br>
одноименного модуля.<br>
Метод append() позволяет добавлять элемент в конец списка; index() определяет<br>
индекс элемента в списке.<br>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>aODrId8UiIgjK4CVOCYQ</guid><pubDate>2015-12-04 04:13:43</pubDate><author>vit01</author><link>https://idec.foxears.su/aODrId8UiIgjK4CVOCYQ#aODrId8UiIgjK4CVOCYQ</link>
		<description>
		Пользователь вводит трехзначное число. Программа должна сложить цифры, из
которых состоит это число. Например, если было введено 349, то программа
должна вывести на экран число 16 (т. к. 3 + 4 + 9 = 16).
Как извлечь отдельные цифры из числа? Если число разделить нацело на десять,...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Пользователь вводит трехзначное число. Программа должна сложить цифры, из<br>
которых состоит это число. Например, если было введено 349, то программа<br>
должна вывести на экран число 16 (т. к. 3 + 4 + 9 = 16).<br>
Как извлечь отдельные цифры из числа? Если число разделить нацело на десять,<br>
то в остатке будет последняя цифра этого числа. Например, если 349 разделить<br>
нацело на 10, то получится частное 34 и остаток 9. Если потом 34 разделить<br>
также, то получится частное 3 и остаток 4; далее при делении 3 на 10 получим<br>
частное 0 и остаток 3.<br>
В языках программирования обычно нет такой арифметической операции, которая бы<br>
давала два результата: частное и остаток. Зато есть две отдельные операции: 1)<br>
нахождение целого при делении нацело и 2) нахождение остатка при делении<br>
нацело. В языке программирования Python v.3 первая операция обозначается //<br>
(двумя знаками деления), а вторая - % (знаком процента). Например:  <br>
<pre class="code">
    &gt;&gt;&gt; 34 // 10
    3
    &gt;&gt;&gt; 34 % 10
    4
</pre>
Примечание. Необходимо знать, что операции деления нацело и нахождения остатка<br>
с точки зрения арифметики применимы только к целым числам. Но в Python их<br>
можно использовать и по отношению к дробным числам:  <br>
<pre class="code">
    &gt;&gt;&gt; 34.5 % 10
    4.5
    &gt;&gt;&gt; 34.5 // 10
    3.0
    &gt;&gt;&gt; 34.5 // 12.9
    2.0
</pre>
Итак, алгоритм нахождения суммы цифр трехзначного числа abc (где a - сотни, b - десятки и c - единицы) можно представить в следующем виде:<br>
  1. Найти остаток от деления abc на 10, записать его в переменную (d1). Это будет цифра c.<br>
  2. Избавиться от цифры c в числе abc, разделив его нацело на 10. <br>
  3. Найти остаток от деления ab на 10, записать его в переменную (d2). Это будет цифра b.<br>
  4. Избавиться от цифры b в числе ab, разделив его нацело на 10. <br>
  5. Найти остаток от деления a на 10, записать его в переменную (d3). Это будет цифра a.<br>
  6. Сложить цифры a, b и c.<br>
<pre class="code">
    n = input("Введите трехзначное число: ")
    n = int(n)
    d1 = n % 10
    n = n // 10
    d2 = n % 10
    n = n // 10
    d3 = n % 10
    print("Сумма цифр числа:", d1 + d2 + d3)
</pre>
Однако, если уж нам известно количество разрядов (цифр) числа, то можно найти<br>
способ "вычленения" цифр из числа и по-хитрее.<br>
  1. Остаток от деления на 10 исходного числа дает последнюю цифру числа.<br>
  2. Если найти остаток от деления на 100 исходного числа, то мы получи последние две цифры числа. Далее можно просто разделить полученное двухначное число нацело на 10, и у нас окажется вторая цифра числа.<br>
  3. Если исходное трехзначное число разделить нацело на 100, то получится первая цифра числа.<br>
<pre class="code">
    n = input("Введите трехзначное число: ")
    n = int(n)
    d1 = n % 10
    d2 = n % 100 // 10
    d3 = n // 100
    print("Сумма цифр числа:", d1 + d2 + d3)
</pre>
Результат работы обоих скриптов одинаков:  <br>
<pre class="code">
    Введите трехзначное число: 742
    Сумма цифр числа: 13
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>trLDfJLSEGNsHOStsv7O</guid><pubDate>2015-12-04 04:13:43</pubDate><author>vit01</author><link>https://idec.foxears.su/trLDfJLSEGNsHOStsv7O#trLDfJLSEGNsHOStsv7O</link>
		<description>
		Гипотеза Сиракуз гласит, что любое натуральное число сводимо к единице при
следующих действиях над ним: а) если число четное, то разделить его пополам,
б) если нечетное - умножить на 3, прибавить 1 и результат разделить на 2. Над
вновь полученным числом вновь повторить действия a...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Гипотеза Сиракуз гласит, что любое натуральное число сводимо к единице при<br>
следующих действиях над ним: а) если число четное, то разделить его пополам,<br>
б) если нечетное - умножить на 3, прибавить 1 и результат разделить на 2. Над<br>
вновь полученным числом вновь повторить действия a) или б) в зависимости от<br>
его четности. Рано или поздно число станет равным 1.<br>
Напишем программу, проверяющую гипотезу Сиракуз. Пусть пользователь вводит<br>
любое натуральное число. Будем выполнять в цикле над ним вышеуказанные<br>
действия, пока оно не станет равным 1. Если гипотеза верна, то рано или позно<br>
цикл закончится, а если нет - то произойдет зацикливание программы.<br>
<pre class="code">
    n = int(input())
    while n != 1:
    	if n % 2 == 0:
    		n = n // 2
    	else:
    		n = (3*n + 1) // 2
    	print(n, end=' ')
</pre>
Примеры выполнения кода:  <br>
<pre class="code">
    100
    50 25 38 19 29 44 22 11 17 26 13 20 10 5 8 4 2 1
</pre>
<pre class="code">
    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
</pre>
Программа зациклится, если ввести отрицательное число. Чтобы этого избежать,<br>
ввод числа можно запрограммировать так:  <br>
<pre class="code">
    n = 0
    while n &lt;= 0:
    	n = int(input())
</pre>

]]>
</content:encoded></item>
<item><title>Списки, кортежи</title><guid>AAQz5DJCTzQWp4PsR5Gq</guid><pubDate>2015-12-04 04:13:42</pubDate><author>vit01</author><link>https://idec.foxears.su/AAQz5DJCTzQWp4PsR5Gq#AAQz5DJCTzQWp4PsR5Gq</link>
		<description>
		В матрице заменить последний элемент каждой строки на сумму предыдущих
элементов той же строки.
**Алгоритм решения основной части задачи** (только сложение и замена):
  1. Для каждой строки присвоить переменной summa значение 0, индексу элемента (i) также значение 0.
  2. Пока ин...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В матрице заменить последний элемент каждой строки на сумму предыдущих<br>
элементов той же строки.<br>
**Алгоритм решения основной части задачи** (только сложение и замена):<br>
  1. Для каждой строки присвоить переменной summa значение 0, индексу элемента (i) также значение 0.<br>
  2. Пока индекс элемента не дошел до последнего элемента строки, увеличивать значение summa на значение очередного элемента строки матрицы.<br>
  3. Иначе (когда индекс элемента указывает на последний элемент строки) изменить значение последнего элемента строки на значение переменной summa. <br>
<pre class="code">
    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 &lt; 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()
</pre>
Пример выполнения кода:<br>
<pre class="code">
      -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
</pre>
В данном случае нельзя использовать метод index() списка. Числа в строке<br>
матрицы могут повторяться и поэтому метод вернет индекс первого элемента с<br>
заданным в качестве аргумента значением. Поэтому вот так неправильно (только<br>
основной алгоритм):  <br>
<pre class="code">
    for line in matrix:
    	summa = 0 
    	for i in line:
    		if line.index(i) != m-1:
    			summa += i
    		else:
    			line[m-1] = summa
</pre>

]]>
</content:encoded></item>
<item><title>Условный оператор</title><guid>Wn3oBkOfhQiLz4BSRRet</guid><pubDate>2015-12-04 04:13:42</pubDate><author>vit01</author><link>https://idec.foxears.su/Wn3oBkOfhQiLz4BSRRet#Wn3oBkOfhQiLz4BSRRet</link>
		<description>
		У треугольника сумма любых двух сторон должна быть больше третьей. Иначе две
стороны просто "лягут" на третью и треугольника не получится.
Пользователь вводит длины трех сторон. Программа должна определять, может ли
существовать треугольник при таких длинах. Т. е. нужно сравнить ...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
У треугольника сумма любых двух сторон должна быть больше третьей. Иначе две<br>
стороны просто "лягут" на третью и треугольника не получится.<br>
Пользователь вводит длины трех сторон. Программа должна определять, может ли<br>
существовать треугольник при таких длинах. Т. е. нужно сравнить суммы двух<br>
любых строн с оставшейся третьей стороной. Чтобы треугольник существовал,<br>
сумма всегда должна быть больше отдельной стороны.<br>
Поскольку всего три стороны, то можно составить три варианта сложения двух<br>
сторон: a + b, b + c, a + c. Первую сумму сравниваем с оставшейся стороной c,<br>
вторую - с a и третью - с b. Если хотя бы в одном случае сумма окажется не<br>
больше третьей стороны, то можно сделать вывод, что треугольник не существует.<br>
<pre class="code">
    print("Введите длины сторон предполагаемого треугольника:")
    a = float(input("a = "))
    b = float(input("b = "))
    c = float(input("c = "))
    if a + b &gt; c and a + c &gt; b and b + c &gt; a:
    	print("Треугольник существует")
    else:
    	print("Треугольник не существует")
</pre>
Можно решить задачу сложнее. Если требуется также определить, какая из сторон<br>
больше суммы двух других, то решение может быть таким:  <br>
<pre class="code">
    print("Введите длины сторон предполагаемого треугольника:")
    a = float(input("a = "))
    b = float(input("b = "))
    c = float(input("c = "))
    flag = ''
    if a + b &gt; c:
    	if a + c &gt; b:
    		if b + c &gt; a:
    			print("Треугольник существует")
    		else:
    			flag = 'a'
    	else:
    		flag = 'b'
    else:
    	flag = 'c'
    if flag != '':
    	print("Треугольник НЕ существует. ", end='')
    	print("Сторона '%s' длиннее или равна сумме двух других." % flag)
</pre>
Особого смысла использовать переменную flag здесь нет. Она просто позволяет<br>
лишний раз не писать в программе строки, информирующие о том, что треугольник<br>
не существует. Большего внимания заслуживает использование вложенных<br>
конструкций if-else.<br>
Примерный результат выполнения программы:  <br>
<pre class="code">
    Введите длины сторон предполагаемого треугольника:
    a = 10
    b = 2
    c = 3
    Треугольник НЕ существует. Сторона 'a' длиннее или равна сумме двух других.
</pre>

]]>
</content:encoded></item>
<item><title>Списки, кортежи</title><guid>80GMrtFswZh0Ax66WApy</guid><pubDate>2015-12-04 04:13:42</pubDate><author>vit01</author><link>https://idec.foxears.su/80GMrtFswZh0Ax66WApy#80GMrtFswZh0Ax66WApy</link>
		<description>
		Дан список положительных и отрицательных вещественных чисел. Получить из этого
списка другой список, состоящий только из положительных элементов первого,
стоящих на четных местах.
Алгоритм решения задачи достаточно прост. Надо проверять каждый второй элемент
первого списка, и есл...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Дан список положительных и отрицательных вещественных чисел. Получить из этого<br>
списка другой список, состоящий только из положительных элементов первого,<br>
стоящих на четных местах.<br>
Алгоритм решения задачи достаточно прост. Надо проверять каждый второй элемент<br>
первого списка, и если он больше нуля, то добавлять во второй список.<br>
Особенностью алгоритма для языка Python является то, что индексация начинается<br>
с 0, а значит четные элементы имеют нечетные индексы.<br>
Особенности скрипта ниже. Выражение random.random()*10-5 генерирует<br>
вещественное число от -5 до 5. Выражение round(x, 2) - округляет x до двух<br>
знаков после запятой. Метод append() списка добавляет элемент в конец списка,<br>
к которому применяется.<br>
<pre class="code">
    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 &lt; 20:
    	if listA[i] &gt; 0:
    		listB.append(listA[i])
    	i += 2
    print("Список B:\n", listB)
</pre>
Пример выполнения кода:  <br>
<pre class="code">
    Список 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]
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>w06zoT5lUCutKEmr7VLl</guid><pubDate>2015-12-04 04:13:41</pubDate><author>vit01</author><link>https://idec.foxears.su/w06zoT5lUCutKEmr7VLl#w06zoT5lUCutKEmr7VLl</link>
		<description>
		Обмен значений двух переменных - это "действие", в результате которого одна
переменная принимает значение, равное второй переменной, а вторая - первой.
Понятно, что если попытаться сделать такой обмен "по-простому", т. е. сначала
первой переменной присвоить значение второй, а вто...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Обмен значений двух переменных - это "действие", в результате которого одна<br>
переменная принимает значение, равное второй переменной, а вторая - первой.<br>
Понятно, что если попытаться сделать такой обмен "по-простому", т. е. сначала<br>
первой переменной присвоить значение второй, а второй - значение первой, то<br>
ничего не получится. Допустим, есть две переменные a и b. При этом `a = 5` и<br>
`b = 6`. Если выполнить выражение `a = b`, то переменная a будет ссылаться на<br>
число 6, также как и `b`. Число 5 будет утеряно, т. к. на него уже не будет<br>
ссылаться ни одна переменная, и выражение `b = a` бессмысленно, т. к. b будет<br>
присвоено его же текущее значение (6 в данном случае).<br>
Поэтому во многих языках программирования (например, Pascal) приходится<br>
вводить третью переменную, играющую роль буфера (ее иногда называют буферной<br>
переменной). В этой переменной сохраняют значение первой переменной, потом<br>
первой переменной присваивают значение второй, в новое значение для второй<br>
переменной берут из буфера. Поэтому алгоритм обмена значений двух переменных<br>
выглядит примерно так:  <br>
<pre class="code">
    a = 5
    b = 6
    buf = a
    a = b
    b = buf
</pre>
Однако есть более "хитрый" способ, позволяющий избавиться от третьей<br>
переменной. Но этим способом не всегда рекомендуют пользоваться. Выглядит он<br>
так:  <br>
<pre class="code">
    a = 5
    b = 7
    a = a + b # 12
    b = a - b # 12-7=5
    a = a - b # 12-5=7
</pre>
В отличие от многих других языков программирования, в Python обмен значений<br>
переменных можно выполнить вообще в одну строчку:  <br>
<pre class="code">
    &gt;&gt;&gt; a = 10
    &gt;&gt;&gt; b = 20
    &gt;&gt;&gt; a,b = b,a
    &gt;&gt;&gt; a
    20
    &gt;&gt;&gt; b
    10
</pre>
Почему такое возможно? Это связано с тем, что в Питоне существует такая<br>
структура данных как кортеж.<br>
При выполнении `a,b = b,a` интерпретатор Python сначала получает значения<br>
связанные с переменными b и a (правая часть) и помещает их в кортеж, в данном<br>
случае получится (10, 20). После этого он связывает каждый элемент кортежа в<br>
определенной позиции с переменной в той же позиции, но в кортеже слева<br>
`(a,b)`.<br>
Таким образом можно поменять значения ни только двух переменных, но и трех,<br>
четырех и т. д. Кроме того в Python можно обменять значения переменных разных<br>
типов. Такая возможность связана с тем, что тип данных в Питоне привязан не к<br>
переменной, а к значению:  <br>
<pre class="code">
    &gt;&gt;&gt; a = 14
    &gt;&gt;&gt; b = 18
    &gt;&gt;&gt; c = 16
    &gt;&gt;&gt; a,b,c = c,a,b
    &gt;&gt;&gt; a,b,c
    (16, 14, 18)
    &gt;&gt;&gt; d = 4.56
    &gt;&gt;&gt; e = "hi"
    &gt;&gt;&gt; d,e = e,d
    &gt;&gt;&gt; d
    'hi'
    &gt;&gt;&gt; e
    4.56
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>ARzf5l9SeozHj5RwovCE</guid><pubDate>2015-12-04 04:13:41</pubDate><author>vit01</author><link>https://idec.foxears.su/ARzf5l9SeozHj5RwovCE#ARzf5l9SeozHj5RwovCE</link>
		<description>
		Вывести таблицу значений заданной функции на отрезке и с шагом, которые вводит
пользователь.
Пусть фунция будет такой: y = -3x2 - 4x + 20.
**Алгоритм решения задачи:**
  1. Запросить у пользователя точки начала и конца отрезка, а также шаг.
  2. Если значение точки начала отрезка...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Вывести таблицу значений заданной функции на отрезке и с шагом, которые вводит<br>
пользователь.<br>
Пусть фунция будет такой: y = -3x2 - 4x + 20.<br>
**Алгоритм решения задачи:**<br>
  1. Запросить у пользователя точки начала и конца отрезка, а также шаг.<br>
  2. Если значение точки начала отрезка больше значения точки конца, то поменять значения.<br>
  3. Пока значение первой точки не достигнет второй<br>
  4. вычислить значение функции,<br>
  5. вывести на экран текущие значения x и y,<br>
  6. увеличить значение первой точки на шаг.<br>
<pre class="code">
    x1 = float(input("Точка начала отрезка: " ))
    x2 = float(input("Точка конца отрезка: " ))
    step = float(input("Шаг: " ))
    if x1 &gt; x2:
    	x1, x2 = x2, x1
    print("Функция: y = -3x**2 - 4x + 20")
    print("   x        y")
    while x1 &lt;= x2:
    	y = -3*x1**2 - 4*x1 + 20
    	print('%5.2f | %7.2f' % (x1, y))
    	x1 += step
</pre>
Пример выполнения кода:<br>
<pre class="code">
    Точка начала отрезка: 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
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>9qc35yQyKqDszmEJQyEI</guid><pubDate>2015-12-04 04:13:40</pubDate><author>vit01</author><link>https://idec.foxears.su/9qc35yQyKqDszmEJQyEI#9qc35yQyKqDszmEJQyEI</link>
		<description>
		В Python над двумя строками можно выполнить операцию, обозначаемую знаком +.
Однако, в отличие от чисел, выполняетя не сложение (что для строк в принципе
невозможно), а соединение, т. е. к концу первой строки добавляется вторая. По-
другому операция соединения строк называется **...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В Python над двумя строками можно выполнить операцию, обозначаемую знаком +.<br>
Однако, в отличие от чисел, выполняетя не сложение (что для строк в принципе<br>
невозможно), а соединение, т. е. к концу первой строки добавляется вторая. По-<br>
другому операция соединения строк называется **конкатенацией**.<br>
Кроме того, в Python есть операция повторения (мультипликации) строки. Она<br>
обозначается знаком * (также как операция умножения для чисел). При повторении<br>
строки с одной стороны от знака * ставится строка, а с другой число,<br>
обозначающее количество повторов. При этом не важно, какой объект с какой<br>
стороны находится (слева от знака можно писать число, а справа - строку).<br>
В одном выражении можно сочетать операции конкатенации и мультипликация. При<br>
этом более высокий приоритет у операции повторения строки. Это видно в примере<br>
ниже: когда опущены скобки, то сначала строка s2 повторяется n раз, а затем<br>
результат присоединяется к s1.<br>
<pre class="code">
    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')
</pre>
В последней строке кода конкатенации нет. Просто функции print() передано два<br>
аргумента, которые она выводит на экран.<br>
Результат выполнения скрипта:  <br>
<pre class="code">
    Введите первую строку: rt
    Введите вторую строку: -
    Введите количество повторов: 5
    rt-----
    rt-rt-rt-rt-rt-
    rt5
    ^^^^^^^^^^^^^^^^^^^^
    Helloworld
    Hello world
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>DO1HmdZpX8ye68u3dvXd</guid><pubDate>2015-12-04 04:13:40</pubDate><author>vit01</author><link>https://idec.foxears.su/DO1HmdZpX8ye68u3dvXd#DO1HmdZpX8ye68u3dvXd</link>
		<description>
		Определить количество простых чисел введенных пользователем.
**Алгоритм решения задачи:**
  1. Пока не будет введено число меньшее или равное 1 (т.к. простым числом может быть только натуральное число большее единицы) будем выполнять нижеследующие действия.
  2. Установим флагову...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Определить количество простых чисел введенных пользователем.<br>
**Алгоритм решения задачи:**<br>
  1. Пока не будет введено число меньшее или равное 1 (т.к. простым числом может быть только натуральное число большее единицы) будем выполнять нижеследующие действия.<br>
  2. Установим флаговую переменную в значение True.<br>
  3. Проверим число на простоту путем деления на него всех целых чисел от 2 до корня из него (почему именно до корня см. математику).<br>
  4. Если число делится нацело хотя бы на один делитель, то оно не простое. Меняем значение флаговой переменной на False.<br>
  5. Если же флаговая переменная не была изменена, то число простое, и мы увеличиваем счетчик количества введенных простых чисел.<br>
<pre class="code">
    import math
    count = 0
    n = int(input())
    while n &gt; 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, "простых чисел")
</pre>
Пример выполнения кода:<br>
<pre class="code">
    35
    18
    10
    11
    197
    3
    17
    1
    Было введено 4 простых чисел
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>7Vz5KNAT4dkOxt6e9XDz</guid><pubDate>2015-12-04 04:13:40</pubDate><author>vit01</author><link>https://idec.foxears.su/7Vz5KNAT4dkOxt6e9XDz#7Vz5KNAT4dkOxt6e9XDz</link>
		<description>
		Требуется убедиться, что брать кредиты не выгодно. Т. е. надо вычислить,
сколько придется платить в месяц по займу и сколько всего отдать денег банку
за весь период.
Месячная выплата по займу вычисляется по такой загадочной формуле:  
m = (s * p * (1 + p)n) / (12 * ((1 + p)n – 1)...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Требуется убедиться, что брать кредиты не выгодно. Т. е. надо вычислить,<br>
сколько придется платить в месяц по займу и сколько всего отдать денег банку<br>
за весь период.<br>
Месячная выплата по займу вычисляется по такой загадочной формуле:  <br>
m = (s * p * (1 + p)n) / (12 * ((1 + p)n – 1)).  <br>
Мы не будем разбирать ее смысл, т.к. все-равно не осилим.<br>
Достаточно знать, что в этой формуле:  <br>
m - размер месячной выплаты;  <br>
s - сумма займа (кредита);  <br>
p - процент банка, выраженный в долях единицы (т. е. если 20%, то будет 0.2).  <br>
n - количество лет, на которые берется займ.<br>
Код решения данной задачи на языке Python может выглядеть так:<br>
<pre class="code">
    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))
</pre>
Здесь следует обратить внимание на операции с различными типами данных.<br>
Значение years преобразутеся к вещественному типу, т.к. кредит можно взять не<br>
на целое количество лет. В выражении pct = pct / 100 получается дробное число<br>
(т.е. переменная pct теперь связана с вещественным типом данных).<br>
Примерные результаты:  <br>
<pre class="code">
    Сколько хотите взять денег: 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% от первоначальной суммы
</pre>

]]>
</content:encoded></item>
<item><title>Строки</title><guid>qJazC9AmczQPdVFEqdVm</guid><pubDate>2015-12-04 04:13:40</pubDate><author>vit01</author><link>https://idec.foxears.su/qJazC9AmczQPdVFEqdVm#qJazC9AmczQPdVFEqdVm</link>
		<description>
		В строке заменить пробельные символы знаком звездочки ("*"). Если встречается
подряд несколько пробелов, то их следует заменить одним знаком "*", пробелы в
начале и конце строки удалить.
**Алгоритм решения задачи:**
  1. Посимвольно просмотреть строку с ее начала. Запомнить номер...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В строке заменить пробельные символы знаком звездочки ("*"). Если встречается<br>
подряд несколько пробелов, то их следует заменить одним знаком "*", пробелы в<br>
начале и конце строки удалить.<br>
**Алгоритм решения задачи:**<br>
  1. Посимвольно просмотреть строку с ее начала. Запомнить номер первого непробельного символа. Взять срез из строки от первого непробельного символа до ее конца.<br>
  2. Просмотреть строку с конца. Запомнить номер первого непробельного символа с конца. Взять срез из строки от ее начала до первого непробельного символа с конца.<br>
  3. Присвоить новой строке первый символ старой (он в любом случае не пробел).<br>
  4. Посимвольно просматривать старую строку. Если очередной символ не является пробелом, то формировать новую строку добавлением к ней этого символа. В ветку `elif` попадают символы пробела, но здесь проверяется не был ли равен предыдущий символ пробелу. И если это не так (не был равен), то только тогда к новой строке добавляется "*". Лишние пробелы будут просто пропущены и не добавлены к новой строке.<br>
<pre class="code">
    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 &lt; len(s):
    	if s[i] != ' ':
    		s1 += s[i]
    	elif s[i-1] != ' ':
    		s1 += '*'
    	i += 1
    print(s1+'!')
</pre>
Пример выполнения скрипта:<br>
<pre class="code">
       one    two three four f*ve    six seven      one*two*three*four*f*ve*six*seven!
</pre>
Однако в языке программирования Python данную задачу проще решить,<br>
преобразовав строку в список или возможно через регулярные выражения.<br>
С помощью метода split() строка разделяется на слова по пробелам. При этом<br>
неважно сколько их. Далее остается только снова собрать слова в строку через<br>
"*":  <br>
<pre class="code">
    s = input()
    l = s.split()
    s1 = ''
    for i in l:
    	s1 += i + '*'
    s1 = s1[:-1] # удаляем последнюю "*"	
    print(s1)
</pre>

]]>
</content:encoded></item>
<item><title>Списки, кортежи</title><guid>kHGiDulhSz6NbkVAGGh2</guid><pubDate>2015-12-04 04:13:39</pubDate><author>vit01</author><link>https://idec.foxears.su/kHGiDulhSz6NbkVAGGh2#kHGiDulhSz6NbkVAGGh2</link>
		<description>
		Дан список-массив, заполненный случайным образом нулями и единицами. Найти
самую длинную непрерывную последовательность единиц и определить индексы
первого и последнего элементов в ней.
**Решение задачи:**
  1. Пусть переменная count содержит текущее значение количества единиц, а...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Дан список-массив, заполненный случайным образом нулями и единицами. Найти<br>
самую длинную непрерывную последовательность единиц и определить индексы<br>
первого и последнего элементов в ней.<br>
**Решение задачи:**<br>
  1. Пусть переменная count содержит текущее значение количества единиц, а max_count - максимально найденное на данный момент. Переменная index хранит индекс последнего элемента в самой длинной на данный момент последовательности единиц. <br>
  2. Если очередной элемент 0, то переменная count обнуляется. Однако перед этим ее значение сравнивается с max_count и, если count больше, то max_count перезаписывается на него. В index помещается индекс последнего элемента найденной последовательности единиц.<br>
  3. При выводе данных на экран, чтобы получить индекс первого элемента последовательности, надо из последнего вычесть уменьшенную на единицу длину последовательности.<br>
<pre class="code">
    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 &lt; len(a):
    	if a[i] == 1:
    		count += 1
    	else:
    		if count &gt; max_count:
    			max_count = count
    			index = i-1 # последовательность закончилась на предыдущем элементе
    		count = 0
    	i += 1
    print("Количество элементов: ", max_count)
    print("id первого элемента: ", index-max_count+1)
    print("id последнего элемента: ", index)
</pre>
Пример выполнения кода:<br>
<pre class="code">
    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
</pre>

]]>
</content:encoded></item>
<item><title>Списки, кортежи</title><guid>I9NJkKtc7nS8qmZHg1f7</guid><pubDate>2015-12-04 04:13:39</pubDate><author>vit01</author><link>https://idec.foxears.su/I9NJkKtc7nS8qmZHg1f7#I9NJkKtc7nS8qmZHg1f7</link>
		<description>
		В общем случае алгоритм решения данной задачи можно свести к следующему:
  1. Если очередной элемент меньше нуля, то увеличиваем счетчик отрицательных элементов и добавляем значение элемента к общей сумме отрицательных элементов.
  2. Находим среднее арифметическое среди отрицате...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В общем случае алгоритм решения данной задачи можно свести к следующему:<br>
  1. Если очередной элемент меньше нуля, то увеличиваем счетчик отрицательных элементов и добавляем значение элемента к общей сумме отрицательных элементов.<br>
  2. Находим среднее арифметическое среди отрицательных элементов, разделив сумму значений элементов на количество найденных элементов.<br>
  3. Находим минимальный элемент в массиве. Определяем его индекс. Заменяем значение по найденному индексу на вычисленное выше среднее арифметическое.<br>
Третью подзадачу (замену минимального элемента) можно решить двумя подходами:<br>
1) написать цикл поиска минимального элемента и его индекса или 2)<br>
воспользоваться фунциями встроенными в язык Python (по-сравнению с тем же<br>
Pascal в Python много "дополнительных инструментов").<br>
Функция min() возвращает минимальный элемент из переданного ей аргумента.<br>
(Передавать можно не только список.)<br>
Метод index() возвращает индекс переданного ему элемента в последовательности,<br>
к которой он применяется.<br>
<pre class="code">
    arr = []
    count = 0 # количество отрицательных элементов
    summa = 0 # сумма отрицательных элементов
    for i in range(10):
    	item = int(input(str(i) + ' item: '))
    	arr.append(item)
    	if item &lt; 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)
</pre>
Пример выполнения кода:<br>
<pre class="code">
    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]
</pre>
Решение задачи в "классическом" стиле (без использования функций min() и<br>
index() может выглядеть так:  <br>
<pre class="code">
    arr = []
    count = 0 
    summa = 0 
    min_id = 0 # индекс минимального элемента
    for i in range(10):
    	item = int(input(str(i) + ' item: '))
    	arr.append(item)
    	if item &lt; 0:
    		count += 1
    		summa += item
    		if item &lt; arr[min_id]:
    			min_id = i
    if count != 0:
    	mean = summa/count 
    	arr[min_id] = round(mean)
    	print(mean)
    	print(arr)
</pre>

]]>
</content:encoded></item>
<item><title>Строки</title><guid>awYcVfAzMziojD6FusNl</guid><pubDate>2015-12-04 04:13:39</pubDate><author>vit01</author><link>https://idec.foxears.su/awYcVfAzMziojD6FusNl#awYcVfAzMziojD6FusNl</link>
		<description>
		Допустим, дана строка слов, разделенных пробелами. Необходимо найти в ней
самое длинное слово и заменить в нем буквы 'a' на буквы 'b'.
Сразу следует оговорить, что в отличие, скажем от Pascal, в Python строки
неизменяемы. Т.е. в Питоне изменить символы в строке в принципе нельзя....
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Допустим, дана строка слов, разделенных пробелами. Необходимо найти в ней<br>
самое длинное слово и заменить в нем буквы 'a' на буквы 'b'.<br>
Сразу следует оговорить, что в отличие, скажем от Pascal, в Python строки<br>
неизменяемы. Т.е. в Питоне изменить символы в строке в принципе нельзя.<br>
Поэтому есть только один выход: сформировать новую измененую строку, или<br>
просто заменять определенные символы при выводе их на экран. Выберем первый<br>
путь.<br>
Сформировать новую строку также можно двумя способами (как минимум):<br>
  * преобразовать исходную в список, выполнить в нем замену, а затем элементы списка соединить в новую строку,<br>
  * вырезать из первой строки все символы до самого длинного слова, посимвольно добавить к ней изменяемое длинное слово, досоединить остаток первой строки.<br>
Логически первый способ проще.<br>
Сам алгоритм поиска самого длинного слова выгляд так:<br>
  1. Если очередной символ не пробел, то увеличиваем счетчик букв слова.<br>
  2. Если все же пробел, то проверяем не самое ли это длинное на данный момент слов. Если это так, то запоминаем длину этого слова (max_w) и индекс начала слова (id_w).<br>
  3. Поскольку последнее слово могло быть не проверено в цикле, то делаем еще одну проверку длины слова за пределами цикла.<br>
При замене букв символы слова перебираются, и если встретиться "нужная" буква,<br>
то вместо нее записывается другая.<br>
<pre class="code">
    s = input()
    s = list(s) # преобразуем в список
    l = len(s)
    max_w = 0
    id_w = 0
    count = 0
    i = 0
    while i &lt; l:
    	if s[i] != ' ':
    		count += 1
    	else:
    		if count &gt; max_w:
    			max_w = count
    			id_w = i - count
    		count = 0
    	i += 1
    if count &gt; max_w: # проверяем последнее слово
    	max_w = count
    	id_w = i - count
    id_w_end = id_w + max_w
    while id_w &lt; id_w_end:
    	if s[id_w] == 'a':
    		s[id_w] = 'b'
    	id_w += 1
    s1 = ''
    for i in s:
    	s1 += i	
    print(s1)
</pre>
Второй способ - через срезы. Здесь не надо в начале программы преобразовывать<br>
строку к списку.  <br>
<pre class="code">
    # часть кода - только замена символов
    s1 = s[0:id_w]
    id_w_end = id_w + max_w
    while id_w &lt; id_w_end:
    	if s[id_w] == 'a':
    		s1 += 'b'
    	else:
    		s1 += s[id_w]
    	id_w += 1
    s1 += s[id_w:]
    print(s1)
</pre>
Пример выполнения кода:<br>
<pre class="code">
    very many variants and variables
    very many variants and vbribbles
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>hzSkmUjEhgcnvOMobsMZ</guid><pubDate>2015-12-04 04:13:38</pubDate><author>vit01</author><link>https://idec.foxears.su/hzSkmUjEhgcnvOMobsMZ#hzSkmUjEhgcnvOMobsMZ</link>
		<description>
		Дан ряд чисел 1, -0.5, 0.25, -0.125, ... Требуется найти сумму стольких его
элементов, сколько указал пользователь. Например, если n = 3, то надо сложить
1, -0.5, 0.25, что в результате даст 0.75.
При решении таких задач сначала необходимо определить, в чем заключается
особенност...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Дан ряд чисел 1, -0.5, 0.25, -0.125, ... Требуется найти сумму стольких его<br>
элементов, сколько указал пользователь. Например, если n = 3, то надо сложить<br>
1, -0.5, 0.25, что в результате даст 0.75.<br>
При решении таких задач сначала необходимо определить, в чем заключается<br>
особенность предложенного ряда. В данном случае видим, что каждый последующий<br>
элемент в 2 раза меньше предыдущего по модулю, но взят с противоположным<br>
знаком. Далее следует найти арифметическое действие, которое из предыдущего<br>
элемента дает последующий. Здесь, например, надо предыдущий элемент делить на<br>
-2.<br>
**Алгоритм решения задачи:**<br>
  1. Присвоим переменной a первое число ряда.<br>
  2. Создадим счетчик суммированных элементов ряда (i).<br>
  3. Создадим переменную для накопления суммы элементов ряда.<br>
  4. Пока счетчик не отсчитает заданного количества элементов ряда (пока i &lt; n) будем выполнять нижеследующие действия.<br>
  5. К сумме будем добавлять значение текущего элемента.<br>
  6. Изменим значение текущего элемента на то, которое должно быть следующим (разделим на -2).<br>
  7. Увеличим значение счетчика на 1.<br>
<pre class="code">
    n = input("Количество элементов ряда: ")
    n = int(n)
    a = 1
    i = 0
    summa = 0
    while i &lt; n:
    	summa += a
    	a = a/-2
    	i += 1
    print(summa)
</pre>
Примеры выполнения:<br>
<pre class="code">
    Количество элементов ряда: 4
    0.625

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

]]>
</content:encoded></item>
<item><title>Строки</title><guid>Dqi7CntgmEdHC259SXnJ</guid><pubDate>2015-12-04 04:13:38</pubDate><author>vit01</author><link>https://idec.foxears.su/Dqi7CntgmEdHC259SXnJ#Dqi7CntgmEdHC259SXnJ</link>
		<description>
		Дана строка, содержащая натуральные числа и слова. Необходимо сформировать
список из чисел, содержащихся в этой строке.
Следует посимвольно перебирать строку. Если очередной символ цифра, то надо
добавить ее в новую строку. Далее проверять символы за ней, и если они тоже
цифры, т...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Дана строка, содержащая натуральные числа и слова. Необходимо сформировать<br>
список из чисел, содержащихся в этой строке.<br>
Следует посимвольно перебирать строку. Если очередной символ цифра, то надо<br>
добавить ее в новую строку. Далее проверять символы за ней, и если они тоже<br>
цифры, то добавлять их в конец этой новой подстроки из цифр. Когда очередной<br>
символ окажется не цифрой, или будет достигнут конец строки, то надо<br>
преобразовать строку из цифр в число и добавить в список.<br>
<pre class="code">
    s = input()
    l = len(s)
    integ = []
    i = 0
    while i &lt; l:
        s_int = ''
        a = s[i]
        while '0' &lt;= a &lt;= '9':
            s_int += a
            i += 1
            if i &lt; l:
                a = s[i]
            else:
                break
        i += 1
        if s_int != '':
            integ.append(int(s_int))
    print(integ)
</pre>
<pre class="code">
    5 dkfj78df 9 8 dkfj8
    [5, 78, 9, 8, 8]
</pre>

]]>
</content:encoded></item>
<item><title>Строки</title><guid>62ndPMOEtsYOFmJC6Qz8</guid><pubDate>2015-12-04 04:13:38</pubDate><author>vit01</author><link>https://idec.foxears.su/62ndPMOEtsYOFmJC6Qz8#62ndPMOEtsYOFmJC6Qz8</link>
		<description>
		Дан массив слов. Требуется заменить последние три символа слов, имеющих
определенную длину, на символ $.
Если длина очередного слова больше определенной длины, то взять срез от начала
слова и до конца, но без трех последних символов и присоединить к этому срезу
символ $. Далее сл...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Дан массив слов. Требуется заменить последние три символа слов, имеющих<br>
определенную длину, на символ $.<br>
Если длина очередного слова больше определенной длины, то взять срез от начала<br>
слова и до конца, но без трех последних символов и присоединить к этому срезу<br>
символ $. Далее следует заменить в массиве старую строку на полученную.<br>
Выражение words[i][0:-3] означает, что из массива-списка сначала "берется"<br>
очередная строка, а далее из нее берется указанный срез.<br>
<pre class="code">
    words = []
    for i in range(10):
    	words.append(input())
    i = 0
    while i &lt; len(words):
    	if len(words[i]) &gt; 5:
    		words[i] = words[i][0:-3] + '$'
    	i += 1
    print(words)
</pre>
Пример выполнения кода:<br>
<pre class="code">
    keybord
    display
    processor
    where
    you
    kitchen
    window
    small
    big
    monster
    ['keyb$', 'disp$', 'proces$', 'where', 'you', 'kitc$', 'win$', 'small', 'big', 'mons$']
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>Z6Hi1X2A0AnCxhmFjg9t</guid><pubDate>2015-12-04 04:13:37</pubDate><author>vit01</author><link>https://idec.foxears.su/Z6Hi1X2A0AnCxhmFjg9t#Z6Hi1X2A0AnCxhmFjg9t</link>
		<description>
		Бывают ситуации, когда данные на экран надо вывести не через один пробел, а
как бы в виде таблицы. Другими словами, в полях определенной ширина, где
ширина измеряется в знакоместах. Рассмотрим пример. Допустим надо вывести
числа второй строки под числами первой. Если выполнить фу...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Бывают ситуации, когда данные на экран надо вывести не через один пробел, а<br>
как бы в виде таблицы. Другими словами, в полях определенной ширина, где<br>
ширина измеряется в знакоместах. Рассмотрим пример. Допустим надо вывести<br>
числа второй строки под числами первой. Если выполнить функцию print() так:<br>
<pre class="code">
    print(10,235)
    print(1000,50)
</pre>
то результат будет выглядеть так:  <br>
<pre class="code">
    10 235
    1000 50
</pre>
Поэтому, чтобы вывод выглядел красиво, необходимо задать ширину поля. Делается<br>
это так:  <br>
<pre class="code">
    print("%5d%7d" % (10,235))
    print("%5d%7d" % (1000,50))
</pre>
Результат:  <br>
<pre class="code">
       10     235
     1000     50
</pre>
Здесь в кавычках указаны форматы данных и ширина полей. После знака % за<br>
кавычками указаны данные, которые будут подставлены вместо каждого указанного<br>
формата. Если количество форматов не совпадает с количеством данных, то<br>
возникнет ошибка.<br>
Форматы данных могут быть: d - целое число, s - строка, f - вещественное<br>
число.<br>
По умолчанию данные выравниваются по правому краю поля. Чтобы выровнять их по<br>
левому достаточно поставить знак минус перед числом, обозначающим ширину поля.<br>
Пример:  <br>
<pre class="code">
    print("%-5d%7d" % (10,235))
    print("%-5d%7d" % (1000,50))
</pre>
Вывод:  <br>
<pre class="code">
    10       235
    1000      50
</pre>

]]>
</content:encoded></item>
<item><title>Строки</title><guid>BNiHoQD04IE2XM0EE4zf</guid><pubDate>2015-12-04 04:13:37</pubDate><author>vit01</author><link>https://idec.foxears.su/BNiHoQD04IE2XM0EE4zf#BNiHoQD04IE2XM0EE4zf</link>
		<description>
		В заданной строке найти самое короткое слово. Слова могут быть разделены
пробелами, несколькими пробелами, знаками препинания.
**Алгоритм решения задачи:**
  1. Длина очередного слова будет храниться в переменной w. Вначале присвоим этой переменно 0, т. к. в строке слов может воо...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В заданной строке найти самое короткое слово. Слова могут быть разделены<br>
пробелами, несколькими пробелами, знаками препинания.<br>
**Алгоритм решения задачи:**<br>
  1. Длина очередного слова будет храниться в переменной w. Вначале присвоим этой переменно 0, т. к. в строке слов может вообще не быть.<br>
  2. Длина самого короткого слова будет записана в переменной min_w. Вначале этой переменной присваивается максимально возможная длина слова. Самое длинное слово может быть, если вся строка состоит только из одного слова. Поэтому сначала min_w равна длине строки.<br>
  3. Перебираем строку посимвольно в цикле for.<br>
  4. Если очередной символ является буквой, то увеличиваем значение w.<br>
  5. Иначе проверяем не меньше ли длина только что "измеренного" слова, чем значение min_w. Если это так, то меняем значение min_w на значение w. <br>
  6. Также в ветке else (иначе) обнуляем w, т.к. очередное слово закончилось и необходимо будет "измерять" новое.<br>
<pre class="code">
    s = input()
    w = 0
    min_w = len(s)
    for i in s:
    	if 'a'&lt;=i&lt;='z' or 'A'&lt;=i&lt;='Z' \
    	or 'а'&lt;=i&lt;='я' or 'А'&lt;=i&lt;='Я':
    		w += 1
    	else:
    		if w &lt; min_w and w != 0:
    			min_w = w
    		w = 0
    print(min_w)
</pre>
Пример работы программы:<br>
<pre class="code">
    Кто сказал мяу?            3
========
    1   what 
    4
</pre>

]]>
</content:encoded></item>
<item><title>Условный оператор</title><guid>oAOBanvlu9FcL7ulvWpq</guid><pubDate>2015-12-04 04:13:37</pubDate><author>vit01</author><link>https://idec.foxears.su/oAOBanvlu9FcL7ulvWpq#oAOBanvlu9FcL7ulvWpq</link>
		<description>
		В зависимости от того, что выберет пользователь, вычислить площадь либо
прямоугольника, либо треугольника, либо круга. Если выбраны прямоугольник или
треугольник, то надо запросить длины сторон, если круг, то его радиус.
Площадь треугольника вычисляется по формуле Герона:  
![Фор...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В зависимости от того, что выберет пользователь, вычислить площадь либо<br>
прямоугольника, либо треугольника, либо круга. Если выбраны прямоугольник или<br>
треугольник, то надо запросить длины сторон, если круг, то его радиус.<br>
Площадь треугольника вычисляется по формуле Герона:  <br>
![Формула Герона](<a href="http://yandex.st/serp/0xdd2480d/libs/z-math/blocks/z-math/fo" class="url">http://yandex.st/serp/0xdd2480d/libs/z-math/blocks/z-math/fo</a><br>
rmula/z-math__formula_for_tri-square-abc-f.png)<br>
<pre class="code">
    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("Ошибка ввода")
</pre>
Пример выполнение программы:  <br>
<pre class="code">
    Выберите фигуру (1-прямоугольник, 2-треугольник, 3-круг): 2
    Длины сторон треугольника:
    a = 4.5
    b = 2.8
    c = 6.1
    Площадь: 5.87
</pre>

]]>
</content:encoded></item>
<item><title>Строки</title><guid>dBO5pSGaHUJPtwuC9o3g</guid><pubDate>2015-12-04 04:13:37</pubDate><author>vit01</author><link>https://idec.foxears.su/dBO5pSGaHUJPtwuC9o3g#dBO5pSGaHUJPtwuC9o3g</link>
		<description>
		Вводится строка, состоящая из слов, разделенных пробелами. Требуется
отсортировать слова в строке так, чтобы наиболее короткие из них были вначале
строки, а наиболее длинные в конце.
**Алгоритм решения задачи:**
  1. Преобразуем строку в список слов. Для этого следует воспользова...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Вводится строка, состоящая из слов, разделенных пробелами. Требуется<br>
отсортировать слова в строке так, чтобы наиболее короткие из них были вначале<br>
строки, а наиболее длинные в конце.<br>
**Алгоритм решения задачи:**<br>
  1. Преобразуем строку в список слов. Для этого следует воспользоваться методом `split()`.<br>
  2. Измерим длину получившегося списка. Это значение показывает количество элементов списка, т.е. количество слов.<br>
  3. Используя метод пузырька, отсортируем элементы списка по их длине. Во внутреннем цикле сортировки должны сравниваться не значения элементов, а их длина.<br>
  4. Создадим пустую строку. В цикле по элементам списка будем добавлять каждое слово в конец этой новой строки, а также добавлять пробел после каждого слова.<br>
<pre class="code">
    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]) &gt; 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)
</pre>
Пример работы программы:<br>
<pre class="code">
    ab aaab ba baaaaa a aba
    a ab ba aba aaab baaaaa
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>1P0IFyHhoDTQe6bNkbvQ</guid><pubDate>2015-12-04 04:13:36</pubDate><author>vit01</author><link>https://idec.foxears.su/1P0IFyHhoDTQe6bNkbvQ#1P0IFyHhoDTQe6bNkbvQ</link>
		<description>
		Найти площадь и периметр прямоугольного треугольника по двум заданным катетам.
Площадь прямоугольного треугольника равна половине площади прямоугольника,
стороны которого равны длинам катетов. Периметр же находится путем сложения
длин всех сторон треугольника.
Поскольку известны ...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Найти площадь и периметр прямоугольного треугольника по двум заданным катетам.<br>
Площадь прямоугольного треугольника равна половине площади прямоугольника,<br>
стороны которого равны длинам катетов. Периметр же находится путем сложения<br>
длин всех сторон треугольника.<br>
Поскольку известны только катеты, то гипотенузу можно найти по теореме<br>
Пифагора: c2 = a2 \+ b2.<br>
Чтобы извлечь квадратный корень в Python можно воспользоваться функцией sqrt()<br>
из модуля math.<br>
<pre class="code">
    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)
</pre>
Результат:  <br>
<pre class="code">
    Длина первого катета: 5.4
    Длина второго катета: 2.1
    Площадь треугольника: 5.67
    Периметр треугольника: 13.29
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>z9iMenjlkrcFkwsQYCYk</guid><pubDate>2015-12-04 04:13:36</pubDate><author>vit01</author><link>https://idec.foxears.su/z9iMenjlkrcFkwsQYCYk#z9iMenjlkrcFkwsQYCYk</link>
		<description>
		Вычислить продолжительность года на двух планетах по введенным их радиусам
орбит и скорости движения по орбитам.
Выяснить, правда ли, что год на первой платете длиннее, чем на второй.
Продолжительность года вычисляется по формуле 2 * радиус_орбиты * пи /
орбитальная_скорость.
===...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Вычислить продолжительность года на двух планетах по введенным их радиусам<br>
орбит и скорости движения по орбитам.<br>
Выяснить, правда ли, что год на первой платете длиннее, чем на второй.<br>
Продолжительность года вычисляется по формуле 2 * радиус_орбиты * пи /<br>
орбитальная_скорость.<br>
<pre class="code">
    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 &gt; year2))
</pre>
Примерные результаты выполнения программы:  <br>
<pre class="code">
    Планета №1: Земля
    Радиус ее орбиты (млн. км): 150
    Ее орбитальная скорость (км/с): 30
    Планета №2: Венера
    Радиус ее орбиты (млн. км): 108
    Ее орбитальная скорость (км/с): 35
    Длина года в днях на планете Земля: 364
    Длина года в днях на планете Венера: 224
    Длина года на Земля больше, чем на Венера? True

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

]]>
</content:encoded></item>
<item><title>Списки, кортежи</title><guid>Ojcs5CGmC24nCwYwMzIN</guid><pubDate>2015-12-04 04:13:35</pubDate><author>vit01</author><link>https://idec.foxears.su/Ojcs5CGmC24nCwYwMzIN#Ojcs5CGmC24nCwYwMzIN</link>
		<description>
		Найти расстояние между точками с заданными координатами в n-мерном
пространстве. Расстояние находится по формуле d = sqrt((a1 - b1)2 + (a2 -
b2)^2 + ... + (an - bn)^2), где sqrt - квадратный корень, а1...an -
координаты первой точки, b1..bn - соответствующие координаты второй точ...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Найти расстояние между точками с заданными координатами в n-мерном<br>
пространстве. Расстояние находится по формуле d = sqrt((a1 - b1)2 + (a2 -<br>
b2)^2 + ... + (an - bn)^2), где sqrt - квадратный корень, а1...an -<br>
координаты первой точки, b1..bn - соответствующие координаты второй точки.<br>
#### Особенности решения задачи<br>
Чтобы не вводить каждую координату отдельно, можно запросить сразу все для<br>
каждой точки. Поскольку данные будут иметь строковый тип, то преобразовать их<br>
к списку можно с помощью функции split(). В качестве аргумента функции<br>
передается строка-разделитель, по которому отделяются элементы; если аргумент<br>
отсутствует, то строка разделяется по пробелу. Несмотря на такое разделение,<br>
каждый элемент списка по-прежнему является строкой, а не числом.<br>
Фунция zip() возвращает кортежи соответствующих элементов последовательностей.<br>
Т.е. если ей передать два списка, то на первой итерации будет возвращен кортеж<br>
из первых элементов обоих списков, на второй - из вторых и т. д.<br>
<pre class="code">
    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)
</pre>
Пример работы программы:<br>
<pre class="code">
    Количество измерений пространства: 4
    Через пробел
    введите 4 координаты 1-ой точки: 2 3 -7 4
    введите 4 координаты 2-ой точки: 0 0 0 0
    Расстояние между точками: 8.83
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>RPyH9lW7DIlWq0RKzzGz</guid><pubDate>2015-12-04 04:13:35</pubDate><author>vit01</author><link>https://idec.foxears.su/RPyH9lW7DIlWq0RKzzGz#RPyH9lW7DIlWq0RKzzGz</link>
		<description>
		Найти сумму и количество элементов последовательности, которые по модулю
больше 0.001. Последовательность: 1/2 - 2/4 + 3/8 - 4/16 + ... - ...
В данной последовательности каждый последующий элемент отличается от
предыдущего:
  * знаком,
  * числитель увеличен на 1,
  * знаменатель...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Найти сумму и количество элементов последовательности, которые по модулю<br>
больше 0.001. Последовательность: 1/2 - 2/4 + 3/8 - 4/16 + ... - ...<br>
В данной последовательности каждый последующий элемент отличается от<br>
предыдущего:<br>
  * знаком,<br>
  * числитель увеличен на 1,<br>
  * знаменатель увеличен в 2 раза.<br>
Значит каждый следующий элемент ряда вычисляется из текущего по формуле<br>
-(a+1)/(b*2), где a и b \- числитель и знаменатель дроби числа ряда.<br>
<pre class="code">
    a = 1 # числитель
    b = 2 # знаменатель
    sign = 1 # умножаем на 1 или -1, чтобы поменять знак числа
    n = 0 # количество чисел ряда
    summa = 0 # сумма n-элементов ряда чисел
    while a/b &gt; 0.001:
    	summa += sign * a / b
    	n += 1
    	a = a + 1
    	b = b * 2
    	sign = -sign
    print(summa)
    print(n)
</pre>
Результат выполнения кода:<br>
<pre class="code">
    0.2227783203125
    13
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>4fvEk0pP5ek7FKagt3tz</guid><pubDate>2015-12-04 04:13:35</pubDate><author>vit01</author><link>https://idec.foxears.su/4fvEk0pP5ek7FKagt3tz#4fvEk0pP5ek7FKagt3tz</link>
		<description>
		Требуется вычислить, сколько банок краски потребуется, чтобы окрасить
поверхность бака цилиндрической формы. Покрасить надо и снаружи, и изнутри.
Пользователь вводит диаметр и высоту бака, а также какую площадь можно
окрасить одной банкой краски.
Чтобы понять, сколько банок краск...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Требуется вычислить, сколько банок краски потребуется, чтобы окрасить<br>
поверхность бака цилиндрической формы. Покрасить надо и снаружи, и изнутри.<br>
Пользователь вводит диаметр и высоту бака, а также какую площадь можно<br>
окрасить одной банкой краски.<br>
Чтобы понять, сколько банок краски потребуется, надо знать площадь цилиндра.<br>
Она представляет собой сумму площадей двух кругов (крышка баки и дно) и<br>
площади непосредственно цилиндрической поверхности. Кроме того, если бак<br>
красится и изнутри, найденную площедь следует умножить на 2.<br>
Площадь круга через диаметр равна pi * d2 / 4.  <br>
Площадь цилиндра: pi * d * h (где d и h - диаметр и высота цилиндра).<br>
<pre class="code">
    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)
</pre>
Выражение `int(qty) + 1` требуется, если надо найти целое значение количества<br>
банок (ведь пол банки не купишь).<br>

]]>
</content:encoded></item>
<item><title>Функции</title><guid>yXXkuj44G1yFzX3AWK5e</guid><pubDate>2015-12-04 04:13:35</pubDate><author>vit01</author><link>https://idec.foxears.su/yXXkuj44G1yFzX3AWK5e#yXXkuj44G1yFzX3AWK5e</link>
		<description>
		В решении данной задачи можно выделить три части:
  1. Заполнение квадратной матрицы
  2. Вызов функции
  3. Функция
#### Заполнение квадратной матрицы
В терминах языка программирования Python матрица - это список с вложенными
списками одинаковой длины. Если говорить о квадратной...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В решении данной задачи можно выделить три части:<br>
  1. Заполнение квадратной матрицы<br>
  2. Вызов функции<br>
  3. Функция<br>
#### Заполнение квадратной матрицы<br>
В терминах языка программирования Python матрица - это список с вложенными<br>
списками одинаковой длины. Если говорить о квадратной матрице (а только в этом<br>
случае имеет смысл говорить о ее диагоналях), то количество вложенных списков<br>
и количество элементов в них должно совпадать. Например, список<br>
[[12,45,18][0,3,10][21,18,6]] можно назвать квадратной матрицей.<br>
Пусть квадратная матрица заполняется случайными числами и ее размерность будет<br>
равна 10 (т. е. 10 строк и 10 столбцов). Перед заполнением матрицы, создается<br>
пустой список. Во внешнем цикле осуществляется проход по строкам, которые<br>
представляют собой вложенные списки. Сначала создается пустой вложенный<br>
список, потом во внутреннем цикле он заполняется случайными числами, после<br>
чего уже заполненный добавляется в основной список. При заполнении матрицы<br>
может также осуществляться вывод ее на экран.<br>
#### Вызов функции<br>
Поскольку функция должна уметь по выбору вычислять как сумму главной, так и<br>
побочной диагонали, то в нее необходимо передавать не только список, но и<br>
"сигнал" о том, по какому пути ей идти. Если функция будет возвращать<br>
полученную сумму в основную ветку программы, то вызов функции надо связать с<br>
переменной или поместить как аргумент в функцию `print()`.<br>
Перед вызовом функции надо получить значение переменной-"сигнала". Сумму какой<br>
диагонали вычислять, может выбрать пользователь. Например, если он вводит<br>
символ '1', то вычислять главную диагональ, если '2', то побочную. Так как<br>
пользователь может ввести не только эти символы, а какие угодно, то разумно<br>
заключить вызов функции и вывод результата на экран в конструкцию `if`,<br>
условием выполнения которой будет правильно введенный символ.<br>
#### Функция<br>
При написании функции надо сделать выбор, будет ли она выводить результат на<br>
экран в своем теле или возвращать в основную ветку программы. Пусть функция<br>
возвращает результат, в таком случае она должна содержать оператор return<br>
(обычно, но не обязательно, в конце тела функции), после которого указывается<br>
возвращаемое значение.<br>
Главная диагональ квадратной матрицы идет от левого верхнего угла до нижнего<br>
правого, и, следовательно, каждый элемент такой диагонали имеет совпадающие<br>
первый и второй индексы. При этом индексы следующего элемента диагонали<br>
отличаются от предыдущего на 1. Т.е. первый элемент главной диагонали имеет<br>
индексы [0][0], второй - [1][1] и т.д. Поэтому для нахождения суммы элементов<br>
главной диагонали, надо построчно перебрать матрицу и в каждой строке взять<br>
элемент, номер которого совпадает с номером строки, и добавить его значение в<br>
общую сумму.<br>
Побочная диагональ идет из верхнего правого угла в нижний левый. Индексы ее<br>
элементов обратны. В первой строке это будет последний элемент, во второй -<br>
предпоследний и т.д. Если i - это номер строки, равный в начале 0, то второй<br>
индекс будет вычисляться как (N-1)-i. Выражение (N-1) - это индекс последнего<br>
элемента при индексации с нуля.<br>
<pre class="code">
    def diagonal(l,c):
        s = 0
        i = 0
        while i &lt; 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)
</pre>
Пример выполнения кода:<br>
<pre class="code">
      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
</pre>

]]>
</content:encoded></item>
<item><title>Списки, кортежи</title><guid>nXdvrN1d0zw4TjziqNfA</guid><pubDate>2015-12-04 04:13:34</pubDate><author>vit01</author><link>https://idec.foxears.su/nXdvrN1d0zw4TjziqNfA#nXdvrN1d0zw4TjziqNfA</link>
		<description>
		В списке, состоящем из положительных и отрицательных целых чисел, найти
первый, третий и шестой положительные элементы и вычислить их произведение.
Задача усложнена тем, что, например, третий по счету положительный элемент
может быть далеко не третим в списке, а каким угодно.
**О...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В списке, состоящем из положительных и отрицательных целых чисел, найти<br>
первый, третий и шестой положительные элементы и вычислить их произведение.<br>
Задача усложнена тем, что, например, третий по счету положительный элемент<br>
может быть далеко не третим в списке, а каким угодно.<br>
**Основная часть алгоритма решения задачи:**<br>
  1. Ввести в программу счетчик положительных элементов (j). Присвоить ему значение 1 (т.е. он указывает на первый положительный элемент).<br>
  2. Перебирать элементы массива-списка по-очереди. Если очередной элемент положительный и счетчик положительных элементов равен 1 или 3 или 6, то сохранить в соответствующей переменной индекс данного элемента. Кроме того, если шестой положительный элемент найден, то нет смысла продолжать цикл дальше и можно его завершить (оператор `break`).<br>
  3. Если в массиве был найден шестой положительный элемент (первый и третий тогда точно найдены), то вычислить произведение.<br>
В программе ниже для заполнения списка используется так называемый генератор.<br>
В данном случае выражение `round(random.random() * 100) - 50` используется в<br>
цикле, который выполняется 20 раз. И на каждой итерации цикла получившееся<br>
число помещается в список a.<br>
<pre class="code">
    import random
    a = [round(random.random() * 100) - 50 for i in range(20)]
    print(a)
    i = j = 0
    i1 = i3 = i6 = -1
    while i &lt; 20:
    while i &lt; 20:
    	if a[i] &gt; 0:
    		if j == 1:
    			i1 = i
    		elif j == 3:
    			i3 = i
    		elif j == 6:
    			i6 = i
    			break
    		j += 1
    	i += 1
    if i6 &gt; 0:
    	mult = a[i1] * a[i3] * a[i6]
    	print("Индексы элементов:", i1, i3, i6)
    	print("%d * %d * %d = %d" % (a[i1], a[i3], a[i6], mult))
</pre>
<pre class="code">
    [-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
</pre>

]]>
</content:encoded></item>
<item><title>Функции</title><guid>zFdfyAma3G9bsaNz2wWM</guid><pubDate>2015-12-04 04:13:34</pubDate><author>vit01</author><link>https://idec.foxears.su/zFdfyAma3G9bsaNz2wWM#zFdfyAma3G9bsaNz2wWM</link>
		<description>
		Найти остаток от деления целой части значения функции y = log(x²+ab) на 7 и, в
зависимости от его величины, напечатать сообщение об одном из дней недели.
Значения переменных а, b, x получить случайным образом на указанном
пользователем интервале.
Поскольку три случайных числа выч...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Найти остаток от деления целой части значения функции y = log(x²+ab) на 7 и, в<br>
зависимости от его величины, напечатать сообщение об одном из дней недели.<br>
Значения переменных а, b, x получить случайным образом на указанном<br>
пользователем интервале.<br>
Поскольку три случайных числа вычисляются по одной и той же формуле, то лучше<br>
ее оформить в отдельную функцию.<br>
Функци log модуля math вычисляет натуральный логарифм (если ей не передан<br>
второй аргумент-основание алгоритма).<br>
Для определения дня недели можно было бы использовать условный оператор, но<br>
вариант со списком намного короче.<br>
<pre class="code">
    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
    пт
</pre>

]]>
</content:encoded></item>
<item><title>Условный оператор</title><guid>YWsBzWfk9Fy8Tz8ZKTz2</guid><pubDate>2015-12-04 04:13:34</pubDate><author>vit01</author><link>https://idec.foxears.su/YWsBzWfk9Fy8Tz8ZKTz2#YWsBzWfk9Fy8Tz8ZKTz2</link>
		<description>
		Пользователь вводит либо количество байт, либо килобайт, мегабайт или
гигабайт. Следует перевести значение во все другие единицы измерения.
В 1Кб 1024 байт, 1Мб = 1024Кб и т. д. 1024 - это 210.
====
    units = input("Выберите единицы измерения:\n \
    \t1 - байты,\n \
    \t2 -...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Пользователь вводит либо количество байт, либо килобайт, мегабайт или<br>
гигабайт. Следует перевести значение во все другие единицы измерения.<br>
В 1Кб 1024 байт, 1Мб = 1024Кб и т. д. 1024 - это 210.<br>
<pre class="code">
    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))
</pre>
Примеры выполнения программы:  <br>
<pre class="code">
    Выберите единицы измерения:
     	1 - байты,
     	2 - килобайты,
     	3 - мегабайты,
     	4 - гигабайты.
    №: 2
    Введите значение: 1679
    Байты:        1719296
    Мегабайты:      1.640
    Гигабайты:      0.002
</pre>
<pre class="code">
    Выберите единицы измерения:
     	1 - байты,
     	2 - килобайты,
     	3 - мегабайты,
     	4 - гигабайты.
    №: 4
    Введите значение: 1.345
    Байты:     1444182753
    Килобайты:    1410334
    Мегабайты:       1377
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>BDC3Di4rTmwZg6yRMLVj</guid><pubDate>2015-12-04 04:13:33</pubDate><author>vit01</author><link>https://idec.foxears.su/BDC3Di4rTmwZg6yRMLVj#BDC3Di4rTmwZg6yRMLVj</link>
		<description>
		Определить, сколько в введенном пользотелем числе четных цифр, а сколько
нечетных.
Если число делится без остатка на 2 (т. е. остаток равен нулю), значит оно
четное. Увеличиваем на 1 счетчик четных цифр (even). Иначе число нечетное,
увеличиваем счетчик нечетных цифр (odd). В Pyth...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Определить, сколько в введенном пользотелем числе четных цифр, а сколько<br>
нечетных.<br>
Если число делится без остатка на 2 (т. е. остаток равен нулю), значит оно<br>
четное. Увеличиваем на 1 счетчик четных цифр (even). Иначе число нечетное,<br>
увеличиваем счетчик нечетных цифр (odd). В Python операцию нахождения остатка<br>
от деления выполняет знак %.<br>
Чтобы избавиться от младшего (уже учтенного) разряда число следует разделить<br>
нацело на 10. Деление нацело обозначается так: //.<br>
<pre class="code">
    a = input()
    a = int(a)
    even = 0
    odd = 0
    while a &gt; 0:
    	if a % 2 == 0:
    		even += 1
    	else:
    		odd += 1
    	a = a // 10
    print("Even: %d, odd: %d" % (even, odd))
</pre>
Примерный результат:  <br>
<pre class="code">
    65439
    Even: 2, odd: 3
</pre>

]]>
</content:encoded></item>
<item><title>Условный оператор</title><guid>PhMWIL4AUA6OO1P4B0XI</guid><pubDate>2015-12-04 04:13:33</pubDate><author>vit01</author><link>https://idec.foxears.su/PhMWIL4AUA6OO1P4B0XI#PhMWIL4AUA6OO1P4B0XI</link>
		<description>
		Определить, принадлежит ли точка с координатами (x;y) кругу радиуса R с
центром в начале координат.
Пользователь вводит координаты точки и радиус круга.
Если выбрать точку на координатной плоскости, то можно увидеть, что проекции
ее координат на оси x и y являются катетами прямоу...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Определить, принадлежит ли точка с координатами (x;y) кругу радиуса R с<br>
центром в начале координат.<br>
Пользователь вводит координаты точки и радиус круга.<br>
Если выбрать точку на координатной плоскости, то можно увидеть, что проекции<br>
ее координат на оси x и y являются катетами прямоугольного треугольника. А<br>
гипотенуза этого прямоугольного треугольника как раз показывает расстояние от<br>
начала координат до точки. Таким образом, если длина гипотенузы будет меньше<br>
радиуса круга, то точка будет принадлежать кругу; иначе она будет находится за<br>
его пределами.<br>
Длину гипотенузы можно вычислить по теореме Пифагора: квадрат гипотенузы равен<br>
сумме квадратов катетов.<br>
<pre class="code">
    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 &lt;= r:
    	print("Точка принадлежит кругу")
    else:
    	print("Точка НЕ принадлежит кругу")
</pre>
Пример выполнения программы:  <br>
<pre class="code">
    x = 1
    y = -1
    R = 3
    Точка принадлежит кругу
</pre>
Обратите внимание, можно вводить отрицательные координаты. При возведении в<br>
квадрат все-равно будет получено положительное число.<br>

]]>
</content:encoded></item>
<item><title>Условный оператор</title><guid>AMd548khLoV1hPA3Ybp9</guid><pubDate>2015-12-04 04:13:33</pubDate><author>vit01</author><link>https://idec.foxears.su/AMd548khLoV1hPA3Ybp9#AMd548khLoV1hPA3Ybp9</link>
		<description>
		В прямоугольной системе координат на плоскости выделяют четверти:  
![Четверти в прямоугольной системе координат](http://upload.wikimedia.org/wiki
pedia/commons/thumb/d/dd/Descartes_system_2D.png/300px-
Descartes_system_2D.png)
  1. I-й четветри соответствуют точки, имеющие обе (...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В прямоугольной системе координат на плоскости выделяют четверти:  <br>
![Четверти в прямоугольной системе координат](<a href="http://upload.wikimedia.org/wiki" class="url">http://upload.wikimedia.org/wiki</a><br>
pedia/commons/thumb/d/dd/Descartes_system_2D.png/300px-<br>
Descartes_system_2D.png)<br>
  1. I-й четветри соответствуют точки, имеющие обе (x и y) положительные координаты.<br>
  2. II-ая четверть: x &lt; 0, y &gt; 0.<br>
  3. III-ая четверть: x &lt; 0, y &lt; 0.<br>
  4. IV-ая четверть: x &gt; 0, y &lt; 0.<br>
<pre class="code">
    print("Введите координаты точки:")
    x = float(input("x = "))
    y = float(input("y = "))
    if x &gt; 0 and y &gt; 0:
    	print("Точка находится в I четверти")
    elif x &lt; 0 and y &gt; 0:
    	print("Точка находится в II четверти")
    elif x &lt; 0 and y &lt; 0:
    	print("Точка находится в III четверти")
    elif x &gt; 0 and y &lt; 0:
    	print("Точка находится в IV четверти")
    elif x == 0 and y == 0:
    	print("Точка находится в начале координат")
    elif x == 0:
    	print("Точка находится на оси 'x'")
    elif y == 0:
    	print("Точка находится на оси 'y'")
</pre>
Задачу можно решить и так:  <br>
<pre class="code">
    if x == 0 and y == 0:
    	print("Точка находится в начале координат")
    elif x == 0:
    	print("Точка находится на оси 'x'")
    elif y == 0:
    	print("Точка находится на оси 'y'") 
    elif x &gt; 0:
    	if y &gt; 0:
    		print("Точка находится в I четверти")
    	elif y &lt; 0:
    		print("Точка находится в IV четверти")
    elif x &lt; 0:
    	if y &gt; 0:
    		print("Точка находится в II четверти")
    	elif y &lt; 0:
    		print("Точка находится в III четверти
</pre>
Результат:  <br>
<pre class="code">
    Введите координаты точки:
    x = 6
    y = -3
    Точка находится в IV четверти
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>uJjHGUH8QQ2yG4Su4cSu</guid><pubDate>2015-12-04 04:13:32</pubDate><author>vit01</author><link>https://idec.foxears.su/uJjHGUH8QQ2yG4Su4cSu#uJjHGUH8QQ2yG4Su4cSu</link>
		<description>
		Тема:
Строки

Вводится натуральное число (&gt; 0). Необходимо найти сумму и произведение цифр,
из которых состоит это число. При этом если в числе встречается цифра 0, то ее
не надо учитывать при нахождении произведения.
Алгоритм решения задачи сводится к извлечению последней цифры ...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Тема:<br>
Строки<br>
<br>
Вводится натуральное число (&gt; 0). Необходимо найти сумму и произведение цифр,<br>
из которых состоит это число. При этом если в числе встречается цифра 0, то ее<br>
не надо учитывать при нахождении произведения.<br>
Алгоритм решения задачи сводится к извлечению последней цифры числа путем<br>
нахождения остатка от деления на 10 и добавлению ее к произведению и сумме.<br>
Далее следует само число разделить нацело на 10, чтобы избавится от последней<br>
цифры. Эти действия следует выполнять до тех пор, пока число больше 0. На<br>
последней итерации цикла однозначное число делится нацело на 10, в результате<br>
чего получается 0 и цикл завершается.<br>
В коде ниже выражение добавления цифры к сумме также можно поместить в ветку if.  <br>
<pre class="code">
    n = int(input())
    mult = 1
    summa = 0
    while n &gt; 0:
    	if n%10 != 0:
    		mult = mult * (n%10)
    	summa = summa + n%10
    	n = n // 10
    print("Сумма цифр:", summa)
    print("Произведение значащих цифр:", mult)
</pre>
В языке программирования Python решить подобную задачу может быть легче другим<br>
способом - оставить число в строковом представлении и далее в цикле for<br>
перебрать элементы последовательности.  <br>
<pre class="code">
    n = input()
    mult = 1
    summa = 0
    for i in n:
    	summa += int(i)
    	if int(i) != 0:
    		mult *= int(i)
    print("Сумма цифр:", summa)
    print("Произведение значащих цифр:", mult)
</pre>
Примечание. Выражение summa += int(i) - это то же самое, что summa = summa +<br>
int(i). Та же сокращенная форма используется и для умножения.<br>
Через строковое представлениие легко решить и более сложную задачу. Например,<br>
надо посчитать сумму и произведение цифр дробного числа или всех цифр,<br>
встречающихся в строке. В таком случае решение может быть таким:  <br>
<pre class="code">
    n = input()
    mult = 1
    summa = 0
    for i in n:
    	if i in ['1','2','3','4','5','6','7','8','9']: # или '1' &lt;= i &lt;= '9'
    		summa += int(i)
    		if int(i) != 0:
    			mult *= int(i)
    print("Сумма цифр:", summa)
    print("Произведение значащих цифр:", mult)
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>OSqUwuSn2X0ICBzpNi4f</guid><pubDate>2015-12-04 04:13:32</pubDate><author>vit01</author><link>https://idec.foxears.su/OSqUwuSn2X0ICBzpNi4f#OSqUwuSn2X0ICBzpNi4f</link>
		<description>
		Вывести степени натуральных чисел, не превосходящие данного числа n.
Пользователь задает показатель степени и число n.
**Алгоритм решения задачи:**
  1. Ввести показатель степени и присвоить его переменной p.
  2. Ввести число n.
  3. Пока натуральное число (i) возведенное в степ...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Вывести степени натуральных чисел, не превосходящие данного числа n.<br>
Пользователь задает показатель степени и число n.<br>
**Алгоритм решения задачи:**<br>
  1. Ввести показатель степени и присвоить его переменной p.<br>
  2. Ввести число n.<br>
  3. Пока натуральное число (i) возведенное в степень p меньше или равно n, то<br>
  4. выводить на экран i в степени p и<br>
  5. увеличивать i на 1 (т.е. переходить к следующему натуральному числу).<br>
<pre class="code">
    # возведение чисел в заданную степень до заданного предела
    p = int(input("Показатель степени: "))
    n = int(input("Максимальный предел степени: "))
    i = 1
    while i**p &lt;= n:
    	print(i**p, end=' ')
    	i += 1
    print("\nПоследнее число, возводимое в степень:", i-1)
</pre>
Примеры выполнения кода:<br>
<pre class="code">
    Показатель степени: 2
    Максимальный предел степени: 100
    1 4 9 16 25 36 49 64 81 100 
    Последнее число, возводимое в степень: 10

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

]]>
</content:encoded></item>
<item><title>Строки</title><guid>oUHGoswYV3LAYspwHtSf</guid><pubDate>2015-12-04 04:13:32</pubDate><author>vit01</author><link>https://idec.foxears.su/oUHGoswYV3LAYspwHtSf#oUHGoswYV3LAYspwHtSf</link>
		<description>
		Вводится строка. Необходимо определить в ней проценты прописных (больших) и
строчных (малых) букв.
Как известно в кодировках символы упорядочены, т.е. коды 'a' &lt; 'b'. Поэтому
если очередной символ принадлежит диапазону от 'a' до 'z', значит это строчная
буква; если диапазону от '...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Вводится строка. Необходимо определить в ней проценты прописных (больших) и<br>
строчных (малых) букв.<br>
Как известно в кодировках символы упорядочены, т.е. коды 'a' &lt; 'b'. Поэтому<br>
если очередной символ принадлежит диапазону от 'a' до 'z', значит это строчная<br>
буква; если диапазону от 'A' до 'Z' - то прописная.<br>
Следует использовать ветку elif, а не else, т. к. помимо букв могут быть иные<br>
символы (пробелы, цифры, знаки препинания и др.).<br>
В языке программирования Python можно выполнять "групповое" присваивание. Так<br>
выражение let_s = let_b = 0 является допустимым и означает, что сначала<br>
переменной let_b был присвоен 0, затем значение let_b было присвоено let_s.<br>
<pre class="code">
    string = input("Введите текст: ")
    length = len(string)
    let_s = let_b = 0
    for i in string:
    	if 'a'&lt;=i&lt;='z':
    		let_s += 1
    	elif 'A'&lt;=i&lt;='Z':
    		let_b += 1
    print("%% строчных букв: %.2f" % (let_s/length * 100))
    print("%% прописных букв: %.2f" % (let_b/length * 100))
</pre>
Удвоенный знак процента в начале строки вывода стоит для того, чтобы вывести<br>
один знак процента. Иначе одиночный % интерпретируется как начало формата<br>
вывода.<br>
Пример выполнения кода:  <br>
<pre class="code">
    Введите текст: Hello, M!
    % строчных букв: 44.44
    % прописных букв: 22.22
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>mHrjutdheyl1BOq3Z0Gq</guid><pubDate>2015-12-04 04:13:31</pubDate><author>vit01</author><link>https://idec.foxears.su/mHrjutdheyl1BOq3Z0Gq#mHrjutdheyl1BOq3Z0Gq</link>
		<description>
		Возьмем, например, такое уравнение: 5x + 10y + 15z = 100. Какие значения
должны иметь переменные x, y, z, чтобы уравнение было верным (т. е. каковы
корни уравнения)? Они могут быть такими: x = 1, y = 8, z = 1. Или такими: x =
4, y = 2, z = 4. Становится понятно, что корней у подо...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Возьмем, например, такое уравнение: 5x + 10y + 15z = 100. Какие значения<br>
должны иметь переменные x, y, z, чтобы уравнение было верным (т. е. каковы<br>
корни уравнения)? Они могут быть такими: x = 1, y = 8, z = 1. Или такими: x =<br>
4, y = 2, z = 4. Становится понятно, что корней у подобных уравнений может<br>
быть множество.<br>
Требуется написать программу, выводящую на экран все возможные корни уравнения<br>
вида ax + by + cz = d, где a, b, c, d - коэффициенты (известны), а x, y, z -<br>
переменные (требуется найти). При этом пусть все числа должны быть<br>
натуральными числами (т. е. &gt; 0).<br>
Решается данная задача методом перебора всех возможных значений x, y, z с<br>
учетом их коэффициентов. Так если a = 10 и d = 100, то x может принять<br>
значения от 1 до 10, т.к. 10 * 10 = 100.  <br>
<pre class="code">
    # Найти все возможные корни уравнения вида
    # ax + by + cz = d, где a, b, c, d - задаются,
    # x, y, z - требуется найти.
    # Все числа (коэффициенты и переменные) - натуральные числа (т.е. &gt; 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))
</pre>
Пример выполнения кода:<br>
<pre class="code">
    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
</pre>
Обычно данную задачу приводят в ином контексте. Требуется найти, сколько<br>
различных (трех видов) товаров можно купить на определенную сумму.  <br>
<pre class="code">
    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)
</pre>
Пример выполнения кода:<br>
<pre class="code">
    Сколько у вас денег? 100
    Цена экземпляра товара 1: 10
    Цена экземпляра товара 2: 20
    Цена экземпляра товара 3: 30
    1 3 1
    2 1 2
    3 2 1
    5 1 1
</pre>
При этом если ставится условие, чтобы всего количество предметов равнялось<br>
какому-то числу или было не меньше какого-то числа, то в условии инструкции if<br>
следует через логический оператор and добавить второе условие (например, a + b<br>
+ c &gt; 5).<br>

]]>
</content:encoded></item>
<item><title>Условный оператор</title><guid>uRpE0HRJ9ekUHKCZcltV</guid><pubDate>2015-12-04 04:13:31</pubDate><author>vit01</author><link>https://idec.foxears.su/uRpE0HRJ9ekUHKCZcltV#uRpE0HRJ9ekUHKCZcltV</link>
		<description>
		Пользователь загадывает число от 1 до 5. Требуется его отгадать, задав как
можно меньше вопросов, и ограничиться только использование оператора ветвления
(обычно подобные задачи решают с помощью цикла).
Чтобы пользователю задать меньше вопросов, надо "разделить" диапазон чисел на...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Пользователь загадывает число от 1 до 5. Требуется его отгадать, задав как<br>
можно меньше вопросов, и ограничиться только использование оператора ветвления<br>
(обычно подобные задачи решают с помощью цикла).<br>
Чтобы пользователю задать меньше вопросов, надо "разделить" диапазон чисел на<br>
две по возможности равные части и определить, в какой из них находится искомое<br>
число.<br>
<pre class="code">
    print("Загадайте в уме число от 1 до 5", end = ' ')
    input("и нажмите Enter")
    a = input("Ваше число больше 3-х? (y/n) ")
    if a == 'y':
    	a = input("Ваше число 4? (y/n) ")
    	if a == 'n':
    		print("Ваше число 5")
    else:
    	a = input("Ваше число 1? (y/n) ")
    	if a == 'n':
    		a = input("Ваше число 2? (y/n) ")
    		if a == 'n':
    			print("Ваше число 3")
    print("Я угадал!")
</pre>
Варианты выполнения программы  <br>
<pre class="code">
    Загадайте в уме число от 1 до 5 и нажмите Enter 
    Ваше число больше 3-х? (y/n) n
    Ваше число 1? (y/n) y
    Я угадал!
</pre>
<pre class="code">
    Загадайте в уме число от 1 до 5 и нажмите Enter
    Ваше число больше 3-х? (y/n) y
    Ваше число 4? (y/n)y
    Я угадал!
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>3V2t6RtKtekcfbwSAbfK</guid><pubDate>2015-12-04 04:13:31</pubDate><author>vit01</author><link>https://idec.foxears.su/3V2t6RtKtekcfbwSAbfK#3V2t6RtKtekcfbwSAbfK</link>
		<description>
		Вводятся два числа в двоичной системе счисления. Требуется выполнить над ними
побитовые операции И, ИЛИ и исключающего ИЛИ. В конце вывести результат
операций также в двоичном представлении.
Побитовые операции выполняются над разрядами числа. Так если имеем два числа
101 и 100, н...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Вводятся два числа в двоичной системе счисления. Требуется выполнить над ними<br>
побитовые операции И, ИЛИ и исключающего ИЛИ. В конце вывести результат<br>
операций также в двоичном представлении.<br>
Побитовые операции выполняются над разрядами числа. Так если имеем два числа<br>
101 и 100, над которыми выполняется побитовая операция ИЛИ, то получим<br>
двоичное число 101:  <br>
101  <br>
100  <br>
101<br>
В языке программирования Python побитовые операции выполняются над числами,<br>
представленными в десятичной системе счисления. Знаки побитовых операций: | -<br>
ИЛИ, &amp; - И, ^ - искл. ИЛИ.<br>
Функция int() всегда преобразует переданную ей строку в десятичную систему<br>
счисления. Но можно указать, в какой системе счисления содержатся данные в<br>
этой строке (двоичной, восьмеричной, шестнадцатеричной).<br>
Функция bin() наоборот принимает десятичное число и возвращает строку,<br>
являющуюся представлением переданного числа в двоичном виде.<br>
<pre class="code">
    n1 = input("Введите первое двоичное число: ")
    n2 = input("Введите второе двоичное число: ")
    n1 = int(n1,2)
    n2 = int(n2,2)
    bit_or = n1 | n2
    bit_and = n1 &amp; n2
    bit_xor = n1 ^ n2
    print("Результат побитового OR: %10s" % bin(bit_or))
    print("Результат побитового AND: %10s" % bin(bit_and))
    print("Результат побитового XOR: %10s" % bin(bit_xor))
</pre>
Результат:  <br>
<pre class="code">
    Введите первое двоичное число: 10100
    Введите второе двоичное число: 10001
    Результат побитового  OR:    0b10101
    Результат побитового AND:    0b10000
    Результат побитового XOR:      0b101
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>8AUJblCahFQAGWBLghXg</guid><pubDate>2015-12-04 04:13:30</pubDate><author>vit01</author><link>https://idec.foxears.su/8AUJblCahFQAGWBLghXg#8AUJblCahFQAGWBLghXg</link>
		<description>
		Уравнение прямой на координатной плоскости имеет следующий вид: y = kx + b.
Если известны координаты двух точек, лежащих на этой прямой, то можно, решая
систему уравнений, определить значения коэффициентов k и b. Таким образом
выводится уравнение конкретной прямой, например, у = ...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Уравнение прямой на координатной плоскости имеет следующий вид: y = kx + b.<br>
Если известны координаты двух точек, лежащих на этой прямой, то можно, решая<br>
систему уравнений, определить значения коэффициентов k и b. Таким образом<br>
выводится уравнение конкретной прямой, например, у = 3x - 1.<br>
Решаем систему уравнений:  <br>
| y1 = kx1 + b  <br>
| y2 = kx2 + b  <br>
b = y2 - kx2  <br>
y1 = kx1 + y2 - kx2  <br>
k = (y1 - y2) / (x1 - x2)<br>
<pre class="code">
    print("Координаты точки A(x1;y1):")
    x1 = float(input("\tx1 = "))
    y1 = float(input("\ty1 = "))
    print("Координаты точки B(x2;y2):")
    x2 = float(input("\tx2 = "))
    y2 = float(input("\ty2 = "))
    print("Уравнение прямой, проходящей через эти точки:")
    k = (y1 - y2) / (x1 - x2)
    b = y2 - k*x2
    print(" y = %.2f*x + %.2f" % (k, b))
</pre>
Примеры выполнения программы:  <br>
<pre class="code">
    Координаты точки A(x1;y1):
    	x1 = 4.3
    	y1 = -1.2
    Координаты точки B(x2;y2):
    	x2 = -8.5
    	y2 = 4
    Уравнение прямой, проходящей через эти точки:
     y = -0.41*x + 0.55
</pre>
<pre class="code">
    Координаты точки A(x1;y1):
    	x1 = -10
    	y1 = -1
    Координаты точки B(x2;y2):
    	x2 = 10
    	y2 = -2 
    Уравнение прямой, проходящей через эти точки:
     y = -0.05*x + -1.50
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>qTm4hrMFCwilJz57djQt</guid><pubDate>2015-12-04 04:13:30</pubDate><author>vit01</author><link>https://idec.foxears.su/qTm4hrMFCwilJz57djQt#qTm4hrMFCwilJz57djQt</link>
		<description>
		Написать программу, умеющую выполнять над двумя вещественными числами
арифметические операции (сложение, вычитание, умножение, деление) и
завершающуюся по желанию пользователя.
**Алгоритм:**
  1. Запустить бесконечный цикл. Выход из него осуществлять с помощью оператора break, ес...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Написать программу, умеющую выполнять над двумя вещественными числами<br>
арифметические операции (сложение, вычитание, умножение, деление) и<br>
завершающуюся по желанию пользователя.<br>
**Алгоритм:**<br>
  1. Запустить бесконечный цикл. Выход из него осуществлять с помощью оператора break, если пользователь вводит определенный символ вместо знака арифметической операции.<br>
  2. Если пользователь ввел знак, который не является ни знаком арифметической операции, ни символом-"прерывателем" работы программы, то вывести сообщение о некорректном вводе.<br>
  3. Если был введен один из четырех знаков операции, то запросить ввод двух чисел.<br>
  4. В зависимости от знака операции выполнить соответствующее арифметическое действие.<br>
  5. Если было выбрано деление, то необходимо проверить не является ли нулем второе число. Если это так, то сообщить о невозможности деления.<br>
<pre class="code">
    print("Ноль в качестве знака операции завершит работу программы")
    while True:
    	s = input("Знак (+,-,*,/): ")
    	if s == '0': break
    	if s in ('+','-','*','/'):
    		x = float(input("x="))
    		y = float(input("y="))
    		if s == '+':
    			print("%.2f" % (x+y))
    		elif s == '-':
    			print("%.2f" % (x-y))
    		elif s == '*':
    			print("%.2f" % (x*y))
    		elif s == '/':
    			if y != 0:
    				print("%.2f" % (x/y))
    			else:
    				print("Деление на ноль!")
    	else:
    		print("Неверный знак операции!")
</pre>
Пример выполнения программы:<br>
<pre class="code">
    Ноль в качестве знака операции завершит работу программы
    Знак (+,-,*,/): h
    Неверный знак операции!
    Знак (+,-,*,/): +
    x=78.456
    y=23.567
    102.02
    Знак (+,-,*,/): -
    x=3.44
    y=10.25
    -6.81
    Знак (+,-,*,/): *
    x=0.012
    y=-2.15
    -0.03
    Знак (+,-,*,/): /
    x=5 
    y=0
    Деление на ноль!
    Знак (+,-,*,/): /
    x=-2.3
    y=5
    -0.46
    Знак (+,-,*,/): 0
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>yeBVlQvG3ZulXlOAm7za</guid><pubDate>2015-12-04 04:13:30</pubDate><author>vit01</author><link>https://idec.foxears.su/yeBVlQvG3ZulXlOAm7za#yeBVlQvG3ZulXlOAm7za</link>
		<description>
		Вводится целое число. Вывести число, обратное по порядку составляющих его цифр
введенному. Например, введено 3425, надо вывести 5243.
**Алгоритм:**
  1. Найдем остаток от деления на 10 исходного числа. Получим последнюю его цифру. 
  2. Добавим эту цифру к новому числу.
  3. Разд...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Вводится целое число. Вывести число, обратное по порядку составляющих его цифр<br>
введенному. Например, введено 3425, надо вывести 5243.<br>
**Алгоритм:**<br>
  1. Найдем остаток от деления на 10 исходного числа. Получим последнюю его цифру. <br>
  2. Добавим эту цифру к новому числу.<br>
  3. Разделим нацело на 10 исходное число. Тем самым избавимся от последней цифры в нем.<br>
  4. Снова найдем остаток от деления на 10 того, что осталось от первого числа. Запомним эту цифру.<br>
  5. Умножим на 10 второе число. Тем самым увеличим его разрядность до двух и сдвинем первую цифру в разряд десятков.<br>
  6. Добавим к полученному второму числу запомненную ранее цифру из первого числа.<br>
  7. Будем повторять действия п.3-6 пока исходное число не уменьшится до нуля, т.е. пока не избавимся от всех его разрядов.<br>
<pre class="code">
    n1 = int(input("Введите целое число: "))
    n2 = 0
    while n1 &gt; 0:
    	digit = n1 % 10; # находим остаток - последнюю цифру числа
    	n1 = n1 // 10; # делим нацело - убираем из числа последнюю цифру
    	n2 = n2 * 10 # увеличиваем разрядность второго числа
    	n2 = n2 + digit # добавляем очередную цифру
    print('"Обратное" ему число:',n2)
</pre>
Примеры выполнения кода:  <br>
<pre class="code">
    Введите целое число: 32809
    "Обратное" ему число: 90823

    Введите целое число: 78290
    "Обратное" ему число: 9287
</pre>

]]>
</content:encoded></item>
<item><title>Строки</title><guid>KaItX9tHVTL1Mb7BICRk</guid><pubDate>2015-12-04 04:13:29</pubDate><author>vit01</author><link>https://idec.foxears.su/KaItX9tHVTL1Mb7BICRk#KaItX9tHVTL1Mb7BICRk</link>
		<description>
		В стороке заменить подстроку, находящуюся между первой открывающей квадратной
скобкой и соответствующей ей закрывающей.
Сложность данной задачи заключается в том, что между первой открывающей и
соответствующей ей закрывающей скобками, могут быть другие скобки. Например, в
строке ...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В стороке заменить подстроку, находящуюся между первой открывающей квадратной<br>
скобкой и соответствующей ей закрывающей.<br>
Сложность данной задачи заключается в том, что между первой открывающей и<br>
соответствующей ей закрывающей скобками, могут быть другие скобки. Например, в<br>
строке 'a[bc[de]f]gh[jkl]' первая открывающая находится после символа 'a', а<br>
соответствующая ей закрывающая - после символа 'f'. Т. е. по условию задачи в<br>
данном примере замене подлежит подстрока '[bc[de]f]'.<br>
Чтобы найти соответствующую закрывающую, в программе ниже вводится счетчик<br>
последующих открывающих скобок, и пока он не будет равен нулю, все закрывающие<br>
скобки соответствующими первой открывающей не считаются.<br>
<pre class="code">
    s = input("Введите исходную строку: ")
    p1 = -1 # индекс первой открывающей скобки
    i = 0
    while i &lt; len(s):
    	if s[i] == '[':
    		p1 = i # мы нашли скобку (ее индекс), 
    		break # дальше просматривать строку бессмысленно
    	i += 1
    if p1 == -1: exit() # открывающей скобки нет, выходим из программы
    p2 = -1 # индекс закрывающей скобки, соответствующей первой открывающей
    count = 0 # счетчик остальных открывающих скобок
    i += 1 # будем просматривать строку со следующего символа за тем, на котором остановились ранее
    while i &lt; len(s): 
    	if s[i] == '[': 
    		count += 1
    	elif s[i] == ']': # встретилась закрывающая скобка 
    		if count == 0: # и счетчик равен нулю
    			p2 = i # значит это закрывающая скобка от первой открывающей
    			break # нет смысла просматривать дальше
    		else: # встретилась закрывающая скобка, но счетчик открыващих не равен нулю,
    			count -= 1 # значит была закрыта какая-то другая, но не первая скобка.
    	i += 1
    if p2 == -1: exit() # закрывающей скобки нет, выходим из программы
    s_in = input("Введите подстроку для вставки: ")
    s_out = s[p1+1:p2] # скобки не берем
    print("Вырезанная подстрока:", s_out)
    s = s[:p1] + s_in + s[p2+1:]
    print("Новая строка:", s)
</pre>
Примеры выполнения программы:<br>
<pre class="code">
    Введите исходную строку: [who[is]it] is big master-[kunfu?].
    Введите подстроку для вставки: Bob Green 
    Вырезанная подстрока: who[is]it
    Новая строка: Bob Green is big master-[kunfu?].
========
    Введите исходную строку: hello [world]
    Введите подстроку для вставки: space
    Вырезанная подстрока: world
    Новая строка: hello space
</pre>

]]>
</content:encoded></item>
<item><title>Циклы</title><guid>tyEKxVY2Sux2uKG8iLis</guid><pubDate>2015-12-04 04:13:29</pubDate><author>vit01</author><link>https://idec.foxears.su/tyEKxVY2Sux2uKG8iLis#tyEKxVY2Sux2uKG8iLis</link>
		<description>
		В Python v.3 для строк используется кодировка Unicode. (Следует помнить, что в
Python, в отличие от других языков программирования, вообще нет такого типа
как одиночный символ; любой символ это строка, длина которой равна 1.)
Первые 128 символов по таблице Unicode такие же как и ...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В Python v.3 для строк используется кодировка Unicode. (Следует помнить, что в<br>
Python, в отличие от других языков программирования, вообще нет такого типа<br>
как одиночный символ; любой символ это строка, длина которой равна 1.)<br>
Первые 128 символов по таблице Unicode такие же как и в таблице символов<br>
ASCII. Выведим их (начиная с пробела - 32-й символ). Чтобы привести вывод к<br>
табличной форме будем переходить на новую строку после каждого десятого<br>
символа (инструкция if в коде ниже).<br>
Функция chr() возвращает символ из таблицы Unicode, соответствующий<br>
переданному коду-числу.<br>
<pre class="code">
    for i in range(32,128):
    	print(chr(i), end=' ')
    	if (i-2) % 10 == 0:
    		print()
    print()
</pre>
Результат выполнения кода:<br>
<pre class="code">
      ! " # $ % &amp; ' ( ) * 
    + , - . / 0 1 2 3 4 
    5 6 7 8 9 : ; &lt; = &gt; 
    ? @ A B C D E F G H 
    I J K L M N O P Q R 
    S T U V W X Y Z [ \ 
    ] ^ _ ` a b c d e f 
    g h i j k l m n o p 
    q r s t u v w x y z 
    { | } ~  
</pre>
Но допустим, нам захотелось или потребовалось узнать коды символов русских<br>
букв (кирилицы). Таблица Unicode очень большая и включает почти все алфавиты<br>
Земли. Однако предположим, что кирилица должна быть закодирована где-то в<br>
начале таблицы (ведь русский - один из распространенных языков мира).<br>
Переберем коды символов от 256 до 10000), и если какой-либо код из этого<br>
диапазона соответствует русской букве (прописной или строчной), то выведем на<br>
экран сам код и букву, которой он соответствует.  <br>
<pre class="code">
    for i in range(256,10000):
    	if 'а'&lt;=chr(i)&lt;='я' or 'А'&lt;=chr(i)&lt;='Я':
    		print(i,'-', chr(i))
</pre>
Результат выполнения кода:<br>
<pre class="code">
    1040 - А
    1041 - Б
    1042 - В
    1043 - Г
    1044 - Д
    1045 - Е
    1046 - Ж
    1047 - З
    1048 - И
    1049 - Й
    1050 - К
    1051 - Л
    1052 - М
    1053 - Н
    1054 - О
    1055 - П
    1056 - Р
    1057 - С
    1058 - Т
    1059 - У
    1060 - Ф
    1061 - Х
    1062 - Ц
    1063 - Ч
    1064 - Ш
    1065 - Щ
    1066 - Ъ
    1067 - Ы
    1068 - Ь
    1069 - Э
    1070 - Ю
    1071 - Я
    1072 - а
    1073 - б
    1074 - в
    1075 - г
    1076 - д
    1077 - е
    1078 - ж
    1079 - з
    1080 - и
    1081 - й
    1082 - к
    1083 - л
    1084 - м
    1085 - н
    1086 - о
    1087 - п
    1088 - р
    1089 - с
    1090 - т
    1091 - у
    1092 - ф
    1093 - х
    1094 - ц
    1095 - ч
    1096 - ш
    1097 - щ
    1098 - ъ
    1099 - ы
    1100 - ь
    1101 - э
    1102 - ю
    1103 - я
</pre>
Теперь мы знаем коды русских букв по таблице Unicode. Но вывод получился<br>
какой-то некомпактный. К тому же мы видим, что буквы алфавита идут одна за<br>
другой. Поэтому достаточно сначала узнать только код первой большой буквы<br>
алфавита (прописные символы идут всегда впереди строчных) и код последней<br>
маленькой буквы алфавита. Кроме того, если мы нашли коды символов, то незачем<br>
далее продолжать цикл. Поэтому перепишем программу следующим образом:  <br>
<pre class="code">
    first = 0
    last = 0
    for i in range(255,10000):
    	if chr(i) == 'А':
    		first = i
    	elif chr(i) == 'я':
    		last = i
    		break # выход из цикла
    j = 0		
    for i in range(first,last+1):
    	print(i,'-', chr(i), end=' ')
    	j += 1
    	if j%10 == 0: print()
    print()
</pre>
Результат выполнения кода:<br>
<pre class="code">
    1040 - А 1041 - Б 1042 - В 1043 - Г 1044 - Д 1045 - Е 1046 - Ж 1047 - З 1048 - И 1049 - Й 
    1050 - К 1051 - Л 1052 - М 1053 - Н 1054 - О 1055 - П 1056 - Р 1057 - С 1058 - Т 1059 - У 
    1060 - Ф 1061 - Х 1062 - Ц 1063 - Ч 1064 - Ш 1065 - Щ 1066 - Ъ 1067 - Ы 1068 - Ь 1069 - Э 
    1070 - Ю 1071 - Я 1072 - а 1073 - б 1074 - в 1075 - г 1076 - д 1077 - е 1078 - ж 1079 - з 
    1080 - и 1081 - й 1082 - к 1083 - л 1084 - м 1085 - н 1086 - о 1087 - п 1088 - р 1089 - с 
    1090 - т 1091 - у 1092 - ф 1093 - х 1094 - ц 1095 - ч 1096 - ш 1097 - щ 1098 - ъ 1099 - ы 
    1100 - ь 1101 - э 1102 - ю 1103 - я 
</pre>

]]>
</content:encoded></item>
<item><title>Списки, кортежи</title><guid>jAKGoOziLhOsytzoT6OR</guid><pubDate>2015-12-04 04:13:29</pubDate><author>vit01</author><link>https://idec.foxears.su/jAKGoOziLhOsytzoT6OR#jAKGoOziLhOsytzoT6OR</link>
		<description>
		Допустим, у нас есть список чисел, из которого надо удалить элементы,
удовлетворяющие определенному условию. Будем удалять из списка, состоящего из
20 чисел в диапазоне от 0 до 100, все элементы, которые больше 35 и меньше 65.
При этом удаляемые числа сохраним в другом списке.
В ...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Допустим, у нас есть список чисел, из которого надо удалить элементы,<br>
удовлетворяющие определенному условию. Будем удалять из списка, состоящего из<br>
20 чисел в диапазоне от 0 до 100, все элементы, которые больше 35 и меньше 65.<br>
При этом удаляемые числа сохраним в другом списке.<br>
В Python с помощью инструкции del можно удалить элемент списка, указав сам<br>
список и индекс удаляемого элемента.<br>
Алгоритм решения задачи выглядит вроде бы простым: достаточно перебрать<br>
элементы списка и удалить те, которые удовлетворяют условию. Но все не так<br>
просто. При удалении элемента на его место становится следующий, но поскольку<br>
мы переходим к следующему элементу, то пропускаем проверку того, что стал на<br>
место удаленного. Цикл for использовать нельзя, т.к. меняется количество<br>
элементов списка.<br>
Можно использовать цикл while, измеряя на каждой его итерации длину списка,<br>
индекс же увеличивать только в том случае, если удаления элемента не<br>
произошло.<br>
<pre class="code">
    import random
    a = []
    for i in range(20):
    	n = round(random.random() * 100) # от 0 до 100 включительно
    	a.append(n)
    print("A =",a)
    b = []
    i = 0
    while i &lt; len(a):
    	if 35 &lt; a[i] &lt; 65:
    		b.append(a[i])
    		del a[i]
    	else:
    		i += 1
    print("A =",a)
    print("B =",b)
</pre>
Примеры выполнения программы:<br>
<pre class="code">
    A = [80, 35, 30, 98, 35, 4, 94, 51, 22, 22, 52, 97, 67, 90, 9, 1, 87, 78, 100, 29]
    A = [80, 35, 30, 98, 35, 4, 94, 22, 22, 97, 67, 90, 9, 1, 87, 78, 100, 29]
    B = [51, 52]

    A = [68, 88, 64, 39, 13, 99, 6, 35, 50, 76, 47, 82, 76, 87, 44, 86, 75, 46, 8, 32]
    A = [68, 88, 13, 99, 6, 35, 76, 82, 76, 87, 86, 75, 8, 32]
    B = [64, 39, 50, 47, 44, 46]
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>TaRFaSvo4uvLAFXNGIY3</guid><pubDate>2015-12-04 04:13:28</pubDate><author>vit01</author><link>https://idec.foxears.su/TaRFaSvo4uvLAFXNGIY3#TaRFaSvo4uvLAFXNGIY3</link>
		<description>
		Сгенерировать случайные целое и вещественное числа, символ в пределах
диапазонов, которые вводит пользователь.
В языке программирования Python в модуле random есть одноименная функция,
которая генерирует вещественное число от 0 до 1. Если умножить полученное
таким образом случайн...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Сгенерировать случайные целое и вещественное числа, символ в пределах<br>
диапазонов, которые вводит пользователь.<br>
В языке программирования Python в модуле random есть одноименная функция,<br>
которая генерирует вещественное число от 0 до 1. Если умножить полученное<br>
таким образом случайное число на длину диапазона, то получим число от 0 до<br>
конца длины диапазона. Если далее прибавить минимальную границу диапазона, то<br>
произойдет смещение и будет получено случайное число от минимальной границы до<br>
максимальной.<br>
Отличие получения целого числа от вещественного заключается в том, что в<br>
первом случае, если максимальная граница входит в диапазон, то надо прибавить<br>
1 к длине диапазона и после умножения преобразовать в целое, отбросив дробную<br>
часть.<br>
Случайный символ получают по той же формуле, что и целое. Символы<br>
"преобразуют" к целым, получают случайное число и далее "преобразуют" его в<br>
символ.<br>
<pre class="code">
    from random import random
    m1 = int(input())
    m2 = int(input())
    n = int(random() * (m2-m1+1)) + m1
    print(n)
    m1 = float(input())
    m2 = float(input())
    n = random() * (m2-m1) + m1
    print(round(n,3))
    m1 = ord(input())
    m2 = ord(input())
    n = int(random() * (m2-m1+1)) + m1
    print(chr(n))
</pre>
Пример выполнения кода:  <br>
<pre class="code">
    -10
    10
    8
    0
    1.1
    0.892
    h
    t
    s
</pre>

]]>
</content:encoded></item>
<item><title>Условный оператор</title><guid>hYyN5lWVhv6zOFr3XzZd</guid><pubDate>2015-12-04 04:13:28</pubDate><author>vit01</author><link>https://idec.foxears.su/hYyN5lWVhv6zOFr3XzZd#hYyN5lWVhv6zOFr3XzZd</link>
		<description>
		Квадратное уравнение имеет вид ax2 + bx + c = 0. При его решении сначала
вычисляют дискриминант по формуле D = b2 - 4ac. Если D &gt; 0, то квадратное
уравнение имеет два корня; если D = 0, то 1 корень; и если D &lt; 0, то делают
вывод, что корней нет.
Таким образом, программа для нахож...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
Квадратное уравнение имеет вид ax2 + bx + c = 0. При его решении сначала<br>
вычисляют дискриминант по формуле D = b2 - 4ac. Если D &gt; 0, то квадратное<br>
уравнение имеет два корня; если D = 0, то 1 корень; и если D &lt; 0, то делают<br>
вывод, что корней нет.<br>
Таким образом, программа для нахождения корней квадратного уравнения может<br>
иметь три ветви условного оператора.<br>
Функция float() преобразует переданный ей аргумент в вещественное число.<br>
<pre class="code">
    print("Введите коэффициенты для квадратного уравнения (ax^2 + bx + c = 0):")
    a = float(input("a = "))
    b = float(input("b = "))
    c = float(input("c = "))
    discr = b**2 - 4 * a * c;
    print("Дискриминант D = %.2f" % discr)
    if discr &gt; 0:
    	import math
    	x1 = (-b + math.sqrt(discr)) / (2 * a)
    	x2 = (-b - math.sqrt(discr)) / (2 * a)
    	print("x1 = %.2f \nx2 = %.2f" % (x1, x2))
    elif discr == 0:
    	x = -b / (2 * a)
    	print("x = %.2f" % x)
    else:
    	print("Корней нет")
</pre>
<pre class="code">
    Введите коэффициенты для квадратного уравнения (ax^2 + bx + c = 0):
    a = 2
    b = 4
    c = 2
    Дискриминант D = 0.00
    x = -1.00

    Введите коэффициенты для квадратного уравнения (ax^2 + bx + c = 0):
    a = 3.2
    b = -7.8
    c = 1
    Дискриминант D = 48.04
    x1 = 2.30 
    x2 = 0.14

    Введите коэффициенты для квадратного уравнения (ax^2 + bx + c = 0):
    a = 8
    b = 4
    c = 2
    Дискриминант D = -48.00
    Корней нет
</pre>

]]>
</content:encoded></item>
<item><title>Линейные алгоритмы</title><guid>dqaajJ1Azn3c3DX8UB3O</guid><pubDate>2015-12-04 04:13:28</pubDate><author>vit01</author><link>https://idec.foxears.su/dqaajJ1Azn3c3DX8UB3O#dqaajJ1Azn3c3DX8UB3O</link>
		<description>
		В Python есть простые логические операторы (=, !=, &lt;, &gt;, &lt;=, &gt;=) и сложные
(and, or, not). Все логические операторы, за исключением not, являются
бинарными. Это значит, что слева и справа от них должны стоять выражения. С
помощью логических операторов эти выражения так или иначе ...
		</description>
		<content:encoded>
<![CDATA[
vit01 -> All<br><br>
В Python есть простые логические операторы (=, !=, &lt;, &gt;, &lt;=, &gt;=) и сложные<br>
(and, or, not). Все логические операторы, за исключением not, являются<br>
бинарными. Это значит, что слева и справа от них должны стоять выражения. С<br>
помощью логических операторов эти выражения так или иначе сравниваются между<br>
собой.<br>
Результат логических операций имеет булевый тип данных (встроенный class<br>
'bool' в Python). Нужно быть осторожным, сравнивая между собой разные типы<br>
данных, т. к. это не всегда возможно. Например, нельзя сравнивать числа и<br>
строки, но вещественные и целые числа - можно.<br>
В сложных логических выражениях нужно учитывать последовательность операций.<br>
Если нет уверенности, какая операция имеет приоритет, то лучше использовать<br>
скобки.<br>
<pre class="code">
    s1 = input("Введите первую строку: ")
    s2 = input("Введите вторую строку: ")
    f1 = input("Введите первое число: ")
    f2 = input("Введите второе число: ")
    f1 = float(f1)
    f2 = float(f2)
    bool_s = s1 &gt; s2
    bool_f = f1 != f2
    bool_or = f1 + f2 &gt; 0 or (s1 != '' and s2 != '')
    print('-'*10)
    print("Первая строка больше второй:", bool_s)
    print("Числа не равны друг другу:", bool_f)
    print("Первая строка больше второй и числа не равны друг другу:", bool_s and bool_f)
    print("Сумма чисел больше нуля ИЛИ ни одна из строк не пуста:", bool_or)
</pre>
Примерный вывод:  <br>
<pre class="code">
    Введите первую строку: ty
    Введите вторую строку: kl;
    Введите первое число: 6.8
    Введите второе число: 8
    ----------
    Первая строка больше второй: True
    Числа не равны друг другу: True
    Первая строка больше второй и числа не равны друг другу: True
    Сумма чисел больше нуля ИЛИ ни одна из строк не пуста: True
</pre>
<pre class="code">
    Введите первую строку: 
    Введите вторую строку: 
    Введите первое число: 7
    Введите второе число: -7
    ----------
    Первая строка больше второй: False
    Числа не равны друг другу: True
    Первая строка больше второй и числа не равны друг другу: False
    Сумма чисел больше нуля ИЛИ ни одна из строк не пуста: False
</pre>

]]>
</content:encoded></item>
</channel></rss>
