Nickolay.info. Обучение. Учебник по Паскалю. Глава 16

Часть 2. Элементы профессионального программирования на Паскале

 

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

16. Кратные циклы

 

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

16.1. Двойной цикл и типовые задачи на двойной цикл

 

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

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

Поясним сказанное на примере. В конструкции, описанной ниже:

for i:=1 to 5 do begin

 {начало внешнего цикла}

 j:=-5;

 while j<=5+1e-6 do begin  

  {начало внутреннего цикла}

  {тело двойного цикла}

  j:=j+0.5;

 end; {конец внутреннего цикла}

end; {конец внешнего цикла}

при i=1 переменная j последовательно принимает значения -5, -4.5, ... , 5, затем процесс повторится при i=2, 3, 4 и 5. Таким образом, за время выполнения каждого шага внешнего цикла for внутренний цикл while выполнится 21 раз.

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

1. Для функции двух переменных f(x,y) = sin 2x + cos 4y построить таблицу ее значений при значениях аргументов x и y, меняющихся от 0 до 2 с шагом, равным 0.25.

Решение задачи возможно, как минимум, в трех вариантах. Они схематично изображены на рис. 16.1.

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

 

Рис. 16.1. Таблицы значений функции 2 переменных

 

var x,y,f:real;

begin

 writeln ('x':8,'y':8,'f':8);

 x:=0;

 while x<=2 do begin

  y:=0;

  while y<=2 do begin

   f:=sin(2*x)+cos(4*y);

   writeln (x:8:2,y:8:2,f:8:2);

   y:=y+0.25;

  end;

  x:=x+0.25;

 end;

end.

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

Вариант 3 удобен "естественным"  представлением таблицы значений функции двух переменных, однако, помешать его реализации может ограниченная ширина окна консоли (80 символов). Ниже приводится одна из возможных реализаций такой программы:

var x,y,f:real;

begin

 writeln; write (' ':6);

  {оставляем место для печати значений y}

 x:=0;

 while x<=2 do begin

  { для печати строки значений x

    потребовался отдельный цикл }

  write (x:6:2);

  x:=x+0.25;

 end;

 y:=0;

 while y<=2 do begin

  writeln;{перевод строки для очередного y}

  write (y:6:2); {печать значения y}

  x:=0; {реализация внутреннего цикла по x}

  while x<=2 do begin

   f:=sin(2*x)+cos(4*y);

   write (f:6:2);

   x:=x+0.25;

  end;

  y:=y+0.25;

 end;

end.

Как видно из листинга, код несколько усложнился за счет дополнительного цикла формирования строки значений x, для того, чтобы строка таблицы помещалась на строке экрана, пришлось также уменьшить ширину поля вывода с 8 до 6 символов. Однако, выигрыш несомненен -- теперь вся таблица поместилась на одном текстовом экране. Ограничение на ширину экрана консоли не имело бы значения, например, при выводе таблицы значений в текстовый файл.

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

Напечатать на первой строке вывода один символ звездочки, на второй -- два, на строке номер N -- N символов. Значение N вводится с клавиатуры, 1<N<25.

В общем виде условие можно сформулировать так: в строке номер i печатается i звездочек, при этом i меняется от 1 до N включительно. Разумеется, для перебора значений i мы используем цикл for. Однако для печати очередной строки звездочек нам потребуется вложенный цикл. Обозначив его счетчик как j, получим закон изменения j от 1 до i включительно:

var i,j,n:integer;

begin

 repeat {Ввод N с контролем ошибок}

  write ('N=');

  {$I-}read (n);{$I-}

  if (IoResult<>0) or (n<2) or (n>24)

  then begin

   writeln ('Ошибка! N должно быть ',

            'числом от 2 до 24');

   continue;

  end;

  break;

 until false;

 {Двойной цикл, в котором вложенный

  цикл имеет переменную границу}

 for i:=1 to n do begin

  writeln;

  for j:=1 to i do

   write ('*');

 end;

end.

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

Заданы N элементов массива A, упорядочить их по возрастанию значений.

Итак, нам требуется получить порядок элементов в массиве, при котором выполняется соотношение A1A2≤...≤AN. Достичь этого можно, сделав перестановки значений элементов, алгоритм перестановки нам известен еще из гл. 4. Представим, что в цикле мы сравниваем первый элемент A1 со всеми остальными Ai, i=2, 3, ... ,N, при необходимости (если A1>Ai) переставляя A1 и Ai. Таким образом, после выполнения этого цикла на первом месте в массиве гарантированно окажется его наименьший элемент. Для поиска следующего по величине элемента алгоритм можно повторить, сравнивая элемент A2 с остальными и при необходимости выполняя перестановку. Таким образом, приходим к двойному циклу следующего вида:

i=1,2,....,N-1 {до N-1 - так как у

              элемента AN нет следующего}

 j=i+1,i+2,...,N {будем для Ai перебирать

                все следующие элементы}

  {в теле двойного цикла сравниваем

   Ai и Aj, при необходимости переставляем

   их значения}

Реализуем этот алгоритм в виде следующей программы:

const nmax=100; {максимальная размерность}

var a:array [1..nmax] of real;

    i,j,n:integer;

    b:real; {буферная переменная}

begin

 repeat {цикл ввода значения N с проверкой}

  writeln ('Введите N от 2 до ',nmax,':');

  {$I-}read (n);{$I+}

  if (IoResult<>0) or (n<2) or (n>nmax)

   then writeln ('Ошибка! Повторите ввод');

 until (n>1) and (n<=nmax);

 {Цикл ввода и печати исходного массива}

 randomize;

 {Элементы массива выберем случайными}

 writeln ('Исходный массив:');

 for i:=1 to n do begin

  a[i]:= random(100);

  write (a[i]:4:0);

 end;

 {Двойной цикл сортировки}

 for i:=1 to n-1 do

 for j:=i+1 to n do

  if a[i]>a[j] then begin

    b:=a[i]; a[i]:=a[j]; a[j]:=b;

  end;

 {Цикл вывода измененного массива}

 writeln;

 writeln ('Отсортированный массив:');

 for i:=1 to n do write (a[i]:4:0);

 reset (input); readln;

end.

Сортировка массива по убыванию отличается лишь знаком в операторе сравнения элементов Ai и Aj.

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

4. Найти, сколько раз каждый элемент встречается в массиве.

Первое, что приходит в голову при решении этой распространенной задачи -- кроме массива данных ввести "массив частот", элементы которого будут хранить информацию о встречаемости  тех или иных значений. Однако решить проблему можно и без столь расточительных трат оперативной памяти (ведь размерность массива частот будет равна размерности исходного массива). Каждый элемент массива ai, кроме последнего, мы будем сравнивать со следующими за ним элементами aj, считая сколько раз выполнилось равенство ai=aj. Для того чтобы исключить повторную обработку уже встречавшихся элементов, учтенные значения нам придется заменять нулями. Поскольку значение ноль само может встретиться в массиве, дополнительный цикл перед обработкой подсчитает количество нулевых элементов.

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

program m_chast;

const size=10;

      Diap=10;

var a:array [1..size] of integer;

    i,n,k,j:integer;

begin

 writeln;

 repeat

  write('Введите размерность 1 массива ',

        '(от 2 до ',size,'):');

  read (n);

 until (n>1) and (n<=size);

 randomize;

 a[1]:=random(Diap);

 write ('A= ',a[1],' ');

 for i:=2 to n do begin

  a[i]:=random(Diap);

  write (a[i],' ');

 end;

 writeln;

 k:=0;

 for i:=1 to n do if a[i]=0 then Inc(k);

 if k>0 then writeln ('0: ',k);

 for i:=1 to n-1 do if a[i]<>0 then begin

  k:=1;

  for j:=i+1 to n do if a[i]=a[j] then

  begin

   a[j]:=0;

   Inc(k);

  end;

  writeln (a[i],': ',k);

 end;

end.

Подобный же принцип сравнения "каждый с каждым" используется при решении большого числа задач.

5. Координаты десяти точек на плоскости заданы двумя массивами xi, yi, i=1, 2, ..., 10. Найти две точки, расстояние между которыми минимально.

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

6. В завершение темы рассмотрим задачу, где число вложений циклов больше двух.

Номера автобусных билетов состоят из 6 цифр. "Счастливыми" называют билеты, в номерах которых  сумма трех первых цифр равна сумме трех последних. Определить общее количество "счастливых" билетов.

Каждая из шести цифр может меняться от 0 до 9 включительно. Создав кратные циклы по шести переменным, воспользуемся известным нам алгоритмом организации счетчика:

var i,j,k,l,m,n:integer;

 kol:longint;

    {типа integer может быть недостаточно}

begin

 kol:=0;

 for i:=0 to 9 do

 for j:=0 to 9 do

 for k:=0 to 9 do

 for l:=0 to 9 do

 for m:=0 to 9 do

 for n:=0 to 9 do

  if i+j+k = l+m+n then inc(kol);

 writeln

  ('Количество счастливых билетов=',kol);

end.

 

16.2. Оператор безусловного перехода

 

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

goto Метка;

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

m:

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

label m;.

Можно объявить и несколько меток сразу, разделив их имена запятыми. Принято располагать оператор описания меток до оператора var. Таким образом, метки и оператор goto позволяют решить задачу быстрого непосредственного перехода к нужному месту в программе:

label 10,20;

var i,j:integer;

begin

 write ('Введите значение I (i>2)');

 readln (i);

 if i<3 then goto 10;

 j:=2;

 20:

 if i mod j = 0 then write (j,' ');

 j:=j+1;

 if j<i then goto 20;

10:

end.

Эта несложная программа позволяет пользователю ввести число i, большее двух, после чего печатает все числа от 2 до  i-1, на которые i делится без остатка (проверка остатка от деления i на j выполнена операцией mod). В случае ввода пользователем недопустимого значения i (меньшего трех) происходит переход на метку 10:, расположенную перед закрывающим оператором end. -- таким образом, программа сразу же завершается. Метка 20: позволяет организовать цикл без использования операторов while, repeat или for. Действительно, перед меткой 20: переменная j получает начальное значение 2, затем, если i делится на j без остатка, значение j выводится на экран, затем увеличивается на единицу и, если значение i не достигнуто, совершается переход на метку 20:, проверяющую уже новое значение j. Однако, и той, и другой цели можно было достигнуть без использования goto, применяя только операторы цикла и break;.

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

var Flag:boolean;      {переменная-флаг}

...

Flag:=false; {флаг установлен в "ложь"}

while true do begin {внешний цикл}

 while true do begin   {внутренний цикл}

   ...

   if Условие then begin

   {случилось что-то, требующее выхода

    из обоих циклов сразу}

    Flag:=true;

    {ставим флаг, сообщая внешнему циклу,

     что требуется завершение}

   break; {выход из внутреннего цикла}

   end;

 end;

 if Flag=true then break;

 {внешний цикл на каждом шаге должен

  отслеживать состояние флага}

end;

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

label go1;

...

while true do begin

 while true do begin

  ...

  if Условие then goto go1;

   {вышли из двух циклов сразу!}

 end;

end;

Go1:

...

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

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

Рейтинг@Mail.ru
вверх гостевая; E-mail