Текст книги "Песни о Паскале (СИ)"
Автор книги: Олег Деревенец
Жанр:
Драматургия
сообщить о нарушении
Текущая страница: 14 (всего у книги 29 страниц)
К сожалению, примитивная техника тех лет не смогла отправить на землю эту фотографию. Спутник передал лишь номера границ каждого государства в виде текстового файла, содержащего строчки чисел.
Рис.87 – Вид на материк из космоса
Выдернув из принтера ещё теплую распечатку файла, первый министр примчался во дворец, протянул листок монарху и покорно припал к подножию трона. Царь встрепенулся, стал разглядывать бумажку, вертеть её так и сяк, и даже на зуб попробовал. Наконец терпение государя иссякло: «Болван, – обратился он к министру, – покажи тут наших соседей. Что? Не можешь? Так проваливай с глаз долой!». И смятая распечатка угодила в лицо министра. «А ведь хотел, как лучше…» – стучало в башке убегающего премьера. «А получилось, как всегда!» – догнал его вопль взбешённого монарха.
Куда податься бедолаге? Разумеется, к самому умному, – к придворному программисту. «Выручай, браток, я тебе премию выпишу!». Инженеры, создавшие спутник, тоже не остались в стороне и растолковали программисту суть проблемы. Расправив скомканную царской рукой бумагу, Ник – так звали придворного программиста – увидел вот что.
29 21 30 31 32
17 18 19 29 28
3 4 5 20 19 18
6 7 22 21 20
8 9 25 24 23 22
10 11 26 30 23 24 25
12 13 15 27 26
14 1 2 17 16 15
16 28 32 31 27
Каждая строка этого файла, – объяснили инженеры, – перечисляет границы некоторого царства: первая строка – царства «A», вторая – царства «B» и так далее. Имена стран в файле не указаны, но подразумевается их алфавитный порядок. Надо составить список стран, которые соседствуют с нашей страной «A» – первой в этом списке.
Друзья, отложите книгу и попытайтесь решить эту интересную задачу. В случае успеха, я похлопочу за вас при дворе!
А пока вы раздумываете, я исполню свой долг перед историей и покажу решение заморского коллеги. Ник сразу понял, что имеет дело с двумя видами множеств: множеством границ, обозначенных числами, и множеством стран, обозначенных буквами (вы помните, что страны именовались буквами?). Парень смекнул, что две страны соседствуют тогда, когда пересечение множеств их границ не пусто (это значит, что у них есть общие границы). Дальше его мысли устремились так быстро, что пальцы едва успевали тыкать по клавишам. Вот плод его труда.
{ P_38_3 – поиск стран–соседей }
type TBoundSet = set of byte; { множество границ }
TStateSet = set of Char; { множество стран }
{– Распечатка множества стран (символов) –}
procedure WriteCharSet(var aFile: text; const aSet : TStateSet);
var c : char;
begin
for c:='A' to 'Z' do if c in aSet then Write(aFile, c:2);
Writeln(aFile);
end;
{– Ввод множества границ (чисел) –}
procedure ReadSet(var aFile: text; var aSet : TBoundSet);
var k : integer;
begin
While not Eoln(aFile) do begin
Read(aFile, K); aSet:= aSet+[K];
end;
Readln (aFile);
end;
var FileIn, FileOut: text;
R: TStateSet; { множество соседей (результат) }
SA, S : TBoundSet; { границы царства «A» и прочих }
State: char; { буква с названием очередной страны }
begin {– Главная программа –}
Assign(FileIn, 'P_38_3.in'); Reset(FileIn);
Assign(FileOut, ''); Rewrite(FileOut);
R:= []; SA:=[]; State:='A'; { начнем с царства «A» }
ReadSet(FileIn, SA); { из первой строки читаем границы для «A»}
while not Eof (FileIn) do begin { цикл по странам }
State:= Succ(State); { буква следующей страны }
S:=[]; ReadSet(FileIn, S); { читаем границы страны }
{ если граничит с царством «A», добавляем к результату }
if S*SA <> [] then R:= R + [State];
end;
WriteCharSet(FileOut, R); Readln; { вывод результата }
Close(FileIn); Close(FileOut);
end.
Программа Ника вычислила, что царство «A» соседствует с царствами «B», «D», «F», «I». Со временем проверка на местности это подтвердила.
Царь щедро наградил программиста, но история на этом не закончилась. О великом научном успехе скоро знала и последняя собака на материке. Но больше других этот успех заинтересовал купцов, плативших пошлины при пересечении границ. Они явились к Нику с предложением, от которого тот не смог отказаться. Хотите продолжения сказки? – оно ждёт вас в главах 49, 57 и 58.
Решето Эратосфена
Древние греки не знали, что они древние. И компьютеров тоже не знали, зато дышали бодрящим морским воздухом, коротая досуг в философских и математических размышлениях. Греческий досуг оказался не таким уж пустым, – иные задачки, придуманные под ласковый шепот волн, не решены по сию пору! Одна из них – вычисление простых чисел.
Прежде всего, выясним, что это за числа? Простым называют число, которое делится без остатка лишь на само себя и единицу. Все прочие числа являются составными. Возьмем, к примеру, числа от 1 до 10 и выделим среди них составные.
1 2 3 4 5 6 7 8 9 10
Здесь отмечены составные числа 4, 6, 8, 9 и 10, – они делятся без остатка либо на 2, либо на 3. Оставшиеся числа 1, 2, 3, 5 и 7 являются простыми.
Кто-то из греков задался вопросом: можно ли вычислить очередное простое число, если известны все предыдущие? Например, исходя из того, что числа 1, 2, 3 и 5 простые, определить следующее простое число (7). Как ни мудрили мудрецы, такой формулы или алгоритма пока не придумали! Но усилия в этом направлении породили целые отрасли математики, – вот такой полезный неуспех!
Размышлял над задачей и грек Эратосфен. Он тоже не решил её, однако нашел остроумный способ отсеивать простые числа, не превышающие некоторого числа N. Вот суть его идеи.
Положим, мы ищем простые числа не превышающие 20. Выпишем на морском песочке в ряд числа с 1 до 20. Первые два числа – 1 и 2 – простые, их не тронем, а среди остальных сотрем каждое второе, то есть 4, 6, 8 и так далее.
Затем находим первое нестертое число – это три. Сотрем каждое третье после тройки: 6, 9, 12, 15 и 18 (хотя часть из них уже стерта, лишний раз это сделать не повредит). Повторяя процедуру, находим следующее нестертое число – это пять. Стираем каждое пятое после пятерки: 10, 15, 20 (хотя все они уже стерты). Достигнув середины этого списка – числа 11, остановимся. Дальше двигаться нет смысла, поскольку на песке остались лишь простые числа.
Примечание. Если говорить точнее, лучше остановиться на числе, которое составляет корень квадратный из числа N, в данном случае это 5. Но для упрощения задачи мы будем обрабатывать больше чисел – половину ряда.
Вот результат этой пляжной математики, где стираемые числа выделены, а стертые обозначены звездочками. Здесь хватило всего двух просевов.
1-й отсев чисел, кратных 2:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
2-й отсев чисел, кратных 3:
1 2 3 * 5 * 7 * 9 * 11 * 13 * 15 * 17 * 19 *
Результат – простые числа:
1 2 3 * 5 * 7 * * * 11 * 13 * * * 17 * 19 *
А если бы Эратосфен жил в наше время? Стал бы он царапать на песке? Конечно, нет, – на что ж тогда компьютеры? Программа «P_38_4» находит все простые числа, не превышающие 255, – роль песка исполняет множество чисел.
program P_38_4; { Решето Эратосфена }
var Simples : set of byte; { множество чисел }
n, m : integer;
F : text;
begin
Assign(F, 'P_38_4.out'); Rewrite(F);
Simples:= [2..255]; { Сначала множество полное }
{ Цикл вычеркивания составных чисел }
for n:=2 to (255 div 2) do begin
{ если число ещё не вычеркнуто }
if n in Simples then
{ проверяем на кратность ему все последующие }
for m:=2*n to 255 do
{ если остаток(m/n) равен нулю, то m – составное }
if (m mod n)=0
{ и его надо вычеркнуть из множества}
then Simples:= Simples – [m];
end;
{ Распечатка множества простых чисел }
for n:=2 to 255 do if n in Simples then Writeln(F,n);
Close(F); Readln;
end.
Мелочь, а приятно
Одну из первых своих программ мы снабдили разумом попугая, научив повторять имя пользователя. После ввода имени в переменную S программа печатала.
Writeln (’Здравствуй, ’+ S);
Сделаем её чуть умнее, научив отличать мальчиков от девочек. По крайней мере, для русских имен. Русские женские имена оканчиваются на буквы «а» или «я» (Анна, Светлана, Мария и так далее), чего не скажешь о мужских. Последнюю букву имени можно «выдернуть» в символьную переменную C таким оператором.
C:= S[Length(S)];
И теперь приветствовать пользователя можно так:
if (C=’А’) or (C=’а’) or (C=’Я’) or (C=’я’)
then Writeln (’Здравствуй, девочка ’+ S)
else Writeln (’Здравствуй, мальчик ’+ S);
Здесь проверяется совпадение переменной C с буквами верхнего и нижнего регистров, поскольку нельзя предсказать, в каком регистре будет введено имя. Условный оператор выглядит громоздко, но, призвав на помощь множество, мы упростим его.
if C in [’А’, ’а’, ’Я’, ’я’]
then Writeln (’Здравствуй, девочка ’+ S)
else Writeln (’Здравствуй, мальчик ’+ S);
Переменную C проверяем на попадание в множество символов. Согласитесь, этот вариант читается приятней.
Итоги
Если вовремя смекнуть, что имеете дело с множествами, сложные задачи, как по волшебству, превратятся в простые!
А слабо?
А) Напишите программу для решения директорских задач и повторите подвиг контрразведчика. Или слабо?
Б) На острове действовали забавные законы по части транспортных средств – автобусов, грузовиков и легковушек. Во-первых, общее количество автомобилей на острове не должно было превышать 256. Автомобилям назначались номера с 0 до 255, при этом соблюдались следующие правила.
Номера, делившиеся без остатка на 7, назначались автобусам. Те, что делились без остатка на 5, назначались грузовикам, а все прочие – легковушкам. Например, номера 35 и 70 (они делятся и на 7, и на 5) доставались автобусам, а не грузовикам.
Схожие правила применялись и к окраске автомобилей, а именно: если номер авто делился на 4, его красили красным, если на 3 – желтым, если на 2 – белым, а остальные автомобили красили черным.
• Сформируйте три множества по классам автомобилей – автобусы, грузовики и легковушки. Вычислите количество машин каждого класса (Ответ: 37, 44, 175).
• Сформируйте четыре множества по цвету автомобилей – красные, желтые, белые и черные. Определите количество машин каждого цвета (Ответ: 64, 64, 43, 85).
• Столица того государства – деревня Кокосовка – страдала от пробок. Для их устранения ввели ограничение на въезд транспорта. Так, в один из дней недели в столицу пускали только красные легковушки, белые грузовики и все автобусы. Найдите номера всех этих машин. Сколько всего автомобилей могло въехать в столицу в тот день?
В) Полицейская база островного государства содержала номера угнанных автомобилей – числа от 1 до 255. Это был текстовый файл такого, например, вида:
120 31 16 25
То есть, номера перечислялись через пробел и следовали в произвольном порядке, что неудобно при поиске вручную. Ваша программа должна создать файл с номерами, упорядоченными по возрастанию. Подсказка: примените множество чисел.
Г) Генерация пароля длиной не менее восьми символов. В пароль входят символы трёх сортов: цифры, маленькие и большие латинские буквы, например: «7UpJ7rsT», «PasCal701». Сделайте четыре варианта так, чтобы соблюдались следующие условия:
• символ каждого сорта входит в пароль не менее двух раз, некоторые символы могут повторяться;
• все символы пароля уникальны (примените множество);
• символы одного сорта не соседствуют, например: «Pa7sCaL5», уникальность символов не требуется;
• символы одного сорта не соседствуют и все символы уникальны.
Д) Напишите четыре булевы функции, проверяющие, является ли введенная пользователем строка правильно сформированным паролем согласно условиям предыдущей задачи.
Глава 39
Командная игра (массивы)
В чём сила компьютеров? В умении стремительно перемалывать огромные объёмы данных: сотни, тысячи, миллионы элементов! Под элементами данных мы разумеем числа, строки и тому подобное. Обратимся и мы к этой способности компьютера. Нет, с миллионом элементов погодим, начнем всего с нескольких: рассмотрим, к примеру, турнирную таблицу чемпионата.
Снежная лавина
Вот задача для болельщика: отсортировать команды в турнирной таблице чемпионата по убыванию набранных ими очков. Команд немного, всего 16. После каждого тура количество очков меняется, и таблица сортируется заново. Корпеть над этим вручную? – это не для нас! Итак, будущая программа должна принимать с клавиатуры очки, набранные командами, и распечатывать команды в порядке убывания этих чисел. При этом набранные очки мы будем вводить всегда в одном и том же порядке.
Сделаем это сначала для двух команд, пусть ими будут «Динамо» и «Спартак». Сортировка двух команд – что может быть проще?
{ ввод и сортировка двух команд (в программе 14 строк) }
var T1, T2 : integer;
begin
Readln (T1, T2); { Ввод очков для «Динамо» и «Спартак» }
if T1>T2
then begin
Writeln('1.Динамо');
Writeln('2.Спартак');
end
else begin
Writeln('1.Спартак');
Writeln('2.Динамо');
end;
Readln;
end.
Здесь для каждой из команд отведена переменная, хранящая набранные очки: T1 – для «Динамо» и T2 – для «Спартака». Вариантов расстановки всего два, поэтому и программа очень проста – всего 14 строк, не считая комментария.
Теперь добавим в чемпионат команду «Зенит». Вариантов расстановки стало втрое больше – шесть, и программа заметно усложнилась, вот она.
{ сортировка трех команд (в этой программе 45 строк) }
var T1, T2, T3 : integer;
begin
Readln (T1, T2, T3); { «Динамо», «Спартак», «Зенит» }
if (T1>T2) and (T1>T3)
then begin
Writeln('1.Динамо');
if T2>T3
then begin
Writeln('2.Спартак');
Writeln('3.Зенит');
end
else begin
Writeln('2.Зенит');
Writeln('3.Спартак');
end
end
else begin
if (T2>T1) and (T2>T3)
then begin
Writeln('1.Спартак');
if T1>T3
then begin
Writeln('2.Динамо');
Writeln('3.Зенит');
end
else begin
Writeln('2.Зенит');
Writeln('3.Динамо');
end
end
else begin
Writeln('1.Зенит');
if T1>T2
then begin
Writeln('2.Динамо');
Writeln('3.Спартак');
end
else begin
Writeln('2.Спартак');
Writeln('3.Динамо');
end
end
end;
Readln;
end.
Здесь уже 45 строк, что втрое больше, чем для двух команд. С добавлением последующих команд программа продолжит разбухать, как снежный ком. Для четырех команд она станет длиннее ещё в 4 раза (180 строк), для пяти – ещё в 5 раз (900 строк) и так далее. Дойдя до шестнадцати команд, мы насчитаем в программе триллионы строк. А ведь триллион – это «всего лишь» миллион миллионов! Скорей свернем с этой гибельной тропы, пока снежная лавина не накрыла нас с головой!
А где же волшебная палочка?
Вы ощущаете причину трудностей? В моих решениях нет циклов, способных выполнять огромное количество однообразных действий. Так, например, одним оператором цикла печатается хоть тысяча, хоть миллион чисел. Увы! Применить цикл к переменным с именами T1, T2 и T3 не получится. Хотя цифры в этих именах означают для нас порядковые номера команд, для компилятора они – всего лишь часть имени переменной, и не более. Как же втолковать компилятору то, чего мы добиваемся нумерацией переменных?
Для этого есть особый тип данных – массив переменных или, проще – массив. Вот она, спасительная волшебная палочка!
Массивы вокруг нас
Массив объединяет несколько однотипных переменных под одним общим именем. Отдельные переменные в массиве называют его элементами, и доступ к ним возможен по их номерам. Массивы придумали отнюдь не программисты. Возьмите любую спортивную команду – футбольную или хоккейную. Здесь, кроме фамилии, игрок снабжен номером, который лучше виден на поле. И это не единственный пример массива. Если отдельную переменную уподобить ящику с хранящейся в нём информацией, то массив переменных будет комодом с пронумерованными ящиками (рис. 88).
Рис.88 – Примеры простых переменных (слева) и массивов (справа)
Итак, массив – это собранные в одну команду переменные. Они получают общее на всех имя – имя своей команды. А внутри команды каждая переменная – элемент массива – обладает своим номером. Ну, чем не игроки?
Объявление массивов
Прежде, чем пользоваться массивом, его надо объявить: либо в секции VAR, либо через объявление пользовательского типа в секции TYPE.
Рассмотрим сначала первый способ, – объявим массив в секции VAR.
VAR Имя_Массива : ARRAY [
Здесь использована пара ключевых слов ARRAY… OF…, что переводится как «массив… из…». Имя массива – это обычный идентификатор, его программист придумывает сам; будем считать это имя названием команды переменных.
Справа, после двоеточия, указывают две характеристики массива: 1) диапазон для индексов и 2) тип элементов массива. Рассмотрим эти атрибуты массива подробней.
Диапазон для индексов определяет допустимые номера элементов внутри массива. Диапазон указывают в квадратных скобках после слова ARRAY, – это два выражения порядкового типа, условно обозначенные мною как MIN и MAX, они разделяются двумя точками. Говоря спортивным языком, здесь назначается диапазон номеров для «игроков команды».
После ключевого слова OF следует второй атрибут массива – тип данных для всех его элементов. Прибегнув вновь к спортивному языку, скажем, что здесь объявляют «вид спорта» для команды.
Вот пример объявления трех массивов: Names (фамилии), Ratings (оценки) и ChampShip (чемпионат).
VAR { объявления переменных-массивов }
{ 30 строковых переменных с фамилиями учеников класса }
Names : ARRAY [1..30] OF string;
{ 30 байтовых переменных с оценками учеников этого класса }
Ratings : ARRAY [1..30] OF byte;
{ 16 чисел с очками, набранными командами в чемпионате }
ChampShip : ARRAY [1..16] OF integer;
Как видите, массив можно составить из элементов любого типа. Так, массив Names содержит внутри себя 30 переменных строкового типа: Names[1], Names[2] и так далее (номера переменных указывают в квадратных скобках).
Объявление массивов в секции VAR не слишком удобно. Почему? Рассмотрим следующий пример.
var A : array [1..5] of integer;
B : array [1..5] of integer;
begin
A:= B; { здесь компилятор видит ошибку несовместимости типов}
end.
Мы объявили массивы A и B; на первый взгляд, это массивы одного типа, поскольку каждый из них содержит по пять целых чисел. Для однотипных переменных, включая массивы, Паскаль допускает операцию копирования. Например, оператором
A:=B
все элементы массива B копируются в элементы массива A. Увы, компилятор увидит здесь ошибку несовместимости типов. В чем дело? А в том, что он считает разнотипными массивы, объявленные в разных операторах. Даже если массивы совершенно одинаковы! Скажете, компилятор недостаточно умен? Может быть, но нам придётся как-то выкручиваться, и для этого есть два пути.
Во-первых, переменные A и B можно объявить в одном операторе.
var A, B : array [1..5] of integer;
Это устраняет проблему несовместимости типов.
Но есть и лучший способ – сначала объявить для массива пользовательский тип данных. Это делается в секции TYPE так:
TYPE Имя_Типа = ARRAY [
В сравнении с объявлением переменной разница мизерная: вместо двоеточия видим знак равенства, а вместо имени переменной – имя типа. Но каковы последствия! Объявите лишь однажды нужный вам тип, и тогда применяйте его, где угодно. Вот объявления типов для указанных выше переменных.
TYPE { примеры объявления типов-массивов }
{ тип для 30 строковых переменных с фамилиями учеников класса }
TNames = ARRAY [1..30] OF string;
{ тип для 30 байтовых переменных с оценками учеников }
TRatings = ARRAY [1..30] OF byte;
{ тип для 16 целых переменных с очками, набранными в чемпионате }
TChampionShip = ARRAY [1..16] OF integer;
Здесь буква «T» в имени типа напоминает о назначении этого идентификатора (помните наше добровольное соглашение об именах?). Теперь учрежденные типы данных можно употребить для объявления переменных и параметров в любом месте программы, вот пример.
TYPE { тип для 30 байтовых переменных с оценками учеников }
TRatings = ARRAY [1..30] OF byte;
VAR { 30 байтовых переменных с оценками учеников }
Ratings : TRatings;
procedure ABC (var arg: TRatings); { параметр процедуры }
var A, B, C : TRatings; { локальные переменные }
begin
...
end;
Здесь тип TRatings служит для объявления переменных и параметров в трех местах программы. В будущем мы всегда будем объявлять типы – как для массивов, так и для других сложных наборов данных.
Доступ к элементам (индексация)
Переменной-массивом можно ворочать как единым целым, например, при копировании одного массива в другой. Но чаще приходится работать с отдельными его элементами, как «выдернуть» их из массива?
Очень просто: воспользуйтесь индексацией, – она знакома вам по работе со строками. Как и для доступа к отдельному символу строки, для доступа к элементу массива надо указать его индекс, то есть порядковый номер в массиве. Индекс указывают в квадратных скобках, стоящих после имени массива, он представляет собой выражение порядкового типа. Кстати, сходство со строками не случайно, ведь строка – это особый род массива, составленного из отдельных символов.
Рассмотрим примеры доступа к элементам объявленных выше массивов.
Пример 1. Трем элементам массива Names присваиваем фамилии хоккеистов.
Names[1]:= ’Петров’;
Names[2]:= ’Михайлов’;
Names[3]:= ’Харламов’;
Пример 2. Сравниваем третий и четвертый элементы массива Ratings. Здесь индексы заданы через целочисленную переменную n.
…
Ratings[3]:= 12;
Ratings[4]:= 8;
n:=3;
if Ratings[n] > Ratings [n+1] then … else …;
Как видите, индекс в массиве можно вычислять, а это открывает дорогу к циклам. И мы двинемся ею немедленно!
Ввод и вывод массивов
Ввод и вывод – это те задачи, не решив которые, не стоит помышлять о применении массивов. Ни то, ни другое не сделать одним махом. Здесь, как и для множеств, нужны циклы, обрабатывающие отдельные элементы массива.
Взять, к примеру, массив Names, ввести который можно так:
for i:=1 to 30 do Readln(F, Names[i]);
Здесь F – это открытый для чтения текстовый файл, каждая строка которого содержит фамилию.
На первый взгляд все просто. Просто, да не гладко, – это будет работать лишь с файлом, в котором не менее 30 строк (по числу циклов). А иначе случится ошибка: противозаконное чтение за пределами файла. Как избежать её? Внимательней присматривайте за концом файла, вот так:
i:=1;
{ пока не конец файла и не введены все элементы }
while not Eof(F) and (i<=30) do begin
Readln(F, Names[i]);
i:= i+1;
end;
А вот ещё один хороший вариант.
for i:=1 to 30 do begin
if Eof(F) then break; { если конец файла, прервать цикл }
Readln(F, Names[i]);
end;
Вывод массива в файл не представляет труда, вот пример.
for i:=1 to 30 do Writeln(F, Names[i]);
Разумеется, что файловая переменная F должна быть открыта для записи.
Ошибки индексации
Объявление массива, как сказано, содержит границы для индексов: MIN – номер первого элемента, и MAX – номер последнего. А что случится при попытке обратиться к элементу с меньшим, чем MIN номером? Или наоборот – с большим, чем MAX? Иначе говоря, что случится при попытке доступа к несуществующему элементу массива? Такие ошибки преследуют даже опытных программистов, а последствия зависят от способа, которым вы совершите сей проступок.
Предположим, в программу вкрался такой оператор:
Names[200]:= ’Синичкин’;
Поскольку в массиве Names нет элемента с индексом 200, здесь вас остановит компилятор, – ошибка слишком явна, чтобы он промолчал. Вам не останется ничего иного, как исправить индекс, иначе программа не откомпилируется.
Но, когда индекс вычисляется при исполнении программы, нарушение границ проявляется и обрабатывается иначе, например:
Readln(N);
Writeln(Names[N]);
Нам не угадать, что введет пользователь в переменную N, – здесь ошибка нарушения границ может возникнуть при выполнении программы. В главе 27 мы рассматривали ошибки времени исполнения, – это как раз такой случай. Если указать индекс, выходящий за границы массива, то реакция программы будет зависеть от настройки компилятора, точнее, от опции контроля диапазонов. Напомню, что эта опция управляется директивой $R, а также доступна через меню по цепочке:
Options –> Compiler… –> Runtime Errors –> Range checking
Рассмотрим вариант компиляции при включенном контроле границ ($R+). Тогда, при нарушении границ индекса, программа выдаст аварийное сообщение «Range check error». То есть, она заметила нарушение границ индекса, «крикнула» об этом и прервала работу.
Теперь отключим контроль диапазонов ($R-) и перекомпилируем программу. Она станет «легче» и быстрее, и по ходу выполнения проверять границы не станет. Но ошибки не пройдут бесследно. Наоборот, последствия будут тяжелыми и непредсказуемыми! Отключать проверку диапазонов позволительно только в тщательно проверенной программе.
Лучший способ избежать нарушения границ индексов – взять проверку на себя. В данном случае это можно сделать так:
repeat
Readln(N);
if N in [1..30]
then Writeln(Names[N])
else Writeln(’Ошибка! Введите индекс от 1 до 30’);
until N in [1..30]
Этот цикл будет терзать пользователя, пока тот не введет допустимое значение индекса, или не выключит компьютер.
Итоги
• Массив – это сложный тип данных, объединяющий в себе несколько однотипных переменных – элементов массива.
• Все элементы массива носят одно общее имя – это имя самого массива. Внутри массива элементы различаются своими порядковыми номерами – индексами.
• В объявлении массива указывают две его характеристики: диапазон индексов и тип элементов.
• Индекс элемента может быть задан числом или выражением порядкового типа.
• Указание неверного индекса порождает ошибки либо при компиляции, либо при выполнении программы.
• Ввод массива из текстового файла и вывод в него возможен только поэлементно, для чего организуют цикл.
А слабо?
А) Массив A и переменная C объявлены так:
var A : array [’a’..’z’] of integer;
C: char;
Допустимо ли такое объявление массива и почему? Сколько элементов содержит массив? Какие из указанных ниже операторов будут (или могут) вызывать ошибки нарушения диапазонов?
A[’s’]:= 10;
A[’R’]:= 10;
C:=’d’; A[C]:= 10;
Readln(C); A[C]:= 10;
Проверьте свои решения на практике.
Глава 40
Пристрелка на знакомых мишенях
Итак, из арсенала Паскаля мы извлекли ещё одно мощное оружие – массивы. Опробуем его на знакомых мишенях, – некоторые наши программы можно улучшить, например, программу «вопрос-ответ» или полицейскую базу данных.
Вопрос-ответ – добиваемся гибкости
В 16-й главе мы смастерили шуточную программку, невпопад отвечающую на вопросы пользователей. Жаль только, что ответы намертво вбиты в саму программу. Скоро пользователям надоест смеяться над одним и тем же, и они забросят игрушку. Так пусть ваши приятели сами сочиняют смешные ответы и помещают их в текстовый файл, и тогда программа при запуске будет загружать их оттуда.
Прежде всего, подумаем над размещением вводимых из файла строк, где поселить их? «В массиве строк», – скажете, и будете правы. А сколько элементов запасти в этом массиве? Чем больше, тем лучше? Некоторые компиляторы накладывают ограничение на размер массива, но сотню строк они позволят, и этого пока достаточно. Итак, для хранения ответов объявим массив из 100 строковых переменных.
Перейдем к процедуре ввода этих строк. Техника ввода массива рассмотрена в предыдущей главе. Но теперь надо ещё и подсчитать введенные строки, иначе в дальнейшем мы не всегда сможем правильно индексировать массив, – ведь фактическое количество строк в файле может быть и меньше ста. С этой целью объявим переменную Fact, в которой и сделаем нужный нам подсчёт.
Обсудив эти моменты, обратимся к программе «P_40_1».
{ P_40_1 – Программа «вопрос-ответ» с применением массива }
const CAnswers = 100; { размер массива с ответами }
{ объявление типа для массива ответов }
type TAnswers = array[1..CAnswers] of string;
var Answers : TAnswers; { объявление массива ответов }
Fact : integer; { фактическое количество ответов }
F : text; { файл с ответами }
S : string; { строка с вопросом }
{ Процедура ввода ответов из файла с подсчетом введенных строк }
procedure ReadFromFile(var aFile: text);
var i: integer;
begin
Fact:=0; { для начала подсчета строк обнуляем счетчик }
{ цикл по массиву строк }
for i:=1 to CAnswers do begin
if Eof(aFile) then Break; { если конец файла – выход}
Readln(aFile, Answers[i]); { читаем строку в элемент массива }
Fact:= Fact+1; { наращиваем счетчик строк }
end;
end;
begin {– Главная программа –}
Assign(F, 'P_40_1.in'); Reset(F);
ReadFromFile(F);
Close(F);
Randomize; { чтобы порядок вопросов не повторялся }
{ Начало главного цикла }
repeat
Write('Введите вопрос: '); Readln(S);
if S<>'' then Writeln(Answers[Random(Fact)+1]);
until S='';
end.
Открыв файл ответов «P_40_1.IN», мы вызываем процедуру ReadFromFile (читать из файла), которая загружает строки в массив Answers (ответы). Она же подсчитывает введенные строки в переменной Fact. Таким образом, если файл содержит больше сотни строк, то в массив попадёт первая сотня, а иначе – столько, сколько там есть фактически, и это количество покажет переменная Fact. Дальше всё работает, как в прежнем варианте: после ввода вопроса ответ случайным образом выбирается из массива. Индекс элемента с ответом определяется выражением Random(Fact)+1. Если помните, функция Random(Fact) возвращает значения в диапазоне от 0 до Fact-1, а индексы нашего массива начинаются с единицы.
Полицейская база данных – ускоряем поиск
А теперь освежите в памяти другое наше творение – программу поиска угнанных автомобилей в полицейской базе данных (глава 29). Её слабость в том, что поиск номеров выполняется в текстовом файле. Ах, если б вы знали, как «тормозит» такой поиск! Вы не заметили? Да, на десятках строк этого не ощутить, иное дело – сотни тысяч, или миллионы. Итак, перенесем список номеров из текстового файла в массив, и тогда поиск ускорится многократно!
