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

1)Пусть требуется найти максимальный элемент в одномерном массиве Х, состоящем из 12 элементов. 
Возможное решение:
var                                 {в разделе var определяются переменные:}
x: array[1..12] of real; {так определяем массив Х из 12 элементов типа real}
i: integer;                      {описываем переменную целого типа - i, понадобится для цикла}
y: real;                           {y - сюда запишем найденный максимальный элемент массива}
begin
    {Следующие 6 строк - обслуживание ввода массива Х пользователем:}
writeln('input values of X:'); {пишем "input values of X" (рус.: "введите значения Х") }
for i:=1 to 12 do                     {цикл по i от 1 до 12}
begin                                       {начало тела цикла}
write(' x(',i,')=');                     {пишем подсказку пользователю: какой элемент Х надо ввести}
readln(x[i]);                            {считываем введенное значение i-го элемента массива X, т.е. x[i] }
end;                                         {конец тела цикла}
    {собственно вот оно решение - следующие три строчки!}
y:=x[1];                                     {пусть x[1] -максимальный элемент массива; присвоим y:=x[1];}
for i:=2 to 12 do                        {цикл по i от 2 до12, а в цикле-}
if x[i]>y then y:=x[i];                {проверка: если текущий элемент X[i] больше Y, то y:=x[i];}
writeln(' maximal X=',y:1:2);   {после выполнения цикла пишем на экран ответ}
end.                                             {конец программы}

2)Пусть требуется найти минимальный элемент и его индексы в матрице (двухмерном массиве) Х из трех строк и четырех столбцов.
Возможное решение:
var {в разделе var определяются переменные:}
x: array[1..3,1..4] of real; {двухмерный массив Х 3 на 4 элемента типа real}
i,j, ii, jj: integer;                 {i,j -для организации цикла, ii,jj -индексы min элемента}
y: real;                                {y - сюда запишем найденный min элемент массива}
begin
    {Следующие 10 строк - обслуживание ввода массива Х пользователем:}
writeln('input values of X:');
for i:=1 to 3 do
begin
for j:=1 to 4 do
begin
write(' x(',i,',',j,')=');
read(x[i,j]);
end;                    {j}
writeln;
end;                    {i}
    {а вот и решение - следующие 9 строк!}
y:=x[1,1]; ii:=1; jj:=1;    {пусть min элемент стоит в первой строке, первом столбце}
for i:=1 to 3 do               {цикл по строкам}
for j:=1 to 4 do               {... и по столбцам}
if x[i,j]<y then                {и если текущий элемент массива x[i,j] меньше Y, то}
begin                              {открываем блок операторов, в которых}
y:=x[i,j];                         {корректируем текущие значения Y}
ii:=i; jj:=j;                       { и индексов ii и jj}
end;                                 {конец условного блока if}
writeln(' Minimal x(',ii,',',jj,')=',x[ii,jj]:1:2);    {выводим ответ на экран}
end.

3)Пусть требуется упорядочить по возрастанию одномерный массив Х, состоящий из 12 элементов. 
Возможное решение:
var                                         {описываем переменные}
x: array[1..12] of real;
i,j: integer;
y: real;
begin
writeln('input values of X:'); {вводим элементы массива}
for i:=1 to 12 do
begin
write(' x(',i,')=');
readln(x[i]);
end;
    {далее - собственно решение, правда, не рациональное, но простое:}
for j:=1 to 11 do      {делаем 11 переборок всего массива}
for i:=1 to 11 do      {а в каждой переборке - сравниваем}
if x[i]>x[i+1] then    { x[i] с последующим x[i+1], и если x[i]>x[i+1], }
begin                        {то меняем их значения местами:}
y:=x[i];                     {копируем значение x[i] в буферную переменную Y}
x[i]:=x[i+1];             {присваиваем x[i]:=x[i+1]}
x[i+1]:=y;                 {и значение x[i] из буферной Y присваиваем x[i+1]-му элементу}
end;                          {конец блока if}
    {пишем результат на экран:}
writeln('***********result:*********');
for i:=1 to 12 do
writeln(' x(',i,')=',x[i]:1:2);
end.

Что нерационального в приведенной выше программе? Конечно же принудительная переборка всего массива 11 раз.
Сделаем так, чтобы переборка повторялась только в том случае, если на предыдущем шаге были сделаны перестановки. Возможное решение:
var
x: array[1..12] of real;
i,j: integer;
y: real;
begin
writeln('input values of X:');
for i:=1 to 12 do
begin
write(' x(',i,')=');
readln(x[i]);
end;
repeat           {будем повторять переборку элементов... }
j:=0;
for i:=1 to 11 do
if x[i]>x[i+1] then
begin
j:=1;              {j=1 - флаг, указывает на то, что перестановки были сделаны}
y:=x[i];
x[i]:=x[i+1];
x[i+1]:=y;
end {if}
until j=0;       {...повторять до тех пор, пока на предыдущем шаге были сделаны перестановки}
writeln('***********result:*********');
for i:=1 to 12 do
writeln(' x(',i,')=',x[i]:1:2);
end.

                                << ранее            к оглавлению            далее>>

                      то же на С                        то же на Basic                 то же на Fortran