Паскаль. Основы программирования
Арифметические операции с целыми числами и переменными целого типа в языке Паскаль
| Операция | Обозначение | ||
| Сложение | + | ||
| Вычитание | - | ||
| Умножение | * | ||
| Деление | a_div_b |
Знак "_" означает пробел. Пробелы между именами переменных и названием операции (div) - обязательны. (Происходит от английского division - деление).
Остаток от деления a на b. a_mod_b
Кроме арифметических операций с целыми числами выполняются:
Арифметические операции с вещественными переменными
| Операция | Запись на Паскале | ||
| Сложение | a + b | ||
| Вычитание | a - b | ||
| Умножение | a*b | ||
| Деление | a/b |
Как видите, единственным отличием от операций с целыми числами - это операция деления, которая обозначается наклонной чертой.
Кроме арифметических операций, в Паскале существуют так называемые стандартные
или встроенные функции, которые выполняются сразу после указания их имени, заведомо объявленных в Паскале, после которого в скобках записывается аргумент функции.
| Функция | Математическое обозначение | Ее объявление на Паскале | |||
| Квадратичная |  | sqr(x) | |||
| Абсолютная величина | |x| | abs(x) | |||
| Квадратный корень |  | sqrt(x) | |||
| Синус | sinx | sin(x) | |||
| Косинус | cosx | cos(x) | |||
| Арктангенс | arctgx | arctan(x) | |||
| Натуральный логарифм | lnx | ln(x) | |||
| Показательная функция (экспонента) |  | exp(x) |
Некоторые из перечисленных встроенных функций могут быть использованы с целыми числами или переменными целого типа (аргумент имеет тип integer).
К таким функциям относятся:
Квадратичная: x2 - sqr(x). Абсолютная величина: |x| - abs(x).
На Паскале нет функций вычисления arcsinx, arccosx, arcctgx. Как с помощью уже известных встроенных функций вычислить значения функций arcsinx, arccosx, arcctgx?
Для этого надо совершить небольшую экскурсию в математику и выразить значение функций arcsinx, arccosx, arcctgx через функцию arctgx.
Arcsinx
Пусть
где |x| 
, тогда 
отсюда 
получаем, 
окончательно имеем: 
| Функция | Математическая обозначение | Ее объявление на Паскале | |||
| Арксинус | arcsinx |  |
Аналогичными рассуждениями можно получить выражения для arccosx и arcctgx.
| Функция | Математическое обозначение | Ее объявление на Паскале | |||
| Арккосинус | arccosx |  | |||
| Арккотангенс | arcctgx |  |
Пример 3. Составить программу решения квадратного уравнения
ax2 + bx + c = 0.
Наметим план составления программы или, иначе говоря, алгоритм.
Под алгоритмом мы будем понимать последовательность указаний для составления программы.
Алгоритм
1. Содержание.
Описание переменных и их типов.
2. Ввод
значений коэффициентов.
3. Вычисление
значения дискриминанта (d).
Если
d < 0, тогда уравнение не имеет корней,
иначе,
если d = 0,
тогда уравнение имеет один корень,
вычислить значение этого корня и выдать его на экран,
иначе, уравнение имеет два корня,
вычислить их и выдать на экран.
4. Конец.
Составим программу, пользуясь алгоритмом.
Program
Problem3; { Программа решения квадратного уравнения }
uses WinCrt;
var
a, b, c, d, x1, x2 : real;
begin
write('Введите коэффициенты уравнения ');
readln(a, b, c);
d := b*b - 4*a*c;
if d < 0 then writeln('Уравнение не имеет корней')
else
if d=0
then
writeln('Уравнение имеет один корень ',-b/(2*a))
else
begin
x1 := (-b - sqrt(d))/(2*a);
x2 := (-b + sqrt(d))/(2*a);
write('Уравнение имеет два различных корня ');
writeln('x1 = ', x1, ' x2 = ', x2)
end
end.
Разберем структуру программы и посмотрим как она будет работать.
ИМЯ ПРОГРАММЫ И КОММЕНТАРИЙ
Имя программы "Problem3;", после этого в комментарии записано содержание программы: "{Программа решения квадратного уравнения};".
РАЗДЕЛ ОПИСАНИЙ
В разделе описаний указаны имена переменных и их типы. Понятно, что переменные a, b, c нужны для значений коэффициентов уравнения, переменная d для значений дискриминанта, а x1 и x2 для корней уравнения. Понятно, что все они принимают вещественные значения, ограничиться целыми невозможно, и имеют тип: real.
РАЗДЕЛ ОПЕРАТОРОВ
Раздел операторов начинается вводом информации. С помощью оператора:
write('Введите коэффициенты уравнения '); readln(a, b, c);
на экран выводится информация, записанная в этом операторе write:
Введите коэффициенты уравнения
В ответ на этот запрос, пользователю надо ввести коэффициенты уравнения, разделяя их пробелами (проще говоря, ввести через пробелы).
Обратите внимание на такую мелочь, в операторе writeln, перед вторым, "заканчивающим" запись апострофом, оставлен пробел. Для чего? Только из эстетических соображений. Следующий оператор readln(a, b, c); будет вводить информацию, которую вы наберете с клавиатуры. Если этого пробела не будет, то вводимое число будет писаться вплотную к слову "уравнения", что, конечно, некрасиво.
Далее вычисляется значение дискриминанта и присваивается переменной d.
Первым условным оператором if проверяется условие d < 0, если оно выполняется, тогда на экран выдается сообщение, записанное после then в операторе writeln: "Уравнение не имеет корней", иначе после else, новое условие if
d = 0, тогда выполняются операторы после then, т.е. выдается сообщение, что уравнение имеет один корень, вычисляется его значение и выдается на экран, так как всё это записано в скобках оператора writeln, иначе, остается одно, - когда дискриминант больше нуля, тогда надо выполнить несколько операторов, которые записаны после else. Но поскольку их несколько, то необходимо открыть операторные скобки begin, в которых и записать вычисление значений корней и вывод их на экран. После чего необходимо закрыть операторные скобки служебным словом end.
После этого программа заканчивается служебным словом end с обязательной точкой в конце.
Каждая операторная скобка, начинаемая словом begin должна обязательно "закрываться" словом end. Если это слово оказывается перед оператором else или является предпоследним, то точка с запятой после end не ставится. Во всех других случаях end заканчивается точкой с запятой, а заканчивающий программу - точкой.
Бесконечные произведения
Напомним основные понятия, относящиеся к бесконечным произведениям.Определение. Если
есть некоторая заданная последовательность чисел, то составленный из них символ
называют бесконечным произведением.
Станем последовательно перемножать числа (1), составляя частичные произведения
Эту последовательность частичных произведений
мы всегда будем сопоставлять символу (2).Предел P частичного произведения
при 
(конечный или бесконечный)
называют значением
произведения (2) и пишут:
Если бесконечное произведение имеет конечное значение P и притом отличное от 0, то само произведение называют сходящимся, в противном случае - расходящимся.
Достаточно одному из сомножителей произведения быть нулем, чтобы и значение всего произведения также было равно нулю. В дальнейшем этот случай будет исключен из рассмотрения, так что для нас всегда
4.1. Примеры некоторых замечательных бесконечных произведений
Пример 1.
Так как частичное произведение
то бесконечное произведение сходится, и его значением будет
Проверим этот факт, для чего составим программу вычисления произведения:
Составим процедуру, которая с заданной точностью вычисляет это произведение и включим ее в программу. Зачем нам нужна процедура, если можно сразу составить программу?
Ответ понятен. Нам придется составлять еще много программ, в которых не только вычисляются произведения, но и выполняется ряд других задач. Изменив только одну процедуру, мы сможем использовать новое произведение для поставленных в программе задач.
Процедура
Procedure
Multiplication(eps : real; var Mult : real);
var
n : longint;
Mult1 : real;
begin
n := 2; Mult1 := 1;
repeat
Mult1 := Mult1*(1 - 1/sqr(n));
n := n + 1;
Mult := Mult1*(1 - 1/sqr(n))
until abs(Mult - Mult1) < eps
end;
Программа
Program Multiply1;
uses WinCrt;
var
Mult, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure Multiplication(eps : real; var Mult : real);
var
n : longint;
Mult1 : real;
begin
n := 2; Mult1 := 1;
repeat
Mult1 := Mult1*(1 - 1/sqr(n));
n := n + 1;
Mult := Mult1*(1 - 1/sqr(n))
until abs(Mult - Mult1) < eps
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите точность вычисления '); readln(eps);
Multiplication(eps, Mult);
writeln('Значение произведения равно ', Mult:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Пример 2.
4.2. Формула Валлиса (J. Wallis)
Формула Валлиса имеет для нас не только исторический интерес, но она поможет применять методику, которая будет использоваться при вычислении числа
с помощью этой формулы. Итак, формула Валлиса имеет вид:
или
Этот предел равносилен разложению числа
в бесконечное произведение
Она же приводит к формулам
или 
.Но надо заметить, что для вычисления числа
существуют методы, гораздо быстрее ведущие к цели.Составим процедуру, а затем и программу вычисления числа
по последней формуле.Процедура
Procedure
Wallis(eps : real; var Mult : real);
var
n : longint;
Mult1 : real;
begin
n := 1; Mult := 1;
repeat
Mult := Mult*(4*sqr(n)/(4*sqr(n)-1));
n := n + 1;
Mult1 := 4*sqr(n)/(4*sqr(n)-1)
until Mult1 < eps
end;
Следует заметить, что оценка погрешности в этой процедуре отличается от оценки погрешности в процедуре примера 1. Такая оценка вытекает из математических соображений, n-й множитель в произведении Валлиса
"быстрее" стремится к нулю, чем разность между n - 1-м произведением и n-м. Программа
Program Problem2;
uses WinCrt;
var
Mult, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure Wallis(eps : real; var
Mult : real);
var
n : longint;
Mult1 : real;
begin
n := 1; Mult := 1;
repeat
Mult := Mult*(4*sqr(n)/(4*sqr(n)-1));
n := n + 1;
Mult1 := 4*sqr(n)/(4*sqr(n)-1)
until Mult1 < eps
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите точность вычисления '); readln(eps);
Wallis(eps, Mult);
writeln('Значение числа Пи равно ', 2*Mult:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
4.3. Полный эллиптический интеграл 1-го рода
Для полного эллиптического интеграла 1-го рода установлена формула
где переменная
определяется рекуррентным соотношением:
, (0 < k < 1).Эта формула дает разложение K(k) в бесконечное произведение
Процедура
Procedure
Elliptic(k, eps : real; var Kk : real);
var
Kk1 : real;
begin
Kk1 := k;
repeat
k := (1 - sqrt(1 - sqr(k)))/(1 + sqrt(1 - sqr(k)));
Kk1 := Kk1*(1 + k);
k := (1 - sqrt(1 - sqr(k)))/(1 + sqrt(1 - sqr(k)));
Kk := Kk1*(1 + k);
until abs(Kk1 - Kk) < eps;
Kk := Kk*Pi/2
end;
Программа
Program Problem3;
uses WinCrt;
var
Kk, k, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure Elliptic(k, eps : real; var
Kk : real);
var
Kk1 : real;
begin
Kk1 := k;
repeat
k := (1 - sqrt(1 - sqr(k)))/(1 + sqrt(1 - sqr(k)));
Kk1 := Kk1*(1 + k);
k := (1 - sqrt(1 - sqr(k)))/(1 + sqrt(1 - sqr(k)));
Kk := Kk1*(1 + k);
until abs(Kk1 - Kk) < eps;
Kk := Kk*Pi/2
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение k (0 < k < 1) '); readln(k);
write('Введите точность вычисления '); readln(eps);
Elliptic(k, eps, Kk);
writeln('Значение интеграла равно ', Kk:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Задание 5
Известен предел:
Теперь мы можем записать это так:
В частности, при
придем к разложению:
Если вспомнить, что
то это разложение можно переписать в виде
Эта формула впервые была предложена Ф. Виетом (F. Viet) и является вместе с формулой Валлиса примерами первых бесконечных произведений.
Используя формулу (1) составьте программу вычисления числа
.Библиотека часто встречающихся процедур и функций
1. Процедуры, вычисляющая сумму цифр числа:Procedure sum_number(n : integer; var
s : integer);
begin
s := 0;
repeat
s := s + n mod 10;
n := n div 10
until n = 0
end;
Procedure sum_number(p : longint; var s : longint);
begin
s := 0;
while p <> 0 do
begin
s := s + p mod 10;
p := p div 10
end
end;
2. Процедура, вычисляющая количество цифр в числе:
Procedure quantity_number(n : integer; var
k : integer);
begin
k := 0;
repeat
k := k + 1;
n := n div 10
until n = 0
end;
3. Процедура, записывающая заданное число в обратном порядке, например, 3467 записывает так: 7643.
Procedure backwards(n : integer; var
a : integer);
begin
a := 0;
repeat
a := a*10 + n mod 10;
n := n div 10
until n = 0
end;
4. Процедура перестановки первой и последней цифр числа.
Procedure first_last_number(n : integer; var n1 : integer);
var
a, i, p : integer;
begin
a := n; i := 1;
p := n mod 10; {последняя цифра введенного числа}
while n >= 10 do
begin
i := i*10;
n := n div 10
end;
n1 := a - n*i - p + n + p*i
end;
5. Процедура, определяющая, является число числом - палиндромом.
Procedure palindrom(a : integer);
var
b, c, p : integer;
begin
b := a; c := 0;
repeat
p := b mod 10;
c := c*10 + p;
b := b div 10
until b = 0;
if c = a then writeln('Число ', a, ' является палиндромом')
else writeln('Число ', a, ' не явл.
29. Процедура размещений из n элементов по k элементов.
Procedure placement(n, k : integer; var
r : longint);
var
i : integer;
begin
r := 1;
for i := 1 to k do r := r*(n - i + 1)
end;
30. Процедура числа сочетаний из n элементов по k элементов.
Procedure Combination(n, k : integer; var c : longint);
var
i : longint;
begin
c := 1;
for i := 1 to k do
c := c*(n - k + i) div i
end;
41. Функция вычисляющая количество знаков после запятой.
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
42. Процедуры вычисления квадратного корня с заданной степенью точности.
1-й способ
Procedure square_root(u, eps : real; var
x : real);
begin
x := (u + 1)/2;
repeat
x := (1/2)*(x + u/x)
until abs(x*x - u) <= eps;
end;
2-й способ
Procedure square_root(u, eps : real; var
x : real);
var
x1, x2 : real;
begin
x1 := 1;
repeat
x1 := (1/2)*(x1 + u/x1);
x2 := (1/2)*(x1 + u/x1)
until abs(x2 - x1) <= eps;
x := x2
end;
Упражнения
167. Дано действительное число
Последовательность a1, a2, ... образована по следующему закону: 
Требуется получить все a1, a2, ..., меньшие или равные b.
168. Дано действительное
Последовательность a1, a2,... образована по следующему закону: 
Найти первый отрицательный член последовательности a1, a2, ... .
169. Составить программу вычисления и вывода на экран n членов последовательности, заданной формулой n-го члена. (Предварительно составить рекуррентную формулу).
а)
б) 
в) 
) 
д) 
е)
ж) 
з) 
где x - заданное действительное число, 
и)
170. Составить программу, подсчитывающую сумму n
первых членов последовательности, заданной формулой n-го члена. (Предварительно составить рекуррентную формулу).
а)
б) 
в) 
г) 
д)
е) 
ж) 
з)
и) 
к) 
x - заданное действительное число.171. Дано действительное
Последовательность r , a2, ... образована по следующему закону: 
, 
Найти первый неотрицательный член последовательности.
172. Дано натуральное n. Вычислить:
173. Для чисел Фибоначчи u0, u1, ... справедлива формула Бине:
Так как
то для больших k выполнено приближенное равенство палиндромом')
end;
6. Процедура нахождения цифрового корня числа.
Цифровым корнем числа называется сумма цифр заданного числа, затем сумма цифр полученной суммы и т.д. до тех пор, пока эта сумма не станет однозначным числом.
Procedure radical_number(n : integer; var
k : integer);
var
p, s : integer;
begin
repeat
s := 0;
while n <> 0 do
begin
p := n mod 10; s := s+p; n := n div
10
end;
n := s
until n < 10;
k := n
end;
7. Процедуры нахождения наибольшего общего делителя:
1-й способ (по простому алгоритму)
Procedure nod1(a, b : integer; var
n : integer);
begin
if a > b then n := b else n := a;
n := n + 1;
repeat
n := n - 1
until (a mod n = 0) and (b mod
n = 0)
end;
2-й способ (по 1-му алгоритму Евклида)
Procedure nod2(a, b : integer; var
n : integer);
begin
while a <> b do
begin
if a > b then a := a - b else
b := b - a
end;
n := a
end;
3-й способ (по 2-му алгоритму Евклида)
Procedure nod(a, b : integer; var
n : integer);
var
r : integer;
begin
repeat
r := a mod b;
a := b; b := r
until b = 0;
n := a
end;
8. Рекурсивная процедура нахождения НОД.
Procedure nod(a, b : integer; var
n : integer);
begin
if b = 0 then n := a else nod(b, a mod
b, n)
end;
9. Процедуры нахождения наименьшего общего кратного двух целых чисел (НОК).
1-й способ
Procedure nok(a, b : integer; var
k : integer);
var
m, n : integer;
begin
k := 0;
repeat
if a > b then
begin
m := a; n := b
end
else
begin
m := b; n := a
end;
k := p + m
until k mod n = 0
end;
2-й способ (с использованием НОД).
Procedure nok1(a, b : integer; var
k : integer);
var
n : integer;
begin
n := a*b;
repeat
c := a mod b;
a := b; b := c
until b = 0;
k := n div a
end;
10. Процедура определения всех делителей заданного числа.
1-й способ
Procedure everyone_divisor(n : integer);
var
i : integer;
begin
writeln('Делители числа ', n);
for i := 1 to n div 2 do
if n mod i = 0 then write(i, ' ');
writeln(n)
end;
2-й способ
Procedure everyone_divisor(n : integer);
var
i : integer;
begin
writeln('Делители числа ', n);
for i := 1 to trunc(sqrt(n)) do
if n mod i = 0 then write(i, ' ', n div i, ' ')
end;
11. Процедура, определяющая число делителей натурального числа:
Procedure number_division(n : integer; var k : integer);
var
d : integer;
begin
k := 0;
for d := 1 to n div 2 do
if n mod d = 0 then k := k + 1;
k := k + 1
end;
12. Процедура разложения числа на простые множители:
Procedure probleme_number(n : integer);
var
i : integer;
begin
while n mod 2 = 0 do
begin
write(2, ' ');
n := n div 2
end;
i := 3;
while i <= n do
if n mod i = 0 then
begin
write(i, ' ');
n := n div i
end
else
i := i + 2
end;
13. Процедура, определяющая, является ли число простым.
первый
способ
Procedure probleme_number(p : integer);
var
i, k : integer;
begin
if p = 2 then write(p, ' ')
else
if p mod 2 <> 0
then
begin
i := 3; k := 0;
while i <= p div
2 do
begin
if p mod i = 0 then k := k + 1;
i := i + 2
end;
if k = 0 then
write(p, ' ')
end
end;
второй
способ
Procedure probleme_number(p : integer);
var
i, k : integer;
begin
if p = 2 then write(p, ' ')
else if p mod 2 <> 0
then
begin
i := 3; k := 0;
while i <= trunc(sqrt(p)) do
begin
if p mod
i = 0 then k := k + 1;
i := i + 2
end;
if k = 0 then
write(p, ' ')
end
end;
14. Процедура, определяющая, является ли число автоморфным? Автоморфным называется такое число, которое равно последним цифрам своего квадрата.
Например: 52 = 25; 252 = 625.
Procedura awtomorf(x : integer);
var
d, k : integer;
begin
d := 10;
while d <= x do d := d*10;
k := x mod 10;
if (k = 1) or (k = 5) or (k = 6)
then
if x*x mod d = x then
writeln(x, ' ', x*x)
end;
15. Процедура, устанавливающая, равно ли заданное число сумме квадратов целых чисел и каких именно, если таковые существуют:
Procedure square(n : integer);
label 1;
var
a, b, k : integer;
begin
a := 1; k := 1;
while a*a + 1 <= n do
begin
k := k + 1; a := a + 1
end;
for a := 1 to k do
for b := 1 to a do if a*a + b*b = n then
begin
writeln(n, '=', a, '*', a, '+', b, '*', b); goto 1
end;
1: end;
16. Процедура определения Пифагоровых чисел из промежутка [n; m].
Procedure pifagor(n, m : integer);
var
a, b, c : integer;
begin
writeln('Пифагоровы числа из промежутка [',n, ';', m,']');
for a := n to m do
for b := n to a do
for c := n to m do
if a*a + b*b = c*c then writeln(a, ' ', b, ' ', c)
end;
17. Процедура представления числа n в виде суммы кубов двух чисел.
Procedure sum_number_cube(n : integer; var p : integer);
var
i, j, k : integer;
begin
k := 0; i := 1;
while i*i*i + 1 <= n do
begin
k := k + 1; i := i + 1
end;
p := 0;
for i := k downto 1 do
for j := 1 to i do
if i*i*i + j*j*j = n
then
begin
p := p + 1;
writeln(i, '*', i, '*', i, '+', j, '*', j, '*', j, '=', n)
end;
if p = 0
then
begin
write('Число ', n, ' нельзя представить в виде ');
writeln('суммы кубов двух чисел')
end
else
writeln('Число способов равно ', p)
end;
18. Процедура представления целого числа n в виде суммы квадратов трех чисел.
Procedure sum_square_number(n : integer; var p : integer);
var
k, x, y, z, p : integer;
begin
k := 0; x := 1;
while x*x + 2 <= n do
begin
k := k + 1; x := x + 1
end;
p := 0;
for x := 1 to k do
for y := 1 to x do
for z := 1 to y do
if x*x + y*y + z*z = n
then
begin
p := p + 1;
writeln(x, '*', x, '+', y, '*', y, '+', z, '*', z, '=', n)
end;
if p = 0
then
begin
write('Число ',n,' нельзя представить в виде ');
writeln('суммы квадратов трех чисел')
end
else writeln('Число способов равно ', p)
end;
19. Процедура определения цифры, стоящей на n-ом месте в записи подряд чисел 1234567891011121314...
Procedure location(n : integer; var
c : integer);
var
p, s, v, m, q : integer;
Procedure number(n : integer; var k : integer);
begin
k := 0;
repeat
k := k + 1;
n := n div 10
until n = 0
end;
begin
p := 1; s := 0;
repeat
number(p, v);
s := s + v; p := p + 1
until s>=n;
m := s - n; p := p - 1; q := 1;
for i := 1 to m do q := q*10;
c := p div q;
c := c mod 10;
writeln('Последняя цифра в записи этих цифр будет ', c);
writeln('Она находится в числе ', p)
end;
20. Процедуры вычисления степени натурального числа с натуральным показателем:
с
циклом repeat ... until
...
Procedure extent(a, n : integer; var s : integer);
var
i : integer;
begin
i := 1; s := 1;
repeat
s := s*a; i := i + 1
until i = n
end;
с
циклом for ... to
... do ...
Procedure extent(a, n : integer; var s : longint);
var
i : integer;
begin
s := 1;
for i := 1 to n do s := s*a
end;
функция вычисления степени числа:
Function extent(a, n : longint) : longint;
var
i : integer;
begin
extent := 1;
for i := 1 to n do extent := extent*a
end;
21. Процедура вычисления факториала числа:
итеративная
Procedure fac(n : integer; var f : longint);
var
i : integer;
begin
if n = 0 then f := 1 else for i := 1 to n do f := f*i
end;
рекурсивная
Procedure fac(n : integer; var f : longint);
begin
if (n = 0) or (n = 1) then f := 1
else
begin
fac(n - 1, f);
f := f*n
end
end;
22. Рекурсивная процедура умножения числа a на каждую цифру числа b, начиная с единиц:
Procedure umnogenie(a, b, s : integer);
begin
if b <> 0
then
begin
s := s + a*(b mod 10);
umnogenie(a, b div 10, s div 10);
write(s mod 10:1)
end
else
if s <> 0 then write(s)
end;
23. Функции вычисления чисел ряда Фибоначчи.
итеративная
Function fib(n : integer) : integer;
var
f, f1, f2, i : integer;
begin
f1 := 1; f := 0;
for i := 1 to n do
begin
f2 := f1; f1 := f;
f := f1 + f2;
end;
fib := f
end;
рекурсивная
Function fib(n : integer) : integer;
begin
if (n = 1) or (n = 2)
then fib := 1
else fib := fib(n - 1) + fib(n - 2)
end;
24. Процедура отделения корней на заданном промежутке [a; b] для заданной функции fx, т.е. определения промежутков, на которых может находиться хотя бы один корень (h - шаг), (x1, x2 - границы полученных промежутков).
Procedure separation_root(a, b, h : real);
var
x1, x2, y1, y2 : real; k : integer;
Function fx(x : real) : real;
begin
fx := ???????????
end;
begin
k := 0; x1 := a; x2 := x1 + h;
y1 := fx(x1);
while x2 <= b do
begin
y2 := fx(x2);
if y1*y2 < 0
then
begin
k := k + 1;
writeln(k, '-й корень на [', x1:6:4, '; ', x2:6:4,']')
end;
x1 := x2; x2 := x1 + h;
y1 := y2
end
end;
25. Процедура уточнения корня некоторой функции func(x) методом деления пополам (a, b - границы промежутка, eps - точность вычисления, x - значение корня, d - погрешность вычисления).
Procedure half(a, b, eps : real; var
x, d : real);
var
c : real;
begin
while abs(b - a) > eps do
begin
c := (a + b)/2;
if func(a)*func(c) < 0 then b := c
else a := c
end;
x := (a + b)/2;
d := abs(b - a)/2
end;
26. Процедура поиском минимума функции на промежутка с помощью ряда Фибоначчи.
{ Процедура определения минимума функции на промежутке }
Procedure minfib(a, b, e : real; var x : real);
label 1;
var
aa, bb, x1, x2, y1, y2 : real;
n : integer;
{----------------------------------------------------------------------------------------}
{ Заданная исследуемая функция }
Function func(x : real) : real;
begin
func := ?????????????????
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления членов ряда Фибоначчи }
Function fib(n : integer) : real;
var
f, f1, f2 : real;
i : integer;
begin
f1 := 1; f := 0;
for i := 1 to n do
begin
f2 := f1; f1 := f;
f := f1 + f2
end;
fib := f
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления знач. аргумента и функции }
{ approach - приближение }
Procedure approach(a, b : real; n : integer; var
x2, y2 : real);
begin
x2 := a + (b - a)*fib(n - 1)/fib(n);
y2 := func(x2)
end;
begin
n := 3;
approach(a, b, n, x2, y2);
while abs(b - a) > e do
begin
x1 := a + b - x2; y1 := func(x1);
if (x2 > x1) and (y2 > y1)
then
begin
n := n + 1;
approach(a, b, n, x2, y2);
b := x2; x2 := x1; y2 := y1; goto 1
end;
if (x2 <= x1) and (y2 > y1)
then
begin
n := n + 1;
approach(a, b, n, x2, y2);
a := x2; x2 := x1; y2 := y1; goto 1
end;
if (x2 > x1) and (y2 < y1)
then
begin
n := n + 1;
approach(a, b, n, x2, y2);
a := x1; goto 1
end;
if (x2 <= x1) and (y2 <= y1)
then
begin
n := n + 1;
approach(a, b, n, x2, y2);
b := x1; goto 1
end;
n := n + 1;
approach(a, b, n, x2, y2);
1: end;
x := (a + b)/2;
end;
27. Процедура поиском минимума функции на промежутке с помощью “золотого сечения”.
Procedure mingold(a, b, e : real; var
x : real);
var
x1, x2, y1, y2 : real;
{----------------------------------------------------------------------------------------}
Function func(x : real):real;
begin
func := ????????????
end;
{----------------------------------------------------------------------------------------}
Function f1(a, b : real) : real;
begin
f1 := 0.618*a + 0.382*b
end;
{----------------------------------------------------------------------------------------}
Function f2(a, b : real) : real;
begin
f2 := 0.382*a+0.618*b
end;
{----------------------------------------------------------------------------------------}
begin
x1 := f1(a, b); y1 := func(x1);
x2 := f2(a, b); y2 := func(x2);
while abs(b - a) > e do
if y1
begin
b := x2; x2 := x1; y2 := y1;
x1 := f1(a, b); y1 := func(x1)
end
else
begin
a := x1; x1 := x2; y1 := y2;
x2 := f2(a, b); y2 := func(x2)
end;
x := (a + b)/2
end;
28. Процедура решения неопределённых уравнений вида ax + by = c:
Procedure
The_equation(a, b, c : integer); {Решение уравнения ax + by = c}
label 1;
var
max, x, y, n : integer;
begin
if (nod(a, b) <> 1) and
(c mod nod(a, b) = 0)
then begin n:= nod(a,b); a := a div n; b := b div n; c := c div n end
else if (nod(a, b) <> 1) and (c mod nod(a, b) <> 0)
then
writeln('Уравнение не имеет решений');
if
abs(a) > abs(b) then max := abs(a) else max := abs(b);
for x := -max to max do
for y := -max to x do
begin
if (a*x + b*y = 1) and
(a > 0) and (b > 0)
then begin writeln('Решения уравнения x = ', x*c, '+', b,'*t, y = ', y*c, '-', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end;
if
(a*x + b*y = 1) and (a < 0) and (b > 0)
then begin writeln('Решения уравнения x = ', x*c, '+', b,'*t, y = ', y*c, ' ', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end;
if
(a*x + b*y = 1) and (a > 0) and (b < 0)
then begin writeln('Решения уравнения x = ', x*c, ' ', b,'*t, y = ', y*c, '-', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end;
if
(a*x + b*y = 1) and (a < 0) and (b < 0)
then begin writeln('Решения уравнения x = ', x*c, ' ', b,'*t, y = ', y*c, ' ', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end
end;
1: end;
Вычислить и округлить до ближайшего целого все числа
а также вычислить u0, u1, ..., u15 по формулам
и сравнить результаты. 174. Вычислить и вывести на экран положительные значения функции
175. Вычислить значения функции
большие заданного числа a, если 
176. Вычислить члены ряда
модуль которых больше заданного числа a, 0 < a < 1, x - любое действительное число.
177. В окружность радиусом r вписан многоугольник со стороной an. Сторона многоугольника с удвоенным числом сторон определяется по формуле
Определить a128, если известны r и а4.
178. Вычислить и вывести на печать значения членов ряда
..., 
179. Вычислить значения функции
180. Последовательность an принимает значения
Чему равен предел an при
? Каково должно быть n, для того чтобы абсолютная величина разности между an и ее пределом была больше 0,0001? 181. Установите, имеет ли следующая последовательность un предел?
. 182. Показать, что последовательность
при неограниченном возрастании n стремится к пределу, равному 
183. Установить имеет ли последовательность, заданная формулой n-го члена предел: а)
б)
..., 
Таким образом, xn+1 получается из xn по формуле
в)
Ответы
К заданию 3
Program Task3;
uses WinCrt;
var
n : integer;
y, eps : real;
{----------------------------------------------------------------------------------------}
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until
eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure
Element_succession(eps : real; var n : integer; var y : real);
var
k : integer;
begin
n := 1;
y := 1;
k := -1;
while abs(y - 2) >= eps do
begin
n := n + 1;
k := k*(-1);
y := 2 + k/n
end
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
writeln('Введите любое положительное число');
write(' Можно даже очень малое '); readln(eps);
Element_succession(eps, n, y);
writeln('Искомый член последовательности ', y:6:t(eps));
writeln('Находится на ', n , '-ом месте')
end.
К
заданию 4
Program Task4;
uses
WinCrt;
var
i, j, n : integer;
k, k1 : longint;
yn, ym, eps : real;
{----------------------------------------------------------------------------------------}
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until
eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
writeln('Введите любое положительное число ');
write('Можно даже очень малое '); readln(eps);
i := 1;
yn := 1/3;
k := 2;
while
abs(yn - 1) >= eps do
begin
i := i + 1;
k := k*2;
yn := (k - 1)/(k + 1)
end;
writeln('Условию |yn - 1| < ', eps:1:t(eps), ' удовлетворяет');
writeln('член последовательности yn = ', yn:6:t(eps), ',');
writeln('находящийся под номером ', i); writeln;
write('Введите номер члена последовательности ');
write('больше ', i, ' '); readln(n);
j := i; ym := yn;
k1 := k;
while
j <= n do
begin
j := j + 1;
k1 := k1*2;
ym := (k1 - 1)/(k1 + 1);
end;
if
abs(ym - 1) < eps
then
begin
write('Неравенство abs(1 - ',ym:6:t(eps),') <', eps:1:t(eps));
writeln(' выполняется')
end
else
begin
write('Неравенство abs(1-', ym:6:t(eps),') <', eps:1:t(eps));
writeln(' не выполняется')
end
end.
К заданию 5
Program Task5;
uses
WinCrt;
var
n : longint;
u, u1, eps : real;
{----------------------------------------------------------------------------------------}
Function
s(k : integer) : longint;
var
i, z : longint;
begin
z := 1;
for
i := 1 to k do z := 3*z;
s := z
end;
{----------------------------------------------------------------------------------------}
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until
eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
writeln('Задайте положительное число eps');
write(' Можно даже очень малое '); readln(eps);
u := 0;
n := 1;
repeat
u := u + 1/(s(n) + 1);
n := n + 1;
u1 := u + 1/(s(n) + 1);
until
abs(u1 - u) < eps;
writeln('Предел последовательности равен ', u1:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Биномиальное распределение
Пример 1. В урне находятся белые и черные шары. Доля белых шаров в урне равна p. Случайное событие А заключается в том, что вынутый наугад шар будет белого цвета; вероятность этого случайного события равна p - доле белых шаров в урне. Вынув из урны шар, отмечают, белый он или нет, затем вынутый шар возвращают в урну и шары тщательно перемешивают. После этого снова вынимают наугад один шар и так повторяют n раз.Случайная величина X - это число появлений события А, т.е. белого шара, при n-кратном повторении испытания. Возможными значениями величины X являются числа 0, 1, 2, ..., n (0 - белый шар не появляется ни разу при всех n испытаниях, 1 - белый шар появляется один раз, 2 - два раза, ..., n - раз, т.е. во все испытаниях).
Найдем закон распределения вероятностей случайной величины X.
Событие X = n означает появление события А во всех испытаниях; по правилу умножения вероятностей (с учетом условия независимости испытаний) получим
Аналогично находим
где 
Событие X = m (m = 1, 2, ..., n-1) означает, что за n испытаний случайное событие А наступит точно m раз, а значит противоположное событие наступит n - m раз.
Вероятность того, что событие А наступит в первых m испытаниях и не наступит в остальных n - m испытаниях, подсчитаем по правилу умножения вероятностей:
Эта вероятность не зависит от того, в каких именно испытаниях наступит событие А. Поэтому по правилу сложения вероятностей искомая вероятность
равна вероятности 
умноженной на число 
способов выбора m испытаний, в которых наступит событие A, из общего числа n испытаний:
(1)Здесь
есть число сочетаний из n элементов по m. Таким образом, мы получим следующую таблицу распределения вероятностей: | X | 0 | 1 | ... | m | ... | n-1 | n | ||||||||
| P(X=m) |  |  | ... |  | ... |  |  |
Этот закон распределения называется биномиальным законом распределения вероятностей. Название связано с тем, что вероятности совпадают с членами разложения бинома (q + p)n по степеням p:
Для вычисления вероятностей по формуле (1) придется не только возводить в степень, но и вычислять число сочетаний из n элементов по k. При этом могут быть достаточно большие числа, что даже установив их вещественный тип можем выйти за пределы допустимого диапазона и получить ошибку при работе программы на Турбо Паскале. Чтобы избежать этого, составим рекуррентное соотношение, с помощью которого можно вычислять вероятности.
Вероятность P(X = m) равна
а вероятность P(X = m - 1) вычисляется по формуле
.Разделим левые и правые части этих равенств, получим:
Таким образом, начиная с P(X = 0), вероятности P(X = m) могут быть вычислены по следующей рекуррентной формуле:
или 
Теперь, для вычисления вероятностей достаточно вычислить вероятность при m = 0, а затем воспользоваться приведенным соотношением.
При m = 0 получаем
Для возведения в натуральную степень вещественного числа составим процедуру:
{ Процедура возведения в степень }
Procedure Extent(a : real; n : integer; var e : real);
var
i : integer;
begin
e := 1;
if
n = 0 then e := 1
else
for i := 1 to n do e := e*a
end;
Используя эту процедуру нетрудно составить процедуру вычисления вероятностей, используя рекуррентное соотношение. Она может быть построена как итеративно, так и рекурсивно. Итеративная процедура приводится ниже, а рекурсивную составьте самостоятельно.
{ Рекуррентная процедура вычисления вероятности }
{биномиального закона распределения }
Procedure
Recurro_binomial(n, m : integer; p : real; var pp : real);
var
i : integer;
begin
Extent(1 - p, n, pp);
for
i := 1 to m do pp := (pp*(n - i + 1)*p)/(i*(1 - p))
end;
Используем эти процедуры для решения следующей задачи.
Пример 2. Из большой партии изделий берут на пробу 10 штук. Известно, что доля нестандартных изделий во всей партии составляет 25 %.
Требуется найти вероятность того, что более пяти отобранных изделий окажутся нестандартными.
Математическое решение задачи
Отбор каждого изделия будем считать испытанием, а обнаружение нестандартности у отобранного изделия - событием А. Вероятность p события А равна доле нестандартных изделий во всей партии, т. е. p = 0.25.
Количество X нестандартных изделий среди отобранных будет случайной величиной с биномиальным распределением вероятностей, если только изделия для пробы отбираются по схеме случайной повторной выборки (изделие после проверки возвращается обратно в общую партию). При этом вероятности подсчитываются по формуле (1) при n = 10, p = 0.25, q = 1 - 0.25 = 0.75.
По правилу сложения вероятностей складываем вероятности при m = 6, 7, 8, 9, 10 и находим искомую вероятность P(X > 5).
Программа
{ Биномиальный закон распределения вероятностей }
Program Problem2;
uses WinCrt;
var
p, pp, sum : real;
n, i : longint;
{----------------------------------------------------------------------------------------}
{ Процедура возведения в степень }
Procedure Extent(a : real; n : integer; var e : real);
var
i : integer;
begin
e := 1;
if n = 0 then e := 1 else for i := 1 to n do
e := e*a
end;
{--------------------------------------------------------------------------------------}
{ Рекуррентная процедура вычисления вероятности }
{ биномиального закона распределения }
Procedure Recurro_binomial(n, m : integer; p : real; var pp : real);
var
i : integer;
begin
Extent(1 - p, n, pp);
for i := 1 to m do pp := (pp*(n - i + 1)*p)/(i*(1 - p))
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите число всех изделий '); readln(n);
write('Введите вероятность появления нестандартного изделия '); readln(p);
writeln('Биномиальный закон распределения вероятностей'); writeln;
for i := 0 to n do write(i:6, ' '); writeln;
writeln;
sum := 0;
for i := 0 to n do
begin
Recurro_binomial(n, i, p, pp);
write(pp:1:4, ' ');
if i >= 6 then sum := sum + pp;
end;
writeln; writeln;
writeln('Вероятность того, что более пяти отобранных');
writeln('изделий окажутся нестандартными равна ', sum:1:6)
end.
Блок-схемы, изображающие условные операторы
Вы уже знаете, что составление программы можно изображать геометрическими фигурами - блоками, в результате чего образуется схема программы. Такая конструкция называется блок-схемой.Какой геометрической фигурой принято обозначать условие? Посмотрите на ниже приведенную конструкцию и вы увидите, что условие изображается ромбом (см. рис. 17).
Рис. 17
Пример 4. Два прямоугольника заданы длинами сторон. Написать программу, после выполнения которой выясняется, можно ли первый прямоугольник целиком разместить во втором. (Рассмотреть только случай, когда соответствующие стороны прямоугольников параллельны.)
Математика этой задачи проста, возможные случаи изображены на рисунке 18, блок-схема на рис. 19:
Рис. 18
Рис. 19
Пользуясь блок-схемой составим программу
Program Problem4;
uses WinCrt;
var
a1, b1, a2, b2 : real;
begin
write('Введите длину и ширину первого прямоугольника ');
readln(a1, b1);
write('Введите длину и ширину второго прямоугольника ');
readln(a2, b2);
if ((a1 < a2) and (b1 < b2)) or
((b1 < a2) and (a1 < b2))
then writeln('Первый прямоугольник размещается во втором')
else writeln('Первый прямоугольник не размещается во втором')
end.
Целый тип longint
Турбо-Паскаль имеет возможности для расширения диапазона значений целых переменных.Так, если тип integer устанавливает диапазон целых значений от -32768 до 32767, то целый тип longint расширяет его от -2147483648 до 2147483647.
Итак, если установить тип переменных longint, тогда выше приведенные программы будут работать для значительно большего множества целых чисел.
Программы
станут такими:
Program
Problem1; { Опред. и вывод на экран цифр числа }
uses WinCrt;
var
n, p, i : longint;
begin
write('Введите натуральное число n '); readln(n);
i := 1;
while n <> 0 do
begin
p := n mod 10;
writeln(i, ' - я цифра справа равна ', p);
n := n div 10;
i := i+1
end
end.
Program Sum; { Сумма цифр числа }
uses WinCrt;
var
a, n, s, p : longint;
begin
write('Введите натуральное число n '); readln(n);
a := n; s := 0;
while n <> 0 do
begin
p := n mod 10; {Определяются цифры числа}
s := s + p; {Находится их сумма}
n := n div 10
end;
writeln('Сумма цифр числа ', a, ' равна ', s)
end.
Program
Problem2a; { Перест. первой и последней цифр числа }
uses WinCrt;
var
n, n1, p, a, i : longint;
begin
write('Введите натуральн. число n <= 2147483647 ');
readln(n);
a := n;
i := 1;
p := n mod 10; {последняя цифра введенного числа}
while n >= 10 do
begin
i := i*10;
n := n div 10;
end;
n1 := a - n*i - p + n + p*i;
writeln('Число после перестановки цифр ', n1);
end.
Подведем итог о
целых типах.
Диапазон возможных значений целых типов зависит от их внутреннего представления, которое может занимать один, два или четыре байта. В таблице приводятся названия целых типов, длина их внутреннего представления в байтах и диапазон возможных значений.
Целые типы
|
Длина, байт |
Название типа |
Диапазон значений |
|
1 |
byte |
0 ... 255 |
|
1 |
shortint |
-128 ... 127 |
|
2 |
word |
0 ... 65535 |
|
2 |
integer |
-32768 ... 32767 |
|
4 |
longint |
-2147483648 ... 2147483647 |
Целый тип данных относится к порядковым типам, которые отличаются тем, что каждый из них имеет конечное число возможных значений. Эти значения можно определенным образом упорядочить и, следовательно, с каждым из них можно сопоставить некоторое целое число - порядковый номер значения (отсюда название типов - порядковый).
Вещественные типы, строго говоря, тоже имеют конечное число значений, которое определяется форматом внутреннего представления вещественного числа. Однако количество возможных значений вещественных типов настолько велико, что сопоставить с каждым из них целое число (его номер) не представляется возможным.
Порядковый
и вещественный типы, в свою очередь, относятся к простым типам.
Числовые характеристики биномиального распределения
При подсчете математического ожидания и дисперсии биномиального распределения воспользуемся методом математической индукции.Для упрощения расчетов представим случайную величину X - число успехов при n-кратном повторении испытания - в виде суммы более простых величин. В качестве таких величин возьмем индикаторы успехов: 1 - "успех", 0 - "неудача". Таким образом, индикатор Xk принимает значение 1 в случае успеха при k-ом повторении испытания и значение 0 в противном случае. Поэтому
X = X1 + X2
+ ... + Xn,
так как эта сумма состоит из единиц и нулей, причем число единиц в ней равно числу успехов при n-кратном повторении испытания.
Отсюда следует, что
MX = MX1 + MX2
+ ... + MXn
(в силу свойства линейности математического ожидания).
Так как биномиальное распределение связано с последовательностью независимых испытаний по схеме Бернулли, то индикаторы X1, X2, ..., Xn
- независимые случайны величины; поэтому можно применить и теорему сложения дисперсий, что дает
DX = DX1 + DX2
+ ... + DXn.
По условию задачи вероятность успеха при каждом повторном испытании одна и та же и равна p. Поэтому распределение вероятностей любого индикатора Xk
дается таблицей
 | 1 | 0 | |||
| p | q |
где q = 1 - p; k = 1, 2, ..., n.
Непосредственный подсчет математического ожидания и дисперсии индикатора Xk приводит нас к следующему результату:
Следовательно, для биномиального распределения имеем
MX = np,
DX = npq,
и, значит,
Математическое ожидание и дисперсия относительной частоты X/n:
Мы пришли к очень важному, применительно к программированию, выводу.
Математическое ожидание относительной частоты случайного события есть вероятность этого события. Формула среднего квадратического отклонения показывает, что рассеяние относительной частоты уменьшается с увеличением числа повторений испытания.
Пример 3. Составить закон распределения случайной величины, выражающей число попаданий в мишень при четырех выстрелах, если вероятность попадания при каждом выстреле равна 0.3.
Вычислить ее математическое ожидание и дисперсию по формулам для характеристик случайной величины, распределенной по биномиальному закону.
{ Биномиальный закон распределения вероятностей }
Program Problem3;
uses WinCrt;
var
p, pp, mx, dx : real;
n, i : integer;
{-------------------------------------------------------------------------------------}
{ Процедура возведения в степень }
Procedure Extent(a : real; n : integer; var e : real);
var
i : integer;
begin
e := 1;
if
n = 0 then e := 1
else
for i := 1 to n do e := e*a
end;
{---------------------------------------------------------------------------------------}
{ Рекуррентная процедура вычисления биномиального закона }
{ распределения }
Procedure
Recurro_binomial(n, m : integer; p : real; var pp : real);
var
i : integer;
begin
Extent(1 - p, n, pp);
for i := 1 to m do pp := (pp*(n - i + 1)*p)/(i*(1 - p))
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите число выстрелов '); readln(n);
write('Введите вероятность попадания при каждом выстреле '); readln(p);
writeln('Биномиальный закон распределения вероятностей');
writeln;
for
i := 0 to n do write(i:6, ' '); writeln;
for
i := 0 to n do
begin
Recurro_binomial(n, i, p, pp);
write(pp:1:4, ' ')
end;
writeln;
mx := n*p;
dx := n*p*(1 - p);
writeln('Математическое ожидание, т.е. число попаданий ');
writeln('при четырех выстрелах ', mx:4:6);
writeln('Дисперсия равна ', dx:4:6);
writeln('Среднее квадратическое отклонение ', sqrt(dx):4:6)
end.
Пример 4.
Длительной проверкой установлено, что из каждых 10 приборов 8 - точных. Составить таблицу распределения числа точных приборов из взятых наудачу пяти приборов. Вычислить математическое ожидание и дисперсию.
{ Биномиальный закон распределения вероятностей }
Program Problem4;
uses WinCrt;
var
p, pp, mx, dx : real;
n, i : integer;
{----------------------------------------------------------------------------------------}
{ Процедура возведения в степень }
Procedure Extent(a : real; n : integer; var e : real);
var
i : integer;
begin
e := 1;
if
n = 0 then e := 1
else
for i := 1 to n do e := e*a
end;
{----------------------------------------------------------------------------------------}
{ Рекуррентная процедура вычисления биномиального закона }
{ распределения }
Procedure
Recurro_binomial(n, m : integer; p : real; var pp : real);
var
i : integer;
begin
Extent(1 - p, n, pp);
for i := 1 to m do pp := (pp*(n - i + 1)*p)/(i*(1 - p))
end;
{---------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите число взятых наудачу приборов '); readln(n);
p := 0.8;
writeln('Вероятность появления точного прибора ', p:1:6);
writeln('Биномиальный закон распределения вероятностей');
writeln;
for
i := 0 to n do write(i:6, ' '); writeln; writeln;
for
i := 0 to n do
begin
Recurro_binomial(n, i, p, pp);
write(pp:1:4, ' ')
end;
writeln; writeln;
mx := n*p; dx := n*p*(1 - p);
writeln('Математическое ожидание, т.е. число точных ');
writeln('приборов из взятых наудачу пяти ', mx:4:6);
writeln('Дисперсия равна ', dx:4:6);
writeln('Среднее квадратич. отклонение ', sqrt(dx):4:6)
end.
Числовые характеристики распределения Пуассона
Математическое ожидание
Это позволяет выяснить статистический смысл параметра a в распределении Пуассона: параметр a есть среднее число событий, наступающих за время t в простейшем потоке. Отсюда можно дать статистическое толкование параметру
: так как= a/t, то параметр есть среднее число событий, наступающих за единицу времени. Дисперсия равна
Дисперсия совпадает с математическим ожиданием. Эти результаты хорошо согласуются с представлением распределения Пуассона в качестве предельного для биномиального распределения при
Действительно, при этом MX = np = a, DX = npq = a(1 - p)
a. Что такое цикл?
Давайте отвлечемся на некоторое время от программирования и попытаемся на природных явлениях, примерах из повседневной жизни человека, а затем и его мыслительной деятельности дать понятие цикла.Если вас спросят, что такое цикл, то, наверное, вы не задумываясь ответите, что это повторяемость
чего-то.
И это совершенно правильно!
Повторяемость времен года в природе - это цикл, кругооборот воды в природе - это цикл, смена дня и ночи - это цикл и многие другие процессы в природе повторяются, образуя циклы или, что чаще нами употребляется, цикличность.
Циклы в математике - явление очень часто встречающееся.
Например, пока
натуральные числа меньше 10, тогда надо суммировать их.
Другими словами, мы находим сумму чисел от 1 до 10.
В этом примере повторяется сложение натуральных чисел, пока выполняется условие
(числа меньше 10).
Такие циклы называются циклами с предыдущим условием или, коротко, с предусловием, потому что условие записывается перед выполнением повторяющейся группы операторов.
Цикл в программировании - это многократно выполняемая группа команд, часть программы.
Сразу заметим, что в программе может быть такая ситуация, когда цикл вообще не выполняться ни разу.
На языке Паскаль возможны циклы с предусловием, которые организуются с помощью оператора:
while (пока) ... do (выполнять) ...
Формат оператора: while <условие> do <операция>.
Работа оператора заключается в том, что операция выполняется до тех пор, пока будет выполняться условие, указанное в операторе while.
Если операция содержит не один оператор, а несколько, то их объединяют с помощью ОПЕРАТОРНЫХ СКОБОК begin и end, например;
while <условие> do
begin
S1; S2; S3; ...
end;
В этом примере символами s1, s2, s3, ... обозначены операторы.
Действие цикла while
... do ... можно изобразить графически следующей схемой (см.
рис. 20):
Рис. 20
Рассмотрим работу оператора while ... do ... на примере.
Пример 1. Определить и вывести на экран цифры целого числа n.
Разберем математику этого вопроса на частном примере.
Найдем цифры числа 4538. Для этого надо найти остаток от деления 4538 на 10 с помощью операции нахождения остатка от деления целых чисел (mod):
4538 mod 10 = 8, получим последнюю цифру числа (она же является первой справа).
Выдаем сообщение: "1 - я цифра справа равна 8".
После этого выполним целочисленное деление заданного числа 4538 на 10, получим 453 (остаток отбрасывается):
4538 div 10 = 453.
Далее процесс повторяем:
2 - й раз; 453 mod 10 = 3
2 - я цифра справа равна 3,
453 div 10 = 45,
3 - й раз; 45 mod 10 = 5,
3 - я цифра справа равна 5,
45 div 10 = 4,
4 - й раз; 4 mod 10 = 4,
4 - я цифра справа равна 4,
4 div 10 = 0.
Обратите внимание! Процесс будет продолжаться пока
число n не равно нулю. Как только оно станет равно нулю цикл заканчивается.
В программе еще надо указывать какая по счету цифра в числе справа. Для этого надо завести еще одну переменную в качестве счетчика. Эта переменная каждый цикл должна увеличиваться на 1.
Программа
Program
Problem1; {Опред. и вывод на экран цифр числа.}
uses WinCrt;
var
n, p, i : integer;
begin
write('Введите натуральное число n <= 32767 '); readln(n);
i := 1;
while n <> 0 do
begin
p := n mod 10;
writeln(i, ' - я цифра справа равна ', p);
n := n div 10;
i := i + 1
end
end.
Построение
программы и ее работа.
В разделе описаний
Переменная n для целого числа, p - для цифр числа, i - счетчик цифр.
В разделе операторов
С помощью оператора write выводится на экран запрос для пользователя о вводе целого числа. Оператор readln заносит его значение в память и присваивает переменной n.
Счетчику i устанавливается первоначальное значение 1.
В операторе while записывается условие (пока n не равно 0), при котором цикл будет выполняться.
Так как в цикле несколько операторов, то используются операторные скобки
begin ... end.
В них записаны операторы:
p := n mod 10; - определяется последняя цифра;
writeln(i,' - я цифра справа равна ', p); - выводится на экран порядковый номер цифры справа и сама эта цифра;
n := n div
10; - от числа "зачеркивается" последняя цифра;
i := i + 1; - счетчик увеличивается на 1.
Циклы в циклах
Рассмотрим еще один пример, где уже приходиться использовать два цикла, один внутри другого.Пример 5. Составить программу вывода всех натуральных чисел, меньших n, квадрат суммы цифр которых равен заданному числу m.
Сущность задачи такова. Вводится натуральное число, до которого надо выводить все натуральные числа, удовлетворяющие заданному условию. Пусть, например, пользователь введет число - 21.
Второе число, которое надо ввести пользователю - это число, которому равен квадрат суммы цифр натуральных чисел.
Понятно, что это число должно быть точным квадратом, оно может быть: 4, 9, 16, 25, 36 и т.д.
Допустим, что пользователь ввел число 4.
Надо найти все натуральные числа от 1 до 21, квадрат суммы цифр которых равна 4. Начинаем из чисел: 1, 2, 3, 4, 5, ..., 21, выбирать те, которые удовлетворяют заданному условию.
Первое из них - 2, так как 22 = 4, второе - 11, так как (1 + 1)2 = 22
= 4, третье - 20, так как (2 + 0)2 = 22 = 4.
Других натуральных чисел до 21, удовлетворяющих такому условию нет.
Все отобранные числа надо вывести на экран, т. е. 2, 11 и 20.
Алгоритм
1. Раздел описаний.
Переменные: n, m, k, a, p, s. Тип целый.
n - для границы значений натуральных чисел, m - для числа, с которым сравнивается квадрат суммы цифр (точный квадрат), k - для натуральных чисел от 1 до n, a - для запоминания натурального числа, перед тем, как будет определяться сумма его цифр, p - для цифр числа, s - для суммы цифр.
2. Раздел операторов.
Ввод значений n и m. Установить первоначальное значение для k (эта переменная "перебирает" все натуральные числа от 1 до n, k := 1).
Цикл, пока
k <= n.
В цикле: установить первоначальные значения для суммы s (s:=0); запомнить число в переменную a (a := k).
Цикл для подсчета суммы цифр, пока k <> 0.
В цикле: выделять по одной цифре числа, известным способом; прибавлять по одной цифре к сумме; уменьшать число на последнюю цифру и на порядок.
Закончить цикл для подсчета суммы цифр.
Проверка выполнения условия.
Если
квадрат суммы цифр равен заданному числу,
тогда
вывести это натуральное число на экран.
Перейти к проверке следующего числа.
Закончить основной цикл проверки чисел.
3. Закончить программу.
По этому алгоритму составим программу.
Program Problem5;
uses WinCrt;
var
n, m, k, a, p, s : integer;
begin
write('Введите натуральное число, до которого ');
write('выводить искомые числа '); readln(n);
writeln('Введите число, с которым сравниваете квадрат');
write('его суммы цифр. Оно должно быть точн. квадрат. '); readln(m);
write('Искомые числа: ');
k := 1;
while k <= n do
begin
s := 0; a := k;
while k <> 0 do
begin
p := k mod 10;
s := s + p;
k := k div 10
end;
if sqr(s) = m then write(a, ' ');
k := a + 1
end
end.
В программе два цикла. Один - внешний, для натуральных чисел, второй - внутренний, для подсчета суммы цифр числа.
Дискретная случайная величина, закон распределения вероятностей
Под случайной величиной мы будем понимать величину, значение которой изменяется случайным образом от одного испытания к другому.Определение. Величина X называется дискретной случайной величиной, если множество ее возможных значений представляет собой конечную или бесконечную последовательность чисел x1, x2, x3, ..., xi, ... и если каждое событие X = xi является случайным событием, т.е. имеет определенную вероятность pi
(события X = xi мы будем называть элементарными событиями).
Примерами дискретных случайных величин являются: число X выпадений герба при бросании двух монет; число X очков, выпадающих на верхней грани игральной кости; число вынутых из урны белых или черных шаров, если в ней содержится определенное число белых и черных шаров; число стандартных изделий в определенной партии изготовленных изделий и др.
Законом распределения (вероятностей) случайной величины X мы будем называть любое правило или закон, позволяющее находить все вероятности
(i = 1, 2, ...). Другими словами, закон распределения задает вероятность pi как функцию, определенную на множестве элементарных случайных событий X = xi. Как и любую функцию ее можно задать различными способами: словесным описанием, таблицей, формулой, графиком.
Пример 1. Число X выпадений герба при бросании двух монет есть дискретная случайная величина, закон распределения вероятностей которой можно задать таблицей:
| X | 0 | 1 | 2 | ||||
| P | 1/4 | 1/2 | 1/4 |
Если случайная величина X может принимать лишь конечное число различных значений x1, x2, x3, ..., xk, то их вероятности образуют полную группу случайных событий, и поэтому сумма их вероятностей равна единице:
p1 + p2
+ ... + pk = 1.
Если множество (различных) возможных значений величины X бесконечно, то конечную сумму в этой формуле можно заменить на бесконечный ряд сумма которого тоже равна 1.
Пример 2. Число X очков, выпадающее на верхней грани правильной игральной кости, есть дискретная случайная величина с законом распределения, записанным таблицей
|
X |
1 |
2 |
3 |
4 |
5 |
6 |
|
P |
1/6 |
1/6 |
1/6 |
1/6 |
1/6 |
1/6 |
Дисперсия, среднее квадратическое отклонение и другие характеристики рассеяния
Математическое ожидание MX называют центром распределения случайной величины. Обозначим MX = a.Тогда рассеянием случайной величины X называется отклонение X - a этой величины от ее центра a. Чем больше эта разность, тем больше рассеяние случайной величины от MX.
Непосредственный подсчет математического ожидания этой разности равен нулю M(X - a) = MX - a = 0, и поэтому не может быть числовой характеристикой рассеяния случайной величины.
Основной числовой характеристикой рассеяния случайной величины X служит среднее квадратическое отклонение
, определяемое по формуле 
Расчеты удобнее производить с подкоренным выражением, которое получило специальное название дисперсии случайной величины X и обозначают DX:
DX = M(X - a)2
Таким образом, дисперсия есть средний квадрат отклонения случайной величины от ее центра распределения. Эта величина уже дает большие возможности для оценки случайной величины и нахождения закона распределения ее вероятности.
Для вычисления дисперсии может быть применима формула:
DX = M(X - a)2
= M(X - C)2 - (a - C)2 ,
где C - любое число. В частности, при C = 0 получаем:
DX = MX2 - a2 = MX2 - (MX)2
Для дополнительных занятий
Пример 14. Сколько всех делителей у числа 210? У числа 30030? У целого числа n?Первая
мысль, которая возникает, - это делить заданное натуральное число на простые числа и подсчитать число простых делителей. Остальные делители получаются всевозможными сочетаниями из простых делителей. Значит, возникает необходимость подсчитать число таких сочетаний, причем сочетания должны быть различными.
Но такой путь является достаточно сложным и долгим. Более простой путь решения можно избрать, если знать следующее математическое утверждение.
Пусть p1, ..., pm - различные простые делители числа q. Если
, где 
- некоторые натуральные числа, тогда число всех делителей числа q (включая 1 и q) равно числу сочетаний с повторениями (кортежей) показателей степеней a1, a2, ..., am, которое, в свою очередь, равно произведению: 
Основываясь на этом предложении составим программу.
Алгоритм
для составления программы может быть таким:
1.
Определяется число простых делителей, равных 2.
2. Число этих делителей увеличивается на 1 и присваивается переменной s.
3. Определяется число нечетных простых делителей.
4. Для каждого простого нечетного делителя устанавливается их число, увеличивается на 1 и умножается на s.
5. Результат - число всех делителей выводится на экран.
Программа
Program Problem14;
uses WinCrt;
var
s, q, m, j, n : integer;
begin
write('Введите целое число '); readln(n);
m := n;
q := 0;
s := 0;
while m mod 2 = 0 do
begin
q := q + 1;
m := m div 2
end;
s := q + 1; j := 3; q := 0;
while j <= m do
begin
if m mod j =0 then
begin
q := q + 1;
m := m div j
end;
s := s*(q + 1);
if m mod j <> 0 then j := j + 2
end;
writeln('К-во всех делителей числа ', n, ' равно ', s)
end.
Дополнительные задания
Пример 9. Задача об остроугольном треугольнике. На окружности случайно выбираются три точки. Какова вероятность того, что треугольник с вершинами в этих точках - остроугольный? (См. рис. 41).Решение
Ясно, что при любом повороте окружности вероятности событий и условие "остроугольности" сохраняются; так что мы можем считать, что одна из трех выбираемых вершин A, B, C - скажем, C - фиксирована, а две другие уже выбираются случайно. Будем задавать их положения величинами дуг CA = a, CB = b, отсчитываемых против часовой стрелки. Будем измерять дуги в радианах, тогда пара (a, b) - это точка в квадрате 0 < a < 2Pi, 0 < b < 2Pi. По теореме о том, что величина вписанного угла измеряется половиной дуги между его сторонами, углы треугольника ABC равны Pi-b/2, a/2 и (b-a)/2 (мы считаем, что b>a; случай a>b совершенно аналогичен - a и b меняются ролями). Точки (a, b) в треугольнике a
Рис. 41
Program Problem9;
uses WinCrt;
var
x, y, p, e, pp : real;
i, n, m : longint;
{-------------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function
FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{-------------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{-------------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random*2*pi; y := random*2*pi;
if ((y > pi) and (y < x + pi) and (x < pi)) or
((y < pi) and (y > x - pi) and (x > pi))
then m := m + 1
end;
p := m/n;
writeln('Искомая вероятность равна ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
155. На отрезке [0; 1] случайно выбираются три числа. Какова вероятность того, что а) выбранное последним число наибольшее? б) числа идут в порядке возрастания?
Пример 10. Какова вероятность того, что при двух бросаниях кубика выпадут а) два числа с суммой не меньше 10? б) два числа, из которых первое делится на второе?
Идея решения задачи проста. Каждое из двух бросаний мы смоделируем, как получение двух случайных чисел из промежутка [1; 6]. (Число очков на игральном кубике следующее: 1, 2, 3, 4, 5, 6).
Для получения таких чисел можно использовать функции:
x := random(6) + 1 и y := random(6) + 1.
"Бросать" кубик будем не два раза, а количество бросаний предоставим устанавливать пользователю. Из "выпавших" чисел x и y будем подсчитывать число случаев, когда: а) x + y > +10; б) x mod y = 0.
Это число случаев разделим на общее число бросаний и получим искомую вероятность (фактически мы получим частоту появления событий о чём речь шла выше).
Программы
Program Problem10a;
uses WinCrt;
var
x, y, p, e, pp : real;
i, n, m : longint;
{-------------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function
FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{-------------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{-------------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random(6) + 1; y := random(6) + 1;
if (x + y >= 10) then m := m + 1
end;
p := m/n;
writeln('Искомая вероятность равна ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Program Problem10b;
uses WinCrt;
var
p, e, pp : real;
x, y, i, n, m : longint;
{----------------------------------------------------------------------------------------}
{ Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random(6) + 1; y := random(6) + 1;
if x mod y = 0 then
m := m + 1
end;
p := m/n;
writeln('Искомая вероятность равна ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
156. Какова вероятность, что при первом бросании выпадет не меньше 5 очков, а при втором - не меньше 4?
157. Какова вероятность, что хотя бы при одном из двух бросаний кубика выпадет не менее 5 очков?
158. Какова вероятность, что количество очков, выпавших при двух бросаниях, отличаются не более чем на 1?
159. (Случайные числа и точки: равномерное распределение). Найдите вероятность того, что сумма x + y, где x, y - случайные числа на отрезке [0; 1], больше данного числа a.
160. На отрезке [0; 1] случайно выбираются три числа. Какова вероятность того, что а) выбранное последним число наибольшее? б) числа идут в порядке возрастания?
161. На окружности случайно выбраны четыре точки A, B, C, D. Какова вероятность того, что отрезки AC и BD пересекаются?
162. а) В окружности проведен диаметр. На нём случайно выбирается точка и через нее проводится хорда, перпендикулярная диаметру. Какова вероятность, что длина хорды больше радиуса окружности?
б) На окружности случайно выбираются две точки. Какова вероятность, что длина соединяющей их хорды больше радиуса?
в) В круге случайно выбрана точка. Какова вероятность, что хорды с серединой в этой точке больше радиуса?
г) Решите аналогичные задачи про хорду длины r
, где r - радиус. Замечание. Задачи а), б), в) как бы три варианта одной и той же: проведем случайную прямую, пересекающую окружность: какова вероятность, что длина высекаемой хорды больше радиуса? Но ответ в них разный (парадокс Бертрана)!
163. На окружности случайно выбраны три точки.
Какова вероятность, что у треугольника с вершинами в этих точках: а) есть угол больше 30 градусов? б) все углы больше 30 градусов? в) все углы меньше 120 градусов?
164. На отрезке случайно выбраны две точки. Какова вероятность, что из отрезков, на которые он разбит, можно составить треугольник?
165. Плоскость разбита сеткой прямых на а) квадраты; б) правильные треугольники со стороной 1. Какова вероятность, что монета диаметра 1, случайно брошенная на плоскость, закроет одну из вершин сетки?
166. Найдите вероятность того, что а) выпуклый n-угольник с вершинами в случайных точках окружности содержит ее центр?
б) Докажите, что вероятность того, что n случайно выбранных точек на сфере лежат на одной полусфере (по одну сторону от некоторого большого круга) равна (n2 - n + 2)/2n.
Ответы
К заданию 2
Так как общее число карточек равно 7, то их можно упорядочить 7! способами. Поскольку обе буквы Т и обе буквы Р можно менять местами, не изменяя слова, то слово ТРАКТОР получится
2!.2! раза. Искомая вероятность равна:
Иначе тот же результат можно было бы получить, заметив, что в результате извлечения карточек мы получаем перестановку с повторениями состава (2, 2, 1, 1, 1), причем все такие перестановки имеют одну и ту же вероятность. Так как число перестановок равно P(2, 2, 1, 1, 1), то вероятность каждой из перестановок
равна
.Program problem2;
uses WinCrt;
var
p : real;
k1, k : integer;
{----------------------------------------------------------------------------------------}
Procedure fakt(n : integer; var f : integer);
var
i : integer;
begin
f := 1;
if n = 0 then f := 1
else for i := 1 to n do
f := f*i
end;
{----------------------------------------------------------------------------------------}
begin
fakt(7, k); fakt(2, k1);
p := (k1*k1)/k;
writeln('Вероятность получ. слова "трактор" равна ', p:10:8)
end.
К заданию 3
Приведем лишь математическое решение задачи. Последующее составление программы достаточно простое.
Вычислить: P4(3) и P6(4).
По формуле Бернулли
; 
. Далее необходимо сравнить полученные результаты и сделать вывод.
К заданию 4 (пример 1)
{ Биномиальный закон распределения вероятностей }
Program Problem4_1;
uses WinCrt;
var
p, pp : real;
n, i : integer;
{----------------------------------------------------------------------------------------}
{ Процедура возведения в степень }
Procedure
Extent(a : real; n : integer; var e : real);
var
i : integer;
begin
e := 1;
if n = 0 then e := 1
else for i := 1 to n do e := e*a
end;
{----------------------------------------------------------------------------------------}
{ Рекуррентная процедура вычисления биномиального закона }
{ распределения }
Procedure Recurro_binomial(n, k : integer; p : real; var pp : real);
var
i : integer;
begin
Extent(1 - p, n, pp);
for i := 1 to k do pp := (pp*(n - i + 1)*p)/(i*(1 - p))
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите общее число рождений '); readln(n);
write('Введите вероятность рождения мальчика '); readln(p);
writeln('Биномиальный закон распределения вероятностей');
writeln;
for i := 0 to n do
write(i:6, ' '); writeln; writeln;
for i := 0 to n do
begin
Recurro_binomial(n, i, p, pp); write(pp:1:4, ' ')
end;
writeln; writeln;
Recurro_binomial(10, 6, p, pp);
writeln('Вероятность того, что из 10 наугад выбранных');
writeln('рождений будет 6 мальчиков, равна ', pp:1:6)
end.
К заданию 7
{ Распределение Пуассона }
Program Problem7;
uses WinCrt;
var
n, m : longint;
p, a : real;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления вероятности распределения Пуассона }
Function PS(m : integer; a : real) : real;
var
i : integer;
pp : real;
begin
pp := exp(-a);
if m = 0 then pp := exp(-a)
else for i := 1 to m do pp := pp*a/i;
PS := pp
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите общее число изделий '); readln(n);
write('Введите вероятность изделия быть бракованным ');
readln(p);
writeln('Введите число бракованных изделий, вероятность ');
write('появления которых Вы находите '); readln(m);
a := n*p;
writeln('Вероятность ', m, ' бракованных изделий в ');
writeln('партии из ',n, ' изделий равна ', PS(m, a):1:6)
end.
К заданию 9
{ Применение интегральной формулы Муавра-Лапласа }
Program Problem1;
uses WinCrt;
var
n, m1, m2 : longint;
p, PP : real;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if
x >= 5
then
FF := 1
else if x <= -5
then
FF := -1 else
begin
u := x; n := 0; I := 0;
repeat
I := I + u; n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until
abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисл. вероятн. наст. событ. из промеж. [m1; m2] }
Procedure
Interval(n, m1, m2 : longint; p : real; var PP : real);
var
x1, x2 : real;
begin
x1 := (m1 - n*p)/sqrt(n*p*(1 - p));
x2 := (m2 - n*p)/sqrt(n*p*(1 - p));
PP := (FF(x2) - FF(x1))/2
end;
{----------------------------------------------------------------------------------------}
{ Основная программа. Число бракованных изделий из промежутка }
begin
write('Введите общее число изделий '); readln(n);
write('Введите вероятность наступление одного события ');
readln(p);
write('Введите левую границу промежутка '); readln(m1);
write('Введите правую границу промежутка '); readln(m2);
Interval(n, m1, m2, p, PP);
writeln('Вероятность того, что число бракованных изделий');
write('находится в промежутке [',m1, '; ', m2, '] равна ');
writeln(PP:1:8)
end.
{ Применение интегральной формулы Муавра-Лапласа }
Program Problem2;
uses WinCrt;
var
n, m1, m2 : longint;
p, q, PP : real;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if
x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u; n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until
abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисл. вероятн. наст. событ. из промеж. [m1; m2] }
Procedure
Interval(n, m1, m2 : longint; p : real; var PP : real);
var
x1, x2 : real;
begin
x1 := (m1 - n*p)/sqrt(n*p*(1 - p));
x2 := (m2 - n*p)/sqrt(n*p*(1 - p));
PP := (FF(x2) - FF(x1))/2
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите общее число изделий '); readln(n);
write('Введите вероятность брака в одном изделии '); readln(q);
write('Введите левую границу промежутка '); readln(m1);
write('Введите правую границу промежутка '); readln(m2);
p := 1 - q;
Interval(n, m1, m2, p, PP);
writeln('Вероятность того, что число пригодных изделий');
write('находится в промежутке [',m1, '; ', m2, '] равна ');
writeln(PP:1:8)
end.
К заданию 10
{ Процедура нахождения числа испытаний n, чтобы обеспечить }
{ заданную вероятность отклонения частоты от np }
Procedure Number(p, e, PP : real; var n : longint);
var
x : real;
begin
x := 0;
repeat
x := x + 0.01
until
FF(x) >= PP;
n := round(e/(x*sqrt(p*(1 - p))) + 0.5);
n := sqr(n)
end;
{ Применение интегральной формулы Муавра-Лапласа }
Program Task10;
uses WinCrt;
var
n : longint;
e, q, PP : real;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if
x >= 5
then
FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until
abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура нахождения числа испытаний n }
Procedure Number(p, e, PP : real; var n : longint);
var
x : real;
begin
x := 0;
repeat
x := x + 0.01
until FF(x) >= PP;
n := round(e/(x*sqrt(p*(1 - p))) + 0.5);
n := sqr(n)
end;
{----------------------------------------------------------------------------------------}
begin
write(' Введите вероятность отклонения клемм от принято');
write('го стандарта '); readln(q);
write('Введите число стандартных клемм отличающихся ');
write('от np (по модулю) '); readln(e);
write('Укажите вероятность этого отклонения '); readln(PP);
Number(q, e, PP, n);
writeln('Искомое число взятых наудачу клемм равно ', n)
end.
К заданию 11
{ Процедура определение границы отклонения (ReIection) частости}
{ от заданной вероятности наступления одного события }
Procedure ReIection(n : longint; p, PP, eps : real; var e : real);
var
x : real;
begin
x := 0;
repeat
x := x + eps
until
FF(x) >= PP;
e := x*sqrt(p*(1 - p)/n)
end;
{ Применение интегральной формулы Муавра-Лапласа }
Program Task3;
uses WinCrt;
var
n : longint;
e, eps, p, pp : real;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if
x >= 5
then
FF := 1
else if x <= -5
then
FF := -1
else
begin
u := x;
n := 0;
I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until
abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура определение границы отклонения (ReIection) частости}
{ от заданной вероятности наступления одного события }
Procedure ReIection(n : longint; p, PP, eps : real; var e : real);
var
x : real;
begin
x := 0;
repeat
x := x + eps
until
FF(x) >= PP;
e := x*sqrt(p*(1 - p)/n)
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите вероятность события в каждом испытании '); readln(p);
write(' Введите общее число произведенных испытаний '); readln(n);
write('Укажите гарантированную вероятность '); readln(PP);
write('Укажите точность вычисления искомой величины '); readln(eps);
ReIection(n, p, PP, eps, e);
writeln('Искомая граница отклонения частости от вероят-');
write('ности будет находиться в промежутке ');
writeln('[', p-e:1:4, '; ', p+e:1:4, ']')
end.
К заданию 12
{ Применение интегральной формулы Муавра-Лапласа }
Program Problem12;
uses WinCrt;
var
n : longint;
e, p, PP : real;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function
FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура нахождения числа испытаний n, чтобы обеспечить }
{ заданную вероятность отклонения частности от заданного числа }
Procedure
Number3(p, e, PP : real; var n : longint);
var
x : real;
begin
x := 0;
repeat
x := x + 0.01
until FF(x) >= PP;
n := round((x*sqrt(p*(1 - p))/e) + 0.5);
n := sqr(n)
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write(' Введите постоянную для каждого испытания ');
write('вероятность '); readln(p);
writeln('Введите число, от которого по абсолютной ');
write('величине должна отличаться частость '); readln(e);
write('Укажите гарантированную вероятность '); readln(PP);
writeln;
Number3(p, e, PP, n);
writeln('Число испытаний должно быть больше или равно ', n)
end.
К
заданию 15
Program Normal1;
uses WinCrt;
var
PP, x, l, c : real;
{-----------------------------------------------------------------------------------------}
{ Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until
abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура нахождения аргумента x }
Procedure Argument(PP : real; var
x : real);
begin
x := 0;
repeat
x := x + 0.0001
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
write(' Введите среднее квадратическое отклонение '); readln(c);
write('Введите вероятность попадания в интервал, симметричн. M(X) ');
readln(PP);
Argument(PP, x);
l := 2*c*x;
writeln('Длина искомого интервала равна ', L:4:6)
end.
Ответ к задаче 2 задания
Указание
По формуле (6) находим
.Ответ
0.06.
Program Exercise_Normal2;
uses WinCrt;
var
PP, x, a, d, e, c : real;
{----------------------------------------------------------------------------------------}
{ Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until
abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура нахождения аргумента x }
Procedure Argument(PP : real; var
x : real);
begin
x := 0;
repeat
x := x + 0.0001
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите среднее значение ');
writeln('нормально распределенной случайной величины a = M(X) ');
write('т.е. средний диаметр детали '); readln(a);
write('Введите дисперсию '); readln(d);
writeln('Введите гарантированную вероятность');
write(' отклонения детали от среднего размера '); readln(PP);
Argument(PP, x);
c := sqrt(d);
e := c*x;
writeln('Максимальное отклонение диаметра от среднего равно ', e:2:6)
end.
Ответ к задаче 3 задания
а) 0.9986; б) 0.7823.
Program Exercise_Normal13a;
uses WinCrt;
var
e, c, d, pp, p1, sum : real;
n, m, i : integer;
{----------------------------------------------------------------------------------------}
{ Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура возведения в степень }
Procedure Extent(a : real; n : integer; var e : real);
var
i : integer;
begin
e := 1;
if n = 0 then e := 1 else for i := 1 to n do
e := e*a
end;
{--------------------------------------------------------------------------------------}
{ Рекуррентная процедура вычисления вероятности }
{ биномиального закона распределения }
Procedure Recurro_binomial(n, m : integer; p : real; var p1 : real);
var
i : integer;
begin
Extent(1 - p, n, p1);
for
i := 1 to m do p1 := (p1*(n - i + 1)*p)/(i*(1 - p))
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите дисперсию '); readln(d); c := sqrt(d);
write(' Введите отклонение детали от заданного размера '); readln(e);
write('Введите число измерений '); readln(n);
write('Введите допускаемое число появления ощибок '); readln(m);
pp := 1 - FF(e/c);
sum := 0;
for i := 0 to m do
begin
Recurro_binomial(n, i, pp, p1);
sum := sum + p1
end;
writeln('Вероятность брака равна ', sum:1:6)
end.
К
заданию 16
Program Task16_1;
uses WinCrt;
var
x, y, p, e, pp : real;
i, n, m, a, b : longint;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function
FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u; n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1; x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите длину отрезка - a = '); readln(a);
write('Введите расстояние b от точки A '); readln(b);
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random*a; y := random*a;
if (x <= b) and (y <= b) then m := m + 1
end;
p := m/n;
writeln('Искомая вероятность равна ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Program Task16_2;
uses WinCrt;
var
x, y, p, a, q, k1, h, e, pp : real;
i, n, k, m : longint;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u; n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1; x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите длину стороны BC '); readln(a);
write('Введите высоту трапеции '); readln(h);
write('Введите величину угла BAE < Pi/2 в рад '); readln(q);
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
k := 0; m := 0; k1 := sin(q)/cos(q);
for i := 1 to n do
begin
x := random*(2*h/k1 + a); y := random*h;
if (y < k1*x) and (y < -k1*x + k1*(2*h/k1 + a)) then k := k + 1;
if ((x < h/k1) and (y < k1*x)) or
((x > a + h/k1) and
(y < -k1*x + k1*(2*h/k1 + a))) then m := m + 1
end;
p := m/k;
writeln('Искомая вероятность равна ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
К заданию 17
Пусть событие E - точка оказалась внутри куба с ребром, равным 3 см. Будем считать, что исходы испытания распределены равномерно. Тогда вероятность наступления события E пропорциональна мере этого куба и равна:
, где V1 - объем куба,V2 - объем параллелепипеда.
Program Task17;
uses WinCrt;
var
x, y, z, p, e, pp : real;
i, n, s : longint;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function
FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
s := 0;
for i := 1 to n do
begin
x := random*4; y := random*6; z := random*10;
if (x < 3) and (y < 3) and (z < 3) then s := s + 1
end;
p := s/n;
writeln('Вероятность появление точки внутри куба ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
К
заданию 18
Program Task18_1;
uses WinCrt;
var
x, y, p, e, pp : real;
i, n, m : longint;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function
FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random*12;
y := random*12;
if (y > x - 3) and (y < x + 3) then m := m + 1
end;
p := m/n;
writeln('Искомая вероятность равна ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Program Task18_2;
uses WinCrt;
var
x, y, p, e, pp : real;
i, n, m : longint;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random*20;
y := random*20;
if (y > x - 5) and (y < x + 5) and
(y > x - 2) and (y < x + 2)
then m := m + 1
end;
p := (2*m)/n;
writeln('Искомая вероятность равна ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
К
заданию 19
Program Task19;
uses WinCrt;
var
p, x, y, z, e, pp : real;
i, n, m : longint;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function
FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random; y := random; z := random;
if ((x < 1/3) and (y > 1/3) and (y < 2/3) and (z > 2/3)) or
((y < 1/3) and (x > 1/3) and (x < 2/3) and (z > 2/3)) or
((y < 1/3) and (z > 1/3) and (z < 2/3) and (x > 2/3)) or
((z < 1/3) and (x > 1/3) and (x < 2/3) and (y > 2/3)) or
((z < 1/3) and (y > 1/3) and (y < 2/3) and (x > 2/3)) or
((x < 1/3) and (z > 1/3) and (z < 2/3) and (y > 2/3))
then m := m + 1
end;
p := m/n;
writeln(' Искомая вероятность равна ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Досрочное прерывание цикла Метка Оператор безусловного перехода goto
Итак, если в числе появляется цифра 2, надо прервать цикл, т. е. нарушить естественный ход выполнения программы, выдать соответствующее сообщение и закончить программу. Такой безоговорочный переход может выполнить оператор goto, который и называется оператором безусловного перехода.Оператор перехода указывает, что дальше программа должна выполняться, начиная с оператора, помеченного меткой, которая записана в этом операторе перехода.
Оператор перехода имеет вид: goto <метка>. Здесь goto - зарезервированное слово (перейти на ... [метку]).
Метка
в Турбо Паскале - это произвольный идентификатор, позволяющий именовать (помечать) некоторый оператор программы и таким образом ссылаться на него. Допускается в качестве меток (в том числе) использовать целые числа без знака (это сделано с целью совместимости Турбо Паскаля со стандартным языком Паскаль).
Например:
goto 2341, goto 23, goto
1, goto bl1, goto mnk3, goto n56.
Любая метка должна быть описана в разделе описания меток, который обычно располагается в программе до начала раздела операторов:
label
<список меток>.
Например: label
2341; label 1, 2; label bl1, 18, mnk.
В программе метка записывается перед оператором, на который осуществляется переход. Метка отделяется от оператора двоеточием. Между меткой и оператором можно включать один или несколько пробелов, например:
1: writeln('Число не содержит цифру 2');
Оператор можно помечать несколькими метками, которые в этом случае отделяются друг от друга двоеточием.
1: 25: a := b div
10;
Теперь составим программу решения предыдущей задачи с использованием меток и оператора перехода.
Ниже приведена эта программа.
Program
Problem4a; { Входит ли цифра 2 в запись числа }
uses WinCrt;
label 1, 2;
var
n, p : integer;
begin
write('Введите целое число '); readln(n);
while n <> 0 do
begin
p := n mod 10;
if p = 2 then goto 1 else n := n div
10
end;
writeln('Цифра 2 не входит в запись этого числа');
goto
2;
1: writeln('Цифра 2 входит в запись этого числа');
2: end.
Внимательно разберитесь в ее работе. Постарайтесь ответить на следующие вопросы.
1) Зачем в программе две метки? Для чего служит каждая из них?
2) Почему в программу введен второй оператор перехода goto 2?
3) Как будет выполняться программа, если этот оператор исключить из нее?
Двумерные случайные величины
Вначале введем понятие независимости случайных величин.Дискретные случайные величины X и Y называются независимыми, если независимы при любых i и I события X = xi и Y = yI (i = 1, 2, ..., n; I = 1, 2, ..., m).
Понятие независимости случайных величин распространяется на любое конечное число случайных величин.
Случайные величины, которые рассматривались ранее, называются еще одномерными. В теории вероятностей рассматриваются еще, так называемые двумерные, трехмерные и вообще многомерные случайные величины.
Определение. Случайная величина называется двумерной, если все значения ее имеют вид (xi, yI), причем 1
i n, 1 I m. Событие, заключающееся в том, что двумерная величина примет значение (xi,yi), означает произведение двух событий:
1) случайная величина X примет xi;
2) случайная величина Y примет значение yi. Вероятность этого события обозначим piI: piI = = P(X = xi; Y = yi). Совокупность всех пар значений (xi, yi) и соответствующих им вероятностей piI составляет закон распределения двумерной случайной величины.
Обозначим через P (Y=yi) условную вероятность того, что X=xi случайная величина Y примет значение yi относительно события, состоящего в том, что случайная величина X приняла значение xi. По определению эту вероятность считаем равной:
Пример 1. Известны результаты стрельб для 2-х стрелков при 3-ч выстрелах: X - число попаданий первого стрелка, Y - число попаданий второго стрелка.
| xi | 1 | 2 | 3 | yi | 1 | 2 | 3 | ||||||||
| pi | 0.3 | 0.2 | 0.5 | pi | 0.1 | 0.6 | 0.3 |
Найти среднее число попаданий каждого стрелка и среднее квадратическое отклонение этих случайных величин.
Решение
По формуле для вычисления математического ожидания
определяем математическое ожидание каждого стрелка M(X) и M(Y). Математические ожидания показывают среднее число попаданий каждого стрелка и сравним их.По формуле
находим дисперсии, а затем и средние квадратические отклонения.
Сравнив их, выясним который из стрелков получает лучший результат при стрельбе.
Программа
Program
Two_dimensional_aleatory_variables1;
uses WinCrt;
Const
k = 10;
Type
t = array[1..k] of real;
var
Px , Py : t;
MX, MY, DX, DY : real;
n, m, i : integer;
begin
write('Введите число выстрелов первого стрелка '); readln(n);
write('Введите число выстрелов второго стрелка '); readln(m);
writeln;
writeln('Вводите вероятности попаданий первого стрелка');
MX := 0;
for i := 1 to n do
begin
write('Вероятность попадания при ', i, '-ом выстреле ');
readln(px[i]);
MX := MX + i*px[i]
end;
writeln('Среднее число попаданий первого стрелка ', MX:2:4);
writeln;
writeln('Вводите вероятности попаданий второго стрелка');
MY := 0;
for i := 1 to m do
begin
write('Вероятность попадания при ', i, '-ом выстреле ');
readln(py[i]);
MY := MY + i*py[i]
end;
writeln('Среднее число попаданий второго стрелка ', MY:2:4);
writeln;
DX := 0;
for i := 1 to n do DX := DX + sqr(i - MX)*px[i];
DY := 0;
for i := 1 to m do DY := DY + sqr(i - MY)*py[i];
if sqrt(DX) < sqrt(DY)
then writeln('Первый стрелок стреляет лучше')
else
if sqrt(DX) > sqrt(DY)
then writeln('Второй стрелок стреляет лучше')
else writeln('Стрелки стреляют с одинаковой точностью')
end.
Пример 2. По данным задачи 1 найти ряд распределения случайной величины Z, равной а) X + Y; б) 5X + 3Y.
Определить в каждом случае математическое ожидание и дисперсию.
Решение
а) Для нахождения значений Z можно воспользоваться матрицей сумм значений X и Y.
|
X\Y |
1 |
2 |
3 |
|
1 |
(1 + 1) |
(1 + 2) |
(1 + 3) |
|
2 |
(2 + 1) |
(2 + 2) |
(2 + 3) |
|
3 |
(3 + 1) |
(3 + 2) |
(3 + 3) |
Procedure Sum(n, m : integer; x, y : t; var zz : t);
var
i, I, k : integer;
begin
k := 0;
for i := 1 to n do
for I := 1 to m do
begin
k := k + 1;
zz[k] := x[i] + y[I]
end
end;
В результате получаются значения Z, среди которых будут повторяющиеся (2, 3, 3, 3, 4, 5, 4, 5, 6).
Необходимо выбрать только различные значения суммы Z = X + Y.
Это можно выполнить с помощью процедуры, которая детально рассматривается в главе "Задачи с массивами чисел".
{ Процедура отбора различных элементов в массиве Z }
Procedure Different(n, m : integer; var z : t; var k : integer);
label 1;
var
i, I : integer;
begin
k := 0;
for i := 1 to n*m do
begin
for I := 1 to k do
if z[i] = z[I] then goto 1;
k := k + 1;
z[k] := z[i];
1: end
end;
Получим, для нашего примера, что Z может принимать значения 2, 3, 4, 5, 6. Определим вероятности, учитывая, что X и Y независимы.
P(Z = 2) = P(X = 1)P(Y = 1);
P(Z = 3) = P(X = 1)P(Y = 2) + P(X = 2)P(Y = 1);
P(Z = 4) = P(X = 1)P(Y = 3) + P(X = 2)P(Y = 2) + P(X = 3)P(Y = 1);
P(Z = 5) = P(X = 2)P(Y = 3) + P(X = 3)P(Y = 2);
P(Z = 6) = P(X = 3)P(Y = 3);
В результате получаем ряд распределения вероятностей.
Используя свойства математического ожидания и дисперсии и результаты примера 1, находим M(Z) = M(X) + M(Y); D(Z) = D(X) + D(Y).
Программа
Program Problem2;
uses WinCrt;
const
p = 20;
type
t = array[1..p] of integer;
tt = array[1..p] of real;
var
x, y, z : t;
px, py, pz : tt;
n, m, k, n1, i : integer;
MX, MY, MZ, DX, DY, DZ : real;
{-----------------------------------------------------------------------------------------------}
{ Процедура суммирования значений X и Y и получение Z }
Procedure Sum(n, m : integer; x, y : t; var z : t);
var
i, I, k : integer;
begin
k := 0;
for i := 1 to n do
for I := 1 to m do
begin
k := k + 1;
z[k] := x[i] + y[I]
end
end;
{-----------------------------------------------------------------------------------------------}
{ Процедура отбора различных элементов в массиве Z }
Procedure Different(n, m : integer; var z : t; var k : integer);
label 1;
var
i, I : integer;
begin
k := 0;
for i := 1 to n*m do
begin
for I := 1 to k do
if z[i] = z[I] then goto 1;
k := k + 1;
z[k] := z[i];
1: end
end;
{-----------------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите число стрелков '); readln(n1);
write(' Введите число выстрелов, сделанных первым стрелком '); readln(n);
write('Введите число выстрелов, сделанных вторым стрелком '); readln(m);
writeln('Вводите вероятности попаданий первого стрелка');
MX := 0;
for i := 1 to n do
begin
write('Вероятность попадания при ', i, '-ом выстреле ');
readln(px[i]);
MX := MX + i*px[i]
end;
writeln(' Среднее число попаданий первого стрелка ', MX:2:4);
writeln;
writeln('Вводите вероятности попаданий второго стрелка');
MY := 0;
for i := 1 to m do
begin
write('Вероятность попадания при ', i, '-ом выстреле ');
readln(py[i]);
MY := MY + i*py[i]
end;
writeln('Среднее число попаданий второго стрелка ', MY:2:4);
writeln;
DX := 0;
for i := 1 to n do DX := DX + sqr(i - MX)*px[i];
DY := 0;
for i := 1 to m do DY := DY + sqr(i - MY)*py[i];
MZ := MX + MY; DZ := DX + DY;
writeln('Искомый ряд распределения вероятностей');
for i := 1 to
n do
begin
x[i] := i;
y[i] := i
end;
Sum(n, m , x, y, z);
Different(n, m, z, k);
for i := 1 to k do write(z[i]:4, ' '); writeln;
pz[1] := px[1]*py[1];
pz[2] := px[1]*py[2] + px[2]*py[1];
pz[3] := px[1]*py[3] + px[2]*py[2] + px[3]*py[1];
pz[4] := px[2]*py[3] + px[3]*py[2];
pz[5] := px[3]*py[3];
for i := 1 to k do write(pz[i]:2:2, ' '); writeln;
writeln('Математическое ожидание равно ', MZ:2:4);
writeln('Дисперсия равна ', DZ:2:4)
end.
Форматированный вывод информации
Если вы выполните программу, то столкнетесь с неприятным явлением - результат, т.е. числовые значения корней, будут выдаваться на экран в экспоненциальной форме.Так, после ввода значений коэффициентов: 2 3 -10, на экран будет выдан результат:
Уравнение имеет два различных корня
x1 = -3.1084952830E+00 x2 = 1.6084952830E+00
Во-первых, такой результат неудобно читать и запоминать, во-вторых, нам не всегда нужна высокая точность вычисления и, в-третьих, даже целые значения корней будут выдаваться тоже в экспоненциальной форме, что уже совсем неудобно.
Чтобы избежать всех этих неприятностей, можно использовать форматированный вывод информации.
В Турбо-Паскале предусмотрен вывод данных с форматами. В общем случае формат имеет следующий вид:
r:f1:f2
Здесь r - имя переменной, значение которой выводится (в данном случае - x1 или x2), формат f1 указывает, сколько позиций нужно для всего числа, включая знак числа, целую часть, точку и дробную часть числа; f2 - число позиций дробной части числа (после точки).
Если формат указан, то значение переменной r выводится в виде константы с фиксированной запятой, например: 12.35, .123. Если параметры f1 и f2 опущены, то вещественная переменная выводится в виде константы с плавающей запятой, например: 2.534E03, 5.67E-12 и т.п. В этом случае значения f1 и f2 устанавливается по умолчанию.
Надо вообще заметить, что вещественное число в формате с фиксированной точкой печатается так:
несколько пробелов; знак минус (-) или пробел; последовательность цифр (целая часть); точка; последовательность цифр (дробная часть).
Рассмотрим несколько примеров форматированного вывода результатов для вещественных переменных.
Пример. Пусть переменная r получает значение частного от деления вещественных переменных a на b.
Составим небольшую программу и выполним ее несколько раз, устанавливая различные значения для форматированного вывода результата.
Program Problem;
uses WinCrt;
var
a, b, r : real;
begin
write('Введите значение переменной a '); readln(a);
write('Введите значение переменной b '); readln(b);
r := a/b;
writeln('Результат равен ', r)
end.
При первом выполнении программы не устанавливайте параметров для форматированного вывода. Вы получите результат в форме с плавающей запятой. При следующем выполнении для a введите значение 1, для b 3, а для вывода результата установите следующий формат: r:6:2; затем, r:1:5; r:0:4 и т.п.
Форматированный вывод возможен и для переменных целого типа, но в этом случае нужен только один параметр:
r:f1
Если значение формата f1 больше, чем необходимое число позиций для записи числа, то перед числом добавляется соответствующее число пробелов. Если значение f1 меньше, оно автоматически увеличивается до числа позиций, необходимого для вывода числа.
Изменим в программе две строки вывода информации:
writeln('Уравнение имеет один корень ', -b/(2*a):6:3) и
writeln('x1 = ', x1:6:3, ' x2 = ', x2:6:3)
Теперь понятно, что для выводимых результатов отведено 6 позиций, а для дробной части - 3 позиции, т.е. до тысячных долей (думается этого достаточно для школьных задач).
Формула Бернулли
Схема повторных независимых испытаний.Рассмотрим опыт, который состоит в том, что испытания повторяются многократно, причем выполнены следующие условия:
1) все испытания независимы друг от друга, т.е. вероятность появления события А в каждом из них не зависит от того, произошло или не произошло рассматриваемое событие в других опытах;
2) каждое испытание имеет только два исхода:
а) событие А произошло; б) событие А не произошло;
3) вероятность появления события А в каждом испытании постоянна и равна p, а следовательно, вероятность не появления события А равна q = 1 - p.
Так как в каждом из n проводимых испытаний событие А может произойти или не произойти, то полученная схема повторных независимых испытаний содержит 2n точек.
Примерами повторных независимых испытаний с двумя исходами могут служить:
1) многократное подбрасывание монеты;
2) стрельба по цели n раз одиночными выстрелами, если нас интересует только попадание или промах;
3) массовый контроль деталей, при котором требуется только установить, какой является деталь, стандартной или нестандартной.
Некоторые задачи, описываемые по такой схеме, можно решить, используя формулу для непосредственного подсчета вероятностей или теореме о вероятности суммы и вероятности произведения событий. Однако, проще воспользоваться формулой Бернулли. Пусть необходимо вычислить вероятность появления события А ровно m раз при проведении n повторных независимых испытаний.
Вероятность появления события А равна p, а вероятность не появления события А равна q, тогда вероятность появления события А ровно m раз при проведении n независимых испытаний равна:
(m = 0, 1, 2, ..., n).Эту формулу называют формулой Бернулли.
Пример 4. Известно, что при каждом взвешивании равновозможна как положительная, так и отрицательная ошибка. Какова вероятность того, что при пяти взвешиваниях получатся три положительные ошибки?
Математическое решение задачи
Проводится 5 независимых испытаний с двумя исходами, причем в каждом испытании p = q = 0,5.
Тогда по формуле Бернулли вероятность появления трех положительных ошибок равна:
.Алгоритм
составления программы
Надо использовать не только процедуру вычисления числа сочетаний из n элементов по m, но и процедуру вычисления степени заданного вещественного числа a. Эта процедура нам знакома из предыдущего занятия.
Программа
Program Problem4;
uses WinCrt;
var
s1 : longint;
p, st, st1 : real;
{----------------------------------------------------------------------------------------}
Procedure combination(n, k : integer; var s : longint);
var
i : longint;
begin
s := 1;
if k = 0 then s := 1
else for i := 1 to n - k do s := s*(k + i) div i
end;
{----------------------------------------------------------------------------------------}
Procedure extent(a : real; n : integer; var q : real);
var
i : integer;
begin
q := 1;
for i := 1 to n do q := a*q
end;
{----------------------------------------------------------------------------------------}
begin
combination(5, 3, s1);
extent(0.5, 3, st);
extent(0.5, 2, st1);
p := s1*st*st1;
writeln('Искомая вероятность равна ', p:6:4)
end.
Формы записи вещественных чисел
В математике На Паскале1. Естественная форма записи
135; 89245; -2,356; 0,28; 135; 89245; -2.356; 0.28
Как видите, отличие заключается в том, что вместо запятой используется точка.
2. Экспоненциальная форма записи или форма записи с плавающей запятой
3,7
105; 1,6710-12 3.7E05; 1.67E-12. При такой записи, множитель, стоящий перед степенью с основанием 10 называется мантиссой, а показатель степени десятки - порядком числа.
В наших примерах: 3.7 и 1.67 - мантиссы, а 5 и -12 - порядки чисел.
Мантисса может иметь 11...12 значащих цифр, а порядок от -39 до 38. (Это в Турбо Паскале версии 7.0 и Barland Pascal.)
Функции
Язык программирования Паскаль допускает введение в программу функции, определяемой пользователем. Она помещается в разделе описаний основной программы.Запись функции начинается так:
Function
<имя> (<список формальных параметр.>) : <тип рез.>
var
<описание переменных, участвующих в работе функции>
Дальнейшее построение такое же, как и во всех других программах на языке Паскаль.
begin
<операторы>
<имя> := <результат>
end;
Обязательной
является команда присваивания имени функции результата, полученного в итоге ее работы. Функция может быть использована несколько раз в программе.
Для ее вызова достаточно указать имя функции и задать значение формальных параметров: <имя> (<значение параметров>).
Например: s(2, 3) или s(n, a). Параметры и переменные функции могут иметь те же имена, что и переменные в основной программе.
Снова обратимся к наиболее типичным примерам, создаваемых функций. Как вы смогли уже убедиться, их конструкция мало чем отличается от процедур, да и существует возможность обратных преобразований функций в процедуру и процедур в функции.
Известный ряд чисел Фибоначчи имеет вид:
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
Каждый член этой последовательности, начиная с третьего, равен сумме двух предыдущих членов.
Если первый член последовательности обозначить f1, второй -
тогда можно составить такую зависимость: 
Пользуясь такой зависимостью, можно получить все члены последовательности чисел Фибоначчи.
Формулу, выражающую любой член последовательности, начиная с некоторого, через предыдущие (один или несколько), называют рекуррентной (от латинского слова recurro - возвращаться).
Зная зависимость между последующим и предыдущими членами, легко создать рекурсивную функцию, позволяющую найти n-е число ряда Фибоначчи:
Function fib(n : integer) : longint;
begin
if (n = 1) or (n = 2) then fib := 1
else fib := fib(n - 1) + fib(n - 2)
end;
Здесь, мы одновременно проследим и построение функции и рекурсии.
В заголовке указывается зарезервированное слово Function, далее пишется по фантазии пользователя ее имя, удовлетворяющее всем требованиям, предъявляемым к идентификаторам.
В скобках описываются, как и в процедурах, входные параметры, заметьте, в функции есть только входные параметры, в качестве выходного значения используется сама функция, поэтому обязательно указывается ее тип.
И вот теперь ее имя fib может быть использовано в программе, наряду со встроенными функциями, в различных операторах и арифметических вычислениях.
Построение самой функции начинается, как и построение любой другой программы, но обязательно надо присваивать конечное значение самой функции: fib.
Function fib(n : integer) : longint;
var
f, f1, f2, i : integer;
begin
f1 := 1; f := 0;
for i := 1 to n do
begin
f2 := f1; f1 := f;
f := f1 + f2;
end;
fib := f
end;
Конечно, удобно составлять программу, когда все члены ряда вычисляются по одному правилу, но в ряде Фибоначчи выпадают из общего правила два первых члена. Если мы хотим вычислить и их по тому же правилу, тогда следует в функции fib искусственно продолжить ряд влево, пополнив его двумя фиктивными членами: f(-1) = 1 и f(0) = 0. Тогда ряд примет следующий вид:
1 0 - фиктивные члены ряда
1 1 2 3 5 ... - подлинные члены ряда.
При наличии этих двух фиктивных членов все подлинные члены ряда вычисляются по тем же правилам.
Работу этой функции понять несложно, поэтому мы не будем останавливаться на детальном разборе ее работы.
Можно составить функцию для вычисления чисел Фибоначчи используя рекурсию, тогда она будет выглядеть более компактной:
Function fib(n : integer) : integer;
begin
if (n = 1) or (n = 2) then fib := 1
else fib := fib(n - 1) + fib(n - 2)
end;
Однако, несмотря на внешнюю изысканность, эта функция крайне неэффективна.
Давайте детально проследим за ходом ее работы.
Когда n = 1 или n = 2, получаем значение функции, выполнив функцию один (первый) раз.
Когда n = 3, выполняется вторая (else) ветвь условного оператора и значение функции находится из выражения fib(2) + fib(1).
Для того, чтобы вычислить значение выражения, следует еще два раза (рекурсивно) обратиться к функции fib.
Когда n = 4, функция будет выполняться пять раз, а когда n = 5 - девять раз.
fib(4) fib(5)fib(3) fib(2) fib(4) fib(3)
fib(2) fib(1) fib(3) fib(2) fib(2) fib(1)
fib(2) fib(1)
Таким образом, при возрастании значения параметра функции очень быстро возрастает и число обращений к функции, а тем самым увеличивается время вычисления. Это происходит от того, что вторая рекурсивная ветвь условного оператора содержит сразу два рекурсивных вызова. Поэтому эта рекурсивная функция служит примером очень часто встречаемых неэффективных рекурсивных функций.
Часто, внешняя любезность рекурсии оборачивается большими неприятностями.
Приведем и другой способ вычисления членов ряда Фибоначчи с помощью с помощью функции, построенной итеративно. Для ее построения возможны два способа.
Пример 1
Первый способ
Function
Fib(n: integer):longint;
var
f1, f2, f : longint;
i : integer;
begin
f2 := 1; f := 1;
if (n = 1) or (n = 2) then f := 1
else
for i := 3 to
n do
begin
f1 := f2; f2 := f
f := f1 + f2;
end;
fib := f
end;
Второй способ
Function fib(n : integer) : integer;
var
f, f1, f2, i : integer;
begin
f1 := 1; f := 0;
for i := 1 to n do
begin
f2 := f1; f1 := f;
f := f1+f2;
end;
fib := f
end;
Полностью программа:
Program Problem1;
uses WinCrt;
var
i, n : integer;
{----------------------------------------------------------------------------------------}
Function fib(n : integer) : integer;
var
f, f1, f2, i : integer;
begin
f1 := 1; f := 0;
for i := 1 to n do
begin
f2 := f1; f1 := f;
f := f1 + f2;
end;
fib := f
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение n '); readln(n);
writeln('Числа Фибоначчи');
for i := 1 to n do write(fib(i), ' ');
writeln
end.
Пример 2.
Последовательность (an) задается так:
- сумма цифр квадрата числа 
плюс 1. Постройте эту последовательность и найдите 
Решение
При построение членов последовательности нам придется находить сумму цифр числа. Поэтому есть смысл составить функцию, которая определяет сумму цифр числа. Эта функция может быть построена так:
Function
Sum(a : integer) : integer;
var
s : integer;
begin
s := 0;
repeat
s := s + a mod 10;
a := a div 10
until a = 0;
Sum := s
end;
Вторая функция - это функция, с помощью которой можно получить любой член последовательности:
Function Succ(n : integer) : integer;
var
a, i : integer;
begin
a := 7;
for i := 2 to n do
a := Sum(a*a) + 1;
Succ := a
end;
Полностью программа может быть построена так:
Program Succession; { succession - последовательность }
uses WinCrt;
var
a, i, n : integer;
{----------------------------------------------------------------------------------------}
Function Sum(a: integer): integer;
var
s: integer;
begin
s:=0;
repeat
s := s + a mod 10;
a := a div 10
until a = 0;
Sum := s
end;
{----------------------------------------------------------------------------------------}
Function Succ(n : integer): integer;
var
a, i : integer;
begin
a := 7;
for i := 2 to n do
a := Sum(a*a) + 1;
Succ := a
end;
{----------------------------------------------------------------------------------------}
begin
write(' Введите число членов последовательности ');
readln(n);
for i := 1 to n do write(Succ(i), ' ');
writeln
end.
Функция random и процедура randomize
Функция random генерирует случайное вещественное число из промежутка
Значения функции random имеют тип real.Возникает естественный вопрос, а как выработать случайное вещественное число из произвольного промежутка [a; b]?
Для этого надо умножить случайное число из промежутка [0; 1], т.е. значение функции random, разность b - a и прибавить левую границу промежутка - a.
Случайное вещественное число из промежутка [a; b] получается от умножения значения функции random на разность b-a и прибавления к результату левой границы промежутка - числа a: random*(b - a) + a
Например, для получения случайного вещественного числа из промежутка
надо длину промежутка 15-(-6)=21 умножить на значение функции random и прибавить -6: random*21-6, а для получения случайного вещественного числа из промежутка [0; 100] надо значение random умножить на 100: random*100.
Функция random(x), где x - целое число (тип: integer), выдает случайное целое число из промежутка [0; x). Значения функции random(x) имеют тип integer.
Например, значением функции random(6) является случайное целое число из промежутка [0; 6) или из [0; 5].
Как с помощью этой функции получить случайное целое число из промежутка [a; b], где a и b целые числа? Это можно сделать с помощью функции:
Например, случайное целое число из промежутка [15; 18] задается функцией:
random(4)+15.
Есть одна особенность в использовании функций случайных чисел или, как еще их называют, генераторов случайных чисел. При повторном обращении к ним, они могут повторять предыдущие значения. Чтобы избежать этого неприятного явления, перед их применением надо использовать процедуру инициализации этого генератора случайных чисел. Такая процедура есть. Ее имя randomize.
Процедура randomize инициализирует датчик случайных чисел random.
Итак, перед использованием в программе датчика псевдослучайных чисел random в программу надо включать процедуру randomize, которая инициализирует датчик случайных чисел.
Пример 1.
На стержне AB, длина которого равна 36 см, нанесена наудачу тонкая риска. Какова вероятность того, что эта риска окажется не далее a от конца A или не далее b от середины стержня: 1) a = 6 см, b = 2 см; 2) a = 12 см, b = 10 см?
Алгоритм
Числовую ось OX расположим так, что ее начало совпадает с левым концом отрезка - точкой A. Тогда нанесение риски на стержень будет означать случайный выбор значения X из промежутка [0; 36] и задаваться следующим равенством:
x := random*36.
Риска должна быть не далее a от начала отрезка, т. е. значения x должно удовлетворять неравенству (см. рис. 30):
Не далее b от середины отрезка означает, что
Надо подсчитать количество значений x, удовлетворяющих неравенствам:
Пусть их число равно m, а общее число "брошенных" на отрезок точек - n. Тогда искомая вероятность будет равна: p = m/n.
Рис. 30
Для определения точности вычисления вероятности, которая равна частости появления события (m/k), а отсюда и числа испытаний, можно воспользоваться способом, который уже применялся при изучении интегральной формулы Муавра-Лапласа.
В зависимости от гарантированной вероятности и точности вычисления можно установить необходимое число испытаний - n, а затем, по числу испытаний рассчитать вероятность.
Возможность применения формулы Муавра-Лапласа к решению геометрической задачи методом Монте-Карло дает следующие обстоятельства.
Испытания, т.е. "бросание" точек, независимы и равновозможны. Вероятность наступления события в каждом испытании постоянна и отлична от нуля и единицы, а число испытаний может быть достаточно велико.
Таким образом, все условия для применения формулы Муавра-Лапласа выполнены. А теперь вспомним пример, в котором находится число испытаний в зависимости от заданной вероятности и точности вычисления.
Для этого можно использовать процедуры и функции из раздела "Интегральная формула Муавра-Лапласа" (в частности, в примере 6).
Вероятность некоторого события хотят установить статистически.
Для этого проводят некоторое количество испытаний, и частость появления события принимают за его вероятность. Сколько надо произвести испытаний, чтобы с вероятностью 0.97 можно гарантировать, что вероятность события в одном испытании будет отличаться от частости полученной из опыта, не более, чем на 0.01?
Одна из идей, которыми можно воспользоваться и реализовать программными средствами, состоит в том, чтобы непосредственным подбором числа n найти его искомое значение.
Для этого достаточно организовать цикл, завершающим условием которого является:
где PP - гарантированная вероятность, FF(x) - значение функции Муавра-Лапласа. Чтобы найти x нужно воспользоваться соотношением: x := 2*e*sqrt(n).
В результате можно составить следующую процедуру:
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until
FF(x) >= PP
end;
Основываясь на этой процедуре составим программу.
{ Применение интегральной формулы Муавра-Лапласа }
Program Problem6;
uses WinCrt;
var
n : longint;
e, pp : real;
{-------------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function
FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{-------------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{-------------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления частости '); readln(e);
NumberExperiment(e, PP, n);
writeln('Число испытаний равно ', n );
writeln('С точностью до ', e:1:8)
end.
Используя процедуры из предыдущей программы, составим программу решения геометрической задачи. Надо сразу заметить, что точность вычисления будет невысокой. При увеличении точности даже с гарантированной вероятностью 0.97, не говоря уже о вероятности 0.99, резко возрастает число испытаний и программа становится трудоемкой для выполнения.
Программа
Program Problem1;
uses WinCrt;
var
x, a, b, p, e, pp : real;
i, n, m : longint;
{----------------------------------------------------------------------------------------}
{ Интегральная функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите расстояние a от конца стержня '); readln(a);
write('Введите расстояние b от середины стержня '); readln(b);
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random*36;
if (x <= a) or (abs(18 - x) <= b) then m := m + 1;
end;
p := m/n;
writeln('Вероятн. появления риски в заданном месте ',p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Пример 2. На отрезке AB длины l независимо друг от друга выбираются наудачу две точки M и N. Какова вероятность того, что точка M окажется ближе к точке A, чем точка N?
Алгоритм
Пусть |AM| = x, |AN| = y. Рассматриваемому событию будут благоприятствовать лишь те точки, которые удовлетворяют условию y>x. Множество всех возможных исходов испытания можно изобразить в виде квадрата, сторона которого равна l (см. рис. 31).
Рис. 31
Множество исходов испытания, благоприятствующих рассматриваемому событию, геометрически изображается точками заштрихованного треугольника.
Координаты всех точек этого треугольника удовлетворяют неравенству: y>x.
Программа
Program Problem2;
uses WinCrt;
var
x, y, p, e, pp : real;
i, n, m : longint;
{--------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function
FF(x : real) : real;
var
n : integer; u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u; n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random;
y := random;
if y > x then m := m + 1
end;
p := m/n;
writeln('Искомая вероятность равна ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Функциональные ряды
Функциональным рядомназывается выражение
где 
(члены ряда) - суть функции одного и того же аргумента x, определенные в некотором промежутке (a, b). Примеры
функциональных рядов.
Функции можно разложить в ряды
1. Показательная функция:
на множестве всех действительных чисел R, т. е. на промежутке от
до 
.2. Тригонометрические функции.
на множестве всех действительных чисел R.
на множестве R.
на промежутке [-1, 1].
Из этого ряда при x = 1 получается знаменитый ряд Лейбница
- первый ряд, дающий разложение числа
. Для вычисления числа
есть еще много других рядов. Вот некоторые из них, которые дают более быстрое приближение к числу : a)
б) ряд Леонардо Эйлера:
3. Логарифмическая функция
на промежутке (-1, 1).
4. Разложение бинома в ряд или биномиальный ряд:
на промежутке (-1, 1), где m - любое вещественное число, отличное от 0 и от всех натуральных чисел (при натуральном m получается известное разложение по формуле Ньютона - бином Ньютона).
Вы уже знакомы с последовательностями, которые задавались формулами n-го члена этих рядов и находили члены этих последовательностей. Это обстоятельство упростит нам процесс составления программ суммирования рядов.
Совершенно ясно, что с помощью этих рядов можно вычислять значения соответствующих функций.
Возникает следующий вопрос. Как оценить точность, с которой надо найти значение функции?
Математика также дает на этот вопрос ответ.
Пусть требуется вычислить значение функции ex с точностью до eps, где eps любое положительное число (в частности, eps может быть равно 0,1, 0,01, 0,001, 0,0001 и т.д.).
Для вычисления ex с заданной степенью точности eps необходимо n членов ряда, тогда можно записать, что приблизительно
Оставшиеся члены ряда можно обозначить rn(x) и назвать остатком ряда или остаточным членом, или дополнительным членом.
Чему равен этот остаточный член? Совершенно очевидно, что он по абсолютной величине будет меньше или равен заданной точности вычисления, т.е.
числу eps,
Поэтому по абсолютной величине остатка rn(x) можно определять точность вычисления exс помощью данного ряда.
Можно записать, что
Математика дает несколько формул дополнительного члена различных рядов. Для этого ряда дополнительный член может быть
записан в следующем виде:
, где 
зависит от n и находится в промежутке (0, 1), 0 < < 1. При x>0 погрешность по этой формуле оценивается так:
В частности, при x = 1,
где 
Подумайте, почему в числителе дроби дополнительного члена оказалось число 3?
С помощью этой формулы можно с большой степенью точности вычислить число e.
Пример 1. Составим программу вычисления числа e по этой формуле.
Прежде найдем рекуррентную формулу, связывающую предыдущий и последующий члены ряда.
Это сделать нетрудно:
отсюда получим, 
Алгоритм
1. Начало.
2. Установить переменные и их типы.
Переменная n будет участвовать в получении членов ряда и должна иметь целый тип (integer).
Переменная eps задает точность, с которой подсчитывается сумма ряда, т.е. значение числа e. Она имеет вещественный тип.
Нужна переменная, в которую будут последовательно заноситься члены ряда. Эту переменную обозначим u. Она будет иметь вещественный тип.
И, наконец, переменная e - результат вычисления, т.е. сумма ряда имеет вещественный тип.
3. Основная программа, в которой вычисляется сумма членов ряда.
1). Ввод пользователем точности, с которой должно быть вычислено значение e. Оно присваивается переменной eps.
2). Для вычисления суммы ряда организуем цикл с последующим условием. Перед началом цикла установим переменным n и u первоначальные значения, которые равны 1, а переменной e - значение 0 (ведь в переменной e будет накапливаться сумма членов ряда).
3). В цикле подсчитывается сумма, "вырабатывается" следующий член ряда и увеличивается значение n на единицу.
4). Условие в конце цикла должно связывать заданную точность вычисления - eps и остаток ряда
Подумайте, как оно должно быть записано? 5). Вывод информации.
4. Конец.
Программа
Program
Problem1; {Вычисление числа e}
uses WinCrt;
var
n : integer;
e, u, z, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
write('Задайте точность вычисления '); readln(eps);
e := 0; u := 1; n := 1;
repeat
e := e+u;
u := u/n; n := n+1
until 3*u <= eps;
write('Число e равно ', e:3:t(eps));
writeln(' с точность до ', eps:1:t(eps))
end.
Задание 1
Вы уже знаете, что значения sinx можно вычислять с помощью следующего ряда:
где погрешность оценивается легко: 
Так как ряд знакочередующийся, то его остаток меньше по абсолютной величине последнего "отброшенного" члена, т. е. n + 1 - го.
Составьте программу вычисления значений sinx с заданной степенью точности eps для различных, вводимых пользователем значений x.
Пример 2. С помощью биномиального ряда, в который разлагается двучлен
можно не только возводить двучлены в любую степень, но и извлекать корни с любым вещественным показателем. Надо лишь помнить, что значения x принадлежат промежутку (-1, 1), на котором рассматривается биномиальный ряд.
Для примера посмотрим, как вычислить значение корня кубического из числа 10, т.е.
. Прежде надо преобразовать подкоренное выражение к виду
где |x| <1. Для этого достаточно подобрать число, куб которого близок к числу 10. Таким числом является 2, так как 23=8, и тогда
преобразуем так: 
Полученное выражение можно разложить в биномиальный ряд и вычислить с любой степенью точности.
Осталось выяснить вопрос относительно оценки точности вычисления с помощью дополнительного члена. Для этого снова обратимся к разложению и его остатку.
Этот ряд также знакочередующийся, значит остаток по абсолютной величине меньше абсолютной величины n + 1 - го члена.
Нетрудно найти рекуррентную формулу для получения членов этого ряда.
Она будет такой:
Теперь составим программу для вычисления корней с помощью этого ряда.
Программа
Program Problem2;
uses WinCrt;
var
n : integer;
x, m, z, eps, u, b : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение x, |x|<1 '); readln(x);
write('Введите значение дробного показателя m '); readln(m);
write('Задайте точность вычисления '); readln(eps);
b := 1; u := 1; n := 1;
repeat
u := (m - n + 1)*x*u/n;
b := b + u;
n := n+1
until abs(u) <= eps;
writeln('Корень', 1/m:3:0, ' - й степени из ', (1 + x):3:t(eps));
writeln(' равен ', b:3:t(eps),' с точностью до ', eps:3:t(eps))
end.
Задание 2
Составьте программу, которая вычисляет значение числа
с заданной степенью точностипри помощи ряда Лейбница:
Геометрические вероятности "геометрическая схема" испытания
"Классическая схема", основанная на понятии равновозможности конечного числа исходов испытания, при изучении большинства явлений реального мира является недостаточной. На практике часто встречаются такие испытания, исходы которых, как правило, являются или неравновозможными, или их число бесконечно.Так, если испытание состоит в том, что сигнальщик в течение часа должен принять мгновенный световой сигнал, то его возможными исходами можно считать появление сигнала в любой момент времени в течение этого часа. Если испытание состоит в том, что разведчик должен нарушить линию связи длиной 2 км, то возможными исходами этого испытания можно считать разрыв линии связи в любой точке.
Множество исходов таких и аналогичных им испытаний бесконечно. Оно может быть иллюстрировано геометрически в виде совокупности точек отрезка прямой, плоской фигуры или пространственного тела. В связи с этим такую схему испытания принято называть геометрической схемой.
Вероятности, вычисляемые как отношения мер. Пусть в результате испытания наудачу выбирается точка в области S. Требуется найти вероятность того, что эта точка окажется в области s, являющейся частью области S.
Как указывалось в первом пункте, мы будем рассматривать области одного, двух и трех измерений. Так как число возможных исходов таких испытаний и число исходов, благоприятствующих рассматриваемым событиям, бесконечно, то формулу для непосредственного подсчета вероятностей применять нельзя.
Введем следующее допущение. Пусть исходы испытания распределены равномерно. Это значит, что если разделить некоторую область S на конечное число равновеликих частей si, (i= 1, 2, 3, ..., n), то событие Ei, означающее попадание наудачу выбранной точки из области S в любую область si ее часть, равновозможны, т.е. можно считать, что вероятность попадания наудачу выбранной точки из области S в какую-либо часть s этой области пропорциональна мере это части и не зависит от расположения и формы.
Следовательно,
где
- вероятность того, что наудачу выбранная точка из области S окажутся в области s, а m(s) и n(s) есть меры соответствующих областей, выраженных в единицах длины, площади или объема. Прежде, чем перейти к рассмотрению примеров с использованием понятия геометрической вероятности рассмотрим стандартную функцию и процедуру, которые используются в Турбо Паскале.
Гипергеометрическое распределение
Биномиальное распределение вероятностей точно только при условии отбора изделий по схеме случайной повторной выборки.
На практике изделия для проверки отбираются по схеме случайной бесповторной выборки, т.е. изделия из партии отбираются каждый раз случайно, но отобранные изделия не возвращаются в партию.
Схема случайной бесповторной выборки приводит уже не к биномиальному, а к так называемому гипергеометрическому закону распределения.
Пример 1. В урне находится N шаров, из которых M белых. Пусть один за другим без возврата (или одновременно, что одно и то же) вынимается n
M) шаров. Тогда вероятность того, что среди этих вынутых n шаров будет m белых шаров, равна 
Для вычисления гипергеометрических вероятностей найдем рекуррентную формулу для вычислений. Здесь тем более могут получаться очень большие числа.
Логика рассуждений будет такая же, как и при нахождении подобной формулы для биномиального закона распределения.
отсюда получаем:
Для начального значения, при m = 0, находим:
Надо заметить, что если число изделий в партии велико, а число отобранных изделий составляет весьма малую долю всей партии, поэтому расчет вероятностей по формулам биномиального распределения дает достаточно хорошие приближения.
{ Гипергеометрический закон распределения вероятностей }
Program Problem1;
uses WinCrt;
var
p, s, s1, s2 : real;
nn, mm, n, m, k : longint;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа сочетаний из n элементов по k }
Procedure
Combination(n, k : integer; var s : real);
var
i : longint;
begin
s := 1;
if k = 0 then s := 1
else for i := 1 to n - k do s := s*(k + i)/i
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите число всех шаров в урне '); readln(nn);
write('Введите число всех белых шаров в урне '); readln(mm);
write('Введите число извлекаемых из урны шаров ');
readln(n);
writeln('Введите число белых шаров, вероятность');
write('получения которых Вы хотите найти '); readln(k);
Combination(nn, n, s); Combination(mm, k, s1);
Combination(nn - mm, n - k, s2);
p := (s1*s2)/s;
writeln;
writeln('Вероятность того, что среди вынутых ', n);
writeln('шаров будет ', k, ' белых шаров, равна ', p:1:6)
end.
Математическое ожидание гипергеометрического распределения равно
Дисперсия определятся формулой:
Арифметические операции
В языке Паскаль используются целые числа, к которым относятся все натуральные числа, образовавшиеся в процессе подсчета предметов: 1, 2, 3, 4, 5, 6, ...; отрицательные числа: ..., -6, -5, -4, -3, -2, -1 и число ноль: 0. Целые числа образуют следующий ряд:..., -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, ...
В Паскале допускается диапазон целых чисел от -32768 до 32767.
Переменные, принимающие целые значения, записываются в разделе описаний с указанием типа integer (целый).
Например: var a, b, c, a1, b34, nomb: integer;
Значения другого типа этим переменным в одной программе присвоить нельзя.
Числовые и функциональные ряды
Снова сделаем небольшую экскурсию в математику и познакомимся с числовыми и функциональными рядами.Определение. Пусть задана некоторая бесконечная последовательность чисел
Составленный из этих чисел символ или сумма
называется бесконечным рядом, а сами числа - членами ряда.
Вместо записи (2), пользуясь знаком суммы, можно записать так:
, где знак 
- сумма, 
- бесконечность; указатель n пробегает значения от 1 до Примеры
числовых рядов.
1. Простейшим примером бесконечного ряда является геометрическая прогрессия:
2.
3. Следующий ряд называется гармоническим:
4. Ряды могут быть не только с положительными членами, но и знакопеременными. Вот простейшие примеры таких рядов:
a)
б)
в)
г)
д)
.Числовые последовательности
Начнем с определения последовательности. Определений числовой последовательности дается много, причем самых разных и достаточно понятных, но, по моим соображениям, самое лучшее с точки зрения и математической строгости и доступности дается в книге: "Курс дифференциального и интегрального исчисления", т. 1 Г.М. Фихтенгольца. Я привожу его с незначительными изменениями.Представим себе натуральный ряд:
1, 2, 3, ..., n, ..., n', ...,
в котором числа расположены в порядке возрастания, так что большее число n' следует за меньшим числом n (или меньшее n предшествует большему числу n'). Если теперь заменить в этом ряде, по какому-нибудь закону каждое натуральное число n некоторым вещественным числом xn , то получится числовая последовательность:
x1, x2, x3, ..., xn, ..., xn', ...,
члены или элементы которой xn занумерованы всеми натуральными числами и расположены в порядке возрастания номеров. При n'>n, член xn' следует за членом xn (xn предшествует xn' ), независимо от того, будет ли само число xn' больше, меньше или даже равно числу xn.
В школьном курсе математики вы уже знакомились с последовательностями вида
- арифметическая прогрессия;или вида
- геометрическая прогрессия. В связи с определением длины окружности обычно рассматривается переменный периметр правильного вписанного в окружность многоугольника, получаемого из шестиугольника последовательным удвоением числа сторон; таким образом, получается следующая последовательность:
Упомянем еще о десятичном приближении (скажем, по недостатку) к
, со всё возрастающей точностью; оно принимает последовательность значений:
Иногда последовательность задается тем, что указывается непосредственно
выражение для xn; так, в случае арифметической или геометрической прогрессии имеем, соответственно,
или 
Пользуясь этим выражением, можно сразу вычислять любое значение элемента последовательности по заданному его номеру, не вычисляя предыдущих значений. В других случаях нам может быть неизвестно выражение для общего члена xn последовательности.
Тем не менее, последовательность считается заданной, если мы владеем правилом, по которому может быть вычислен любой ее член, лишь только известен его номер.
Поэтому-то, зная правило для приближенного вычисления корней, мы можем считать заданной всю последовательность десятичных приближений к
, хотя выражения для его общего члена мы не знаем. Можно сказать, что в этом случае последовательность задается "словесным описанием". Если последовательность - в указанном смысле - задана, то этим не только охарактеризовано все множество принимаемых ею значений в целом, но и определен порядок, в котором эти значения принимаются; каждому номеру отвечает свое значение элемента последовательности, и из двух значений то считается следующим, номер которого больше.
Еще подчеркнем, что значения элементов последовательности не должны быть обязательно различными. Например, если задать последовательность одной из формул:
то соответствующие последовательности будут:
В первом
случае мы имеем просто постоянную величину, всё "множество" принимаемых ею значений сводится к одному.
Во втором
- это множество состоит из двух значений, 1 или -1, принимаемых поочередно. Наконец, в третьем случае множество значений бесконечно, но это не мешает значениям элементов через одно равняться 0; и мы считаем, что значение 0 на пятом месте следует не только за 1 на втором месте, но и за значением 0 на первом месте.
Еще один способ задания последовательности - это рекуррентная формула. Вспомним, что это такое.
Формулу, выражающую любой член последовательности, начиная с некоторого, через предыдущие (один или несколько), называют рекуррентной
(от латинского слова recurro - возвращаться).
Подводя итог вышеизложенного можно назвать три основных способа задания последовательности.
1. Аналитический
- последовательность задается формулой общего (или n-го) члена.
2. Рекуррентный
- любой член последовательности, начиная с некоторого, выражается через предшествующие члены. При этом способе задания последовательности указывают ее первый член или несколько начальных членов и формулу, позволяющую определить любой член последовательности по известным предшествующим членам.
3. Словесный
- задание последовательности описанием.
Надо сразу заметить, что для составления программ чаще нам придется использовать рекуррентное соотношение. Покажем это на примере.
Пример 1. Составить программу вывода на экран членов последовательности, заданной следующей формулой:
Для составления программы необходимо перейти от формулы n-го члена, которым задана последовательность к рекуррентному соотношению, связывающему предыдущий член с последующим и указать начальное значение для первого или "нулевого" элемента. Как это сделать? Оказывается очень просто!
1. Запишем, чему будет равен член последовательности предыдущий к n - му, т. е. n-1 - й элемент последовательности:
2. Теперь разделим n - й элемент на n-1 - й, получим:
3. Отсюда выразим, чему будет равен n-й член:
4. Найдем начальное значение
Процедуру можно построить из одного цикла с параметром, в котором каждый раз при выполнении цикла предыдущее значение будет умножаться на 10 и делится на значение переменной цикла, которая обозначена n.
Procedure Create_succession(k : integer);
var
n : integer;
a : real;
begin
a := 1;
writeln('Искомая последовательность');
for n := 1 to k do
begin
a := a*10/n;
write(a:6:6, ' ')
end;
writeln
end;
Программа
Program Problem1; {Вывод членов последовательности}
uses WinCrt;
var
k : integer;
{---------------------------------------------------------------------------------------}
Procedure Create_succession(k : integer);
var
n : integer;
a : real;
begin
a := 1;
writeln('Искомая последовательность');
for n := 1 to k do
begin
a := a*10/n;
write(a:6:6, ' ')
end;
writeln
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите число элементов '); readln(k);
Create_succession(k);
end.
Пример 2. Составим программу вывода на экран членов последовательности, описываемой словесно, в частности, десятичных приближений числа
с недостатком. Вот здесь дело обстоит сложнее. Закон, по которому строится последовательность указан словесно. Надо от словесного задания правила перейти к рекуррентной формуле.
А есть ли формула для вычисления квадратных корней? Оказывается есть и достаточно простая.
Рассмотрим бесконечную последовательность x1, x2, x3, ..., образованную по следующему закону:
Оказывается, что члены этой последовательности с увеличением номера i всё меньше и меньше отличается от
(этот факт был известен Герону Александрийскому в 1 веке н. э.). Пусть, например, u = 2. Вычисление первых членов последовательности x1, x2, x3, ... дает нам 
Напомним, что
= 1.4142135... Мы можем, используя данное рекуррентное соотношение, составить процедуру и программу
вычисления квадратных корней для любого действительного подкоренного выражения, а не только 2.
Program Problem2;
uses WinCrt;
var
n : integer;
u : real;
{----------------------------------------------------------------------------------------}
Procedure Square_root(n : integer; u : real);
var
i : integer;
x : real;
begin
writeln('Десятичные приближ. с недост. кв. корня из ', u);
x := (u + 1)/2;
for i := 1 to n do
begin
x := (1/2)*(x + u/x);
write(x:3:i, ' ')
end;
writeln
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите подкоренное выражение '); readln(u);
write('Введите число членов последовательн. '); readln(n);
Square_root(n, u);
end.
Вычислим приближенное значение квадратного корня из заданного числа с указанной точностью eps. Теперь нам не надо выводить на экран все члены последовательности, а выдать только одно значение удовлетворяющее указанной точности.
Например, поставлена задача получить квадратный корень из 2 с точностью до 0.01. На экран должно быть выдано значение этого корня (причем совсем не обязательно, чтобы в его записи было два знака после запятой, их может быть больше, но мы будем заведомо знать, что знаки после сотых долей не являются точными).
Такие программы
можно составить двумя способами.
Способ первый состоит в том, что цикл будет продолжаться до тех пор, пока разность между квадратом получаемого результата и подкоренным выражением по абсолютной величине не станет меньше или равна указанной точности eps. Тогда цикл заканчивается и выдается результат.
1-й способ
Program
Problem2a;
uses WinCrt;
var
u : longint;
x, eps : real;
{----------------------------------------------------------------------------------------}
Procedure Square_root1(eps, u : real; var x : real);
begin
x := (u + 1)/2;
repeat
x := (1/2)*(x + u/x)
until abs(x*x - u) <= eps
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите подкоренное выражение '); readln(u);
write('Задайте точность вычисления '); readln(eps);
Square_root1(eps, u, x);
writeln('Квадратный корень из ', u, ' равен ', x:12:12);
writeln(' с точностью до ', eps:3:12)
end.
Во втором способе вычисляются два члена последовательности и их разность по абсолютной величине сравнивается с заданной точностью.
Как только эта разность станет равна или меньше указанной точности eps цикл заканчивается.
2-й способ
Program Problem2b;
uses WinCrt;
var
u : longint;
x, eps : real;
{----------------------------------------------------------------------------------------}
Procedure Square_root2(eps, u : real; var x : real);
var
x1, x2 : real;
begin
x1 := 1;
repeat
x1 := (1/2)*(x1 + u/x1);
x2 := (1/2)*(x1 + u/x1)
until abs(x2 - x1) <= eps;
x := x2
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите подкоренное выражение '); readln(u);
write('Задайте точность вычисления '); readln(eps);
Square_root2(eps, u , x );
writeln('Квадратный корень из ', u, ' равен ', x:12:12);
writeln('с точностью до ', eps:3:12)
end.
Разберите содержание этих программ и выполните их на компьютере. В чем отличие этих двух способов? Какой из них вы считаете более рациональным и почему?
Измените каждую из этих программ так, чтобы на экран выдавались последовательно десятичные приближения корней с недостатком? С избытком?
Если вы внимательно разобрались в составлении и работе предыдущих программ, то могли заметить, что в программе примера 2, несмотря на то, что математически последовательность задана формулой n-го члена, используется рекуррентное соотношение. Указывается начальное значение a := 1, а затем каждый цикл предыдущее значение умножается на постоянный множитель:
Таким образом, при составлении программ чаще всего будет использоваться рекуррентное соотношение. Возникает закономерный вопрос. Как перейти от задания последовательности формулой n-го члена к рекуррентному соотношению?
Разберем этот процесс на частном примере.
Пример..
Пусть задана последовательность с помощью формулы n-го члена, например:
Находим с ее помощью (n - 1)-й член: 
Разделим n-й член на (n-1)-й, получим:
Отсюда легко получить рекуррентную формулу:
Одной формулы недостаточно, еще необходимо задать некоторые начальные значения, первые члены последовательности, желательно нулевой член.
Получаем:
и Итак, если последовательность задана формулой n-го члена, тогда, чтобы задать ее рекуррентной формулой, необходимо найти частное от деления n-го члена на (n - 1)-й, а затем умножить (n - 1)-й член на частное. Это произведение будет равно n-му члену и мы получаем нужную формулу. К ней необходимо добавить значение некоторых первых членов и, таким образом, последовательность будет задана. Коротко этот процесс можно записать так:
После выполнения программы вы, конечно, обратили внимание на то, что независимо от того какую точность вы указываете значение результата будут выдаваться с 12-ю знаками после запятой (такой формат задан в программе). И нам трудно определить сколько десятичных знаков являются верными.
Было бы очень удобно, указав точность, получать в результате только требуемое количество десятичных знаков, например, указав 0.001, мы получали бы в результате 3 знака после запятой и не более.
Это можно сделать с помощью следующей функции:
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
Ее работа проста. Введенное значение точности (eps) последовательно умножается на 10 до тех пор, пока ее значение не станет больше 1.
Например, для значения eps = 0.001 процесс определения порядка будет проходить так:
Переменная k подсчитывает число выполняемых циклов. Но число циклов будет на 1 больше, чем количество знаков после запятой. Почему? Да потому, что цикл выполняется до тех пор пока, пока значение eps станет больше 1. Это сделано из тех соображений, что значение eps никогда не станет точно равно 1, ибо для этой переменной установлен вещественный тип real, а это значит, что eps не будет равно целому числу, хотя в примере кажется, что
но это не так.
Фактическое значение в этом случае может выражаться числом 0.99999999... . Чтобы устранить неудобства, первоначальному значению k задано значение -1, а останов цикла выполняется после eps > 1.
Добавляя эту функцию в программу, легко использовать ее для вывода результата с требуемым числом десятичных знаков.
Тогда, две вышеприведенные программы могут быть построены так:
Program Problem2a;
uses WinCrt;
var
u : longint;
x, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{---------------------------------------------------------------------------------------}
Procedure Square_root(eps, u : real; var x : real);
begin
x := (u + 1)/2;
repeat
x := (1/2)*(x + u/x)
until abs(x*x - u) <= eps
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите подкоренное выражение '); readln(u);
write('Задайте точность вычисления '); readln(eps);
Square_root(eps, u, x);
writeln('Квадратный корень из ', u, ' равен ', x:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Program Problem2b;
uses WinCrt;
var
u : longint;
x, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{---------------------------------------------------------------------------------------}
Procedure Square_root(eps, u : real; var x : real);
var
x1, x2 : real;
begin
x1 := 1;
repeat
x1 := (1/2)*(x1 + u/x1);
x2 := (1/2)*(x1 + u/x1)
until abs(x2 - x1) <= eps;
x := x2
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите подкоренное выражение '); readln(u);
write('Задайте точность вычисления '); readln(eps);
Square_root(eps, u, x);
writeln('Квадратный корень из ', u, ' равен ', x:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Задание 1
1. Составьте программы вывода на экран членов последовательности, задаваемых следующими способами:
1)
3) последовательность состоит из десятичных приближений с избытком частного
Пример 3. Рассмотрим бесконечную последовательность x1, x2,..., образованную по следующему закону:
, 
где u - данное неотрицательное действительное число, n - натуральное число.
Эта последовательность позволяет получить сколь угодно точные приближения числа
. По аналогии с программой для составить программу для приближённого вычисления и проверьте ее для а) 
, б) 
. { Вычисление корня с любым натур. показат. действит. числа }
Program Problem3;
uses WinCrt;
var
u, n, eps, x : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure Root(u, n, eps : real; var
x : real);
var
x1, x2, xn : real;
i : integer;
begin
x1 := (u + n - 1)/2;
repeat
xn := 1;
for i := 1 to trunc(n) - 1 do
xn := xn*x1;
x1 := ((n - 1)*x1 + u/xn)/n;
x2 := ((n - 1)*x1 + u/xn)/n
until abs(x1 - x2) <= eps;
x := x2
end;
{--------------------------------------------------------------------------------------}
begin
write('Введите подкоренное выражение '); readln(u);
write('Введите показатель корня '); readln(n);
write('Введите точность вычисления '); readln(eps);
Root(u, n, eps, x);
writeln('Значение корня равно ', x:8:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Рассмотрим несколько последовательностей, заданных формулами n-го члена:
3)
все три последовательности имеют место при любом значении x; 4)
, где m - вещественное число, отличное от 0 и от всех натуральных чисел при 
5)
при |x| < 1 и x = 1; 6) 
при |x| 1. Нам еще придется на следующем занятии иметь дело с этими последовательностями, но уже при постановке несколько иной задаче. А теперь составим программы вычисления членов последовательности, причем вычисления вести до того члена, который по абсолютной величине станет равным или меньше заданной точности. Выполним это задание для последовательностей 2-й и 4-й.
Пример 4.
Последовательность задана формулой
Вывести на экран члены последовательности до члена, меньшего заданного положительного числа eps. Желательно принять 0 < eps < 1.
Самое важное - это перейти от формулы n-го члена к рекурретному соотношению, которое впоследствии надо использовать при составлении программы.
Запишем формулу n-1 -го члена:
Разделим un
на un-1, получим:
тогда
Надо заметить, что первый член равен: u1 = x.
После этого нетрудно составить программу. Организуем цикл с предусловием "пока", пока |u| > eps. Почему для этой задачи удобно устроить именно такой цикл?
В нашем примере, в качестве начального значения берется первый элемент последовательности. Может случиться, что пользователь задал такое значение eps, что уже первый член меньше этого числа. И тогда вычислений выполнять не следует, т.е цикл не выполняется, а значит необходимо сразу проверить условие. Такое делается в цикле с предусловием. Цикл repeat ... until будет обязательно выполняться хотя бы один раз, а этого нам не нужно.
Программа
Program Problem4;
uses
WinCrt;
var
x, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure
Create_succession(x, eps : real);
var
u : real;
n : integer;
begin
u := x;
n := 1;
while abs(u) > eps do
begin
n := n + 1;
write(u:6:t(eps), '; ');
u := (-1)*u*x*x/((2*n - 2)*(2*n - 1))
end;
writeln
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значения |x| <= 1 '); readln(x);
write('Задайте положит. число eps '); readln(eps);
writeln('Члены последовательности');
Create_succession(x, eps);
end.
Пример 5. Последовательность задана формулой:
где m - вещественное число, отличное от 0 и от всех натуральных чисел, при
Вывести на экран члены последовательности до члена, меньшего наперед заданного положительного числа eps, 0 < eps < 1.
Из формулы n-го члена составьте рекуррентную формулу, установите каким должно быть первоначальное значение, составьте программу и сравните ее с приведенной ниже программой.
Program Problem5;
uses WinCrt;
var
x, m, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure
Create_succession(x, m, eps : real);
var
n : integer;
u : real;
begin
u := 1;
n := 1;
repeat
u := u*(m - n + 1)*x/n;
write(u:3:t(eps), ' ');
n := n + 1
until abs(u) <= eps;
writeln
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите значения x, |x| < 1 '); readln(x);
writeln('Введите вещественное положительное m, отличное от');
write('натуральных чисел '); readln(m);
write('Задайте положительное число eps '); readln(eps);
writeln('Члены последовательности');
Create_succession(x, m, eps)
end.
Задание 2
Составьте программы вывода на экран членов последовательности до члена, меньшего заданного положительного числа eps, 0 < eps < 1. Возьмите для задания примеры 1, 3, 6:
1)
где x - любое действительное число,3)
где x - любое действительное число,6)
при 
Усложним задачи и разберем следующий пример.
Пример 6. Дано положительное число eps. Последовательность a1, a2, a3,... образована по следующему закону:
Найти первый член an последовательности, для которого выполнено условие:
Составить программу выполнения этого задания.
Алгритм
1. Содержание.
а) Переменные и их типы. Переменная i принимает целые значения:
Переменные ap, an и eps принимают вещественные значения. 2. Основная часть.
а) Ввод значения eps.
б) Установить первоначальные значения переменных i, ap и an:
i := 1, ap := 1, an := 1 - 1/2.
в) Цикл "пока" с условием: abs(an - ap) >= eps.
Команды в цикле. Значения i каждый раз в цикле должны увеличиваться на единицу; значения ap := 1 - 1/i; значения an := ap*(1 - 1/(i + 1)).
г) После завершения работы цикла, вывод значения an на экран. Можно вывести и номер i этого члена последовательности.
3. Конец.
Составим процедуру и программу, используя алгоритм.
Программа
Program Problem6;
uses
WinCrt;
var
i : integer;
a, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until
eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Procedure
Create_succession(eps : real; var i : integer; var a : real);
var
i : integer;
an, ap : real;
begin
i := 1; ap := 1; an := 1 - 1/2;
while abs(an - ap) >= eps do
begin
i := i + 1;
ap := ap*(1 - 1/i);
an := ap*(1 - 1/(i + 1))
end;
a := an
end;
{---------------------------------------------------------------------------------------}
{ Основная программа }
begin
write(' Введите любое положительное число eps '); readln(eps);
Create_succession(eps, i, a);
writeln('Искомый член последовательности ', a:6:t(eps));
writeln('Находится на ', i, '-ом месте в последовательности')
end.
Задание 3
Последовательность задана формулой:
Составьте программу, показывающую, что для любого положительного числа eps, найдется член последовательности yN, для которого будет выполняться неравенство 
Если Вы составили программу и выполнили ее несколько раз, то смогли убедиться в том, что для любого положительного числа eps найдется член последовательности yN, такой, что модуль разности (yN- 2) меньше eps.
Дополним программу так, чтобы она показывала, что неравенство
выполняется для членов этой последовательности с номерами 
Но перед этим, вспомним определение предела последовательности.
Определение предела последовательности
Число A называется пределом последовательности xn, если для любого положительного числа
найдется такой номер последовательности N, что для всех номеров n > N, будет выполняться неравенство
Последнее неравенство равносильно следующему:
Если изобразить числа A, 
и значения последовательности xn на числовой оси, то получится наглядное геометрическое истолкование предела последовательности: Рис. 42
Какой бы малый отрезок (длиной
) с центром в точке A (см. рис. 42) ни взять, все точки xn, начиная с некоторой из них, должны попасть внутрь этого отрезка (так что вне его может остаться разве лишь конечное число точек).
Точка, изображающая предел A, является как бы средоточением сгустка точек, изображающих значения членов последовательности.
Возвращаясь к примеру 5, можно сказать, что по сути дела мы показывали, что число 2 является пределом последовательности
Если эту программу немного изменить, то она станет такой.
Пример 7. Программа, показывающая, что пределом последовательности
является число 2. Program Problem7;
uses
WinCrt;
var
i, n, k : longint;
eps, yn, yp : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until
eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
writeln('Введите произвольное положительное число, ');
write('можно даже очень малое '); readln(eps);
i := 1; k := -1; yn := 1;
while
abs(yn - 2) >= eps do
begin
i := i + 1; k := k*(-1);
yn := 2 + k/i
end;
writeln('Условию abs(yn-2)<', eps:1:t(eps), ' удовлетворяет');
writeln('член последовательности yn = ', yn:6:t(eps), ',');
writeln('находящийся под номером ', i); writeln;
write('Введите номер члена последовательности больше ',i,' ');
readln(n);
if
n mod 2 = 0 then yn := 2 + 1/n else yn := 2 - 1/n;
if
abs(2 - yn) < eps
then
begin
write('Неравенство abs(2 - ', yn:6:t(eps), ') < ', eps:1:t(eps));
writeln( ' выполняется ')
end
else
begin
write('Неравенство abs(2 - ', yn:6:t(eps), ') < ', eps:1:t(eps));
writeln(' не выполняется')
end
end.
Задание 4
Составьте программу, показывающую, что число 1 является пределом последовательности
Продолжим составление программ на последовательности и немного усложним задачу. Если в двух предыдущих примерах заведомо было известно число, которое является пределом последовательности, то в следующем примере надо будет определить существует ли вообще предел и если существует, тогда найти его и показать, что оно действительно является пределом заданной последовательности.
Таким образом, задача имеет две части:
1) установить существование
предела и,
2) если таковой существует, то показать чему он равен.
Перед выполнением такого задания обратимся к курсу математического анализа, в котором есть теорема, которая принадлежит чешскому математику Больцано и французскому математику Коши, ее часто называют принципом сходимости. Она выражает общий
Признак существования конечного предела последовательности
Пусть задана последовательность xn, пробегающая значения x1, x2, ..., xn, ..., xm, ... Для того, чтобы последовательность xn имела конечный предел, необходимо и достаточно, чтобы для каждого числа
существовал такой номер N, чтобы неравенство 
выполнялось, лишь только 
и 
. Как видите, суть дела здесь в том, чтобы значения переменной xn и xmмежду собой безгранично сближались по мере возрастания их номеров.
Этот признак допускает простую геометрическую иллюстрацию (рисунок 43).
Рис. 43
Пример 8. Выяснить имеет ли предел последовательность, заданная формулой:
Если имеет, то найти его. Алгоритм решения основывается на признаке существования предела последовательности. Нам необходимо установить, что члены последовательности по мере увеличения номера сближаются друг с другом. Перекладывая это на язык математики, нам надо задать положительное число eps, которое может быть сколь угодно малым и найти такие два члена последовательности, разность между которыми по абсолютной величине будет меньше этого наперед заданного, может быть даже, очень малого числа eps.
Идея становится понятной. Остается продумать, как находить члены последовательности в зависимости от их номеров?
Конечно, можно составить рекуррентное соотношение, но это будет немного трудным делом чисто в математическом отношении.
Возникает другая мысль. Составить подпрограмму возведения в степень и из основной программы каждый раз обращаться к ней для вычисления степени с изменением номера n. Тем более, что опыт составления подпрограмм у нас уже есть. Мы достаточно много составляли на прошедших занятиях подпрограмм в форме процедур и функций.
Основная программа. Вначале попросим пользователя задать точность вычисления (так мы назвали число eps).
Затем задается начальное значение переменной n (n := 1). Организуется цикл с последующим условием (repeat ... until...), в котором переменной x - члену последовательности присваивается значение, вычисляющее значение функции
для данного значения n. Далее значение n увеличивается на 1
и вычисляется следующий член последовательности x1, который также будет равен значению функции 
, - помните, что значение n уже увеличилось на 1. Проверяется условие abs(x1 - x) < eps. Как только условие выполнится, цикл закончится и в качестве значения предела последовательности мы можем брать любое из значений x или x1 и оно укажет нам значение предела последовательности с заданной точностью eps.
Если кто-нибудь из вас раньше встречался с такой последовательностью, то он сразу был уверен, что ее предел существует и равен числу e - основанию натурального логарифма.
Проверьте это, выполнив программу
Program
Problem8;
uses WinCrt;
var
n : integer; x, x1, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Function s(k: integer; p : real) : real;
var
i : integer; z : real;
begin
z := 1;
for i := 1 to k do z := z*p;
s := z
end;
{----------------------------------------------------------------------------------------}
begin
write('Задайте точность '); readln(eps);
n := 1;
repeat
x := s(n, (1 + 1/n));
n := n + 1;
x1 := s(n, (1 + 1/n))
until abs(x1 - x) < eps;
writeln('Предел последовательности равен ', x1:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Задание 5
Последовательность un принимает значения
Показать, что un
стремится к некоторому пределу при
. (При составлении программы использовать в качестве подпрограммы функцию вычисления степени числа 3 с показателем n).
Цикл с последующим условием Оператор repeatuntil
1. Оператор цикла с последующим условием (постусловием) похож на оператор цикла с предусловием, но условие вычисляется и проверяется после выполнения операторов, составляющих тело цикла.Общий вид оператора цикла с постусловием такой:
repeat
s1; s2; s3; ..
until <условие>,
где s1, s2, s3, ... - операторы тела цикла; <условие> - логическое выражение.
Переводится: repeat
- повторять, until - до тех пор пока.
Как видите, такой цикл начинается с выполнения операторов внутри цикла, а уже затем вычисляется выражение, записанное в условии.
Если значение этого выражения истинно, тогда осуществляется выход из цикла, если значение ложно, то цикл продолжается и снова выполняются операторы
Надо сразу заметить, что в отличии от цикла while ... do, в цикле repeat
... until ... операторные скобки begin ... end могут не использоваться, хотя и использование их вреда не принесет. Можно сказать другими словами, что оператор цикла repeat ... until. ... не требует операторных скобок begin ... end.
Рассмотрим работу этого оператора на примере.
Пример 1. Найти наименьшее натуральное число, дающее при делении на 2, 3, 4, 5, 6 соответственно остатки 1, 2, 3, 4, 5.
Задачу будем решать так: берется наименьшее натуральное число - единица и находятся остатки от деления его на 2, 3, 4, 5 и 6; если остатки будут равны 1, 2, 3, 4 и 5, тогда это число является искомым, его надо выдать на экран и закончить программу, в противном случае, надо брать следующее натуральное число - 2 и проверять его, и так далее.
Программа, составленная по этой идее, очень проста:
Program Problem1;
uses WinCrt;
var
n : integer;
begin
n := 0;
repeat
n := n + 1;
until (n mod 2 = 1) and (n mod 3 = 2) and (n mod 4 = 3) and
(n mod 5 = 4) and
(n mod 6 = 5);
writeln('Искомое целое число ', n)
end.
Еще один пример, который демонстрирует работу цикла с постусловием.
Пример 2. Числа, одинаково читающиеся и слева направо, и справа налево, называются палиндромами. Например, числа 42324 или 1331 - палиндромы. Составьте программу, которая будет находить числа - палиндромы из заданного промежутка.
Логика составления программы такова.
Переставить цифры в числе и сравнить полученное число с заданным.
Раньше уже составлялась программа перестановки цифр числа, которая была выполнена с помощью цикла с предусловием
while ... do
...
Как будет построена часть программы о перестановки цифр с помощью цикла
repeat ... until ...
Пусть заданное число a, тогда введем еще одну переменную b, которой будет присвоено значение переменной a (для чего это делается вы узнаете позже): b := a;
Заведем еще одну переменную a1 для нового числа, в котором цифры уже будут переставлены.
Первоначальное значение этой переменной - ноль: a1 := 0;
Почему значение этой переменной равно нулю станет ясно из программы.
Далее организуем цикл repeat, в котором будет происходить перестановка цифр числа b:
repeat
a1 := a1*10 + b mod 10;
b := b div 10
until b = 0;
Итак, в цикле, также как и в цикле while ... do ..., отделяется последняя цифра:
b mod
10; (например, 343 mod 10 = 3); переменной a1 присваивается значение:
a1 := a1*10 + b mod
10; 0 * 10 + 3 =3;
"отбрасывается" последняя цифра заданного числа с помощью операции целочисленного деления:
b := b div 10; 343 div 10 = 34;
проверяется условие: b = 0, 34 = 0, условие не выполняется, значит цикл продолжается.
Отделяется последняя цифра уже нового числа:
b mod 10 = 34 mod 10;
новое число a1, уже равное 3, умножается на 10 и к результату прибавляется следующая цифра - 4:
a1 := a1*10 + b mod
10;
"отбрасывается" последняя цифра числа b:
b := b div 10 ; 34 div 10 = 3;
проверяется условие: b = 0, 3 = 0; условие не выполняется, значит цикл продолжается.
Отделяется последняя цифра числа:
b mod 10 ; 3 mod
10 = 3;
формируется новое число:
a1 := a1*10 + b mod 10 ; 34 * 10 + 3 = 343;
"отбрасывается" последняя цифра числа и получается новое число:
b := b div 10 ; 3 div 10 = 0;
проверяется условие: b = 0, 0 = 0; условие выполняется, значит цикл заканчивается.
Теперь становится ясно, почему введена другая переменная b для заданного числа, ее значение в цикле меняется от начального до нуля и, чтобы сохранить заданное число в переменной a, и вводится, так сказать, "рабочая" переменная - b.
После окончания цикла перестановки цифр числа, сравнивается первоначальное число, которое "сохранилось" в переменной a и число, которое получилось после перестановки цифр и "накопилось" в переменной a1.
Если
a = a1, тогда значение a выдается на экран, так как это число является палиндромом.
Далее, значение a увеличивается на 1, т. е. берется для рассмотрения следующее по порядку натуральное число и снова продолжается внешний цикл. Цифры числа переставляются, полученное новое число после перестановки цифр - a1, сравнивается с первоначальным a и так далее.
Внешний цикл заканчивается, когда значение a становится равным правой границе интервала - n.
Составим
программу
Program Problem2;
uses WinCrt;
var
m, n, a, b, a1 : longint;
begin
write('Введите левую границу промежутка '); readln(m);
write('Введите правую границу промежутка '); readln(n);
a := m;
writeln('Числа палиндромы из [', m, ';', n, ']');
repeat
b := a; a1 := 0;
repeat
a1 := a1*10 + b mod 10;
b := b div 10
until b=0;
if a1 = a then write(a, ' ');
a := a + 1
until a > n;
end.
Программы, составленные с циклом с предусловием (while ... do...), легко можно переделать с циклом с постусловием (repeat ... until ...) и они будут такими:
Программа, подсчитывающая сумму цифр числа:
Program Sum; { Сумма цифр числа }
uses WinCrt;
var
n, s, a : integer;
begin
write('Введите целое число '); readln(n);
a := n; s := 0;
repeat
s := s + n mod 10; n := n div 10
until n = 0;
writeln('Сумма цифр числа ', a, ' равна ', s)
end.
Программа
перестановки первой и последней цифр в числе:
Program Transpose;
uses WinCrt;
var
n, n1, p, a, i : longint;
begin
write('Введите натуральное число n '); readln(n);
a := n; i := 1;
p := n mod
10; {последняя цифра введенного числа}
repeat
i := i*10; n := n div 10
until n<10;
n1 := a - n*i - p + n + p*i;
writeln('Число после перестановки цифр ', n1)
end.
Схематически цикл repeat можно изобразить так (см. рис. 21):
Рис. 21
Циклы с параметрами Операторы fortodo и fordowntodo
1. Иногда заранее известно, сколько раз должен выполняться цикл. Для задач такого типа в языке Паскаль имеются операторы циклов с параметрами.Формат записи таких операторов следующий:
for <пар.цикла> := <нач.знач> to <кон.знач.> do <оператор>.
Здесь for, to, do - зарезервированные слова (для, до, выполнить);
<пар. цикла> - параметр цикла - переменная типа integer (точнее, любого порядкового типа);
<нач. знач.> - начальное значение - число или выражение того же типа;
<кон. знач.> - конечное значение - число или выражение того же типа;
<оператор> - произвольный оператор Паскаля.
Если операторов несколько, тогда, как и в операторе while ... do ..., используются операторные скобки: begin ... end.
Например, возможны такие записи оператора цикла:
for i := a to b do s1;
for j := a to b do begin
s1; s2; ..., sn end; или
for k := p to m do
begin
s1;
s2;
...
sn
end;
Здесь s1, s2, s3, ... sn - операторы цикла.
При выполнении оператора for вначале вычисляется выражение <нач .знач.> и осуществляется присваивание его значения переменной цикла
<пар .цикла> := <нач. знач.>.
После этого циклически повторяются:
1) проверка условия <пар .цикла>
<кон. знач.>; если условие не выполнено, оператор for завершает работу; 2) выполнение оператора <оператор> или операторов s1; s2; s3; ... sn;
3) переменная цикла <пар. цикла> увеличивается на единицу.
Надо сразу заметить, что задать шаг цикла, отличный от 1 в этом операторе, нельзя.
Для иллюстрации работы оператора for рассмотрим пример уже ставший традиционным при изучении работы этого оператора.
Пример 1. Составить программу вычисления факториала числа n, т. е. n!.
Вспомним из математики, что факториал числа n равен произведению чисел от 1 до n.
Например:
Замечание.
В математике принято: 0! = 1.
Программа
Program
Problem1; { Вычисление факториала числа n! }
uses WinCrt;
var
n, f, i : longint;
begin
write('Введите натуральное число '); readln(n);
f := 1;
if n <> 0 then for i := 1 to
n do f := f*i;
writeln('Факториал числа ', n, ' равен ', f)
end.
Переменная n - для вводимого пользователем числа, факториал которого надо найти; f - переменная, в которой будет "накапливаться" значение факториала числа n; i - переменная цикла.
Устанавливается первоначальное значение переменной f := 1.
Далее начинается цикл. Переменной i присваивается начальное значение 1; оно сравнивается с конечным - n (1 <= n), если условие истинно, тогда
выполняется оператор (в этой программе он один): f := f*i, 1*1=1; значение переменной цикла увеличивается на 1, т. е. станет равным: i := i + 1, 1 + 1 = 2 и цикл повторяется.
Когда
значение i станет равным n, тогда цикл выполнится последний раз, потому что следующее значение i будет n + 1, что больше конечного значения n, условие
i <= n - ложно, цикл не выполняется.
Элементы комбинаторики
Здесь мы рассмотрим некоторые примеры из очень обширного круга задач, для решения которых используются ЭВМ и персональные компьютеры. Это вопросы комбинаторики и теории вероятностей.Подпрограммы на паскале Процедуры и функции Рекурсия
1. Дедуктивный метод программированияОтвлечемся на некоторое время от составления программ и поговорим о творческом процессе вообще, не только программиста или математика, а, например, художника или архитектора.
Допустим, что художник собирается нарисовать картину: портрет человека или что-то другое. Прежде, в глубине его сознания созревает общий образ будущего произведения, затем начинается ее реальное воплощение на холсте, бумаге, дереве или на чем-то другом. И вот здесь начинается тяжелейшая работа. Художник выполняет эскизы, рисунки отдельных фрагментов картины, а потом создает единое произведение, воплощающее в красках, цвете и тени, выношенный им образ.
Архитектор задолго до создания проекта своей новой конструкции также видит его целиком, а затем воплощает по отдельным частям единый проект здания или сооружения.
Подобно им и программист должен видеть в целом программу, которая решает какую-то задачу, а потом разбивает ее на отдельные части, составляет на выбранном языке программирования эти части программы, объединяет их в единое целое и получает программу.
Итак, весь творческий процесс можно разбить (разумеется, чисто условно) на следующие этапы:
1) основная идея решения задачи;
2) общая конструкция программы;
3) выделение отдельных, элементарных частей программы;
4) практическая реализация на языке программирования этих частей программы;
5) объединение их в единую программу.
Такой процесс программирования называют структурным или нисходящим. Более подробно с этим процессом мы познакомимся позже, когда изучим хотя бы основы языка программирования, но об отдельных частях, "кирпичиках", составляющих программу узнаем на этом занятии.
Подпрограммой называется группа операторов, к которой обращаются из основной программы несколько раз. Иногда это может быть 2, 3 раза, а очень часто, каждый раз из выполняемого цикла основной программы.
Вполне понятно, что писать несколько раз одинаковые группы операторов трудно, проделывается много "технической" работы, а в некоторых случаях просто невозможно (если обращаться приходиться каждый раз при выполнении цикла).
Для облегчения такой работы и созданы подпрограммы.
Использование подпрограмм позволяет:
1) сделать основную программу более наглядной и компактной;
2) уменьшить объем используемой памяти ЭВМ;
3) сократить время отладки программы.
На языке Паскаль подпрограммы бывают двух видов, - это процедуры и функции.
2. Процедуры
Рассмотрим следующий простой пример, с помощью которого попробуем разобраться в конструкции процедур на Паскале.
Пример 1. Составить программу, которая бы проверяла, являются ли три числа взаимно простыми.
Мы знаем, что числа называются взаимно простыми, если их наибольший общий делитель (НОД) равен 1. Значит, для решения этой задачи нам придется дважды находить НОД чисел. Если заданы три числа: a, b, c, то найти НОД(a, b), а затем найти НОД(НОД(a, b), c).
Дважды писать операторы для нахождения НОД нам не хочется, поэтому оформим операторы для НОД в виде процедуры.
Посмотрите, как это будет выглядеть в программе:
Program Problem1;
uses WinCrt;
var
a, b, c, k : integer;
{----------------------------------------------------------------------------------------}
Procedure nod(a, b : integer; var n : integer);
var
r : integer;
begin
repeat
r := a mod b;
a := b; b := r
until b = 0;
n := a
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите три натуральных числа '); readln(a, b, c);
nod(a, b, k);
a := k; b := c;
nod(a, b, k);
if k = 1 then writeln('Числа взаимно простые')
else writeln('Числа не взаимно простые')
end.
В разделе описаний, после описания переменных, записывается заголовок процедуры: Procedure
Это слово является служебным и зарезервировано в Паскале. В одной строке с ним, через пробел, записывается имя процедуры, которое должно удовлетворять всем требованиям, предъявляемым к именам, основными из которых являются: начинаться с буквы и не иметь пробелов, т.
е., требования такие же, как и к имени программы (имя нашей процедуры - nod):
Procedure nod(a, b : integer; var
n : integer);
Далее, в скобках, записываются имена переменных и их типы, значения которых будут вводиться
в процедуру из основной программы, в нашем случае, их две (a, b) и они имеют тип integer.
Сразу надо заметить, что имена этих переменных могут не совпадать с именами переменных в основной программе, скажем мы могли их обозначить m, n или любыми другими именами.
После точки с запятой и зарезервированного слова var, записываются переменные и их типы, значения которых будет являться результатом работы процедуры и выводятся
из нее в основную программу. Такая переменная в нашем примере одна - n. Она выведет значение НОД чисел a и b. Ее имя также может иметь одноименное в основной программе и это нисколько не отразится на работе процедуры.
Обратите внимание, что перед переменными, значения которых вводятся из основной программы, не ставится слово var, а перед переменной, значение которой выводится
в основную программу, это слово записано. Это очень важное обстоятельство!
Так, если поставить var перед a и b, то компилятор будет воспринимать эти переменные как выходные и вводимые для них значения воспринимать не будет, и, наоборот, если var не будет записано перед выходной переменной, то компилятор воспримет ее как входную и выводить ее значение в основную программу не будет.
Дальнейшее построение процедуры строится также, как и основная программа на Паскале.
Описываются переменные, которые будут участвовать в ее работе, но их имена не должны повторять имена уже описанных входных и выходных параметров в заголовке программы. Далее описываются необходимые для работы операторы.
В нашем примере процедура nod будет такой:
Procedure nod(a, b : integer; var
n : integer);
var
r : integer;
begin
repeat
r := a mod b;
a := b; b := r
until b = 0;
n := a
end;
Основная программа строится обычным образом, но там, где необходимо найти НОД чисел, обращается к процедуре. Как?
Для этого обращаются к ней по имени, а в скобках записывают фактические значения входных переменных (в нашем случае для переменных a и b), а также имена выходных переменных (в нашем случае k).
Из приведенного ниже участка программы видно, что при первом обращении к процедуре nod определяется НОД чисел a и b (nod(a, b, k) и результат запоминается в переменную k, далее, изменяются значения переменных a и b
и снова вызывается процедура nod, которая уже находит НОД чисел k и c и результат присваивает переменной k. Вы можете видеть основную часть программы:
begin
write('Введите три натуральных числа '); readln(a, b, c);
nod(a, b, k);
a := k; b := c;
nod(a, b, k);
if k = 1 then writeln('Числа взаимно простые')
else writeln('Числа не взаимно простые')
end.
Сделаем общие выводы для построения и работы процедур
Процедуры помещаются в разделе описаний и начинается зарезервированным (служебным) словом
Procedure
Процедуре обязательно
дается имя, которое должно удовлетворять тем же требованиям, что и имена переменных, т.е. это может быть одна или несколько букв, комбинация букв и целых чисел, но без пробелов, начинаться с буквы и т.д.
После имени, в скобках записываются переменные - параметры и их тип: входные, значения которых используются для вычисления в качестве аргументов.
Выходные параметры - это те переменные, в которых получается результат выполнения процедуры.
Входные и выходные параметры процедуры называются формальными параметрами.
Фактические, конкретные, значения формальные параметры должны получить в основной программе после обращения к ней (а пока в процедуре они являются не чем иным, как "пустышками").
После формальных параметров, описываются переменные, которые необходимы непосредственно для работы процедуры.
Это параметры процедуры. Они нужны в ней, как и в любой другой программе и описываются также.
Их имена должны отличаться от имен входных и выходных параметров.
Надо заметить, что процедура может быть такой, что в ней не будет вообще параметров, достаточно тех, которые будут введены из программы.
Описание процедуры имеет вид:
Procedure <имя> (<входные параметры> : <их тип>;
var
<выходные параметры> : <их тип>);
(раздел описаний)
begin
(раздел операторов)
end;
Она помещается в основной программе в разделе описаний.
По входным и выходным параметрам процедуры могут быть следующих типов:
1) иметь и входные и выходные параметры:
Procedure
<имя>(<входные параметры> : <их тип>;
var
<выходные параметры> : <их тип>);
Мы только познакомились с программой такого типа.
2) иметь входные параметры, но не иметь выходных:
Procedure <имя>(<входные параметры> : <их тип>);
3) иметь выходные параметры, но не иметь входных:
Procedure
<имя>(var <выходные параметры> : <их тип>);
4) не иметь ни входных, ни выходных параметров:
Procedure
<имя>;
В зависимости от этого различаются процедуры по своей конструкции и выполняемым функциям.
Далее следует раздел операторов, который составляется по тем же правилам, как и в других программах.
Процедура описана и после этого начинается основная программа.
Вызов процедуры из программы
Как происходит вызов подпрограммы - процедуры?
Обязательно указывается имя процедуры. В скобках задаются фактические значения входных параметров и те переменные, в которые будут "запоминаться" выходные значения.
Рассмотрим пример, где может быть использована процедура второго типа: имеет входные параметры, но не имеет выходных.
Пример 2. Составить программу, которая устанавливает, какие числа из заданного промежутка [a; b] можно представить в виде суммы двух квадратов целых чисел?
В этой программе, нам придется проверять каждое из чисел промежутка [a; b] можно ли его представить в виде суммы квадратов двух чисел, поэтому было бы разумно разработать процедуру, которая бы проверяла одно число и затем обращаться к ней из основной программы для проверки каждого числа из промежутка.
Процедуру составим по следующему способу. Пусть задано число n. Нам необходимо найти такие два числа a и b, чтобы сумма их квадратов была равна n, т.е. решить в целых числах уравнение:
Возникает естественное желание испытывать натуральные числа от 1 и до ...? А вот до какого значения неизвестно. Если их брать до числа n, то это будет слишком много лишней и бесполезной работы.
Чтобы выяснить этот вопрос, можно организовать цикл, в котором проверять сколько чисел a
надо, чтобы выполнялось неравенство:
Здесь, в качестве b взято наименьшее натуральное число 1. Организовав такой цикл, и подсчитав, сколько чисел a потребуется, мы узнаем сколько чисел надо просматривать, чтобы найти решение уравнения. Этот цикл
может быть таким:
a := 1; k := 1;
while a*a + 1<=n do
begin
k := k + 1;
a := a + 1
end;
Теперь ясно, что для испытания чисел, следует устроить цикл от 1 до k:
for a := 1 to
k do
Второй цикл должен быть для значений b. Но если его организовать тоже от 1 до k, тогда могут повторяться дважды одинаковые значения, только на разных местах, например, для числа 20 могут быть выданы следующие значения:
22 + 42
= 20 и 42 + 22 = 20.
Чтобы избежать повторения чисел, цикл для чисел b можно организовать либо от 1 до a, либо от k до а.
Нами выбран первый вариант.
Процедура
Procedure
to_square(n : integer);
label 1;
var
a, b, k : integer;
begin
a := 1; k := 1;
while a*a + 1<=n do
begin
k := k + 1;
a := a + 1
end;
for a := 1 to k do
for b := 1 to a do
if a*a + b*b = n
then
begin
writeln(n, '=', a, '*', a,' +', b, '*', b); goto
1
end;
1: end;
Процедура выполнена с досрочным прерыванием цикла, так как нет необходимости выяснять всевозможные значения пар чисел, удовлетворяющих этому уравнению, а достаточно просто выяснить возможность такого представления.
Выполнив такую процедуру, не составляет труда решить полностью задачу. Для этого в основной программе выполнить цикл для всех чисел из промежутка, и каждое из которых, с помощью процедуры проверять. Кстати говоря, эта процедура имеет только один формальный параметр - входной, - значение проверяемого числа из промежутка и не имеет выходных параметров.
Программа
Program Problem2;
uses WinCrt;
var
a, b, i : integer;
{---------------------------------------------------------------------------------------}
Procedure to_square(n : integer);
label 1;
var
a, b, k : integer;
begin
a := 1; k := 1;
while a*a + 1 <= n do
begin
k := k + 1;
a := a + 1
end;
for a := 1 to k do
for b := 1 to a do
if a*a + b*b = n
then
begin
writeln(n, '=', a, '*', a, '+', b,'*', b); goto
1
end;
1: end;
{----------------------------------------------------------------------------------------}
begin
write('Введите начало промежутка '); readln(a);
write('Введите конец промежутка '); readln(b);
write('Числа, которые можно представить в виде суммы ');
writeln('квадратов следующих чисел');
for i := a to b do to_square(i);
end.
Структура программы на языке "Паскаль"
 |
На этом занятии мы познакомимся с конструкцией программ на языке программирования высокого уровня "Паскаль".
Этот язык разработал сравнительно недавно, в 1970 году, профессор кафедры вычислительной техники Швейцарского федерального института технологии - Николас Вирт.
Обо всех достоинствах и преимуществах Паскаля перед другими языками мы узнаем после первоначального знакомства с ним, в конце первой части этой книги, а теперь обратимся к составлению простейших программ на этом языке.
Изучение конструкции программ на Паскале начнем с простого примера.
Пример 1. Составить программу решения следующей задачи.
Саша спросил Сережу: "Сколько тебе лет?" Сережа ответил:
"Если бы число моих лет увеличить в 3 раза, а потом уменьшить на 17, то мне было бы 16 лет". Сколько лет Сереже?
Обычно решение такого типа задач начинается с "конца".
Число лет, которое было бы Сереже, т. е. 16, увеличиваем на 17, получаем
Полученный результат уменьшаем в 3 раза, т.е. делим на
получаем 11.Итак, Сереже было 11 лет.
Посмотрим, как будет выглядеть программа решения этой задачи на языке Паскаль.
Program Serg;
var
a, b, c: integer;
begin
write('Ведите число лет, которое было бы Сереже '); readln(a);
b := a + 17;
c := b div 3;
writeln('Сереже было ', c, ' лет')
end.
Если эту программу ввести в компьютер и выполнить, то на экране появится вначале запрос для пользователя:
Введите число лет, которое было бы Сереже
После ввода числа 16, компьютер выдаст на экран:
Сереже было 11 лет
Рассмотрим более детально построение программы.
Она начинается со слова program. Слово program зарезервировано в Паскале, т.е. не может использоваться ни в каких других целях, лишь для начала программы.
После служебного слова program записывается имя программы. В нашей программе именем является serg. Имя программы записывается на английском языке по усмотрению и фантазии автора программы. (В некоторых версиях Паскаля допускается запись имени программы на русском языке).
Конечно, желательным является, чтобы имя программы выражало ее содержание, но как вы сами понимаете, это не всегда возможно.
Имя программы никак в дальнейшем не используется, поэтому требование обязательности объявления имени программы можно считать излишним. Программу можно выполнять и без имени. С другой стороны, - программа без имени неудобна, а иногда непонятна для пользователей и программистов.
Количество символов в имени программы не ограничивается, но значащими считаются первые 63 символа.
Имя программы должно начинаться с буквы. В нем не должно быть пробелов, запятых, точек.
В конце первой строки, после имени программы стоит ";" - точка с запятой.
Этот знак указывает на то, что некоторая инструкция закончена и за ней будет записана следующая инструкция. Правда, первая "инструкция" является именем программы и не походит на инструкцию в смысле "делай то и делай так", но термин " инструкция" мы употребляем в более широком смысле, как одно логически завершенное предложение или его часть. Точка с запятой является обязательным
разделительным знаком в языке Паскаль.
В некоторых версиях языка Паскаль, вы можете встретить такое начало программы:
Program
Serg (input, output);
Как видите, в скобках записаны служебные слова input (ввод) и output (вывод). Они указывают, что в программе будет вводиться и выводиться информация. Для большинства современных версий языка Паскаль и для Турбо Паскаля эти служебные слова являются необязательными. Хотя, надо заметить, их запись в программе не приведет к ошибке. В дальнейшем мы не будем использовать их в программах.
Следующая строка программы:
var
a, b, c : integer;
В этой строке обязательно
указываются все переменные, участвующие в программе и их типы.
Слово var
- это сокращение от слова variable (переменная) и является так же, как и слово program, зарезервированным словом.
После него записываются имена переменных - идентификаторы, в нашем примере: a, b, c. Они записываются через запятую.
После имен переменных стоит ":" - двоеточие, а затем записано служебное, зарезервированное, слово integer. Integer (целый) указывает тип значений, которые принимают переменные - целые числа (..., -4, -3, -2, -1, 0, 1, 2, 3, 4, 5,...). Эта строка программы, также как и предыдущая, заканчивается ";" - точкой с запятой.
Далее в программе следует служебное, зарезервированное, слово begin (начать), которым начинается новый раздел программы - раздел операторов.
В этом разделе последовательно записываются команды, операторы, которые разделяются ";" - точкой с запятой. Они будут выполняться компьютером.
Программа заканчивается
служебным словом end, после которого стоит точка.
Она является обязательной во всех паскалевских программах. Точка оповещает о конце текста программы.
Заметьте, последняя строка из раздела операторов перед служебным словом end не заканчивается точкой с запятой. Но, если вы ее поставите, то ошибки не будет.
1. Итак, КОНСТРУКЦИЯ ПРОГРАММЫ на языке
ПАСКАЛЬ
Program <имя>;
РАЗДЕЛ ОПИСАНИЙ
В нем описываются имена переменных и их типы.
Begin
РАЗДЕЛ ОПЕРАТОРОВ
Ввод данных, последовательность команд, вывод результатов.
end.
Эту конструкцию очень удобно изобразить с помощью блок-схемы. Вспомним, что блок-схема состоит из отдельных геометрических фигур - блоков, каждый из которых показывает какие команды или операции надо выполнить.
Вот эти блоки:
Ввод и выполнение программ
1. В интегрированной среде Турбо Паскаль 7.0.После запуска Турбо Паскаля на экране появится следующая оболочка (см. рис. 3):
Рис. 3
Верхняя строка открывшегося окна содержит "меню" возможных режимов работы Турбо Паскаля, нижняя - краткую справку о назначении основных функциональных клавиш. Вся остальная часть экрана принадлежит окну текстового
редактора, очерченному двойной рамкой и предназначенному для ввода и редактирования текста программы.
Когда мы вводим программу, то работаем с текстовым редактором, встроенным в среду Турбо Паскаль. Поэтому ниже мы и познакомимся с работой редактора и основными его командами.
Признаком того, что среда находится в состоянии редактирования, является наличие в окне редактора курсора - небольшой мигающей черточки.
Для создания текста программы нужно ввести этот текст с помощью клавиатуры подобно тому, как это делается при печатании текста на пишущей машинке. После заполнения очередной строки следует нажать на клавишу <Enter> "Ввод", чтобы перевести курсор на следующую строку (курсор всегда показывает место на экране, куда будет помещен очередной вводимый символ программы).
Окно редактора имитирует длинный и достаточно широкий лист бумаги, часть которого видна в окне экрана. Если курсор достиг нижнего края, осуществляется прокрутка окна редактора: его содержимое смещается вверх на одну строку и внизу появляется новая строка "листа". Наибольшая длина строки на Турбо Паскале - 126 символов.
Окно можно смещать относительно листа с помощью следующих клавиш:
PgUp - на страницу вверх (PaGe UP - страница вверх);
PgDn - на страницу вниз (PaGe DowN - страница вниз);
Home - в начало текущей строки (HOME - домой);
End - в конец текущей строки (END - конец);
Ctrl-PgUp - в начало текста;
Ctrl-PgDn - в конец текста.
Клавишами управления курсора “курсор” можно смещать по тексту на экране (заметьте, только по тексту!).
По "чистому" не исписанному экрану курсор не перемещается!
Если Вы ошиблись при вводе очередного символа, его можно стереть с помощью клавиши, обозначенной стрелкой влево (клавиша Backspace - <Забой>, она располагается справа и вверху зоны основных алфавитно-цифровых клавиш над клавишей
Чтобы "разрезать" строку, следует подвести курсор к нужному месту и нажать клавишу <Ввод>, чтобы "склеить" соседние строки, нужно установить курсор в конец первой строки и нажать клавишу
или установить курсор в начало следующей строки и нажать клавишу <Забой>.
Режим вставки
Нормальный режим работы редактора - режим вставки, в котором каждый вновь вводимый символ как бы "раздвигает" текст на экране, смещая вправо остаток строки. Следует учитывать, что "разрезание" и последующая вставка пропущенных символов возможна только в этом режиме.
Примеры "разрезания", "склеивания" строк и вставки символов в текст.
Пусть по каким-то причинам на экране получена такая запись:
Program Serg; var
a, b, c : integer;
Если говорить об эстетической стороне написания программы, то желательно, чтобы раздел описаний, который начинается со слова var, начинался с красной строки. Для внесения изменений в текст установим курсор на букву v и нажмем клавишу <Ввод>, при этом часть текста после курсора и под ним переместится на следующую строку, получим:
Program Serg;
var
a, b, c : integer;
Для большей красоты и наглядности, не перемещая курсора, а оставляя его на букве v, нажмем несколько раз клавишу <Пробел>. Вся строка передвинется на вправо и запись станет такой:
Program Serg;
var
a, b, c : integer;
Допустим другую ситуацию, когда часть текста "разорвалась" и ее нам надо "склеить", например, получилось так:
write('Введите число лет, кото
рое было бы Серёже ");
Устанавливаем курсор в начало второй строки перед буквой "р" и нажимаем клавишу <Забой>, получим:
write('Введите число лет, которое было бы Серёже ');
Можно поступить иначе, установить курсор в конец первой строки после буквы "о" и нажимая несколько раз клавишу
С помощью клавиш <Забой> и
можно "соединять" "разорванную” строку. Например, в такой ситуации:
write('Вве дите число лет, которое было бы Сереже ');
Устанавливаем курсор перед буквой "д" и нажимаем несколько раз клавишу <Забой> до тех пор, пока слово "Введите" примет нужную конструкцию, или, установив курсор после буквы "е" нажать несколько раз клавишу
Вставка пропущенных символов делается еще проще.
Например, вы пропустили несколько букв:
wrte('Ввете число лет, которое было бы Сеже ');
В первом слове пропущена буква "i", в слове "Введите" пропущены две буквы "ди", в слове "Сережа" буквы "ер".
Установим курсор на букву "t" в первом слове и наберем с клавиатуры "i", она тут же вставится на нужное место. Далее установим курсор на букву "т" в слове "Ввете" и наберем с клавиатуры "ди", слово "раздвинется" и буквы "ди" станут на свои места. Установим курсор на "е" в слове "Сежа" и наберем "ер",
Режим наложения
Редактор может также работать в режиме наложения новых символов на существующий старый текст: в этом режиме новый символ заменяет собой тот символ, на который указывает курсор, а остаток строки справа от курсора не смещается вправо. Для перехода к режиму наложения надо нажать клавишу
Режим автоотступа
Еще одной особенностью редактора является то, что обычно он работает в режиме автоотступа. В этом режиме каждая новая строка начинается в той же позиции экрана, что и предыдущая.
Режим автоотступа поддерживает хороший стиль оформления текстов программ: отступы от левого края выделяют различные операторы и делают программу более наглядной.
Отказаться от режима автоотступа можно командой Ctrl-O I (при нажатой клавише Ctrl
нажимается сначала клавиша O, затем клавиша O отпускается и нажимается клавиша I), повторная команда Ctrl-O I восстановит режим автоотступа.
Ниже перечислены наиболее часто используемые команды текстового редактора Турбо Паскаля, кроме тех, которые были приведены выше.
Команды редактирования
Backspac - <Забой> - стереть символ слева от курсора;
Del - стереть символ, на который указывает курсор;
Ctrl-Y - стереть строку, на которой располагается курсор;
Enter - <Ввод> - вставить новую строку, "разрезать" старую;
Ctrl-Q L - восстановить текущую строку (действует, если
курсор не покидал измененную строку).
Работа с блоком
Ctrl-K B - пометить начало блока;
Ctrl-K Y - стереть блок;
Ctrl-K V - переместить блок;
Ctrl-K R - прочитать блок из дискового файла;
Ctrl-K P - напечатать блок;
Ctrl-K H
- спрятать/отобразить блок (снять пометку);
Ctrl-K K
- пометить конец блока;
Ctrl-K C - копировать блок;
Ctrl-K W
- записать блок в дисковый файл;
Выполнение программы
После того, как программа набрана можно попробовать ее выполнить.Для этого нажимаем клавиши
На экране раскроется меню второго уровня, связанное с этой опцией. Новое меню как бы "выпадает" из верхней строки, поэтому такое меню часто называют выпадающим (Pull-down). Экран станет таким (см. рис. 4):
Рис. 4
Теперь надо найти в новом меню опцию RUN (пуск) и нажать клавишу <Ввод>.
Если не было ошибки при вводе текста, то, спустя несколько секунд, произойдет смена изображения на экране. Турбо Паскаль предоставляет экран в распоряжение работающей программы пользователя. Такой экран называется окном программы.
В ответ на запрос:
Введите число лет, которое было бы Серёже, надо ввести 16 и нажать клавишу <Ввод>.
После завершения прогона (работа программы часто называется ее прогоном) на экране вновь появится окно редактора с текстом программы. Если Вы не успели разглядеть изображение окна программы, то нажмите Alt-F5. При этом окно редактора скроется
и вы сможете увидеть результаты работы программы. Чтобы вернуть экран в режим воспроизведения окна редактора, надо нажать на любую клавишу.
Можно экран сделать более удобным, чтобы видеть результаты работы программы. Для этого в нижней части экрана можно открыть второе окно.
Для этого нажмите клавишу F10, чтобы перейти к режиму выбора из главного меню, подведите указатель к опции Debug (отлаживать) и нажмите клавишу <Ввод> - на экране раскроется меню второго уровня, связанное с этой опцией.
Экран станет таким (см. рис. 5):
Рис. 5
Найдите в новом меню опцию OUTPUT (вывод программы), подведите к ней указатель и нажмите клавишу <Ввод>.
В нижней части экрана появится второе окно, но оно уже не будет исчезать.
Теперь добьемся того, чтобы на экране демонстрировалось два окна одновременно: снова нажмите клавишу F10, выберите WINDOW, нажмите клавишу <Ввод>, подведите указатель к опции TILE (черепица) и нажмите клавишу <Ввод>.
Если все сделано правильно, экран примет вид (см. рис. 6):
Рис. 6
Двойная рамка, очерчивающая окно программы, свидетельствует о том, что именно это окно активно в данный момент.
Сделаем активным окно редактора: нажмем клавишу
Первые ошибки и их исправление
1. Не поставлена точка с запятой, например, после оператора readln(a). После пуска программы, нажатием клавиш
Error 85: ";" expected.
(Ошибка 85: ";" отсутствует.)
Редактор установит курсор на следующий символ после пропущенного знака, в нашем примере на переменную b. После нажатия любой клавиши, сообщение об ошибке исчезает и редактор переходит в режим вставки. Надо подвести курсор к нужному месту, поставить точку с запятой - “;” и продолжить работу.
2. В описании переменных не записана переменная, а в программе она присутствует, например переменная c. После пуска программы, будет выдано сообщение:
Error 3: Unknown identifier.
(Ошибка 3: Неизвестный идентификатор.)
Курсор будет установлен на эту переменную, в нашем примере на переменную c. Надо исправить ошибку, т.е. записать переменную c в раздел описаний переменных и продолжить работу.
3. Не поставлена точка после оператора end в конце программы.
Сообщение компилятора будет таким:
Error 10: Unexpected end of file.
(Ошибка 10: Неправильный конец файла.),
курсор установится на букву "e" в слове "end". Надо поставить точку и снова выполнить программу.
Запись файла на диск
Итак, программа отредактирована и выполнена (прокручена), теперь ее надо записать на диск. Для этого можно воспользоваться основным меню, в котором выбрать опцию "File" (см. рис. 7). Последовательность действий такова: 1) нажать клавишу F10 и перейти в основное меню; 2) переместить указатель на опцию "File" и нажать <Ввод>, откроется второе меню опции "File":
Рис. 7
Вы можете из этого меню выбрать опцию "Save". Она записывает содержимое активного окна редактора в дисковый файл.
Если нажать клавишу <Ввод>, то среда запросит имя файла, если такового не было установлено и окно было связано с именем NONAME00.PAS. Вы можете изменить имя, или оставить его прежним.
Эта опция вызывается непосредственно из редактора клавишей
Можно выбрать опцию SAVE AS. Она записывает содержимое активного окна редактора в дисковый файл под другим именем.
Диалоговое окно этой опции имеет вид (см. рис. 8):
Рис. 8
В поле ввода Вы должны написать имя того файла, в который будет переписано содержимое активного окна редактора. Вы можете выбрать уже существующий файл из поля выбора или из протокола с опциями. В этом случае в зависимости от настройки среды старое содержимое файла будет уничтожено или сохранено в виде страховой копии с расширением .BAK.
Построчная запись текста программы
В Паскале нет правил разбивки текста программы на строки.
Однако для записи программы можно дать некоторые
Рекомендации
Очень важно, чтобы текст программы был расположен наглядно не только ради красоты, но (и это главное!) ради избежания ошибок. (Найти ошибки в наглядном тексте значительно легче.)
1. Каждый оператор следует писать с новой строки, за исключением коротких и по смыслу связанных операторов.
Например,
write ... readln ... - записываются в одной строке, короткие операторы присваивания можно записать в одну строку:
a := 23; b := 105; c := -11.2.
2. Операторы одного уровня, находящиеся в разных строках, должны быть выровнены по вертикали, т.е. одинаково отодвинуты от левого края.
Например, запишем последовательность операторов для определения суммы цифр трехзначного числа:
s := a div 100;
d := a div 10 mod 10;
e := a mod 10;
sum := s + d + e
Здесь все операторы равноценны, последовательно идут один за другим, поэтому все начинаются с одной и той же вертикальной позиции.
3. Операторы, включенные в другой оператор, следует сдвинуть вправо на несколько позиций (желательно одинаково).
begin
write ...
readln ...
if ... then
begin
.....
end
else
begin
.....
end;
end.
4. Рекомендуется вертикально выравнивать пары базовых слов: begin и end, с которыми мы уже познакомились, а также слова, с которыми мы познакомимся позже: repeat и until, record и end, case
и end.
5. Оператор if рекомендуется размещать с учетом длины и сложности условия, и операторов, идущих после слов then и else.
Вот несколько самых популярных вариантов размещения оператора if:
а) if ... then ...
else ...
б) if ... then ...
else ...
в) if ...
then ...
else ...
г) if ...
then ...
else ...
д) if ... then ... else ...
6. Комментарии пишутся либо рядом с конструкцией (идентификатором, оператором, его частью), которую они объясняют, либо в отдельной строке.
7. После знаков препинания: , - запятой, ; - точки с запятой, : - двоеточия рекомендуется оставлять по одному пробелу.
Задание
Наберите программу Serg и выполните ее.Закончите работу в системе Turbo Pascal.
Интегральная формула Муавра-Лапласа
Если вероятность p наступления события в каждом испытании постоянна и отлична от нуля и единицы, а число испытаний достаточно велико, то вероятность того, в n независимых испытаниях событие состоится число раз, заключенное в границах от [m1; m2] (m1 < m2), приближенно равна:
где
а
- функция Лапласа. Для применения этой формулы, необходимо составить функцию вычисления интеграла
Для его вычисления воспользуемся способом разложения подынтегральной функции в ряд с последующим интегрированием членов полученного степенного ряда с заданной степенью точности. (Подробнее об этом см. в главе "Числовые и функциональные ряды", "Приближенное вычисление интегралов с помощью рядов").
При составлении функции учтем то обстоятельство, что при
значение функции равно 1, а при 
значение функции равно -1. В результате получим следующую функцию для вычисления интегральной функции Муавра-Лаплапса:
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if
x >= 5
then FF := 1
else if x <= -5
then
FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)) )
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
Используя эту функцию, составим процедуру для вычисления вероятности появления события из заданного интервала [m1; m2].
{ Процедура вычисл. вероятн. наст. событ. из промеж. [m1; m2] }
Procedure Interval(n, m1, m2 : longint; p : real; var PP : real);
var
x1, x2 : real;
begin
x1 := (m1 - n*p)/sqrt(n*p*(1 - p));
x2 := (m2 - n*p)/sqrt(n*p*(1 - p));
PP := (FF(x2) - FF(x1))/2
end;
Дальнейшее не представляет труда. Полученные функция и процедура дают нам возможность решать довольной большой круг задач определения вероятности наступления событий. Разберем это на конкретных примерах.
Пример 1. Вероятность некоторого события равна 0.4 в каждом из n испытаний. Найти вероятность того, что число появления события при n = 1500 будет заключено между 1) 570 и 630; 2) 600 и 660; 3) 620 и 680; 4) 580 и 640.
Программа
{ Применение интегральной формулы Муавра-Лапласа }
Program Problem1;
uses WinCrt;
var
n, m1, m2 : longint;
p, PP : real;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer; u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u; n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисл. вероятн. наст. событ. из промеж. [m1; m2] }
Procedure Interval(n, m1, m2 : longint; p : real; var PP : real);
var
x1, x2 : real;
begin
x1 := (m1 - n*p)/sqrt(n*p*(1 - p));
x2 := (m2 - n*p)/sqrt(n*p*(1 - p));
PP := (FF(x2) - FF(x1))/2
end;
{----------------------------------------------------------------------------------------}
{ Основная программа. Число бракованных изделий из промежутка }
begin
write('Введите общее число изделий '); readln(n);
write('Введите вероятность наступление одного события '); readln(p);
write('Введите левую границу промежутка '); readln(m1);
write('Введите правую границу промежутка '); readln(m2);
Interval(n, m1, m2, p, PP);
writeln('Вероятность того, что число бракованных изделий');
write('находится в промежутке [',m1, '; ', m2, '] равна ');
writeln(PP:1:8)
end.
Пример 2. Число отклонений от установленного стандарта при обточке металлических болванок составляет, по данным длительной проверки ОТК, 0.12 от взятого количества продукции. Определить вероятность того, что из взятых наудачу 25 образцов не менее 21 будет соответствовать стандарту.
Программа
{ Применение интегральной формулы Муавра-Лапласа }
Program Problem2;
uses WinCrt;
var
n : longint;
e, p, PP : real;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u; n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления вероятности частоты наступления событий }
{ при заданной точности e }
Procedure Probability(n : longint; p, e : real; var PP : real);
var
x : real;
begin
x := e/sqrt(n*p*(1 - p));
PP := FF(x)
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write(' Введите вероятность приема одного сообщения ');
write('без ошибок '); readln(p);
write('Введите общее число сообщений '); readln(n);
writeln('На сколько число принятых сообщений должно быть');
write('безошибочным, (точность) прин. сообщ. '); readln(e);
Probability(n, p, e, PP);
writeln('Искомая вероятность равна ', PP:1:8)
end.
Пример 3. На склад поступает продукция трех фабрик, причем изделия первой фабрики на складе составляют 30%, второй - 32% и третьей - 38%. В продукции первой фабрики 60% изделий высшего сорта, второй - 25%, третьей - 50%. Найти вероятность того, что среди 300 наудачу взятых со склада изделий число изделий высшего сорта заключено между 130 и 170.
В этой задаче прежде надо определить вероятность получения числа изделий высшего сорта со всех трех фабрик, т.е. их наличие на складе.
Пусть H1 - изделие сделано на 1-ой фабрике, P(H1) = 0.3; H2
- изделие сделано на 2-ой фабрике, P(H2) = 0.32; H3 - изделие сделано на 3-ей фабрике, P(H3) = 0.38.
A - изделие высшего сорта. В задаче даны PHi(A), i = 1, 2, 3;
{ Применение интегральной формулы Муавра-Лапласа }
Program Problem3;
uses WinCrt;
var
n, m1, m2 : longint;
p, PP : real;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисл. вероятн. наст. событ. из промеж. [m1; m2] }
Procedure
Interval(n, m1, m2 : longint; p : real; var PP : real);
var
x1, x2 : real;
begin
x1 := (m1 - n*p)/sqrt(n*p*(1 - p));
x2 := (m2 - n*p)/sqrt(n*p*(1 - p));
PP := (FF(x2) - FF(x1))/2
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите общее число изделий '); readln(n);
p := 0.6*0.3 + 0.25*0.32 + 0.5*0.38;
write('Введите левую границу промежутка '); readln(m1);
write('Введите правую границу промежутка '); readln(m2);
Interval(n, m1, m2, p, PP);
writeln('Вероятность того, что число изделий высшего');
write('сорта находится в [',m1, '; ', m2, '] равна '); writeln(PP:1:8)
end.
Классические методы нахождения изолированного корня
На этом занятии мы рассмотрим задачу нахождения корней уравненияf(x) = 0. (1)
"Изолированным" мы будем называть корень c уравнения (1), если найден, содержащий его промежуток [a, b]: a < c < b, на котором других корней нет.
Для решения задачи уточнения корня, потребуем, чтобы функция удовлетворяла следующим условиям:
1) f(x), f'(x) и f''(x) непрерывны на промежутке [a, b]; 2) значения функции на концах промежутка [a, b] имеют разные знаки:
т. е. функция заведомо имеет корень на этом промежутке; 3) обе производные f'(x) и f''(x) сохраняют каждая определенные знаки на всем промежутке [a, b], это значит, что функция строго монотонна (возрастает или убывает) на этом промежутке. Требование сохранение знака второй производной f''(x) геометрически означает, что график функции вогнутостью обращен всегда в одну сторону и не имеет перегибов.
Столь жесткие требования к поведению функции на промежутке казалось бы сильно сужают круг рассматриваемых функций, но это не так.
Для алгебраических функций всегда можно найти промежуток (если вообще вещественные корни алгебраического уравнения существуют), на котором все три перечисленных условия выполняются.
Что касается трансцендентных уравнений, то на практике в большинстве случаев перечисленные условия выполняются и для них.
Во всяком случае, круг уравнений достаточно широк, чтобы заняться рассмотрением ниже приводимых приемов решения, тем более что эти способы являются классическими и полезны будут даже из соображений общего развития читателей.
Рис. 44
На рисунке 44 изображены четыре возможные случая, отвечающие различным комбинациям знаков f'(x) и f''(x).
1-й случай, когда f'(x)>0 - функция возрастает на промежутке, f''(x) > 0 - график вогнутостью направлен вверх.
2-й случай: f'(x)<0 - функция убывает, f''(x)>0 - вогнутость вверх.
3-й случай: f'(x) > 0 - функция возрастает, f''(x) < 0 - вогнутость направлена вниз.
4-й случай: f'(x) < 0 - функция убывает, f''(x) < 0 - вогнутость вниз.
1.1. Метод хорд (правило пропорциональных частей)
Пусть c - корень уравнения f(x) = 0 на промежутке [a, b], тогда c - абсцисса точки пересечения кривой с осью ox. Конечная задача - найти эту точку или как можно близкое значение абсциссы к этой точки.
Рассмотрим случаи 1-й и 3-й, когда хорда находится слева от кривой и пересекает ось x между точками a и c (см. рис. 45).
Рис. 45
Заменим кривую AcB хордой AB. Мы сможем написать уравнение этой хорды, а значит найти ее точку пересечения с осью x.
Уравнение хорды - это уравнение прямой, проходящей через две точки (a, f(a)) и (b, f(b)).
Общий вид уравнения прямой, проходящей через две точки такой:
Подставляя в эту формулу значения, получим уравнение хорды AB:
отсюда 
Пусть x1
- точка пересечения хорды с осью x, так как y = 0, то
x1 может считаться приближенным значением корня. Для более точного его определения рассмотрим промежуток [x1, b]. И на этом промежутке заменим кривую хордой A1B и найдем новое приближение к корню - x2:
и так далее. Для n + 1 - го приближения получим:
Этот процесс можно продолжать сколь угодно долго и построить возрастающую последовательность приближенных значений корня:
a < x1
< x2 < ... < xn < xn+1 < ... < c.
В математическом анализе доказывается, что переменная xn с ростом n стремится к c, т.е. c является пределом этой последовательности.
Для случаев 2-го и 3-го, когда хорда располагается справа от кривой (см. рис. 46), и пересекает ось ox между точками с и b, значения приближенных значений корней будут следующими:
Рис. 46
....................................,
(1)В результате получим убывающую последовательность, которая также сходится к c:
b > x1
> x2 > ... > xn > xn+1 > ... > c
Во всех случаях можно найти корень с любой степенью точности.
Как оценивается точность приближенного значения xn?
По формуле Лагранжа (формуле конечных приращений) для разности
получим: 
, где 
или 
Так как f(c) = 0, то получим:
Если обозначить через m наименьшее значение |f'(x)| на промежутке [a, b], которое можно определить заранее, то получим формулу для оценки точности вычисления корня:
или 
где eps - заданная точность вычисления. Пользуясь рекуррентной формулой (1) и формулой для оценки точности вычисления, нетрудно составить процедуру уточнения корня методом хорд:
{ Процедура уточнения корня методом хорд }
Procedure chord(a, b, eps, min : real; var
x : real);
var
x1 : real;
begin
x1 := a;
repeat
x := x1 - ((b - x1)*fx(x1))/(fx(b) - fx(x1));
x1 := x
until abs(fx(x))/min < eps
end;
Для оценки точности вычисления корня необходимо вычислять наименьшее значение производной f'(x) на промежутке [a, b], поэтому возникает необходимость в нахождении значения производной в точке и здесь мы приходим к задаче численного дифференцирования.
1.2. Вычисление производных (численное дифференцирование)
При вычислении производной функции, будем иметь в виду, что один из способов найти производную
- это взять достаточно малые значения справа и слева на равном расстоянии от 
- точке, в которой мы хотим найти производную. 
Таким образом, вычисляется производная в середине промежутка.
По значениям f' можно таким же способом найти производную от f', т.е. f''. Можно выразить f'' непосредственно через f(x):
Для производной третьего порядка можно использовать следующую формулу:
Возникают естественные вопросы, откуда происходят эти формулы и как оценивать точность вычисления производных по этим формулам?
Формулы являются результатом дифференцирования интерполяционных многочленов Ньютона и других. Сущность которых состоит в том, что заданная функция f(x) представляется в виде многочлена, который значительно проще дифференцировать, чем какие-либо другие функции, особенно трансцендентные или представляющие собой сложные выражения. Как получаются такие многочлены, мы узнаем позже - этому вопросу будет посвящена полностью глава, а сейчас ограничимся лишь результатами, которые нам необходимы в этой главе.
Оценка погрешности и точности вычисления не менее серьезный и сложный процесс, чем само приближенное вычисление.
Так для оценки погрешности дифференцирования могут быть применены следующие формулы:
(2)где предполагается, что функция f(x) дифференцируемая n + 1 раз, а точка
- некоторое промежуточное значение между x0 - точкой, в которой находится производная и точками (x0 - 2dx), (x0 - dx), (x0 + dx), (x0 + 2dx), ... из заданного промежутка [a, b]. На практике f
(n+1)(c) оценивать непросто, поэтому при малых dx приближенно полагают:
и тогда получается следующая формула
(3) Мы будем пользоваться формулой (2), а впоследствии и формулой (3), в зависимости от конкретной задачи и тех сложностей, которые могут возникнуть при составлении программ.
Используя эти формулы, составим функцию для вычисления первой производной. Точность вычисления eps задается пользователем, а первоначальная величина промежутка dx устанавливается 1, а затем, для уточнения вычисления - делится на 2. Впрочем, читатель может предложить другие способы изменения промежутка dx, когда значительно быстрее достигается вычисление производной с заданной степенью точности.
{ Вычисление 1-й производной и опред. точности ее вычислен.}
{ derivative - производная }
Function derivat1(x0, eps : real) : real;
var
dx, dy, dy2 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx/2) - fx(x0 - dx/2);
dy2 := fx(5*x0/4 + dx) - 2*fx(5*x0/4);
dy2 := dy2 + fx(5*x0/4 - dx)
until abs(dy2/(2*dx)) < eps;
derivat1 := dy/dx
end;
Здесь, для определения точности вычисления, используется вторая производная в точке
dy2 := fx(5*x0/4 + dx) - 2*fx(5*x0/4) + fx(5*x0/4 - dx); Запись ее вычисления выполнена в две строки только из-за лучшей наглядности написания программы.
Возможен и другой вариант написания функции с использованием формулы (3) для оценки точности вычисления.
Тогда функция запишется так:
{ Вычисление 1-й производной и опред. точности ее вычислен.}
{ derivative - производная }
Function derivat1(x0, eps : real) : real;
var
dx, dy, dy2 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx/2) - fx(x0 - dx/2);
dy2 := fx(5*x0/4 + dx) - 2*fx(5*x0/4);
dy2 := dy2 + fx(5*x0/4 - dx)
until abs((dy2*dy2*fx(x0))/(2*dx)) < eps;
derivat1 := dy/dx
end;
Задание 1
Составьте самостоятельно функции для вычисления второй производной и проверьте ее работу в программах для вычисления второй производной функций:
Однако вернемся к задаче решения уравнения методом хорд. Имея возможность вычислить значение производной, можно составить процедуру определения модуля ее наименьшего значения на промежутке [a, b].
Для этого достаточно сравнить модуль значения производной на концах промежутка и выбрать среди этих двух значений меньшее (такое право дает нам сделать тот факт, что по условию, функция на промежутке строго монотонна вместе со своими производными первого и второго порядков). Процедура получится простой:
{ Процедура определения наименьшего значения производной }
Procedure
minimum(a, b, eps : real; var min : real);
begin
min := abs(derivat1(a, eps));
if min > abs(derivat1(b, eps))
then min := abs(derivat1(b, eps))
end;
Но и построенная таким образом процедура имеет очень существенный недостаток! А если в точке a или b производная будет равна нулю? Тогда деление на нуль станет невозможным и в программе будет получена ошибка. Чтобы избежать этого, изменим процедуру так, чтобы в случае равенства нулю производной в одной и точек a или b находилось бы ее значение в ближайшей окрестности этой точки. Но, для точки a брать значение слева нельзя, оно выйдет за пределы промежутка [a, b], также, как и справа от точки b. Поэтому следует брать значение очень близкое к a, но справа от нее, аналогично для точки b - брать близкое значение слева от b.
Процедуру
можно построить так:
{ Процедура определения наименьшего значения производной }
{ на заданном промежутке }
Procedure minimum(a, b, eps : real; var min : real);
var
d : real;
begin
a := a - eps;
b := b + eps;
repeat
a := a + eps;
b := b - eps;
min := abs(derivat1(a, eps));
d := abs(derivat1(b, eps));
if min > d then min := d
until min <> 0
end;
Объединяя полученные функции и процедуры в одну программу, мы получим программу вычисления корня уравнения на изолированном промежутке методом хорд.
{ Решение уравнений методом хорд. method - метод, chord - хорда }
Program Method_Chord;
uses WinCrt;
var
a, b, x, min, eps : real;
{--------------------------------------------------------------------------------------}
{ Заданная функция }
Function fx(x : real) : real;
begin
fx := x*x*x - 2*x*x - 4*x - 7
end;
{--------------------------------------------------------------------------------------}
{ Вычисление 1-й производной }
{ derivative - производная }
Function derivat1(x0, eps : real) : real;
var
dx, dy, dy2 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx/2) - fx(x0 - dx/2);
dy2 := fx(5*x0/4 + dx) - 2*fx(5*x0/4);
dy2 := dy2 + fx(5*x0/4 - dx)
until abs(dy2/(2*dx)) < eps;
derivat1 := dy/dx
end;
{----------------------------------------------------------------------------------------}
{ Процедура определения наименьшего значения производной }
{ на заданном промежутке }
Procedure minimum(a, b, eps : real; var min : real);
var
d : real;
begin
a := a - eps;
b := b + eps;
repeat
a := a + eps;
b := b - eps;
min := abs(derivat1(a, eps));
d := abs(derivat1(b, eps));
if min > d then min := d
until min <> 0
end;
{----------------------------------------------------------------------------------------}
{ Процедура уточнения корня методом хорд }
Procedure chord(a, b, eps, min : real; var
x : real);
var
x1 : real;
begin
x1 := a;
repeat
x := x1 - ((b - x1)*fx(x1))/(fx(b) - fx(x1));
x1 := x
until abs(fx(x))/min < eps
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите левый конец промежутка a = '); readln(a);
write('Введите правый конец промежутка b = '); readln(b);
write('Введите точность вычисления корня eps = ');
readln(eps);
minimum(a, b, eps, min);
chord(a, b, eps, min, x);
writeln('Корень уравнения равен x = ', x:12:12);
writeln('С точностью до eps = ', eps:1:12)
end.
И в этих программах будем применять уже известную нам функцию для указания точности вычисления.
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
Добавим эту функцию в программу.
{ Решение уравнений методом хорд. method - метод, chord - хорда}
{ Правило пропорциональных частей }
Program
Method_Chord;
uses WinCrt;
var
a, b, x, min, eps : real;
{----------------------------------------------------------------------------------------}
{ Заданная функция }
Function fx(x : real) : real;
begin
fx := x*x*x - 2*x*x - 4*x - 7
end;
{----------------------------------------------------------------------------------------}
{ Вычисление 1-й производной }
{ derivative - производная }
Function derivat1(x0, eps : real) : real;
var
dx, dy, dy2 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx/2) - fx(x0 - dx/2);
dy2 := fx(5*x0/4 + dx) - 2*fx(5*x0/4);
dy2 := dy2 + fx(5*x0/4 - dx)
until abs(dy2/(2*dx)) < eps;
derivat1 := dy/dx
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Процедура определения наименьшего значения производной }
{ на заданном промежутке }
Procedure minimum(a, b, eps : real; var min : real);
var
d : real;
begin
a := a - eps;
b := b + eps;
repeat
a := a + eps;
b := b - eps;
min := abs(derivat1(a, eps));
d := abs(derivat1(b, eps));
if min > d then min := d
until min <> 0
end;
{----------------------------------------------------------------------------------------}
{ Процедура уточнения корня методом хорд }
Procedure chord(a, b, eps, min : real; var
x : real);
var
x1 : real;
begin
x1 := a;
repeat
x := x1 - ((b - x1)*fx(x1))/(fx(b) - fx(x1));
x1 := x
until abs(fx(x))/min < eps
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите левый конец промежутка a = '); readln(a);
write('Введите правый конец промежутка b = '); readln(b);
write(' Введите точность вычисления корня eps = ');
readln(eps);
minimum(a, b, eps, min);
chord(a, b, eps, min, x);
writeln('Корень уравнения равен x = ', x:6:t(eps));
writeln('С точностью до eps = ', eps:1:t(eps))
end.
1.3. Правило Ньютона (метод касательных)
Будем по прежнему считать, что функция f(x) удовлетворяет всем перечисленным ранее требованиям и искомый корень c изолирован на промежутке [a, b], т. е. a < c < b.
Если в предыдущем примере была предпринята замена кривой, - графика функции, хордой, то возникает естественная идея, а почему бы не заменить ее касательной, проведенной первоначально из точек A или B.
Этот метод носит название правило Ньютона или метод касательных.
Также возможны четыре случая, которые представлены на рисунке 47.
Рис. 47
Рассмотрим уравнение касательной, проведенной в точке B с абсциссой b. Уравнение касательной в этой точке составить нетрудно, оно будет таким:
зная, что в точке пересечения с осью ox y = 0, найдем из уравнения значение x, получим:
Таким образом, мы получаем приближенное значение корня
(4)Возникает вопрос, где лежит точка x1, полученная по формуле (3). Ведь из рисунка следует, что в случаях 2 и 3 она может лежать вообще за пределами промежутка.
В математическом анализе доказывается, что если значение f(b) одного знака с f''(x) - это случаи 1 и 4, то x1 лежит между корнем c и точкой b.
Аналогично, если исходить из точки a, и касательную к кривой провести в точке A, то получим следующую формулу для приближенного значения корня
Также и здесь доказывается, что если f(a) и f''(a) одного знака, то x1 лежит между a и c, a < x1 < c (на рисунке это соответствует случаям 2 и 3).
Как и для случая метода хорд можно построить для 1-го и 4-го случаев убывающую последовательность значений xn сходящейся к c:
b > x1
> x2 > ... > xn > xn+1 > ... > c,
а для случаев 2 и 3 возрастающую последовательность значений также сходящихся к c: a < x1 < x2
< ... < xn < xn+1 < ... < c.
Вычисление значений членов последовательности производится по следующей рекуррентной формуле:
Надо иметь ввиду, что для выбора первоначального значения x (x = a или x = b), надо установить, где знак функции f(x) совпадает со знаком f''(x).
Оценка точности приближения происходит также, как и для случая метода хорд по значению отношения
где eps - заданная точность, а m - наименьшее значение |f'(x)| на промежутке [a, b]. Исходя из высказанных соображений составим процедуру уточнения корня методом касательных.
{ Процедура уточнения корня методом касательных }
Procedure tangent(a, b, eps, min, dy : real; var x : real);
var
x1 : real;
begin
x1 := a;
repeat
x := x1 - fx(x1)/derivat1(x1);
x1 := x
until abs(fx(x))/min < eps
end;
Для установления первоначального значения x (конца промежутка, от которого начнется уточнения корня) нам нужна будет вторая производная. Функцию, которая ее вычисляет вы должны были составить самостоятельно, а сейчас проверьте себя:
{ Функция вычисления второй производной }
Function
derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
Программа
{ Решение уравнений методом касательных. method - метод }
{ tangent - касательная. Правило пропорциональных частей }
Program Method_Tangent;
uses WinCrt;
var
a, b, x, min, eps : real;
{----------------------------------------------------------------------------------------}
{ Заданная функция }
Function fx(x : real) : real;
begin
fx := x*x*x - 2*x*x - 4*x - 7
end;
{----------------------------------------------------------------------------------------}
{ Вычисление 1-й производной }
{ derivative - производная }
Function derivat1(x0, eps : real) : real;
var
dx, dy, dy2 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx/2) - fx(x0 - dx/2);
dy2 := fx(5*x0/4 + dx) - 2*fx(5*x0/4);
dy2 := dy2 + fx(5*x0/4 - dx)
until abs((dy2*dy2*fx(x0))/(2*dx)) < eps;
derivat1 := dy/dx
end;
{----------------------------------------------------------------------------------------}
Function derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Процедура определения наименьшего значения производной }
{ на заданном промежутке }
Procedure minimum(a, b, eps : real; var min : real);
var
d : real;
begin
a := a - eps;
b := b + eps;
repeat
a := a + eps;
b := b - eps;
min := abs(derivat1(a, eps));
d := abs(derivat1(b, eps));
if min > d then min := d
until min <> 0
end;
{----------------------------------------------------------------------------------------}
{ Процедура уточнения корня методом касательных }
Procedure tangent(a, b, eps, min : real; var x : real);
var
x1 : real;
begin
x1 := a;
repeat
x := x1 - fx(x1)/derivat1(x1, eps);
x1 := x
until abs(fx(x))/min < eps
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите левый конец промежутка a = '); readln(a);
write('Введите правый конец промежутка b = ');
readln(b);
write('Введите точность вычисления корня eps = ');
readln(eps);
minimum(a, b, eps, min);
if fx(a)*derivat2(a, eps) > 0
then tangent(a, b, eps, min, x)
else tangent(b, a, eps, min, x);
writeln('Корень уравнения равен x = ', x:6:t(eps));
writeln('С точностью до eps = ', eps:1:t(eps))
end.
Вы обратили внимание, что первая производная вычисляется с определением точности вторым способом через приращение аргумента и приращение функции. Почему это сделано?
Когда выяснялся вопрос о точности вычисления производных, то оговаривалось, что при оценки погрешности первой производной по значению второй производной, точка, в которой вычисляется значение второй производной должна быть отлична от x0 и от точек, которые отстоят от x0 на расстоянии кратном dx. При вычислении корня по методу касательных значение первой производной меняется в зависимости от x1, которое может неожиданно попасть в точку, отстоящую от x0 на расстоянии кратном dx, что недопустимо. Поэтому оценка погрешности выполняется вторым способом.
1.4. Комбинированный метод касательных и хорд
Он состоит в одновременном использовании как метода касательных, так и метода хорд.
Если Вы внимательно следили за вычислениями приближенных значений двумя методами, то вероятно заметили, что если методом хорд последовательность значений, начиная от первоначального значения a - левого конца промежутка, возрастает, то для этого же случая по методу касательных последовательность убывает.
Для других двух случаев получается наоборот. Таким образом, получаемые последовательности сближаются и тем самым, применяя одновременно два метода можно получить более быстрое приближение корня.
Если мы имеем дело со случаем 1, тогда, обозначая приближенные значения по методу хорд x1, а по методу касательных - z1, получим:
тогда, a < x1 < c < z1 < b.
При следующем шаге заменяется в этих формулах a и b через x1 и z1:
Общие формулу для построения приближений будут следующими:
О качестве достигнутого приближения, т.е. о точности, можно судить по величине |zn
- xn| - в этом удобство комбинированного метода.
Необходимо изменить процедуры вычисления приближенных корней уравнения по методу хорд и методу касательных следующим образом:
{ Процедура уточнения корня методом хорд }
Procedure chord(a, b : real; var
x : real);
begin
x := a - ((b - a)*fx(a))/(fx(b) - fx(a))
end;
{----------------------------------------------------------------------------------------}
{ Процедура уточнения корня методом касательных }
Procedure tangent(a, b, eps : real; var
z : real);
begin
z := a - fx(a)/derivat1(a, eps)
end;
В основной программе организовать цикл до выполнения условия
а в самом цикле в зависимости от знака функции и ее производной изменяйте значения a и b на x и z. { Решение уравнений комбинированным методом хорд и касательных }
Program Combination_Method;
uses WinCrt;
var
a, b, x, z, eps : real;
{----------------------------------------------------------------------------------------}
{ Заданная функция }
Function fx(x : real) : real;
begin
fx := x*sin(x) - 0.5
end;
{----------------------------------------------------------------------------------------}
{ Вычисление 1-й производной }
{ derivative - производная }
Function derivat1(x0, eps : real) : real;
var
dx, dy, dy2 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx/2) - fx(x0 - dx/2);
dy2 := fx(5*x0/4 + dx) - 2*fx(5*x0/4);
dy2 := dy2 + fx(5*x0/4 - dx)
until abs((dy2*dy2*fx(x0))/(2*dx)) < eps;
derivat1 := dy/dx
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления второй производной }
Function derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Процедура уточнения корня методом хорд }
Procedure chord(a, b : real; var
x : real);
begin
x := a - ((b - a)*fx(a))/(fx(b) - fx(a))
end;
{----------------------------------------------------------------------------------------}
{ Процедура уточнения корня методом касательных }
Procedure tangent(a, b, eps : real; var
z : real);
begin
z := a - fx(a)/derivat1(a, eps)
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите левый конец промежутка a = '); readln(a);
write('Введите правый конец промежутка b = '); readln(b);
write(' Введите точность вычисления корня eps = ');
readln(eps);
repeat
if fx(a)*derivat2(a, eps) > 0
then
begin
tangent(a, b, eps, z);
chord(b, a, x);
b := z; a := x
end
else
begin
tangent(b, a, eps, z);
chord(a, b, x);
b := x; a := z
end
until abs(z - x) < eps;
writeln('Корень уравнения равен x = ', x:6:t(eps));
writeln('С точностью до eps = ', eps:1:t(eps))
end.
Задание 2
При выполнении задания Вам необходимо использовать программу отделения корней, которая изучалась ранее. Таким образом, задания надо выполнять в таком порядке:
1) графическим путем найти самый "большой" промежуток, на котором может находится один или более корней (это можно сделать "вручную", схематически вычертив графики функции);
2) составить программу, в которой объединяется метод отделения корней (другими словами, нахождение изолированных промежутков) и соответствующий метод уточнения корня (метод хорд, касательных или комбинированный).
1. При решении следующих уравнений используйте для уточнения корня метод хорд:
2. Примените для уточнения корня метод касательных:
Замечание. Последнее уравнение можно преобразовать к виду более удобному для решения: ln(3x ) = ln(3x) или xln3 = ln(3x), xln3 - ln(3x) = 0.
Вообще для вычисления степени ax с любым действительным показателем и любым положительным действительным основанием можно составить отдельную процедуру, основываясь на следующих соображениях:
ax = y, ln(a x) = lny, xlna = lny, y = e xlna, окончательно получаем a = exlnx .
На Паскале это запишется так: exp(x*ln(a)).
3. Для решения следующих уравнений используйте в качестве метода уточнения корней, комбинированный метод:
Классическое определение вероятности
Самый удобный инструмент для первого знакомства с вероятностями - игральная кость: кубик, грани которого занумерованы числами 1, 2, ..., 6.Поскольку кубик совершенно симметричен, мы считаем, что все шесть исходов бросания кости, т.е. выпадения цифр 1 или 2, или 3, или 4, или 5, или 6 имеют совершенно одинаковую возможность.
Если отвлечься от реального содержания исходов испытания и интересоваться лишь тем, произошел или не произошел тот или иной исход, мы получим понятие элементарного события, которое в теории вероятностей является основным и не определяется.
В теории вероятностей под событием мы будем понимать все то, что может произойти, но может и не произойти в результате выполнения некоторой совокупности (комплекса) условий. Такие события называются случайными событиями.
Например, случайными событиями будут:
а) попадание в цель при выстреле;
б) выпадение орла при бросании монеты;
в) наудачу взятое изделие - стандартное;
г) наудачу взятое изделие - бракованное;
д) выпадение определенного числа очков при бросании игральной кости и т.д.
Условимся события обозначать большими буквами латинского алфавита A, B, C, ... и т. д. В дальнейшем, если данный комплекс условий многократно повторяется, мы вместо слов "совокупность условий выполнена" будем говорить: "произведено испытание" или "произведен опыт". Другими словами, событие
мы будем рассматривать как результат испытания.
Так в примере а) выстрел - это испытание, а попадание в цель - это событие; в примере б) подбрасывание монеты - это испытание, а выпадение орла - это событие и т. д.
Условимся буквой P обозначать вероятность события, и сформулируем определение вероятности события.
Рассмотрим следующий пример. В урне содержится девять одинаковых, тщательно перемешанных между собой шаров, причем четыре из них - красных, три - синие и два - белые.
Поставлена задача: найти количественную оценку того, что взятый наудачу шар будет цветным. Каждый из возможных результатов испытания (извлечение шара из урны) будем называть элементарным исходом.
В нашем примере возможны девять элементарных исходов: C1, C2 - появился белый шар, C3, C4, C5 - появился синий шар, C6, C7, C8, C9 - появился красный шар.
Элементарные исходы, при которых событие наступает, называются благоприятствующими
исходами.
В нашем примере событию: "взятый шар цветной", благоприятствуют следующие исходы: C3, C4, C5, C6, C7, C8, C9. Поэтому вероятность того, что взятый шар окажется цветным, равна P=7/9.
Вероятностью события A называется отношение числа событий, благоприятствующих событию A (m), к общему числу всех равновозможных событий (n), т. е.
; 
Из определения вероятности вытекают следующие ее свойства:
1. Наибольшую вероятность имеет достоверное событие, т.к. для него все элементарные исходы - благоприятствующие, т. е. P = 1.
2. Наименьшую вероятность имеет невозможное событие - P = 0.
3. Вероятность любого случайного события удовлетворяет неравенству:
0 < P < 1.
Рассмотрим примеры, для решения которых используется вероятность событий. Нас будет интересовать применение комбинаторики к вычислению вероятностей.
Вот несколько примеров вычисления вероятностей с помощью сочетаний, размещений и перестановок.
Пример 1. Пусть мешок содержит одинаковые по размерам и материалу шары, помеченные числами от 1 до 90. Из мешка вытаскивают какие-то 5 шаров. Какова вероятность, что среди этих шаров один помечен числом 90?
Вначале приведем математическое решение задачи, затем составим алгоритм и программу на языке Паскаль, т.е. будем придерживаться традиционной схемы решения задач на компьютере:
математическая модель - алгоритм - программа - отладка.
Событием в этой задаче является извлечение пятерки шаров (например, попали пять шаров с числами 24, 35, 42, 64, 83).
Каждая такая пятерка является подмножеством из множества 90 элементов, поэтому число таких подмножеств равно числу сочетаний из 90 элементов по 5:
- это число и будет числом всех равновозможных событий, которое обозначим n, 
Какое число событий будет благоприятствовать появлению шара с номером 90?
Допустим, что шар с номером 90 извлечен из мешка, тогда в мешке останется 89 шаров, из которых извлекаются еще 4 шара в добавление к одному с номером 90.
Извлечь 4 шара из 89 можно
способами, именно это число событий будет благоприятствовать событию - появлению шара с номером 90; 
Искомая вероятность будет равна:
.Алгоритм
1. Содержание:
а) имя программы;
б) описание переменных и их типов;
в) описание процедуры вычисления числа сочетаний.
2. Выполнение операторов:
а) вызов процедуры сочетаний и вычисление числа сочетаний из 90 по 5;
б) вызов процедуры сочетаний и вычисление числа сочетаний из 89 по 4;
в) вычисление вероятности; г) вывод результата.
3. Конец.
По алгоритму составим программу, используя процедуру вычисления числа сочетаний.
Программа
Program Problem1;
uses WinCrt;
var
n1, m : longint;
p : real;
{----------------------------------------------------------------------------------------}
Procedure combination(n, k : integer; var s : longint);
var
i : longint;
begin
s := 1;
if k = 0 then s := 1
else for i := 1 to n - k do s := s*(k + i) div i
end;
{----------------------------------------------------------------------------------------}
begin
combination(90, 5, n1);
combination(89, 4, m);
p:=m/n1;
writeln('Вероятность появления шара с номером 90 равна ', p:6:4)
end.
Пример 2. Из пруда, в котором плавают 40 щук, выловили 5 щук, пометили их и пустили обратно в пруд. Во второй раз выловили 9 щук. Какова вероятность, что среди них окажутся ровно две помеченные щуки?
Математическое решение
Выясним общее число возможных событий, т.е. сколькими способами можно выловить 9 щук из 40 плавающих. Оно равно числу сочетаний из 40 по 9:
. Сколько событий будут благоприятствовать тому, что среди этих 9 щук будут 2 помеченные.
Во-первых, две помеченные щуки можно выбрать из 5 ранее помеченных следующим количеством способов:
. Во-вторых, к этим двум щукам надо добавить еще не помеченных 7 щук, которые можно выбрать из 35 не помеченных (ведь пять щук помеченные) количеством способов:
. Значит, общее число благоприятствующих событий будет равно произведению числа способов из 5 по 2 на число способов из 35 по 7:
.Тогда, искомая вероятность равна:
Вообще, если Y является m-подмножеством в n-множестве X и из X выбираются k-подмножество A, то вероятность того, что среди выбранных элементов содержится ровно r элементов из Y, равна:
Алгоритм
составления программы достаточно прост и поэтому сразу составим программу. Она будет такой:
Программа
Program Problem2;
uses WinCrt;
var
s1, s2, s3, p : real;
{----------------------------------------------------------------------------------------}
Procedure combination(n, k : integer; var s : real);
var
i : longint;
begin
s := 1;
if k = 0 then s := 1 else for
i := 1 to n - k do s := s*(k + i)/i
end;
{----------------------------------------------------------------------------------------}
begin
combination(40, 9, s1);
combination(35, 7, s2);
combination(5, 2, s3);
p := (s2*s3)/s1;
writeln('Вероятность появления двух помеченных щук равна ', p:6:4)
end.
Команда присваивания
В программе, которая была приведена выше, есть следующие записи: 
Что означает знак ":="?Так на языке Паскаль обозначается команда присваивания. В чем ее сущность?
Команда присваивания "стирает" предыдущее значение переменной и "придает" ей новое значение. На языке Паскаль команда присваивания обозначается: := двоеточие и знак равно.
В нашей программе, переменной b присваивается значение a + 17, что равно 33, переменной c присваивается значение частного от деления переменной b на 3,
Чтобы понять значение терминов "стирает" и "придает" в определении команды присваивания, надо немного глубже рассмотреть "компьютерную физиологию", т.е., что происходит в компьютере при выполнении команды присваивания.
Для каждой переменной в оперативной памяти компьютера отводится место - ячейка памяти, куда компьютер заносит значение этой переменной. Каждая ячейка имеет свое имя по имени переменной в программе. В нашей программе под переменные отведено 3 ячейки с именами a, b, c.
При выполнении команды присваивания в ячейки с этими именами будут занесены соответствующие числа. Если в них была записана какая-то информация, то она уничтожится. Происходит процесс похожий на запись на магнитофонную ленту. При записи новой информации прежняя стирается.
Логические операции
| Логическая операция | Ее значение | Примеры записи | Значение примера | ||||
| AND | Логическое "И" | (x<7) and (x>3) | x меньше 7 и x больше 3 (3|
| | |||
| OR | Логическое "ИЛИ" | (y>100) or (y<10) | y больше 100 или y меньше 10 (y<10, y>100) | ||||
| NOT | Логическое "НЕ" | not (x=2) | не x равно 2 |
Правила использования операций AND и OR (Таблица истинности)| a | b | a and b | a or b | ||||
| истина | истина | истина | истина | ||||
| истина | ложь | ложь | истина | ||||
| ложь | истина | ложь | истина | ||||
| ложь | ложь | ложь | ложь |
Остановимся немного подробнее на операции целочисленного деления (div) и операции, выдающей остаток от деления (mod).
Так, результатом целочисленного деления 17 на 5 будет 3:
17 div 5 = 3, а результатом деления меньшего числа на большее, будет 0:
46 div
200 = 0.
Делаем вывод, что при целочисленном деление дробная часть отбрасывается, сам термин "целочисленное деление" или "деление нацело" говорит сам за себя.
Операция a div b осуществляет целочисленное деление целого a на целое b.
Дробная часть при этом отбрасывается.
Еще одна интересная операция - остаток от деления a на b.
Понятно, что остатком от деления 17 на 5 будет число 2:
17 mod 5 = 2,
а вот чему будет равен остаток от деления меньшего числа на большее, например, 46 mod 200?
Оказывается, в этом случае, результатом операции будет число 46. Вот другие примеры:
34 mod
125 = 34,
120 mod 6 = 0.
Интересно, что остаток от деления любого целого числа на 10 будет равен последней цифре этого числа:
543 mod 10 = 3, 45 mod 10 = 5, 7 mod 10 = 7.
Рассмотрим задачу, которая показывает использование операций целочисленного деления и остатка от деления.
Пример 1. Найти разность между трехзначным числом и числом, составленным из тех же цифр, но взятых в обратном порядке.
При решении этой задачи, надо помнить, что компьютер не знает десятичной и позиционной формы записи чисел, так для него совершенно неизвестно, сколько в числе 342 сотен, десятков и единиц.
Это известно нам, потому что с раннего возраста мы используем такую форму записи чисел. Мы условились считать, что на первом месте слева стоит цифра единиц, на втором - цифра десятков, на третьем - цифра сотен и т.д.
Компьютеру это неизвестно! Он любое число переводит на язык двух цифр -
А для решения этой задачи нам необходимо знать цифры единиц, десятков и сотен заданного числа, чтобы затем переставить их, отсюда возникает первая задача - научить компьютер находить цифры числа, принадлежащие различным разрядам. Для этого можно использовать два способа.
Способ первый достаточно простой. Сущность которого в следующем.
Для определения цифры сотен делим данное число на 100 и остаток отбрасываем, т. е. выполняем целочисленное деление.
Для определения цифры десятков надо из данного числа вычесть сотни, результат разделить на 10 и остаток отбросить.
Для определения цифры единиц надо из данного числа вычесть сотни и десятки. Для записи числа теми же цифрами в обратном порядке, умножим цифру единиц на 100, сложим с цифрой десятков, умноженной на 10 и с цифрой сотен.
Далее из заданного числа вычитаем полученное новое. Например, для числа 342. Выполним целочисленное деление числа на 100, получим цифру сотен:
342 div 100 = 3;
вычитаем из 342 сотни 3*100 и результат делим на 10 - получим цифру десятков:
(342 - 3*100) div
10 = 4;
наконец, вычитаем из заданного числа сотни и десятки, получаем цифру единиц:
342 - 3*100 - 4*10 = 2.
Для записи числа в обратном порядке, умножаем цифру единиц 2 на 100 и складываем с цифрой десятков, умноженных на 10 (4*10) и прибавляем цифру сотен 3. Получим новое число, записанное теми же цифрами, но в обратном порядке:
2
100 + 410 + 3 = 243. Вычитаем: 342 - 243 = 99.
Программа
Program Problem1;
uses WinCrt;
var
a, s, d, e, b, r : integer;
begin
write('Введите трехзначное число '); readln(a);
s := a div 100;
d := (a - s*100) div 10;
e := a - s*100 - d*10;
b := e*100 + d*10 + s;
r := a - b;
writeln('Искомая разность равна ', r)
end.
Программа достаточно проста и понятна.
В разделе описаний переменным a, s, d, e, b, r устанавливается целый тип - integer.
Вводится трехзначное число и присваивается переменной a.
Переменной s присваивается результат целочисленного деления введенного числа a на 100. Это значение есть цифра сотен. Переменная d получает значение цифры десятков:
d := (a - s*100) div
10,
переменная e - это цифра единиц:
e := a - s*100 - d*10.
Дальнейшая работа программы понятна.
Математическое ожидание и дисперсия непрерывной случайной величины
Определение. Математическим ожиданием M(X) непрерывной случайной величины X, плотностью вероятности которой является функция p(x), называется величина интеграла
(4)если он сходится абсолютно, а дисперсией называется величина интеграла
(5)если он сходится [где a = M(X)].
Легко заметить полную аналогию определений математического ожидания непрерывной и прерывной случайных величин. В формуле (5) суммирование заменено интегрированием (что вполне естественно для непрерывной случайной величины). Роль xi играет непрерывно изменяющаяся переменная x. Так как p(x)
с точностью до бесконечно малых высшего порядка по сравнению с 
дает вероятность того, что случайная величина примет какое-нибудь значение из интервала (x, x + ), то ясно также, что p(x)dx и pi играют одинаковую роль. Так же устанавливается полная аналогия определений дисперсии непрерывной и прерывной случайных величин.Пример 1. Минутная стрелка электрических часов передвигается скачками поминутно. Вы бросили взгляд на часы. Они показывают a минут. Тогда для Вас истинное время в данный момент будет случайная величина. Найти ее функцию распределения.
Решение
Функция распределения истинного времени равна 0 для всех x
a и единице для x > a + 1. Время течет равномерно. Поэтому вероятность того, что истинное время меньше a + 0.5 мин, равна 0.5, так как одинаково вероятно, прошло ли после a менее или более полминуты. Вероятность того, что истинное время - меньше a+0.25 мин, равна 0.25 (вероятность этого времени втрое меньше вероятности того, что истинное время больше a + 0.25 мин, а сумма их равна единице, как сумма вероятностей противоположных событий). Аналогично рассуждая, найдем, что вероятность того, что истинное время меньше a + 0.6 мин, равна 0.6. В общем случае вероятность того, что истинное время меньше 
мин 
, равна 
Следовательно, функция распределения истинного времени имеет такое выражение:
Она непрерывна всюду, а производная ее непрерывна во всех точках за исключением двух: x = a и x = a + 1.
Программа
Program
Function_Continuous1;
uses WinCrt;
var
a : integer;
x, alfa : real;
{---------------------------------------------------------------------------------------}
Function Fx(a : integer; x, alfa : real) : real;
begin
if x < a
then Fx := 0
else if x = a + alfa
then Fx := alfa
else Fx := 1
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите число минут, которое показывает минутная стрелка ');
readln(a);
write('Введите значение аргумента функции распределения '); readln(x);
if (x - a < 1) and (x - a > 0) then alfa := x - a
else alfa := 0;
write('Значение функции распределения равно ', Fx(a, x, alfa):4:6)
end.
Пример 2. Случайная величина X равномерно распределена. Ее плотность вероятности p(x) = A, если a
x b и p(x) = 0, если x < a и x > b. Определить коэффициент A. Решение
По формуле (3') получаем:
тогда 
отсюда находим A:
Программа
Program Problem2;
uses WinCrt;
var
AA, a, b : real;
begin
write('Введите левую границу интервала '); readln(a);
write('Введите правую границу интервала '); readln(b);
AA := 1/(b - a);
writeln('Значение коэффициента A равно ', AA:6:6)
end.
Математическое ожидание
Рассмотрим дискретную случайную величину X, которая принимает следующие значения x1, x2, ..., xk с вероятностями p1, p2, ..., pk. Произведем n независимых испытаний для определения значений величины X, и пусть каждое значение xi встретится ni раз (i = 1, 2, ..., k), так что n1 + n2 + ... + nk = n.Этот процесс очень похож на n - кратное бросание игральной кости, а значения x1, x2, ..., xk на выпадение соответствующего числа очков (1, 2, 3, 4, 5, 6); n1, n2, n3, ..., nk
- на число выпадения этого числа очков.
Среднее арифметическое из полученных значений определяется формулой:
(1)(каждое значение надо учитывать слагаемым столько раз, сколько раз оно встретилось!).
Представим среднее арифметическое
в следующем виде: 
(2)При большом числе испытаний (n) относительные частоты ni/n будут близки соответствующим вероятностям
ni/n = pi
= P(X = xi),
тогда, значение среднего арифметического x будет приблизительно равно
Определение. Математическим ожиданием MX дискретной случайной величины X называется сумма произведений всех ее возможных значений xi на их вероятности pi:
Если множество возможных значений дискретной случайной величины X бесконечно, то математическое ожидание будет выражаться суммой бесконечного ряда:
При этом мы всегда будем предполагать, что этот бесконечный ряд абсолютно сходится (т.е. имеет конечную сумму), в противном случае считается, что математическое ожидание случайной величины не существует.
Математическое ожидание MX называют также средним значением случайной величины X, подчеркивая тем самым статистический смысл этого понятия (статистическим аналогом математического ожидания служит среднее арифметическое из эмпирических значений случайной величины).
Надо заметить, что в отличие от среднего арифметического значения, которое само по себе является случайной величиной, так как зависит от числа испытаний, математическое ожидание является числом, которое связано только с законом распределения случайной величины.
Математическое ожидание MX называют еще центром распределения случайной величины X.
Это название произошло из-за аналогии с понятием центра тяжести для системы материальных точек, расположенных на одной прямой; если на оси x в k точках с координатами x1, x2, ..., xk сосредоточены массы p1, p2, ..., pk, то координата xc центра тяжести системы находится по формуле
для распределения вероятностей
и результат становится равным
Метод статистических испытаний
Статистические испытания предполагают многократное повторение однотипных испытаний. Результат любого отдельного испытания случаен и сам по себе какого-либо интереса не представляет. В то же время совокупность большого числа подобных результатов оказывается весьма полезной. Она обнаруживает определенную устойчивость (ее называют статистической устойчивостью), которая позволяет количественно описать явление, исследуемое в данных испытаниях. Рассмотрим специальный метод исследования случайных процессов, основанный на статистических испытаниях. Его так и называют - метод статистических испытаний. Другое название этого метода, которое используется чаще, - метод Монте-Карло.Прежде, чем рассмотреть непосредственное применение этого метода надо познакомится с понятием геометрической вероятности.
Наиболее вероятное число событий биномиального распределения
Из распределения вероятностей по биномиальному закону видно, что вероятность вначале возрастает, а затем убывает. Естественно возникает вопрос о числе событий, имеющей наибольшую вероятность.
При возрастании m от 0 до n-1 это отношение убывает от np/q до p/nq. Если np > q и nq > p, то рассматриваемое отношение переходит от значений больших 1, к значениям, меньшим 1. А это означает, что вероятность P(X = m) сначала возрастает, а затем убывает. И лишь в крайних случаях, когда np < q или nq < p, вероятности P(X = m) изменяются монотонно.
Во всех случаях наиболее вероятное значение X = m0 находится из неравенств
откуда следует, что
Этому неравенству удовлетворяет только одно целое число m0 , если только np + p не является целым числом: в последнем случае имеются два наиболее вероятных значения X = np + p - 1 и X = np + p. В частном случае, когда произведение np - целое число, оно и является наиболее вероятным значением величины X.
Пример 5. Вероятность появления бракованной детали равна 0.02. Определить наиболее вероятное число годных деталей в партии из 1000 штук, а также математическое ожидание и дисперсию случайной величины.
{ Биномиальный закон распределения вероятностей }
{ Наиболее вероятное число исходов }
Program Problem5;
uses WinCrt;
var
p, m1, m2, mx, dx : real;
n, m0 : integer;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите общее число деталей в партии '); readln(n);
write('Введите вероятность появления бракованной детали ');
readln(p);
m1 := n*p + p - 1; m2 := n*p + p;
if (m1 = m2) and (m1 = trunc(m1)) then m0 := trunc(m1)
else m0 := trunc(m2);
mx := n*p; dx := n*p*(1 - p);
write('Наиболее вероятное число бракованных деталей ');
writeln(' в этой партии равно ', m0);
writeln('Математическое ожидание равно ', mx:1:6);
writeln('Дисперсия случайной величины равна ', dx:1:6)
end.
Из этого примера видно, что наиболее вероятное число появление событий при малой вероятности и большом числе исходов - m0, равно математическому ожиданию дискретной случайной величины mx (m0 = mx).
Некоторые замечательные функции
6.1. Функция БесселяДля
а для 
Легко видеть, что
. Эти функции играют важную роль в математической физике, небесной механике и т. д.Для определения слагаемых применим рекуррентную формулу
В качестве начальных значений суммы и слагаемого использовать член ряда при k = 0, равный
. Для вычисления значения функции при k = 0, необходимо использовать функции вычисления степени c основанием
и показателем n, а также функцию вычисления факториала числа n.Функция вычисления степени.
Function
Extent(x : real; n : integer) : real;
var
i : integer;
E : real;
begin
E := 1;
if n = 0 then E := 1
else for
i := 1 to n do E := E*x/2;
Extent := E
end;
Функция вычисления факториала.
Function Fakt(n : integer) : longint;
var
i : integer;
F : longint;
begin
F := 1;
if n = 0 then F := 1
else for
i := 1 to n do F := F*i;
Fakt := F
end;
А теперь составим функцию вычисления всей суммы
Function J(x, eps : real; n : integer) : real;
var
y, jj : real;
k : integer;
begin
k := 0; y := Extent(x, n)/Fakt(n); jj := 0;
repeat
jj := jj + y;
k := k + 1;
y := -y*x*x/(4*k*(n + k))
until abs(y) < eps;
J := jj
end;
Программа
Program Bessel;
uses WinCrt;
var
n : integer;
x, eps : real;
{----------------------------------------------------------------------------------------}
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Function Extent(x : real; n : integer) : real;
var
i : integer;
E : real;
begin
E := 1;
if n = 0 then E := 1
else for
i := 1 to n do E := E*x/2;
Extent := E
end;
{----------------------------------------------------------------------------------------}
Function Fakt(n : integer) : longint;
var
i : integer;
F : longint;
begin
F := 1;
if n = 0 then F := 1
else for
i := 1 to n do F := F*i;
Fakt := F
end;
{----------------------------------------------------------------------------------------}
Function J(x, eps : real; n : integer) : real;
var
y, jj : real;
k : integer;
begin
k := 0; y := Extent(x, n)/Fakt(n); jj := 0;
repeat
jj := jj + y;
k := k + 1;
y := -y*x*x/(4*k*(n + k))
until abs(y) < eps;
J := jj
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение x '); readln(x);
write('Введите значение n '); readln(n);
write('Введите точность вычисления '); readln(eps);
writeln('Значение функции Бесселя равно ', J(x, eps, n):6:t(eps))
end.
6.2. Гамма-функция Эйлера
Рассмотрим (вместе с Эйлером) бесконечное произведение
считая x отличным от нуля и от всех целых отрицательных чисел.
Легко представить его общий множитель так:
отсюда вытекает, что наше произведение (абсолютно) сходится.
Определяемая им функция
является (после элементарных) одной из важнейших рассматриваемых в анализе функций, а ее роль в теории вероятностей просто неоценима.Используя формулу
составим функцию вычисления 
Для этого найдем, что n-й член бесконечного произведения 
будет равен 
, а первый член должен быть равен 
тогда, при увеличении n можно получать соответствующие значения гамма-функции.Теперь надо оставить функцию для вычисления степени действительного положительного аргумента a с любым действительным показателем x. Для этого достаточно воспользоваться соотношением:
где a > 0.Function
Extent_real(a, x : real) : real;
begin
Extent_real := exp(x*ln(a))
end;
Теперь можно составить основную функцию для вычисления гамма-функции.
Function G(x, eps : real) : real;
var
n : longint;
g1, gg : real;
begin
n := 1; gg := Extent_real((n + 1)/n, x)/(x*(x + n));
repeat
n := n + 1;
gg := gg*n*Extent_real((n + 1)/n, x)/(x + n);
n := n + 1;
g1 := gg*n*Extent_real((n + 1)/n, x)/(x + n)
until abs(g1 - gg) < eps;
G := gg
end;
Программа
Program
Gamma_function;
uses WinCrt;
var
x, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - количества знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Function Extent_real(a, x : real) : real;
begin
Extent_real := exp(x*ln(a))
end;
{----------------------------------------------------------------------------------------}
Function G(x, eps : real) : real;
var
n : longint;
g1, gg : real;
begin
n := 1; gg := Extent_real((n + 1)/n, x)/(x*(x + n));
repeat
n := n + 1;
gg := gg*n*Extent_real((n + 1)/n, x)/(x + n);
n := n + 1;
g1 := gg*n*Extent_real((n + 1)/n, x)/(x + n)
until abs(g1 - gg) < eps;
G := gg
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение аргумента '); readln(x);
write('Введите точность вычисления '); readln(eps);
writeln('Значение гамма-функции равно ', G(x, eps):6:t(eps))
end.
Так как n- е частичное произведение имеет вид
тогда можно положить
Написав аналогичную формулу для
легко видеть, что
и мы приходим к простому и важному соотношению:
Если вы выполняли предыдущую программу для различных значений аргумента, то смогли убедиться, что точность вычисления невелика, даже при достаточно большом значении n.
Формула
дает возможность более точно вычислять значения гамма-функции для значений аргумента, заключенного в интервале (1; 2).Для этого составим следующую функцию:
Function
Gamma(x, eps : real) : real;
begin
x := x - 1;
Gamma := x*G(x, eps)
end;
Program
Gamma_function;
uses WinCrt;
var
x, eps, gg : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - количества знаков после запятой }
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Function Extent_real(a, x : real) : real;
begin
Extent_real := exp(x*ln(a))
end;
{----------------------------------------------------------------------------------------}
Function G(x, eps : real) : real;
var
n : longint;
g1, gg : real;
begin
n := 1; gg := Extent_real((n + 1)/n, x)/(x*(x + n));
repeat
n := n + 1;
gg := gg*n*Extent_real((n + 1)/n, x)/(x + n);
n := n + 1;
g1 := gg*n*Extent_real((n + 1)/n, x)/(x + n)
until abs(g1 - gg) < eps;
G := gg
end;
{----------------------------------------------------------------------------------------}
Function Gamma(x, eps : real) : real;
begin
x := x - 1;
Gamma := x*G(x, eps)
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение аргумента '); readln(x);
write('Введите точность вычисления '); readln(eps);
if (x < 2) and (x > 1) then gg := Gamma(x, eps)
else gg := G(x, eps);
writeln('Значение гамма-функции равно ', gg:6:t(eps))
end.
Если положить x равным натуральному числу m, то получим рекуррентную формулу
Так как
(что легко проверить), то отсюда 
Эта формула дает еще одну возможность уточнить значения функции для натуральных значений аргумента. Для вычисления по этой формуле составим еще одну функцию.
Function G_natural(m : integer) : longint;
var
i : integer;
g : longint;
begin
g := 1;
for i := 2 to m do
g := g*i;
G_natural := g
end;
Программа
изменится и станет такой:
Program
Gamma_function;
uses WinCrt;
var
x, eps, gg : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - количества знаков после запятой }
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
Function Extent_real(a, x : real) : real;
begin
Extent_real := exp(x*ln(a))
end;
{----------------------------------------------------------------------------------------}
Function G(x, eps : real) : real;
var
n : longint;
g1, gg : real;
begin
n := 1; gg := Extent_real((n + 1)/n, x)/(x*(x + n));
repeat
n := n + 1;
gg := gg*n*Extent_real((n + 1)/n, x)/(x + n);
n := n + 1;
g1 := gg*n*Extent_real((n + 1)/n, x)/(x + n)
until abs(g1 - gg) < eps;
G := gg
end;
{----------------------------------------------------------------------------------------}
Function Gamma(x, eps : real) : real;
begin
x := x - 1;
Gamma := x*G(x, eps)
end;
{----------------------------------------------------------------------------------------}
Function G_natural(m : integer) : longint;
var
i : integer;
g : longint;
begin
g := 1;
for i := 2 to m do
g := g*i;
G_natural := g
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение аргумента '); readln(x);
write('Введите точность вычисления '); readln(eps);
if x = trunc(x)
then gg := G_natural(trunc(x))
else
if (x < 2) and (x > 1)
then gg := Gamma(x, eps)
else gg := G(x, eps);
writeln('Значение гамма-функции равно ', gg:6:t(eps));
end.
Еще одну важную формулу для функции
мы получим, если перемножим почленно равенства 
и 
Мы находим:
или 
Это - формула Вейерштрасса.
Библиотека часто встречающихся процедур и функций
55. Вычисление числа e.
Procedure number_e(eps : real; var
e : real);
var
n : integer;
u : real;
begin
e := 0; u := 1; n := 1;
repeat
e := e + u;
u := u/n; n := n + 1
until 3*u <= eps;
end;
56. Вычисление корней любой степени из произвольного числа.
Procedure Radical(n : integer ; x, eps : real; var b : real);
var
n : integer;
z, m, u : real;
begin
b := 1; u := 1; n := 1;
repeat
u := (m - n + 1)*x*u/n; b := b + u; n := n+1
until abs(u) <= eps;
end;
57. Процедура вычисления бесконечного произведения
Procedure
Multiplication(eps : real; var Mult : real);
var
n : longint;
Mult1 : real;
begin
n := 2; Mult1 := 1;
repeat
Mult1 := Mult1*(1 - 1/sqr(n));
n := n + 1;
Mult := Mult1*(1 - 1/sqr(n))
until abs(Mult - Mult1) < eps
end;
58. Процедура вычисления числа
по формуле Валлиса.Procedure Wallis(eps : real; var Mult : real);
var
n : longint;
Mult1 : real;
begin
n := 1; Mult := 1;
repeat
Mult := Mult*(4*sqr(n)/(4*sqr(n)-1));
n := n + 1;
Mult1 := 4*sqr(n)/(4*sqr(n)-1)
until Mult1 < eps
end;
59. Процедур вычисления эллиптического интеграла 1-го рода через бесконечное произведение.
Procedure Elliptic(k, eps : real; var Kk : real);
var
Kk1 : real;
begin
Kk1 := k;
repeat
k := (1 - sqrt(1 - sqr(k)))/(1 + sqrt(1 - sqr(k)));
Kk1 := Kk1*(1 + k);
k := (1 - sqrt(1 - sqr(k)))/(1 + sqrt(1 - sqr(k)));
Kk := Kk1*(1 + k);
until abs(Kk1 - Kk) < eps;
Kk := Kk*Pi/2
end;
60. Рекуррентная функция вычисления интеграла вероятностей.
Function
FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
61. Процедура вычисления интеграла
.Procedure
Integral(x, eps : real; var I : real);
var
n : integer;
u : real;
begin
u := x; n := 1; I := 0;
repeat
I := I + u;
n := n + 1;
u := -(u*x*x*(2*n - 3))/((2*n - 2)*sqr(2*n - 1))
until abs(u) < eps
end;
62. Процедура вычисления эллиптического интеграла 2-го рода с помощью интегрирования рядов.
Procedure Elliptic2(k, eps : real; var Ek : real);
var
n : integer;
u : real;
begin
u := k*k/4; n := 1; Ek := 0;
repeat
Ek := Ek + u;
n := n + 1;
u := (u*k*k*(2*n - 1)*(2*n - 3))/(4*n*n);
until abs(u) < eps;
Ek := Pi*(1 - Ek)/2
end;
63. Функция Бесселя:
Function
J(x, eps : real; n : integer) : real;
var
y, jj : real;
k : integer;
begin
k := 0; y := Extent(x, n)/Fakt(n); jj := 0;
repeat
jj := jj + y;
k := k + 1;
y := -y*x*x/(4*k*(n + k))
until abs(y) < eps;
J := jj
end;
64. Функция вычисления степени положительного действительного числа с произвольным действительным показателем.
Function
Extent_real(a, x : real) : real;
begin
Extent_real := exp(x*ln(a))
end;
65. Функции для вычисления гамма-функции.
Для произвольного действительного аргумента x, отличного от нуля и от всех целых отрицательных чисел.
Function G(x, eps : real) : real;
var
n : longint;
g1, gg : real;
begin
n := 1; gg := Extent_real((n + 1)/n, x)/(x*(x + n));
repeat
n := n + 1;
gg := gg*n*Extent_real((n + 1)/n, x)/(x + n);
n := n + 1;
g1 := gg*n*Extent_real((n + 1)/n, x)/(x + n)
until abs(g1 - gg) < eps;
G := gg
end;
Вычисление гамма-функции для значений аргумента из промежутка (1, 2)
Function Gamma(x, eps : real) : real;
begin
x := x - 1;
Gamma := x*G(x, eps)
end;
Вычисление гамма-функции натурального аргумента.
Function
G_natural(m : integer) : longint;
var
i : integer;
g : longint;
begin
g := 1;
for i := 2 to m do
g := g*i;
G_natural := g
end;
Упражнения
194. Вычислить сумму членов рядов, заданных формулами общего члена. Число членов ряда задается пользователем.
195. Составьте функции для нахождения с указанной точностью числа
путем вычисления следующих рядов: a)
б) ряд Леонардо Эйлера:
196. Составьте функции для вычисления с указанной точностью значений тригонометрических функций путем вычисления следующих рядов:
а)
Для вычисления значения члена ряда использовать рекуррентную формулу
б)
Для определения значения члена ряда использовать формулу
197. Дано действительное x. Вычислить приближенное значение бесконечной суммы:
Нужное приближение считается полученным, если вычислена сумма нескольких первых слагаемых, и очередное слагаемое оказалось по модулю меньше 0.00001.
198. Вычислить приближенное значение бесконечной суммы (справа от каждой суммы дается ее точное значение, с которым можно сравнить полученный результат):
а)
0.6931478... ,б)
1,в)
г)
Нужное приближение считается полученным, если вычислена сумма нескольких первых слагаемых, и очередное слагаемое оказалось по модулю меньше данного положительного числа eps.
199. Дано: натуральное n, действительное x. Вычислить:
а)
б) 
в)
200. Дано: действительные a, h, натуральное n. Вычислить
где 
201. Дано: натуральное n, действительное x. Вычислить:
202. Вычислить:
а)
б) 
в)
г) 
203. Вычислить сумму членов ряда
с точностью до члена ряда меньшего 0.0000001.
204. Установить, сходятся ли следующие ряды:
а)
б) 
в) 
205. Составить программу вычисления бесконечного произведения:
Частичное произведение имеет вид
где C - эйлерова постоянная, а
бесконечно малая. Произведение сходится и его значение равно 
206. Эйлером были найдены следующие разложения тригонометрических функций в бесконечные произведения:
1)
2)
Составьте программы вычисления этих произведений и вычислите значения sinx и cosx с заданной точностью.
207. Дано натуральное n. Получить:
а)
б) 
в)
г)
д)
е) 
208. Дано натуральное n. Получить
где
209. Вычислить интеграл
Использовать разложение в логарифмический ряд.Ответы
К заданию 1
Program
Task1; {Вычисление sinx с помощью ряда}
uses WinCrt;
var
n, k : integer;
x, e, eps, sin, u : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
write('Задайте точность вычисления '); readln(eps);
write('Введите значение аргумента в радианах '); readln(x);
u := x; n := 2;
sin := x;
repeat
u := -u*x*x/((2*n-1)*(2*n-2));
sin := sin + u;
n := n + 1
until abs(u) < eps;
write('Значение sin( ', x:1:t(eps), ' ) равно ', sin:3:t(eps));
writeln(' с точностью до ', eps:1:t(eps))
end.
К
заданию 2
Program Task2;
uses WinCrt;
var
n : integer;
p, u, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
write(' Укажите точность вычисления числа пи '); readln(eps);
u := 1; p := 0; n := 1;
repeat
p := p + u;
n := n + 1;
u := -u*(2*n - 3)/(2*n - 1)
until abs(u) < eps;
write('Число Пи равно ', 4*p:1:t(eps), ' с точностью до ');
writeln(eps:1:t(eps))
end.
К
заданию 3
Program Task3;
uses WinCrt;
var
k : integer;
a, u, z, z1, e, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение a>1 '); readln(a);
write('Задайте точность eps '); readln(eps);
u := 1; z := 0;
repeat
u := u*a;
z := z + 1/(1 + u);
z1 := z + 1/(1 + u*a)
until abs(z1 - z) < eps;
write('Сумма ряда равна ', z1:1:t(eps));
writeln(' с точностью до ', eps:1:t(eps))
end.
К
заданию 4
Program Task4;
uses WinCrt;
n : integer;
var
a : longint;
{----------------------------------------------------------------------------------------}
Function c(a : integer) : longint;
var
s, z : integer;
begin
z := 0;
repeat
s := a mod 10;
z := z + s;
a := a div 10
until s = 0;
c := z
end;
{----------------------------------------------------------------------------------------}
begin
a := 7;
n := 1;
while n <= 1000 do
begin
a := c(a*a);
n := n + 1
end;
writeln(n - 1, '- й член последовательности равен ', a)
end.
Непрерывные случайные величины
Определение 1. Случайная величина называется непрерывной, если функция ее распределения всюду непрерывна, а производная функции распределения непрерывна во всех точках, за исключением, быть может, конечного числа точек на любом конечном интервале.Примерами непрерывных случайных величин могут служить: диаметр детали, которую токарь обтачивает до заданного размера, рост человека, дальность полета снаряда и др.
Определение 2. Плотностью вероятности f(x) непрерывной случайной величины называется производная ее функции распределения F(x), т.е. f(x) = F'(x). (1)
Нормальное распределение
Случайная величина X распределена по нормальному закону, если ее плотность вероятности равна
(1)Для нормального закона распределения:
Функция распределения нормально распределенной случайной величины
(2)Функция F(x) связана с функцией Лапласа
равенствомСледует вспомнить из предыдущего раздела рекуррентную функцию вычисления функции Лапласа и используя ее составить функцию вычисления нормально распределенной случайной величины:
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if
x > 5
then FF := 1
else if x < -5
then
FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u; n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until
abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
(3)Для нормальной распределенной случайной величины X верны формулы
- (4)вероятность того, что X примет значения от
до 
;
- (5)вероятность отклонения X от a
по модулю меньше, чем на
;
- (6) правило "трех сигм".
Примеры
1. Автомат штампует детали. Контролируется длина детали X, которая распределена нормально с математическим ожиданием (проектная длина), равным 50 мм. Известно, что средняя квадратическая ошибка равна 3.6 мм.
Найти вероятность того, что длина наудачу взятой детали находится в границах а) от 55 мм до 68 мм; б) от 32 мм до 40 мм.
Математическое решение задачи
По условию
По формуле (4) получаем:а)
.б)
Для составления программы достаточно использовать функцию Муавра-Лапласа.
Программа
Program Normal1;
uses WinCrt;
var
a, a1, b, c, PP : real;
{----------------------------------------------------------------------------------------}
{ Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer; u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u; n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите математическое ожидание (проектную длину) a ');
readln(a);
write('Введите левую границу интервала '); readln(a1);
write('Введите правую границу интервала '); readln(b);
write('Введите среднюю квадратическую ошибку '); readln(c);
pp := 0.5*(FF((b - a)/c)-FF((a1 - a)/c));
write('Вероятность того, что деталь находится в ');
writeln('заданных границах равна ', pp:1:6)
end.
2. Автомат изготовляет шарики для подшипников. Шарик считаем принятым, если отклонение X диаметра шарика от заданного размера по абсолютной величине меньше 0.7 мм. Считается, что X распределена нормально со средним квадратическим отклонением
= 0.4 мм. Найти, сколько будет годных шариков среди 50 изготовленных.Решение
По условию задачи отклонение X шарика от заданного размера a есть случайная величина.
Следовательно, M(X) = 0. Допустимая ошибка отклонения
мм, а средняя квадратическая ошибка 0. 4 мм. Найдем вероятность того, что наугад рассмотренный шарик будет принят, т.е. для него X не превзойдет по абсолютной величине , по формуле (5).
Тогда из 50 шариков в среднем будет принято 50
P(|X| < 0.7).Программа
Program Normal2;
uses WinCrt;
var
e, c : real;
n : integer;
{----------------------------------------------------------------------------------------}
{ Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
begin
writeln('Введите отклонение X диаметра шарика');
write('от заданного размера по абсолютной величине '); readln(e);
write('Введите среднее квадратическое отклонение '); readln(c);
write('Введите число изготовленных шариков '); readln(n);
n := Round(FF(e/c)*n);
writeln('Число годных шариков равно ', n)
end.
3. Случайная величина X распределена нормально со средним квадратическим отклонением
= 5 мм. Найти длину интервала, симметричного относительно M(X), в который с вероятностью 0.990 попадает X в результате испытания.Решение
В условии задачи дано, что
= 5 мм, а P(|X - a| < ) = 0.990. Необходимо найти . Тогда 
- длина интервала.
По формуле (5) получаем
Теперь остается найти аргумент функции Муавра-Лапласа. Для этого достаточно составить следующую небольшую процедуру:
{ Процедура нахождения аргумента функции Муавра-Лапласа }
Procedure
Argument(PP : real; var x : real);
begin
x := 0;
repeat
x := x + 0.0001
until FF(x) >= PP
end;
Процедуре организована с помощью цикла с последующим условием repeat
... until ... , в котором заведомо установлен шаг - 0.0001 для поиска аргумента. Однако этот шаг можно изменить или вводить в процедуру по усмотрению пользователя.
Тогда процедуру можно построить так:
{ Процедура нахождения аргумента функции Муавра-Лапласа }
Procedure
Argument(PP, eps : real; var x : real);
begin
x := 0;
repeat
x := x + eps
until FF(x) >= PP
end;
Новый способ задания случайной величины
Ранее дискретная случайная величина характеризовалась законом распределения. Однако задать случайную величину можно и иначе, например так называемой функцией распределенияЭтот способ является более общим, чем предыдущий и приводит нас к рассмотрению непрерывных случайных величин.
Рассмотрим событие, состоящее в том, что случайная величина Y примет какое-нибудь значение, меньшее произвольного числа x, т.е. Y < x. Оно имеет определенную вероятность. Обозначим ее F(x) = P(Y < x).
При изменении x будут, вообще говоря, меняться вероятности
Поэтому F(x) можно рассматривать как функцию переменной величины x. Случайная величина будет полностью охарактеризована, если для каждого x 
будет известно значение функции. Определение. Функцией распределения случайной величины Y называется функция F(x), выражающая для каждого x вероятность того, что случайная величина Y примет какое-нибудь значение, меньшее x.
Будем говорить, что известно распределение случайной величины Y, если известна ее функция распределения F(x).
Пример 1. Пусть вероятность изготовления нестандартного изделия при некотором технологическом процессе равна 0.06. Контролер берет из партии изделие и сразу проверяет его качество. Если оно оказывается нестандартным, дальнейшие испытания прекращаются, а партия задерживается. Если же изделие оказывается стандартным, контролер берет следующее и т. д., но всего проверяет не более пяти изделий. Найти функцию распределения случайной величины Y - числа проверяемых изделий.
Решение
Нам известен закон распределения случайной величины:
| Число проверяемых изделий | 1 | 2 | 3 | 4 | 5 | ||||||
| Вероятность | 0.06 | 0.056 | 0.053 | 0.050 | 0.0781 |
Случайная величина Y не принимает значений, меньших 1. Следовательно, если x
1, то событие Y < x невозможно, а вероятность его равна нулю. Поэтому равна нулю функция распределения случайной величины Y для всех значений x1. Для всех x, удовлетворяющих двойному неравенству 1 < x 2, функция F(x) равна 0.06.
Действительно, если, например, x = 1.2, то F(x) означает вероятность события
Но случайная величина Y принимает значение, меньшее 1.2, в одном случае: значение 1 с вероятностью 0.06. Покажем, что для всех x, удовлетворяющих двойному неравенству 2 < x
3, 
Пусть, например, 
Тогда F(3) выражает вероятность события 
Это возможно в двух случаях: или случайная величина Y принимает значение 1 (с вероятностью 0.06), или 2 (с вероятностью 0.056). Применяя теорему сложения вероятностей, мы и получим указанное значение функции F(x) при x = 3. Аналогичными рассуждениями можно найти функцию распределения. Запишем ее в виде таблицы.
|
x |
x1 |
1 |
2 |
3 |
4 |
x>5 |
|
F(x) |
0 |
0.06 |
0.116 |
0.169 |
0.219 |
1 |
В программе обратите внимание на организацию форматированного вывода результата.
Program Function1; { Функция распределения случайной величины }
uses WinCrt;
Const
k = 20;
type
t = array[1..k] of integer;
tt = array[0..k] of real;
var
x : t; p : tt;
i, n : integer; pp : real;
begin
write('Введите общее число проверяемых изделий '); readln(n);
writeln('Вводите число изделий и соответствующие им вероятности');
for i := 1 to
n do
begin
write('Число изделий '); readln(x[i]);
write('Соответствующая вероятность '); readln(p[i])
end;
for i := 1 to n do write(x[i]:2+i*2); writeln;
for i := 1 to n do write(p[i]:1:4, ' ':3); writeln;
writeln('Значения аргумента функции распределения x');
write('(-бесконечность; ', x[1], ']; ':4);
for i := 1 to
n-1 do write('(', x[i], '; ',x[i + 1], ']', '; ':3);
write('(', x[n], '; +бесконечность)'); writeln;
write(' ',0:4, ' '); pp := 0;
for i := 1 to n - 1 do
begin
pp := pp + p[i];
write(pp:1:4, ' ':2)
end;
write(0:4, ' '); writeln
end.
Пример 2. Прибор состоит из двух блоков, вероятность безотказной работы каждого из которых в течение времени
равна 0.5. Найти ряд распределения для числа блоков, работающих в момент t = T. Найти функцию распределения F(x) дискретной случайной величины X, заданной в задаче. Решение
Ряд распределения вероятностей
|
xi |
0 |
1 |
2 |
|
pi |
1/4 |
1/2 |
1/4 |
Если 0 < x
1, то в промежуток (; x) попадает одно значение X = 0, следовательно, F(x) = P(X = 0) = 1/4 = 0.25. Если 1 < x
2, то в промежуток (, x) попадает два значения X = 0 и X=1, следовательно, F(x) = P(X = 0) + P(X =1) = 3/4 = 0.75. Если 2 < x <
, то в промежуток (, x) попадают все значения X т.е. X=0, X = 1, X = 2. Следовательно, F(x) = 1. Получаем
Свойства функции распределения: F(
) = 0; F() = 1; 0 F(x) 1; если 
то 
Другими словами, функция распределения любой случайной величины является неубывающей функцией, а изменяется она от 0 до 1 при изменении x от
до . Программа
Program Function2; { Функция распределения случайной величины }
uses WinCrt;
Const
k = 20;
type
t = array[1..k] of integer;
tt = array[0..k] of real;
var
x : t;
p, pp : tt;
i, n, m : integer;
xx : real;
{----------------------------------------------------------------------------------------}
{ Функция распределения случайной величины }
Function Fx(xx : real) : real;
begin
if xx <= 0
then Fx := 0
else
if (xx > 0) and (xx <= 1)
then Fx := pp[1]
else
if (xx > 1) and (xx <= 2)
then Fx := pp[2]
else Fx := 1
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите общее число испытаний '); readln(n);
writeln('Вводите число испытаний и соответствующие им вероятности');
for i := 1 to
n do
begin
write('Число испытаний '); readln(x[i]);
write('Соответствующая вероятность '); readln(p[i])
end;
for i := 1 to n do write(x[i]:3+i*2); writeln;
for i := 1 to n do write(p[i]:1:4, ' ':3); writeln;
writeln(' Значения аргумента функции распределения x');
write('(-бесконечность; ', x[1], ']; ':4);
for i := 1 to
n-1 do write('(', x[i], '; ',x[i + 1], ']', '; ':4);
write('(', x[n], '; +бесконечность)'); writeln;
write(' ',0:4, ' ');
m := 0; pp[0] := 0;
for i := 1 to n - 1 do
begin
m := m + 1;
pp[m] := pp[m-1] + p[i];
write(pp[m]:1:4, ' ':2)
end;
write(1:4, ' '); writeln;
writeln('Функция распределения случайной величины');
write('Введите значение аргумента '); readln(xx);
writeln('Значение функции F(x) равно ' , Fx(xx):1:4)
end.
Вероятность попадания случайной величины X в промежуток [a; b) определяется формулой
(1)Операции отношения или сравнения
| Знак | Наименование | Пример | Пояснение | ||||
| < | Меньше | a < 6 | a меньше 6 | ||||
| <= | Меньше или равно | b <= 23 | b меньше или равно 23 | ||||
| > | Больше | x > 5 | x больше 5 | ||||
| >= | Больше или равно | y >= 8 | y больше или равно 8 | ||||
| = | Равно | c = 10 | c равно 10 | ||||
| <> | Не равно | d <> 3 | d не равно 3 |
Оператор цикла fordowntodo
Существует другая форма оператора цикла for:for <пар .цик.> := <нач. зн.> downto <кон. зн.> do
<оператор>.
Замена зарезервированного слова to на downto
означает, что шаг параметра цикла равен (-1).
Изменение значения параметра идет от большего значения к меньшему, т. е. <нач. знач.>
<кон. знач.>. Программу вычисления факториала числа можно составить, используя этот оператор цикла.
Программа
Program Problem1a;
uses WinCrt;
var
n, i, f : longint;
begin
write('Введите натуральное число '); readln(n);
f := 1;
if n <> 0 then for i := n downto 1 do f := f*i;
writeln('Факториал числа ', n, ' равен ', f)
end.
Графическое изображение циклов for будет таким (см. рис. 22):
Рис. 22
Здесь: p - переменная цикла; n - ее начальное значение; k - ее конечное значение. Тело цикла составляет оператор или несколько операторов: s1; s2; ... sn;, которые нарисованы в прямоугольнике. Задание 1
1. Выполните программу примера 1 на компьютерах.
2. Измените и дополните ее так, чтобы она вычисляла следующую сумму:
1! + 2! + 3! + ... + n!.
Разберем другие, на мой взгляд, более интересные примеры с использованием циклов for
... to ... do ..., а также вложенных друг в друга циклов (циклов в циклах), совмещение циклов с параметром с другими циклами.
Пример 2. Квадрат любого натурального числа n равен сумме n первых нечетных чисел:
12 = 1
22 = 1 + 3
32 = 1 + 3 + 5
42 = 1 + 3 + 5 + 7
52 = 1 + 3 + 5 + 7 + 9
. . . . . . . . . . . . . . . . . . .
Основываясь на этом свойстве, составить программу, позволяющую напечатать квадраты натуральных чисел от 1 до n.
Ясно, что цикл в программе надо организовать от 1 до n, в котором выполнять всего три оператора: находить сумму нечетных чисел (а их как раз столько, сколько раз будет выполняться цикл); выдавать полученную сумму на экран; "получать" следующее нечетное число.
Программа
Program Problem2;
uses WinCrt;
var
i, n, s, k: integer;
begin
writeln(' Введите натуральное число, до которого надо');
write('выводить квадраты чисел '); readln(n);
writeln('Квадраты чисел следующие:');
s := 0; k := 1;
for i := 1 to n do
begin
s := s + k;
writeln('Квадрат числа ', i, ' равен ', s);
k := k + 2
end
end.
Задание 2
1. Измените программу так, чтобы она выдавала на экран не таблицу квадратов чисел от 1 до n, а квадрат только одного числа n, введенного пользователем.
2. Измените и дополните программу так, чтобы она выдавала значение квадрата числа и те нечетные числа, сумме которых он равен.
3. Продолжая тему возведения натуральных чисел в степень, без операций умножения, рассмотрим еще два интересных примера. В первом из них нам придется совмещать, "вкладывать" друг в друга два цикла for, а во втором, циклы for и repeat.
Пример 3. Куб любого натурального числа n равен сумме n нечетных чисел, следующих по порядку за числами, сумма которых составляла куб предыдущего числа n - 1:
13 = 1
23 = 3 + 5
33 = 7 + 9 + 11
43 = 13 + 15 + 17 + 19
. . . . . . . . . . . . . . . . . . . . . .
Основываясь на этом свойстве, создайте программу, позволяющую напечатать таблицу кубов натуральных чисел.
Вот здесь уже нужны два цикла. Один - внешний, по количеству нечетных чисел, которое равно возводимому в куб числу, например, для 43 этот цикл должен выполняться 4 раза. В этом же цикле надо будет после подсчета суммы выводить ее значение на экран вместе с числом, которое возводится в куб.
Второй - внутренний, который будет суммировать нечетные числа и "вырабатывать" нужные нечетные числа для суммирования.
Программа
Program
Problem3; { Кубы натуральных чисел от 1 до n }
uses WinCrt;
var
i, j, n, s, k : longint;
begin
writeln('Введите натуральное число, до которого надо');
write('выводить кубы чисел '); readln(n);
writeln('Кубы чисел следующие:');
k := 1;
for i := 1 to n do
begin
s := 0;
for j := 1 to i do
begin
s := s + k; k := k + 2
end;
writeln('Куб числа ', i, ' равен ', s)
end
end.
Разберем работу этой программы
Переменные i и j нужны в качестве переменных первого - внешнего и второго - внутреннего циклов. Переменная k для нечетных чисел, а s для суммы чисел. Тип этих переменных установлен целый, но longint, так как могут быть достаточно большие целые числа, большие 32767.
Программа начинается с запроса для пользователя с помощью операторов writeln и write о вводе натурального числа, до которого надо выдавать таблицу кубов чисел. Затем с помощью оператора readln это значение вводится в память компьютера и присваивается переменной n.
Выводится надпись "Кубы чисел следующие". Она дана перед началом циклов по понятным причинам. В циклах ее дать нельзя, - она будет повторяться несколько раз. По окончании циклов тоже, тогда она будет написана внизу, после вывода самих чисел. Переменной k присваивается первое нечетное значение 1.
Начинается внешний цикл по количеству чисел, от 1 до n. В цикле несколько операторов, поэтому "открываются" операторные скобки: - begin ...
Перед началом внутреннего цикла обнуляется переменная s - сумма. Причем такое обнуление будет происходить каждый раз, когда повторяется внешний цикл, перед началом выполнения внутреннего цикла.
Внутренний цикл выполняется от 1 до i. Почему? В цикле вычисляется сумма и увеличивается нечетное k на 2, т. е. "вырабатывается" следующее нечетное число.
Заметьте!
Переменной k не присваивается перед началом каждого внутреннего цикла 1. Почему?
Следующим оператором writeln внутри внешнего цикла выдается информация на экран. Почему он размещен во внешнем цикле?
Пример 4. Из математики известно, что всякая натуральная степень числа n есть сумма n последовательных нечетных натуральных чисел. Составьте программу, которая для любой степени натурального числа n находила бы последовательность нечетных чисел, сумме которых равна эта степень.
Например, для 53 она выдавала бы последовательность чисел: 21, 23, 25, 27, 29.
План составления программы
1. Определим цель составления программы: надо показать, что действительно любую натуральную степень натурального числа можно представить в виде суммы последовательных нечетных чисел.
А если это так, тогда нам совершенно необходимо знать значение степени числа n с показателем k.
Это можно сделать с помощью простого цикла:
s := 1;
for i := 1 to k do s := s*n;
Значение степени будут накапливаться в переменной s, для этого ей устанавливается первоначальное значение 1.
В цикле, значение переменной s последовательно, k раз умножается на основание степени n. После выполнения цикла переменная s получит значение степени числа n с показателем k.
2. Вся острота вопроса состоит в том, что неизвестно первое нечетное число, от которого надо начинать суммирование последовательных нечетных чисел.
Для этого надо пробовать складывать нечетные числа вначале от 1 и далее (известно их количество - n);
1 + 3 + 5 + 7 + 9 ...,
а затем проверять полученный результат, сравнивая со значением степени s. Если равенство выполняется, тогда закончить цикл и вывести на экран полученные нечетные числа, если равенство не выполняется, тогда надо начинать суммирование со следующего нечетного числа - 3: 3 + 5 + 7 + 9 ... и т.д.
Этот процесс легче организовать с помощью цикла repeat. Переменной j, которая будет задавать начальные нечетные числа надо установить перед началом цикла первоначальное значение 1.
Общий вид такого цикла:
j := 1;
repeat
. . . . . .
j := j + 2
until ...= s;
3. Осталось продумать, как подсчитывать суммы последовательных нечетных чисел. Мы уже сталкивались с этим вопросом и знаем, что для этого надо создать цикл от 1 до n, в котором в одну из переменных, скажем m, накапливать эту сумму, а вторая переменная должна "вырабатывать" следующее нечетное число.
Этот цикл можно записать так:
p := j; m := 0;
for i := 1 to n do
begin
m := m + p; p := p + 2
end;
Обратите внимание! Переменная p, каждый цикл repeat, (внешний по отношению к данному), будет получать новое начальное значение нечетного числа, а переменная m - для суммы должна обнуляться перед каждым новым суммированием для другой последовательности нечетных чисел.
4. Наконец, когда последовательность нечетных чисел найдена, ее надо вывести на экран. Для этого надо устроить еще один цикл от 1 до n, в котором выдавать значения этих нечетных чисел. За первое нечетное число из последовательности надо взять значение j, но так как оно уже увеличилось на 2, то из j следует вычесть 2. Этот цикл будет:
j := j - 2;
for i := 1 to n do
begin
write(j, ' ');
j := j + 2
end
Программа
Program Problem4;
uses WinCrt;
var
n, i, k, j, m, s, p : longint;
begin
write('Введите натуральное число - основание степени '); readln(n);
write('Введите натуральное число - показатель степени '); readln(k);
s := 1; j := 1;
for i := 1 to k do s := s*n;
repeat
p := j; m := 0;
for i := 1 to n do
begin
m := m + p;
p := p + 2
end;
j := j + 2
until m=s;
write('Степень с основанием ', n);
writeln(' и показателем ', k, ' т. е. ', s);
writeln('равна сумме следующих нечетных чисел');
j := j - 2;
for i:=1 to n do
begin
write(j, ' ');
j := j + 2
end
end.
Чтобы лучше понять ее работу, возьмите степень 25 и проверьте как будут последовательно выполняться операторы программы.
Задание 3
1. Выполните эту программу на компьютерах.
2. Составьте программу, которая выясняет, может ли произведение а) трех; б) четырех последовательных натуральных чисел равняться некоторой степени некоторого натурального числа (квадрату, кубу, и т. д.)?
Оператор if then else
Многие представляют ЭВМ как чисто вычислительную машину, что является заблуждением. ЭВМ способна, подобно человеку, принимать решения.Вот некоторые простые решения, которые принимает человек в зависимости от условия.
Если
пойдет дождь, тогда надо взять зонтик,
иначе, зонтик не брать.
Если в комнате темно, тогда надо включить свет.
Человек, принимая какое-то решение, может сомневаться, взвешивать, прикидывать, машина принимает решения категорически: либо - да, либо - нет и никаких сомнений.
Для реализации принимаемых решений на языке Паскаль могут быть использованы операторы if
(если), then (тогда) и else (иначе).
После оператора if записывается условие, а после операторов then и else - команды, которые необходимо выполнить.
Для более ясного понимания использования этих операторов, рассмотрим следующий пример.
Пример 2. Составить программу, после выполнения которой меньшее из двух неравных чисел будет увеличено вдвое, а большее оставлено без изменения.
Программа
Program
Problem2; { Увеличения меньшего из двух целых чисел вдвое }
uses WinCrt;
var
a, b, c : integer;
begin
write('Введите первое целое число '); readln(a);
write('Введите второе целое число '); readln(b);
if a < b then c := 2*a
else c := 2*b;
writeln('Меньшее число ', c div 2);
writeln('Оно же увеличенное вдвое ', c)
end.
После пуска программы вводятся два целых числа и их значения присваиваются переменным a и b. Далее, в операторе if проверяется условие (a
После этого выводится на экран меньшее число и это же число, но увеличенное вдвое.
Заметьте,
в процедуре writeln, кроме вывода информации, выполняется еще и деление переменной c на 2.
В процедуре write (writeln) можно записывать выполнение арифметических операций.
Ещё одно существенное замечание. Вы уже заметили, что перед оператором else
точка с запятой не ставится.
Программа имеет один недостаток. В ней не учитывается то, когда введенные числа будут равны. В этом случае на экран надо выдать сообщение: "Числа равны".
Программа
Program
Problem2a; {Программа удвоения меньшего из двух чисел}
uses WinCrt;
var
a, b, c : integer;
begin
write('Введите первое число '); readln(a);
write('Введите второе число '); readln(b);
if a = b then writeln('Числа равны')
else
begin
if a < b then c := 2*a
else c := 2*b;
writeln('Меньшее число ', c div 2);
writeln('Удвоенное меньшее число ', c)
end
end.
В этой программе два условных оператора, первым проверяется условие равенства чисел и, в случае его выполнения, будет выдано сообщение о равенстве чисел, которое находится в операторе then.
В операторе else
записано несколько команд, поэтому в нём установлены операторные скобки:
begin
........
end;
Такие же операторные скобки в необходимых случаях могут быть использованы и в операторе then.
ВЫВОДЫ
В операторах then и else могут быть использованы операторные скобки:
begin ... end;,
где записывается еще одна группа операторов.
Перед оператором else точка с запятой не ставится.
Задание 2
1. Введите первую программу примера 2 и выполните ее. Измените программу так, как это было сделано во втором случае, т. е. с учетом равенства вводимых чисел.
2. Составьте программу определения большего из двух чисел.
3. Составить программу определения модуля числа.
Операторы read и readln Процедуры ввода информации
Так же, как и для операторов вывода информации, операторы read и reeadln являются операторами обращения к встроенным процедурам ввода информации.Операторы read (считывать) и readln, который происходит от двух английских слов read (считывать) и line (строка) используются в программах для ввода информации в память компьютера и "считывания" значений в переменную.
Рассмотрим работу этих операторов и процедур ввода информации.
В нашей программе есть процедура readln(a). При выполнении программы, встретив оператор readln, компьютер приостановит работу в ожидании ввода информации. После того, как мы введем с клавиатуры значение переменной a - 16, компьютер присвоит это значение переменной a, т.е. отправит его в ячейку памяти с именем a и продолжит выполнение программы. Этот процесс мы называем "считыванием" значения в переменную.
Итак, процедуры read и readln "считывают" значения переменных и присваивают их тем переменным, которые записаны в них.
Таких переменных может быть несколько, тогда они записываются в этих операторах через запятую, например:
read(a, b, c, n, g, j, i), readln(e,f, k, p, d) и т.п.
Чем же отличается работа процедур read и readln?
Процедура read потребует после себя ввод или вывод информации в одну строку, а процедура readln дает возможность после себя вводить и выводить информацию с начала новой строки.
Например:
В программе: write('Введите значения a и b '); read(a, b);
write('Ввод информации в одну строку');
При выполнении этой части программы, на экран будет выведено все то, что записано в первом операторе write, затем в той же строке будет находиться курсор, и компьютер будет ждать ввода значений a и b. Введем их значения - 2 и 3, разделяя их пробелом или, иначе говоря, через пробел. После этого, в той же строке будет выдана информация записанная в следующем операторе write.
На экране:
Введите значения a и b 2 3 Ввод информации в одну строку
В программе:
writeln('Введите значения a, b и c); readln(a, b, c);
writeln('Ввод и вывод информации с начала строки');
На экране:
Введите значения a, b и c
2 3 4
Ввод и вывод информации с начала строки
Операторы write и writeln Процедуры вывода информации
Вы обратили внимание, что в программе были использованы операторы write и writeln. Английское слово write переводится - писать, а слово writeln происходит как сокращение от двух английских слов write - писать и line - строка.Кроме операторов write и writeln мы говорим о процедурах вывода информации.
Что же такое процедура?
Понятие процедуры - одно из основных понятий Паскаля. Ему подобна подпрограмма на языке Бейсик.
Процедура - это некоторая последовательность операторов языка Паскаль, имеющая имя и к которой можно обратиться из любого места основной программы, указав ее имя.
Выше мы говорили об операторах вывода информации, хотя в Паскале, в отличие от Бейсика нет операторов вывода информации, а через служебные слова write и writeln происходит обращение к стандартной или встроенной
процедуре вывода информации. Стандартная процедура не нуждается в предварительном описании, она доступна любой программе, в которой содержится обращение к ней. Вот почему обращение к write или writeln напоминает оператор PRINT - вывода информации на языке Бейсик.
Разница между оператором вывода и обращением к процедуре вывода состоит в том, что имя процедуры вывода, как и любой другой процедуры Паскаля не является зарезервированным словом, а, следовательно, пользователь может написать свою собственную процедуру с именем write или writeln. Но это очень редко используется на практике.
Таким образом, операторы write и writeln являются операторами обращения к встроенным процедурам вывода информации.
Обе эти процедуры выводят информацию на экран, если эта информация содержится в виде значений переменных, тогда достаточно в скобках в операторах write или writeln записать имена этих переменных, например: write(a), writeln(f). Если таких переменных несколько, то их записывают через запятую, например: write(a, b, c, d), writeln(e,f, g, h).
Если информацией являются слова, предложения, части слов или символы, тогда она заключается между знаками " ' " - апостроф, например:
write('Введите длину пути'),
writeln('Значение скорости равно'
Возможен одновременный вывод и символьной информации и значений переменных, тогда в операторе write или writeln они разделяются запятыми, например:
write('Значение температуры равно ', t),
writeln('Скорость равна ', v, ' при времени движения ', t).
Заметьте, в конце слов, перед апострофом оставлен пробел.
Для чего это сделано? Конечно, чтобы следующая числовая информация была разделена со словами пробелом.
В чем состоит отличие
в работе процедур write и writeln?
Процедура write требует от следующих процедур ввода или вывода, информацию вводить или выводить ее на ту же строку (в одну строку).
Если в программе указан оператор write и за ним следуют еще операторы write или writeln, то выводимая ими информация будет присоединяться к строке информации первого оператора write.
Например: write('Сегодня и завтра будут ');
write('выходные дни ');
На экран выводится:
Сегодня и завтра будут выходные дни
Пробел между словом "будут" и "выходные" обеспечивается за счет пробела в конце первой строки. Если его не будет, то вывод произойдет слитно:
write('Сегодня и завтра будут');
write('выходные дни');
Сегодня и завтра будутвыходные дни
Еще некоторые примеры: t:=20;
write('Время движения равно ');
write(t);
write(' секунд');
Время движения равно 20 секунд
a := 18; b := 12;
write('Сумма чисел равна ');
write(a+b);
write(', а произведение ');
write(a*b);
Сумма чисел равна 30, а произведение 216
Процедура writeln обеспечивает для следующих процедур ввода или вывода информации вводить или выводить ее с начала каждой новой строки.
В программе:
writeln('Сегодня вечером, вечером, вечером,');
writeln('Когда пилотам, скажем прямо, делать нечего');
На экран выводится:
Сегодня вечером, вечером, вечером,
Когда пилотам, скажем прямо, делать нечего
В программе:
a := 25;
b := 17;
writeln('Сумма и разность чисел равны:');
writeln(a + b);
writeln(a - b);
На экране:
Сумма и разность чисел равны:
42
8
Определение законов распределения дискретных величин эмпирическим (опытным) путем
Как мы уже знаем, для случайного события статистическим аналогом вероятности служит относительная частота, которую можно получить, повторяя опыт или наблюдение n раз и регистрируя относительную частоту m/n появления события.Тогда закон распределения вероятностей можно записать в виде следующей таблицы:
| X |  |  | ... |  | |||||
| Относительная частота |  |  | ... |  |
При достаточно большом числе n повторений испытания мы вправе считать, что относительны частоты mi/n будут близки к соответствующим вероятностям pi= P(X = xi) (i = 1, 2, ..., k).
Попытаемся программными средствами Турбо Паскаля построить закон распределения числа очков, выпадающей на верхней грани игральной кости.
Составить процедуру, подсчитывающую относительные частоты выпадения очков нетрудно. Она может быть построена так:
Procedure Game(n, num : longint; var p : real);
var
m, x, i : longint;
begin
randomize;
m := 0;
for
i := 1 to n do
begin
x := random(6) + 1;
if
x = num then m := m + 1
end;
p := m/n
end;
Здесь, переменная n - число повторений испытания, которые задет пользователь, num - число очков на верхней грани игральной кости, вероятность выпадения которых надо определить, - это 1, 2, 3, 4, 5 или 6.
С помощью функции случайных чисел random(6) + 1 вырабатывается случайное целое число из промежутка [1, 6], т.е., по сути дела, моделируется выпадение числа очков при "бросание" игральной кости.
С помощью условного оператора if x = num then m := m + 1 подсчитывается число появления указанного числа очков при повторении испытания (бросания).
После завершения цикла, определяется относительная частота появления заданного числа очков и выводится в переменной p.
Программа
Program Problem1;
uses WinCrt;
var
n, num : longint;
p : real;
{----------------------------------------------------------------------------------------}
Procedure Game(n, num : longint; var
p : real);
var
m, x, i : longint;
begin
randomize;
m := 0;
for i := 1 to n do
begin
x := random(6) + 1;
if x = num then m := m + 1
end;
p := m/n
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите число повторений испытания '); readln(n);
writeln('Введите число очков, вероятность');
write('выпадения которых надо найти '); readln(num);
Game(n, num, p);
writeln('Относительная частота появления события ', p:1:9);
writeln('Сравните с теоретически найденной вероятностью ', 1/6:1:9)
end.
Можно видеть, что при увеличении числа повторений испытания относительная частота приближается к теоретически предсказанной вероятностью.
Однако возникают много вопросов. Самый первый из них - сколько повторений испытания надо сделать, чтобы с достаточной уверенностью можно было утверждать, что относительная частота равна вероятности? Какова степень этой "уверенности" или, выражаясь более точно, достоверности (достаточной уверенности)?
Чтобы ответить на эти и другие вопросы, надо обратиться к "числовым характеристикам распределения".
Сумма цифр числа равна
К заданию 1Program
Task1;
uses WinCrt;
var
a, e, d, s, t, s1, p : integer;
begin
write('Введите четырехзначное число '); readln(a);
e := a mod 10; a := a div 10;
d := a mod 10; a := a div 10;
s := a mod 10; t := a div 10;
s1 := e + d + s + t; {Сумма цифр}
p := e*d*s*t; {Произведение цифр}
writeln(' Сумма цифр числа равна ', s1);
writeln('Произведение цифр равно ', p)
end.
К заданию 2
Задача 2
Program Task2_2;{Определение большего из двух чисел}
uses WinCrt;
var
a, b, c : integer;
begin
write('Введите первое число '); readln(a);
write('Введите второе число '); readln(b);
if a = b then writeln('Числа равны')
else if a > b then writeln('Большее число ', a)
else
writeln('Большее число ', b)
end.
Задача 3
Program Task2_3;{Определение модуля числа}
uses WinCrt;
var
a : integer;
begin
write('Введите целое число '); readln(a);
if a >= 0 then writeln('Модуль числа ', a, ' равен ', a)
else writeln('Модуль числа ', a, ' равен ', -a)
end.
К заданию 3
Program
Task3; { Решение уравнения ax = b }
uses WinCrt;
var
a, b : real;
begin
write('Введите первый коэффициент '); readln(a);
write('Введите свободный член '); readln(b);
if
a <> 0 then writeln('Уравнение имеет одно решение ', b/a:6:3)
else if (a = 0) and (b <> 0)
then
writeln('Уравнение не имеет решений')
else writeln('Уравнение имеет б/м решений')
end.
К заданию 4
Program
Task4; { Входят ли четные цифры в запись трехзначного числа? }
uses WinCrt;
var
a, s, d, e : integer;
begin
write('Введите трехзначное число '); readln(a);
e := a mod 10; a := a div 10; d := a mod 10; s := a div 10;
if (s mod 2 = 0) or (d mod 2 = 0) or (e mod 2 = 0)
then writeln('Четные цифры входят в запись этого числа')
else writeln('Четные цифры не входят в запись числа')
end.
К заданию 2
Задача 2
1-й способ
Program Task2_2;
uses WinCrt;
var
n, p, n1 : longint;
begin
write('Введите натуральное число n '); readln(n);
n1 := 0;
while n > 0 do
begin
p := n mod 10;
n1 := n1*10 + p;
n := n div 10
end;
writeln('Число, после перестановки цифр ', n1 + n)
end.
2-й способ
Program Task2_2a;
uses WinCrt;
var
n, p, n1 : longint;
begin
write('Введите натуральное число '); readln(n);
n1 := 0;
while n > 0 do
begin
n1 := n1*10 + n mod 10;
n := n div 10
end;
writeln('Число, после перестановки цифр равно ', n1)
end.
К
заданию 3
Задача 2
Program Task3_2;
uses WinCrt;
var
n, a, p, b, s : integer;
begin
write(' Введите натуральное число меньшее 28 '); readln(a);
b := 100;
writeln('Трехзначные числа, сумма цифр которых');
write('равна числу ', a, ' следующие: ');
while b < 1000 do
begin
s := 0; n := b;
while n <> 0 do
begin
p := n mod 10;
s := s + p;
n := n div 10
end;
if s = a then write(b, ', ');
b := b + 1
end; writeln
end.
Задача 3
Program Task3_3;
uses WinCrt;
var
n, d, e : integer;
begin
n := 10;
write('Искомое двузначное число ');
while n <= 99 do
begin
d := n div 10; e := n mod 10;
if n + d*d*d + e*e*e = e*10 + d then
writeln(n);
n := n + 1
end
end.
К
заданию 4
Program Task4;
uses WinCrt;
var
n, a, p, b, s : integer;
begin
write('Введите натуральное число '); readln(a);
b := 1;
writeln('Натуральные числа, сумма цифр ');
write('которых равна числу ', a, ' следующие: ');
while b < 32767 do
begin
s := 0; n := b;
while n <> 0 do
begin
p := n mod 10; s := s + p; n := n div
10
end;
if s = a then write(b, ', ');
b := b + 1
end; writeln
end.
К
заданию 1
Program Task1;
uses WinCrt;
var
n, a, k : integer;
begin
n := 131;
repeat
n := n + 131;
a := n; k := 0;
repeat
k := k + 1;
a := a div 10
until a = 0;
until k mod 2 = 0;
writeln('Наименьшее натуральное число, кратное 131');
writeln(' с четным количеством цифр равно ', n)
end.
К
заданию 2
Program Task2_2;
uses WinCrt;
var
a, n, p, s : integer;
begin
a := 100;
writeln('Трехзначные числа, при делении которых на 11');
write('частное равно сумме квадратов их цифр следующие ');
repeat
n := a; s := 0;
repeat
p := n mod 10;
s := s + p*p;
n := n div 10
until n = 0;
if (a mod 11 = 0) and (s = a div
11) then write(a, '; ');
a := a + 1
until a = 1000;
end.
К заданию 4
Program
Task4; { НОК двух чисел. 1 - способ }
uses WinCrt;
var
a, b, m, n, p : integer;
begin
write('Введите первое число '); readln(a);
write('Введите второе число '); readln(b);
p := 0;
repeat
if a>b then
begin
m := a; n := b
end
else
begin
m := b; n := a
end;
p := p + m
until p mod n =0;
writeln('НОК чисел ', a, ' и ', b, ' равен ', p)
end.
К заданию 5
Program
Task5; { Является ли число простым? 2- способ }
uses WinCrt;
label 1, 2;
var
n, i : integer;
begin
write('Введите целое число '); readln(n);
i := 3;
if n = 2 then writeln('Число ', n, ' - простое')
else if n = 3
then writeln('Число ', n, ' - простое')
else
if n mod 2 = 0 then
writeln('Число ',n,' составное')
else
repeat
if
n mod i = 0 then goto 1;
i := i + 2
until
i > n div 2;
writeln('Число ', n, ' простое'); goto 2;
1: writeln('Число ', n, ' составное');
2: end.
К заданию 1
Program
Task1;
uses WinCrt;
var
n, s, s1 : integer;
{----------------------------------------------------------------------------------------}
Procedure extent(a, n : integer; var s : integer);
var
i : integer;
begin
i := 1; s := 1;
repeat
s := s*a; i := i + 1
until i = n
end;
{----------------------------------------------------------------------------------------}
begin
n := 1;
repeat
n := n + 1;
extent(2, n, s);
extent(3, n, s1);
until ((s - 2) mod (n - 1) <> 0) and
((s1 - 3) mod (n - 1) = 0);
writeln(' Искомое число равно ', n - 1)
end.
К
заданию 2
Program Task2;
uses WinCrt;
var
n, s, s1 : integer;
{----------------------------------------------------------------------------------------}
Procedure extent(a, n : integer; var s : integer);
var
i : integer;
begin
i := 1;
s := 1;
repeat
s := s*a;
i := i+1
until i=n
end;
{----------------------------------------------------------------------------------------}
begin
n := 1;
repeat
n := n+1;
extent(2, n, s);
extent(3, n, s1);
until ((s-2) mod (n-1)<>0) and
((s1-3) mod (n-1)=0);
writeln('Искомое число равно ', n-1)
end.
К заданию 3
Program Task3; { Сумма правильных делителей }
uses WinCrt;
var
i, a, b, s : integer;
{----------------------------------------------------------------------------------------}
Procedure math_divisor(n : integer; var s : integer);
var
d : integer;
begin
s := 0;
for d := 1 to n div 2 do
if n mod d = 0 then s := s + d
end;
{----------------------------------------------------------------------------------------}
К заданию 1
К примеру 1
Program Task1;
uses WinCrt;
var
p : longint;
{----------------------------------------------------------------------------------------}
Procedure placement(n, k : integer; var r : longint);
var
i : integer;
begin
r := 1;
for i := 1 to k do r := r*(n - k + i)
end;
{----------------------------------------------------------------------------------------}
begin
placement(40, 3, p);
writeln('Число различных способов равно ', p)
end.
К
примеру 2
Program Task1_2;
uses WinCrt;
var
s, r1, r2, r3 : longint;
{----------------------------------------------------------------------------------------}
Procedure placement(n, k : integer; var r : longint);
var
i : integer;
begin
r := 1;
for i := 1 to k do r := r*(n - k + i)
end;
{----------------------------------------------------------------------------------------}
begin
placement(5, 1, r1);
placement(5, 2, r2);
placement(5, 3, r3);
s := r1 + r2 + r3;
writeln(' Не более чем трехзнач. чисел можно составить');
writeln('из цифр 1, 2, 3, 4, 5; ', s, ' способами')
end.
К заданию 2
К примеру 1
Program Task2_1;
uses WinCrt;
var
p1, p2, p : longint;
m, n : integer;
{----------------------------------------------------------------------------------------}
Procedure placement(n, k : integer; var r : longint);
var
i : integer;
begin
r := 1;
for i := 1 to k do r := r*(n - k + i)
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите число всех элементов '); readln(m);
write('Введите число выбираемых элементов '); readln(n);
placement(m, n, p1);
Переменные и их имена
Под переменной в языке Паскаль, как и в других языках программирования, понимают программный объект (число, слово, часть слова, несколько слов, символы), имеющий имя и значение, которое может быть получено и изменено программой.Если "заглянуть" в компьютер, то переменную можно определить так.
Переменная - это имя физического участка в памяти, в котором в каждый момент времени может быть только одно значение.
Само название "переменная" подразумевает, что содержимое этого участка может изменяться.
В качестве имен переменных в Паскале могут быть латинские буквы с индексами. Причем может быть не одна буква, а несколько.
В качестве числового индекса может быть любое целое число. Всего в обозначении переменных может быть произвольное число символов, но значащими считаются первые 63 символа. В некоторых версиях Паскаля допускаются имена переменных, содержащие до 8 символов.
Примеры обозначений переменных: a, b, e, vert, trenin, d, f1, g23, p564, red18 и т.п.
Имена переменных называются идентификаторами.
Замечания
Не имеет значение в обозначении переменных маленькими или большими (строчными или прописными) буквами они написаны!
Имя переменной должно удовлетворять следующим требованиям:
1) всегда начинаться с буквы, после которой при необходимости может следовать некоторое целое число (индекс);
2) в идентификаторе (имени) не должно быть пробелов, запятых или других непредусмотренных знаков, например недопустимы следующие имена переменных: jan.2 (есть точка); 3x (начинается с цифры); a 2 (имеется пробел); чн (русские буквы);
3) нельзя использовать в качестве имен переменных слова, которые являются служебными или операторами, например: program, begin, write, end и другие.
Перестановки с повторениями
Пример 8. Сколько различных слов, каждое из которых состоит из семи букв, можно составить из букв слова "коробок".В отличие от предыдущего примера здесь не все буквы слова различны (там были все цифры разными). Если бы все буквы были различны, то из них можно было бы составить 7! различных слов.
Однако не все перестановки букв дают новые слова. Очевидно, что перестановка букв "к", так же как и букв "о", между собой не дают нового слова. Следовательно, рассматриваемая задача свелась к тому, чтобы определить число перестановок, в результате которых получается одно и то же слово. Число перестановок буквы "к" между собой, в результате которых получаются одинаковые слова равно 2! После каждой такой перестановки буква "о" может быть переставлена 3! способами. Применяя правило произведения, получим, что каждое новое слово будет повторяться
раз, и поэтому число различных слов, которое можно составить из слова "коробок", равно 
. Вообще, пусть дано множество M = {a, b, c, ...}, состоящее из n элементов, из которых элемент a повторяется n1 раз, элемент b - n2 раз, элемент c - n3 раз, ... так, что
Требуется найти число перестановок с заданным числом повторений входящих в него элементов.
Число перестановок в этом случае определяется по формуле:
где
Если 
то из этой формулы получается: 
Программа
Program Problem8;
uses WinCrt;
var
s, k1, k2 : longint;
{----------------------------------------------------------------------------------------}
Procedure Factorial(n : integer; var f : longint);
var
i : integer;
begin
f := 1;
if n = 0 then f := 1
else for i := 1 to n do f := f*i
end;
{----------------------------------------------------------------------------------------}
begin
Factorial(7, s); Factorial(3, k1); Factorial(2, k2);
s := s div (k1*k2);
writeln('Из слова "КОРОБОК" можно составить ', s, ' различных слов')
end.
Перестановки
Пример 6. Каким числом способов 10 человек могут находиться в очереди?Рассуждая над этой задачей, нам становится понятным, что необходимо 10 элементов (10 человек) разместить на 10 местах в очереди, т.е. необходимо выполнить размещения
из 10 элементов по 10 -
, которое равно: = 1098 ... 321 = 10!Размещения из n
элементов по n называются перестановками из n элементов. Таким образом, две различные перестановки из n элементов могут отличаться друг от друга не числом элементов, а только порядком расположения элементов.
Определение. Пусть имеется конечное множество M = {a1, a2, ..., an}. Всякое упорядоченное множество, состоящее из n элементов множества M, называется перестановкой этого множества.
Согласно определению, число всевозможных различных перестановок из n элементов равно:
Не забывайте, что принято 0! = 1.
Для решения нашей задачи, надо составить программу с процедурой вычисления факториала числа.
Program Problem6;
uses WinCrt;
var
n, f : longint;
{----------------------------------------------------------------------------------------}
Procedure Factorial(n : integer; var
f : longint);
var
i : integer;
begin
f := 1;
if n = 0 then f := 1
else for i := 1 to n do
f := f*i
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите число элементов множества '); readln(n);
Factorial(n, f);
writeln('Десять человек могут находится в очереди ', f, ' способами')
end.
Пример 7. Сколько четных пятизначных чисел можно составить из цифр
2, 3, 4, 5, 9?
Математический алгоритм решения
Четными будут те числа, которые оканчиваются четной цифрой. В данном примере четных цифр две.
Допустим, что одна из четных цифр находится во всех случаях на последнем месте, тогда все получаемые числа будут четными. Сколько таких чисел будет? Их будет столько, сколько перестановок можно сделать из оставшихся 4-х цифр, т. е. 4! Но среди заданных цифр есть еще одна четная. Допустим, что теперь эта вторая цифра находится на последнем месте, тогда снова будут получаться четные числа и их также будет 4!
Окончательное число четных пятизначных чисел равно
Программу составить нетрудно. Выполните это самостоятельно.
Повторение
О рекурсии1. Подпрограмме на Паскале (т.е. функции или процедуре) разрешено обращаться к самой себе - либо напрямую, либо через цепочку вызовов других подпрограмм, приводящую к первоначальной точке вызова.
О подпрограмме, которая вызывает саму себя, говорят, что она рекурсивна.
Многие математические функции и алгоритмы, будучи запрограммированы на Паскале, наиболее естественно выражаются именно в рекурсивной форме. В большинстве случаев рекурсивное решение задачи получается достаточно простым, но в то же время оказывается крайне неэффективным в сравнении с итеративной реализацией этого алгоритма.
2. Рекурсивное определение какого-либо понятия или процесса должно содержать два обязательных элемента: 1) условие прекращения рекурсии, задающее некоторое фиксированное значение для одного или нескольких простых этапов вычисления; 2) выражение более сложного этапа вычислений в терминах менее сложного. Правильно организованный рекурсивный процесс развивается таким образом, что любая сколь угодно сложная ситуация в конце концов сводится к условию прекращения рекурсии.
3. В качестве примера, демонстрирующего рекурсию, часто используют функцию факториала, определяемую как произведение всех натуральных чисел от 1 до n (в математической нотации n!). Например, 4! = 1 . 2 . 3 .
4 = 24. Этому вычислительному процессу можно придать и рекурсивную трактовку. Роль условия выхода из рекурсии здесь играет равенство 0! = 1 или 1! = 1. Выражение сложного этапа через более простой имеет вид n! = (n - 1)!
n. 4. В подпрограмме на Паскале рекурсивный вызов внешне выглядит точно так же, как и вызов любой другой подпрограммы. Так, в функции fac, вычисляющей значение "n-факториал", ее тело имеет следующий вид:
if (n = 0) or (n = 1) then
fac := 1 {завершение рекурсии}
{иначе - рекурсивный вызов}
else fac := fac(n - 1)*n
Имя функции fac получает значение 1, если n равно 0 или 1; если же n больше единицы, то значение fac определяется как произведение n и значения, полученного от рекурсивного обращения к fac(n - 1).
Правила вычисления дисперсий и средних квадратических отклонений
1. Дисперсия постоянной величины равна нулю:DC = 0, где C - постоянная.
2. При линейном преобразовании случайной величины X, т.е. для линейной функции
Y = kX + b,
дисперсия увеличивается в k раз, а среднее квадратическое отклонение - в |k|2 раз:
DY = D(KX + b) = k2 DX,
3. Теорема сложения дисперсий: если случайные величины X и Y независимы, то дисперсия и суммы равна сумме их дисперсий:
D(X + Y) = DX + DY,
и следовательно,
Следствие. Дисперсия линейной комбинации попарно независимых случайных величин X1, X2, ..., Xn может быть вычислена по формуле
D(C1X1
+ C2X2 + ... + CnXn) = C1
D2X1 + C2 D2X2 + ... + Cn D2Xn.
В частности, если все величины X1, X2, ..., Xn
имеют одинаковую дисперсию
(i = 1, 2, ..., n), то дисперсия их среднего арифметического равна
и, следовательно, среднее квадратическое отклонение равно
Предельная теорема Муавра-Лапласа
Если вероятность p наступления события A в каждом испытании постоянна и отлична от нуля и единицы, а число испытаний достаточно велико, то вероятность P(X = m) того, что в n независимых испытаниях событие A наступит m раз, приближенно равна:
Значение функции Гаусса
Используя эти формулы можно составить процедуру вычисления вероятности по локальной формуле Муавра-Лапласа, но прежде составим функцию вычисляющую значение функции Гаусса:
{ Функция Гаусса }
Function G(x : real) : real;
begin
G := exp(-sqr(x)/2)/sqrt(2*Pi)
end;
Тогда процедура вычисления вероятности по локальной формуле Муавра-Лапласа будет следующей:
{ Процедура нахожд. вероятн. по локальной форм. Муавра-Лапласа }
Procedure Local_Laplace(n, m : longint; p : real; var pp : real);
var
x : real;
begin
x := (m - n*p)/sqrt(n*p*(1 - p));
pp := G(x)/sqrt(n*p*(1 - p))
end;
Пример 1. Вероятность того, что данное изделие будет забраковано, равна 0.2. Определить вероятность того, что в партии из 400 изделий будет 104 бракованных.
{ Использование локальной формулы Лапласа для вычисл. вероятн. }
Program Problem1;
uses WinCrt;
var
n, m : longint;
p, pp : real;
{----------------------------------------------------------------------------------------}
{ Функция Гаусса }
Function G(x : real) : real;
begin
G := exp(-sqr(x)/2)/sqrt(2*Pi)
end;
{----------------------------------------------------------------------------------------}
{ Процедура нахожд. вероятн. по локальной форм. Муавра-Лапласа }
Procedure Local_Laplace(n, m : longint; p : real; var pp : real);
var
x : real;
begin
x := (m - n*p)/sqrt(n*p*(1 - p));
pp := G(x)/sqrt(n*p*(1 - p))
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите число изделий в партии '); readln(n);
write(' Введите вероятность быть бракованным для одного ');
write('изделия '); readln(p);
write('Введите число изделий, вероятность которых надо ');
write('найти '); readln(m);
Local_Laplace(n, m, p, pp);
writeln('Вероятность появления ', m, ' бракованных');
writeln('изделий среди ', n, ' изделий равна ', pp:1:6)
end.
Пример 2. Появление бракованного изделия в партии оценивается вероятностью 0.5. Взято 100 изделий. Какова должна быть частота бракованных изделий, чтобы вероятность такой частоты была бы равна 0.0782?
{ Использование локальной формулы Лапласа для вычисл. вероятн. }
Program Problem2;
uses WinCrt;
var
n, m : longint;
p, Pm : real;
{----------------------------------------------------------------------------------------}
{ Функция Гаусса }
Function G(x : real) : real;
begin
G := exp(-sqr(x)/2)/sqrt(2*Pi)
end;
{----------------------------------------------------------------------------------------}
{ Процедура определения частоты. 1-й способ. }
Procedure
Frequency1(n : longint; p, Pm : real;
var
m : longint);
var
x, pp : real;
begin
m := -1;
repeat
m := m + 1;
x := (m - n*p)/sqrt(n*p*(1 - p));
pp := G(x)/sqrt(n*p*(1 - p))
until pp >= Pm
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите общее число изделий в партии '); readln(n);
write('Введите вероятность быть бракованным для одного ');
write('изделия '); readln(p);
write('Введите вероятность получения частоты '); readln(Pm);
Frequency1(n, p, Pm, m);
writeln('Частота бракованных изделий равна ', m)
end.
Пример 3. По данным длительной проверки качества выпускаемых запчастей брак составляет 13%. Определить вероятность того, что в непроверенной партии из 200 запчастей пригодных будет а) 174; б) от 150 до 180.
Program Problem3a;
uses WinCrt;
var
n, m : longint;
p, q, pp : real;
{----------------------------------------------------------------------------------------}
{ Функция Гаусса }
Function G(x : real) : real;
begin
G := exp(-sqr(x)/2)/sqrt(2*Pi)
end;
{----------------------------------------------------------------------------------------}
{ Локальная формула Муавра-Лапласа }
Procedure Local_Laplace(n, m : longint; p : real; var pp : real);
var
x : real;
begin
x := (m - n*p)/sqrt(n*p*(1 - p));
pp := G(x)/sqrt(n*p*(1 - p))
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите число запчастей в партии '); readln(n);
write(' Введите вероятность быть бракованным для одной запчасти ');
readln(q);
write('Введите число запчастей, вероятность которых надо ');
write('найти '); readln(m);
p := 1 - q;
Local_Laplace(n, m, p, pp);
writeln('Вероятность появления ', m, ' пригодных');
writeln('запчастей среди ', n, ' изделий равна ', pp:1:6)
end.
Преобразование типов
Пример 8. Двузначное десятичное число в сумме с числом, записанным теми же цифрами, но в обратном порядке, дает полный квадрат. Найти все такие числа.Пусть искомое двузначное число
= a10 + b, тогда число, записанное теми же цифрами, но в обратном порядке будет 
= b10 + a, например, 12 и 21, 13 и 31 и т. п. Сумма этих чисел должна давать полный квадрат, т.е. точный квадрат целых чисел. Как это проверить?
Проверку можно было бы выполнить так: извлечь квадратный корень из полученной суммы; затем округлить результат до целого числа, а потом умножить полученный результат на себя, если снова получится сумма этих чисел, то значит она является точным или полным квадратом.
Например, 12 + 21=33, извлекаем квадратный корень из 33, он равен 5.74...; округляем, будет 6; умножаем 6 само на себя и получаем 36.
Мы не получили исходного результата, значит сумма 33 не является точным квадратом.
Еще один пример, чтобы вам была понятна идея решения. Пусть двузначное число 29, тогда число, записанное теми же цифрами, но в обратном порядке - 92, в сумме они дают 121. Извлекаем квадратный корень из 121 и получаем 11. Умножив 11 само на себя, снова получим 121. Делаем вывод, что получен точный квадрат, а значит двузначное число 29 является искомым.
Чтобы составить программу по этому принципу, придется извлекать квадратный корень из суммы, что можно сделать с помощью стандартной функции sqrt(x). Результат функции sqrt(x) является вещественным числом, его надо округлить или отбросить дробную часть, а нам неизвестно, как это сделать.
Но, даже более существенным, является то, что если квадратный корень в множестве целых чисел извлекается нацело, как для 121 (он равен 11), то на множестве вещественных чисел мы не получим строго число 11, а результат будет очень близок к 11 и после умножения на себя всё равно не получится 121, т.е. возникает необходимость преобразовать
вещественное значение в целое.
Итак перед нами две задачи: 1) выяснить как округлять числа и; 2) установить, как преобразовывать вещественный тип в целый.
Для этого в Паскале есть стандартные функции round(x) и trunc(x)
Стандартные функции round и trunc предназначены для замены значений вещественного типа значениями целого типа.
Функция round(x) округляет вещественное число x до целого - ее значение есть ближайшее целое число:
round(4.2) = 4, round(4.7) = 5, round(4.5)=5,
round(-4.2) = -4, round(-4.7) = -5, round(-4.5) = -5.
Функция trunc(x) отбрасывает (без округления) дробную часть вещественного числа x:
trunc(1.2) = 1, trunc(5.8) = 5, trunc(-1.2) = -1,
trunc(-5.8) = -5, trunc(-6.7) = -6, trunc(8,9) = 8
Функции округления связаны так:
trunc(x + 0.5) = round(x), если x
0, trunc(x - 0.5) = round(x), если x < 0.
Итак, в программе можно воспользоваться одной из этих функций. Какой? Подумайте сами и попробуйте применить в программе вначале функцию trunc, а потом замените ее на round и сравните полученные результаты.
Программа
Program Problem8;
uses WinCrt;
var
d, e, k : integer;
begin
writeln('Искомые двузначные числа');
for d := 1 to 9 do
for e := 1 to 9 do
begin
k := round(sqrt(d*10 + e + e*10 + d));
if k*k = d*10 + e + e*10 + d
then write(d*10 + e, ' ')
end
end.
Задание 7
Найти целые числа из заданного промежутка [m; n], которые являются точными квадратами и остаются таковыми после приписывания к ним справа единицы (в десятичной системе записи).
Упражнения
37. Составьте программу, которая находит 4 последовательных натуральных числа, произведение которых равно 1680.
38. Показать, что четырехзначное число, у которого цифры тысяч и десятков одинаковы и цифры сотен и единиц тоже одинаковы, не может быть точным квадратом.
39. Произведение шести последовательных натуральных чисел может быть равно произведению трех последовательных натуральных чисел. Например, 1
23456 = 8910 = 720. Есть ли еще такие числа? 40. Доказать, что произведение четырех последовательных целых чисел в сумме с единицей дает полный квадрат.
41. Найдите 11 последовательных натуральных чисел, сумма квадратов которых есть квадрат целого числа.
42. Существуют ли такие целые числа, которые уменьшаются в 57 раз при зачеркивании их первой (слева) цифры?
43. Найти четырехзначное число, зная, что оно является квадратом натурального числа и что цифры его распадаются на две пары, состоящие из одинаковых цифр.
44. Найдите все семизначные числа, которые делятся на 15 и записываются только цифрами 0 и 1.
45. Шестизначное число начинается с цифры 1. Если эту цифру переставить в конец числа, то новое число будет в три раза больше первоначального. Найдите число.
46. Сколько точных квадратов можно составить из цифр 3, 4, 5, 6?
47. Даны 20 различных натуральных чисел, не больших 50. Найдите два из них, разность которых равна 4, 5 или 9.
48. Во сколько раз увеличится двузначное число, если справа к нему приписать такое же двузначное число?
49. Определить наибольшее значение отношения трехзначного числа к числу, равному сумме цифр этого числа.
50. Найти трёхзначное число, кратное 45, если разность между этим числом и числом, записанным теми же цифрами, но в обратном порядке равна 297.
51. Найти четырёхзначное число
, кратное 11, при условии: b + c = a и 
есть полный квадрат.52. Найти трёхзначное число, равное сумме цифры десятков, квадрата цифры сотен и куба цифры единиц.
53. Найти два числа, произведение которых есть трёхзначное число, являющееся кубом некоторого числа, а частное является квадратом этого числа.
54. Разность между числом и произведением его цифр равна сумме цифр этого числа. Найти это число.
55. Найти все значения числа m, для которых сумма 1! + 2! + ,,, + m! является полным квадратом.
56. Найти положительное четырёхзначное число, кратное 7 и представляющее собою сумму куба и квадрата некоторого числа.
57. Некоторое число при делении на 7 дает в остатке 3; его квадрат при делении на 72 дает остаток 44; его куб при делении на 73
даёт остаток 111. Найти это число.
58. При каком натуральном значении a число a2 + a + 1589 будет точным квадратом?
59. Найти совершенное число вида 16p.
60. Найти два числа, если сумма их квадратов равна 468, а сумма их общего наибольшего делителя и наименьшего кратного равна 42.
Ответы
К заданию 1
Program
Task1;
uses WinCrt;
var
n, f, i, s : longint;
begin
write('Введите натуральное число '); readln(n);
s := 0; f := 1;
for i := 1 to n do
begin
f := f*i; s := s + f
end;
writeln('Сумма факториалов чисел от 1 до ', n, ' равна ', s)
end.
К
заданию 4
Program Task4;
uses WinCrt;
var
t, s, d, e : integer;
begin
writeln('Искомое четырехзначное число');
for t := 1 to 9 do
for s := 0 to 9 do if s <> t then
for d := 0 to 9 do if (d <> s) and (d <> t) then
for e := 0 to 9 do
if (e <> d) and (e <> s) and
(e <> t) then
if (t*1000 + s*100 + d*10 + e)*9 = t*10000 + s*100 + d*10 + e
then writeln(t*1000 + s*100 + d*10 + e)
end.
К
заданию 6
Program Task6;
uses WinCrt;
var
x, y, z, n, k, p : longint;
begin
write('Введите натуральное число '); readln(n);
k := 0; x := 1;
while x*x + 2<=n do
begin
k := k + 1; x := x + 1
end;
p := 0;
for x := 1 to k do
for y := 1 to x do
for z := 1 to y do
if x*x + y*y + z*z=n
then
begin
p := p + 1;
writeln(x, '*', x, '+', y, '*', y, '+', z, '*', z, '=', n)
end;
if
p=0
then
begin
write('Число ', n, ' нельзя представить в виде ');
writeln(' суммы квадратов трех чисел')
end
else
writeln('Число способов равно ', p)
end.
К
заданию 7
Program Task7;
uses WinCrt;
var
m, n, i, k, k1 : longint;
begin
write('Введите начало промежутка '); readln(m);
write('Введите конец промежутка '); readln(n);
write('Искомые числа ');
for i := m to n do
begin
k := round(sqrt(i));
k1 := round(sqrt(i*10 + 1));
if (k*k = i) and (k1*k1 = i*10 + 1) then
write(i, ' ')
end
end.
Приближенное вычисление интегралов с помощью рядов
С помощью почленного интегрирования рядов получаются разложения в бесконечные степенные ряды для некоторых интегралов, не выражающихся в конечном виде через элементарные функции. Эти разложения могут быть использованы для приближенных вычислений.Так, исходя из разложения
,найдем значение интеграла
для всех действительных значений x.Вначале разложим в ряд функцию
:
Интегрируем почленно этот ряд, получим:
который сходится на множестве всех действительных чисел.
Чтобы составить программу, найдем рекуррентную формулу для вычисления суммы ряда.
отсюда получаем:
Так как ряд знакочередующийся, то оценить точность вычисления можно по абсолютной величине последнего "отброшенного" члена, т. е. по значению
Программа
Program Problem1;
uses WinCrt;
var
n : longint;
u, I, x, eps : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение аргумента x '); readln(x);
write('Введите точность вычисления '); readln(eps);
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -(u*x*x*(2*n - 1))/(2*n*(2*n + 1))
until abs(u) < eps;
writeln('Значение интеграла равно ', I:6:t(eps))
end.
В теории вероятностей нам придется иметь дело с функцией - интегралом вероятностей
Надо лишь заметить, что значение этой функции при
равно 1, а при равно -1.Для составления программы вычисления значений этого интеграла и большего удобства использования в других программах, создадим функцию:
{ Рекуррентная функция вычисления интеграла вероятностей }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
Использование ее в программе приводится ниже.
Program Problem2;
uses WinCrt;
var
x, eps : real;
{----------------------------------------------------------------------------------------}
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
Function FF(x, eps : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u; n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until
abs(u) < eps;
FF := 2*I/sqrt(2*Pi)
end
end;
{-----------------------------------------------------------------------------------------}
begin
write('Введите значение аргумента x '); readln(x);
write('Введите точность вычисления '); readln(eps);
writeln('Значение интеграла вероятностей равно ', FF(x, eps):6:t(eps))
end.
Аналогично предыдущему примеру вычислим интеграл
.Для этого надо вспомнить ряд, в который разлагается функция sinx
при всех
Разложим в ряд
: 
Интегрируя его, получим:
Найдем рекуррентную формулу для составления программы.
Отсюда находим, что 
Оценить точность можно по абсолютной величине n-го члена, т. е. по величине
Составим процедуру вычисления этого интеграла.
Procedure
Integral(x, eps : real; var I : real);
var
n : integer;
u : real;
begin
u := x; n := 1; I := 0;
repeat
I := I + u;
n := n + 1;
u := -(u*x*x*(2*n - 3))/((2*n - 2)*sqr(2*n - 1))
until abs(u) < eps
end;
Программа
Program Problem2;
uses WinCrt;
var
I, x, eps : real;
{----------------------------------------------------------------------------------------}
Procedure
Integral(x, eps : real; var I : real);
var
n : integer;
u : real;
begin
u := x; n := 1; I := 0;
repeat
I := I + u;
n := n + 1;
u := -(u*x*x*(2*n - 3))/((2*n - 2)*sqr(2*n - 1))
until abs(u) < eps
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение аргумента x '); readln(x);
write('Введите точность вычисления '); readln(eps);
Integral(x, eps, I);
writeln('Значение интеграла равно ', I:6:t(eps))
end.
Задание 6
Вычислить с помощью разложения в ряд интеграл
5.1. Полный эллиптический интеграл 2-го рода
Полный эллиптический интеграл 1-го рода
Полный эллиптический интеграл 2-го рода
Поставим задачу разложить эти интегралы по степеням модуля k (0 < k < 1). Для этого, положим в формуле интеграла 1-го рода
(1)
получим: 
Этот ряд сходится равномерно относительно
, ибо мажорируется при всех значениях сходящимся рядом
следовательно, допустимо почленное интегрирование, получим:
Аналогично, исходя из формулы
, (2)найдем
Ряды (1) и (2) являются частными случаями биномиального ряда при
и 
Найдем рекуррентную формулу для вычисления суммы
отсюда получаем 
Процедура
Procedure Elliptic2(k, eps : real; var
Ek : real);
var
n : integer;
u : real;
begin
u := k*k/4; n := 1; Ek := 0;
repeat
Ek := Ek + u;
n := n + 1;
u := (u*k*k*(2*n - 1)*(2*n - 3))/(4*n*n);
until abs(u) < eps;
Ek := Pi*(1 - Ek)/2
end;
Программа
Program Problem3;
uses WinCrt;
var
Ek, k, eps : real;
{----------------------------------------------------------------------------------------}
Procedure
Elliptic2(k, eps : real; var Ek : real);
var
n : integer;
u : real;
begin
u := k*k/4; n := 1; Ek := 0;
repeat
Ek := Ek + u;
n := n + 1;
u := (u*k*k*(2*n - 1)*(2*n - 3))/(4*n*n);
until abs(u) < eps;
Ek := Pi*(1 - Ek)/2
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function
t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите значение аргумента 0 < k < 1 '); readln(k);
write('Введите точность вычисления '); readln(eps);
Elliptic2(k, eps, Ek);
writeln('Значение интеграла равно ', Ek:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Задание 7
Составить программу вычисления эллиптического интеграла 1-го рода и сравнить результат с результатом, полученным с помощью бесконечных произведений.
Приближенное вычисление интегралов
Пусть требуется вычислить определенный интеграл
, где f(x) непрерывная на [a, b] функция. Надо заметить, что с помощью различных способов нахождения первообразных можно вычислить интегралы для довольно незначительного класса функций, поэтому возникает необходимость в приближенных методах вычисления интегралов. На этом занятии мы познакомимся с простыми способами приближенного вычисления: формулой прямоугольников, формулой трапеций, формулой Симпсона или параболическим интегрированием, методом Монте-Карло.
3.1. Формула прямоугольников
Будем исходить из геометрических соображений и рассматривать определенный интеграл
,как площадь некоторой фигуры, чаще всего ее называют криволинейной трапецией, ограниченной кривой y = f(x), осью Ox и прямыми y=a, y = b. Будем также предполагать, что функция y = f(x) непрерывна на [a. b]. 
Рис. 48
Идея, которая привела к понятию определенного интеграла заключалась в следующем. Разбить всю фигуру на полоски одинаковой ширины dx = (b - a)/n, а затем каждую полоску заменить прямоугольником, высота которого равно какой-либо ординате (см. рис. 48).
Тогда получится следующая формула:
где xi
<= ci <= xi+1 (i = 0, 1, ..., n-1). Площадь криволинейной фигуры заменится площадью сумм прямоугольников. Эта приближенная формула и называется формулой прямоугольников.
Практически, в качестве точки ci берут середину промежутка [xi , xi+1], т. е.
Нетрудно составить процедуру вычисления такой суммы.
{ Вычисление интеграла методом прямоугольников }
{ Rectangle - прямоугольник }
Procedure Rectangle(a, b : real; n : integer; var j : real);
var
dx, c, f : real;
i : integer;
begin
dx := (b - a)/n;
c := a + dx/2;
f := fx(c);
for i := 1 to n - 1 do
begin
c := c + dx;
f := f + fx(c)
end;
j := dx * f
end;
Теперь возникает вопрос о числе точек деления - n, который напрямую связан с точностью вычисления интеграла.
Известно, что точность вычисления интеграла по формуле прямоугольников оценивается по дополнительному члену, который выражается формулой:
где 
значит оценивать точность вычисления можно по модулю этого остаточного или дополнительного члена, |Rn|.
Вторую производную вычислить мы сможем с достаточно высокой степенью точности, применив следующую функцию:
{ Функция вычисления второй производной }
Function
derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
Осталось выяснить, в какой точке промежутка интегрирования [a, b] находить значение этой производной. Остаточный член не требует строго определенного значения аргумента из этого промежутка, поэтому можно выбрать любое значение, не выходящее за пределы интервала [a, b]. Сразу возникает мысль вычислить вторую производную в середине промежутка, т.е. в точке (a + b)/2. Но представьте себе ситуацию, когда промежуток [-1, 1] или [-6.28; 6.28], тогда середина этого отрезка - точка 0 и значение производной будет равно нулю, а значит для числа точек деления n может быть установлено значение любое, даже 1, что, конечно, не даст требуемой точности вычисления интеграла.
Итак, следующая проблема, в какой точке промежутка находить значение производной?
Можно найти наибольшее значение производной на промежутке интегрирования [a, b]. Это можно сделать с помощью процедуры:
{ Определение наибольшего значения второй производной }
Procedure Maximum(a, b, eps : real; var
max : real);
var
dx, x : real;
begin
dx := 0.1; x := a;
max := abs(derivat2(x, eps));
while x<= b do
begin
x := x + dx;
if max < abs(derivat2(x, eps))
then max := abs(derivat2(x, eps))
end
end;
В ней установлен шаг - 0.1 и затем, в каждой следующей точке промежутка определяется значение второй производной и находится наибольшее.
Теперь составим процедуру определения числа точек деления, а затем и полностью программу.
{ Процедура определения числа точек деления промежутка интегр. }
Procedure Number(a, b, eps, max : real; var
n : integer);
var
d : real;
begin
n := 1;
d := abs((b - a)*(b - a)*(b - a));
while (max*d)/(24*n*n) >= eps do n := n+1;
end;
Программа вычисления интеграла по формуле прямоугольников
{ Вычисление интеграла по формуле прямоугольников }
Program Jntegral_Rectangle2;
uses WinCrt;
var
a, b, eps, j : real;
n : integer;
{----------------------------------------------------------------------------------------}
Function fx(x : real) : real;
begin
fx := sin(x)
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления второй производной }
Function derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
{----------------------------------------------------------------------------------------}
{ Процедура определения числа точек деления промежутка интегр. }
Procedure Number(a, b, eps : real; var
n : integer);
var
dy2, d, c, dx : real;
begin
c := (a + b)/2;
dy2 := derivat2(c, eps);
if dy2 = 0
then
begin
c := a; dx := (b - a)/10;
while derivat2(c, eps) = 0 do c := c + dx;
dy2 := derivat2(c, eps)
end;
n := 1;
d := abs((b - a)*(b - a)*(b - a));
while abs(dy2*d)/(24*n*n) >= eps do n := n+1;
end;
{----------------------------------------------------------------------------------------}
{ Вычисление интеграла методом прямоугольников }
Procedure Rectangle(a, b : real; n : integer; var j : real);
var
dx, c, f : real;
i : integer;
begin
dx := (b - a)/n;
c := a + dx/2;
f := fx(c);
for i := 1 to n - 1 do
begin
c := c + dx;
f := f + fx(c)
end;
j := dx * f
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите нижний предел интегрирования '); readln(a);
write('Введите верхний предел интегрирования '); readln(b);
write('Введите точность вычисления интеграла '); readln(eps);
Number(a, b, eps, n); Rectangle(a, b, n, j);
writeln('Значение интеграла равно ', j:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
Такой способ можно использовать, но он может быть долгим, особенно, если большой промежуток интегрирования, малый шаг и более высокая точность вычисления производной.
Для определения числа точек деления можно применить и другой прием.
{ Процедура определения числа точек деления промежутка интегр. }
Procedure Number(a, b, eps : real; var
n : integer);
var
dy2, d, c, dx : real;
begin
c := (a + b)/2;
dy2 := derivat2(c, eps);
dx := (b - a)/10;
if dy2 = 0
then
begin
c := a;
while derivat2(c, eps) = 0 do c := c + dx;
dy2 := derivat2(c, eps)
end;
n := 1;
d := abs((b - a)*(b - a)*(b - a));
while abs(dy2*d)/(24*n*n) >= eps do n := n+1;
end;
Как работает эта процедура? Вычисляется значение второй производной в середине промежутка: c := (a + b)/2. Если она не равна нулю, тогда все в порядке, вычисляется в зависимости от заданной точности число точек деления n. Если значение второй производной равно нулю в середине промежутка интегрирования: dy2 = 0, тогда устанавливается шаг dx := (b - a)/10 и начинается цикл, в котором вычисляется производная через каждый промежуток dx, начиная от точки a, пока производная равна нулю цикл продолжается и заканчивается как только она не станет равной нулю.
Такой прием экономит время работы программы, производную можно вычислить с большей точностью, да и сама программа становится менее громоздкой:
Program Jntegral_Rectangle2;
uses WinCrt;
var
a, b, eps, j : real;
n : integer;
Function fx(x : real) : real;
begin
fx := sin(x)
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления второй производной }
Function derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
{----------------------------------------------------------------------------------------}
{ Процедура определения числа точек деления промежутка интегр. }
Procedure Number(a, b, eps : real; var
n : integer);
var
dy2, d, c, dx : real;
begin
c := (a + b)/2;
dy2 := derivat2(c, eps);
if dy2 = 0
then
begin
c := a; dx := (b - a)/10;
while derivat2(c, eps) = 0 do c := c + dx;
dy2 := derivat2(c, eps)
end;
n := 1;
d := abs((b - a)*(b - a)*(b - a));
while abs(dy2*d)/(24*n*n) >= eps do n := n+1;
end;
{----------------------------------------------------------------------------------------}
{ Вычисление интеграла методом прямоугольников }
Procedure Rectangle(a, b : real; n : integer; var j : real);
var
dx, c, f : real;
i : integer;
begin
dx := (b - a)/n;
c := a + dx/2;
f := fx(c);
for i := 1 to n - 1 do
begin
c := c + dx;
f := f + fx(c)
end;
j := dx * f
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите нижний предел интегрирования '); readln(a);
write('Введите верхний предел интегрирования '); readln(b);
write('Введите точность вычисления интеграла ');
readln(eps);
Number(a, b, eps, n);
Rectangle(a, b, n, j);
writeln('Значение интеграла равно ', j:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
3.2. Формула трапеций
Рис. 49
Заменим данную кривую вписанной в нее ломаной, с вершинами в точках (xi, yi), где yi = f(xi) (i = 0, 1, 2, ..., n-1). Тогда криволинейная трапеция заменится фигурой, состоящей из трапеций (см. рис. 49). Будем по-прежнему считать, что промежуток [a, b] разбит на равные части, тогда площади этих трапеций будут равны:
Складывая полученные значения, приходим к приближенной формуле:
Эта приближенная формула называется формулой трапеций.
Оценка погрешности формулы трапеций определяется по следующему дополнительному члену:
Задание 4
Составьте процедуры вычисления интеграла по формуле трапеций и процедуру определения числа точек деления.
Составьте полностью программу и вычислите интегралы следующих функций на указанных промежутках с заданной точностью:
1) f(x) = 1/x на [1; 2] с точностью до 0.001;
2) f(x) = x/(x2
+ 1)2 на [-1; 2] с точностью до 0.01;
3) f(x) = 1/cos2 x на [0; Pi/3] с точностью до 0.0000001.
3.3. Параболическое интерполирование. Дробление промежутка интегрирования. Формула Симпсона
Параболическое интерполирование
Для приближенного вычисления интеграла функции
на промежутке 
можно заменить функцию f(x) многочленом 
и тогда будет выполняться приближенное равенство
Такая замена тем более важна, когда подынтегральная функция представляет собой выражение, интеграл которой точно вычислить нельзя.
Геометрически это можно представить так, что криволинейная трапеция, находящаяся под кривой y = f(x) заменяется "параболой k-го порядка", поэтому такой процесс получил название параболическое интерполирование.
Существует много интерполяционных многочленов, о некоторых из них мы будем говорить на других занятиях, а на этом познакомимся с интерполяционным многочленом Лагранжа, который строится по следующей формуле:
При интегрировании получается линейное относительно значений
выражение, коэффициенты которого от этих значений не зависят. Вычислив коэффициенты, можно ими пользоваться для любой функции f(x) в заданном промежутке [a, b]. При k = 0, функция f(x) просто заменяется постоянной f(c0), где c0 - любая точка из промежутка [a, b], например средняя: c0 = (a + b)/2. Тогда приближенно
Геометрически это означает, что криволинейная фигура под кривой y = f(x) заменяется прямоугольником с высотой, равной средней ординате.
При k = 1 функция f(x) заменяется линейной функцией P1(x), которая имеет одинаковые с ней значения при x = c0 и x = c1. Если взять c0
= a, c1 = b, то
после преобразования, получим
Таким образом, здесь мы приближенно допускаем
Геометрически это будет представляться, как замена криволинейной фигуры трапецией: вместо кривой берется хорда, соединяющая ее концы.
Более интересный результат получается, если взять k = 2. Можно положить c0= a, c1 = (a + b)/2, c2 = b, тогда интерполяционный многочлен P2(x), будет иметь вид
После преобразований и интегрирования многочлена P2(x), приходим к приближенной формуле
(7)В этом случае, площадь фигуры под кривой заменяется площадью фигуры, ограниченной параболой (с вертикальной осью), проходящей через крайние и среднюю точки кривой.
Увеличивая степень k интерполяционного многочлена, т.е. проводя параболу через все большее число точек данной кривой, можно добиться большей точности. Но на практике часто используют другой способ, основанный на сочетании параболического интерполирования с идеей дробления промежутка.
3.4. Дробление промежутка интегрирования
Для вычисления интеграла
можно поступить таким способом. Разобьем сначала промежуток [a, b] на некоторое число, n, равных промежутков [x0, x1], [x1, x2], ..., [xn-1, xn] (x0 = a, xn = b),
искомый интеграл представится в виде суммы
После этого, к каждому из этих промежутков применим параболическое интерполирование, т.е. станем вычислять перечисленные интегралы по одной из приближенных формул: прямоугольников, трапеций или по параболической формуле (7).
В первых двух случаях мы получим уже известные формулы прямоугольников и трапеций.
Применим теперь формулу (7) к каждому из интегралов, при этом положим, что
Получим
................................................
Складывая почленно эти равенства, получим формулу:
(8)Эта формула называется формулой Симпсона. Ею пользуются для приближенного вычисления интегралов чаще, чем формулами прямоугольников и трапеций, так как она дает более точный результат.
Составим процедуру на языке Паскаль реализующую эту формулу.
{ Вычисление интеграла по формуле Симпсона }
Procedure Simpson(a, b : real; n : integer; var j : real);
var
dx, c, c1, f : real;
i : integer;
begin
dx := (b - a)/n;
c := a;
c1 := a + dx/2;
f := fx(a) + fx(b) + 4*fx(c1);
for i := 1 to n - 1 do
begin
c := c + dx; c1 := c1 + dx;
f := f + 2*fx(c) + 4*fx(c1)
end;
j := (dx/6)* f
end;
Остается выяснить вопрос о числе точек деления в зависимости от заданной точности вычисления, другими словами, установить погрешность вычисления.
Если промежуток [a, b] разделен на n равных частей, то для формулы Симпсона дополнительный член имеет вид
Значит оценить точность вычисления можно по модулю этого дополнительного члена: |Rn|.
Однако, это связано с неприятностью находить 4-ю производную функции, что достаточно нелегкое дело. Есть и другой путь оценки точности вычисления интегралов и не только по формуле Симпсона, но и по формуле прямоугольника и трапеций.
Этот прием заключается в следующем. Искомый интеграл вычисляется дважды: при делении отрезка [a, b] на n частей и на 2n частей. Полученные значения интегралов In
и I2n сравниваются и первые совпадающие десятичные знаки считаются верными.
Покажем, как, используя такой метод оценить точность интеграла, вычисленного по формуле Симпсона.
Преобразуем дополнительный член Rn формулы Симпсона:
где h = (b - a)/2n. Пусть Rn
и R2n - погрешности интегрирования, тогда, учитывая предыдущую формулу можно составить пропорцию:
Понятно, что h2n
= hn/2. Тогда из пропорции получаем: Rn = 16 R2n. Если I - истинное значение интеграла, то I = In + Rn и I = I2n + R2n, откуда находим: In + 16 R2n
= I2n + R2n, т.е.
Надо помнить, что в процессе практических вычислений при последовательном удвоении числа отрезков разбиения начинает сильно прогрессировать удельный вес ошибки округления, значение которой с некоторого момента ставит предел достижимой точности.
Ниже, мы рассмотрим и другой способ оценки точности. А сейчас, основываясь на последней формуле, составим программу вычисления интеграла с применением формулы Симпсона.
{ Вычисление интеграла по формуле Симпсона }
Program Jntegral_Simpson;
uses WinCrt;
var
a, b, eps, j, j1 : real;
n : integer;
Function fx(x : real) : real;
begin
fx := exp(-x*x)
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Вычисление интеграла по формуле Симпсона }
Procedure Simpson(a, b : real; n : integer; var j : real);
var
dx, c, c1, f : real;
i : integer;
begin
dx := (b - a)/n;
c := a;
c1 := a + dx/2;
f := fx(a) + fx(b) + 4*fx(c1);
for i := 1 to n - 1 do
begin
c := c + dx; c1 := c1 + dx;
f := f + 2*fx(c) + 4*fx(c1)
end;
j := (dx/6)* f
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите нижний предел интегрирования '); readln(a);
write('Введите верхний предел интегрирования '); readln(b);
write('Введите точность вычисления интеграла '); readln(eps);
n := 2;
Simpson(a, b, n, j); Simpson(a, b, 2*n, j1);
while abs(j - j1)/15 > eps do
begin
n := n + 2;
Simpson(a, b, n, j); Simpson(a, b, 2*n, j1)
end;
writeln('Значение интеграла равно ', j1:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
3.5. Об оценке погрешности
При вычисление интегралов по формуле прямоугольников и по формуле трапеций оценка погрешности делалась по формуле с помощью второй производной, которая была ограничена на заданном промежутке своим наибольшим значением.
Так, в формуле трапеций, оценка погрешности использовалась для определения числа точек разбиения, которое определяло точность вычисления. Это делалось с помощью процедуры:
{ Процедура определения числа точек деления промежутка интегр. }
Procedure Number(a, b, eps, max : real; var
n : integer);
var
d : real;
begin
n := 1;
d := abs((b - a)*(b - a)*(b - a));
while (max*d)/(24*n*n) >= eps do n := n+1;
end;
Такого рода оценки погрешности называются гарантированными оценками погрешности.
На основании этой оценки можно гарантировать, что погрешность приближенного значения интеграла не превосходит определенной величины.
Существует второй способ оценки - отказ от получения строгой, гарантированной оценки погрешности и получение оценки погрешности лишь с определенной степенью достоверности. В частности при оценки погрешности вычисления интеграла по методу Симпсона погрешность оценивалась через разность результатов приближенного значения интеграла при различных значениях параметров, в частности, при n и 2n.
Необходимость применения метода Симпсона, как раз по причине метода оценки погрешности, примененной в этом методе, в следующих случаях.
1) Когда уже первая производная подынтегральной функции равна нулю.
2) Когда первая производная подынтегральной функции обращается в точках (пределах интегрирования или других) в бесконечность.
Примером может быть интеграл
Подынтегральная функция при
стремится к 0, а поэтому ее можно считать непрерывной на промежутке от 0 до 1. Эти два обстоятельства вызывают необходимость выбирать метод интегрирования в зависимости от заданной функции и поведения ее производных.
Задание 5
1. Используя оператор выбора Case ... of ..., составьте программу, с помощью которой пользователю можно было бы выбирать метод интегрирования, подобно программе выбора метода решения уравнений.
2. Вычислите по формуле Симпсона следующие интегралы:
1) полный эллиптический интеграл 2-го рода
2)
3) 
3.6. Вычисление интегралов методом Монте-Карло
Вычисление интегралов методом Монте-Карло часто применяется для двойных, тройных, вообще, кратных интегралов. Идея метода состоит в следующем.
Пусть задана некоторая подынтегральная функция F - непрерывная в области интегрирования Q. Выберем в этой области n случайных точек M, найдем значение заданной функции в некоторой "средней" точке области интегрирования. При достаточно большом n можно считать, что
Тогда, значение интеграла приблизительно равно
где D - многомерный объем области интегрирования. Применим этот метод для простейшего интеграла на промежутке [a, b], т.е. необходимо вычислить интеграл:
В этом случае в качестве объема области интегрирования D выступает длина отрезка [a, b], которая равна: D = b - a.
Пусть xi (i = 1, 2, ..., n) - случайные точки из промежутка [a, b], тогда значение функции f(x) в некоторой "средней" точке будет:
а значение интеграла станет равно
Для получение точек xi можно использовать уже известный способ нахождения случайных точек с помощью функции random,
x := random*(b - a) + a
Функция для вычисления интеграла получится такой:
{ Функция вычисления интеграла методом Монте-Карло }
Function I(n : longint; a, b : real) : real;
var
x, f : real;
k : longint;
begin
randomize;
f := 0;
for k := 1 to n do
begin
x := random*(b - a) + a;
f := f + fx(x)
end;
I := (b - a)*f/n
end;
Итак, с помощью генератора случайных чисел (random) вырабатывается случайное число из промежутка [a, b], находится значение функции в этой точке и суммируются ее абсолютные величины (учитывая, что функция может принимать и отрицательные значения) в переменную f. Приближенное значение интеграла вычисляется с помощью оператора I := (b - a)*f/n.
Теперь стоит очень болезненный вопрос оценки точности значения интеграла. Не вдаваясь в долгие математические рассуждения (о чем смотрите [19]), покажем неравенства, с помощью которых можно оценить точность вычисления интеграла.
Пусть I(f) - точное значение интеграла, а Sn(f) - его приближенное значение, тогда с вероятностью 0,997 и 0,99999 выполняются следующие соотношения
и 
Здесь D(f) - дисперсия непрерывной случайной величины, которая вычисляется по формуле:
где сумма есть математическое ожидание случайной величины.
Приведем схему последовательного вычисления интеграла с заданной точностью eps. Последовательно, при n = 1, ... получаются случайные точки x и вычисляющая величины tn
, Sn , dn , пользуясь рекуррентными соотношениями
и величину
или 
Начальные условия рекурсии n = 1,
, 
Если оказалось, что
<= eps или <=eps, то вычисления прекращаются и полагают, что приближенное значение интеграла равно Sn с вероятностью 0,997 или 0,99999 и точностью eps. Изложенные математические соображения можно реализовать следующей процедурой:
{ Процедура оценки точности и вычисления интеграла }
Procedure Monte_Karlo(a, b, eps : real; var
s : real);
var
t, d, f, dd : real;
n : longint;
begin
n := 1;
t := I(n, a, b);
s := t;
d :=0;
repeat
n := n + 1;
t := t + I(n, a, b);
s := t/n;
d := d + (n/(n - 1))*sqr(I(n, a, b) - s);
dd := d/(n - 1)
until 5*sqrt(dd/n) < eps
end;
Полностью программа приводится ниже. Надо заметить, что для интегралов на промежутке программа работает медленно и лучше применять для их вычисления другие методы, а вот для кратных интегралов программа может быть очень полезной.
{Вычисление интеграла и оценка его точности методом Монте-Карло}
Program Integral_Monte_Karlo;
uses WinCrt;
var
a, b, s, eps : real;
{-----------------------------------------------------------------------------------------}
Function fx(x : real) : real; { Промежуток интегрир. [3, 4] }
begin { Интеграл хорошо вычисл. с точн. до 0.00001 }
fx := sin(0.2*x - 3)/(x*x + 1)
end;
{-----------------------------------------------------------------------------------------}
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления интеграла методом Монте-Карло }
Function I(n : longint; a, b : real) : real;
var
x, f : real;
k : longint;
begin
randomize;
f := 0;
for k := 1 to n do
begin
x := random*(b - a) + a;
f := f + fx(x)
end;
I := (b - a)*f/n
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления точности и интеграла }
Procedure Monte_Karlo(a, b, eps : real; var s : real);
var
t, d, f, dd : real;
n : longint;
begin
n := 1;
t := I(n, a, b);
s := t;
d :=0;
repeat
n := n + 1;
t := t + I(n, a, b);
s := t/n;
d := d + (n/(n - 1))*sqr(I(n, a, b) - s);
dd := d/(n - 1)
until 5*sqrt(dd/n) < eps
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
randomize;
write('Введите нижний предел интегрирования '); readln(a);
write('Введите верхний предел интегрирования '); readln(b);
write('Введите точность вычисления '); readln(eps);
Monte_Karlo(a, b, eps, s);
writeln('Значение интеграла равно ', s:6:t(eps));
write('С точностью до ', eps:1:t(eps));
writeln(' и вероятностью 0.99999')
end.
Задание 6
Используя второй способ оценки погрешности через разность результатов приближенного значения интеграла при различных значениях аргументов, изменить программу вычисления интеграла по методу Монте-Карло. И вычислить с ее помощью интегралы из задания 5.
3.7. Вычисление двойных интегралов методом Монте-Карло
Вначале сделаем отступление в курс математического анализа и познакомимся с понятием двойного интеграла. Как и прежде, в определении понятий математического анализа, мы будем следовать Г.М. Фихтенгольцу.
Возникновение двойного (определенного) интеграла связывают с задачей определения объема цилиндрического бруса, подобно тому, как определенный интеграл возник из задачи определения площади криволинейной трапеции.
Рассмотрим тело (V), которое сверху ограничено поверхностью z = f(x, y), с боков - цилиндрической поверхностью с образующими, параллельными оси z, наконец, снизу - плоской фигурой (P) на плоскости xy. Требуется найти объем V тела.
Для решения этой задачи мы прибегаем к обычному в интегральном исчислении приему, состоящему в разложении искомой величины на элементарные части, приближенному подсчету каждой части, суммированию и последующему предельному переходу. С этой целью разложим область (P) сетью кривых на части (P1), (P2), ..., (Pn) и рассмотрим ряд цилиндрических столбиков, которые имеют своими основаниями эти частичные области и в совокупности составляют данное тело.
Для подсчета объема отдельных столбиков возьмем произвольно в каждой фигуре (Pi) по точке (xi, yi). Если приближенно принять каждый столбик, за настоящий цилиндр с высотой, равной аппликате f(xi, yi), то объем отдельного столбика оказывается приближенно равным f(xi, yi)*Pi, где Pi означает площадь фигуры (Pi). В таком случае приближенное выражение объема всего тела будет
Для повышения точности этого равенства будем уменьшать размеры площадок (Pi), увеличивая их число. В пределе, при стремлении к нулю наибольшего из диаметров всех областей (Pi), это равенство делается точным, так что
и поставленная задача решена.
Предел этого вида и есть двойной интеграл от функции f(x, y) по области (P); он обозначается символом
так что формула для объема принимает вид 
Таким образом, двойной интеграл является прямым обобщением понятия простого определенного интеграла на случай функции двух переменных.
Пример 1. Вычислить интеграл, распространенный на прямоугольник
(P) = [3, 4; 1, 2]:
Решить этот интеграл методом Монте-Карло очень просто. Для этого достаточно изменить функцию:
Function fx(x, y : real) : real;
begin
fx := 5*x*x*y - 2*y*y*y
end;
Изменить функцию вычисления интеграла, куда добавить в качестве входных параметров две другие координаты прямоугольной области по оси OY и в результате вычисления умножать среднее значение функции, не на длину отрезка, а на площадь области, в данном случае, на площадь прямоугольника. Разумеется, задавать случайные значения для y из соответствующего промежутка [a1, b1].
Функция станет такой:
{ Функция вычисления интеграла методом Монте-Карло }
Function I(n : longint; a, b, a1, b1 : real) : real;
var
x, y, f : real;
k : longint;
begin
randomize;
f := 0;
for k := 1 to n do
begin
y := random*(b1 - a1) + a1;
x := random*(b - a) + a;
f := f + fx(x, y)
end;
I := (b - a)*(b1 - a1)*f/n
end;
Необходимо внести незначительные изменения в процедуру Monte_Karlo, а в основной программа, не забыть описать новые переменный и ввести их в программу.
Составьте программу самостоятельно и выполните ее.
Задание 7
Вычислить двойной интеграл
,где (P) есть круг радиуса R с центром в начале координат.
Библиотека часто встречающихся процедур и функций
43. Процедура уточнения корня методом хорд.
{ Процедура уточнения корня методом хорд }
Procedure chord(a, b, eps, min : real; var
x : real);
var
x1 : real;
begin
x1 := a;
repeat
x := x1 - ((b - x1)*fx(x1))/(fx(b) - fx(x1));
x1 := x
until abs(fx(x))/min < eps
end;
44. Функция вычисления первой производной.
{ Вычисление 1-й производной и опред. точности ее вычислен.}
{ derivative - производная }
Function derivat1(x0, eps : real) : real;
var
dx, dy, dy2 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx/2) - fx(x0 - dx/2);
dy2 := fx(5*x0/4 + dx) - 2*fx(5*x0/4);
dy2 := dy2 + fx(5*x0/4 - dx)
until abs(dy2/(2*dx)) < eps;
derivat1 := dy/dx
end;
45. Процедура определения наименьшего значения первой производной.
{ Процедура определения наименьшего значения производной }
{ на заданном промежутке }
Procedure minimum(a, b, eps : real; var min : real);
var
d : real;
begin
a := a - eps;
b := b + eps;
repeat
a := a + eps;
b := b - eps;
min := abs(derivat1(a, eps));
d := abs(derivat1(b, eps));
if min > d then min := d
until min <> 0
end;
46. Функция вычисления порядка, в зависимости от задаваемой точности.
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
47. Процедура уточнения корня методом касательных.
{ Процедура уточнения корня методом касательных }
Procedure tangent(a, b, eps, min, dy : real; var x : real);
var
x1 : real;
begin
x1 := a;
repeat
x := x1 - fx(x1)/derivat1(x1);
x1 := x
until abs(fx(x))/min < eps
end;
48. Функция вычисления второй производной.
{ Функция вычисления второй производной }
Function
derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
49. Процедура вычисления корня уравнения (комбинированный метод).
{ Комбинированный метод }
Procedure Combination(a, b, eps : real; var x : real);
var
z : real;
begin
repeat
if fx(a)*derivat2(a, eps) > 0
then
begin
tangent(a, b, eps, z);
chord(b, a, x);
b := z; a := x
end
else
begin
tangent(b, a, eps, z);
chord(a, b, x);
b := x; a := z
end
until abs(z - x) < eps
end;
50. Процедура определения числа точек деления промежутка в зависимости от вычисляемой точности.
{ Процедура определения числа точек деления промежутка интегр. }
Procedure Number(a, b, eps : real; var
n : integer);
var
dy2, d, c, dx : real;
begin
c := (a + b)/2;
dy2 := derivat2(c, eps);
if dy2 = 0
then
begin
c := a; dx := (b - a)/10;
while derivat2(c, eps) = 0 do c := c + dx;
dy2 := derivat2(c, eps)
end;
n := 1;
d := abs((b - a)*(b - a)*(b - a));
while abs(dy2*d)/(24*n*n) >= eps do n := n+1;
end;
{--------------------------------------------------------------}
{ Вычисление интеграла методом прямоугольников }
Procedure Rectangle(a, b : real; n : integer; var j : real);
var
dx, c, f : real; i : integer;
begin
dx := (b - a)/n; c := a + dx/2;
f := fx(c);
for i := 1 to n - 1 do
begin
c := c + dx;
f := f + fx(c)
end;
j := dx * f
end;
51. Процедура вычисления интеграла по формуле прямоугольников.
{ Вычисление интеграла методом прямоугольников }
{ Rectangle - прямоугольник }
Procedure Rectangle(a, b : real; n : integer; var j : real);
var
dx, c, f : real;
i : integer;
begin
dx := (b - a)/n;
c := a + dx/2;
f := fx(c);
for i := 1 to n - 1 do
begin
c := c + dx;
f := f + fx(c)
end;
j := dx * f
end;
52. Процедура вычисления интеграла по формуле трапеций.
{ Вычисл. интеграла по формуле трапеций. Trapezoid - трапеция }
Procedure Trapezoid(a, b : real; n : integer; var j : real);
var
dx, c, f : real;
i : integer;
begin
dx := (b - a)/n; c := a;
f := (fx(a)) + fx(b))/2;
for i := 1 to n - 1 do
begin
c := c + dx;
f := f + fx(c)
end;
j := dx * f
end;
53. Процедура вычисления интеграла по формуле Симпсона.
Procedure Simpson(a, b : real; n : integer; var j : real);
var
dx, c, c1, f : real;
i : integer;
begin
dx := (b - a)/n;
c := a;
c1 := a + dx/2;
f := fx(a) + fx(b) + 4*fx(c1);
for i := 1 to n - 1 do
begin
c := c + dx; c1 := c1 + dx;
f := f + 2*fx(c) + 4*fx(c1)
end;
j := (dx/6)* f
end;
54. Процедуры вычисления интеграла по методу Монте-Карло.
Function I(n : longint; a, b : real) : real;
var
x, f : real; k : longint;
begin
randomize;
f := 0;
for k := 1 to n do
begin
x := random*(b - a) + a;
f := f + fx(x)
end;
I := (b - a)*f/n
end;
{----------------------------------------------------------------------------------------}
Procedure Monte_Karlo(a, b, eps : real; var s : real);
var
t, d, f, dd : real; n : longint;
begin
n := 1;
t := I(n, a, b);
s := t;
d :=0;
repeat
n := n + 1;
t := t + I(n, a, b);
s := t/n;
d := d + (n/(n - 1))*sqr(I(n, a, b) - s);
dd := d/(n - 1)
until 5*sqrt(dd/n) < eps
end;
Упражнения
184. Вычислить значение дифференциала функции
при изменении независимой переменной от Pi/6 до 61Pi/360. 185.
Вычислить dy при x = 1 и dx = 0.2. 186. Доказать, что функция y = ex sinx удовлетворяет соотношению
а функция y = e-x sinx соотношению 
(В качестве x0 взять произвольное значение x из области определения функции). 187. Решите уравнения, выбирая подходящий метод решения:
x3 - 9x + 2 = 0, xeч = 2, x = 0.538sinx + 1, aч = ax при a > 1, x2 arctgx = a, где
188. Решить уравнение
, 
189. Пользуясь правилами прямоугольника, трапеции и правилом Симпсона, вычислить приближенно число
. Полученные результаты сравнивать между собой и значением с заданной точностью. 
190. Вычислить
, используя правило Симпсона. Найти модуль перехода от натурального логарифма к десятичному.
191. Вычислить по формуле Симпсона или методом Монте-Карло.
, 
, 
, 
, 
192. В следующих задачах при нахождении пределов интегрирования необходимо воспользоваться методами приближенного решения уравнений.
а) Найти площадь фигуры, ограниченной дугами парабол y = x3- 7 и
y = - 2x2+ 3x и осью ординат.
б) Найти площадь фигуры, ограниченной параболой y = x3 и прямой
y = 7(x + 1).
в) Найти площадь фигуры, ограниченной параболой y=16 - x3 и полукубической параболой y =
193. Вычислить двойной интеграл по методу Монте-Карло:
если область (A) ограничена двумя параболами: y = x2 и y2 = x.
Ответы
К
заданию 1
Program derivative2;
uses WinCrt;
var
x0, eps, dx, dy, dy3 : real;
Function fx(x : real) : real;
begin
fx := x*x*x*x
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления второй производной }
Function derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите точку, в которой находится ');
write('вторая производная '); readln(x0);
write(' Введите точность вычисления второй производной ');
readln(eps);
dy := derivat2(x0, eps);
write('Вторая производная функции в точке ', x0:6:t(eps));
writeln(' равна ', dy:6:t(eps));
writeln('с точностью до ', eps:1:t(eps))
end.
К заданию 3
{ Выбор метода решения уравнений: метод хорд, метод касательн. }
{ комбинированный метод }
Program Case_method;
uses WinCrt;
var
a, b, x, eps : real;
k : integer;
{----------------------------------------------------------------------------------------}
{ Заданная функция }
Function fx(x : real) : real;
begin
fx := x*sin(x) - 0.5
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Вычисление 1-й производной }
Function derivat1(x0, eps : real) : real;
var
dx, dy, dy2 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx/2) - fx(x0 - dx/2);
dy2 := fx(5*x0/4 + dx) - 2*fx(5*x0/4);
dy2 := dy2 + fx(5*x0/4 - dx)
until abs((dy2*dy2*fx(x0))/(2*dx)) < eps;
derivat1 := dy/dx
end;
{----------------------------------------------------------------------------------------}
{ Вычисление 2-й производной }
Function derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
{----------------------------------------------------------------------------------------}
{ Процедура определения наименьшего значения производной }
{ на заданном промежутке }
Procedure minimum(a, b, eps : real; var min : real);
var
d : real;
begin
a := a - eps;
b := b + eps;
repeat
a := a + eps;
b := b - eps;
min := abs(derivat1(a, eps));
d := abs(derivat1(b, eps));
if min > d then min := d
until min <> 0
end;
{----------------------------------------------------------------------------------------}
{ Процедура уточнения корня методом хорд }
Procedure chord1(a, b, eps : real; var
x : real);
var
x1, min : real;
begin
minimum(a, b, eps, min);
x1 := a;
repeat
x := x1 - ((b - x1)*fx(x1))/(fx(b) - fx(x1));
x1 := x
until abs(fx(x))/min < eps
end;
{----------------------------------------------------------------------------------------}
{ Процедура уточнения корня методом касательных }
Procedure tangent1(a, b, eps, min : real; var x : real);
var
x1 : real;
begin
x1 := a;
repeat
x := x1 - fx(x1)/derivat1(x1, eps);
x1 := x
until abs(fx(x))/min < eps
end;
{----------------------------------------------------------------------------------------}
Procedure Tangent2(a, b, eps : real; var x : real);
var
min : real;
begin
minimum(a, b, eps, min);
if fx(a)*derivat2(a, eps) > 0
then tangent1(a, b, eps, min, x)
else tangent1(b, a, eps, min, x)
end;
{----------------------------------------------------------------------------------------}
{ Процедура уточнения корня методом хорд }
Procedure chord(a, b : real; var
x : real);
begin
x := a - ((b - a)*fx(a))/(fx(b) - fx(a))
end;
{----------------------------------------------------------------------------------------}
{ Процедура уточнения корня методом касательных }
Procedure tangent(a, b, eps : real; var
z : real);
begin
z := a - fx(a)/derivat1(a, eps)
end;
{----------------------------------------------------------------------------------------}
{ Комбинированный метод }
Procedure Combination(a, b, eps : real; var x : real);
var
z : real;
begin
repeat
if fx(a)*derivat2(a, eps) > 0
then
begin
tangent(a, b, eps, z);
chord(b, a, x);
b := z; a := x
end
else
begin
tangent(b, a, eps, z);
chord(a, b, x);
b := x; a := z
end
until abs(z - x) < eps
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите левый конец промежутка a = '); readln(a);
write('Введите правый конец промежутка b = '); readln(b);
write('Введите точность вычисления корня eps = ');
readln(eps);
writeln('Для выбора метода решения, введите его номер ');
writeln('1 - метод хорд, 2 - метод касательных');
writeln(' 3 - комбинированный метод'); readln(k);
Case k of
1 : chord1(a, b, eps, x);
2 : Tangent2(a, b, eps, x);
3 : Combination(a, b, eps, x)
end;
writeln('Корень уравнения равен x = ', x:6:t(eps));
writeln('С точностью до eps = ', eps:1:t(eps))
end.
К заданию 4
{ Вычисление интеграла по формуле трапеций }
Program integral_trapezoid;
uses WinCrt;
var
a, b, eps, j : real;
n : integer;
Function fx(x : real) : real;
begin
fx := 1/x
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления второй производной }
Function derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
{----------------------------------------------------------------------------------------}
{ Процедура определения числа точек деления промежутка интегр. }
Procedure Number(a, b, eps : real; var
n : integer);
var
dy2, d, c, dx : real;
begin
c := (a + b)/2;
dy2 := derivat2(c, eps);
dx := (b - a)/10;
if dy2 = 0
then
begin
c := a;
while derivat2(c, eps) = 0 do c := c + dx;
dy2 := derivat2(c, eps)
end;
n := 1;
d := abs((b - a)*(b - a)*(b - a));
while abs(dy2*d)/(12*n*n) >= eps do n := n+1;
end;
{----------------------------------------------------------------------------------------}
{ Вычисл. интеграла по формуле трапеций. Trapezoid - трапеция }
Procedure Trapezoid(a, b : real; n : integer; var j : real);
var
dx, c, f : real;
i : integer;
begin
dx := (b - a)/n;
c := a;
f := (fx(a) + fx(b))/2;
for i := 1 to n - 1 do
begin
c := c + dx;
f := f + fx(c)
end;
j := dx * f
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите нижний предел интегрирования '); readln(a);
write('Введите верхний предел интегрирования '); readln(b);
write('Введите точность вычисления интеграла ');
readln(eps);
Number(a, b, eps, n);
Trapezoid(a, b, n, j);
writeln('Значение интеграла равно ', j:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
2-й способ
{ Вычисление интеграла по формуле трапеций }
Program integral_trapezoid;
uses WinCrt;
var
a, b, eps, max, j : real;
n : integer;
Function fx(x : real) : real;
begin
fx := 1/x
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления второй производной }
Function derivat2(x0, eps : real) : real;
var
dx, dy, dy3 : real;
begin
dx := 1;
repeat
dx := dx/2;
dy := fx(x0 + dx) - 2*fx(x0) + fx(x0 - dx);
dy3 := fx(5*x0/4 + 2*dx) - 2*fx(5*x0/4 + dx);
dy3 := dy3 - fx(5*x0/4 - 2*dx) + 2*fx(5*x0/4 - dx)
until abs(dy3/(6*dx)) < eps;
derivat2 := dy/(dx*dx)
end;
{----------------------------------------------------------------------------------------}
{ Определение наибольшего значения второй производной }
Procedure Maximum(a, b, eps : real; var
max : real);
var
dx, x : real;
begin
dx := 0.1; x := a;
max := abs(derivat2(x, eps));
while x<= b do
begin
x := x + dx;
if max < abs(derivat2(x, eps))
then max := abs(derivat2(x, eps))
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура определения числа точек деления промежутка интегр. }
Procedure Number(a, b, eps, max : real; var
n : integer);
var
d : real;
begin
n := 1;
d := abs((b - a)*(b - a)*(b - a));
while (max*d)/(24*n*n) >= eps do n := n+1;
end;
{----------------------------------------------------------------------------------------}
{ Вычисл. интеграла по формуле трапеций. Trapezoid - трапеция }
Procedure Trapezoid(a, b : real; n : integer; var j : real);
var
dx, c, f : real;
i : integer;
begin
dx := (b - a)/n;
c := a;
f := (fx(a) + fx(b))/2;
for i := 1 to n - 1 do
begin
c := c + dx;
f := f + fx(c)
end;
j := dx * f
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите нижний предел интегрирования '); readln(a);
write('Введите верхний предел интегрирования '); readln(b);
write('Введите точность вычисления интеграла '); readln(eps);
Maximum(a, b, eps, max); Number(a, b, eps, max, n);
Trapezoid(a, b, n, j);
writeln('Значение интеграла равно ', j:6:t(eps));
writeln('С точностью до ', eps:1:t(eps))
end.
К заданию 6
{ Вычисление интеграла методом Монте-Карло }
Program integral_Monte_Karlo;
uses WinCrt;
var
a, b, eps : real;
n : longint;
{----------------------------------------------------------------------------------------}
Function fx(x : real) : real; { Промежуток интегрир. [3, 4] }
begin { Интеграл хорошо вычисл. с точн. до 0.00001 }
fx := sin(0.2*x - 3)/(x*x + 1)
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол- во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления интеграла методом Монте-Карло }
Function I(n : longint; a, b : real) : real;
var
x, f : real;
k : longint;
begin
randomize;
f := 0;
for k := 1 to n do
begin
x := random*(b - a) + a;
f := f + fx(x)
end;
I := (b - a)*f/n
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите нижний предел интегрирования '); readln(a);
write('Введите верхний предел интегрирования '); readln(b);
write('Введите точность вычисления '); readln(eps);
n := 10;
repeat
n := 2*n
until abs(I(n, a, b) - I(2*n, a, b)) <= eps;
writeln('Значение интеграла равно ', I(2*n, a, b):6:t(eps));
writeln('С точностью до ', eps:1:t(eps));
end.
Применение метода Монте-Карло для вычисления площадей фигур
Рассмотрим применение метода Монте-Карло для определения площадей фигур, ограниченных линиями.Пример 7. Вычислить площадь фигуры, ограниченной линиями
Решение
Прежде необходимо установить ту фигуру, площадь которой требуется найти. Эта фигура заключена между осью OX, - уравнение y = 0; параболой с вершиной в точке (0; 0) и двумя прямыми, параллельными оси OY и проходящими через точки 1 и 2 на оси OX.
Установим, внутри какой простой фигуры (квадрата, прямоугольника и т.п.) может быть заключена заданная сложная фигура (см. рис. 39).
Рис. 39
По рисунку легко установить, что такой фигурой является прямоугольник с вершинами в точках (1; 0), (2; 0), (2; 4) и (1; 4). Площадь этого прямоугольника равна: Sпр = 4.
Значит площадь искомой фигуры будет равна:
где 4 - площадь прямоугольника, M - число точек, попавших в фигуру, N - число всех "брошенных" точек. Дальнейший ход решения такой же, как и в предыдущем примере.
"Бросаются" точки в прямоугольник. Их случайные координаты задаются так: x := random + 1, y := random*4.
Какие точки попадут в фигуру, площадь которой надо найти? Координаты точек, попадающих в фигуру, должны удовлетворять неравенствам:
и 
Но условие для x выполняется заведомо, так как у любой случайно "брошенной" точки координата по x удовлетворяет неравенству (ибо уже задано, что x := random + 1, а для координаты по y выполнена лишь левая часть неравенства, значит чтобы точка попала в данную фигуру достаточно потребовать, чтобы 
На основе этих соображений составляем программу
Program Problem7;
uses WinCrt;
var
x, y, s, e, pp : real;
i, n, m : longint;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random + 1; y := random*4;
if y < x*x then m := m + 1
end;
s := 4*m/n;
writeln('Площадь фигуры равна ', s:1:6);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Пример 8. Вычислить площадь фигуры, ограниченной линиями
и 
Начертим заданную фигуру. Графиком функции y = 3 - 2x - x2 является парабола, ветви которой направлены вниз, а вершина находится в точке (-1; 4). В самом деле, выделим квадрат двучлена, получим:
y = -(x2 + 2x + 1 - 1 - 3) = -(x + 1)2 + 4.
Графиком функции y = 1 - x является прямая, проходящая через точки (1; 0) и (0; 1).
Необходимо найти точки пересечения этих графиков. Для этого надо решить систему из уравнений, описывающих заданные функции:
Решая находим, 1 - x =3 - 2x - x2, отсюда получаем: x1 = -2, x2 = 1. Значит координаты точек пересечения будут: (-2; 3) и (1; 0).
Полученную фигуру можно заключить в прямоугольник с вершинами (-2; 0), (-2; 4), (1; 4) и (1; 0) (см. рис. 40).
Рис. 40
Площадь этого прямоугольника равна
Тогда площадь искомой фигуры равна: 
Чтобы "бросить" точку в этот прямоугольник, надо указать следующие случайные координаты этих точек: x := random*3 - 2 и y := random*4.
Точки, попавшие в заданную фигуру должны лежать "выше" прямой
и "ниже" параболы 
значит их координаты должны удовлетворять неравенствам: 
Программа
Program Problem8;
uses WinCrt;
var
x, y, s, e, pp : real;
i, n, m : longint;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function
FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random*3 - 2; y := random*4;
if (y <= 3 - 2*x - x*x) and
(y >= 1 - x) then m := m + 1
end;
s := 12*m/n;
writeln('Площадь фигуры равна ', s:1:6);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Задание 20
Вычислить площади фигур, ограниченных линиями:
1) y = 0, x = 0, x = 2, y = 1/(x + 1)2 +1;
2) y = cosx, y = 0, x = 0, x =
/2.Библиотека часто встречающихся процедур и функций
31. Процедура вычисления вероятности биномиального закона распределения.
{ Рекуррентная процедура вычисления вероятности }
{биномиального закона распределения }
Procedure Recurro_binomial(n, m : integer; p : real; var pp : real);
var
i : integer;
begin
Extent(1 - p, n, pp);
for
i := 1 to m do pp := (pp*(n - i + 1)*p)/(i*(1 - p))
end;
32. Функция вычисления вероятностей по формуле Пуассона.
{ Функция вычисления вероятности распределения Пуассона }
Function PS(m : integer; a : real) : real;
var
i : integer;
pp : real;
begin
pp := exp(-a);
if m = 0 then pp := exp(-a)
else for i := 1 to m do pp := pp*a/i;
PS := pp
end;
33. Функция вычисления значений функции Гаусса:
{ Функция Гаусса }
Function G(x : real) : real;
begin
G := exp(-sqr(x)/2)/sqrt(2*Pi)
end;
34. Процедура вычисления вероятности по локальной формуле Муавра-Лапласа.
{ Процедура нахожд. вероятн. по локальной форм. Муавра-Лапласа }
Procedure Local_Laplace(n, m : longint; p : real; var pp : real);
var
x : real;
begin
x := (m - n*p)/sqrt(n*p*(1 - p));
pp := G(x)/sqrt(n*p*(1 - p))
end;
35. Функция вычисления интегральной функции Муавра-Лаплапса.
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if
x >= 5
then FF := 1
else if x <= -5
then
FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until
abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
36. Процедура вычисления вероятности появления события из заданного интервала [m1; m2].
{ Процедура вычисл. вероятн. наст. событ. из промеж. [m1; m2] }
Procedure Interval(n, m1, m2 : longint; p : real; var PP : real);
var
x1, x2 : real;
begin
x1 := (m1 - n*p)/sqrt(n*p*(1 - p));
x2 := (m2 - n*p)/sqrt(n*p*(1 - p));
PP := (FF(x2) - FF(x1))/2
end;
37. Процедура вычисления вероятности отклонения частоты m от заданного произведения np.
{ Процедура вычисления вероятности частоты наступления событий }
{ при заданной точности e - отклонении частоты от np }
Procedure
Probability(n : longint; p, e : real; var PP : real);
var
x : real;
begin
x := e/sqrt(n*p*(1 - p));
PP := FF(x)
end;
38. Процедура вычисления вероятности отклонения частости от вероятности в одном испытании (по абсолютной величине).
Procedure
ProbabilityLap(n : longint; p, e : real; var PP : real);
var
x : real;
begin
x := e*sqrt(n/(p*(1 - p)));
PP := FF(x)
end;
39. Процедура вычисления числа испытаний при заданной гарантированной вероятности и заданной точности частости.
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until
FF(x) >= PP
end;
Второй способ
нахождения значения n. Он основывается на следующей процедуре:
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure Number2(e, PP : real; var n : longint);
var
x : real;
begin
x := 0;
repeat
x := x + 0.0001
until
FF(x) >= PP;
n := trunc(sqr(x/(2*e)))
end;
40. Процедура нахождения аргумента функции Муавра-Лапласа
Procedure
Argument(PP : real; var x : real);
begin
x := 0;
repeat
x := x + 0.0001
until FF(x) >= PP
end;
Второй способ
{ Процедура нахождения аргумента функции Муавра-Лапласа }
Procedure
Argument(PP, eps : real; var x : real);
begin
x := 0;
repeat
x := x + eps
until FF(x) >= PP
end;
Упражнения
144. Вероятность солнечной погоды в некоторой местности для каждого дня равна 0,4. Какова вероятность того, что в течение трех дней хотя бы один день будет солнечным?
145. Минное заграждение поставлено в одну линию с интервалами между минами в 100 м. Какова вероятность того, что корабль шириной 20 м, пересекая это заграждение под прямым углом, подорвется на мине? (Размерами мины можно пренебречь.)
146. На окружности радиуса R наудачу выбирается точка. Найти вероятность того, что выбранная точка будет находиться от точки A, фиксированной на данной окружности, на расстоянии, не превышающем R.
147. Из фиксированной вершины квадрата произвольным радиусом, меньшим его диагонали, проведена окружность. Какова вероятность того, что дуга пересечет стороны квадрата, имеющие эту вершину одним из своих концов?
148. В круг радиуса R вписан правильный шестиугольник. Какова вероятность того, что наудачу выбранная точка внутри круга окажется внутри шестиугольника?
149. Шар радиуса r = 2 см наудачу бросают в круг радиуса R=25 см, в котором вырезано квадратное отверстие со стороной a = 14 см. Какова вероятность того, что шар пройдет через это отверстие, не задев его края, если он непременно попадет в круг?
150. В 25 см от центра шара, радиус которого равен 15 см, находится точечный источник света. Какова вероятность того, что наудачу взятая точка на поверхности шара окажется освещенной?
151. На отрезке AB длины a наудачу выбирается точка M, а на отрезке CD длины b
- точка N. Какова вероятность того, что точки M и N делят отрезки AB и CD так, что отношение
, а отношение 
, если точки M и N выбираются независимо друг от друга? 152. Точка A наудачу выбирается на окружности, радиус которой равен R, а точка B - на отрезке CD длины a. Найти вероятность того, что точка A окажется на дуге, длина которой равна R, а точка B окажется расположенной от конца C отрезка CD не далее чем на 0,4а.
153. Какова вероятность того, что две наудачу выбранные точки внутри круга радиуса R окажутся внутри вписанного в этот круг квадрата, если они выбираются независимо друг от друга?
154. Два действительных числа x и y выбираются наугад независимо друг от друга так, что сумма их квадратов меньше 64. Какова вероятность того, что сумма положительных x и y окажется меньше восьми?
Применение ряда Фибоначчи
Пример 2. Определение минимума функции с помощью ряда Фибоначчи.Ряд Фибоначчи много интересных применений в математике. О некоторых из них мы поговорим позже, а на этом занятии разберем использование этого ряда для поиска минимума функции на заданном промежутке (смотри также В.Ф. Очков, Ю.В. Пухначев, "128 советов начинающему программисту", Москва, 1991 г.).
Для примера рассмотрим функцию
на промежутке (0, 2). График этой функции, а точнее, его часть на промежутка (0, 2) показан на рисунке 23.
Рис. 23
Итак, стоит задача найти минимум функции на этом промежутке, т.е. значение x, при котором получается минимум и значение функции y в этой точке. Первая мысль, которая возникает - это делить отрезок (0, 2) пополам, затем выяснять, на каком из получившихся частей может находится минимум и делить эту часть пополам и так далее. Такой процесс возможен, но имеет два существенных недостатка.
Во-первых, "приближение" к точке минимума будет очень медленным, придется испробовать много вариантов, чтобы "подобраться" к искомой точке.
Во-вторых, при даже очень большом количестве делений точность приближения будет невелика.
Поэтому, возникает необходимость как-то иначе делить отрезок (если мы избрали метод деления отрезка). Но как? Отделять от одного конца 4-ю или 3-ю части и постепенно сужать отрезок к лучшему результату не приведет, пожалуй еще и к худшему.
Улучшить процесс деления отрезка помогает ряд Фибоначчи. Может даже возникнуть впечатление, что он как будто специально создан для этой цели. Хотя ряд возник совершенно из других более естественных соображений, он показывает число появления кроликов во 2-й, 3-й, 4-й и т. д. годы, если первоначально есть только одна самка и один самец. Но многие закономерности природы прекрасно описываются математическими средствами, вот и в нашем примере ряд Фибоначчи дает очень хорошие результаты.
Для деления отрезка можно задать число делений - n, а затем в зависимости от n определить коэффициент деления, как отношение (n - 1)-го и n-го членов ряда.
Если a - левый конец промежутка, b - правый, тогда разделить отрезок можно так: x2 := a + (b - a)*fib(n - 1)/fib(n); y2 := f(x2);
Для n = 10 отношение fib(9)/fib(10) = 34/55 = 0.6181818... . Тогда, правая граница станет равна: x2 := 1.236364... . Для дальнейшего процесса поиска, надо "приблизить" левый конец промежутка на такое же расстояние к правому концу (
), затем найти соответствующее значения функции (y1 := f(x1) и определить, который из промежутков брать для дальнейшего рассмотрения. В дальнейшем могут возникнуть несколько случаев.
Если x2 > x1 и y2 > y1, тогда в качестве правого конца промежутка принять x2 и зафиксировать его (b := x2), а x2 заменить на x1 (x2 := x1), y2 присвоить значение y1 (y2:=y1) и повторить процесс приближения левого конца к правому:
x1 := a + b - x2.
Если x2 <= x1 и y2 > y1, тогда a := x2; x2 := x1; y2 := y1 и повторить:
x1 := a + b - x2.
Если x2 > x1 и y2 < y1, тогда a := x1 и выполнить: x1 := a + b - x2.
Если x2 <= x1 и y2 <= y1, тогда b := x1 и выполнить: x1 := a + b - x2.
Если ни одно из этих условий не выполняется, тогда выполнятся оператор:
x1 := a + b - x2
и весь процесс повторяется.
Для составления программы потребуется функция, вычисляющая члены ряда Фибоначчи, уже знакомая нам:
{ Функция вычисления членов ряда Фибоначчи }
Function fib(n : integer) : real;
var
f, f1, f2 : real;
i : integer;
begin
f1 := 1; f := 0;
for i := 1 to n do
begin
f2 := f1; f1 := f;
f := f1 + f2
end;
fib := f
end;
Нужно будет вычислять значения заданной функции и для этого составим следующую функцию:
{ Заданная исследуемая функция }
Function
func(x : real) : real;
begin
func := x*x*x*x - 14*x*x*x + 60*x*x - 70*x
end;
Полностью программа
приводится ниже:
Program Minimumfib;
uses WinCrt;
label 1;
var
a, aa, bb, x, b, x1, x2, y1, y2 : real; i, n : integer;
{----------------------------------------------------------------------------------------}
{ Заданная исследуемая функция }
Function func(x : real) : real;
begin
func := x*x*x*x - 14*x*x*x + 60*x*x - 70*x
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления членов ряда Фибоначчи }
Function fib(n : integer) : real;
var
f, f1, f2 : real; i: integer;
begin
f1 := 1; f := 0;
for i := 1 to n do
begin
f2 := f1;
f1 := f;
f := f1 + f2
end;
fib := f
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите нижнюю границу промежутка '); readln(a);
aa := a;
write('Введите правую границу промежутка '); readln(b);
bb := b;
write('Введите число приближений к минимуму '); readln(n);
x2 := a + (b - a)*fib(n-1)/fib(n); y2 := func(x2);
for i := 1 to n do
begin
x1 := a + b - x2; y1 := func(x1);
if (x2 > x1) and (y2 > y1)
then
begin
b := x2; x2 := x1; y2 := y1; goto 1
end;
if (x2 <= x1) and (y2 > y1)
then
begin
a := x2; x2 := x1; y2 := y1; goto 1
end;
if (x2 > x1) and (y2 < y1)
then
begin
a := x1; goto 1
end;
if (x2 <= x1) and (y2 <= y1)
then
begin
b := x1; goto 1
end;
1: end;
x := (a + b)/2;
write('Мин.
значение функции на (');
writeln(aa:1:0, ',', bb:2:0, ')');
writeln('Значение функции равно ', func(x):6:12);
writeln('При значении аргумента ', x:6:12)
end.
В этой программе число приближений устанавливается пользователем. Программу можно изменить, указав в условии цикла точность приближения значений аргумента x. Но тогда придется каждый раз при повторении цикла изменять коэффициент деления, так неизвестно конечное число повторений цикла. Для этого можно добавить в программу процедуру вычисления границ промежутка:
{ Процедура вычисления знач. аргумента и функции }
{ approach - приближение }
Procedure approach(a, b : real; n : integer; var x2, y2 : real);
begin
x2 := a + (b - a)*fib(n - 1)/fib(n);
y2 := func(x2)
end;
И тогда, программа станет следующей:
{Поиск минимума функции методом Фибоначчи}
Program Minimumfib;
uses WinCrt;
label 1;
var
a, aa, bb, x, b, x1, x2, y1, y2, e : real;
n : integer;
{----------------------------------------------------------------------------------------}
{ Заданная исследуемая функция }
Function func(x : real) : real;
begin
func := x*x*x*x - 14*x*x*x + 60*x*x - 70*x
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления членов ряда Фибоначчи }
Function fib(n : integer) : real;
var
f, f1, f2 : real;
i : integer;
begin
f1 := 1; f := 0;
for i := 1 to n do
begin
f2 := f1;
f1 := f;
f := f1+f2
end;
fib := f
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления знач.
аргумента и функции }
{ approach - приближение }
Procedure approach(a, b : real; n : integer;
var x2, y2 : real);
begin
x2 := a + (b - a)*fib(n-1)/fib(n);
y2 := func(x2)
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write(' Введите нижнюю границу промежутка '); readln(a);
aa := a;
write('Введите правую границу промежутка '); readln(b);
bb := b;
write('Введите точность приближения '); readln(e); n := 3;
approach(a, b, n, x2, y2);
while abs(b - a) > e do
begin
x1 := a + b - x2; y1 := func(x1);
if (x2 > x1) and (y2 > y1)
then
begin
n := n + 1;
approach(a, b, n, x2, y2);
b := x2; x2 := x1; y2 := y1; goto 1
end;
if (x2 <= x1) and (y2 > y1)
then
begin
n := n + 1;
approach(a, b, n, x2, y2);
a := x2; x2 := x1; y2 := y1; goto 1
end;
if (x2 > x1) and (y2 < y1)
then
begin
n := n + 1;
approach(a, b, n, x2, y2);
a := x1; goto 1
end;
if (x2 <= x1) and (y2 <= y1)
then
begin
n := n + 1;
approach(a, b, n, x2, y2);
b := x1; goto 1
end;
n := n + 1;
approach(a, b, n, x2, y2);
1: end;
x := (a + b)/2;
write('Мин. значение функции на промежутке (');
writeln(aa:1:0,',',bb:2:0,')');
writeln('Значение функции равно ', func(x):6:12);
writeln('При значении аргумента ', x:6:12)
end.
Очень часто, при поиске минимума функции для деления отрезка используют так называемое "Золотое сечение".
"Золотое сечение" или "золотое сечение" - деление отрезка на две части так, что большая из них есть средняя пропорциональная между меньшей частью и всем отрезком. Если a - весь отрезок, x - большая из двух частей, тогда:
a : x = x : (a - x)
Решая это уравнение, получаем:
получим: 
(с точностью до 0.001). Зная это, можно составить программу поиска минимума функции, используя "золотое сечение", тогда:
x1 := 0.618*a + 0.382*b, x2 := 0.382*a + 0.618*b.
Для вычисления этих значений можно составить две процедуры, которые затем использовать в программе.
Procedure gold1(a, b : real; var
x1, y1 : real);
begin
x1 := 0.618*a + 0.382*b; y1 := fx(x1)
end;
{------------------------------------------------------}
Procedure gold2(a, b : real; var
x2, y2 : real);
begin
x2 := 0.382*a + 0.618*b; y2 := fx(x2)
end;
Программирование в среде Microsoft Windows на языке Pascal
В этой части занятия описывается программирование с помощью компиляторов Turbo Pascal for Windows и Borland Pascal for Windows.Ясно, что эта часть занятия будет полезна тем, кто работает в среде Windows.
На этом занятии мы не будем останавливаться на огромных возможностях, которые предоставляет интегрированная среда Borland Pascal, а узнаем начальные этапы работы. Прежде выясним, как можно программы, разработанные на Turbo Pascal 7 запустить в среде Borland Pascal.
Для этого, забегая несколько вперед, познакомимся с тем, что такое модули и каким модулем надо пользоваться, чтобы программа, написанная в DOS, могла работать в среде Windows.
Что такое модуль?
Модуль представляет собой набор констант, типов данных, переменных, процедур и функций. Каждый модуль по своей структуре аналогичен отдельной программе. Вместе с тем структура модуля позволяет использовать его как своеобразную библиотеку описаний.
В Borland Pascal входит 7 модулей. На этом занятии мы познакомимся с одним из них - WinCRT.
Модуль WinCRT может быть использован для преобразования DOS-программ и создания небольших Windows программ.
Для этого необходимо включить в начале DOS-программы следующую строку:
uses WinCrt;
Для примера рассмотрим приведенную выше программу Serg. В DOS она имела следующий вид:
Program Serg;
var
a, b, c: integer;
begin
write('Введите число лет, которое было бы Сереже '); readln(a);
b := a + 17;
c := b div 3;
writeln('Сереже было ', c, ' лет')
end.
Добавим в начала этой программы модуль WinCrt и программа сможет работать в среде Borland Pascal. В этом случае она станет такой:
Program Serg;
uses WinCrt;
var
a, b, c: integer;
begin
write('Введите число лет, которое было бы Сереже '); readln(a);
b := a + 17;
c := b div 3;
writeln('Сереже было ', c, ' лет')
end.
Теперь поговорим о среде разработчика. После запуска программы BPW (так в Windows записан Borland Pascal for Windows) на экране появляется следующее окно (см.
рис. 9):
Рис. 9
Чтобы набрать текст программы, достаточно выбрать из верхнего меню "File" и "щелкнуть" один раз левой кнопкой мыши. Окно разработчика примет вид (см. рис. 10):
Рис. 10
Из "выпавшего" меню следует выбрать "New" и нажать <Enter> или "щелкнуть" один раз левой кнопкой мыши. Окно очистится и предоставит пользователю возможность набирать текст программы на "чистом" поле (см. рис. 11).
Рис. 11
Перед началом ввода текста программы желательно установить шрифт, с котором вы будете работать. Желательно выбрать шрифт с кириллицей, т. е. такой, чтобы можно было бы набирать и русский текст.
Для установки шрифта следует выбрать в верхнем меню опцию "Options" и нажать <Enter> или "щелкнуть" один раз левой кнопкой мыши. "Выпадает" новое меню, из которого надо выбрать опцию "Environment" ("Среда") (см. рис. 12).
Рис. 12
После установки курсорной доски на слово "Environment" справа появляется новое меню, которое является своеобразным подменю раздела "Environment", которое состоит из следующих разделов:
Environment Preferences .. .Editor ...
Mouse ...
Startup ...
Highlight ...
Из появившегося меню надо выбрать "Editor ..." и нажать <Enter> или "щелкнуть" один раз левой кнопкой мыши. На экране появится меню, в котором из раздела "Font", "наступив" на указатель выбора шрифта можно выбрать нужный шрифт, название которого появится в видимом окне (см. рис. 13).
Рис. 13
После выбора шрифта можно набирать текст программы. Текст программы набран. Как выполнить пуск программы? Для этого из верхнего меню выбираем "Run" ("Пуск"), "выпадает" меню опции "Run" (см. рис. 14):
Рис. 14
Следует выбрать "Run Ctrl+F9". Программа будет запушена и выполнена.
Для записи программы на диск, следует выбрать опцию "File" из верхнего меню. Выбрать "Save" или "Save as" и записать в нужный каталог и под указанным именем свою программу (см. рис. 15).
Рис. 15
Если программа была уже записана на диск и вам потребовалось ее вызвать для доработки или запуска в работу, тогда следую выбрать из меню опции "File" "Open" ("Открыть"), выбрать нужный каталог, файл и работать с программой (см. рис. 16).
Рис. 16
В дальнейшем мы будем составлять и выполнять программы в интегрированной среде Borland Pascal. Но если кто-то работает на Turbo Pascal 6 или 7, тогда достаточно не писать в начале программы обращение к модулю uses WinCrt или заключить это обращение в фигурные скобки, т. е. сделать в виде комментария. Все остальное в программах остается без изменения. И лишь в главах, где рассматриваются модули и объектно-ориентированное программирование отдельно будет оговорено использование модулей в DOS и Windows.
Программы с совместным использованием циклов repeat и while do
Пример 3.Если мы сложим все цифры какого-либо числа, затем - все цифры найденной суммы и будем повторять это много раз, мы наконец получим однозначное число (цифру), называемое цифровым корнем данного числа. Например, цифровой корень числа 561 равен 3 (5 + 6 + 1 = 12; 1 + 2 = 3).
Составьте программу для нахождения числового корня числа.
Соображения по составлению программы
Ясно, что в программе должен быть цикл, который определяет сумму цифр числа. В свою очередь, этот цикл должен также выполняться до тех пор, пока значение суммы цифр не станет равным одной цифре, т.е. станет меньше 10, но остается больше 0. Для этого надо организовать еще один цикл, который будет являться внешним
по отношению к циклу, подсчитывающему сумму цифр.
Одна тонкая особенность! Каждый раз после выполнения внутреннего цикла подсчета суммы цифр, значение этой суммы надо присваивать переменной, в которой содержится первоначальное число, т. е. заменять число на его сумму, проверять условие (не является ли сумма меньше десяти) и продолжать цикл уже с новым числом - суммой, если условие не выполняется. А ту переменную, в которой накапливалась сумма надо каждый раз не забывать обнулять.
Итак, если введенное число было присвоено переменной n, а сумма его цифр переменной s, то после подсчета суммы цифр, переменная должна получить значение s (n:= s), проверить условие (n < 10), если оно еще не выполняется, тогда обнулить переменную s (s:= 0) и продолжить цикл подсчета суммы цифр.
Внешний цикл по проверке значения суммы организуем с помощью операторов repeat ... until
n < 10, а внутренний по подсчету суммы цифр с помощью операторов while
... do.
Программа
Program
Problem3; { Цифровой корень числа }
uses WinCrt;
var
n, a, s : integer;
begin
write('Введите натуральное число '); readln(n);
a := n;
repeat
s := 0;
while n <> 0 do
begin
s := s + n mod 10; n := n div 10
end;
n := s
until n < 10;
writeln('Цифровой корень числа ', a, ' равен ', n)
end.
Распределение Пуассона
Распределение Пуассона часто встречается в задачах, связанных с потоком событий.Под потоком событий будем понимать последовательность событий, наступающих одно за другим в случайные моменты времени.
Примерами могут быть: поток вызовов на телефонной станции, поток заявок в системе массового обслуживания, последовательность распада частиц некоторого количества радия и др.
Простейший поток событий характеризуется следующими свойствами:
а) вероятность наступления того или иного числа событий за любой промежуток времени зависит только от длительности этого промежутка (а не от начала отсчета);
б) указанная вероятность не зависит от того, какое число событий наступило до начала рассматриваемого промежутка времени (отсутствие последствия);
в) за малый промежуток времени вероятность наступления одного события приближенно пропорциональна длительности такого промежутка, а вероятностью наступления двух или более событий можно пренебречь.
В качестве случайной величины X мы рассмотрим число событий простейшего потока, наступающих за фиксированный промежуток времени t.
Значениями этой случайной величины могут быть любые целые числа
m = 0, 1, 2, 3, ...
Соответствующие вероятности обозначим через
pm(t) есть вероятность того, что за фиксированный промежуток m времени t наступит ровно m событий простейшего потока.
Пусть
- малая величина, сравним вероятности 
В результате несложных математических рассуждений приходим, что в пределе при
мы получаем для искомой вероятности p0(t) линейное дифференциальное уравнение первого порядка 
Решая это уравнение при начальном условии p0(0) = 1, находим искомую вероятность отсутствия событий за промежуток времени t;
Нетрудно получить и общую формулу для расчета вероятностей
при 
Эта формула и дает закон распределения случайной величины X - числа событий простейшего потока, наступающих за промежуток времени t.
Статистический смысл параметра
в этой формуле можно выяснить, если единицу времени разбить на N равных промежутков 
тогда получаем приближенное равенство 
мы можем толковать его правую часть как относительную частоту наступления некоторого события простейшего потока за промежуток времени наблюдения
; это означает, что есть среднее число наступления таких событий за единицу времени. Обычно произведение
t обозначают a и записывают закон распределения в виде 
Этот закон распределения и называют законом распределения Пуассона или законом редких явлений.
Замечание. При малых значениях p и больших значениях n распределение Пуассона может быть применено в качестве приближенного значения для биномиального распределения.
Обозначим np = a, тогда p = a/n, q = 1 - p = 1 - a/n. Разложим вероятность
в степенной ряд по степеням 1/n; ограничиваясь членами порядка 1/n, получим 
Первый член этого разложения дает как раз вероятность в распределении Пуассона, откуда и следует приближенная (асимптотическая) формула
второй член в скобках может служить для оценки относительной погрешности этой приближенной формулы:
Составим процедуру для вычисления вероятности по формуле Пуассона.
Для этого выведем рекуррентную формулу для вычисления вероятности:
отсюда получаем соотношение:
При m = 0, получим
Пользуясь этими двумя формулами легко составить функцию вычисления вероятностей по формуле Пуассона.
{ Функция вычисления вероятности распределения Пуассона }
Function PS(m : integer; a : real) : real;
var
i : integer;
pp : real;
begin
pp := exp(-a);
if m = 0 then pp := exp(-a)
else for i := 1 to m do pp := pp*a/i;
PS := pp
end;
Составим программы решения следующих задач, используя эту процедуру.
Пример 1. Вероятность изделию быть бракованным равна 0.05. Найти вероятность того, что среди 1000 изделий 40 бракованных.
{ Распределение Пуассона }
Program Problem1;
uses WinCrt;
var
n, m : longint;
p, a : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления вероятности распределения Пуассона }
Function PS(m : integer; a : real) : real;
var
i : integer;
pp : real;
begin
pp := exp(-a);
if m = 0 then pp := exp(-a)
else for i := 1 to m do pp := pp*a/i;
PS := pp
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите общее число изделий '); readln(n);
write('Введите вероятность изделия быть бракованным '); readln(p);
writeln('Введите число бракованных изделий, вероятность ');
write('появления которых Вы находите '); readln(m);
a := n*p;
writeln('Вероятность ', m, ' бракованных изделий в ');
writeln('партии из ',n, ' изделий равна ', PS(m, a):1:6)
end.
Пример 2. Вероятность сбить самолет одним выстрелом из винтовки в определенных условиях равна 0.003. Определить вероятность поражения самолета, если сделано по одному выстрелу из 300 винтовок.
{ Распределение Пуассона }
Program Problem2;
uses WinCrt;
var
n : longint;
p, a : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления вероятности распределения Пуассона }
Function PS(m : integer; a : real) : real;
var
i : integer;
pp : real;
begin
pp := exp(-a);
if m = 0 then pp := exp(-a)
else for i := 1 to m do pp := pp*a/i;
PS := pp
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите общее число выстрелов '); readln(n);
write('Введите вероятность попадания при одном выстр. ');
readln(p);
a := n*p;
write('Вероятность поражения самолета при ');
writeln(n, ' выстрелах равна ', (1 - PS(0, a)):1:6)
end.
Пример 3.
Прибор состоит из 200 деталей, каждая из которых за время t может выйти из строя с вероятностью p = 0.01.
Найти вероятность того, что за время t выйдут из строя: а) 3 детали; б) не более трех деталей; в) не менее двух деталей; г) от двух до четырех деталей включительно.
{ Распределение Пуассона }
Program Problem3;
uses WinCrt;
var
n, m, i : longint;
p, a, Sum : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления вероятности распределения Пуассона }
Function PS(m : integer; a : real) : real;
var
i : integer;
pp : real;
begin
pp := exp(-a);
if m = 0 then pp := exp(-a)
else for i := 1 to m do pp := pp*a/i;
PS := pp
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите общее число деталей '); readln(n);
write('Введите вероятность выхода изделия из строя '); readln(p);
writeln('Введите число изделий, вероятность выхода из');
write('строя которых Вы находите '); readln(m); writeln;
a := n*p;
Sum := 0;
for i := 0 to 3 do Sum := Sum + PS(i, a);
writeln('Вероятность того, что за указанное время ');
write('выйдет из строя ',m, ' изделия равна ');
writeln(PS(m, a):1:6);
writeln('не более ',m, ' изделий ', Sum:1:6);
Sum := 0;
for i := 0 to 1 do Sum := Sum + PS(i, a);
Sum := 1 - Sum;
writeln('выйдет из строя не менее 2 деталей ', Sum:1:6);
Sum := 0;
for i := 2 to 4 do Sum := Sum + PS(i, a);
writeln('выйдет из строя от 2 до 4 деталей ', Sum:1:6)
end.
Пример 4. При контролируемом производственном процессе доля брака равна 0.02. При обнаружении в партии из 150 изделий более 5 бракованных изделий вся партия задерживается. Определить вероятность того, что партия будет принята.
{ Распределение Пуассона }
Program Problem4;
uses WinCrt;
var
n, m, i : longint;
p, a, PP : real;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления вероятности распределения Пуассона }
Function PS(m : integer; a : real) : real;
var
i : integer;
pp : real;
begin
pp := exp(-a);
if m = 0 then pp := exp(-a)
else for i := 1 to m do pp := pp*a/i;
PS := pp
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите общее число изделий '); readln(n);
write('Введите вероятность изделия быть бракованным ');
readln(p);
writeln('Введите число бракованных изделий, вероятность ');
write('появления которых Вы находите '); readln(m);
a := n*p;
PP := 0;
for i := 0 to m do PP := PP + PS(i, a);
writeln('Вероятность ', m, ' бракованных изделий в ');
writeln('партии из ',n, ' изделий равна ', PP:1:6)
end.
Равномерное распределение в интервале (a, b)
Говорят, что случайная величина X распределена равномерно в конечном интервале (a, b), если все ее возможные значения сосредоточены на этом интервале и если плотность распределения ее вероятностей на этом интервале и если плотность распределения ее вероятностей на этом интервале постоянна. Если эту постоянную обозначить буквой C, то плотность равномерного распределения задается формулой
(1)Для случайной величины X, равномерно распределенной в интервале
, вероятность попадания в любой интервал (x1, x2), лежащий внутри интервала , пропорциональна длине этого интервала.
(2) Параметр C определяется из условия нормирования:
откуда
Подставляя полученное значение C в формулу (2), мы находим, что вероятность попадания значения величины X в интервал (x1, x2) равна отношению длины этого интервала к длине всего интервала
: 
(3)Заметим, что обычно употребляемое выражение "выберем точку X наудачу в интервале
" означает, что рассматриваемая точка X представляет собой случайную величину с равномерным распределением вероятностей в интервале . Точно так же, если говорят, что выбирается наудачу направление на плоскости, то имеют в виду, что выбираемый угол есть случайная величина с равномерным распределением вероятностей в интервале 
. Различия между циклом - while и циклом - repeat
1. Оператор, находящийся в цикле while, повторяется до тех пор, пока условие удовлетворено (т.е. истинно). Последовательность операторов, находящихся в цикле repeat, повторяется до тех пор, пока условие не удовлетворено (т. е. ложно).Следовательно, в цикле while используется условие продолжения цикла, а в цикле repeat
- условие окончания цикла.
2. В цикле while
повторяется один оператор (несколько операторов надо объединять в составной оператор с помощью операторных скобок begin ... end), а в цикле repeat
можно повторять несколько операторов без операторных скобок.
3. В цикле while
сначала проверяется условие, а после этого в зависимости от значения условия выполняется
или не выполняется оператор или группа операторов после слова do.
В цикле repeat
последовательность операторов выполняется один раз, а после этого проверяется условие, т. е. эта последовательность всегда выполняется хотя бы один
раз, а в цикле while операторы, составляющие тело цикла могут вообще не выполняться ни одного раза.
Размещения
Прежде вспомним некоторые основные понятия из математики, в частности из теории множеств.Во-первых, что такое множество вообще? Понятие множества является основополагающим в математике и неопределяемым.
Под множеством понимается некоторая совокупность объектов, объединенных по какому-то общему признаку.
Так, можно говорить о множестве стульев и столов в классе, множестве натуральных чисел, целых, рациональных и действительных (вещественных) чисел.
Объекты, входящие в множество, мы будем называть элементами.
Число 5 является элементом множества натуральных чисел. Стол является элементом множества столов в классе. Обычно множества обозначаются большими латинскими буквами
A, B, C, D, ..., X, Y, Z, а их элементы - малыми буквами a, b, c, d, ..., x, y, z.
О том факте, что a является элементом множества A говорят, что a принадлежит
множеству A.
Обычно элементы множества записываются в фигурных скобках
Пусть нам даны множества A, с уже указанными его элементами, и множество B = {a1, a2, a3, a4}.
Как вы заметили, каждый элемент множества B является и элементом множества A. В этом случае говорят, что B является подмножеством множества A.
Определение. Если каждый элемент множества B является в то же время элементом и множества A, то говорят, что B есть подмножество (часть) A.
Очень часто нам будет важно знать не только элементы множества, но и порядок их расположения в множестве.
Если учитывается порядок расположения элементов в множестве, тогда множества, имеющие одинаковые элементы, но имеющие их разное расположение, будут для нас различными.
Например: Z = {z1, z2, z3, z4 } и B = {z2, z1, z3, z4} будут считаться разными, так как у них различен порядок расположения элементов.
Множество, в котором задан порядок следования элементов, называются упорядоченным.
Рассмотрим некоторые простые примеры.
Пример 1. В классе 12 учебных предметов. В день проводится 5 разных уроков. Сколькими способами может быть составлено расписание занятий.
Для простоты рассуждений обозначим учебные предметы числами от 1 до 12:
1, 2, 3, 4, 5, ..., 10, 11, 12.
По условию задачи, нам необходимо из этих 12 чисел выбирать по 5 чисел. Причем эти наборы из пяти чисел могут отличаться не только числами, но и расположением чисел, например, один из наборов будет: {1, 2, 3, 4, 5}; набор, который получается при перестановке этих же чисел {2, 1, 3, 4, 5}, также будет удовлетворять условию задачи.
В самом деле, пусть первый набор будет состоять из следующих предметов: {алгебра, физика, химия, история, литература}; тогда набор, полученный при перестановке хотя бы двух предметов уже даст новое расписание: {физика, алгебра, химия, история, литература}.
Таким образом, наборы из 5 чисел могут отличаться не только самими числами, но и порядком их расположения.
Такие подмножества называются в комбинаторике размещениями.
Определение. Размещением из n
элементов по k называется всякое упорядоченное подмножество данного множества, содержащее k элементов.
О размещениях можно сказать несколько иначе, правда менее строго с математической точки зрения, но более понятно для нас.
Размещением из n
элементов по k называется всякое подмножество данного множества, состоящее из k элементов, которое может отличаться не только элементами, но и порядком их расположения.
Например, из множества M = {1, 2, 3, 4} можно образовать 12 различных размещений, из 4 по 2:
{1, 2} {1, 3} {1, 4} {2, 3} {2, 4} {3, 4}
{2, 1} {3, 1} {4, 1} {3, 2} {4, 2} {4, 3}
Число размещений, взятых из n элементов по k, мы будем обозначать символом
и определять по формуле: = 
.Значит,
= 
= 
= 
= 12. Возвращаемся к примеру 1. В нем, как теперь уже стало ясно, надо найти число размещений
из 12 по 5.
По формуле находим:
= 
= 
Вычислить число размещений можно другим способом:
= =
Итак,
Словами можно сказать, что число размещений из n элементов по k равно произведению k элементов
Например,
Таким образом, составив процедуру вычисления размещений по этому принципу, мы избегаем недопустимо больших чисел, которые могут образовываться при вычисление факториалов и упрощаем составление программ, а также имеем возможность в дальнейшем применять процедуру размещений в других программах.
Процедура
размещений из n элементов по k элементов.
Procedure placement(n, k : integer; var
r : longint);
var
i : integer;
begin
r := 1;
for i := 1 to k do r := r*(n - k + i)
end;
Программа
Program Problem1;
uses WinCrt;
var
n, k, r : longint;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа размещений из n по k }
Procedure placement(n, k : integer; var
r : longint);
var
i : integer;
begin
r := 1;
for i := 1 to k do r := r*(n - k + i)
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите число всех предметов '); readln(n);
write('Введите число уроков в день '); readln(k);
Placement(n, k, r);
writeln('Число вариантов расписания равно ', r)
end.
Пример 2. Сколько различных четырехзначных чисел можно написать при помощи цифр 0, 1, 2, ..., 9?
Рассуждения могут быть очень простыми. Нам надо выяснить сколькими способами можно выбрать по 4 цифры из 10, причем важен порядок расположения цифр, так как 1234 и 2134 дают разные числа. Значит необходимо определить число размещений из 10 элементов по 4,
.Но из этого количества чисел мы должны исключить те, которые начинаются цифрой 0, например, 0123, 0213 и т.п. Эти числа уже не будут четырехзначными.
Сколько таких чисел? Да столько, сколько трехзначных чисел получится из 9 цифр (без нуля), т. е. равное числу размещений из 9 элементов по 3,
. Окончательное количество четырехзначных чисел, которые можно составить из 10 цифр равно разности:
.Программа
Program Problem2;
uses WinCrt;
var
n, k, a, a1 : longint;
{----------------------------------------------------------------------------------------}
Procedure placement(n, k : integer; var r : longint);
var
i : integer;
begin
r := 1;
for i := 1 to k do r := r*(n - k + i)
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите заданное ко-во цифр '); readln(n);
write('Введите ко-во цифр, из скольких составляется число '); readln(k);
placement(n, k , a);
placement(n - 1, k - 1, a1);
writeln('Число различных 4-х знач. чисел, которые можно');
writeln('написать при помощи цифр 0, 1, 2, .., 9 равно ', a - a1)
end.
Разные задачи
Пример 1. Составить программу определения всех делителей числа n.Когда ставится такая задача, то очень часто учащиеся предлагают такой способ решения.
Надо испробовать все натуральные числа, начиная от 1 до n и, если какое-то из них будет являться делителем числа n, тогда выдавать его на экран. Например, для числа 36, берем для проверки числа 1, 2, 3, ..., 36 и выбираем из них делители 36. Делители будут следующими: 1, 2, 3, 4, 6, 9, 12, 18 и 36.
Такой способ возможен. Но, если вы внимательно посмотрите на делители числа 36, то обнаружите, что все они находятся в интервале от 1 до 18, т.е. до половины числа 36 и лишь последний делитель - это само число.
Да и простая логика рассуждений убеждает нас, что делители будут располагаться именно в этом интервале: от 1 до
. Если допустить мысль, что есть делитель больше половины числа, тогда умножив его только лишь на 2, мы получим число большее заданного.
Итак, становится ясным, что все делители числа, кроме самого, находятся в промежутке от 1 до
, а значит надо проверять числа на возможные делители именно из этого промежутка. Отсюда возникает такой план составления программы: организовать цикл от 1 до
; есличисло n делится на число из этого промежутка, тогда вывести этот делитель на экран; продолжить цикл; выдать на экран само число.
Программа
Program
Problem1; { Простой алгоритм. 1 - способ }
uses WinCrt;
var
n, d : integer;
begin
write('Введите целое число '); readln(n);
d := 1;
writeln('Делители числа ', n);
repeat
if n mod d = 0 then write(d, ' ');
d := d + 1
until d > n div 2;
write(n)
end.
Но и при решении этой задачи машине можно помочь и облегчить ее работу. Здесь на помощь снова приходит математика.
Оказывается, для того чтобы найти делители числа n, достаточно обнаружить делители не превышающие
. Все остальные делители получаются в результате деления числа n на найденные делители.
Например, если n = 30, то достаточно найти делители 1, 2, 3, 5 (натуральный квадратный корень из 30 равен 5), а все прочие делители получаются делением на найденные:
30 div 1 = 30;
30 div 2 = 15;
30 div 3 = 10;
30 div 5 = 6.
При составлении программы возникает проблема - нет встроенной функции извлечения квадратного корня в множестве целых чисел. Это препятствие легко обойти, если организовать цикл для выбора делителей d от 1 до тех пор покаd*d
Почему надо сделать именно так. Это становится понятным на примере для числа 36.
= 6, цикл - пока dd < 6; d = 1, d
d = 11 = 1 < 36 (истина), цикл продолжается;
находится остаток от деления 36 mod 1 = 0; выдается 1 и частное от деления 36 на 1, 36 div 1 =36;
d = 2, d
d = 22 = 4 < 36 (истина),цикл продолжается;
36 mod 2 = 0;
выдается 2 и частное от деления 36 на 2, 36 div 2 = 18;
d = 3, d
d = 33 = 9 < 36 (истина), цикл продолжается;
36 mod 3 = 0;
выдается 3 и частное от деления 36 на 3, 36 div 3 = 12;
d = 4, d
d = 44 = 16 < 36 (истина), цикл продолжается;
36 mod 4 =0;
выдается 4 и 36 div 4 = 9;
d = 5, d
d = 55 = 25 < 36 (истина),цикл продолжается;
36 mod 5 <>0, ничего не выдается на экран,
цикл продолжается;
d = 6, d
d = 66 = 36 < 36 (ложь), цикл заканчивается. Проверяется d = 6 (d
d = n), 66 = 36 (истина), выдается 6. Если бы цикл продолжался, пока d
d <= n, тогда при d = 6 на экран выдавалось бы - 6 и 36 div 6 = 6, т. е. две шестерки, что было бы ошибкой. Программа
Program
Problem1a; { Делители числа. 2 - способ }
uses WinCrt;
var
n, d : integer;
begin
write('Введите целое число '); readln(n);
writeln('Делители числа ', n);
d := 1;
while d*d < n do
begin
if n mod d=0 then write(d, ' ', n div d, ' ');
d := d + 1
end;
if d*d = n then write(d); writeln
end.
Рекурсия
Такой процесс, когда в процедуре происходит обращение к самой себе, называется рекурсией(рекурсия - возврат). (Происходит от латинского recurreus - возвращающийся).
Теперь нам предстоит более подробно поговорить о рекурсиях.
Рекурсия - это такой способ организации подпрограммы, при котором в ходе выполнения она обращается сама к себе.
Приведем примеры, которые уже стали классическими, использования рекурсий в подпрограммах:
Пример 10. Вычисление факториала числа.
Ниже приведена программа вычисления факториала числа, в которой используется рекурсивная процедура fac:
Procedure fac(n : integer; var f : real);
begin
if (n = 0) or (n = 1) then f := 1
else
begin
fac(n - 1, f);
f := f*n
end
end;
Разберемся детально в работе этой процедуры. Для этого снова обратимся к математике.
Для вычисления факториала числа n, т.е. n! надо умножить последовательно n натуральных чисел от 1 до n:
Так, 4! будет равно:
Это прямой путь вычисления или итеративный.
Возможен и другой путь вычисления:
Этот путь можно назвать возвратным или рекурсивным. Именно на этом принципе основана работа приведенной процедуры.
Пусть введено в программу значение 4 для вычисления факториала 4! Как будет работать процедура?
После начала ее работы, будет выполнена проверка:
if (n = 0) or (n = 1) then
f := 1
Понятно, что 4 не равно 0 и не равно 1, значит будет выполняться оператор после else, т. е. fac(n - 1, f), а это означает, что снова будет вызвана также процедура, но значение n уменьшится на единицу и станет равным 3; затем снова будет выполнена проверка условия:
if
(n = 0) or (n = 1) then f := 1 и переход к вызову процедуры fac(n - 1, f).
Значение n
уменьшится на 1 и станет равным 2 и т.
д. до тех пор, пока n не станет равным 1, а значение f получит значение 1 ( надо заметить, что при всех предыдущих операциях значение f оставалось равным 0, а точнее говоря, неопределенным).
После этого, начнется обратный процесс, в котором будет выполняться команда: f := f*n. Он будет происходить так:
f := 1*4; f := 4*3; f := 12*2; f := 24*1.
Образно говоря, при первоначальном процессе, значения n от 4 до 1 "запоминаются" в стековую память "Паскаль-машины", а при следующем процессе, значения n "считываются" из стековой памяти “Паскаль-машины”
и умножаются на значения f.
Условно-схематически это можно изобразить так: значения n запоминаются в стек-память "Паскаль-машины":
|
4 |
|||
|
3 |
4 |
||
|
2 |
3 |
4 |
|
|
1 |
2 |
3 |
4 |
Обязательным элементом в описании всякого рекурсивного процесса является некоторое утверждение, определяющее условие завершения рекурсии; иногда его называют опорным условием рекурсии (или "якорем"). В нашем случае это условие:
if
(n = 0) or (n = 1) then f := 1.
В опорном условии может быть задано какое-то фиксированное значение, заведомо достигаемое в ходе рекурсивного вычисления и позволяющего организовать своевременную остановку процесса; применительно к вычислению факториала им будет равенство 1! = 1. Таким образом, любое рекурсивное определение всегда содержит два элемента: условие завершения и способ выражения одного шага решения посредством другого, более простого шага.
Для четкого понимания происходящих при этом процессов необходимо иметь в виду, что:
а) при каждом вызове процедуры создается новый экземпляр f;
б) все экземпляры f накапливаются во внутреннем стеке “Паскаль-машины” и
в) в любой момент обработке доступен только один, хронологически последний экземпляр переменной f, который
г) по завершению очередного рекурсивного вызова автоматически уничтожается).
Вывод
При каждом входе в рекурсивную подпрограмму ее локальные переменные размещаются в особым образом организованной области памяти, называемой программным стеком.
Программа
Program Problem10;
uses WinCrt;
var
n : integer;
f : real;
{---------------------------------------------------------------------------------------}
Procedure fac(n : integer; var f : real);
begin
if (n=0) or (n=1) then f := 1
else
begin
fac(n - 1, f);
f := f*n
end
end;
{---------------------------------------------------------------------------------------}
begin
write('Введите натуральное значение n '); readln(n);
fac(n, f);
writeln('Факториал числа ', n, ' равен ', f:12:0)
end.
Турбо-Паскаль 7 или 6 дает очень удобную возможность пошаговой трассировки программы и процедуру. Для этого достаточно последовательно нажимать клавишу F7 и вы сможете полностью убедиться в правильности наших соображений.
Рекурсивная форма организации подпрограммы обычно выглядит изящнее итерационной (последовательной) и дает более компактный текст программы, но при выполнении, как правило, медленнее и может вызвать переполнение стека.
Как избавиться от этой неприятности вы узнаете позже. Но стоит знать, что при зацикливании программы следует выйти из нее нажатием
Еще примеры с использованием рекурсивных процедур.
Пример 11. Над цепью озер летела стая белых гусей. На каждом озере садилось половина гусей и еще полгуся, а остальные летели дальше. Все гуси сели на семи озерах. Сколько гусей было в стае?
Решение
Математически задача решается устно очень остроумным способом.
Пусть вместе со стаей белых гусей все время летит еще один, Серый гусь.
Если к некоторому озеру подлетит m белых гусей и Серый, то на этом озере садится
- ровно половина всех гусей вместе с серым. Поэтому после каждого озера число летящих гусей уменьшается ровно вдвое. После семи озер оно уменьшится в 27 = 128 раз, а остается летящим один Серый гусь. Значит, вначале было 128 гусей, из них 127 - белых. А теперь выполним, образно говоря, прямые рассуждения для решения задачи.
Обозначим через xk количество летящих белых гусей, когда впереди еще k озер. Тогда условие задачи записывается так:
Отсюда получаем для последовательности (xk) рекуррентное соотношение
Зная его, легко составить рекурсивную процедуру:
Procedure goose(x, k : integer);
begin
if k = 1 then writeln(x) else
goose(2*x + 1, k - 1)
end;
В процедуру вводятся всего две переменные: x - искомое число гусей; k - число озер. Процедура устроена с расчетом, что гуси уже пролетели все 7 озер, значит надо вводить значение для x - один (1), а для k - семь (7). В процедуре устроено, что число k уменьшается на 1 и тогда опорным условием ("якорем") завершения процедуры является условие равенства 1 значений k и после этого на экран надо выдать значение числа гусей:
if k = 1 then writeln(x)
Опорное условие может быть и другим, если первоначальным значением k будет 1, тогда при повторном обращении к процедуре значение k надо не уменьшать, а увеличивать на 1 (k + 1), опорным условием, в этом случае, будет k = 7.
Ниже приводится законченная программа решения этой задачи:
Program Problem11;
uses WinCrt;
var
k : integer;
{----------------------------------------------------------------------------------------}
Procedure goose(x, k : integer);
begin
if k = 1 then write(x) else
goose(2*x + 1, k - 1)
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите число озер '); readln(k);
write('В стае было ');
goose(1, k);
writeln(' гусей')
end.
Придерживаясь подобных соображений, решите следующую задачу.
Решение уравнений с одной переменной методом половинного деления
Здесь мы очень кратко рассмотрим один из простых методов решения нелинейных уравнений - метод половинного деления, так как другие методы будут рассмотрены позже, после изучения последовательностей, массивов и множеств.Главная цель этого небольшого раздела - показать использование функций, создаваемых пользователем в программах.
Отделение корней
Первый этап численного решения уравнения f(x) = 0 состоит в отделении корней, т.е. в установлении "тесных" промежутков, содержащих только один корень.
При отделении корней на некотором промежутке [a, b], мы потребуем, чтобы функция f(x) была непрерывна на этом промежутке и будем считать, что все интересующие нас корни находятся на промежутке [a, b], в котором f(a)*f(b) < 0.
Будем вычислять значения функции f(x), начиная с точки x = a, двигаясь вправо с некоторым шагом h. Как только обнаружится пара соседних значений f(x), имеющих разные знаки, и функция f(x) монотонна на этом отрезке, тогда значения аргумента x (предыдущее и последующее) можно считать концами отрезка, содержащего корень. Результатом решения этой задачи будет вывод значений концов промежутка.
Очевидно, что надежность рассмотренного подхода к отделению корней зависит как от характера функции f(x), так и от выбранной величины шага h. Действительно, если при достаточно малом значении h на концах текущего отрезка
функция f(x) принимает значение одного знака, естественно ожидать, что уравнение f(x) = 0 корней на этом отрезке не имеет. Однако, это не всегда так: при несоблюдении условия монотонности функции f(x) на отрезке могут оказаться корни уравнения. Не один, а несколько корней могут оказаться на отрезке и при соблюдении условия 
Смотрите рисунки 24 и 25, иллюстрирующие эти случаи. 
Рис. 24
Рис. 25
Предвидя подобные ситуации, следует выбирать при отделении корней достаточно малые значения h.
Давайте посмотрим как будет выглядеть программа отделения корней для функции
на промежутке [-10; 10]. Ясно, что необходимо завести функцию, которая бы при необходимости обращения к ней вычисляла ее значения.
Эту функцию мы устроим уже известным нам способом и назовем fx:
Function fx(x : real) : real;
begin
fx := cos(x) - 0.1*x
end;
В основной программе, естественно потребовать от пользователя ввода границ промежутка и шага. В качестве границ промежутка будут переменные a и b, а для шага - h (в качестве значения шага, при выполнении программы возьмем 0.1).
Для подсчета числа промежутков будет служить счетчик k. Первоначальное значение левой границы: x1:=a; а первая правая граница будет равна сумме левой границы и шага: x2:=x1+h; значение функции в левой границе первого промежутка: y1:=fx(x1).
Последовательно к левой границе добавляется шаг h и так должно продолжаться пока
это значение не станет равно правой границе данного промежутка b. Значит, необходимо организовать цикл "пока": while x2 <= b do
В цикле, вычислять значение функции в точке x2, которая уже получилась от увеличения x1 на h: y2 := fx(x2).
Теперь следует проверить знак произведения значений функций на концах промежутка (fx(x1)*fx(x2)) и, если оно отрицательно, то на этом промежутке будет существовать корень, а значит надо выдать на экран координаты этого промежутка и его номер:
if y1*y2 < 0 then
begin
k := k + 1;
writeln(k,'-й корень на [',x1:6:4,'; ',x2:6:4,']')
end;
Далее следует продолжить движение к правой границе, а для этого выполнить следующие операторы:
x1 := x2; x2 := x1 + h; y1 := y2
Вот и вся несложная тактика этой программы. Полностью она приводится ниже:
Program
Separation_root; { Программа отделения корней }
uses WinCrt;
var
a, b, h, x1, x2, y1, y2 : real;
k : integer;
{----------------------------------------------------------------------------------------}
Function fx(x : real) : real;
begin
fx := cos(x) - 0.1*x
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите левую границу промежутка '); readln(a);
write('Введите правую границу промежутка '); readln(b);
write('Введите шаг '); readln(h);
k := 0;
x1 := a; x2 := x1 + h;
y1 := fx(x1);
while x2 <= b do
begin
y2 := fx(x2);
if y1*y2 < 0
then
begin
k := k+1;
writeln(k, '-й корень на [', x1:6:4, ';', x2:6:4, ']')
end;
x1 := x2; x2 := x1 + h;
y1 := y2
end
end.
Следующим, естественным этапом решения, является нахождение на промежутке корень с заданной степенью точности (если, конечно, уже известно, что он существует на нем).
Для этого нетрудно сочинить простую программу вычисления корня методом половинного деления, сущность которого заключается в следующем.
Известно, что на промежутке [a; b] есть корень. Зададим необходимую точность, с которой нам необходимо его вычислить. Обозначим ее - e.
Разделим промежуток [a; b] пополам. Точкой деления будет точка (см. рис. 25)
Рис. 25
Установим, на котором из полученных двух промежутков находится корень. Для чего найдем знак разности fx(a)*fx(c). Если этот знак отрицательный, тогда корень находится на левом промежутке. Заменив c на b (b:=c), мы получим новый промежуток, обозначенный прежними буквами (см. рис. 26):
Рис. 26
А если разность fx(a)*fx(c) не будет отрицательной, тогда корень находится на правом промежутке. Заменив c на a (a := c), мы получим новый промежуток для поиска корня, обозначенный теми же буквами (см. рис. 27):
Рис. 27
И такой процесс деления надо выполнять, пока разность между правой и левой границами по абсолютной величине будет больше заданной точности e
(
Пользуясь этими соображениями, нетрудно составить программу, где сам процесс половинного деления будет выполняться с помощью процедуры.
В качестве функции берется функция: f(x) := sin(2*x) - ln(x) и рассматривается на промежутке
После завершения основного цикла, находится окончательное значение x,
и вычисляется погрешность d, 
Program Division;
uses WinCrt;
var
a, b, c, e, x, d : real;
{----------------------------------------------------------------------------------------}
Function func(x : real) : real;
begin
func := sin(2*x) - ln(x)
end;
{----------------------------------------------------------------------------------------}
Procedure half(a, b, e : real; var x, d : real);
var
c : real;
begin
while abs(b - a) > e do
begin
c := (a + b)/2;
if func(a)*func(c) < 0 then b := c else a := c
end;
x := (a + b)/2;
d := abs(b - a)/2
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите левую границу промежутка '); readln(a);
write('Введите правую границу промежутка '); readln(b);
write('Введите точность вычисления корня '); readln(e);
half(a, b, e, x, d);
writeln('Значение корня равно x = ', x:6:10);
writeln('С границей погрешности ', d:2:10)
end.
Можно объединить программы отделения корня и уточнения его методом половинного деления в одну и получить программу, которая отделяет промежутки и сразу вычисляет на каждом из них корни с заданной точностью.
Программа
Program Equation;
uses WinCrt;
var
a, b, h, x1, x2, y1, y2, e, x, d : real;
k : integer;
{----------------------------------------------------------------------------------------}
Function fx(x : real) : real;
begin
fx := cos(x) - 0.1*x
end;
{----------------------------------------------------------------------------------------}
Procedure half(a, b, e : real; var x, d : real);
var
c : real;
begin
while abs(b - a) > e do
begin
c := (a + b)/2;
if fx(a)*fx(c) < 0 then b := c else
a := c
end;
x := (a + b)/2;
d := abs(b - a)/2
end;
{----------------------------------------------------------------------------------------}
begin
write(' Введите левую границу промежутка '); readln(a);
write('Введите правую границу промежутка '); readln(b);
write('Введите шаг '); readln(h);
write('Введите точность вычисления корня '); readln(e);
k := 0; x1 := a; x2 := x1 + h;
y1 := fx(x1);
while x2 <= b do
begin
y2 := fx(x2);
if y1*y2 < 0
then
begin
k := k + 1;
half(x1, x2, e, x, d);
write(k,'-й корень равен ', x:6:6);
writeln(' с погрешностью ', d:2:10)
end;
x1 := x2; x2 := x1 + h; y1 := y2
end
end.
Сходимость числовых и функциональных рядов
Пусть дан бесконечный ряд:
Станем последовательно складывать члены ряда, составляя (в бесконечном количестве) суммы;
их называют частными суммами (или отрезками) ряда.
Конечный или бесконечный предел
частичной суммы 
ряда при : 
называется суммой ряда и пишут
Если ряд имеет конечную сумму, его называют сходящимся, в противном случае (т.е. если сумма равна
или 
, либо же суммы вовсе нет - расходящимся. Попробуем установить являются ли некоторые ряды сходящимися?
Пример 3. Является ли ряд
сходящимся? Для установления этого, надо определить имеет ли предел последовательность частичных сумм ряда, а это в свою очередь, означает будет ли разность между суммами по абсолютной величине меньше заданного положительного, даже очень малого числа eps, т.е. будет ли выполняться неравенство:
Отсюда вытекает алгоритм составления программы.
Надо находить сумму членов ряда и как только разность между текущей суммой и следующей будет меньше eps, то цикл закончить, значит ряд сходится и выдать его сумму, которая будет равна текущей сумме с заданной степенью точности.
Установить является ли следующий ряд сходящимся и найти то число с заданной точностью eps, к которому он сходится.
Для вычисления суммы ряда нам придётся находить его члены и прибавлять к текущей сумме, а для нахождения членов ряда воспользуемся подпрограммой - функцией для вычисления факториала числа.
Программа
Program Problem3;
uses WinCrt;
var
n : integer;
z, z1, e, eps : real;
{----------------------------------------------------------------------------------------}
Function fakt(n : longint) : real;
var
i : longint;
f : real;
begin
f := 1;
if n = 0 then f := 1
else for i := 1 to n do
f := f*i;
fakt := f
end;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
write(' Задайте точность eps '); readln(eps);
z := 0; n := 1;
repeat
z := z + sqr(fakt(n))/fakt(2*n);
n := n + 1;
z1 := z + sqr(fakt(n))/fakt(2*n)
until abs(z1 - z) < eps;
write('Сумма ряда равна ', z1:6:t(eps));
writeln(' с точностью до ', eps:3:t(eps))
end.
Задание 3
Установить, является ли ряд
, при a > 1 сходящимся? Сочетания и бином Ньютона
В математике известна формула бинома (двучлена) Ньютона. Она используется для возведения двучлена a + b в n-ю степень. Эта формула имеет вид:
Числа
в этой формуле называются биномиальными коэффициентами. Надо отметить, что биномиальные коэффициенты образует треугольник Паскаля. Этот треугольник имеет вид: 1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Его можно записать иначе и сразу обозначить строки треугольника:
Номера строк. Треугольник Паскаля.
0 1
1 1 1
2 1 2 1
3 1 3 3 1
4 1 4 6 4 1
5 1 5 10 10 5 1
. . . . . . . . . . . . . . . . .
n
Пример 11. Вычислить сумму пяти средних элементов девятой строки треугольника Паскаля.
Всего в девятой строке треугольника Паскаля 10 элементов. Пять средних элементов будут находиться начиная с третьего места и по 7-е место.
Эти элементы будут следующими:
Ясно, что для вычисления их суммы необходимо организовать цикл по "верхним" индексам сочетаний. Каждый цикл надо вызывать процедуру числа сочетаний из 9 элементов по j (j - переменная цикла) и прибавлять к переменной, заведенной для суммы.
Программа
Program Problem11;
uses WinCrt;
var
s, j, s1 : longint;
{----------------------------------------------------------------------------------------}
Procedure Combination(n, k : integer; var c : longint);
var
i : longint;
begin
c := 1;
for i := 1 to k do
c := c*(n - k + i) div i
end;
{----------------------------------------------------------------------------------------}
begin
s := 0;
for j := 2 to 6 do
begin
combination(8, j, s1); s := s + s1
end;
writeln('Сумма пяти средних элементов 9-й строки равна ', s)
end.
Пример 12. Составить программу вывода на экран n заданных строк треугольника Паскаля.
Понятно, что для вывода строк треугольника Паскаля на экран необходимо организовать два цикла for. Один - по числу строк, второй - по числу элементов в каждой строке.
Первый, внешний цикл, для числа строк должен быть организован от 0 до n, пусть с переменной j1.
Второй, внутренний цикл, надо организовать от 0 до j1. Это легко объясняется тем, что в каждой строке должно быть на 1 больше элементов, чем номер ее строки. В нулевой строке 1 элемент, в 1-й 2 элемента, во 2-й три элемента и т. д., в n-й строке будет n + 1 элементов. Такое вызвано тем, что элементы начинают нумероваться с нуля.
Программа
Program
Problem12;
uses WinCrt;
var
j, j1, n, p : longint;
{----------------------------------------------------------------------------------------}
Procedure Combination(n, k : integer; var c : longint);
var
i : longint;
begin
c := 1;
for i := 1 to k do
c := c*(n - k + i) div i
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите число строк треугольника Паскаля ');
readln(n);
writeln('Треугольник Паскаля ');
for j1 := 0 to n do
begin
for j := 0 to j1 do
begin
combination(j1, j, p);
write(p, ' ')
end;
writeln
end
end.
Сочетания
Пусть M - конечное (не обязательно упорядоченное) множество, состоящее из n элементов.Определение. Сочетанием из n элементов по k называется любое подмножество множества
, состоящее из k элементов. Два сочетания из n элементов по k мы будем считать различными в том случае, если в одном из них есть, хотя бы один элемент, не содержащийся в другом. Другими словами, в сочетаниях не важен порядок элементов, а важен лишь их состав. Так, например, из множества M = {1, 2, 3, 4} можно составить четыре различных сочетания из 4 по 3: {1, 2, 3}, {1,2,4}, {2, 3, 4}, {1, 3, 4}.
Число различных сочетаний из n элементов по k равно:
Если k = 0, тогда 
Учитывая, что число размещений из n элементов по k равно, но
,можно выразить число сочетаний через число размещений, тогда получим:
.Пример 9. Дано 10 точек, из которых никакие три не лежат на одной прямой и никакие четыре точки не лежат в одной плоскости. Сколько различных плоскостей можно провести через эти точки?
Из геометрии нам известна аксиома, что через три точки, не лежащие на одной прямой можно провести плоскость и притом только одну.
Поскольку это так, тогда, если плоскость проходит через три точки A, B, C, то через точки B, A, C или C, B, A и т.п., проходит та же плоскость, т. е.
порядок расположения трех точек, через которые проходит плоскость не имеет значения. А значит число различных плоскостей, проведенных через каждые три точки из 10 равно числу сочетаний из 10 элементов по 3.
Составим процедуру вычисления числа сочетаний из n элементов по k.
Для этого удобней воспользоваться второй формулой, в которой вычисляется только один факториал числа k. В формуле
их надо вычислять целых три (n!, (n - k)! и k!) и может возникнуть ситуация, когда будут получаться очень большие числа, которые могут выходить за пределы указанного целого типа. Можно найти и другую формулу для числа сочетаний, в которой можно избежать больших чисел и вычисления факториалов чисел.
Итак, пользуемся формулой:
В процедуре, в качестве входных формальных переменных будут две переменные n и k, для числа всех элементов и числа выбираемых элементов.
Выходной параметр для значения сочетания обозначим c, имя процедуры - Сombination.
Получим: Procedure Combination(n, k : integer; var с : longint);
Входные параметры имеют тип integer, а выходной - longint, так как значение числа сочетаний может быть даже очень большим числом.
Переменные самой процедуры - i, - переменная для цикла for и p - промежуточная переменная для факториала k!.
В процедуре устанавливаются первоначальные значения для числа сочетаний (c := 1).
Организуется цикл for от 1 до k, в котором в переменную с будет накапливаться произведение, которое и является числом сочетаний из n элементов по k:
, (1) где 
- знак произведения от 1 до k.Давайте проверим, будет ли эта формула выдавать нам число сочетаний из n элементов по k. Пусть n = 5, k = 3, тогда по формуле для числа сочетаний будем иметь:
а по формуле (1), получаем:
Таким образом, этой формулой можно пользоваться при подсчете числа сочетаний в программе.
Окончательно процедура вычисления числа сочетаний будет следующей:
Procedure combination(n, k : integer; var
с : longint);
var
i : longint;
begin
с := 1;
for i := 1 to k do с := с*(n - k + i) div i
end;
Для составления программы решения данной задачи, надо в основной программе обратиться к процедуре combination, причем фактические значения переменных будут 10, - общее число точек и 3 - число точек через которые проходит одна плоскость.
Программа
Program Problem9;
uses WinCrt;
var
pl : longint;
{----------------------------------------------------------------------------------------}
Procedure combination(n, k : integer; var c : longint);
var
i : longint;
begin
c := 1;
for i := 1 to n - k do c := c*(n - k + i) div i
end;
{----------------------------------------------------------------------------------------}
begin
combination(10, 3, pl);
writeln('Число плоскостей равно: ', pl)
end.
Пример 10. Сколько различных вариантов хоккейной команды можно составить из 9 нападающих, 5 защитников и 3 вратарей, если в состав команды должны войти 3 нападающих, 2 защитника и 1 вратарь?
Соображения по составлению программы
Из 9 нападающих можно выбрать троих числом способов:
Из 5 защитников можно выбрать двоих способами. Из 3 вратарей можно выбрать одного 
способами. Общее число возможных способов равно произведению числа способов выбора нападающих, защитников и вратарей: 
. Программа
Program Problem10;
uses WinCrt;
var
h1, h2, h3 : longint;
{----------------------------------------------------------------------------------------}
Procedure Combination(n, k : integer; var c : longint);
var
i : longint;
begin
c := 1;
for i := 1 to k do c := c*(n - k + i) div i
end;
{----------------------------------------------------------------------------------------}
begin
combination(9, 3, h1);
combination(5, 2, h2);
combination(3, 1, h3);
write('Хоккейную команду можно составить ', h1*h2*h3);
writeln(' способами');
end.
Свойства математического ожидания как операции осреднения
Эти свойства справедливы для математических ожиданий случайных величин вообще и дискретных случайных величин, в частности.1. Математическое ожидание постоянной равно этой постоянной:
MC = С.
2. Постоянный множитель C можно выносить за знак математического ожидания:
MCX = CMX.
3. Математическое ожидание суммы двух случайных величин равно сумме их математических ожиданий:
M(X + Y) = MX + MY.
Это свойство выражает линейность математического ожидания.
Математическое ожидание линейной комбинации случайных величин равно линейной комбинации их математических ожиданий.
Умножение математических ожиданий
Математическое ожидание произведения независимых случайных величин равно произведению их математических ожиданий.
и предпоследней цифр записи этого
1. Дано целое число n
10. Написать программу получения последней и предпоследней цифр записи этого числа. 2. Даны три числа a, b, c. Написать программу, в результате которой числа удвоятся, если
и числа будут заменены на их абсолютные величины в прочих случаях. 3. Составьте программы определения большего (меньшего) из трех чисел.
4. Написать программу, при выполнении которой выводится 1, если данное число x принадлежит отрезку [a, b], где a и b заданные числа, и выводится 0 в противоположной ситуации.
5. Точка плоскости задана своими координатами x, y. Написать программу, при выполнении которой определяется, принадлежит ли данная точка плоской фигуре, являющейся кольцом с центром в точке (0, 0), с внутренним радиусом 3 и с наружным радиусом 4.
6. Даны положительные числа x, y, z. Выяснить, существует ли треугольник с длинами сторон x, y, z?
7. Определить является ли данное целое число четным.
8. Определить, верно ли, что при делении целого неотрицательного числа a на целое положительное число b получается остаток r или s.
9. Составить программу решения биквадратного уравнения
10. Найти все трехзначные числа, при делении каждого из которых на 11 получается частное, равное сумме квадратов значений отдельных цифр данного числа.
11. Трехзначное десятичное число оканчивается цифрой 3. Если эту цифру переместить через два знака влево, т. е. с этой цифры будет начинаться запись нового числа, то это новое число будет на единицу больше утроенного исходного числа. Найдите это число.
12. Найдите все трехзначные числа, которые равны сумме кубов своих цифр.
13. Шестизначное десятичное число начинается слева цифрой 1. Если эту цифру перенести с первого места слева на последнее место справа, то значение образованного числа будет втрое больше исходного. Найдите исходное число.
14. Дано целое число
Написать программу получения m последних цифр десятичной записи числа n. 15. Найти четырехзначное число, равное квадрату числа, выраженного двумя последними цифрами этого четырехзначного числа.
16. Натуральное число называется совершенным, если оно равно сумме всех своих делителей, за исключением самого себя.
Число 6 является совершенным, так как 6 = 1 + 2 + 3, число 8 не является совершенным, так как 8 не равно 1 + 2 + 4. Написать программу вывода всех совершенных чисел, меньших заданного числа n.
17. Найти четырехзначные числа, каждое из которых делится на 11 и сумма цифр каждого равна 11.
18. Найти четырехзначные числа, которые, будучи приписаны справа к числу 400, дают полный квадрат.
19. Найти наименьшее целое число, делящееся на 7, которое при делении на 2, 3, 4, 5, 6 дает в остатке 1.
20. Какие числа, заключенные между числами 2320 и 2350 простые, а какие составные?
21. Составьте программу для нахождения наименьшего нечетного неравного 1 натурального делителя любого заданного натурального числа, большего 1.
22. Найти двузначное число, которое на 6 меньше квадрата суммы своих цифр.
23. Дана сократимая дробь, ее числитель и знаменатель - натуральные числа m и n. Найти такие натуральные числа m1 и n1, не имеющие общих делителей, что
, т. е. сократить дробь 
24. Напишите программу, которая для каждого из целых чисел от 1 до n напечатает все его делители. Например, для числа 35 - делители: 1, 5, 7, 35. Аналогичный список делителей должен быть выдан для каждого из чисел от 1 до заданного числа n.
25. Найти наименьшее натуральное число n, обладающее следующими свойствами: а) его запись в десятичной системе счисления оканчивается цифрой 6;
б) если переставить цифру 6 из конца числа в его начало, то полученное число будет в 4 раза больше данного.
26. Написать программу вывода всех натуральных чисел, меньших n, квадрат суммы цифр которых равен m.
27. Можно ли данное целое p представить в виде суммы двух квадратов целых чисел? Написать программу решения этой задачи.
28. Найти все четырехзначные числа
, удовлетворяющие условию: = (
+ 
).29. Найти числа, оканчивающиеся на цифру a (a = 2, 3, 4, 5, 6, 7, 8, 9) и обладающее тем свойством, что если последнюю цифру переставить в начало числа, то число увеличится во столько раз, сколько единиц в переставляемом числе.
30. Найти целые числа n, делящиеся на все простые числа, не большие
. 31. Составьте программу для проверки, можно ли заданное натуральное число представить в виде:
а) произведения двух простых чисел; б) произведения трех простых чисел;
в) квадрата какого-либо простого числа; г) куба какого-либо простого числа. Следует напечатать ответ ДА или НЕТ.
32. Разрезание прямоугольника на квадраты.
61. Найти наибольший общий делитель всех чисел из заданного промежутка
62. Сократить дробь. Даны натуральные числа a и b. Сократить дробь
63. Найдите пять троек натуральных чисел (x; y; z), удовлетворяющих условию
64. Б. Кордемский указывает одно интересное число 145, которое равно сумме факториалов своих цифр: 145 = 1! + 4! + 5!. Он пишет, что неизвестно, есть ли еще такие числа, удовлетворяющие названному условию. Выясните, существуют ли еще такие числа?
65. Найти трехзначное число, являющееся точным квадратом числа a, и такое, чтобы произведение его цифр было равно a - 1.
66. Найти все натуральные решения уравнения в интервале [1; 20]
67. Найдите какие-нибудь три последовательных натуральных числа, каждое из которых делится на квадрат целого числа, большего единицы.
68. Нетрудно указать тройку квадратов целых чисел, образующих арифметическую прогрессию: 1, 25, 49. Найдите еще три такие тройки (из квадратов чисел, не имеющих общего делителя, т. е. взаимно простых).
69. Найти три таких простых числа, чтобы их сумма была в 5 раз меньше их произведения.
70. Попробуйте найти решения задачи Ферма
на некотором промежутке [a, b] для показателей из промежутка [1, 30]. 71. Попытайтесь найти пять идущих подряд целых чисел, таких, чтобы сумма квадратов двух наибольших из них равнялась сумме квадратов трех остальных?
72. Некоторое четное число является суммой двух точных квадратов. Докажите, что его половина является суммой двух точных квадратов.
73.
Каждое из чисел 9, 25, 49, 81 при делении на 8 дает остаток 1. Что это: случайность или же этому закону подчинены квадраты всех нечетных чисел? 74. Пусть у целых чисел A и B последние k цифр одинаковы. Докажите, что у чисел
и 
(n - любое натуральное) также k последних цифр одинаковы (ограничиться случаями n = 2, 3, 4).75. Покажите, что любое натуральное число и его пятая степень оканчиваются одной и той же цифрой.
76. Некоторое четное число является суммой двух точных квадратов. Докажите, что его половина является суммой двух точных квадратов.
77. Покажите, что квадрат числа, являющегося суммой двух точных квадратов, также можно представить в виде суммы двух точных квадратов.
78. Покажите, что произведение двух целых чисел, из которых каждое есть сумма квадратов двух целых чисел, можно представить в виде суммы двух точных квадратов.
79. Покажите, что n7- n делится на 42 (n - натуральное число).
80. Рассмотрим числа вида 22 + 1 (их называют иногда "числами Ферма"); при n = 2, 3, 4 мы получим числа 17, 257, 65537. Эти числа оканчиваются на 7. Докажите, что при любом натуральном n, больше 1, числа этого вида оканчиваются семеркой.
81. Сложили каких-то 3 целых числа, и их сумма разделилась на 6. Докажите, что сумма кубов тех же чисел также разделится на 6.
82. Покажите, что сумма квадратов двух нечетных чисел не может быть точным квадратом.
83. Число 365 нечетное. В то же время 365 можно представить в виде разности двух точных квадратов: 365 = 392 - 342 и 365 = 1832
- 1822. Докажите, что любое нечетное число можно представить в виде разности точных квадратов.
84. Целое число x заключено между 0 и 60 (0 < x < 60). При делении числа x на 3, 4, 5 получили соответственно остатки a, b, c. Докажите, что x равен остатку от деления числа 40a + 45b + 36c на 60. (На этом основан фокус - угадывания задуманного числа по остаткам от деления этого числа на 3, 4, 5.)
85. Число 148 делится на 37. Переставим в нем первую цифру с начала в конец: получится 481. Оно тоже делится на 37. Снова первую цифру (4) на последнее место. Опять получим число, которое делится на 37. Верно ли аналогичное свойство для каждого трехзначного числа, делящегося на 37?
86. Если дана последовательность 15 чисел a1, a2, a3, ..., a15, то можно построить новую последовательность чисел b1, b2, b3, ..., b15, где bi равно количеству чисел первой последовательности, меньших ai, i = 1, 2, ..., 15.
96. Сколько можно составить трехзначных чисел из нечетных цифр, если каждую из этих цифр использовать только один раз?
97. Сколько трехзначных чисел можно составить из всех цифр так, чтобы цифры в числах не повторялись?
98. Собрание, на котором присутствует 20 человек, избирает в президиум двух человек, один из которых должен быть председателем, а другой - секретарем. Каким числом способов это можно сделать?
99. Сколько различных слов, каждое из которых содержит 4 буквы, можно составить из букв слова выборка?
100. Сколько различных четырехзначных чисел можно написать при помощи цифр 0, 1, 2, ..., 9?
101. Сколько различных правильных дробей можно составить из чисел 3, 5, 7, 11, 13, 17, 19, 23?
102. Определить число всех диагоналей 5-, 8 -, 12 - и 15 - угольников?
103. Из двух спортивных обществ, насчитывающих по 100 фехтовальщиков каждое, надо выделить по одному фехтовальщику для участия в состязаниях. Сколькими способами можно это сделать?
104. У одного человека есть 7 книг по информатике, а у другого - 9 книг. Сколькими способами они могут обменяться друг с другом по две книги?
105. Для премий на олимпиаде по информатике выделено 3 экземпляра одной книги, два экземпляра другой и один экземпляр третьей книги. Сколькими способами могут быть вручены премии, если в олимпиаде участвовало 20 человек и никому не дают двух книг сразу? Та же задача, если никому не дают двух экземпляров одной и той же книги, но могут быть вручены две или три различные книги.
106. Во скольких точках пересекаются 8 прямых линий, если две из них параллельны между собой и через каждую точку пересечения проходит не более двух прямых?
107. Вычислить сумму четырех крайних членов одиннадцатой строки треугольника Паскаля.
108. Сколько хорд можно провести через 4 точки, лежащие на одной окружности?
109. На отрезке AB дано пять точек: C, D, E, F, K. Сколько различных отрезков, включая отрезок AB, получилось при этом?
110. Сколькими способами группу учащихся из восьми человек можно разбить на две подгруппы, состоящие из трех и пяти учеников.
111. Имеется 6 пар перчаток различных размеров. Сколькими способами можно выбрать из них одну перчатку на левую руку и одну перчатку на правую руку так, чтобы эти перчатки были различных размеров?
112
Сколькими способами можно составить флаг, состоящий из трех горизонтальных полос различных цветов, если имеется материал пяти различных цветов?
113. Сколькими способами можно расставить белые фигуры (2 коня, 2 слона, 2 ладьи, ферзя и короля) на первой линии шахматной доски?
114. Найти число точек пересечения диагоналей, лежащих внутри выпуклого n-угольника, если никакие три из них не пересекаются в одной точке.
115. Известно, что при каждом взвешивании равновозможна как положительная, так и отрицательная ошибка. Какова вероятность того, что при пяти взвешиваниях получатся три положительные ошибки?
116. Из урны, содержащей белый и черный шары, извлекают шар, записывают его цвет и возвращают в урну. После n извлечений получаем кортеж длины n из букв Б и Ч. Какова вероятность, что он содержит k букв Б?
117. Для данного участника игры вероятность наброса кольца на колышек равна 0,3. Какова вероятность того, что при шести бросках кольца три кольца окажутся на колышке, если броски кольца считать независимыми?
118. Вероятность отказа каждого прибора при испытании равна 0,4. Что вероятнее ожидать: отказ двух приборов при четырех независимых испытаниях или трех приборов при шести испытаниях?
119. Партия изделий содержит 5% брака. Какова вероятность того, что среди взятых на испытание четырех изделий одно окажется бракованным?
120. Автоматическая штамповка металлических клемм для соединительных пластин дает 20% отклонений от принятого стандарта. Определить вероятность наличия в партии из 600 клемм от 100 до 125 клемм, не соответствующих стандарту.
121. Нужно исследовать 400 проб руды. Вероятность промышленного содержания металла в каждой пробе одинакова и равна 0.8. Определить вероятность того, что число проб с промышленным содержанием металла будет заключено между 290 и 350.
122. В каких границах находится частость наступления события при 1200 независимых испытаниях, вероятность отклонения которой от числа 2/3 равна 0.9857? Каковы границы частоты наступления события в этой задаче?
123. При массовом выпуске некоторой продукции бывает в среднем 4% брака. Определить вероятность того, что в партии из 625 единиц продукции отклонение частости от указанного процента брака будет менее, чем 0.02.
124. Средний процент нарушений работы кинескопа телевизора в течение гарантийного срока равен 12%. Вычислить вероятность того, что из 200 телевизоров более 160 выдержат гарантийный срок.
125. Посажено 600 семян кукурузы с вероятностью прорастания 0.9 для каждого семени. Найти границу абсолютной величины отклонения частости взошедших семян от вероятности p = 0.9, если эта граница должна быть гарантирована с вероятностью P = 0.995.
126. было посажено 400 деревьев. Найти вероятность того, что число принявшихся деревьев больше 250, если вероятность, что отдельное дерево приживется, равна 0.8.
127. В некоторой местности имеется 3 % больных малярией. Производится обследование 500 человек. С какой вероятностью среди обследованных окажется
больных малярией? Вероятность некоторого события равна 0.4 в каждом из n испытаний. Найти вероятность того, что:
а) Частость наступления события при n = 1500 отклонится от p = 0.4 в ту или другую сторону меньше, чем на 0.02.
б) Число появления события будет заключено между 1) 570 и 630; 2) 600 и 660; 3) 620 и 680; 4) 580 и 640.
в) В каких граница находится та частость события при n = 1200, вероятность отклонения которой от p = 2/3 равна 0.985? В каких границах заключено число появления событий в этой задаче?
г) Сколько необходимо произвести испытаний, чтобы вероятность того, что отклонение частости m/n от вероятности p = 3/8 в ту или другую сторону будет меньше, чем на 0.01, была равна 0.995?
128. Значение измеряемого теодолитом угла X имеет нормальное распределение со средним квадратическим отклонением, равным 8''. Найти вероятность того, что ошибка измерения угла не превзойдет по абсолютной величине 10''.
129. Станок автомат изготавливает валики. Контролируется их диаметр X. Считается, что X - нормально распределенная случайная величина со средним значением a = 10 мм. Какова средняя квадратическая ошибка, если с вероятностью 0.990 диаметр заключен в интервале (9.7; 10.3)?
130. В каких границах следует ожидать величину диаметра валика в предыдущей задаче с вероятностью 0.9973?
131. Случайная величина распределена по нормальному закону, Известно, что математическое ожидание ее равно 10 и среднее квадратическое отклонение равно 5. Определить вероятность того, что случайная величина примет значения, принадлежащие интервалу (7; 12).
132. Случайная величина распределена по нормальному закону. Ее математическое ожидание равно 10 и среднее квадратическое отклонение составляет 5. Определить вероятность того, что отклонение значений случайной величины от математического ожидания не превзойдет по абсолютной величине
=2.133. Известно, что вес некоторых плодов, выращиваемых в совхозе, подчиняется нормальному закону с математическим ожиданием 175 г. и
= 25. Определить вероятность того, что вес наудачу взятого плода будет: а) заключен в пределах от 125 до 250 г; б) не менее 250 г; в) не более 300 г.134. Длина детали - случайная величина, распределенная по нормальному закону, со средним значением 20 см и дисперсией, равной 0.2 см2 . Определить вероятность того, что длина наудачу взятой детали будет заключена в пределах от 19.7 до 20.3 см.
135. При измерении расстояний до удаленных предметов ошибка подчинена нормальному закону со средним значением, равным 20 м и средним квадратическим отклонением 40 м. Определить вероятность того, что измеренное расстояние отклоняется от действительного в ту или иную сторону не более чем на 30 м.
136. Изготовленные цехом детали по размерам диаметра распределяются по нормальному закону с математическим ожиданием 4.9 см и средним квадратическим отклонением 0.5 см.
Условия в программах с циклами
Рассмотрим два примера, в программах которых используются не только циклы, но и в циклах необходимо применение условного оператораif ... then ... else ...
Пример 3. Составить программу разложения натурального числа n на простые множители.
Прежде вспомним, что к простым числам относятся все те натуральные числа, которые имеют только два делителя - единицу и само себя.
Натуральные числа, имеющие более двух делителей называются составными.
Единица имеет только один делитель - само себя и поэтому она не может относится ни к простым, ни к составным числам. Если выписать простые числа в порядке их возрастания, начиная от самого меньшего - 2, то получим следующий ряд чисел:
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ...
А теперь вспомним, как в младших классах мы раскладывали натуральные числа на простые множители.
Для этого берем первое простое число - 2 и пробуем делить данное натуральное число на 2, если число делится на 2, тогда надо 2 записать, а число разделить на 2 и снова полученный результат пробуем делить на два, если делится, тогда повторяем процесс деления, если не делится, тогда пробовать делить на следующее простое число - 3 и так далее.
Обычно такой процесс мы записывали "столбиком":
Например: или
Таким образом, число 360 можно разложить на следующие простые множители: 360 = 2
22335. Самый простой алгоритм для составления программы может быть таким.
Алгоритм
В качестве первого делителя взять 2, присвоить это значение некоторой переменной i;
начать цикл "пока i <= n";
если
данное число n делится на i, тогда выдать на экран значение i и разделив данное число на i, присвоить новое значение той же переменной n (n := n div i);
далее цикл продолжить, но значение i не увеличивать на 1, а проверить деление нового значения n на прежнее значение i;
если n не делится на i, тогда i увеличить на 1 (i := i + 1) и продолжить цикл, т.е.
выполнить проверку условия цикла (i <= n), а затем снова проверить деление n на уже новое значение i.
Обратите внимание, что при таком алгоритме в качестве делителей уже не попадут составные числа. Объясните почему?
Программа
Program
Problem3; { Разлож. числа на прост. множит.. 1- й спос. }
uses WinCrt;
var
n, i : integer;
begin
write('Введите натуральное число '); readln(n);
write('Простые делители числа ', n, ' следующие; ');
i := 2;
while i <= n do
if n mod i =0 then
begin
write(i, ' ');
n := n div i
end
else i := i + 1
end.
Конечно, эта программа далека от совершенства и не может иметь претензии на оригинальность.
Она заставляет компьютер выполнять много лишних проверок на деление.
Вот более совершенный алгоритм.
Он основывается на следующих соображениях.
Вначале находим все делители, равные 2. Для этого последовательно делим число 360 на 2:
После этого, полученный результат делим на нечетные числа. Причем на каждое нечетное число делим не один раз, а до тех пор, пока такое деление будет возможным.
Делим на 3: 45:3 = 15, 15:3 = 5.
Делим на 5: 5:5 = 1.
Делим на 7, не делится, пробуем делить на следующее нечетное число.
Делим на 9, не делится, переходим к следующему нечетному числу.
Делим на 11, не делится, и так далее.
До тех пор будем пробовать деление на нечетные числа, пока они будут меньше или равны получаемому частному от деления числа на соответствующий делитель.
На основании этих соображений составляем программу.
Program Problem3a;
uses WinCrt;
var
i, n : integer;
begin
write('Введите целое число '); readln(n); writeln;
writeln('Простые делители целого числа ', n);
{----------------------------------------------------------------------------------------}
while n mod 2 = 0 do { Цикл для вывода делителей, равных 2 }
begin
write(2, ' ');
n := n div 2
end;
{----------------------------------------------------------------------------------------}
i := 3;
while i <= n do { Цикл для нечетных делителей }
if n mod
i = 0
then
begin
write(i, ' ');
n := n div i
end
else i := i + 2;
writeln
end.
Можно расширить область вводимых чисел, используя уже известный тип
longint:
Еще один пример, где используются цикл и условие.
Пример 4. Написать программу, в результате выполнения которой выяснится, входит ли цифра 2 в запись данного целого числа n.
Идея составления программы проста. Надо организовать цикл, в котором выделять цифры числа уже известным вам способом и каждую из них сравнивать с цифрой 2. Если
цифра числа оказывается равной двум, тогда надо счетчик, которым может быть некоторая числовая переменная, увеличивать на единицу, иначе,
цикл надо продолжать.
Когда цикл будет выполнен полностью, т. е. все цифры числа проверены и каждая из них будет сравнена с цифрой 2, надо снова использовать условный оператор и сравнить значение переменной - счетчика с нулем. Если значение переменной равно нулю, то это значит, что цифра 2 не входит в запись числа, иначе
- входит.
АЛГОРИТМ
1. Содержание. Переменные целого типа n, p, k: n - для вводимого числа; p - для цифр этого числа; k - счетчик, подсчитывающий количество цифр в числе, равных 2.
2. Ввод целого числа.
Счетчику k устанавливается первоначальное значение 0.
3. Цикл, пока n <> 0. В цикле, переменной p присваивать значение цифры числа.
Если
p = 2, тогда увеличивать k на единицу.
Вычесть из числа n последнюю цифру и разделить его на 10.
Продолжить и закончить цикл.
4. Если
k = 0, тогда выдать сообщение: "Цифра 2 не входит в запись числа", иначе, выдать сообщение: "Цифра 2 входит в запись числа".
5. Конец.
Программа
Program
Problem4; { Входит ли цифра 2 в запись числа }
uses WinCrt;
var
n, p, k : integer;
begin
write('Введите целое число '); readln(n);
k := 0;
while n <> 0 do
begin
p := n mod 10;
if p = 2 then k := k + 1;
n := n div 10
end;
if
k = 0 then writeln('Цифра 2 не входит в запись этого числа')
else writeln('Цифра 2 входит в запись этого числа')
end.
Если вы внимательно разобрались в работе программы, то могли заметить, что во многих случаях в программе будет проделываться бесполезная работа.
Например, если нами введено число 31572. В программе сделано так, что отделяется по одной цифре справа и так продолжается до первой цифры слева.
Первой цифрой справа является 2. Казалось бы, раз в числе сразу первой цифрой найдена двойка, то можно выдать сообщение, что число содержит цифру 2 и на этом работу закончить. Однако в программе сделано не так. Цикл будет продолжаться до последней цифры числа и большая работа будет проделываться бесполезно.
Возникает необходимость в досрочном прерывании цикла. Как это сделать мы рассмотрим ниже.
Вещественный тип real в операторах if then else
Для дальнейшего составления программ на Паскале нам недостаточно целых чисел. Например, мы хотим составить программу решения квадратного уравнения вида:ax2 + bx + c = 0.
Коэффициенты этого уравнения могут принимать не только целые значения, но любые действительные (a не равно нулю), также значения корней этого уравнения принимают значения из множества действительных чисел.
Действительные или вещественные числа объединяют в себе целые числа и дробные числа (рациональные и иррациональные).
Переменные, принимающие вещественные значения, имеют тип, который на языке Паскаль обозначается: real.
Например: var a, b, c : real;
Это означает, что переменные a, b и c принимают вещественные значения.
Второе определение непрерывной случайной величины
Величина X называется непрерывной случайной величиной, если вероятность попадания ее значения в любой интервал (x1, x2) может быть представлена в виде интеграла (2) от некоторой функции p(x) - плотности распределения вероятностей.
(2) Плотность распределения вероятностей вполне определяет закон распределения непрерывной случайной величины X (или, как мы будем говорить, непрерывный закон распределения). При этом функция p(x) должна быть неотрицательной (что связано с не отрицательностью вероятностей) и должна быть нормирована условием
, (3)отражающим достоверность события
Если все возможные значения случайной величины X сосредоточены в конечном интервале (a, b), то мы будем считать, что вне этого интервала плотность p(x) = 0 и, значит, условие (3) сводится к условию 
(3')Плотность вероятности p(x) случайной величины X и ее функция распределения F(x) взаимно определяют друг друга. Действительно, если известна функция распределения F(x) случайной величины X, то плотность вероятности ее найдется по равенству (1). Наоборот, пусть известна плотность вероятности p(x) случайной величины X. Функция распределения F(x) определяется равенством:
Но согласно формуле (3) вероятность того, что случайная величина X примет какое-нибудь значение от
до x, равна:
(4)Из этих двух равенств получаем:
(5)Таким образом, для полной характеристики случайной величины достаточно задать или функцию распределения, или плотность вероятности ее. Однако в большинстве случаев имеют дело с плотностью вероятности из-за удобств при теоретических исследованиях и из-за простых геометрических истолкований.
Выбор метода Оператор Caseof
Часто возникает необходимость сделать выбор из любого количества вариантов. В нашем случае такое может возникнуть, если пользователю необходимо выбрать из трех методов уточнения корня - один, по усмотрению пользователя, который, в свою очередь, выбирает метод в зависимости от заданной функции.Структура оператора выбора в Turbo Pascale следующая:
Case I of
Const1 : S1;
Const2 : S2;
............
ConstN : SN;
else S
end;
В этой записи: I - выражение порядкового типа, значение которого вычисляется; Const1, Const2, ..., ConstN - константы, с которыми сравнивается значение выражения I; S1, S2, ..., SN - операторы, из которых выполняется тот, с соответствующей константой которого совпадает значение выражения I; S - оператор, который выполняется, если значение выражения I не совпадает ни с одной из констант Const1, ..., ConstN.
Ветвь оператора else является необязательной. Если она отсутствует и значение I не совпадает ни с одной из перечисленных констант, весь оператор рассматривается как пустой. В отличие от оператора if перед словом else точку с запятой можно ставить.
Если для нескольких констант нужно выполнить один и тот же оператор, их можно перечислить через запятую (или даже указать диапазон, если это возможно), сопроводив их одним оператором.
Пример 1
Program
Problem1; { Вычисление значений функций }
uses WinCrt;
var
i : integer;
x : real;
begin
{ Инструкция }
write('Введите значение аргумента '); readln(x);
writeln('Наберите соответствующий номер для');
writeln('вычисления значения нужной вам функции');
writeln('1 - sin(x), 2 - cos(x), 3 - exp(x), 4 - ln(x)');
readln(i);
Case I of
1 : writeln('Значение sinx = ', sin(x):1:8);
2 : writeln('Значение cosx = ', cos(x):1:8);
3 : writeln('Значение exp(x) = ', exp(x):8:8);
4 : writeln('Значение ln(x) = ', ln(x):8:8)
end
end.
Пример 2.
Case I of
0, 2, 4, 6, 8 : writeln('Четная цифра');
1, 3, 5, 7, 9 : writeln('Нечетная цифра');
10..100 : writeln('Числа от 10 до 100');
else
writeln('Отрицательное число или больше 100')
end;
Обратимся к поставленной задачи - выбора метода уточнения корня в зависимости от воли пользователя и особенностей заданной функции.
{ Основная программа }
begin
write('Введите левый конец промежутка a = '); readln(a);
write('Введите правый конец промежутка b = '); readln(b);
write('Введите точность вычисления корня eps = '); readln(eps);
writeln('Для выбора метода решения, введите его номер ');
writeln('1 - метод хорд, 2 - метод касательных');
writeln(' 3 - комбинированный метод'); readln(k);
Case
k of
1 : вызов процедуры метода хорд;
2 : вызов процедуры метода касательных;
3 : вызов процедуры комбинированного метода;
end;
writeln('Корень уравнения равен x = ', x:12:t(eps));
writeln('С точностью до eps = ', eps:1:t(eps))
end.
Но каждая из процедур должна претерпеть некоторые изменения, так как в предыдущих программа каждая из процедур, образно говоря, была менее независима от других конструкций программы, а теперь она должна быть полностью автономна.
{ Процедура уточнения корня методом хорд }
Procedure chord1(a, b, eps : real; var
x : real);
var
x1, min : real;
begin
minimum(a, b, eps, min);
x1 := a;
repeat
x := x1 - ((b - x1)*fx(x1))/(fx(b) - fx(x1));
x1 := x
until abs(fx(x))/min < eps
end;
Она названа Chord1, потому что в программе будет еще одна процедура под именем Chord, которая помогает в работе комбинированному методу.
Процедура вычисления корня по методу касательных может стать такой:
Procedure Tangent2(a, b, eps : real; var
x : real);
var
min : real;
begin
minimum(a, b, eps, min);
if fx(a)*derivat2(a, eps) > 0
then tangent1(a, b, eps, min, x)
else tangent1(b, a, eps, min, x)
end;
Она названа Tangent2, так как сама использует процедуру tangent1:
Procedure tangent1(a, b, eps, min : real; var x : real);
var
x1 : real;
begin
x1 := a;
repeat
x := x1 - fx(x1)/derivat1(x1, eps);
x1 := x
until abs(fx(x))/min < eps
end;
А эта процедура названа tangent1, потому что процедура под именем tangent используется в работе комбинированного метода, процедура которого может быть такой:
{ Комбинированный метод }
Procedure Combination(a, b, eps : real; var x : real);
var
z : real;
begin
repeat
if fx(a)*derivat2(a, eps) > 0
then
begin
tangent(a, b, eps, z);
chord(b, a, x);
b := z; a := x
end
else
begin
tangent(b, a, eps, z);
chord(a, b, x);
b := x; a := z
end
until abs(z - x) < eps
end;
Разумеется в программе должны быть функции вычисления первой и второй производных, а также заданная функция.
Задание 3
Составьте полностью программу. Используйте ее для вычисления корней уравнений из предыдущего задания 2, выбирая метод в зависимости от уравнения и собственных соображений.
Вычисление корней уравнения нахождением минимума функции на промежутке
Зная определение минимума функции на промежутке, легко применить этот метод к нахождению корней уравнения.Для этого достаточно рассматривать на заданном промежутке не саму функцию, а ее модуль, тогда минимум функции будет находиться на оси OX , а значение аргумента в этой точке даст нам значение корня уравнения на заданном промежутке. Разумеется, функция должна удовлетворять всем вышеперечисленным требованиям.
Ниже приводятся рисунки, которые наглядно показывают механизм применения поиска минимума функции на промежутке к нахождению корней. На одном из рисунков схематически показан график заданной функции, а на втором - график абсолютного значения этой функции применительно к нахождению корня с использованием поиска минимума для нахождения корня (см. рис. 28 и 29).
Рис. 28
Рис. 29
Программа нахождения корня уравнения с использованием поиска минимума функции методом “золотого сечения” приводится ниже.
{Решение уравнений с использованием определения минимума }
{ с помощью "золотого сечения" }
Program Equation_min_gold;
uses WinCrt;
var
a, a1, b, b1, e, x : real;
{----------------------------------------------------------------------------------------}
{ Поиск минимума функции методом золотого сечения }
Procedure mingold(a, b, e : real; var
x : real);
var
x1, x2, y1, y2 : real;
{----------------------------------------------------------------------------------------}
Function func(x : real) : real;
begin
func := abs(sin(2*x) - ln(x))
end;
{----------------------------------------------------------------------------------------}
Function f1(a, b : real) : real;
begin
f1 := 0.618*a + 0.382*b
end;
{----------------------------------------------------------------------------------------}
Function f2(a, b : real) : real;
begin
f2 := 0.382*a + 0.618*b
end;
{----------------------------------------------------------------------------------------}
begin
x1 := f1(a, b); y1 := func(x1);
x2 := f2(a, b); y2 := func(x2);
while abs(b - a) > e do
if y1
begin
b := x2; x2 := x1; y2 := y1;
x1 := f1(a, b); y1 := func(x1)
end
else
begin
a := x1; x1 := x2; y1 := y2;
x2 := f2(a, b); y2 := func(x2)
end;
x := (a + b)/2
end;
{----------------------------------------------------------------------------------------}
{ Основная программа }
begin
write('Введите нижнюю границу промежутка '); readln(a);
a1 := a;
write('Введите правую границу промежутка '); readln(b);
b1 := b;
write('Введите точность вычисления корня ');readln(e);
mingold(a, b, e, x);
write('Корень уравнения на промежутке (');
write(a1:1:0, '; ', b1:2:0, ')');
writeln(' равен x = ', x:6:6);
writeln('с точностью до ',e:2:6)
end.
Задание 5
Составьте программу нахождения корня уравнения, применяя поиск минимума функции с помощью ряда Фибоначчи.
Вызов процедуры из процедуры
Пример 7. Нумерация книжных страниц. В книге n страниц. Составим программу, которая будет находить, сколько цифр понадобится для того, чтобы занумеровать все страницы книги.
Решение
Математическое решение рассмотрим на частном примере, а потом сделаем общий вывод.
Пусть нам требуется определить число цифр для нумерации 357 страниц.
Естественными рассуждения будут такими: однозначных цифр 9, значит они пронумеруют 9 страниц; двузначных чисел 90 - они нумеруют 90 страниц и используют 90 .
2 = 180 цифр; трехзначных чисел 900 - они пронумеруют 900 страниц и используют 2700 цифр. Следовательно, для нумерации данных 357 страниц потребуются все однозначные и двузначные числа и часть трехзначных. Чтобы узнать, сколько трехзначных чисел потребуется для нумерации, надо из заданного числа вычесть "использованные" однозначные и двузначные числа: 357 - (9 + 90) = 258.
Итак, всего потребуется цифр:
. . . . . . . . . . .
Итого: 9 + 180 + 774 = 963 цифры.
Теперь обобщим наши соображения. Пусть задано число страниц n, которое имеет c
цифр. Тогда для нумерации потребуются цифры:
1 - значные; потребуется: 9
1 = 9 цифр; 2 - значные; 90
2 = 180 цифр; 3х - значные; 900
3 = 2700 цифр;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
c-1 -значные; 9....0 . (c-1) . . . цифр,
а c-значных полностью не хватит, также, как не хватило полностью трехзначных для нумерации 357 страниц.
Чтобы узнать сколько потребуется c-значных цифр, надо из данного числа вычесть все число одно, -дву, -трех,- и т. д., c-1 значные, которые уже использованы:
а затем полученный результат умножить на c - значность числа. Сложив израсходованные цифры, мы получим окончательный результат. Попробуем на основе этих рассуждений составить программу.
Прежде, составим процедуру, которая определяет число цифр во введенном числе страниц. С такой программой мы уже раньше имели дело:
Procedure number(n : integer; var k : integer);
begin
k := 0;
repeat
k := k + 1;
n := n div 10
until n = 0
end;
В следующей процедуре будет находиться искомое число цифр. В ней, переменная m будет служить для указания числа цифр в одно, - двух, - трех, ... c-значных числах (9, 90, 900, ..., 9...0).
Переменная c
покажет число цифр в числе - номере страницы, в переменной z будет накапливаться искомый результат, а сумма s даст нам сколько всего n-значных чисел было использовано для подсчета.
Первоначальные значения: m := 9; z := 0; s := 0, а число цифр числа будет получено из процедуры number(n, c) и задаст значение переменной c:
m := 9; number(n, c); z := 0; s := 0;
Теперь организуем цикл по количеству цифр введенного числа страниц, от 1 до c - 1. Переменная цикла i.
for i := 1 to c - 1 do
begin
z := z + m*i; {Сумма цифр}
s := s + m;
m := m*10
end;
В цикле подсчитывается сумма цифр (z := z + m*i), сумма использованных однозначных, двузначных и т.д. цифр.
После завершения цикла, к сумме z добавляются оставшиеся c-значные цифры:
z := z + (n - s)
c {n - s оставшиеся страницы c-значными}{цифрами}
Процедура
Procedure Page(n : integer; var
z : integer);
var
i, m, c, s : integer;
begin
m := 9;
number(n, c); z := 0; s := 0;
for i := 1 to c - 1 do
begin
z := z + m*i; {Сумма цифр}
s := s + m;
m := m*10
end;
z := z + (n - s)*c
end;
И, наконец, полностью программа
Program
Problem7; { Число цифр для нумерации страниц }
uses WinCrt;
var
n, c : integer;
{----------------------------------------------------------------------------------------}
Procedure number(n : integer; var k : integer);
begin
k := 0;
repeat
k := k + 1; n := n div 10
until n = 0
end;
{----------------------------------------------------------------------------------------}
Procedure Page(n : integer; var z : integer);
var
i, m, c, s : integer;
begin
m := 9; number(n, c); z := 0; s := 0;
for i := 1 to c - 1 do
begin
z := z + m*i; {Сумма цифр}
s := s + m; m := m*10
end;
z := z + (n - s)*c {n - s оставшиеся страницы c-значными цифрами}
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите число страниц '); readln(n);
page(n, c);
writeln(' Число цифр, необходимых для нумерации ', c)
end.
Задача Бюффона
Пример 5. На большой лист клетчатой бумаги со стороной клетки 1 случайно бросают точку. Какова вероятность, что она будет находиться на расстоянии меньше 1/2 от центра некоторой клетки?
Математическая схема решения
Достаточно рассмотреть одну клетку. Точки, находящиеся на расстоянии не более 1/2 от ее центра, заполняют круг площади
/4. Это и есть ответ: искомая вероятность (отношение площади круга к площади клетки) равна /4. Эту задачу можно использовать для вычисления числа
. Для этого задачу можно перефразировать так:
"На большой лист клетчатой бумаги со стороной клетки 1 случайно бросают точки. Вычислить значение числа
". Для решения и этой задачи достаточно рассмотреть одну клетку.
Впишем в эту клетку окружность, радиус которой будет равен 1/2. Построим систему координат с началом в центре, вписанной в клетку окружности (см. рис. 35). Тогда площадь круга равна
Площадь квадрата равна S2 = 1.
Рис. 35
Как мы уже выяснили из предыдущей задачи вероятность того, что точка попадет в круг равна отношению площади круга к площади квадрата:
С помощью компьютера эту вероятность можно определить следующим способом. Мы можем "заставить" компьютер "бросать" в квадрат точки и подсчитать число всех точек и тех, которые попадут в круг.
Тогда вероятность определить просто, - надо будет найти отношение числа точек, попавших в круг к общему числу "брошенных" точек. Это значение и даст нам искомую вероятность.
Будем "бросать" в этот квадрат точки. Их координаты должны быть заключены в промежутке от -1/2 до 1/2 и могут задаваться функциями случайных чисел:
x := random - 1/2 и y := random - 1/2.
Координаты точек, которые попадают в круг должны удовлетворять неравенству:
Пусть общее число "брошенных" точек - n, а число точек попавших в круг - m, тогда, вероятность попадания точек в круг будет равна отношению числа точек, попавших в него, к общему числу брошенных точек: p := m/n.
Отсюда получаем, что S1/S2= m/n или
Таким образом, мы получаем способ для вычисления числа
. Программа
Program Problem5;
uses WinCrt;
var
x, y, p, e, pp : real;
i, n, m : longint;
{----------------------------------------------------------------------------------------}
{ Интегральная функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random - 1/2; y := random - 1/2;
if x*x + y*y <= 1/4 then m := m + 1
end;
p := 4*m/n;
writeln('Значение числа Pi равно ', p:8:6);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Пример 6. (задача Бюффона об игле). Плоскость разлинована на полосы шириной 1. На нее бросают иглу (отрезок) длиной 1. Какова вероятность, что игла пересечет одну из линий? (См. рисунки 36, 37 и 38).
Решение
У этой задачи удивительный ответ:
. Откуда же берется, если в условии нет речи ни об окружностях, ни о расстояниях? Наметим коротко одно из решений. Положение иглы (если не говорить о смещении ее вдоль линий, очевидно, не играющем роли) определяется двумя параметрами: расстояние y конца иглы от верхнего края полосы, в которую он попал
и углом иглы с прямой, перпендикулярной линиям. 
Рис. 36
Можно считать, по соображениям симметрии, что
</2. Условие, при котором игла пересекает край полосы: y < cos. Итак, среди точек (, y) в прямоугольнике 
, 
мы должны выбрать лежащие ниже линии y = cos и найти отношение площади S1полученной фигуры к площади S2 прямоугольника
Для тех, кто знаком с понятием интеграла, найти площадь фигуры под кривой нетрудно: S1=1. 
Рис. 37
И тогда, вероятность того, что игла пересечет одну из линий будет равна:
С другой стороны, вероятность пересечения иглой одной из линий будет равна отношению числа пересечений к общему числу "бросаний" иглы: p = m/n. Приравнивая значения вычисленных вероятностей по первому и по второму способам, получим:
отсюда 
Выясним случайные координаты иглы, - угла
и ординаты y. Для ординаты случайные значения уже известны: 0 < y < 1. Как определить величину угла
? Для этого расположим систему координат так, чтобы ее начало совпадало с концом иглы, ось OX была параллельна, проведенным прямым. Возьмем на игле две произвольные точки A и B, их координаты соответственно равны (x1, y1) и
ясно, они являются случайными числами из промежутка (0, 1), т.е. 
тогда легко найти, что 
Отсюда, значение угла
: 
Чтобы игла пересекала хотя бы одну линию надо, чтобы y удовлетворял условию:
или 
Рис. 38
Программа
Program Problem6;
uses WinCrt;
var
x1, x2, y1, y2, y, p, e, pp : real;
i, n, m : longint;
{----------------------------------------------------------------------------------------}
{ Интегральная функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure
NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x1 := random; x2 := random;
y1 := random; y2 := random; y := random;
if y < cos(arctan((x1 - x2)/(y1 - y2))) then m := m + 1
end;
p := 2*n/m;
writeln('Значение числа Pi равно ', p:8:6);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Задание 19
Отрезок разделён на три равные части. Какова вероятность, что три точки, случайно брошенные на отрезок, попадут в три разные кусочка? Составьте программу.
Задача о встрече
Пример 4. Два лица A и B условились встретиться в определенном месте между 11 и 12 ч. Пришедший первым ждет другого в течение 20 мин, после чего уходит. Какова вероятность встречи этих лиц, если каждый в течение часа приходит к этому месту наудачу, а моменты прихода независимы друг от друга? (См. рис. 34).Алгоритм решения
На прямой отложим отрезок, равный единицы длины, принимая за единицу масштаба 1 ч. Моменты случайного прихода лиц A и B можно изобразить точками на этом отрезке. Таким образом, нам необходимо выбрать наудачу две точки на данном отрезке. Обозначим моменты прихода лица A через x, а лица B - через y. Тогда множество всех возможных исходов испытания можно изобразить точками квадрата, сторона которого равна единице.
Рис. 34
Встреча произойдет лишь в том случае, если разность моментов прихода лиц A и B по абсолютной величине не будет превосходить 1/3 (20 мин), т.е. если произойдет событие, удовлетворяющее неравенству |x - y| < 1/3. Запишем это неравенство в виде системы неравенств:
Эта система неравенств задает область, заштрихованную на рисунке.
Программа
Program Problem4;
uses WinCrt;
var
x, y, p, e, pp : real;
i, n, m : longint;
{----------------------------------------------------------------------------------------}
{ Рекуррентная функция вычисления интеграла вероятностей }
{ Пределы интегрирования от 0 до x. Функция Муавра-Лапласа }
Function FF(x : real) : real;
var
n : integer;
u, I : real;
begin
if x >= 5
then FF := 1
else if x <= -5
then FF := -1
else
begin
u := x; n := 0; I := 0;
repeat
I := I + u;
n := n + 1;
u := -u*(x*x*(2*n - 1)/(2*n*(2*n + 1)))
until abs(u) < 0.00001;
FF := 2*I/sqrt(2*Pi)
end
end;
{----------------------------------------------------------------------------------------}
{ Процедура вычисления числа испытаний при заданной гарантиро- }
{ ванной вероятности и заданной точности частости }
Procedure NumberExperiment(e, PP : real; var n : longint);
var
x : real;
begin
n := 0;
repeat
n := n + 1;
x := 2*e*sqrt(n)
until FF(x) >= PP
end;
{----------------------------------------------------------------------------------------}
begin
randomize;
write('Введите гарантированную вероятность '); readln(PP);
write('Введите точность вычисления '); readln(e);
NumberExperiment(e, PP, n);
m := 0;
for i := 1 to n do
begin
x := random;
y := random;
if (y > x - 1/3) and (y < x + 1/3) then
m := m + 1
end;
p := m/n;
writeln('Искомая вероятность равна ', p:6:4);
writeln('С точностью до ', e:1:6);
writeln('С гарантированной вероятностью ', PP:1:4);
writeln('При числе испытаний ', n)
end.
Задание 18
Составьте программы решения задач.
1. В соответствии с заданием на полет экипажам двух самолетов необходимо передать одно донесение по радио в любое время от 10 ч до 10 ч 15 мин. Для передачи донесения требуется 3 мин. Какова вероятность того, что радист одного самолета начнет передачу донесения тогда, когда радист другого самолета передачу своего донесения не закончит?
2. В течение 20 мин после 9 ч ученик A в случайный момент времени звонит по телефону ученику B и ждет 2 мин, после чего кладет трубку. В течение тех же 20 мин ученик B заходит в квартиру в случайный момент и остается дома в течение 5 мин. Какова вероятность того, что разговор между учениками состоится?
Задачи, решаемые с помощью размещений
Пример 3. Некто забыл нужный ему номер телефона, который состоит из одной из десяти букв и пяти цифр, но он помнит, что в образовании этого номера участвуют цифры 3, 5, 7, 9. Какое наибольшее количество проб надо сделать, чтобы дозвониться нужному абоненту?В искомый номер должны войти четыре цифры, которые можно разместить на 5 местах
различными способами, но пятая цифра может быть любой из 10 цифр (0, 1, 2, ..., 9). Поэтому различных телефонных номеров без буквы будет 
Комбинируя эти номера с каждой из десяти букв, получаем:
10
10 .Составим программу
с использованием процедуры размещений.
Program Problem3;
uses WinCrt;
var
p : longint;
{----------------------------------------------------------------------------------------}
Procedure placement(n, k : integer; var r : longint);
var
i : integer;
begin
r := 1;
for i := 1 to k do
r := r*(n - k + i)
end;
{----------------------------------------------------------------------------------------}
begin
placement(5, 4, p);
p := 10*10*p;
writeln('Надо сделать ', p, ' проб, чтобы дозвониться')
end.
Пример 4. Сколько размещений из n элементов по m будет начинаться с первого элемента?
Соображения по составлению программы
Из n элементов выберем первый элемент и строго закрепим его на первом месте в получаемых размещениях.
Тогда, в исходном множестве останется n - 1 элементов, из которых надо выбирать еще по m - 1 - му элементу и добавлять к уже имеющемуся и стоящему на первом месте первому элементу.
Теперь остается выяснить, сколькими способами можно из n - 1 выбрать по
Это можно сделать 
способами.Поскольку первый элемент строго закреплен на первом месте в получаемых размещениях, то число всевозможных способов и будет равно
. Программа
Program Problem4;
uses WinCrt;
var
p : longint;
m, n : integer;
{----------------------------------------------------------------------------------------}
Procedure placement(n, k : integer; var r : longint);
var
i : integer;
begin
r := 1;
for i := 1 to k do r := r*(n - k + i)
end;
{----------------------------------------------------------------------------------------}
begin
write('Введите число всех элементов '); readln(m);
write('Введите число выбираемых элементов '); readln(n);
placement(m - 1, n - 1, p);
writeln('Число размещений из ', m, ' элементов по ', n, ',');
writeln('которые нач. с первого элемента, равно ', p)
end.
Пример 5. Составлены размещения из 10 элементов по 7 элементов. Сколько из этих размещений будут содержать: а) первый элемент, б) второй и четвертый элементы?
Решение
Во-первых, чем эта задача отличается от предыдущей?
В предыдущей задаче к первому элементу было строгое требование, - он должен находиться в образуемых размещениях обязательно на первом месте.
В этом примере, первый элемент просто должен присутствовать в получаемых размещениях, но совсем необязательно чтобы он находился на первом месте, значит он может занимать любое из 7 мест в получаемых размещениях.
Пронумеруем элементы множества цифрами от 1 до 7, тогда заданное множество элементов может быть записано так: {1, 2, 3, 4, 5, 6, 7}. Первый элемент выбираем из заданного множества, а "незанятые" места обозначим "x". Как видно, получается 7 подмножеств.
Отсюда следует, что его можно расположить в получаемых размещениях
способами. Во-вторых,
после того, как "вытащили” первый элемент из 10 в нем осталось 9 элементов. Из этих 9 надо выбрать и добавить к первому элементу еще 6, чтобы всего получаемых эл. было бы 7. Это можно сделать
способами. 
В итого мы имеем количество способов, равное произведению размещений
. Продумайте решение пункта б) этой задачи. Программу
составьте самостоятельно
Задачи с использованием последовательностей и рядов
Пример 4. Последовательность (an)
задается так:
и 
для каждого n=1, 2, 3, ... Найдите число, которое меньше всех членов последовательности с четными номерами и одновременно больше всех ее членов с нечетными номерами.
Если такое число существует, обозначим его a, тогда должно выполняться неравенство
Нетрудно заметить, что последовательность слева является возрастающей, а справа убывающей, а значит число a является "сгустком" для членов этой последовательности, т.е. ее пределом. Теперь осталось найти этот предел. Для этого воспользуемся признаком существования предела.
Зададимся положительным числом eps, даже очень малым и найдем члены последовательности, разность между которыми по абсолютной величине будет меньше eps. Найденный член последовательности и даст искомое число с указанной точностью.
Кстати говоря, это число в математике известно и равно
Программа
Program Problem4;
uses WinCrt;
var
n, k : integer;
a, a1, eps, e : real;
{----------------------------------------------------------------------------------------}
{ Функция вычисления порядка - кол-во знаков после запятой }
Function t(eps : real) : integer;
var
k : integer;
begin
k := -1;
repeat
eps := eps*10;
k := k + 1
until eps > 1;
t := k
end;
{----------------------------------------------------------------------------------------}
begin
write('Задайте точность eps '); readln(eps);
a := 1;
repeat
a := 1 + 1/a; {с четными номерами}
a1 := 1 + 1/a {с нечетными номерами}
until abs(a1 - a) < eps;
write('Искомое число ', a1:3:t(eps));
writeln(' с точностью до ', eps:3:t(eps));
writeln('Сравните с точным результатом ', (sqrt(5)+1)/2:3:t(eps))
end.
Задание 4
Последовательность
задается так: 
- сумма цифр числа 
Найдите 
Задачи с применением НОД
Пример 5. Один мастер делает на длинной ленте пометки синим карандашом от ее начала через каждые 36 см. Другой мастер делает пометки красным карандашом от начала через каждые 25 см. Может ли синяя пометка оказаться на расстоянии 1 см от какой-нибудь красной?Решение
Ответ: может. Например, 9-я синяя пометка и 13-я красная находятся друг от друга на расстоянии 1 см, так как 13
25 - 936 = 1. В этой задаче нам фактически надо было найти какое-нибудь решение в целых числах одного из уравнений 25x - 36y = 1, 25x - 36y = - 1
или доказать, что таких решений нет. Существует стандартная процедура, с помощью которой всегда можно найти решение уравнения
если 
Продемонстрируем ее на нашей задаче. Выпишем все шаги алгоритма Евклида для нахождения НОД(36; 25): 36 = 25
1 + 11; 25 = 112 + 3; 11 = 33 + 2; 3 = 21 + 1.Перепишем эту цепочку равенств по остаткам:
11 = 36 - 25
1; 3 = 25 - 112; 2 = 11 - 33; 1 = 3 - 21. Тогда получим:
1 = 3 - (11 - 3
3) = 34 - 11 = (25-112) 4 - 11 = 254 - 119 == 25
4 - 119 = 254 - (36 - 25) 9 = 2513 - 369. В результате получается равенство 25
13 - 369 = 1, дающее одно решение уравнения 25x - 36y = 1. Определение. Неопределенные уравнения - уравнения, содержащие более одного неизвестного.
Под одним решением неопределенного уравнения понимается совокупность значений неизвестных, которая обращает данное уравнение в верное равенство.
Уравнения вида ax + by = c, где a, b, c - целые числа, отличные от нуля
Теорема 1. Если НОД (a; b) = d, то существуют такие целые числа x и y, что имеет место равенство
.(Это равенство называется линейной комбинацией или линейным представлением наибольшего общего делителя двух чисел через сами эти числа.)
Теорема 2. Если в уравнении ax + by = l (a, b) = 1, то уравнение имеет по крайней мере одно целое решение.
Справедливость этой теоремы следует из теоремы 1. Таким образом, чтобы найти одно целое решение уравнения ах + by = 1, если (а, b) = 1, достаточно представить число 1 в виде линейной комбинации чисел а и b.
Пример. Найти целое решение уравнения 15x + 37y = 1.
Решение
1) Применим алгоритм Евклида и найдем НОД(15, 37):
НОД(15, 37) = 1
2) Выразим 1 последовательно через неполные частные и остатки, используя полученные равенства, начиная с конца:
, т. е.x0
= 5, y0 = -2.
Теорема 3. Если в уравнении ах + by = с (а, b) = d > 1 и с не делится на d, то уравнение целых решений не имеет.
Пример. Найти целое решение уравнения 16x - 34y = 7.
Решение
(16, 34) = 2, 7 не делится на 2, уравнение целых решений не имеет.
Теорема 4. Если в уравнении ах + by = с (a, b) = d > 1 и c делится на d, то оно равносильно уравнению а1х + b1у = c1, в котором (a1, b1) = 1.
Теорема 5. Если в уравнении ах + by = с (а, b) = 1, то все целые решения этого уравнения заключены в формулах:
где x0, y0 - целое решение уравнения ах + by = 1, t - любое целое число.
Приведенные теоремы позволяют установить следующее правило решения в целых числах уравнения ах + by = с, где (а, b) = 1:
1) находится целое решение уравнения ах + by = 1 путем представления 1 как линейной комбинации чисел а и b (существуют и другие способы отыскания целых решений этого уравнения, например при использовании цепных дробей);
2) составляется общая формула целых решений данного уравнения:
где x0, y0 - целое решение уравнения ах + by = 1, t—любое целое число.
Придавая t определенные целые значения, можно получить частные решения данного уравнения: наименьшие по абсолютной величине, наименьшие положительные (если можно) и т. д.
Пример 1. Найти целые решения уравнения 407х - 2816у = 33.
Решение
1) Упрощаем данное уравнение, приводя его к виду 37х - 256у = 3.
2) Решаем уравнение 37x - 256y = 1.
. 
.3) Найдем решения данного уравнения по формулам:
Ответ:
Для составления программы решения неопределенных уравнений, нам предстоит решить три задачи:
1) нахождение НОД, для последующего выяснения числа решений уравнения, - это легко сделать с помощью известной процедуры;
2) нахождение одного решения уравнения вида ах + by = 1 и
3) последующий вывод обобщенных результатов решения с учётом знаков a и b, и с учетом формулы
где t - произвольное целое число.Первую задачу можно решить с помощью рекурсивной функции:
Function nod(a, b : integer) : integer;
begin
if b = 0 then nod := abs(a)
else nod := nod(abs(b), abs(a) mod abs(b))
end;
Для решения второй задачи применять методику нахождения остатков от деления, а затем выполнять процесс в обратном порядке для компьютера нерационально. Проще составить два цикла с параметром, перебирающие числа от наименьшего (который равен наибольшему по модулю, но берётся с противоположным знаком) до наибольшего из коэффициентов (почему, будут существовать решения уравнения, меньшие или равные его коэффициентов? Докажите сами).
if abs(a) > abs(b) then max := abs(a) else max := abs(b);
for x := -max to max do
for y := -max to max do
Для вывода результатов следует рассмотреть несколько случаев, в зависимости от знаков коэффициентов a и b, а также, чтобы не получать несколько ответов, включить оператор безусловного перехода, после завершения проверки каждого условия.
Procedure
The_equation(a, b : integer); {Решение уравнения ax + by = 1}
label 1;
var
max, x, y, n : integer;
begin
if (nod(a, b) <> 1) then
writeln('Уравнение не имеет решений');
if abs(a) > abs(b) then
max := abs(a) else max := abs(b);
for x := -max to max do
for y := -max to x do
begin
if (a*x + b*y = 1) and
(a > 0) and (b > 0)
then begin writeln('Решения уравнения x = ', x, '+', b,'*t, y = ', y, '-', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end;
if (a*x + b*y = 1) and (a < 0) and (b > 0)
then begin writeln('Решения уравнения x = ', x, '+', b,'*t, y = ', y, ' ', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end;
if (a*x + b*y = 1) and (a > 0) and (b < 0)
then begin writeln('Решения уравнения x = ', x, ' ', b,'*t, y = ', y, '-', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end;
if (a*x + b*y = 1) and (a < 0) and (b < 0)
then begin writeln('Решения уравнения x = ', x, ' ', b,'*t, y = ', y, ' ', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end
end;
1: end;
Полностью программа решения уравнений вида ах + by = 1 будет такой:
Program Problem5;
uses WinCrt;
var
a, b : integer;
{---------------------------------------------------------------------------------------------------------}
Function nod(a, b : integer) : integer;
begin
if b = 0 then nod := abs(a)
else nod := nod(abs(b), abs(a) mod abs(b))
end;
{----------------------------------------------------------------------------------------------------------}
Procedure
The_equation(a, b : integer); {Решение уравнения ax + by = 1}
label 1;
var
max, x, y, n : integer;
begin
if (nod(a, b) <> 1) then
writeln('Уравнение не имеет решений');
if abs(a) > abs(b) then
max := abs(a) else max := abs(b);
for x := -max to max do
for y := -max to x do
begin
if (a*x + b*y = 1) and
(a > 0) and (b > 0)
then begin writeln('Решения уравнения x = ', x, '+', b,'*t, y = ', y, '-', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end;
if (a*x + b*y = 1) and (a < 0) and (b > 0)
then begin writeln('Решения уравнения x = ', x, '+', b,'*t, y = ', y, ' ', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end;
if (a*x + b*y = 1) and (a > 0) and (b < 0)
then begin writeln('Решения уравнения x = ', x, ' ', b,'*t, y = ', y, '-', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end;
if (a*x + b*y = 1) and (a < 0) and (b < 0)
then begin writeln('Решения уравнения x = ', x, ' ', b,'*t, y = ', y, ' ', a, '*t,');
writeln('где t - произвольное целое число'); goto 1 end
end;
1: end;
{-----------------------------------------------------------------------------------------------------------}
begin
write(' Введите значение коэффициента при x, a '); readln(a);
write('Введите значение коэффициента при y, b '); readln(b);
The_equation(a, b);
end.
в составление программы. Посудите сами,
1. Оператор gotoвносит фактическое безумие в составление программы. Посудите сами, какой человек может идти, идти, а затем без всякой причины повернуться и пойти обратно! У нормального человека всегда должна быть причина, условие
такого поступка.
Оператор goto
может заставить даже без всякой причины, условия нарушить естественный ход выполнения программы и перевести работу на помеченную строку.
Итак, оператор перехода изменяет последовательность выполнения операторов - они выполняются не в том порядке, как написаны в тексте программы. Операторы перехода нарушают связь между структурой выполнения (динамической) и текстовой (статистической) структурой программы.
Из-за этого программа становится менее понятной и труднее определяется ее правильность. Часто это становится гордиевым узлом, о котором программисты могут сказать: "Но все-таки программа работает". Почему и как работает программа, однако, остается секретом из-за оператора goto.
2. Частое использование операторов перехода указывает, что программист еще не научился программировать "структурно", т. е. использовать последовательные, разветвляющиеся и циклические структуры управления.
Оператор перехода рекомендуется использовать только в исключительных случаях. Такой случай может быть, когда цикл прерывается при удовлетворении определенного условия. Именно такой случай есть в нашей программе.
3. Переход внутрь сложного оператора не определен. Ошибок такого рода транслятор может и не обнаружить.
1) if
p then goto 3;
.....................
if q then 3: s;
2) while
i<= 10 do
begin
s1;
3: s2;
end;
.............
goto 3;
4. Метка в Турбо Паскале - это произвольный идентификатор (может быть обозначен и буквами), позволяющий именовать некоторый оператор программы и таким образом ссылаться на него.
В целях совместимости со стандартным языком Паскаль, в Турбо Паскале допускается в качестве меток использование целых чисел без знака.
Само собой возникает вопрос, можно ли программу примера 4 составить без оператора перехода goto?
Оказывается это возможно, о чем вы узнаете в следующих занятиях.
Программирование: Языки - Технологии - Разработка
- Программирование
- Технологии программирования
- Разработка программ
- Работа с данными
- Методы программирования
- IDE интерфейс
- Графический интерфейс
- Программирование интерфейсов
- Отладка программ
- Тестирование программ
- Программирование на Delphi
- Программирование в ActionScript
- Assembler
- Basic
- Pascal
- Perl
- VBA
- VRML
- XML
- Ada
- Lisp
- Python
- UML
- Форт
- Языки программирования