Программирование на языке Паскаль

Ввод информации в программе осуществляется операторами:

Read(x1, x2, x3, …);

ReadLn(x1, x2, x3, …);

где x1, x2, x3, …- список ввода - перечень имен переменных, значения которых вводятся.

Пример: ReadLn(n, m, r); - ввести значения переменных

n, m, r.

Операторы ввода позволяют организовать диалоговый (интерактивный) режим работы компьютера - при их исполнении выполнение программы останавливается, и ожидается ввод данных.

Пользователь должен ввести с клавиатуры необходимое количество данных в соответствии с типами переменных, перечисленных в операторе ввода (чисел, символов, строк):

если переменные целого или вещественного типа, то их значения можно вводить одной строкой, разделяя пробелами:

1.5 -2.21 5 10.6е-12

если переменные символьного типа, то при вводе одной строкой их значения записываются без апострофов и каких бы то ни было разделителей (пробелов или запятых), которые в этом случае будут восприниматься как символы,

строки вводятся в соответствии с описанной длиной: если вводимая строка длиннее описанной, то она обрезается, если меньше, то пробелами не дополняется,

значения переменных логического типа нельзя вводить с клавиатуры,

в любом случае значения переменных можно вводить по одному в строке:

1.5

-2.21

5

10.6е-12

после выполнения оператора Read курсор на новую строку не переводится, а оператора ReadLn - переводится в начало новой строки и очищается буфер ввода, оператор ReadLn без списка ввода останавливает выполнение программы до тех пор, пока не будет нажата клавиша ENTER.

Вывод данных

Под выводом данных понимается передача информации из оперативной памяти компьютера на внешние устройства (принтер, диски).

Вывод информации в программе осуществляется операторами:

Write(x1, x2, x3, …);

WriteLn(x1, x2, x3, …);

где x1, x2, x3, … - список вывода - перечень имен переменных, значения которых выводятся.

Оператор WriteLn после вывода значения последней переменной списка вывода переводит курсор в начало следующей строки на экране монитора или в текстовом файле.

Вывод данных может быть осуществлен бесформатным и форматным способами.

Бесформатный способ вывода

В этом случае для вывода данных различных типов компьютер автоматически отводит заранее определенное число позиций на экране:

для целых чисел отводится столько позиций, сколько в числе значащих цифр плюс позиция для знака ”минус”: например, число +025 будет выведено как 25.

Таким образом, знак + при выводе не печатается, а само число занимает столько позиций на экране, сколько в нем значащих цифр,

для данных вещественного типа отводится 17 позиций:

±d.ddddddddddE±dd

Позиции распределяются следующим образом:

1-я - знак числа (если число положительное, то выводится пробел),

2-я - первая значащая цифра числа,

3-я - десятичная точка,

4 - 13-я - десять цифр дробной части с округлением,

14-я - буква E,

15-я - знак показателя степени,

16 - 17-я - две цифры показателя степени.

Пример: следующие числа

3,14159265358979

-798,344

9112,0789

-0,00598Ч10-5

бесформатным способом будут выведены так:

3.1415926536E+00

-7.9834400000E+02

9.1120789000E+03

-5.9800000000E-08

Таким образом, вещественные числа при выводе округляются или дополняются нулями до 10 цифр после запятой.

Для вывода данных символьного типа отводится одна позиция, логического - пять. Строки выводятся по количеству символов в строке.

Использовать бесформатный вывод не всегда удобно - получаются длинные и трудночитаемые числа. Поэтому для вывода целых и вещественных чисел используется форматный способ.

Форматный способ вывода

В этом случае программист сам задает формат вывода - количество позиций для вывода значения переменной.

Для целых чисел указывается длина поля вывода - общее количество позиций для вывода числа:

i:=-12;

WriteLn(i);

WriteLn(i:3);

WriteLn(i:7);

WriteLn(i:1);

На экран будет выведено:

-12

-12

-12

-12

Таким образом, если указанное количество позиций (длина поля вывода) больше количества символов в числе, то перед числом выводится соответствующее количество пробелов (число прижимается к правому краю поля вывода), а если меньше (программист ошибся) - то число выводится бесформатным способом.

Для данных вещественного типа необходимо указать как общую длину числа, включая его знак и десятичную точку, так и количество цифр в его дробной части - точность вывода:

Pi:=3.14159265358979;

WriteLn(Pi);

WriteLn(Pi:6:2);

WriteLn(Pi:7:4);

WriteLn(Pi:2:1);

WriteLn(Pi:0:2);

WriteLn(Pi:3:0);

На экран будет выведено:

3.1415926536e+00

3.14

3.1416

3.1

3.14

3

Таким образом, при некорректном задании формата вывода (вторая цифра формата больше или равна первой) определяющей для вывода числа является заданная точность вывода.

Вывод чисел без всякой дополнительной информации называется “немым” - он некрасив и непонятен. Поэтому при выводе чисел желательно выводить и поясняющий текст, заключая его в апострофы:

WriteLn(`Pi=',Pi:7:4);

На экран будет выведено:

Pi=3.1416

Для отступа от левого края экрана нужно указать необходимое количество пробелов слева от выводимого значения:

WriteLn(` `:30,`Pi=',Pi:7:4);

На экран будет выведено:

Pi=3.1416

30 пробелов

Оператор WriteLn без списка вывода пропускает на экране одну чистую строку.

Структуры данных

В повседневной практике обработки информации мы часто имеем дело с естественно организованными (объединенными) представлениями информации: текстами, списками, таблицами, анкетами. Такие организованные (структурированные) данные во многом облегчают их восприятие и обработку.

Естественная организация данных эффективно отражается в современных языках программирования понятием структур данных.

Под структурами данных понимаются специальным образом организованные совокупности данных, облегчающие реализацию алгоритма и их компьютерную обработку.

Отличительной особенностью хорошо написанных программ является то, что данные в них организованы в определенные, наиболее подходящие для их хранения и обработки структуры, а сами программы являются лишь средством обработки этих структур независимо от их информационного содержания. Проектирование подходящих структур данных для их эффективной обработки программой столь же важно, и занятие это, возможно, более сложное, чем написание собственно операторов программы в соответствии с выбранным алгоритмом их обработки. Хорошо спроектированные структуры данных облегчают и ускоряют их обработку, улучшают понимание самой программы.

К базовым структурам данных в Паскале относятся:

переменные,

массивы,

строки,

множества,

записи,

файлы.

Из этих структур можно конструировать более сложные, например, файлы записей (базы данных). Понятие переменных было введено раньше - это структура данных, состоящая из отдельных элементов, каждый из которых имеет имя, тип и конкретное значение.

Массивы

В программировании часто встречаются задачи, связанные с хранением и обработкой большого количества однотипных данных. Например, требуется ввести оценки по информатике для 25 студентов группы ИС-09 и определить средний балл. Для решения этой задачи опишем 25 переменных: is09_1, is09_2, is09_3, …, is09_25:

Var is09_1, is09_2, is09_3, …, is09_25: 2..5;

Каждая из них будет соответствовать одному студенту. После этого используем 25 операторов для ввода оценок:

ReadLn(is09_1);

ReadLn(is09_2);

ReadLn(is09_3);. . . . . . . . . . . . .

ReadLn(is09_25);

И, наконец, определим средний балл:

sr_ball:=(is09_1+is09_2+is09_3+ . . . +is09_25)/25.0;

А что произойдет, если нужно будет решить эту задачу для всего университета? Вводить несколько тысяч переменных?

Для решения таких задач используют массивы. Для структур, используемых в алгоритмизации, организация массивов представляется наиболее удобной для программирования. Это связано с возможностью непосредственного логического доступа к любому их элементу, без обращения к предыдущим элементам, что обеспечивает простоту интерфейса между логической организацией данных и их физическим представлением, поскольку массив легко проецируется на оперативную память. Это обстоятельство оказалось столь удобным для программирования, что для большинства структур данных разработаны механизмы их эмуляции на базе массивов.

Массив состоит из конечного числа элементов (компонент), содержимое которых относится к некоторому общему, базовому типу. При этом сам базовый тип должен быть таким, что принадлежность к нему гарантирует одинаковые размеры памяти для размещения каждой из компонент. Элементы различаются местом их размещения внутри структуры, иначе говоря, номером или индексом. Обычным является непрерывное представление массива, как логическое, так и физическое, то есть логический (описанный в программе) массив проецируется на непрерывный участок оперативной памяти. Значит, необходимо, чтобы такой участок существовал. Отсюда вытекают ограничения на размер массива, диктуемые организацией оперативной памяти: массив должен поместиться в сегмент данных программы, размеры которого фиксированы. И, конечно, данные в массивах сохраняются только до конца работы программы.

Таким образом, массив представляет собой структуру данных, определяемую на основе следующих своих свойств:

массив состоит из однотипных элементов, при этом используемый тип называется базовым,

число элементов массива строго фиксировано,

элементы массива упорядочены в том смысле, что каждому из них соответствует один или несколько индексов, позволяющих однозначно указать его расположение в составе структуры,

количество индексов, которое связано с отдельным элементом массива, определяет его размерность,

число элементов массива совпадает с общим количеством возможных значений его индексов,

массив - именованная совокупность данных, причем использование его имени совместно с индексами позволяет определять значения его элементов,

доступ к элементам массива является прямым, то есть любой элемент массива полностью определяется своими индексами и возможности доступа к нему не зависят от других элементов.

Массивы можно определить и через понятия математики.

В современной математике для описания и решения многих задач используются матрицы и вектора.

Матрицей Anm называется таблица чисел, состоящая из n строк и m столбцов.

Каждый элемент матрицы aij полностью определяется своими индексами - номерами строки i и столбца j , в которых он расположен.

Количество индексов определяет размерность матрицы: одномерная (вектор), двумерная, трехмерная и т.д.

Максимальное значение каждого индекса определяет размер матрицы.

В качестве аналога матриц в программировании выступают массивы.

Массив - это упорядоченный набор фиксированного количества однотипных компонентов, имеющих общее имя - имя массива, и различающихся значениями своих индексов. В зависимости от количества индексов компонентов (элементов) массива различают одномерные (вектора), двумерные (матрицы) и т.д. массивы. В Паскале допускаются восьмимерные массивы.

Элементы векторов хранятся в оперативной памяти компьютера в расположенных друг за другом ячейках в том порядке, в котором они размещены в векторе. Таким образом, структура вектора полностью соответствует структуре оперативной памяти компьютера, поэтому остальные структуры данных размещаются в памяти так, как они размещались бы в одномерных массивах.

Двумерный массив состоит из элементов, образующих прямоугольную таблицу, причем первый индекс элемента обозначает номер строки, а второй - номер столбца этой таблицы, на пересечении которых расположен данный элемент:

a11 a12 a13 …

a21 a22 a23 …

a31 a32 a33 … ……………………..

Таким образом, двумерный массив полностью соответствует понятию матрицы. В оперативной памяти элементы двумерного массива расположены последовательно, строка за строкой: сначала элементы первой строки, затем второй и так далее: a11, a12, a13,…, a21, a22, a23,…, a31, a32, a33,… Значит, быстрее изменяется второй индекс (номер столбца), чем первый (номер строки).

Многомерные массивы располагаются в памяти компьютера так, что сначала изменяется последний индекс элемента, затем - предпоследний и так далее.

Массив как структура данных характеризуется тем, что с помощью индексов обеспечивается прямой (непосредственный) доступ к каждому его элементу: чтение или запись любого элемента массива не зависит от того, прочитаны или записаны предшествующие ему элементы.

Тип элементов массива называется его базовым типом. В Паскале это может быть любой стандартный (целый, вещественный, строковый, символьный, логический) или пользовательский (массив записей, файлов, множеств) тип данных.

Индексы элементов массива могут быть не только целыми положительными числами, но и данными любого упорядоченного типа (интервального, перечисляемого, символьного, строкового).

Перед использованием массива в программе его необходимо описать - назвать его имя, указать начальное и конечное значения каждого индекса элементов массива и их базовый тип.

Пусть имеется целочисленный массив A23, состоящий из следующих элементов:

-5 8 0

9 -1 4

Описание массива можно произвести несколькими способами:

а) в разделе описания переменных:

Var A : Array [1..2,1..3] Of Integer;

Описан массив целых чисел А , имеющий две строки с индексами 1 и 2 и три столбца с индексами 1,2,3.

Внимание! Индексы указываются в квадратных скобках, между начальными и конечными значениями индексов ставится по две точки, а между измерениями - запятая.

Внимание! При компиляции программ, использующих массивы, настоятельно рекомендуется использовать директиву компиляции {$R+}. В этом режиме проверяются все индексы массивов на выход за свои границы. При выходе за границы выполнение программы прерывается и выдается сообщение об ошибке:

Error 201: Range check error

б) в разделе определения констант, типов и описания переменных:

Const row = 2;

Col = 3;

Type TMatrix = Array [1..row,1..col] Of Integer;

Var A : TMatrix;

Сначала определены поименованные константы row и col (описаны их имена и заданы конкретные значения), затем определен новый тип данных TMatrix с использованием ранее определенных констант, а в конце описан массив A с использованием ранее определенного типа данных,

в) определением массива как типизированной константы:

Const A : Array [1..2,1..3] Of Integer =((-5,8,0),(9,-1,4));

При этом задаются не только имя, размеры и базовый тип массива, но и конкретное значение его элементов. Эти значения могут изменяться в программе.

Номера строк и столбцов массивов могут быть заданы не только целыми положительными числами, но и символами, отрицательными целыми числами и строками.

Примеры:

Описать массив Doska, позволяющий рассматривать его как модель шахматной доски.

На шахматной доске строки обозначаются латинскими буквами от a до h, а столбцы - цифрами от 1 до 8, а шахматные фигуры - тоже латинскими буквами. Поэтому описание этого массива может выглядеть так:

Var Doska : Array [`a'..'h',1..8] Of Char;

а обращение к элементу этого массива - так:

Doska[`c',2]:='f';

Использование нечисловых индексов элементов массива повышает наглядность программы, делает ее более понятной.

Описать массив Roma, в котором можно было бы хранить данные о количестве жителей Рима с года его основания (754 г. до н.э.) и до 33 г. н.э.

Традиционное описание:

Var Roma : Array [1..787] Of Word;

В этом случае первый элемент массива соответствует году основания Рима:

Roma[1]:=2; в год основания Рима в нем жили два основателя

Roma[787]:=450000; в 33 г. н.э. в Риме проживали 450000 жителей

Тогда какой элемент массива соответствует, например, 639 году до н.э.? Сразу сказать трудно, необходимо вычислить индекс этого элемента.

Таким образом, при традиционном описании этого массива возникают трудности сопоставления индекса элемента с годом.

Опишем массив по-другому, используя отрицательные индексы элементов:

Var Roma : Array [-754..33] Of Word;

В этом случае можно сразу сказать, что 639 году до н.э. соответствует элемент Roma[-639].

3. Описать массив Ozenka, в котором можно было бы хранить оценки студентов Иванова И. и Петрова П. по математике, физике и информатике:

Мат. Физ. Инф.

Иванов И. 4 5 5

Петров П. 3 4 3

Традиционное описание:

Var Ozenka : Array [1..2,1..3] Of Word;

В этом случае по оператору присваивания:

Ozenka[2,1]:=3;

трудно догадаться, что у Петрова П. по математике оценка 3.

Опишем этот массив, введя новые типы данных:

Type Fam = (Ivanov, Petrov);

Predm = (Math, Phis, Inf);

Var Ozenka : Array [Fam, Predm] Of 2..5;

Сейчас можно поставить Петрову П. оценку по математике следующим образом:

Ozenka[Petrov,Math]:=3;

Конечно, такое описание массива повышает наглядность программы.

При решении некоторых задач полезно использовать массивы размерностью более двух, например, трехмерные массивы. Такие массивы представляют собой объемную конструкцию типа куба. Этот куб состоит из нескольких слоев -двумерных массивов. Каждый из них имеет строки и столбцы.

Например, целочисленный массив A размером 3 слоя, по 4 строки и 5 столбцов в каждом слое, можно описать так:

Var a: Array [1..3, 1..4, 1..5] Of Integer;

и представить в следующем виде:

Строки

Строки занимают промежуточное положение между простыми переменными и сложными структурами - массивами, множествами, записями.

Строка - это упорядоченная последовательность символов расширенной таблицы кода ASCII не длиннее 255 символов или массив значений типа Char.

Наличие совокупности элементарных значений (символов) и существование определенных упорядоченных взаимосвязей между ними (в виде последовательности) требует отнести строковый тип к структурированным, например, векторам. Другими словами, строки напоминают одномерные массивы - векторы: к любому элементу строки можно обратиться так же, как к элементу одномерного массива, и выполнять поэлементные действия над ним, предусмотренные для символьного типа данных.

Уникальность величин строкового типа состоит в том, что они выступают и как величины простого, неструктурированного типа, иначе говоря, как единое целое: строки можно сравнивать между собой, вводить с клавиатуры или выводить на экран целиком, использовать в выражениях, они могут быть значениями функций.

В программе величины строкового типа могут фигурировать в виде констант, переменных, а также значений выражений соответствующего типа.

Строки можно описать в операторе Var с указанием их длины:

Var str_1: String; строка длиной 255 символов

str_2: String[25]; строка длиной 25 символов

str_3: String[10]; строка длиной 10 символов

или задать в Const как поименованную константу:

Const my_str='Это строка символов'; записывается в апострофах

klav='qwerty';

Эту же строку можно задать с помощью шестнадцатеричных или десятичных кодов символов таблицы ASCII, причем в этом случае апострофы не ставятся:

Const klav=#113#119#101#114#116#121; десятичные коды символов

Эту же строку можно задать с использованием смещения:

Const klav=^1^7^%^2^4^9; смещения кодов в таблице ASCII

Смещение обозначается знаком карата ^. Рассмотрим таблицу кодов ASCII, для этого выведем ее в текстовый файл следующей программой:

Program Table_ASCII;

Uses CRT;

Const n: String[16] = '0123456789ABCDEF';

s: String = '--+-----------------------------------------------';

Var i, j: Byte;

c: Char;

f: Text;

Begin

ClrScr;

Assign(f, 'D:\User\ASCII.txt');

ReWrite(f);

Write(f, ' | ');

For j:=0 To 15 Do

Write(f, n[j+1],' ');

WriteLn(f);

WriteLn(f, s);

Write(f, '0 | ');

For j:=0 To 15 Do

Begin

If (j In [9,10,13])

Then c:=' '

Else c:=Chr(j);

Write(f, c, ' ');

End;

WriteLn(f);

For i:=1 To 15 Do

Begin

Write(f, n[i+1],' | ');

For j:=0 To 15 Do

Write(f, Chr(i*16+j), ' ');

WriteLn(f);

End;

WriteLn(f, s);

WriteLn(f);

Close(f);

End.

Результат работы программы - кодирование в 16-ричной системе счисления, причем символы первых двух строк на экран вывести нельзя - это управляющие символы:

Таким образом, 16-ричный код цифры ноль - 30, что соответствует ее коду 48 в десятичной системе счисления.

Строки с нулевой по седьмую - это первая, стандартная часть таблицы, где хранятся коды цифр, символов латинского алфавита и некоторых символов клавиатуры. Строки с восьмой по F - это расширенная, национальная часть таблицы, где хранятся коды символов национальных алфавитов.

Рассмотрим стандартную часть таблицы, состоящую из первых восьми строк. Разобьем ее на две половины по четыре строки. Если S - любой символ из верхней половины, то ^S - символ из нижней половины, находящийся в том же столбце, то есть отстоящий на четыре строки, и наоборот.

Например, ^} соответствует = , наоборот ^= соответствует символу }.

Аналогичное правило действует и в расширенной, национальной части таблицы.

При вводе с клавиатуры исходных данных знак карата ^ соответствует нажатию клавиши CTRL, удерживаемой при одновременном нажатии того или иного знака. Этим часто пользуются при вводе символов, отсутствующих на клавиатуре: ^м будет соответствовать символу ¬ (операция отрицания).

Нумерация элементов строки начинается с единицы. Для каждого элемента строки в оперативной памяти выделяется 1 байт. Для хранения текущей длины строки в памяти выделяется дополнительный байт в начале строки (нулевой байт). Длина строки хранится в нем в виде ASCII-символа, порядковый номер которого и определяет ее длину. Например, Ord(my_str[0])=19 - в ней 19 символов, включая пробелы.

В программе строки можно задать операторами присваивания:

srt_1 := `Это первая строка'; записывается в апострофах

srt_2 := `Это вторая строка';

или ввести с клавиатуры целиком, указывая имя строки:

ReadLn(str_1); вводится без апострофов

Если длина задаваемой строки меньше длины, указанной в ее описании, то остальные элементы строки не заполняются, а если больше - то лишние элементы отбрасываются.

Строки можно выводить на экран целиком, указывая имя строки:

WriteLn(str_1);

Помимо присваивания, ввода и вывода, над строками определены следующие операции:

1. сложение (конкатенация) строк:

str_1 :='Turbo';

str_2 := ` Pascal';

str_3 := str_1 + str_2; в str_3 будет фраза Turbo Pascal

2. сравнение строк - осуществляется операциями отношения >, >=, <, <=, =, <> посимвольно слева направо до первого несовпадающего символа - сравниваются коды символов строк. Большей считается та строка, у которой код этого символа больше:

`Vova' > `Vasja' = True так как Ord(`o') > Ord(`a')

Для работы со строками определены следующие функции:

1. Length(строка) - текущая длина строки - количество символов в ней (целое число):

str_1 :='Turbo';

n := Length(str_1); n=5 - в строке 5 символов

2. Pos(строка_1, строка_2) - определение положения строки_1 в строке_2 (положение - номер символа - целое число):

str_1 :='ша';

str_2 :='Наша Маша шагает в шапке';

n := Pos(str_1, str_2); n=3 - определяется первое вхождение str_1 в str_2, а это позиция с номером 3 во второй строке

Внимание! Если искомая строка не найдена, то результат равен нулю.

3. Copy(строка, номер символа, длина фрагмента) - копирование фрагмента заданной длины, начиная с заданного номера символа строки; получается новая строка:

str_1 :='браконьер';

str_2:=Copy(str_1, 2, 3); из строки браконьер, начиная со второй буквы, копируется фрагмент длиной 3 символа; получается str_2='рак'

4. Concat(строка_1, строка_2, строка_3, ...) - конкатенация (сложение) строк; получается новая строка:

str_1 :='Turbo';

str_2 := ` Pascal';

str_3 := Concat(str_1, str_2); в str_3 будет фраза Turbo Pascal

Внимание! Длина суммарной строки не должна превышать 255 символов.

Для работы со строками определены следующие процедуры:

1. Delete(строка, номер символа, длина фрагмента) - удаление из строки фрагмента заданной длины, начиная с заданного номера символа строки; получается новая строка_1:

str_1 :='коробочка';

Delete(str_1, 4, 2); из строки коробочка, начиная с четвертой буквы, удаляется фрагмент длиной 2 символа; получается str_1='корочка'

2. Insert(строка_1, строка_2, номер символа) - вставка строки_1 в строку_2, начиная с заданного номера символа; получается новая строка_2:

str_1 :='сор';

str_2 :='мука';

Insert(str_1, str_2, 3); в строку мука, начиная от третьей буквы, вставляется строка сор; получается str_2='мусорка'

Паскаль позволяет преобразовывать данные числового типа в строку символов, а также преобразовывать строку в число, если она содержит последовательность символов, удовлетворяющую правилам записи чисел. Для этого используются две процедуры:

1. Str(число, строка) - преобразование числового значения величины число в строку:

x:= 3.14;

Str(x, str_1); строка str_1 примет значение `3.14'

2. Val(строка, число, код) - преобразование значения строки в величину целого или вещественного типа число. Если во время операции преобразования ошибки не обнаружено, то значение кода равно нулю. Если же обнаружена ошибка (строка не переводится в число), то код будет содержать номер позиции ошибочного символа, а значение числа не определено:

str_1 := `3.14';

Val(str_1, x, n); строка str_1 преобразуется в число x=3.14,

n = 0 (ошибок нет)

str_1 := `3,14';

Val(str_1, x, n); строка str_1 не будет преобразована в число,

n = 2 (второй символ - запятая - ошибочен), x не определен

Использование этой функции позволяет избежать неприятной ошибки выполнения Invalid numeric format, возникающей при неправильном вводе числовых данных, при появлении которой программа заканчивает работу. Если же вводить число в виде строки, а потом преобразовывать ее в число, используя процедуру Val, то даже при некорректном вводе можно будет продолжать работу, анализируя значение кода ошибки и повторив ввод.

С остальными структурами данных - множествами, записями и файлами - мы познакомимся после изучения базовых структур алгоритмических языков, позволяющих осуществлять обработку данных по сложным алгоритмам.

Алгоритм и его свойства

Алгоритм - это последовательность предписаний (команд), точное выполнение которых приводит к решению поставленной задачи.

Правильно построенные алгоритмы должны обладать следующими свойствами:

дискретность - алгоритм разбит на отдельные элементарные этапы (шаги), возможность выполнения которых не вызывает сомнений,

однозначность - команды, входящие в алгоритм, должны быть точными и понятными, порядок их выполнения должен быть единственно возможным, любая неопределенность или двусмысленность недопустима,

детерминированность - повтор результатов при повторе исходных данных,

результативность - алгоритм должен приводить к результату за конечное число шагов,

массовость - алгоритм должен быть пригоден для решения всех задач данного класса.

Схемы алгоритмов

Любой алгоритм можно представить или записать тремя способами:

словесным (вербальным) - с использованием слов и предложений,

табличным (аналитическим) - с помощью формул и таблиц,

графическим - с помощью рисунков, геометрических фигур и символов.

Самым наглядным из них является графический способ - представление алгоритма схемой.

Схема алгоритма - это графическое изображение его структуры, отдельных составных частей и взаимосвязей между ними.

Схема алгоритма представляет собой совокупность специальных символов (блоков), соединенных между собой стрелками, которые указывают последовательность выполнения алгоритма. Внутри каждого блока может быть записан его номер и краткое содержание исполняемых им функций (операций).

Правила выполнения схем алгоритмов устанавливает Единая система программной документации (ЕСПД), в которую входят:

ГОСТ 19002-80 “Схемы алгоритмов и программ. Правила выполнения”

ГОСТ 19003-80 “Схемы алгоритмов и программ. Обозначения условные графические”

Перечень, наименование, обозначение и размеры наиболее употребляемых символов и отображаемых ими функций:

процесс - выполнение операции или группы операций, в результате которых изменяется значение, форма представления или расположение данных,



Для построения удобных в работе схем алгоритмов необходимо руководствоваться следующими правилами:

каждая схема должна иметь точку начала и точку конца,

от точки начала блоки располагаются сверху вниз и слева направо,

направление линий потока сверху вниз и слева направо принимается за основное и, если линия потока не имеет излома, то стрелками ее можно не обозначать,

расстояние между параллельными линиями потока должно быть не менее 3 мм, между остальными линями схемы - не менее 5 мм,

количество входящих в блок линий потока не ограничивается, но выходить из него может только одна линия (исключение - блок решения, из которого всегда выходят две линии),

запись в блоках должна быть словесной или математической, а не в виде операторов конкретного алгоритмического языка: нужно показать, что делается в блоке, а не как это делается,

записи внутри блоков должны быть расположены так, чтобы их можно было читать слева направо и сверху вниз независимо от направления линий потока,

схема должна читаться без дополнительных пояснений автора,

используемые в некотором блоке переменные должны получать конкретные значения в предыдущих или в том же блоке,

входные и выходные блоки подпрограмм должны содержать перечень соответственно входных и выходных параметров,

блоки можно объединять в более крупные пунктирными линиями, при этом необходимо описать назначение объединенных блоков,

над левой частью блоков ставятся метки, которыми в программе будут помечены операторы, описанные в данном блоке, а в разрыве верхней левой линии ставится номер блока.

Базовые структуры

Преимущество компьютеров и в то же время трудность их использования состоит в том, что они без труда выполняют операции, которые весьма трудоемки или практически невыполнимы людьми, и наоборот, действия, которые нам кажутся столь очевидными, что мы и не пытаемся их анализировать, зачастую становятся проблемой, когда предпринимается попытка их запрограммировать. Внешне заманчивая возможность, предписав одним росчерком пера выполнение тысяч элементарных действий, ставит трудную задачу понимания сложности, проблему, для решения которой необходимо вооружить себя определенными средствами. Такие средства алгоритмизации и программирования носят название базовых (управляющих) структур.

Как всякое автоматическое устройство, компьютер способен выполнять некоторое число элементарных операций: сложение, вычитание, сравнение, запись и чтение данных. Причем он обладает способностью самостоятельно управлять выполнением этих операций во времени. Если попытаться явно выразить возможности этого управления, то можно выделить три основные (базовые) управляющие структуры : цепочка (следование), ветвление, цикл. Эти комбинируемые по желанию структуры дают нам конструктор, позволяющий описать процесс вычислений произвольной сложности и полностью контролировать действия, предписываемые программой.

Практика разработки алгоритмов показывает, что в отдельных случаях одна и та же задача может быть успешно решена по алгоритмам, имеющим различную структуру. Главное требование к алгоритму заключается в том, чтобы он правильно решал поставленную задачу. Для удовлетворения этого требования алгоритм должен быть легким для понимания, простым для доказательства его правильности и удобным для модификации.

Опыт практической алгоритмизации привел к формированию особой методики организации алгоритмов, использование которой уменьшает вероятность ошибок в процессе их разработки и записи, упрощает их понимание и модификацию. Эту методику алгоритмизации называют структурным программированием.

При структурном программировании алгоритм как бы собирается из трех базовых структур, каждая из которых имеет один вход и один выход - цепочек, ветвлений и циклов. С помощью этих структур можно построить алгоритмы любой сложности, подсоединяя одну структуру к другой и развивая алгоритм не только вширь, но и вглубь. Конструируемые по этой методике алгоритмы четки и понятны, легко поддаются проверке, так как состоят из ограниченного числа одинаково устроенных блоков.

Для использования методики структурного программирования при словесной записи алгоритмов необходимо, чтобы такая запись располагала специальными средствами, адекватно реализующими базовые структуры. Если таких средств в том или ином алгоритмическом языке нет, то для облегчения последующей работы по переводу алгоритма в программу (кодирования) необходимо отработать языковые шаблоны, эквивалентно представляющие базовые структуры.

Таким образом, в соответствии с принципами структурного программирования любой алгоритм можно представить, используя только три базовые структуры - цепочку, ветвление, цикл.

Цепочка

Самой простой базовой структурой является цепочка - последовательность операторов присваивания.

Цепочку можно представить следующей схемой:

Основное свойство цепочки - очередной оператор цепочки будет выполнен после выполнения всех предыдущих операторов, то есть все операторы цепочки выполняются последовательно друг за другом.



Алгоритм циклического обмена в этом случае будет выглядеть следующим образом:

Переменные a и b обмениваются своими значениями через переменную x.

По этому алгоритму можно написать последовательность операторов на Паскале:

Ветвления

Одним из достоинств компьютеров является их способность делать выбор пути решения задачи в зависимости от выполнения заданных условий.

Выбор пути решения осуществляется в алгоритмических языках ветвлениями, которые могут быть представлены в двух формах:

альтернатива,

переключатель.

Альтернатива

Альтернатива является простейшей формой ветвлений. Она предполагает выбор одного из двух путей решения задачи, причем этот выбор зависит от выполнения заданных условий:

Альтернативу можно описать словесно:

ЕСЛИ (условие)

ТО цепочка-1

ИНАЧЕ цепочка-2

В альтернативе может отсутствовать часть (ветвь) ИНАЧЕ, тогда она приобретает вид усеченной альтернативы:

ЕСЛИ (условие)

ТО цепочка-1

В альтернативе в качестве условия используется логическое выражение, которое, как известно, может быть истинным или ложным.

Действие альтернативы:

проверяется выполнение условия,

если условие истинно, то выполняется следующая за ним цепочка-1, а цепочка-2, если она имеется, не выполняется,

если условие ложно, то выполняется цепочка-2, если она имеется.

В Паскале альтернатива реализуется условным оператором:

If (условие)

Then оператор-1

Else оператор-2;

где условие - это любое логическое выражение.

После ключевых слов Then и Else в Паскале может следовать только один оператор языка, причем перед Else точка с запятой не ставится.

Примеры:

1. определить значения переменной z после выполнения операторов:

x := 1;

z := 3;

If (x - z > 0) в данном случае условие ложно, поэтому

Then z := z - 1 будет выполняться ветвь Else, и, значит,

Else z := z + 1; z = 4

определить наибольшую из двух переменных a и b, присвоив ее значение переменной с:

да нет

Словесное описание алгоритма:

ЕСЛИ (a > b)

ТО c = a

ИНАЧЕ c = b;

Реализуем этот алгоритм на Паскале:

If (a > b)

Then c: = a

Else c: = b;

3. решить эту же задачу сокращенной альтернативой:

а) двумя сокращенными альтернативами:

If (a > b)

Then c := a;

If (b > a)

Then c := b;

б) одной сокращенной альтернативой:



c := b;

If (a > b) Then c := a;

Реализация альтернативы усложняется, если в каждой ее ветви имеется не по одному оператору, а по цепочке операторов. В этом случае цепочки заключаются в операторные скобки: BEGIN … END. Получается составной оператор:



1/c, если c ? 2,5

На Паскале:

If (c < 2.5) Внимание! Перед служебными словами

Then Then и Else , а также после них точка с

Begin запятой не ставятся!

a:=Sin(c);

b:=Abs(c) Перед End точку с запятой можно не ставить!

End

Else

Begin

a:=Cos(c);

b:=1.0/c

End;

В условном операторе If после слов Then и Else могут в свою очередь следовать новые операторы If , что дает возможность использовать вложение операторов If до любого уровня:

Примеры:

1. определить наибольшую из трех переменных x, y, z и присвоить ее значение переменной s:



а) с использованием полной альтернативы:

ЕСЛИ (x > y) If (x > y)

ТО ЕСЛИ (x > z) Then If (x > z)

ТО s = x Then s:=x

ИНАЧЕ s = z Else s:=z

ИНАЧЕ ЕСЛИ (y > z) Else If (y > z)

ТО s = y Then s:=y

ИНАЧЕ s = z; Else s:=z;

Внимание! В этом вложенном операторе точка с запятой только одна - в конце всего оператора.

б) с использованием усеченной альтернативы: вариант 1

s = z; s := z;

ЕСЛИ (x > y) If (x > y)

ТО ЕСЛИ (x > z) Then If (x > z)

ТО s = x; Then s:=x;

ЕСЛИ (y > x) If (y >x)

ТО ЕСЛИ (y > z) Then If (y > z)

ТО s = y; Then s:=y

вариант 2 - с использованием операции конъюнкция

s = z; s := z;

ЕСЛИ (x > y) & (x > z) If (x > y) And (x > z)

ТО s = x; Then s:=x;

ЕСЛИ (y > x) & (y > z) If (y >x) And (y > z)

ТО s = y; Then s:=y;

По принятому в Паскале соглашению, Else всегда относится к ближайшему предшествующему ему незанятому If:

If (n>0)

Then If (m Mod n > n)

Then m := m - n

Else m := m + n

Else m := m Mod n;

В данном случае ветвь Else m := m + n относится к If (m Mod n > n), а ветвь Else m := m Mod n относится к If (n > 0).

Часто встречающиеся ошибки программирования:

1. Использование в качестве условия выражения не логического типа:

If (n + m)

Then . . .

2. Использование Else без Then:

If (n > m)

Else . . .

3. Использование в операторных скобках, стоящих после Else или Then, слова Begin без End или наоборот:

If (n > m)

Then

Begin

a:=1;

b:=0;

Else . . .

4. Использование точки с запятой перед словами Else или Then:

If (n > m);

Then a:=1;

Else a:=0;

5. При использовании в условии логических операций операнды не заключаются в скобки:

If n > m And n <= k

Then . . .

6. Использование лишних проверок условий:

If (n > m)

Then a:=1

Else If (n <= m)

Then a:=0

Else a:=2;

Пример

Задан график функции f(x) - полуокружность радиуса R=1:

Определить:

Значение функции y при заданном значении аргумента x.

Площади фигур слева и справа от линии разреза.

По теореме Пифагора:

Площадь фигуры слева от линии разреза определяется суммой площадей прямоугольного треугольника:

s1 = 0,5 x y

и сегмента: s2 = 0,5 R2 (б - sin б), где б - центральный угол в радианах,

причем б = arcsin(y/R).



Площадь всей фигуры (полукруга) определяется выражением:

S = р R2/2.

Программа решения задачи:

Program Primer;

Uses CRT;

Var x, y, s_left, s_right, alfa, sin_alfa, segment : Real;

Begin

ClrScr;

Write(`x=');

ReadLn(x);

If (x<=1.0) Then первый участок

Begin

y:=Sqrt(1.0 - (x - 1.0 ) * (x - 1.0 ));

If (x<=0.0)

Then y:=0.0;

End

Else

Begin второй участок

y:=Sqrt(1.0 - (x- Trunc(x)) * (x- Trunc(x)));

If (x>=2.0)

Then y:=0.0;

End;

If (x=1.0) Then

Begin

s_left:=0.7854;

s_right:=0.7854;

End;

If (x<1.0) Then первый участок

Begin

sin_alfa:=y;

If (sin_alfa<>1.0)

Then alfa:=Arctan(sin_alfa/Sqrt(1.0 - sin_alfa*sin_alfa))

Else alfa:=Pi/2.0;

segment:=0.5*(alfa - sin_alfa);

s_left:=segment + 0.5*x*y;

s_right:=Pi/2.0 - s_left;

End; x<=1.0

If (x>1.0) Then второй участок

Begin

x:=2.0-x;

sin_alfa:=y;

If (sin_alfa<>1.0)

Then alfa:=Arctan(sin_alfa/Sqrt(1.0 - sin_alfa*sin_alfa))

Else alfa:=Pi/2.0;

segment:=0.5*(alfa - sin_alfa);

s_right:=segment + 0.5*x*y;

s_left:=Pi/2.0 - s_right;

End; x>=1.0

WriteLn(`y=', y:6:4);

WriteLn(`s_left=', s_left:6:4);

WriteLn(`s_right=', s_right:6:4);

End.

Переключатель

Часто приходится делать выбор не между двумя, а между несколькими путями решения задачи.



Такую ситуацию называют переключателем.

Структура переключателя предусматривает выполнение i-ой цепочки операторов, если селектор принимает значение-i.

В Паскале переключатель реализуется оператором выбора:

Case (селектор) Of

значение-1: оператор-1;

значение-2: оператор-2;

значение-3: оператор-3;

значение-n: оператор-n;

Else оператор-n+1;

End;

где Case - служебное слово “вариант”,

селектор - переменная или выражение любого порядкового или перечисляемого типа,

значение-1, значение-2,… - метки вариантов - конкретные значения или диапазоны значений селектора,

Else - служебное слово “иначе” (не обязательно).

Внимание! Перед словом Else можно ставить точку с запятой.

Действия оператора:

вычисляется значение селектора,

среди меток вариантов отыскивается это значение,

выполняется оператор, стоящий за найденной меткой,

осуществляется выход из переключателя,

если вычисленное значение селектора не найдено среди меток вариантов, то выполняется оператор, стоящий после слова Else, если оно есть.

Внимание! Переключатель всегда заканчивается служебным словом End, причем слова Begin для него нет.

Пример: чему будут равны значения переменных k и d после выполнения следующих операторов:

d := 5;

k := 4;

Case (k Mod d ) Of

2,3,5..8: d := k; метки вариантов могут перечисляться через запятую

1: ; это пустой оператор - программа ничего не выполняет

4,9: Begin если в одной ветви переключателя несколько операторов,

k := 0; то они заключаются в операторные скобки

d := 2;

End; перед Else ставится точка с запятой

Else d := 1; если значение селектора не совпадает ни с одной из меток

End;

В этом случае значение селектора 4 Mod 5 = 4 , поэтому переходим на ветвь с меткой варианта, равной 4, отсюда k = 0 и d = 2.

Таким образом,

в каждой ветви могут стоять по нескольку меток вариантов, разделенных запятыми: 2,3,

можно использовать интервалы данных: 5..8

в качестве оператора можно использовать пустой оператор

если после метки вариантов следует несколько операторов, то необходимо заключать в операторные скобки Begin…End

метки вариантов не должны повторяться.

Пример: написать программу с использованием переключателя, которая по введенному номеру месяца определяет количество дней в нем.

В данном случае у переключателя будут три ветви:

для месяцев с 30 днями

для месяцев с 31 днем

для месяца с 28 днями (вариант високосного года рассматривать не будем).

Program Mesjac;

Uses Crt;

Var Month: 1..12;

Begin

ClrScr;

Write(`Введите номер месяца:');

ReadLn(Month);

Case (Month) Of

4,6,9,11: WriteLn('30 дней');

1,3,5,7,8,10,12: WriteLn('31 день');

2: WriteLn('28 дней');

Else WriteLn(`Такого месяца нет');

End;

ReadLn;

End.

Часто встречающиеся ошибки программирования:

1. Использование в качестве селектора выражения логического типа:

Case (n > m) Of. . .

2. Использование в качестве селектора выражения вещественного типа:

Case (n + 2.5) Of. . .

3. Использование в качестве меток вещественных чисел:

Case (n + m) Of

0.5 : n:=1;

1.5 : n:=2;

Else n:=3;

End;

4. Использование двоеточия или точки с запятой после слова Of:

Case (n + m) Of:. . . . . . . . .

5. Повторение меток:

Case (n + m) Of

0..3 : n:=1;

3, 4 : n:=2;

Else n:=3;

End;

6. Отсутствие в конце оператора слова End:

Case (n + m) Of

0..2 : n:=1;

3, 4 : n:=2;

Else n:=3;

7. Отсутствие точки с запятой в конце каждой ветви переключателя:

Case (n + m) Of

0..3 : n:=1

3, 4 : n:=2;

Else n:=3;

End;

Внимание! Перед веткой Else точка с запятой может ставиться, а может и не ставиться.

8. При задании меток интервалом используются не две, а три точки:

Case (n + m) Of

0...3 : n:=1;

3, 4 : n:=2

Else n:=3;

End;

Внимание! Перед словом End точка с запятой может ставиться, а может и не ставиться.

9. При перечислении меток используются не запятые, а точки с запятой:

Case (n + m) Of

0...3 : n:=1;

3; 4 : n:=2

Else n:=3;

End;

Циклы

Одним из самых ценных свойств компьютеров является их способность многократно повторять последовательность одинаковых или похожих действий - циклов. Являясь наиболее мощными структурами алгоритмических языков, циклы подразделяются на:

бесконечные циклы,

циклы с предусловием (циклы типа ПОКА),

циклы с постусловием (циклы типа ДО),

циклы с параметром (циклы типа ДЛЯ).



Бесконечные циклы

Бесконечный цикл может быть представлен следующей схемой:

i :=0;

5: i := i + 1; эти три оператора образуют бесконечный цикл

i := i -1;

GoTo 5;

Как правило, появление в программе бесконечных циклов вызвано логическими ошибками, допущенными программистом при разработке алгоритма и кодировании (написании операторов программы) и использовании оператора безусловного перехода GoTo. Поэтому в современных алгоритмических языках этот оператор практически не используется, а заменяется циклами. Бесконечные циклы не выявляются транслятором при синтаксическом контроле и проявляются только после запуска программы на выполнение следующим образом:

длительное время (десятки секунд) программа не выводит на устройство вывода никакой информации - программа зависает,

на устройство вывода постоянно выводится одна и та же информация.

Таким образом, бесконечные циклы - это логические ошибки программиста. С ними встречается любой программист, и поэтому необходимо овладеть методами их поиска.



Циклы с предусловием

Как правило, некоторую цепочку операторов необходимо повторять не бесконечно, а до тех пор, пока выполняется некоторое условие:

ПОКА (условие) ВЫПОЛНЯТЬ

цепочка;

Такой цикл называется циклом с предусловием (циклом ПОКА) и изображается следующей схемой:

Условие - это логическое выражение, зависящее от переменных, входящих в цепочку. Цикл повторяется до тех пор, пока условие истинно. Значит, данное условие является условием продолжения цикла. Выполнение цикла заканчивается, если операторы цепочки изменяют значения переменных, входящих в условие, и оно становится ложным.

Цикл не выполняется ни разу, если условие было ложным с самого начала.

Цикл ПОКА превращается в бесконечный, если условие подобрано так, что оно всегда истинно.

В Паскале цикл с предусловием реализуется оператором цикла While:

While (условие) Do

оператор;

или

While (условие) Do

Begin

оператор;

оператор;

оператор;…

End;

Операторы, находящиеся между Begin и End, называются телом цикла.

Внимание! После слова Do точка с запятой не ставится!

Если поставить точку с запятой после слова Do, то этот цикл, как правило, превращается в бесконечный, потому что в этом случае условие изменяться не будет.

Операторные скобки Begin … End используются в том случае, если после слова Do должна следовать цепочка операторов.

Действия оператора While:

проверяется выполнение условия,

если оно истинно, то выполняется оператор (цепочка), стоящий после Do,

после его выполнения снова проверяется условие, и если оно снова истинно, то цикл повторяется,

если условие становится ложным, то цикл заканчивает работу.

Примеры:

вычислить сумму ста первых натуральных чисел:

s = 1 + 2 + 3 + … + 98 + 99 + 100

Пусть s - искомая сумма,

i - очередное число (изменяется от 1 до 100).

Тогда алгоритм решения задачи можно описать следующим образом:

обнуляем сумму s - в ней ничего нет,

берем первое число: i = 1,

добавляем в сумму очередное число, пока оно не достигнет 100.

Представим этот алгоритм так:

s = 0;

i = 1;

ПОКА (i ? 100) ВЫПОЛНЯТЬ

НАЧАЛО

s = s + i;

i = i + 1;

КОНЕЦ;

Программа:

Program Gauss;

Uses CRT;

Var i, s : Word;

Begin

ClrScr;

s := 0;

i := 1;

While (i <= 100) Do

Begin

s := s + i;

i := i + 1;

End;

WriteLn(`s = `, s);

ReadLn;

End.

вычислить сумму s всех цифр заданного натурального числа n

Пусть s - искомая сумма,

i - очередная цифра числа.

Тогда алгоритм решения задачи можно описать следующим образом:

обнуляем сумму s,

берем последнюю цифру числа, для чего определяем остаток от деления исходного числа на 10: i = n Mod 10,

добавляем в сумму найденную цифру: s = s + i,

уменьшаем число в 10 раз: n = n Div 10,

повторяем цикл до тех пор, пока n > 0 - это и будет условием продолжения цикла.



Схема алгоритма: Программа:

Program Sum;

Uses CRT;

Var i, s, n : Word;

Begin

ClrScr;

Write(`n=`);

ReadLn(n);

s := 0;

While (n > 0) Do

Begin

i := n Mod 10;

s := s + i;

n := n Div 10;

End;

WriteLn(`s = `, s);

ReadLn;

End.

ввести с клавиатуры по одному последовательность целых чисел (конец последовательности - число 0). Определить их сумму, максимальное и минимальное число, количество введенных чисел и их среднее арифметическое.

Пусть s - искомая сумма,

min, max - минимальное и максимальное из введенных чисел,

count - количество введенных чисел,

sred - среднее арифметическое,

n - очередное число.

Тогда алгоритм решения задачи можно описать следующим образом:

обнуляем сумму s ,

вводим первое число n,

если оно не равно нулю, то

принимаем его значение за min и max

количество введенных чисел count = 1

увеличиваем сумму на введенное число s = s + n

входим в цикл ввода:

вводим очередное число n,

если оно не равно нулю, то

количество введенных чисел увеличиваем на 1: count = count+1

увеличиваем сумму на введенное число s = s + n

если оно меньше min, то min = n,

если оно больше max, то max = n,

повторяем цикл до тех пор, пока n # 0 - это и будет условием продолжения цикла.

Создадим интерфейс этой задачи - взаимодействие программы с пользователем, то есть что должно выводиться на экран:

Первое число: 3

Очередное число: 8

Очередное число: 1

Очередное число: -2

Очередное число: 0

Сумма = 10

Количество чисел = 4

Min = -2

Max = 8

Среднее арифметическое = 2.50

Схема алгоритма:



Программа

Program Posled;

Uses CRT;

Var n, min, max, s, count: Word;

sred: Real;

Begin

ClrScr;

s := 0;

Write(`Первое число:');

ReadLn(n);

If (n = 0)

Then Exit;

min := n;

max := n;

count := 1;

s := s + n;

While (n <> 0) Do

Begin

Write(`Oчередное число:');

ReadLn(n);

If (n <> 0) Then

Begin

count := count + 1;

s := s + n;

If (n > max)

Then max := n;

If (n < min)

Then min := n;

End; {If (n <> 0)}

End; {While}

sred := s / count;

WriteLn;

WriteLn(`Сумма =',s);

WriteLn(`Количество чисел =',count);

WriteLn(`min=',min);

WriteLn(`max=',max);

WriteLn(`Среднее арифметическое =',sred:5:2);

ReadLn;

End.

Часто встречающиеся ошибки программирования:

1. Использование в качестве условия выражения не логического типа:

While (n + m) Do. . .

2. Отсутствие в заголовке цикла слова Do:

While (n < 10). . .

3. Использование после слова Do точки с запятой, которая, как правило, приводит к появлению бесконечного цикла:

s:=0;

n:=1;

While (n < 10) Do;

Begin

s := s + n;

n := n + 1;

End;

Циклы с постусловием

У циклов с постусловием (циклов типа ДО) проверка условия окончания цикла производится после выполнения операторов, составляющих тело цикла:



ПОВТОРЯТЬ

цепочка

ДО (условие);

Такой цикл повторяется до тех пор, пока условие ложно. Выполнение цикла заканчивается, если операторы цепочки изменяют значения переменных, входящих в условие, и оно становится истинным.

В любом случае этот цикл выполняется хотя бы один раз. Цикл с постусловием превращается в бесконечный, если условие подобрано так, что оно всегда ложно.

Таким образом, условие в данном цикле является условием его окончания, а не продолжения, как в цикле с предусловием.

В Паскале цикл с постусловием реализован оператором цикла Repeat:

Repeat

цепочка

Until (условие);

где Repeat - служебное слово повторять,

Until - служебное слово до.

Внимание! После слова Repeat точка с запятой не ставится!

Перед словом Until точку с запятой можно не ставить.

В отличие от цикла с предусловием, в цикле с постусловием не требуется использование операторных скобок Begin … End.

Действия оператора Repeat:

выполняется оператор (цепочка),

проверяется выполнение условия, стоящего после слова Until,

если оно ложно, то цикл повторяется,

если условие становится истинным, то цикл заканчивает работу.

Примеры:

вычислить сумму ста первых натуральных чисел:

s = 1 + 2 + 3 + … + 98 + 99 + 100

Пусть s - искомая сумма,

i - очередное число (изменяется от 1 до 100).

Тогда алгоритм решения задачи можно описать следующим образом:

обнуляем сумму s ,

берем первое число: i = 1,

добавляем в сумму очередное число, пока оно не достигнет 100.

Представим этот алгоритм так:

s = 0;

i = 1;

ПОВТОРЯТЬ

s = s + i;

i = i + 1;

ДО (i > 100);



Программа:

Program Gauss;

Uses CRT;

Var i, s : Word;

Begin

ClrScr;

s := 0;

i := 1;

Repeat

s := s + i;

i := i + 1;

Until (i>100);

WriteLn(`s = `, s);

ReadLn;

End.

вычислить сумму s всех цифр заданного натурального числа n

...