Определение переменных программы

Для реализации алгоритма нам будут необходимы следующие переменные.

Массив целых чисел, который будет обрабатываться:

  int Ar[100];

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

Индексы элементов массива для внешнего (блоки 3 - 17) и внутреннего (блоки 14 - 16) циклов:

   int i, j;

Переменные, в которых будут храниться параметры очередной последовательности: сумма элементов, а потом среднее значение - av, количество элементов в последовательности - nn, индекс начала последовательности - ib:

int av;

int nn;

int ib;

Отметим, что для большинства данных, которые представляются переменными программы, достаточно было бы и типа short или char, т.к. их значения укладываются в диапазон: -128 - 128. Мы выбираем тип int согласно с общим стилем программирования на языке C. Отдельного рассмотрения требует переменная av, т.к. в ней накапливается сумма, а значит, ее значение может значительно превысить значения остальных переменных. Но в наихудшем случае (когда все элементы массива будут иметь максимальные значения) ее значение не превысит 100*50=5000, следовательно типа int достаточно и для нее.

Разработка текста программы

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

#include <stdio.h>

#include <time.h>

#include <stdlib.h>

В файле stdio.h описания функций стандартного ввода-вывода, в файле stdlib.h - функции генерации случайных чисел. В описании функции randomize() мы нашли примечание, что она является макросом, который обращается к функции time(), следовательно, перед файлом stdlib.h в программу должен быть включен файл time.h.

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

int Ar[100];

Далее ставим заголовок главной функции main и открываем ее тело:

int main(void){

Главная функция начинается с объявления остальных переменных программы см. п.5.2.

Кодовая часть программы начинается с обращения к функции инициализации датчика случайных чисел (блок 2):

randomize(100);

Далее организуем простой цикл со счетчиком (блок 3), в каждой итерации которого в следующий элемент массива записывается случайное число (блок 4). Обращение к функцииrand() возвращает нам число в пределах 0 - 100; вычитая из него 50, мы приводим его к диапазону -50 - +50.

for (i=0; i<100; Ar[i++]=random(101)-50 );

Заполненный таким образом массив в цикле выводим на экран (блок 5). Формат вывода каждого элемента - %3d - обеспечивает отображение числа из двух цифр со знаком. Между числами задаеv еще два пробела, таким образом, каждый элемент занимает 5 позиций, а в одной строке экрана разместится целое число (16) элементов, что обеспечит удобное представление массива.

printf("Начальный массив:\n");

for (i=0; i<100; printf("%3d ",Ar[i++]));

putchar('\n');

putchar('\n');

Далее идет заголовок цикла перебора массива (блок 7), в котором мы также присваиваем начальное значение счетчику nn (блок 6):

for (nn=i=0; i<100; i++) {

Все тело цикла состоит из одного условного оператора. В этом операторе проверяем (блок 8) знак i-го элемента массива:

if (Ar[i]<0)

Если это условие - истина, то проверяем, не равен ли 0 счетчик элементов последовательности nn (блок 9):

if (!nn)

При выполнении этого условия выполняется ряд действий (блок 10), которые мы берем в операторные скобки:

{ ib=i; av=Ar[i]; nn=1; }

Если же условие ложно, то выполняется сложный оператор (блок 11):

else { av+=Ar[i]; nn++; }

Если же элемент положительный, то выполняется часть else первого условного оператора, в которой анализируется nn - нет ли у нас необработанной отрицательной последовательности (блок 12):

else if (nn) {

Если есть необработанная последовательность, выполняем усреднение значения av (блок 13):

av/=nn;

и организуем цикл с параметром j, который изменяется от ib до i-1(блок 14):

for (j=ib; j<i; j++)

В каждой итерации этого цикла j-й элемент массива сравнивается с средним значением (блок 15) и, если он больше, заменяется на среднее значение (блок 16). Это реализуется одним условным оператором:

if (Ar[j]<av) Ar[j]=av;

При выходе из цикла записываем 0 в счетчик nn (блок 17):

nn=0;

На этом заканчивается и внешний цикл.

Несколько операторов, которые следуют после выхода из цикла (блок 18), обеспечивают обработку последней последовательности и в основном являются копией тех операторов, которые реализуют блоки 12 - 17. Разница состоит в том, что тут мы внесли усреднение в начальное действие цикла и убрали присваивание nn=0, т.к. значение nn нам больше не понадобится.

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

Полный текст программы приведен ниже.

/***************************************************/

/*        Лабораторная работа №4         */

/*          Работа с массивами           */

/*      Пример решения. Вариант №30.     */

/***************************************************/

#include <stdio.h>

#include <time.h>

#include <stdlib.h>

 int Ar[100]; /* массив, который обрабатывается */

int main(void) {

 int i, j; /* индексы в массиве */

 int av; /* среднее значение */

 int nn; /* количество эл-тов в последовательности */

 int ib; /* индекс начала последовательности */

randomize(); /* инициализация rand */

/* заполнение массива случайными числами */

for (i=0; i<100; Ar[i++]=random(101)-50 );

/* вывод начального массива */

printf("Начальный массив:\n");

for (i=0; i<100; printf("%3d ",Ar[i++]));

putchar('\n');

putchar('\n');

for (nn=i=0; i<100; i++) { /* перебор массива */

if (Ar[i]<0)

/* обработка отрицательного элемента */

if (!nn) {

   /* начало последовательности */

   /* запомнить индекс начала,

      начальное значение накопителя суммы

      и счетчика элементов */

   ib=i; av=Ar[i]; nn=1;

   }

else {

   /* накопление суммы,

      подсчет количества */

   av+=Ar[i]; nn++;

   }

/* конец обработки отрицательного элемента */

else /* обработка положительного элемента */

if (nn) {

   /* если есть необработанная

      отрицательная последовательность */

   av/=nn; /* усреднение */

   /* перебор всей последовательности

      с ограничением */

   for (j=ib; j<i; j++)

     if (Ar[j]>av) Ar[j]=av;

       nn=0; /* последовательность обработана */

   } /* конец если есть необработанная... */

} /* конец перебор массива */

if (nn) /* если не обработана последняя

        отрицательная последовательность */

for (av/=nn, j=ib; j<i; j++)

if (Ar[j]>av) Ar[j]=av;

/* вывод результатов */

printf("Массив-результат:\n");

for (i=0; i<100; printf("%3d ",Ar[i++]));

putchar('\n');

return 0;

}

/***************************************************/

/*        Лабораторная работа №4         */

/*          Работа с массивами           */

/*     Пример решения (упрощенный).      */

/***************************************************/

#include <stdio.h>

#include <stdlib.h>

int main(void) {

 int i, j; /* индексы в массиве */

 const n=10, m=10;

 int Ar[n][m]; /* массив, который обрабатывается */

 int firs_value=-10;

 int last_value=10*2;

 /* заполнение массива случайными числами */

 for (i=0; i<=n-1; i++)

   for (j=0; j<=m-1; j++)

    Ar[i][j]=firs_value + rand() % last_value;

/* вывод начального массива */

printf("Begining mas:\n");

for (i=0; i<=n-1; i++)

{ for (j=0; j<=m-1; j++)

   printf("%5i",Ar[i][j]);

printf("\n");}

/* заполнение элементов массива выше главной диагонали */

 for (i=1; i<=n-1; i++)

 for (j=0; j<=i-1; j++)

    Ar[i][j]=0;

 /* заполнение элементов массива ниже главной диагонали */

 for (i=0; i<=n-2; i++)

for (j=i+1; j<=m-1; j++)

     Ar[i][j]=1; 

/* вывод результатов */

printf("Ending mas:\n");

for (i=0; i<=n-1; i++)

{ for (j=0; j<=m-1; j++)

   printf("%5i",Ar[i][j]);

    printf("\n");}

return 0;

}

Отладка программы

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

Если же обнаруживаются ошибки в результатах, то можно использовать пошаговый метод отладки, при этом следует проверять работу алгоритма отдельно по ветвям: 7 - 8 - 9 - 10; 7 - 8 - 9 - 11; 7 - 8 - 12 - 13 - 14 - 15 - 16 - 17. При пошаговой отладке следует отслеживать в первую очередь значения тех переменных, которые отвечают за преобразование - ib, nn,av.

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