Обработка структур данных

Count, Result:Word; {Число считываемых и фактически считанных}

Buf: Array[1..2000] of Char;{переменная чтения}

BEGIN

ClrScr;

Write(`Введите имя файла: ');Readln(Fname);

Assign(F, Fname); Reset(F,RecSize); {Откр. файлы размером }

Write(`Введите имя нового файла: ');Readln(Fname1); {записи }

Assign(F, Fname1); Rewrite(F,RecSize); { RecSize}

Count:=100; {Число записей чтения.вывода}

While not Eof(F) do

Begin

BlockRead(F,Buf, Count, Result); {читаем в Buf блоком Count *RecSize }

BlockWrite(F1, Buf , Result, Count); {записываем в другой }

End;

Close(F); Close(F1);

END.

Задача №3 Разработать программу создания копии любого файла (копировать блоком байт). Имена файлов запрашиваем в режиме диалога.

Справка.

1). Часто целесообразно задавать размер записи в 1б и тогда читать и записывать размером в буфер.

2). Цикл чтения и записи ограничить условиями:

ѕ (NumRead=0) обозначает, что читать уже нечего (конец файла);

ѕ (NumRead<> Sizeof(Buf)) обозначает, прочитана последняя порция;

ѕ (NumWrite<>NumRead) - нет места на диске, куда записываем.

3). Что бы процесс копирования не был безликим, можно использовать анимацию процесса копирования:

ѕ просто вывести сообщение, что идет копирование {*};

ѕ сообщение выводить по несколько символов с небольшой задержкой и выделяя цветом (см. фрагмент программы ниже {**});

ѕ вывод символа (анимация) ниже сообщения.{***})

Uses Crt;

Var

F_old,F_new: File;{файл. перем. для исходного и результирующего файлов}

Fname1,Fname2: String; {имена файлов}

Buf:Array[1..2000] of Char; {переменная чтения и записи}

NumRead, NumWrite:Word;{действительно прочитанные и записанные}

BEGIN

ClrScr;

Write(`Откуда копируем:'); Readln(Fname1);

Assign(F_old, Fname1); Reset(F_old,1); {файл чтения - размер записи 1б}

Write(`Куда копируем:'); Readln(Fname2);

Assign (F_new, Fname2);Rewrite(F_new,1);{файл записи - размер записи 1б}

{*} Writeln(`Идет копирование ',FileSize(F_old), ` байт файла `, Fname1);

Delay(1000);

Repeat {в цикле }

BlockRead(F_old, Buf, Sizeof(Buf),NumRead); {читаем из одного}

BlockWrite(F_new, Buf , NumRead, NumWrite); {записываем в другой}

Until (NumRead=0) or (NumWrite<>NumRead);

{или (NumRead<> Sizeof(Buf))}

{пока читать будет нечего или нет места на диске, куда записываем}

If (NumWrite<>NumRead) Then

Writeln (`Не хватило места на диске - ',(NumRead-NumWrite),' байт');

Close(F_old); Close(F_new);

END.

{**} - вывод строки сообщения с подсветкой.

Str(FileSize(F_old), st1); {Размер файла преобразовываем в строку}

St:= `Идет копирование '+st1+` байт файла `+ Fname1; {Собираем строку}

GoToXY(10,4); Write(st); {Выводим строку сообщения}

GoToXY(10,4); {Устанавливаем курсор в 1-ую позицию строки}

TextColor(red); {Задаем цвет}

Repeat {В цикле;}

Write(Copy(st,1,5);{выводим 5-ть символов строки}

Delete(st,1,5); {удаляем их из строки}

Delay(1000); {задерживаем вывод}

Until length(st)<5; {пока длина строки не станет меньше порции символов вывода}

Write(st); {выводим оставшиеся символы строки}

{***} - подсветка ниже выведенной строки.

Str(FileSize(F_old), st1); {Размер файла преобразовываем в строку}

St:= `Идет копирование '+st1+` байт файла `+ Fname1; {Собираем строку}

GoToXY(10,4); Write(st); {Выводим строку}

GoToXY(10,6); {Устанавливаем курсор под 1-ую позицию строки}

For i:=1 to length(st) do {в цикле до конца строки}

Begin

Write(`#'); {выводим символ}

Delay(1000); {задерживаем вывод}

End;

Задача №4 Разработать программу создания копии любого файла аналогично команде Copy MS DOS, т.е. запуская которую из командной строки (.EXE), могли сразу задавать имена исходного файла и его копии.

Справка.

1). Вспомним, что команда Copy имеет 2 параметра:

<имя исходного файла> <имя результирующего файла>, разделенные пробелом.

U:\Copy Old.txt New.txt

2) Нужно разработать программу, что бы вместо команды Copy использовать EXE-файл программы и рядом <имя исходного файла> <имя результирующего файла>, разделенные пробелом.

U:\<имя файла>.EXE Old.txt New.txt

3).Для этого в программе нужно использовать функции:

ѕ ParamStr(ParNumb:Word):String - возвращает значение параметра командной строки с номером, заданным ParNumb.

ѕ ParamCount - возвращает количество параметров командной строки.

Uses Crt;

Var

F_old,F_new: File; {файловые перем. для исходного и копии}

Buf:Array[1..2048] of Char; {переменная чтения и записи}

NumRead, NumWrite:Word;{действительно прочитанные и записанные}

BEGIN

ClrScr;

{ Проверяем наличие параметров командной строки}

If ParamCount<>2 Then

Begin

Writeln(`Укажите в командной строке через пробел:');

Writeln(`имя файла.EXE <имя исходного файла> <имя копии>');

EXIT;

End;

{ Открываем файлы для чтения и записи}

Assign(F_old , ParamStr(1)); Reset(F_old,1); {файл чтения - 1-ый параметр}

Assign(F_new,ParamStr(2));Rewrite(F_new,1);{файл записи - 2-ой параметр }

Writeln(`Идет копирование ',FileSize(F_old), ` байт файла `,ParamStr(1)) );

{ Создаем жесткую копию файла}

Repeat {в цикле }

BlockRead(F_old, Buf, Sizeof(Buf),NumRead); {читаем из одного}

BlockWrite(F_new, Buf , NumRead, NumWrite); {записываем в другой}

Until (NumRead=0) or (NumWrite<>NumRead);

{ Сообщение нехватки места на диске присоздании копии}

If (NumWrite<>NumRead) Then

Writeln (`Не хватило места на диске - ',(NumRead-NumWrite),' байт');

Close(F_old); Close(F_new);

END.

6. ЗАПИСИ

6.1 Теоретические сведения

Одной из самых распространенных задач программирования является структурирование информации. Наряду с массивами к группе структурированных типов относится тип запись (Record). Структурные типы называются еще сложными типами или составными.

ЗАПИСЬ можно определить как совокупность фиксированного числа компонент различных типов, называемых полями записи.

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

Описание записи:

1) Запись описывается в разделе описания типов данных Type и имеет следующий вид:

Type

<имя типа>=Record {начало описания записи}

<имя переменной 1>:<тип переменной>;

<имя переменной 2>:< тип переменной>;

…

<имя переменной N>:< тип переменной>;

End; {конец описания записи}

2) .Например, если запись будет состоять из характеристики монитора, то описание будет:

Uses Crt;

Const

N=50;

Type

Monitor_Type =Record {имя типа}

Names:String; {поле марки модели монитора}

Price:Word; {поле цены монитора}

Diagonal:Real; {поле диагонали}

End; {конец описания записи}

Var

Monitor: Monitor_Type; {одна запись}

BEGIN

END.

3) Если несколько полей имеют один и тот же тип, то их можно перечислить через запятую.

Type

Monitor_Type =Record {имя типа}

Names:String; {поле марки модели монитора}

Price, Diagonal:Real; {поле цены и диагонали монитора}

End; {конец описания записи}

4) Число полей может быть произвольным, но суммарный размер полей не превышает 64 Кб. Для приведенного выше примера:

SizeOf (Monitor)= SizeOf (String) + SizeOf (Real)*2= 256+6*2=268 байт.

Работа с записями целиком:

1). Применяется в операции присвоения, если обе переменные имеют один тип. При выполнении операции присвоения всем полям переменной слева присваиваются значения полей переменной справа.

Type

Monitor_Type =Record {имя типа}

Names:String; {поле марки модели монитора}

Price, Diagonal:Real; {поле цены и диагонали монитора}

End; {конец описания записи}

Var

Monitor: Monitor_Type;

New_Monitor: Monitor_Type;

BEGIN

Monitor:= New_Monitor; { New_Monitor ранее определен}

END.

2). Используется в качестве формальных и фактических параметров собственных процедур и функций, если они описаны через Type.

Procedre Poisk(New_monitor: Monitor_Type);

3). Применяется при чтении из типизированного файла и записи в типизированный файл, если переменная и файл одного типа:

ѕ Если одна перемення типа запись:

Read(F,New_Monitor); Write(F,New_Monitor);

ѕ Если элемент массива записей типа запись:

For i:=1 to n do For i:=1 to n do

Read(F,Monitor[i]); Write(F,Monitor[i]);

Работа с полями записи:

1) Формируется и обрабатывается запись по полям.

Write(`Вв. марку мрнитора '); Readln(new_monitir.names);

2) Для обращения к какому-либо полю записи указывается имя записи и имя поля записи, которые разделяются «точкой».

<имя записи>.<имя поля записи>

В переменной типа запись:

New_Monitor.Names {поле марки монитора}

New_Monitor.Price {поле цены монитора}

3) С полями записи можно производить любые операции, допустимые для типа данного поля:

ѕ для целочисленного + , -, *, DIV, MOD, SQR, …

ѕ для строкового VAL, STR, COPY, «+», …

4) Можно заменить значение любого поля.

New_Monitor.Price := 1002;

5) Формирование и вывод по полям дает возможность вводить и выводить поля в любой последовательности. А так же выводить только те, которые нужны в том или ином случае.

Writeln( New_Monitor.Price);

Работа со списком записей:

Что бы работать со списком, к примеру, мониторов, можно использовать:

Марка монитора	Цена (у.е)
CTX_PV505	420
Bliss_1940	1295
Pover_Scan_Slim_Pro	589
FineView_Lm1770A	677
View_Sonic_VG_191Black	1485

ѕ массив записей;

Uses Crt;

Type

Monitor_Type =Record {имя типа}

Names:String; {поле марки модели монитора}

Price, Diagonal:Real; {поле цены и диагонали монитора}

End; {конец описания записи}

Var

Monitor: array[1..50] of Monitor_Type;

Monitor[1]

Monitor[2]

ѕ типизированные файлы.

Var

F: File of Monitor_Type;

6.2  Задачи

Задача №1 Разработать программу сортировки записей по цене мониторов и вывода их на экран, используя массив записей и ввод в режиме диалога с клавиатуры.

Алгоритм:

ѕ ввести кол-во записей;

ѕ сформировать массив записей;

ѕ отсортировать массив;

ѕ вывести его на экран.

Справка:

1). Записи формируются, сортируются и выводятся по полям.

2). Не рационально использовать массивы т.к. они занимаеют много памяти.

3). Ввод каждый раз информации теряет смысл.

Uses Crt;

Type

Monitor_Type =Record {имя типа}

Names:String; {поле марки модели монитора}

Price, Diagonal:Real; {поле цены и диагонали монитора}

End; {конец описания записи}

Var

Monitor: array[1..50] of Monitor_Type;

N:Byte;

{Процедура формирования массива записей по полям}

Procedure Read_Info_Monitor(Var Monitor: Monitor_Type; Var n:Byte);

Var

I:Byte;

Begin

Write(`введите количество записей: ');

Readln(n);

For i:=1 to N do

Begin

Write('Введите марку монитора: '); Readln(Monitor[i].Names);

Write(' Введите цену: '); Readln(Monitor[i].Price);

Write(' Введите диагональ: '); Readln(Monitor[i].Diagonal);

End;{For}

End;{-----------------------------------------------------}

{Процедура сортировки массива записей}

Procedure Sort_Price_Monitor(Var Monitor: Monitor_Type; Var n:Byte);

Var

I,j:Byte;

Buf_Monitor: Monitor_Type;

Begin

For i:=1 to N-1 do

For j:=1 to N-i do

If Monitor[j].Price> Monitor[j+1].Price Then {сравниваем поля }

Begin

Buf_monitor:= Monitor[j]; {меняем местами}

Monitor[j]:= Monitor[j+1]; {полностью}

Monitor[j+1]:= Buf_monitor; {записи}

End;

End;{-------------------------------------------------------}

{Процедура вывода полей записи на экран}

Procedure Write_Info_Monitor(Monitor: Monitor_Type; n:Byte);

Var

I:Byte;

Begin

For i:=1 to N do

Writeln(Monitor[i].Names:15, Monitor[i].Price:10, Monitor[i].Diagonal:12);

End;{--------------------------------------------------------------}

BEGIN

ClrScr;

Read_Info_Monitor(Monitor, n); {Формируем массив по полям записи}

Procedure Sort_Price_Monitor(Monitor,n); {Сортируем записи по цене}

Write_Info_Monitor(Monitor, n); {Выводим поля записи на экран}

Readkey

END.

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

Алгоритм:

ѕ открыть текстовый файл для чтения;

ѕ открыть типизированный файл для записи;

ѕ перезаписать информацию из текстового файла в типизированный файл;

ѕ отсортировать типизированный файл по цене;

ѕ просмотреть информацию после сортировки;

ѕ закрыть файлы.

Куда проще информацию занести в текстовый файл, используя любой текстовый редактор, а затем ее обрабатывать программным путем. Из текстового файла всегда можно удалить ненужную информацию, добавить новую, внести корректировки и т.д.

Сам текстовый файл может иметь разный вид:

1) Выстроенный по полям:

Позиции 1( поле1) 30(поле2) 40 (поле3)

CTX_PV505 420 15

BLISS_1940 1295 19

2) Информация набрана в произвольном порядке:

CTX_PV505 420 15

BLISS_1940 1295 19

Справка.

1). Читать из текстового файла нужно в переменную строкового типа.

2). Формирование полей записи зависит от структуры текстового файла, а значит отличие будет только в процедуре формирования записей типизированного файла Text_Type( Var F:Text;Var F1: FF);.

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

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

5). Процедуры открытия файла, сортировки, вывода допишите сами.

Uses Crt;

Type

Monitor_Type =Record {имя типа}

Names:String; {поле марки модели монитора}

Price, Diagonal:Real; {поле цены и диагонали монитора}

End; {конец описания записи}

FF= File of Monitor_Type

Var

F:Text;

F1: FF;

Procedure Open_File( Var F:Text;Var F1: FF);

Begin

End;{-------------------------------------------------------}

{Процедура формирования типизированного файла записей по полям}

Procedure Text_Type( Var F:Text;Var F1: FF);

Var

Sl, St:String;

Code:Integer;

Monitor: Monitor_Type;

Begin

While Not EOF(f) Do {пока не конец текстового файла}

Begin

Readln(F,St); {читаем в строку из файла}

{формируем поля записи:}

{1} Monitor.Names:=Copy(St,1,Pos(` `,st)-1); {часть строки «до пробела»}

{2} Sl:=Copy(St,30,9); {записываем в дополнительную переменную}

While Pos(` `,sl)<>0 Do Delete(sl, Pos(` `,sl),1); {удаляем все пробелы }

Val(Sl,Monitor.Price,code); {переводим строку в число}

{3} Sl:=Copy(St,40,4);

While Pos(` `,sl)<>0 Do

Delete(sl, Pos(` `,sl),1);

Val(Sl,Monitor.Diagonal,code);

Write(F1,Monitor); {записываем запись в файл}

End;

End;{--------------------------------------------------}

{Процедура сортировки типизированного файла}

Procedure Sort_file_price(Var F1:FF);

Begin

End;{---------------------------------------------------}

{Процедура вывода полей записи из типизированного файла}

Procedure Write_Info_Monitor(Var F1:FF);

Begin

End;{----------------------------------------------------}

BEGIN

ClrScr;

Open_File( F, F1); {Открываем текстовый и типизированный файлы}

Text_Type( F, F1); {Формируем записи и выводим в типиз. файл}

Sort_file_price(F1); {Сортируем типизированный файл по цене}

Write_Info_Monitor(F1); {Ввыводим поля записи из типизированного файла}

Readkey;

END.

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

ѕ прочитать строку;

ѕ привести к виду «слово - пробел»;

ѕ копировать слово «до пробела» в поле строкового типа;

ѕ если не строковое, то через дополнительную переменную с преобразованием в числовое поле;

ѕ обязательно удалить из строки, записанное вместе с пробелом;

ѕ записать запись в файл.

Процедуры сортировки типизированного файла и просмотра файла мы уже рассматривали. Главное, что нужно помнить, что читаем и записываем запись целиком, а сравниваем, формируем, выводим - по полям. А вот процедура формирования типизированного файла изменится:

Procedure Text_Type( Var F:Text;Var F1: FF);

Var

Sl, St:String;

Code:Integer;

Monitor: Monitor_Type;

Begin

While Not EOF(f) Do {пока не конец текстового файла}

Begin

Readln(F,St); {читаем в строку из файла и формируем поля записи:}

{Преобразовываем строку}

While pos(' ',st)<>0 do Delete(st, pos(' ',st),1);

If st[1]=' ` then Delete(st, 1,1);

If st[Length(st)]=' ` then Delete(st, Length(st),1);

{Формируем поля записи:}

{1} Monitor.Names:=Copy(St,1,Pos(` `,st)-1);{заносим часть строки «до пробела»}

Delete(St,1,Pos(` `,st)); {удаляем часть строки вместе с пробелом}

{2} Sl:=Copy(St,1,Pos(` `,st)-1); {заносим в дополнительную переменную}

Delete(St,1,Pos(` `,st)); {удаляем часть строки вместе с пробелом}

Val(Sl,Monitor.Price,code); {переводим строку в число}

{3} Val(St,Monitor.Diagonal,code); {остаток строки переводим в число}

Write(F1,Monitor); {записываем запись в файл}

End;

End;{--------------------------------------------------}

Задача №2 Откорректировать типизированный файл (внести изменения), например цены на мониторы (подорожание или понижение цены во время акции).

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

Procedure Change_Price(Var F1:FF);

Var

N:Byte; {номер записи}

Begin

N:=0; {начальный номер записи}

While Not EOF(f1) Do {пока не конец файла}

Begin

Seek(F1,n); {устанавливаем указатель на текущую запись}

Read(f1,Monitor); {читаем запись}

Write(`Введите новую цену');

Readln(Monitor.Price); {вводим новую цену}

Seek(F1,n); {возвращаем указатель на ту же запись}

Write(F1,Monitor); {записываем запись на то же место в файл}

Inc(n); {переходим на следующую запись}

End;

End;{------------------------------------------------------}

Задача №3 В типизированном файле, состоящем из записей, которые будут содержать:

ѕ номер группы,

ѕ фамилию студента,

ѕ и средний балл экзаменационной сессии,

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

Алгоритм этой задачи условно можно разбить на 4 части:

- открытие файла (процедура Open_File);

- запись информации в типизированный файл (процедура Create_File);

- замена номера группы в файле (процедура Substitute) ;

- вывод из файла на экран (процедура Write_Con).

Справка:

1). В этой программе напрямую сформируем типизированный файл с проверкой на ввод пустой строки. Поэтому, первое поле введем в строковую переменную и, если это не пустая строка, то будем формировать поля записи.

2). Формировать запись, обрабатывать ее, выводить на экран - только по полям. Поэтому, можно прочитав запись из файла, работать только с интересующим нас полем. В данном случае заменять интересующее нас поле, присваивая ему новое значение (stud.g:=n_g;).

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

Seek(f1,n); - устанавливаем указатель на запись

Read(f1,stud); - читаем ее из файла

После замены, записываем:

Seek(f1,n); - устанавливаем указатель на ту же запись

Write(f1,stud); - выводим в файл на то же место.

4). Прцедуру вывода используем дважды.

Uses Crt;

Type

spisok= Record {Тип запись, которая состоит из полей разных типов:}

g:Byte; {группа}

f:String; {фамилия}

m:Real; {средний балл}

End;

ff=File Of spisok; {файловая переменная типа список}

Var

f1:ff; {f1 - файловая переменная типизированного файла}

Procedure Open_File(Var f1:ff); {Процедура открытия файла}

Var

fname:String; {fname - имя типизированного файла}

Begin

ClrScr;

Writeln('Вв.имя файла:'); Readln(fname); {Вводим имя файла,}

Assign(f1,fname); {Связываем его с файловой переменной}

Rewrite(f1); {Открываем новый файл}

End;{-------------------Конец процедуры Open_File----------------------}

{Процедура формирования типизированного файла}

Procedure Create_File(var f1:ff);

Var

stud:spisok; {stud переменная типа список}

st:string; {Строка для ограничения цикла при вводе списка}

code:Integer;{Обязательный параметр процедуры преобразования строки в число}

Begin

{формируем поля записи и записываем в типизированный файл типа запись}

Repeat {В цикле}

write('Введите группу '); Readln(st); {вводим номер группы как строку}

If st<>'' then Begin {если строка не пустая}

Val(st,stud.g,Code); {преобразовываем ее в первое поле записи}

Write('Введите фамилию '); Readln(stud.f); {вводим 2-ое поле записи}

Write('Введите средний балл '); Readln(stud.m); {вводим 3-е поле записи}

Write(f1,stud); {записываем всю запись в файл типа запись}

End;

Until st=''; {пока не введем пустую строку}

End; {-------------------Конец процедуры Create_File ------------------}

Procedure Write_Con(Var f1:ff); {Процедура вывода из файла на экран}

Var

stud:spisok; {stud переменная типа запись с 3 полями}

y:Byte; {Координата вывода}

i:Byte;

Begin

ClrScr;

Reset(f1); {Устанавливаем курсор в начало файла}

GoToXy(5,2); Write('ГРУППА'); {Выводим "шапку" 1-го}

GoToXy(15,2);Write('ФАМИЛИЯ СТУДЕНТА');{второго поля}

GoToXy(35,2);Write('СРЕДНИЙ БАЛЛ'); {третьего поля}

y:=3; {Устанавливаем начальную координату вывода}

While Not EOF(f1) Do {В цикле до конца файла}

Begin

Read(f1,stud); {читаем всю запись}

GoToXy(5,y); writeln(stud.g); {устанавливаем курсор}

GoToXy(15,y); Write(stud.f); {выводим каждое поле отдельно}

GoToXy(35,y); Write(stud.m:4:2);

inc(y); {изменяем координату вывода}

If y=25 Then {Если вся страница заполнена}

Begin

Readkey; {задерживаем выдачу на экране}

Y:=3; {устанавливаем координату первой строки следующей страницы}

End;

End;

For i:=y To 25 Do {чистим экран от последней строки вывода до 25}

Writeln(' ');

End; {-------------------Конец процедуры Write_Con ----------------------}

Procedure Substitute(Var f1:ff);{Процедура замены номера группы во всем файле}

Var

stud:spisok; {Переменная типа запись}

n,n_g:Byte; {n - номер записи в файле,

n_g - номер группы для замены}

Begin

ClrScr;

Write('ВВЕДИТЕ НОМЕР ГРУППЫ>'); {Выводим запрос на ввод}

Readln(n_g); {Вводим номер группы}

Reset(f1); {Устанавливаем курсор в начало файла}

n:=0; {Начинаем с нулевой записи}

While Not Eof(f1) Do {Пока не конец файла}

Begin

Seek(f1,n); {Устанавливаем указатель на запись}

Read(f1,stud); {Читаем ее из файла}

stud.g:=n_g; {Заменяем номер группы}

Seek(f1,n); {Устанавливаем указатель на ту же запись}

Write(f1,stud); {Выводим в файл на то же место}

Inc(n); {Увеличиваем номер записи для перехода на следующую}

end;

end; {-----------------Конец процедуры Substitute--------------}

BEGIN

Open_File(f1); {Открываем файл}

Create_File(f1); {Записываем в типизированный}

Write_Con(f1); {Выводим из файла на экран}

Readkey;

Substitute(f1); {Заменям номер группы по всему файлу}

Write_Con(f1); {Выводим из файла на экран}

Readkey;

Close(f1);

END.

Размещено на Allbest.ru

...