Главная страница Случайная страница
Разделы сайта
АвтомобилиАстрономияБиологияГеографияДом и садДругие языкиДругоеИнформатикаИсторияКультураЛитератураЛогикаМатематикаМедицинаМеталлургияМеханикаОбразованиеОхрана трудаПедагогикаПолитикаПравоПсихологияРелигияРиторикаСоциологияСпортСтроительствоТехнологияТуризмФизикаФилософияФинансыХимияЧерчениеЭкологияЭкономикаЭлектроника
Примеры решения задач с помощью языка программирования “Паскаль”.
|
|
Пример 1. Найти разность между трехзначным числом и числом, составленным из тех же цифр, но взятых в обратном порядке.
Программа
Program Problem1;
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.
Пример 2. Составить программу, после выполнения которой меньшее из двух неравных чисел будет увеличено вдвое, а большее оставлено без изменения.
Программа
Program Problem2; { Увеличения меньшего из двух целых чисел вдвое }
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.
Пример 3. Составить программу решения квадратного уравнения
ax2 + bx + c = 0.
Наметим план составления программы или, иначе говоря, алгоритм.
Под алгоритмом мы будем понимать последовательность указаний для составления программы.
Алгоритм
1. Начало.
Описание переменных и их типов.
2. Ввод значений коэффициентов.
3. Вычисление значения дискриминанта (d).
Если d < 0, тогда уравнение не имеет корней,
иначе,
если d = 0,
тогда уравнение имеет один корень,
вычислить значение этого корня и выдать его на экран,
иначе, уравнение имеет два корня,
вычислить их и выдать на экран.
4. Конец.
Составим программу, пользуясь алгоритмом.
Program Problem3; {Программа решения квадратного уравнения}
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.
Пример 4. Два прямоугольника заданы длинами сторон. Написать программу, после выполнения которой выясняется, можно ли первый прямоугольник целиком разместить во втором. (Рассмотреть только случай, когда соответствующие стороны прямоугольников параллельны.)
Пользуясь блок-схемой составим программу
Program Problem4;
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.
Пример 5. Определить и вывести на экран цифры целого числа 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; {Опред. и вывод на экран цифр числа.}
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.
Пример 6. Составить программу перестановки первой и последней цифр введенного натурального числа.
Математику этого вопроса разберем на частном примере.
Пусть пользователем введено число 4538. После перестановки первой и последней цифр число станет таким: 8534.
Определить последнюю цифру числа нетрудно. Это можно сделать уже известным нам способом: 4538 mod 10.
Чтобы найти и отделить первую цифру числа, надо использовать прием, который применялся в предыдущих программах для вывода цифр числа и для подсчета суммы цифр, т. е. отделять по одной цифре справа. Но, если в предыдущих программах такой процесс продолжался до тех пор пока n < > 0 (n не равнялось нулю), а когда n становилось равным нулю, то цикл заканчивался т. е. все цифры, включая первую, отделялись, то теперь надо этот процесс остановить на одну цифру раньше и тогда последним значением переменной n будет первая цифра числа.
В нашем примере она равна 4.
Итак, первая и последняя цифры найдены. Как переставить их в числе.
Для введенного нами числа это можно сделать так. Вычесть из него первую цифру, умноженную на 1000 и вычесть последнюю цифру:
4538 - 4 
1000 - 8 = 530.
К полученному результату прибавить последнюю цифру - 8, умноженную на 1000 и прибавить первую цифру: 530 + 8 1000 + 4 = 8534.
Две последние операции можно записать в одной строке:
4538 - 4 1000 - 8 + 8 1000 + 4 = 8534.
Возникает одна трудность. Как определить разряд, в котором находится первая цифра числа (первая слева) и на сколько надо умножить ее при вычитании? Тысячи ли это, десятки тысяч или другой разряд?
Для того, чтобы это выяснять заведем переменную, первоначальное значение которой 1, а затем, каждый раз при отделении цифры она умножается на 10.
Посмотрим весь процесс на примере того же числа 4538.
Первоначальные значения: n = 4538, i = 1.
Цикл продолжается пока n 
10, 4538 10 - истина, значит операторы цикла выполняются первый раз: i: = i*10 = 1*10 = 10; - переменная i получает первое значение,
n: = 4538 div 10 = 453.
Проверка условия: 453 10 - условие выполняется, значит цикл выполняется второй раз: i: = i*10 = 10*10 = 100; n: = 453 div 10 = 45.
Проверка условия: 45 10 - истина, значит цикл выполняется третий раз:
i: = i*10 = 100*10 = 1000, n: = 45 div = 4.
Проверка условия: 4> =10 - ложь, значит операторы цикла не выполняются. Цикл заканчивается.
Конечные значения переменных: n = 4 - первая цифра числа, i = 1000. Теперь остается выполнить сам процесс перестановки цифр и выдать результат на экран.
Программа
Program Problem2; { Перест. первой и последней цифр числа }
var
n, n1, p, a, i: integer;
begin
write('Введите натуральное число n '); 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.
Пример 7. Составить программу разложения натурального числа n на простые множители.
Прежде вспомним, что к простым числам относятся все те натуральные числа, которые имеют только два делителя - единицу и само себя.
Натуральные числа, имеющие более двух делителей называются составными.
Единица имеет только один делитель - само себя и поэтому она не может относится ни к простым, ни к составным числам. Если выписать простые числа в порядке их возрастания, начиная от самого меньшего - 2, то получим следующий ряд чисел:
2, 3, 5, 7, 11, 13, 17, 19, 23, 29,...
А теперь вспомним, как в младших классах мы раскладывали натуральные числа на простые множители.
Для этого берем первое простое число - 2 и пробуем делить данное натуральное число на 2, если число делится на 2, тогда надо 2 записать, а число разделить на 2 и снова полученный результат пробуем делить на два, если делится, тогда повторяем процесс деления, если не делится, тогда пробовать делить на следующее простое число - 3 и так далее.
Обычно такой процесс мы записывали " столбиком ":
Например: или
Таким образом, число 360 можно разложить на следующие простые множители: 360 = 2 2 2 3 3 5.
Самый простой алгоритм для составления программы может быть таким.
В качестве первого делителя взять 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- й спос. }
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.
Пример 8. Написать программу, в результате выполнения которой выяснится, входит ли цифра 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 в запись числа }
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.
Пример 9. Составить программу вывода всех натуральных чисел, меньших 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;
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.
Пример 10. Найти наименьшее натуральное число, дающее при делении на 2, 3, 4, 5, 6 соответственно остатки 1, 2, 3, 4, 5.
Задачу будем решать так: берется наименьшее натуральное число - единица и находятся остатки от деления его на 2, 3, 4, 5 и 6; если остатки будут равны 1, 2, 3, 4 и 5, тогда это число является искомым, его надо выдать на экран и закончить программу, в противном случае, надо брать следующее натуральное число - 2 и проверять его, и так далее.
Программа, составленная по этой идее, очень проста:
Program Problem1;
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.
Пример 11. Числа, одинаково читающиеся и слева направо, и справа налево, называются палиндромами. Например, числа 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;
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.
Пример 12. Если мы сложим все цифры какого-либо числа, затем - все цифры найденной суммы и будем повторять это много раз, мы наконец получим однозначное число (цифру), называемое цифровым корнем данного числа. Например, цифровой корень числа 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; { Цифровой корень числа }
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.
Пример 13. Составить программу вычисления факториала числа n, т. е. n!.
Вспомним из математики, что факториал числа n равен произведению чисел от 1 до n.
Например:
З амечание. В математике принято: 0! = 1.
Программа
Program Problem1; { Вычисление факториала числа n! }
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.
Пример 14. Квадрат любого натурального числа 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;
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.
Пример 15. Двузначное десятичное число в сумме с числом, записанным теми же цифрами, но в обратном порядке, дает полный квадрат. Найти все такие числа.
Пусть искомое двузначное число 
= a 10 + b, тогда число, записанное теми же цифрами, но в обратном порядке будет 
= b 10 + 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;
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.
Пример 16. Составить программу, которая бы проверяла, являются ли три числа взаимно простыми.
Мы знаем, что числа называются взаимно простыми, если их наибольший общий делитель (НОД) равен 1. Значит, для решения этой задачи нам придется дважды находить НОД чисел. Если заданы три числа: a, b, c, то найти НОД(a, b), а затем найти НОД(НОД(a, b), c).
Дважды писать операторы для нахождения НОД нам не хочется, поэтому оформим операторы для НОД в виде процедуры.
Посмотрите, как это будет выглядеть в программе:
Program Problem1;
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.
Пример 17. Составить программу, которая устанавливает, какие числа из заданного промежутка [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;
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.
Пример 18. Составить программу нахождения и вывода на экран всех простых чисел из заданного промежутка [n; m]. (Массивы не использовать.)
Следует сразу заметить, что эта задача решается иначе с помощью программы " Решето Эратосфена", но ее мы будем разбирать при изучении работы с массивами чисел и множествами.
А сейчас приведем другой вариант решения этой задачи. Ясно, что для ее решения нам потребуется процедура, которая устанавливает, является ли число простым. На предыдущих занятиях мы уже составляли такую программу. Сейчас вспомним ее работу и возможно внесем некоторые изменения.
Алгоритм составления процедуры такой.
Во-первых, вспомним, какие числа называются простыми.
Натуральные числа, которые имеют только два делителя 1 и само себя называются простыми. Остальные называются составными.
Из их числа исключается число 1, которое не относится ни к простым, ни к составным.
Первое простое число - это 2. Если оно есть, тогда его сразу надо выводить на экран:
if p = 2 then write(p, ' ')
Ясно, что все остальные четные числа являются составными, а значит их нет смысла проверять. Для исключения из рассмотренных четных чисел введем для проверки условный оператор:
else if p mod 2 < > 0 then
Если число нечетное, тогда его надо проверять. Сущность проверки будет заключаться в определении числа делителей. Но нам уже известен математический факт, что все делители некоторого натурального числа p находятся в промежутке от 1 до корня квадратного из этого числа (исключая само число). Значит, если имеются делители, в данном случае, от 3 до trunc(sqrt(p)), то оно является составным, а если таких делителей нет (четные числа мы уже исключили, а единицу и само число p не рассматриваем), тогда число будет простым.
Для проверки этого факта устроен следующий цикл:
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
Полностью процедура, устанавливающая является ли число простым будет следующей (probleme number -простое число):
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;
Снова, эта процедура имеет только входной формальный параметр и не имеет выходных.
Программу составить нетрудно. В ней достаточно организовать цикл для проверки чисел из заданного промежутка и каждое из них проверять с помощью процедуры.
Program Problem3; { Простые числа из промежутка [n; m] }
var
n, m, i: integer;
{---------------------------------------------------------------------------------}
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;
{---------------------------------------------------------------------------------}
begin
write('Введите левую границу промежутка > 1 '); readln(n);
write('Введите правую границу промежутка '); readln(m);
writeln('Простые числа из промежутка [', n, ' ', m, ']');
for i: = n to m do probleme_number(i);
writeln
end.
Пример 19. Нумерация книжных страниц. В книге 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; { Число цифр для нумерации страниц }
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.
Пример 20. Счастливые автобусные билеты.
Номера автобусных билетов представляют собой шестизначные числа. Счастливым считается тот билет, у которого сумма первых трех цифр равна сумме последних трех цифр. Например, билет 356428 считается счастливым, так как:
3 + 5 + 6 = 4 + 2 + 8 =14.
Будем считать, что номера билетов принадлежат промежутку
[100000; 999999].
Составить программу определения счастливого билета.
Алгоритм
Для программы составим две процедуры: одна - определяющая сумму цифр введенного числа, уже известную нам (sum number - сумма цифр):
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;
вторую - отделяющую первые и последние три цифры, а затем, с помощью вызова процедуры sum_number, устанавливает равны ли эти суммы (happiness - счастье):
Procedure happiness(x: longint);
var
l, r: longint;
begin
sum_number(x mod 1000, l);
sum_number(x div 1000, r);
if l = r then write(x, ' ')
end;
x mod 1000 - отделяет последнее трехзначное число, а x div 1000 - первое трехзначное число.
Программа
Program Problem9; { Счастливые автобусные билеты }
var
i: longint;
{---------------------------------------------------------------------------------}
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;
{---------------------------------------------------------------------------------}
Procedure happiness(x: longint);
var
l, r: longint;
begin
sum_number(x mod 1000, l);
sum_number(x div 1000, r);
if l = r then write(x, ' ')
end;
{---------------------------------------------------------------------------------}
begin
writeln('Счастливые автобусные билеты');
for i: = 100000 to 999999 do happiness(i);
writeln
end.
Пример 21. Поставим задачей, записать в один файл произвольный массив чисел, затем прочесть их из файла, отсортировать по не убыванию методом пузырьковой сортировки и записать отсортированный массив в новый файл.
1. Нам уже известно, что файл - это именованная область на диске для записи информации. Значит, этой области надо дать имя, иначе говоря " открыть файл" на диске, Для этого надо указать: имя диска, имя каталога и подкаталога, в который записывается файл и, наконец, имя самого файла. (Сразу надо заметить, что не всегда обязательно нужно указывать путь к файлу, т. е. диск, каталог, подкаталог. Другие случаи разберем позже).
Итак, указываем путь к файлу и его имя. Сразу возникает вопрос, в каком разделе программы это можно сделать?
Один из способов - записать в разделе констант, т. е. некоторой константе определить имя физического файла, а затем работать уже с этой константой, что может упростить запись, особенно в тех случаях, когда путь к файлу " долгий " - состоит из нескольких подкаталогов.
Это можно сделать так:
const
name = 'd: \Bp\prakt\p23\array1.dat';
name - константа, в которой записывается путь к файлу и его имя. Далее, в апострофах, как символьная переменная, записывается:
'd: \Bp\Prakt\p23\array1.dat'
d - имя диска, Bp - имя каталога, Prakt - имя подкаталога, P23 - еще один подкаталог, array1.dat - имя файла и его расширение, которое должно удовлетворять известным требованиям (имя - не должно превышать 8 символов, расширение - трех символов).
В файл array1.dat будут записываться элементы массива до сортировки.
Теперь надо, таким же образом, указать второй файл, в который будут записываться отсортированные элементы массива, назовем его array1.int и запишем в другую константу name1.
Окончательная запись в разделе констант будет такой:
const
name = 'd: \Bp\prakt\p23\array1.dat';
name1 = 'd: \Bp\Prakt\p23\array1.int';
n = 100;
Здесь еще добавилось n - возможное число элементов массива.
2. Понятно, что константой, определяющей имя файла еще нельзя пользоваться в программе. Константа - это постоянная, не подверженная изменениям в программе, а ведь нам надо записывать информацию в файл, считывать ее, да и размер файла не всегда может быть заведомо установлен.
Значит, необходимо завести переменные для файлов. Обозначим эти переменные f и f1. Но поскольку это переменные, необходимо указать их тип.
Для переменных файлового типа указывается тип: file - что и означает файловый тип, а затем указывается тип данных, которые будут записаны в этот файл. В данном случае - это целые числа, значит, запись будет такой: file of integer.
Нам уже известно, как можно описать переменные. Вот эти два способа:
1) 2)
type var
v = file of integer; f, f1: file of integer;
var
f, f1: v;
В нашем примере будет использован первый способ. Кроме того, опишем массив чисел и другие переменные. И тогда полностью раздел описаний станет таким:
const
name = 'd: \Bp\prakt\p23\array1.dat';
name1 = 'd: \Bp\Prakt\p23\array1.int';
n = 100;
type
v = file of integer;
t = array[1..n] of integer;
var
f, f1: v;
a: t;
i: integer;
3. Для создания массива чисел мы, как и раньше, воспользуемся процедурой, но в из нее нам надо получить файл с записью целых чисел массива, значит в качестве выходного параметра добавляется и файловая переменная f.
Начало процедуры станет:
Procedure create(n: integer; var a: t; var f: v);
Но чтобы работать в программе или процедуре с файловой переменной, надо связать логическое имя файла f с физическим, которое записано в константе name, т. е. сделать доступной переменную f, как сам файл.
Для этого используется стандартная (встроенная) процедура assign (назначит).
Она запишется так: assign(f, name); { доступ к файлу f }
В переводе на простой язык, это значит, что файлу name назначается в программе имя f и в дальнейшем к переменной f можно обращаться как самому файлу, т. е. посредством f осуществляется доступ к файлу.
Процедура уже напишется дальше:
Procedure create(n: integer; var a: t; var f: v);
var
i: integer;
begin
assign(f, name); { доступ к файлу f }
4. Теперь наступило время приступить к работе с файлом f. Но, прежде, надо установить, что делать в файле: записывать в него информацию, читать или что-то другое. Нам следует записать в него информацию. Для этого его надо открыть для записи.
Открывается файл для записи стандартной процедурой rewrite(f) (переписать). При этом уничтожается вся информация, которая была в файле f и запись новой информации начнется с начала файла.
Procedure create(n: integer; var a: t; var f: v);
var
i: integer;
begin
assign(f, name); { доступ к файлу f }
{$i-}
rewrite(f); { открытие его для записи }
{$i+}
if ioresult < > 0 then writeln('Такой файл не существует');
В процедуре записаны два новых для вас знака {$i-} и {$i+}. Что они означают?
С помощью указания (директиве) компилятору {$i-} отключается автоматический контроль ошибок ввода-вывода. Если этого не сделать, то отсутствие файла приведет к аварийному завершению программы.
{$i-} { Отключить контроль ошибок ввода-вывода }
С помощью директивы {$i+}, напротив, включается контроль за ошибками ввода и вывода.
{$i+} { Включить контроль ошибок ввода-вывода }
Вначале, до открытия файла для записи, контроль за ошибками был отключен, после включения контроля за ошибками ввода и вывода, можно установить условный оператор, который бы, в случае ошибки, выдавал соответствующую информацию.
Это делается с помощью условного оператора
if IORESULT < > 0 then..... { Файл не существует }
else.... { Файл существует }
Встроенная функция IORESULT типа WORD в случае ошибки получает ненулевое значение, в частности, если файл, к которому обращаются, вообще не существует.
5. Препятствий для записи элементов массива в файл f нет. Сделаем это с помощью известной встроенной процедуры write(f, a[i]).
Procedure create(n: integer; var a: t; var f: v);
var
i: integer;
begin
assign(f, name); { доступ к файлу f }
{$i-}
rewrite(f); { открытие его для записи }
{$i+}
if ioresult < > 0 then writeln('Такой файл не существует');
randomize;
for i: = 1 to n do
begin
a[i]: = random(201) - 100;
write(f, a[i]) {запись элементов массива в файл f}
end;
6. После записи информации в файл, его надо закрыть. Это делается с помощью встроенной, стандартной процедуры close(f).
Полностью процедура создания массива чисел и его записи в файл со строгим контролем за ошибками ввода-вывода получится такой:
{ Открытие файла f, соответствующего на диске файлу arra1.dat
и процедура заполнения его массивом произвольных целых чисел }
Procedure create(n: integer; var a: t; var f: v);
var
i: integer;
begin
assign(f, name); { Доступ к файлу f }
{$i-} { Отключить контроль ошибок ввода-вывода }
rewrite(f); { Открытие его для записи }
{$i+} { Включить контроль ошибок ввода-вывода }
if ioresult < > 0 then writeln('Такой файл не существует');
randomize;
for i: = 1 to n do
begin
a[i]: = random(201) - 100;
write(f, a[i]) { Запись элементов массива в файл f }
end;
close(f); {Закрытие файла f}
end;
Пример 22. Создать файл f, содержащий числа 1, 2, 3, 4, 5. Необходимо вместо последних трех элементов файла f записать числа 30, 40, 50.
1. На этот раз, мы не будем записывать путь и имя файла на диске в разделе констант, а применим другой способ. Предоставим пользователю самому во время работы указать по его усмотрению имя файла. Для этого в программу включим следующее предложение:
write('Введите имя файла '); readln(name);
Но тогда, переменной name надо указать тип в разделе описаний. Поскольку имя файла представляет собой строку символов, тогда тип переменной name будет string. С этим типом переменных мы познакомимся ниже. Сейчас важно знать, что он определяет строку символов.
Итак, в разделе описаний, опишем тип переменной name, а также тип файла f, который будет в программе и другие переменные.
var
name: string;
f: file of integer;
x, i: integer;
Ясно почему файловая переменная f имеет файловый тип из целых чисел integer, потому что в файл будут записываться целые числа.
2. В начале программы, как уже говорилось, пользователь сам вводит имя файла. Затем процедурой assign(f, name) устанавливается доступ к файлу f, как к файлу name, т. е. f становится своеобразным логическим именем файла.
3. Файл открывается для чтения rewrite(f) и с помощью цикла в него записываются числа 1, 2, 3, 4, 5: for i: = 1 to 5 do write(f, i). Запись в файл закончена.
4. Теперь открываем его для чтения процедурой reset(f) и указатель устанавливается в начало файла.
5. Далее стоит задача заменить числа 3, 4 и 5 на 30, 40 и 50. И вот здесь надо быть внимательным и помнить, что указатель файла устанавливается на начало файла, которая имеет нулевую позицию, т. е. номер числа 1, записанной в файл первым будет - 0, номер числа 2 будет 1, числа 3 - 2, числа 4 - 3 и числа 5 - 4.
Это очень важно знать для использования функции seek(f, n). В нашем примере функция seek(f, 0) укажет на число 1 в файле f, seek(f, 1) на число 2 и т. д.
Наша задача заменить числа 3, 4, 5, которые будут под номерами 2, 3, 4. Поэтому, используя функцию seek как указатель на компонент файла, надо иметь это обстоятельство ввиду,
Итак, укажем с помощью функции seek на нужные элементы файла, прочтем их, изменим на заданные числа, вновь укажем на те места в файле, куда следует их записать и запишем. Все это будет выполнено с помощью операторов:
for i: = 3 to 5 do
begin
seek(f, i - 1);
read(f, x);
x: = 10*i;
seek(f, i - 1);
write(f, x)
end;
Прочитываемые из файла числа умножаются на 10 и присваиваются переменной x, а потом записываются на те же места.
6. Осталось вывести на экран все содержимое файла f, т. е. прочесть его содержимое до конца.
Для этого, открываем его для чтения reset(f) и организуем цикл, в котором " руководящую роль" играет функция eof.
while not eof(f) do - означает, пока запись файла f не закончена, надо продолжать с ним работать. Что же делается в цикле?
read(f, x); write(x, ' ')
Считывается из файла информация в переменную x и выводится на экран.
7. Когда цикл закончен, файл закрывается: close(f).
Программа
Program Problem2;
var
name: string;
f: file of integer;
x, i: integer;
begin
write('Введите имя файла '); readln(name);
assign(f, name);
rewrite(f);
for i: = 1 to 5 do write(f, i);
reset(f);
for i: = 3 to 5 do
begin
seek(f, i - 1); read(f, x);
x: = 10*i;
seek(f, i - 1);
write(f, x)
end;
writeln('Содержимое файла f');
reset(f);
while not eof(f) do
begin
read(f, x);
write(x, ' ')
end;
close(f);
end.
Пример 23. Компонентами файла f являются действительные числа. Найти:
а) сумму компонент; б) произведение компонент;
в) сумму квадратов компонент;
г) модуль суммы и квадрат произведения компонент;
д) последнюю компоненту файла.
Program Problem3; { Обработка компонентов файла }
const
name = 'd: \Bp\Prakt\P23\array3.dat';
type
v = file of real;
var
f: v;
a, s, sk, p: real;
i: integer;
{---------------------------------------------------------------------------------}
{Открытие файла f, соответствующего на диске файлу arra3.dat
и процедура заполнения его действительными числами}
Procedure create(var f: v);
var
i, n: integer;
a: real;
begin
assign(f, name); { доступ к файлу f }
{$i-}
rewrite(f); { открытие его для записи }
{$i+}
if ioresult < > 0 then writeln('Такой файл не существует');
write('Введите число элементов '); readln(n);
for i: = 1 to n do
begin
write('Введите ', i, '-й элемент '); readln(a);
write(f, a) { запись элементов массива в файл f }
end;
close(f); { закрытие файла f }
end;
{---------------------------------------------------------------------------------}
begin
create(f);
assign(f, name); {доступ к файлу f}
{$i-}
reset(f); {Открытие файла f для чтения}
{$i+}
if ioresult < > 0 then writeln('Такой файл не существует');
s: = 0; p: = 1; sk: = 0;
while not eof(f) do
begin
read(f, a); { Чтение элементов массива из файла f }
s: = s + a; p: = p*a;
sk: = sk + a*a;
end;
writeln('Сумма компонент файла равна ', s: 6: 4);
writeln('Произведение компонент
|
|