Статистика знает все?

Давно ли вы заглядывали в классный журнал? Хорошо бы делать это раньше своих родителей. Ах, если бы журнал можно было и править!.. Нет, я не подбиваю вас подтирать оценки! Мы всего лишь подвергнем журнал статистической обработке. Статистика – это наука, находящая закономерности в массе данных. Она как тот холм, взобравшись на который, за деревьями видишь лес. Нужен пример? Пожалуйста.

В некой школе некоторого царства-государства для сравнения учеников и классов учредили рейтинги. Что такое рейтинг? – это вроде места в турнирной таблице. Чем выше рейтинг, тем сильнее спортсмен или команда, то есть ученик или класс. Определять рейтинг условились по средней оценке ученика или всего класса. Так, совокупность многих оценок заменялась одним числом – средним баллом. Когда вместо десятков чисел получаешь одно, – это и есть плод статистической обработки.

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

Акулова 3 5 4

Быков       5 5 5 5

Воронов 4 5 5 4

Галкина 3 4 3

Крокодилкин 4 3

А вот что получалось после обработки его упомянутой программой.

Номер Фамилия    Количество   Сумма    Средний

      оценок       баллов   балл

1     Акулова      3        12       4.0

2     Быков       4       20       5.0

3     Волков       4        18       4.5

4     Галкина      3       10       3.3

5     Крокодилкин  2       7       3.5

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

И все было хорошо, пока вирусная атака не уничтожила бесценную программу. А где распечатка исходника? Увы, к тому времени её погрызли мыши! Друзья, теперь надежда только на вас, выручайте школу!

Строим планы

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

3 5 4

5 5 5 5

4 5 5 4

3 4 3

4 3

А в результате обработки мы должны получить такой выходной файл.

Номер Количество Сумма   Средний

      оценок     баллов  балл

1       3       12       4.0

2       4       20       5.0

3       4       18       4.5

4       3       10       3.3

5       2 7       3.5

Набросаем план предстоящего сражения, то есть блок-схемы алгоритмов. На рис. 68 показан алгоритм главной программы. Он очень похож на тот, что применялся при шифровании текста, и это объяснимо: и там, и здесь выполняется построчная обработка файла.

Рис.68 – Алгоритм главной программы

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

Разобравшись с главной программой, сосредоточимся на обработке отдельной строки. Здесь заметно сходство со вторым вариантом полицейской базы данных (глава 29). И там, и тут читается ряд чисел, размещенных в одной строке. Но если в полицейской программе нам было безразлично, где кончается строка, то теперь иное дело, – ведь на следующей строке расположены оценки другого ученика! Нужен признак, сообщающий о достижении конца читаемой строки. Где его взять?

Ну, вы же понимаете, – в Паскале предусмотрено все! Познакомьтесь с функцией булевого типа по имени EoLn (от английского End of Line, что значит «конец строки»). Заголовок этой функции выглядит так:

      function Eoln(var aFile: text): boolean;

Функция принимает параметр – ссылку на текстовый файл – и возвращает TRUE, если позиция чтения в этом файле достигла конца строки. Она похожа на функцию Eof, проверяющую достижение конца файла. Исследуем функцию следующей программкой.

{----- Программа для исследование функции Eoln -----}

var F: text; N: integer;

begin

      Assign(F, 'Police.txt'); Reset(F);

      while not Eof(F) do begin

      Read(F, N); { чтение числа }

      Writeln(N, ' -- ', Eoln(F) ); { печать признака конца строки }

      end;

      Close(F); Readln;

end.

Здесь из файла «Police.txt» читаются все числа, при этом печатаются и сами числа, и признак конца строки. Предположим, файл «Police.txt» содержал такие строки.

1 2 3

10 20 30

100 200 300

Тогда на экране явится вот что.

1 -- FALSE

2 -- FALSE

3 -- TRUE

10 -- FALSE

20 -- FALSE

30 -- TRUE

100 -- FALSE

200 -- FALSE

300 -- TRUE

Как видите, после чтения последнего числа в строке признак её окончания равен TRUE.

Теперь, когда мы нащупали конец строки, соорудим алгоритм обработки одной строчки входного файла (рис. 69).

Рис.69 – Блок-схема обработки одной строки входного файла

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

Кстати, годится ли для чтения строки оператор цикла REPEAT-UNTIL? Правильный ответ – нет. Если текущая строка окажется пустой, следующая оценка прочитается уже на следующей строке, а это не то, что нам нужно! Оператор WHILE – единственно правильное решение.

Барабаним по клавишам

Теперь все готово для сочинения задуманной программы «P_30_1», ниже показан её текст. В начале программы объявлены три глобальные переменные: две – для доступа к входному и выходному файлам, и одна – для подсчета читаемых строк. Поскольку эти переменные объявлены перед процедурой обработки строки HandleString, то будут видны и в этой процедуре. Поэтому передавать содержащиеся в них данные через параметры здесь не обязательно (но возможно). Таким образом, мы передаем данные в процедуру через глобальные переменные, – в небольших программах это допустимо. Только не злоупотребляйте этим приемом, иначе в сложных программах запутаетесь.

Заглянем теперь внутрь процедуры HandleString. Кстати, её название составлено из двух слов: Handle – «обработка», и String – «строка». Процедура не принимает параметров, поскольку все необходимые данные получает через глобальные переменные. Обратите внимание на вычисление среднего балла:

      Rating:= Sum div Cnt;

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

А что сказать о главной программе? Она работает по ранее рассмотренному алгоритму. По крайней мере, сейчас нам так кажется.

{ P_30_1 – обработка журнала, первый вариант }

      {----- Глобальные переменные -----}

var InFile, OutFile : text; { входной и выходной файлы }

      Counter: integer;       { счетчик строк входного файла }

      {----- Процедура обработки одной строки -----}

procedure HandleString;

var N : integer; { оценка, прочитанная из файла }

      Cnt: integer; { количество оценок }

      Sum: integer; { сумма баллов }

      Rating: integer; { средний балл }

begin

      Sum:=0; Cnt:=0; { очищаем накопитель и счетчик оценок }

      while not Eoln(InFile) do begin { пока не конец строки }

      Read(InFile, N);       { читаем оценку в переменную N }

      Sum:= Sum+N;       { накапливаем сумму баллов }

      Cnt:= Cnt+1;       { наращиваем счетчик оценок }

      end;

      if Cnt>0

      then begin       { если оценки были }

      Rating:= Sum div Cnt;

      Writeln(OutFile, Counter, Cnt, Sum, Rating);

      end

      else { а если оценок не было }

      Writeln(OutFile, Counter, ' Ученик не аттестован');

end;

      {----- Главная программа -----}

begin

      Counter:= 0;       { обнуляем счетчик строк }

      { открываем входной файл }

      Assign(InFile,' P_30_1.in '); Reset(InFile);

      { создаем выходной файл }

      Assign(OutFile,' P_30_1.out '); Rewrite(OutFile);

      { выводим шапку таблицы }

      Writeln(OutFile, 'Номер Количество Сумма Средний');

      Writeln(OutFile, 'ученика оценок       баллов балл');

      { пока не конец входного файла… }

      while not Eof(InFile) do begin

      Counter:= Counter+1; { наращиваем счетчик строк }

      HandleString;       { обрабатываем строку }

      end;

      { закрываем оба файла }

      Close(InFile); Close(OutFile);

end.

Скомпилировали программу? Тогда подготовьте входной файл с оценками учеников (без фамилий). Назовите его «P_30_1.in» и сохраните, как обычно, в рабочем каталоге. Можно запускать? В общем-то, да. Но будьте настороже, – ошибки караулят нас на каждом шагу! Возьмите за правило первый прогон своих программ выполнять в пошаговом режиме. Поступим так и в этот раз.

Первый блин

Переключитесь в окно программы и для исполнения одного шага нажмите клавишу F7. Продолжайте нажимать её, наблюдая за ходом выполнения операторов. При желании добавьте в окно обзора переменных «Watch» глобальную переменную Counter.

После нескольких шагов вы попадете внутрь процедуры HandleString и благополучно пройдете по ней. На следующем цикле главной программы вновь войдете туда же, но теперь вас ждут «чудеса». Во-первых, цикл

      while not Eoln(InFile)

уже не выполняется ни разу, и в выходной файл пишется «Ученик не аттестован». Ещё загадочней другой фокус: не выполняется условие выхода из цикла в главной программе.

      while not Eof(InFile)

Обработав несколько строк, программа почему-то продолжает фанатично работать и дальше; она, как говорится, зациклилась. Если бы мы запустили её сразу в непрерывном режиме, то захламили бы выходным файлом весь диск! Пришлось бы аварийно снимать программу диспетчером задач. Ясно, что где-то притаилась ошибка, и надо прервать выполнение программы. Сделать это в пошаговом режиме несложно, – нажмите комбинацию Ctrl+F2.

Теперь сядем на пенёк и поразмыслим, в чем дело? Ведь первый вход в процедуру отработан верно. Вспомните наше исследование функции Eoln: чтение последнего числа в строке устанавливает признак конца строки в TRUE. Значит, при повторном входе в процедуру обработки строки цикл while not Eoln(InFile) не должен выполняться ни разу, – так оно и происходит. Так вот где собака порылась, – мы застряли в конце первой строки!

Этим же объясняется и зацикливание в главной программе, – не проскочив первой строки, нам не достичь конца файла. Виновник найден? – да, и теперь поищем решение проблемы. После обработки строки нам надо всего лишь перескочить с конца текущей строки в начало следующей, ничего при этом не читая. На ум приходит процедура Readln, – ведь она любит это делать. Помните, как подвела она нас во второй версии полицейской базы данных? Зато теперь выручит! Где её вызвать? Сделаем это после выхода из процедуры HandleString, то есть в цикле главной программы. Теперь главный цикл будет выглядеть так:

      while not Eof(InFile) do begin

      Counter:= Counter+1; { наращиваем счетчик строк }

      HandleString;       { обрабатываем строку }

      Readln(InFile) ;       { переход на следующую строку }

      end;

Процедуре Readln передана лишь файловая переменная InFile, поскольку никаких данных ей читать не надо. Стало быть, для исправления программы добавим лишь один оператор. Сделайте это и запустите программу в пошаговом режиме. Если пара строк будет обработана правильно, запустите её далее в непрерывном режиме.

Блин второй

Запуская программу, не ждите результатов на экране, – программа отработает молча. Для просмотра результатов откройте выходной файл «P_30_1.out». Сделайте это, не выходя из IDE: просто нажмите F3 и укажите имя файла. Вам откроется следующая картина.

Номер Количество       Сумма       Средний

      оценок       баллов       балл

13124

24205

34184

43103

5273

Что это? Вместо ожидаемых четырех колонок чисел мы видим только одну. Да и числа в ней несуразные! Откуда они взялись? Пробуем разгадать эту головоломку: первая цифра совпадает с порядковым номером строки: 1, 2, 3 и так далее. Вторая равна количеству оценок ученика: 3, 4, 4, 3, 2. Ага, значит, результаты правильные, только «слиплись» в одно число, – между числами нет пробелов. Кто виноват? Нет, не мы с вами, а этот оператор.

      Writeln(OutFile, Counter, Cnt, Sum, Rating);

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

      Writeln(OutFile, Counter,’ ’,Cnt,’ ’,Sum,’ ’, Rating);

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

Спецификатор ширины поля

Лучшее решение дают спецификаторы ширины поля. Это числовые выражения, задающие количество позиций для печати параметра. Их указывают за печатаемым параметром, причем параметр и спецификатор разделяются двоеточием, например:

      W := 15;

      Writeln(OutFile, Cnt : 10, Sum : W );

Здесь значение переменной Cnt будет напечатано на десяти символьных позициях, а значение переменной Sum – на пятнадцати (соответственно значению W).

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

Для нашего случая я подобрал следующие значения спецификаторов.

      Writeln(OutFile, Counter:3, Cnt:13, Sum:14, Rating:12);

Исправьте заодно и этот оператор вывода в файл:

      Writeln(OutFile, Counter:3, ' Ученик не аттестован');

Снова запустите программу и проверьте результат. Кстати, если вы не закрывали окно с выходным файлом «P_30_1.out», то по завершении программы IDE сообщит о том, что файл на диске был изменен, – это сделала ваша программа. Но в открытом окне все осталось по-прежнему, потому IDE спрашивает разрешение на обновление окна, – дайте положительный ответ кнопкой «Yes» и переключитесь в окно с файлом «P_30_1.out». Теперь вы увидите вот что.

Номер Количество       Сумма       Средний

      оценок       баллов       балл

1       3       12       4

2       4       20       5

3       4       18       4

4       3       10       3

5       2       7       3

Это почти идеальный результат. Осталась лишь одна шероховатость, – средний балл не содержит дробной части. Займемся этим вопросом.

«Развесные» числа

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

      Rating:= Sum div Cnt;

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

      7 div 3 = 2

      7 div 4 = 1

      7 div 5 = 1

Целые числа потому и целые, что не дают «отколоть» от себя ни крошки. Они как штучный товар. Но средний балл – это «развесной товар», – для него нужны другие числа, и они в Паскале есть.

Я говорю о вещественных числах. В Паскале есть несколько типов для представления таких чисел. Один из них – REAL – родной для Паскаля, поскольку существовал в первой версии языка. Другие добавились с появлением в компьютерах математических сопроцессоров. Для хранения среднего балла воспользуемся типом REAL; с этой целью изменим объявление переменной Rating следующим образом:

      var Rating: Real;

Но этого недостаточно. Дело в том, что, если мы оставим формулу

      Rating:= Sum div Cnt;

без изменений, то и результат не изменится. Все потому, что операция DIV (от Division – «деление») предназначена только для целых чисел, и дробную часть она всё равно отбросит. Для деления вещественных чисел в Паскале есть другая операция, она записывается косой чертой «/». Значит, упомянутый выше оператор мы должны изменить так:

      Rating:= Sum / Cnt;

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

Номер Количество       Сумма       Средний

      оценок       баллов       балл

1       3       12 4.00000000000000E+0000

2       4       20 5.00000000000000E+0000

3       4       18 4.50000000000000E+0000

4       3       10 3.33333333333212E+0000

5       2       7 3.50000000000000E+0000

Что бы это значило? Средний балл считается верно, но печатается очень странными уродливыми числами! Не пугайтесь, перед вами научный формат представления вещественного числа, он удобен для изображения очень маленьких и очень больших чисел. Например, известное физикам и химикам число Авогадро (примерно 6,022140 умноженное на 10 в 23-й степени) изображается как 6.022140E+0023. Но нам этот формат не подходит, и мы заменим его, задав спецификатор ширины поля.

Для вещественных чисел спецификатор состоит из двух частей, разделяемых двоеточием. Первая часть задает общую ширину поля печати (так же, как и для целых чисел), а вторая – количество цифр после запятой (после точки). Чтобы напечатать переменную Rating с одним знаком после точки при общей ширине поля в 12 позиций, нам следует применить такой оператор печати.

      Writeln(OutFile, Counter:3, Cnt:13, Sum:14, Rating:12:1 );

Теперь вновь запустим программу и полюбуемся на результат.

Номер Количество       Сумма       Средний

      оценок       баллов       балл

1       3       12       4.0

2       4       20       5.0

3       4       18       4.5

4       3       10       3.3

5       2       7       3.5

Прекрасно! Изрядно потрудившись и одолев ряд ошибок, мы достигли цели! Осталось лишь подытожить завоевания этой главы.

Итоги

• Функция Eoln следит за признаком конца текущей строки, применяется совместно с оператором WHILE.

• Для продвижения позиции чтения в начало следующей строки вызывайте процедуру Readln, указывая лишь один параметр – файловую переменную.

• Данные внутрь процедур и функций можно передавать через глобальные переменные; такой прием допустим для несложных программ.

• Целые числа не содержат дробной части. Для действий с дробными числами применяют вещественные типы, например, Real.

• Для получения дробного результата деления пользуйтесь операцией «/» (косая черта). Операция DIV при делении отбрасывает дробную часть.

• Для ровной печати чисел применяйте спецификаторы ширины поля.

А слабо?

А) Функция Trunc выделяет целую часть вещественного числа, например:

      Writeln (Trunc( 12.345 )); { 12 }

Исследуйте её и придумайте способ выделения дробной части вещественного числа. Напишите подходящую функцию и программу для её проверки.

Б) Объясните и проверьте, что напечатает следующая программа.

var N: integer;

begin       for N:=1 to 20 do Writeln (’ ’:N, N); end.

В) Сформируйте файл «Numbers.txt», поместив в него 100 случайных чисел в диапазоне от 0 до 999 (некоторые числа могут повторяться). Затем найдите в этом файле: 1) максимальное и минимальное число; 2) сумму всех чисел; 3) среднее арифметическое – напечатайте его с двумя знаками после точки.

Г) Сканирование марсианской поверхности дало файл, содержащий высоту отдельных его точек вдоль одного из направлений, – пусть это будет файл «Numbers.txt» из предыдущей задачи. Найдите точки, где вероятней всего обнаружить марсианскую воду. На следующем ниже рисунке они обозначены буквами W. Программа должна напечатать две колонки: порядковый номер точки относительно начала файла (счет от нуля) и высоту точки (такие точки математики называют локальными минимумами).

Рис. 70 – Рельеф марсианской поверхности