Программирование на языке Паскаль

Пусть s - искомая сумма,

i - очередная цифра числа.

Тогда алгоритм решения задачи можно описать следующим образом:

обнуляем сумму s ,

берем последнюю цифру числа, для чего определяем остаток от деления исходного числа на 10: i = n Mod 10,

добавляем в сумму найденную цифру: s = s + i,

уменьшаем число в 10 раз: n = n Div 10,

повторяем цикл до тех пор, пока n = 0 - это и будет условием выхода из цикла.

Схема алгоритма: Программа:

Program Sum;

Uses CRT;

Var i, s, n : Word;

Begin

ClrScr;

Write(`n= `);

ReadLn(n);

s := 0;

Repeat

i := n Mod 10;

s := s + i;

n := n Div 10;

Until (n = 0);

WriteLn(`s = `, s);

ReadLn;

Endввести с клавиатуры по одному последовательность целых чисел (конец последовательности - число 0). Определить их сумму, максимальное и минимальное число, количество введенных чисел и их среднее арифметическое.

Пусть s - искомая сумма,

min, max - минимальное и максимальное из введенных чисел,

count - количество введенных чисел,

sred - среднее арифметическое,

n - очередное число.

Тогда алгоритм решения задачи можно описать следующим образом:

обнуляем сумму s ,

вводим первое число n,

если оно не равно нулю, то

принимаем его значение за min и max

количество введенных чисел count = 1

увеличиваем сумму на введенное число s = s + n

входим в цикл ввода:

вводим очередное число n,

если оно не равно нулю, то

количество введенных чисел увеличиваем на 1: count = count +1

увеличиваем сумму на введенное число s = s + n

если оно меньше min, то min = n,

если оно больше max, то max = n,

повторяем цикл до тех пор, пока n = 0 - это и будет условием выхода из цикла.

Создадим интерфейс этой задачи - взаимодействие программы с пользователем, то есть что должно выводиться на экран:

Первое число: 3

Очередное число: 8

Очередное число: 1

Очередное число: -2

Очередное число: 0

Сумма = 10

Количество чисел = 4

Min = -2

Max = 8

Среднее арифметическое = 2.50

Схема алгоритма:



Программа

Program Posled;

Uses CRT;

Var n,min,max,s,count: Word;

sred: Real;

Begin

ClrScr;

s := 0;

Write(`Первое число:');

ReadLn(n);

If (n = 0)

Then Exit;

min := n;

max := n;

count := 1;

s := s + n;

Repeat

Write(`Oчередное число:');

ReadLn(n);

If (n <> 0) Then

Begin

count := count + 1;

s := s + n;

If (n > max)

Then max := n;

If (n < min)

Then min := n;

End { If (n <> 0 )}

Until (n = 0);

sred := s / count;

WriteLn;

WriteLn(`Сумма =',s);

WriteLn(`Количество чисел =',count);

WriteLn(`min=',min);

WriteLn(`max=',max);

WriteLn(`Среднее арифметическое =',sred:5:2);

ReadLn;

End.

вычислить s - сумму членов бесконечного ряда:

s = 1 + x/ 1! + x2 / 2! + x3 / 3! + … + xk / k! + …

с погрешностью е0.

Каждый последующий член ряда можно определить через предыдущий, используя рекуррентную формулу:

yk+1 = yk·x / k

Текущая погрешность вычислений е определяется последним просуммированным членом ряда:

е =|yn|

Эту погрешность необходимо сравнить с заданной погрешностью е0 для реализации условия окончания суммирования:

- если е > е0 , то заданная точность еще не достигнута, и суммирование ряда необходимо продолжить, прибавив к имеющейся сумме еще один член,

- если е <= е0 , то заданная точность достигнута, и суммирование необходимо прекратить.

Пусть s - искомая сумма,

y - очередной член ряда,

k - номер члена ряда,

eps_0 - заданная точность вычислений,

x - вводимый аргумент.



Схема алгоритма: Программа:

Program Summa;

Uses CRT;

Const eps_0 = 0.001;

Var k : Word;

x, y, s : Real;

Begin

ClrScr;

Write(`Значение аргумента = `);

ReadLn(x);

k :=0;

y := 1.0; обязательно указать дробную часть!

s :=y;

Repeat

k := k + 1;

y := y * x / k;

s := s + y

Until (Abs(y)<=eps_0);

WriteLn;

WriteLn(`Сумма равна ',s:5:2);

ReadLn;

End.



Циклы с постусловием обычно используются в фильтрах входных данных - исходные данные вводятся до тех пор, пока они не будут корректными, а некорректные исходные данные отвергаются.

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

Программа: Схема фильтра (month - номер месяца)

Program Mesjac;

Uses Crt;

Var Month: 1..12;

Begin

ClrScr;

Repeat

Write(`Введите номер месяца:');

ReadLn(Month);

Until (Month>=1) And (Month<=12);

Case (Month) Of

4,6,9,11: WriteLn('30 дней');

1,3,5,7,8,10,12: WriteLn('31 день');

2: WriteLn('28 дней');

End; здесь можно обойтись без ветви Else

ReadLn;

End.

Циклы с пред- и постусловиями используются тогда, когда заранее неизвестно количество их повторений (итераций). Если количество итераций известно заранее, то используются циклы с параметром.

Часто встречающиеся ошибки программирования:

1. Использование в качестве условия выражения не логического типа:

Repeat. . .

Until (n + m);

2. Отсутствие условия после слова Until:

Repeat. . .

Until;

Использование после слова Repeat двоеточия или точки с запятой:

Repeat;. . .

Until (n >= 10);

Циклы с параметром

Управление работой циклов с параметром осуществляется не условием, а значением специальной переменной - параметра цикла (счетчика).

Схему цикла с параметром можно представить в следующем виде:

где i - параметр цикла - любая переменная порядкового типа (целого, символьного, интервального, перечисляемого),

i_нач - его начальное значение,

i_кон - его конечное значение.

Действия цикла:

параметру цикла i присваивается его начальное значение i_нач,

если оно не превосходит конечного (i_нач ? i_кон), то выполняется тело цикла,

параметр цикла автоматически увеличивается на единицу, и цикл повторяется до тех пор, пока параметр цикла не достигнет своего конечного значения,

если начальное значение параметра цикла больше его конечного значения (i_нач > i_кон), то цикл не выполняется ни разу.

В Паскале циклы с параметром реализуются оператором цикла:

For i := iнач To iкон Do это заголовок цикла

оператор;

или

For i := iнач To iкон Do

Begin

оператор;

оператор;

оператор;

End;

Если в заголовке цикла используется служебное слово To (к), то шаг изменения параметра цикла равен +1.

Если в заголовке цикла используется служебное слово DownTo (уменьшая до), то шаг изменения параметра цикла равен -1.

Внимание! После слова Do точка с запятой никогда не ставится!

Пример: определить сумму s натуральных чисел от 1 до 100.



Схема алгоритма: Программа:

Program Gauss;

Uses CRT;

Var n, s : Word;

Begin

ClrScr;

s := 0;

For n:=1 To 100 Do

s := s + n;

WriteLn(`Сумма равна ', s);

ReadLn;

End.

Эту же задачу можно решить, суммируя числа справа налево, то есть от 100 до 1:

Program Gauss;

Uses CRT;

Var i, s : Word;

Begin

ClrScr;

s := 0;

For i:=100 DownTo 1 Do

s := s + i;

WriteLn(`Сумма равна ', s);

ReadLn;

End.

Построение операторов цикла For подчиняется следующим правилам:

1. начальное и конечное значения параметра цикла можно задавать константами (как в примере), заранее определенными переменными или выражениями,

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

m := 1;

n := 10;

For j := m To n Do

Begin

a[j] := j + 10;

m := m + 1; ошибка!

n := n + 1; ошибка!

End;

Выходим из этого цикла со значением параметра цикла j, равным 10.

Нежелательно внутри области цикла самому изменять значение параметра цикла - это может привести к появлению бесконечных циклов:

s := 0;

n := 10;

For k := 1 To n Do

Begin

k := k + 1;

s := s + k;

End;

Эта программа вычисляет сумму s четных целых чисел от 2 до 10, равную 30. При этом конечное значение параметра цикла k равно 10 .

Зададим n = 11:

s := 0;

n := 11;

For k := 1 To n Do

Begin

k := k + 1;

s := s + k;

End;

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

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

s := 0;

p := 1;

For k := 10 To 1 Do

Begin

p := p * k;

s := s + k;

End;

Выходим из этого цикла со значением k, равным 0.

3. допускается использование цикла в цикле, при этом циклы должны иметь различные параметры цикла:

For i := 1 To n Do эти циклы выводят элементы массива Anm

Begin в виде матрицы, построчно

For j:= 1 To m Do

Write(a[i,j]:5);

WriteLn;

End;

4. после окончания работы цикла значение параметра цикла сохраняется,

5. в область цикла можно входить только через заголовок цикла For;

не разрешается переход с помощью операторов If и GoTo, расположенных вне данного цикла, на операторы в области цикла:

If (p Mod s > 10)

Then GoTo 5; ошибка - переход в тело цикла, минуя его заголовок

For i := 1 To 10 Do

Begin

s := s + i;

5: p := p + i;

End;

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

For i := 1 To 100 Do

Begin

If (a[i]=0)

Then Goto 2; переход внутри тела цикла

a[i] := 1 / a[i];

2:

End;

7. с помощью оператора Break можно досрочно выйти из цикла:

For i := 1 To 100 Do

Begin

k := i;

If (a[i] < 0)

Then Break; поиск первого отрицательного элемента в векторе

End;

8. оператор Continue позволяет досрочно перейти к следующей итерации цикла:

For i := 1 To 100 Do

Begin

If (a[i] = 0)

Then Continue; если ноль, то на следующую итерацию

a[i] := 1 / a[i];

End;

Основное назначение циклов с параметром - обработка массивов, причем параметр цикла отождествляется с индексом (номером) элемента массива.

Примеры:

1. Задать элементы целочисленного вектора vectorn случайными числами, лежащими в диапазоне от vect_min до vect_max.

Для решения этой задачи используется стандартная функция - генератор случайных чисел Random(k). При каждом обращении к этой функции она вырабатывает целое случайное число, лежащее в диапазоне от 0 до k - 1.

Program Primer_1;

Uses WinCrt;

Const n = 10; задание исходных данных в виде именованных констант

vect_min = -10;

vect_max = 20;

Var i : Word; параметр цикла

Vector : Array [1..n] Of Integer; описание вектора с использованием константы n

Begin

ClrScr; очистка экрана

Randomize; запуск генератора случайных чисел

For i:=1 To n Do заполнение вектора случайными числами

Vector[i]:=Random(vect_max - vect_min + 1) + vect_min;

For i:=1 To n Do форматный вывод вектора на экран в одну строку

Write(Vector[i]:5);

WriteLn; переход на новую строку на экране

ReadLn; задержка картинки на экране до нажатия на ENTER

End.

2. Задать элементы целочисленного массива massivnm случайными числами, лежащими в диапазоне от mass_min до mass_max. Полученный массив вывести на экран построчно.

Program Primer_2;

Uses WinCrt;

Const n = 5;

m = 8;

mass_min = -50;

mass_max = 50;

Var i, j : Word; параметры циклов

Massiv : Array [1..n, 1..m] Of Integer; описание массива с использованием констант n и m

Begin

ClrScr;

Randomize; запуск генератора случайных чисел

For i:=1 To n Do заполнение массива случайными числами

For j:=1 To m Do в заданном диапазоне

Massiv[i, j]:=Random(mass_max - mass_min + 1) + mass_min;

For i:=1 To n Do форматный вывод массива на экран построчно

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn; переход на новую строку на экране

End;

WriteLn;

ReadLn;

End.

3. Задать элементы целочисленного массива massivnm в виде чисел от 1 до n*m . Полученный массив вывести на экран построчно:

Program Primer_3;

Uses WinCrt;

Const n = 3;

m = 5;

Var i, j, k : Word;

Massiv : Array [1..n, 1..m] Of Word;

Begin

ClrScr;

k:= 0; рабочая переменная для задания элементов массива

For i:=1 To n Do заполнение массива

For j:=1 To m Do

Begin

k:= k + 1;

Massiv[i, j]:= k;

End;

For i:=1 To n Do форматный вывод массива на экран построчно

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

ReadLn;

End.

4. Задать элементы целочисленного вектора vectorn случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран в одну строку. Определить индекс i_max и значение vector_max максимального элемента вектора.

Перед поиском максимального элемента вектора за таковой принимается первый элемент вектора, а затем он сравнивается с остальными элементами:

Program Primer_4;

Uses WinCrt;

Const n = 10; задание исходных данных в виде именованных констант

vect_min = -10;

vect_max = 10;

Var i, i_max, vector_max : Integer;

Vector : Array [1..n] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max - vect_min + 1) + vect_min;

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

Vector_max:= Vector[1]; пока максимальный элемент - первый

i_max:= 1; элемент вектора

For i:=2 To n Do поиск начинаем со второго элемента!

If (Vector[i] > Vector_max) Then если очередной элемент больше

Begin текущего максимального,

Vector_max := Vector[i]; то максимальным элементом

i_max := i; становится очередной элемент вектора

End;

WriteLn(`Vector_max=', Vector_max);

WriteLn(`i_max=', i_max);

ReadLn;

End.

5. Задать элементы целочисленного вектора vectorn случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Определить сумму S элементов вектора.

Перед началом суммирования сбрасываем сумму на нуль, потом в цикле будем добавлять в нее очередной элемент:

Program Primer_5;

Uses WinCrt;

Const n = 10; задание исходных данных в виде именованных констант

vect_min = -50;

vect_max = 50;

Var i, s : Integer;

Vector : Array [1..n] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max - vect_min + 1) + vect_min;

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

S := 0; начальная сумма равна нулю!

For i:=1 To n Do добавляем в сумму очередной

s := s + Vector[i]; элемент вектора

WriteLn(`s=', s);

ReadLn;

End.

6. Задать элементы целочисленного вектора vectorn случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Перевернуть вектор: поменять местами первый и последний элементы, второй и предпоследний, и так далее (поплавок):

Program Primer_6;

Uses WinCrt;

Const n = 10;

vect_min = -50;

vect_max = 50;

Var i, k, m : Integer;

Vector : Array [1..n] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max - vect_min + 1) + vect_min;

WriteLn(`Исходный вектор:');

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

m:= n Div 2; средина вектора

For i:=1 To m Do идем до средины вектора

Begin

k:= Vector[i];

Vector[i]:= Vector[n - i + 1];

Vector[n - i + 1]:= k;

End;

WriteLn;

WriteLn(`Полученный вектор:');

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

ReadLn;

End.

7. Задать элементы целочисленного вектора vectorn случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Определить сумму S элементов вектора, лежащих в диапазоне от min до max, и количество count этих элементов.

Перед началом суммирования сбрасываем сумму и количество на нуль, потом в цикле будем добавлять в нее очередной элемент, отвечающий заданным условиям:

Program Primer_7;

Uses WinCrt;

Const n = 10; задание исходных данных в виде именованных констант

vect_min = -50;

vect_max = 50;

min = -10;

max = 10;

Var i, s, count : Integer;

Vector : Array [1..n] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max - vect_min + 1) + vect_min;

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

count:= 0;

s:= 0; начальная сумма равна нулю!

For i:=1 To n Do

If (Vector[i] >= min) And (Vector[i] <= max) проверка условия

Then

Begin

s:= s + Vector[i];

count:= count + 1;

End;

WriteLn(`s=', s);

WriteLn(`count=', count);

ReadLn;

End.

8. Задать элементы целочисленного вектора vectorn случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Поменять местами максимальный max и минимальный min элементы вектора.

Перед началом поиска максимального и минимального элементов за таковые принимается первый элемент вектора. Для обмена местами этих элементов необходимо определить их номера (индексы) i_min и i_max:

Program Primer_8;

Uses WinCrt;

Const n = 10; задание исходных данных

vect_min = -50;

vect_max = 50;

Var i, k, min, max, i_min, i_max : Integer;

Vector : Array [1..n] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max - vect_min + 1) + vect_min;

WriteLn(`Исходный вектор:');

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

min:= Vector[1]; начальные значения минимального

max:= Vector[1]; и максимального элементов массива

i_min:= 1; индексы этих элементов

i_max:= 1;

For i:=2 To n Do начинаем просмотр со второго элемента

Begin

If (Vector[i] < min) Then если очередной элемент вектора

Begin меньше минимального,

min:= Vector[i]; то за минимальный принимаем

i_min:= i; этот очередной элемент

End; и запоминаем его индекс

If (Vector[i] > max) Then если очередной элемент вектора

Begin больше максимального,

max:= Vector[i]; то за максимальный принимаем

i_max:= i; этот очередной элемент

End; и запоминаем его индекс

End;

WriteLn;

WriteLn(`Минимальный элемент=', Vector[i_min]);

WriteLn(`Его индекс=', i_min);

WriteLn(`Максимальный элемент=', Vector[i_max]);

WriteLn(`Его индекс=', i_max);

k:= Vector[i_min]; меняем их местами через

Vector[i_min]:= Vector[i_max]; третью переменную

Vector[i_max]:= k;

WriteLn;

WriteLn(`Полученный вектор:');

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

ReadLn;

End.

9. Задать элементы целочисленного вектора vectorn случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Поменять местами первый отрицательный и последний положительный элементы массива. Предусмотреть случай, когда элементы массива имеют один знак - только отрицательные или только положительные.

Обозначим их индексы как i_otr и i_pol. Перед началом поиска сбросим их на ноль. Если после поиска какой-нибудь из них останется равным нулю, то в векторе - элементы одного знака:

Program Primer_9;

Uses WinCrt;

Const n = 10; задание исходных данных

vect_min = -50;

vect_max = 50;

Var i, k, i_otr, i_pol : Integer;

Vector : Array [1..n] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max - vect_min + 1) + vect_min;

WriteLn(`Исходный вектор:');

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

i_otr:= 0;

i_pol:= 0;

For i:=1 To n Do

If (Vector[i] < 0) Then если очередной элемент вектора

Begin меньше нуля,

i_otr:= i; то запоминаем его индекс

Break; и выходим из цикла

End;

For i:=1 To n Do

If (Vector[i] > 0) если очередной элемент вектора

Then i_pol:= i; больше нуля, то запоминаем его индекс

If (i_otr = 0)

Then WriteLn(`В векторе только положительные элементы');

If (i_pol = 0)

Then WriteLn(`В векторе только отрицательные элементы');

If (i_otr > 0) And (i_pol > 0) Then

Begin

WriteLn;

WriteLn(`Первый отрицательный элемент=', Vector[i_otr]);

WriteLn(`Его индекс=', i_otr);

WriteLn(`Последний положительный элемент=', Vector[i_pol]);

WriteLn(`Его индекс=', i_pol);

k:= Vector[i_otr]; меняем их местами через

Vector[i_otr]:= Vector[i_pol]; третью переменную

Vector[i_pol]:= k;

WriteLn;

WriteLn(`Полученный вектор:');

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

End;

ReadLn;

End.

10. Задать элементы целочисленного вектора vectorn случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Сдвинуть элементы вектора вправо на один шаг, причем последний элемент должен встать на первое место.

Для решения этой задачи запомним последний элемент вектора на переменной posl, сдвинем все элементы на шаг вправо, начиная с предпоследнего, а затем значение переменной posl поместим в первый элемент массива:

Program Primer_10;

Uses WinCrt;

Const n = 10; задание исходных данных

vect_min = -50;

vect_max = 50;

Var i, k, posl : Integer;

Vector : Array [1..n] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max - vect_min + 1) + vect_min;

WriteLn(`Исходный вектор:');

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

posl:= Vector[n]; запоминаем последний элемент вектора

For i:= n DownTo 2 Do

Begin

k:= Vector[i]; сдвигаем элементы вектора

Vector[i]:= Vector[i-1]; на один шаг вправо

Vector[i-1]:= k;

End;

Vector[1]:= posl; вставляем последний элемент

на первое место

WriteLn;

WriteLn(`Полученный вектор:');

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

ReadLn;

End.

11. Задать элементы целочисленного вектора vectork случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Разместить элементы вектора в массиве massivnm построчно (n*m = k):

Program Primer_11;

Uses WinCrt;

Const k = 12; задание исходных данных в виде именованных констант

vect_min = -50;

vect_max = 50;

n = 3;

m = 4;

Var i, j, t : Integer;

Vector : Array [1..k] Of Integer;

Massiv : Array [1..n, 1..m] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To k Do

Vector[i]:=Random(vect_max - vect_min + 1) + vect_min;

WriteLn(`Исходный вектор');

WriteLn;

For i:=1 To k Do

Write(Vector[i]:5);

WriteLn;

t := 0; номер очередного элемента вектора

For i:=1 To n Do

For j:=1 To m Do

Begin

t := t + 1;

Massiv[i, j] := Vector[t];

End;

WriteLn(`Полученный массив');

WriteLn;

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

ReadLn;

End.

12. Задать элементы целочисленного квадратного массива massivnm случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Разместить элементы массива в векторе Vectork построчно (k = n*m):

Program Primer_12;

Uses WinCrt;

Const n = 5;

m = 7;

k = n * m;

mass_min = -50;

mass_max = 50;

Var i, j, t : Integer;

Vector : Array [1..k] Of Integer;

Massiv : Array [1..n, 1..m] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To n Do

Massiv[i, j]:= Random(mass_max - mass_min + 1) + mass_min;

WriteLn;

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

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

t := 0;

For i:=1 To n Do

For j:=1 To m Do

Begin

t := t + 1;

Vector[t] := Massiv[i,j];

End;

WriteLn(`Полученный вектор');

WriteLn;

For i:=1 To k Do

Write(Vector[i]:5);

WriteLn;

ReadLn;

End.

13. Задать элементы целочисленного квадратного массива massivnn случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Транспонировать массив, заменив его строки соответствующими столбцами: первую строку - на первый столбец, вторую - на второй, и так далее. Транспонированный массив вывести на экран построчно:

Program Primer_13;

Uses WinCrt;

Const n = 5;

mass_min = -50;

mass_max = 50;

Var i, j, k : Integer;

Massiv : Array [1..n, 1..n] Of Integer; описание массива с использованием константы n

Begin

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To n Do

Massiv[i, j]:=Random(mass_max - mass_min + 1) + mass_min;

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

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To n Do строки начинаем с первой

For j:=i To n Do столбцы начинаем с главной диагонали

Begin

k:= Massiv[i,j]; транспонирование массива с использованием

Massiv[i,j]:= Massiv[j,i]; алгоритма циклического обмена

Massiv[j,i]:= k; значениями двух переменных через третью

End;

WriteLn(`Транспонированный массив:');

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

ReadLn;

End.

14. Задать элементы целочисленного массива massivnm случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Сдвинуть столбцы массива на шаг вправо, причем последний столбец должен встать на место первого.

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

Program Primer_14;

Uses WinCrt;

Const n = 5;

m = 6;

mass_min = -50;

mass_max = 50;

Var i, j, k, posl : Integer;

Massiv : Array [1..n, 1..m] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To m Do

Massiv[i, j]:= Random(mass_max - mass_min + 1) + mass_min;

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

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To n Do перебираем строки массива

Begin

posl:= Massiv[i, m]; запоминаем последний элемент строки

For j:=m DownTo 2 Do

Begin

k:= Massiv[i,j]; сдвигаем элементы строки на шаг Massiv[i,j]:= Massiv[i, j-1]; вправо

Massiv[i, j-1]:= k;

End;

Massiv[i,1]:= posl; вставляем последний элемент

на первое место в строке

End; конец цикла по строкам

WriteLn(`Полученный массив:');

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

ReadLn;

End.

15. Задать элементы целочисленного квадратного массива massivnn случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Повернуть массив на 900 по часовой стрелке, например:

1 2 3 7 4 1

4 5 6 => 8 5 2

7 8 9 9 6 3

Для выполнения этой операции массив сначала транспонируют, а затем применяют для каждой строки поплавок - переворачивают строки:

Program Primer_15;

Uses WinCrt;

Const n = 5;

mass_min = -50;

mass_max = 50;

Var i, j, k, m : Integer;

Massiv : Array [1..n, 1..n] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To n Do

Massiv[i, j]:= Random(mass_max - mass_min + 1) + mass_min;

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

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To n Do строки начинаем с первой

For j:=i To n Do столбцы начинаем с главной диагонали

Begin

k:= Massiv[i,j]; транспонирование массива с использованием

Massiv[i,j]:= Massiv[j,i]; алгоритма циклического обмена

Massiv[j,i]:= k; значениями двух переменных через третью

End;

WriteLn(`Транспонированный массив:');

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

m:= n Div 2;

For i:=1 To n Do перебираем строки массива

For j:=1 To m Do переворачиваем каждую строку

Begin

k:= Massiv[i,j];

Massiv[i,j]:= Massiv[i, n - j + 1];

Massiv[i, n - j + 1] := k;

End;

WriteLn;

WriteLn(`Полученный массив:');

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

ReadLn;

End.

16.Задать элементы целочисленного массива massivnm случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Определить седловую точку массива. Седловой точкой массива называется элемент, наименьший в своей строке и одновременно наибольший в своем столбце:

Program Primer_16;

Uses WinCrt;

Const n = 5;

m = 10;

mass_min = -50;

mass_max = 50;

Var i, j, k, i_max, j_min : Word;

min, max : Integer;

Massiv : Array [1..n, 1..m] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To m Do

Massiv[i, j]:= Random(mass_max - mass_min + 1) + mass_min;

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

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To n Do перебираем строки массива

Begin

min:= Massiv[i,1];

j_min:= 1; номер столбца с минимальным элементом в этой строке

For j:=2 To m Do

If (Massiv[i,j] < min) Then

Begin

min:= Massiv[i,j];

j_min:= j;

End;

max:= Massiv[1, j_min]; ищем максимальный элемент в столбце,

i_max:= 1; содержащем минимальный элемент этой строки

For k:=2 To n Do

If (Massiv[k,j_min] > max) Then

Begin

max:= Massiv[k,j_min];

i_max:= k;

End;

If (i = i_max) Then

Begin

WriteLn(`Номер строки=',i,

` Номер столбца=',j_min,

` Седловая точка=', Massiv[i, j_min]);

Break;

End;

End; конец цикла по строкам

ReadLn;

End.

17. Задать элементы целочисленного квадратного массива ann случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Заполнить вектор vk суммами элементов исходного массива, расположенных параллельно побочной диагонали (k = 2n - 1).

Для решения этой задачи рассмотрим исходный массив поэлементно:

a11 a12 a13 a14 . . . a1n

a21 a22 a23 a24 . . . a2n

a31 a32 a33 a34 . . . a3n. . . . . . . . . . . . .

an1 an2 an3 an4 . . . ann

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

v1 = a11 сумма индексов элемента 1 + 1 = 2

v2 = a21 + a12 сумма индексов элементов 1 + 2 = 3

v2 = a31 + a22 + a13 сумма индексов элементов 1 + 3 = 4. . . . . . . . .

v2n-1 = ann сумма индексов элемента n + n = 2n

Таким образом, сумма индексов элементов массива, входящих в сумму элементов, на единицу меньше индекса соответствующего элемента вектора:

Program Primer_17;

Uses WinCrt;

Const n = 5;

k = 2*n - 1;

mass_min = -50;

mass_max = 50;

Var i, j, t : Integer;

vector : Array [1..k] Of Integer;

a : Array [1..n, 1..n] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To n Do

a[i, j]:= Random(mass_max - mass_min + 1) + mass_min;

WriteLn;

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

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(a[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To k Do обнуляем выходной вектор

vector [i]:= 0;

For i:=1 To n Do

For j:=1 To n Do

Begin

t:= i + j - 1; определяем индекс элемента вектора

vector[t]:= vector[t] + a[i,j]; вычисляем сумму элементов массива

End;

WriteLn;

WriteLn(`Полученный вектор');

WriteLn;

For i:=1 To k Do

Write(vector[i]:5);

WriteLn;

ReadLn;

End.

18. Задать элементы целочисленного квадратного массива ann случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Заполнить вектор vk суммами элементов исходного массива, расположенных параллельно главной диагонали (k = 2n - 1).

Для решения этой задачи рассмотрим исходный массив поэлементно:

a11 a12 a13 a14 . . . a1n

a21 a22 a23 a24 . . . a2n

a31 a32 a33 a34 . . . a3n. . . . . . . . . . . . .

an1 an2 an3 an4 . . . ann

Заменим элементы исходного массива элементами вычисляемого вектора:

vn vn-1 vn-2 vn-3 . . . v2 v1

vn+1 vn vn-1 vn-2 . . . v3 v2

vn+2 vn-1 vn vn-2 . . . v4 v3. . . . . . . . . . . . . . . .

V2n-1 v2n-2 v2n-3 v2n-4 . . . vn+1 vn

Алгоритм очевиден:

Program Primer_18;

Uses WinCrt;

Const n = 5;

k = 2*n - 1;

mass_min = -50;

mass_max = 50;

Var i, j, m, t : Integer;

vector : Array [1..k] Of Integer;

a : Array [1..n, 1..n] Of Integer;

Begin

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To n Do

a[i, j]:= Random(mass_max - mass_min + 1) + mass_min;

WriteLn;

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

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(a[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To k Do обнуляем выходной вектор

vector[i]:= 0;

m:= n-1;

For i:= 1 To n Do

Begin

m:= m+1;

t:= m;

For j:=1 To n Do

Begin

vector[t]:= vector[t] + a[i,j];

t:= t - 1;

End;

End;

WriteLn;

WriteLn(`Полученный вектор');

WriteLn;

For i:=1 To k Do

Write(vector[i]:5);

WriteLn;

ReadLn;

End.

19.Задать элементы целочисленного трехмерного массива massivknm по слоям в виде чисел от 1 до k*n*m . Вывести на экран верхнюю, переднюю и правую грани массива:



Program Primer_19;

Uses WinCrt;

Const k = 3; количество слоев

n = 4; количество строк в слое

m = 5; количество столбцов в слое

Var i, j, b, c : Word;

Massiv : Array [1..k, 1..n, 1..m] Of Word;

Begin порядок следования индексов: слой, строка, столбец

ClrScr;

c:= 0; рабочая переменная для задания элементов массива

For i:=1 To k Do заполнение слоев массива

For j:=1 To n Do заполнение строк массива

For b:=1 To m Do заполнение столбцов массива

Begin

c:= c + 1;

Massiv[i, j, b]:= c;

End;

WriteLn('Верхняя грань:');

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[1, i, j]:5);

WriteLn;

End;

WriteLn;

WriteLn('Передняя грань:');

For i:=1 To k Do

Begin

For j:=1 To m Do

Write(Massiv[i, n, j]:5);

WriteLn;

End;

WriteLn;

WriteLn('Правая грань:');

For i:=1 To k Do

Begin

For j:=1 To n Do

Write(Massiv[i, j, m]:5);

WriteLn;

End;

WriteLn;

ReadLn;

End.

Результат работы программы:

Верхняя грань:

1 2 3 4 5

6 7 8 9 10

11 12 13 14 15

16 17 18 19 20

Передняя грань:

16 17 18 19 20

36 37 38 39 40

56 57 58 59 60

Правая грань:

5 10 15 20

25 30 35 40

45 50 55 60

Часто встречающиеся ошибки программирования:

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

s := 0;

For i := 1 To 100 Do;

s := s + i; в этом случае s = 100

2. При использовании слова To конечное значение параметра цикла превосходит его начальное значение. В этом случае цикл не выполняется ни разу:

s := 0;

For i := 100 To 1 Do

s := s + i; в этом случае s = 0

3. Использование в качестве параметра цикла переменной вещественного типа:

s := 0.0;

For i := 1.0 To 100.0 Do

s := s + i;

4. Изменение внутри области цикла значения параметра цикла, а также его начального и конечного значения:

m := 10;

n := 1;

For j := m DownTo n Do

Begin

a[j] := j + 10;

j := j + 1; ошибка!

m := m + 1; ошибка!

n := n - 1; ошибка!

End;

Множества

Множества - это структуры данных, наряду с переменными, массивами и строками.

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

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

Под множеством в Паскале понимается неупорядоченный набор фиксированного количества (не более 255) неповторяющихся однотипных элементов, имеющих общее имя - имя множества.

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

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

целого (множество целых чисел, не более 255 чисел),

логического (множество, состоящее из двух логических констант: TRUE и FALSE),

символьного (множество символов таблицы ASCII),

перечисляемого,

интервального.

Таким образом, в Паскале не определено множество, состоящее из чисел с дробной частью (REAL).

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

1. объявлением его имени и типа в разделе описания переменных Var :

Var r : Set Of `a '. . 'c';

d : Set Of 1 . . 4;

Описано множество r символов алфавита от `a' до `c' и множество d целых чисел 1, 2, 3, 4.

Внимание! Между начальным и конечным значениями интервала ставятся две точки!

2. объявлением типа множества в разделе определения типов Type и его имени - в разделе описания переменных Var :

Type TSymb = Set Of `a' . . `c';

TNumb = Set Of 1 . . 4;

Var r : TSymb;

d : TNumb;

3. заданием множества как типизированной константы:

Const r : Set Of `a '. . 'c' = [`a','c'];

d : Set Of 1 . . 4 = [2,1,3];

Внимание! Элементы множества перечисляются в квадратных скобках через запятую.

Элементы множества можно задавать следующими способами:

a) перечислением отдельных его значений:

[`c', `a', `e'] [76, 102, 5, 12]

b) интервалом базового типа:

[25..45, 3..10] [`a'..'d', `k'..'n']

c) выражениями базового типа:

[Ord(109),'s'] [Succ(3), Pred(9), Round(Sin(1.0))]

Множество может принимать значения любых наборов элементов, указанных в его описании. Например, описанное ранее множество r может принимать следующие значения:

[`a', `b', `c']

[`a', `b']

[`a', `c']

[ `b', `c']

[`a']

[ `b']

[ `c']

[] пустое множество d - следующие:

[1, 2, 3, 4]

[1, 2, 3]

[1, 3, 4]

[1, 2, 4]

[2, 3, 4]

[1, 2]

[1, 3]

[1, 4]

[2, 3]

[2, 4]

[3, 4]

[1]

[2]

[3]

[4]

[]

Таким образом, любое множество может принимать 2n значений, где n - количество элементов в описании множества.

Порядок следования элементов во множестве не устанавливается, поэтому, например, значения множества [`a', `b', `c'] и [`b', `c', `a'] эквивалентны.

При работе со множествами в Паскале можно использовать следующие операции:

+ объединение (сумма) множеств,

* пересечение (произведение) множеств,

- разность множеств,

In вхождение элемента во множество.

Пересечением двух множеств называется множество, состоящее из элементов, одновременно входящих в оба множества-сомножителя:

[3, 4, 5] * [1, 3, 5] = [3]

[3, 4, 5] * [3, 4, 5] = [3, 4, 5]

[2, 1, 0] * [] = []

[2, 9, 8] * [6, 7] = [] пустое множество

[`a', `b', `c'] * [`d', `c', `a'] = [`a', `c']

Объединением двух множеств называется множество, состоящее из элементов, входящих хотя бы в одно из множеств-слагаемых:

[3, 4, 5] + [1, 3, 5] = [1, 3, 4, 5]

[2, 9, 8] + [] = [2, 9, 8]

[1, 2, 3] + [1, 2, 3] = [1, 2, 3]

[`a', `b', `c'] + [`d', `c', `a'] = [`a', 'b', `c', `d']

Разностью двух множеств называется множество, состоящее из элементов множества-уменьшаемого без элементов множества-вычитаемого:

[3, 4, 5] - [1, 3, 5] = [4]

[2, 9, 5] - [3, 7] = [2, 9, 5]

[2, 4] - [5, 4, 2] = []

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

([3, 4, 5] + [1, 3, 6, 7]) * [5, 6, 7] - [6] = [5, 7]

Пример: в группе 12 студентов. Заданы множества номеров студентов:

множество спортсменов sport = [1, 2, 3, 4, 5]

множество отличников otl = [2, 3, 6, 7]

множество курящих smok = [7, 8]

Определить:

1. множество спортсменов-отличников:

sport * otl = [1, 2, 3, 4, 5] * [2, 3, 6, 7] = [2, 3]

2. множество спортсменов или отличников:

sport + otl = [1, 2, 3, 4, 5] + [2, 3, 6, 7] = [1, 2, 3, 4, 5, 6, 7] = [1 . . 7]

3. множество курящих спортсменов:

sport * smok = [1, 2, 3, 4, 5] * [7, 8] = [] - пустое множество - спортсмены не курят!

4. множество некурящих отличников:

otl - smok = [2, 3, 6, 7] - [7, 8] = [2, 3, 6]

Для проверки вхождения какой-либо константы или переменной в определенное множество используется операция In , результатом которой является TRUE, если это значение входит во множество, и FALSE - если не входит:

5 In [1, 5, 7] = TRUE

`b' In [`a', `c', `d'] = FALSE

Наряду с этими операциями, над множествами определены и операции сравнения, используемые для сравнения однотипных множеств. Пусть A и B -два однотипных множества, тогда:

A <= B равно TRUE, если все элементы множества A входят во множество B:

[5, 3, 2] <= [1, 2, 3, 4, 5] = True

A >= B равно TRUE, если все элементы множества B входят во множество A:

[`d', `e', `f', `g'] >= [`d', `g'] = True

A = B равно TRUE, если элементы этих множеств полностью совпадают:

[1, 2, 3] = [3, 2, 1] = TRUE

A <> B равно TRUE, если эти множества различаются хотя бы одним элементом:

[1, 2, 3] <> [5, 2, 1] = TRUE

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

V := S;

где V - переменная-множество,

S - выражение со множествами того же типа.

Внимание! Элементы множеств нельзя вводить и выводить операторами Read и Write, то есть имя множества не должно появляться в списках операторов ввода-вывода.

Основные операции со множествами

Задание множеств

Множество можно задать типизированной константой:

Const mnosh : Set Of 1..10 = [2, 3, 8]; задано множество целых чисел с элементами 2, 3, 8.

Множество можно задать в самой программе оператором присваивания:

mnosh := [2, 3, 8]; множество с элементами 2, 3, 8

mnosh := []; пустое множество

mnosh := [2..5]; множество с элементами 2, 3, 4, 5

2. Добавление и удаление элементов множеств

Эти операции осуществляются операторами присваивания:

mnosh := [1..4]; во множестве элементы 1, 2, 3, 4

mnosh := mnosh + [7, 9]; во множестве элементы 1, 2, 3, 4, 7, 9

mnosh := mnosh - [2, 3]; во множестве элементы 1, 4, 7, 9

3. Ввод элементов множества с клавиатуры

Введем во множество mnosh несколько чисел циклом с постусловием, пока не напечатаем 0:

Repeat

Write(`Очередной элемент:');

ReadLn(n);

If (n <> 0)

Then Mnosh := mnosh + [n]; очередной элемент обязательно в

Until (n = 0); квадратных скобках

Вывод элементов множества на экран

Пусть множество mnosh описано как:

Var mnosh : Set Of 1 . . 100;

Заданы какие-то элементы этого множества. Выведем эти элементы на экран циклом:

For i := 1 To 100 Do перебираем все возможные элементы множества,

If (I In mnosh) если очередной элемент входит во множество,

Then Write(i:5); то выводим его на экран

WriteLn;

Процедуры для работы со множествами

Для работы со множествами определены следующие процедуры:

Включение элемента во множество

Include(mnosh, s);

mnosh - имя множества,

s - константа (переменная, выражение) того же типа, как и элементы множества.

Исключение элемента из множества

Exclude(mnosh, s);

mnosh - имя множества,

s - константа (переменная, выражение) того же типа, как и элементы множества.

Файлы

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

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

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

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

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

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

Таким образом, файл - это упорядоченная совокупность однотипных элементов (типизированные файлы), имеющая произвольную длину, прямой или последовательный доступ.

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

Файлы, используемые в Паскале, делятся на физические (внешние) и логические (внутренние). Физические файлы являются средствами обмена данными и хранятся на внешних носителях. Это единственная структура, посредством которой данные, обрабатываемые программой, могут быть получены извне, а результаты работы программы могут быть переданы во внешний мир и сохранены.

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

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

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

В Паскале различают три типа внешних файлов:

типизированные

текстовые

нетипизированные

Типизированные файлы

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

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

Объявить файл можно двумя способами:

1. указанием его имени и типа в разделе описания переменных Var :

Var f_int : File Of Integer; описан файл целых чисел f_int,

f_int - имя логического файла - файловой переменной

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

Структура файла целых чисел:

EOF - End Of File - метка конца файла: символ с кодом 26 (CTRL+Z).

Var f_char : File Of Char; описан файл символов f_char,

f_char - имя логического файла -

файловой переменной

Структура файла символов:

2. указанием его типа в разделе определения типов TYPE и имени - в разделе описания переменных Var :

Type TFile_int : File Of Integer;

Var f_int : TFile_Int;

Таким образом, можно перечислить отличия файла от, например, массива:

файлы располагаются во внешней памяти - сохраняются после окончания работы программы,

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

текущее количество элементов файла в каждый момент работы программы неизвестно, но всегда известно, где конец файла (метка EOF),

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

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

Assign(имя файловой переменной, `путь к физическому файлу');

Assign(f_int,'D:\User\f_int.dat');

f_int - имя файловой переменной (логического файла),

D:\User\f_int.dat - полный путь к физическому файлу на внешнем носителе:

диск D:

директория (папка) User

файл f_int_dat.

Внимание! Желательно совпадение имени физического файла и имени файловой переменной; расширение имени типизированного файла .dat.

После установления пути к физическому файлу его можно открыть:

а) открытие нового файла для записи в него данных:

ReWrite(f_int);

При этом на внешнем носителе создается новый физический файл с заданным именем. Если файл с таким же именем уже существовал, то он очищается. С каждым файлом связан указатель текущего элемента (записи). В этом случае этот указатель становится в начало файла - элемент с номером 0.

Внимание! Нумерация элементов файлов начинается с нуля!

б) открытие существующего файла для чтения и записи в него данных:

ReSet(f_int);

При этом на внешнем носителе отыскивается файл с заданным именем и, если он найден, то указатель текущей записи становится в начало файла - на запись с номером 0.

Запись в открытый для записи файл осуществляется оператором

Write(файловая переменная, имя записываемой переменной);

Например,

Write(f_int, n); записать в файл f_int значение переменной n

Внимание! Оператор WriteLn использовать нельзя.

В этом случае значение переменной n записывается в файл на то место, где стоит указатель текущей записи. Если там была какая-то запись, то она заменяется новой. После записи указатель автоматически перемещается на следующую позицию. Если указатель перед этим находился на метке EOF - в конце файла, то новая запись помещается в конец файла и файл автоматически расширяется.

Из открытого для чтения файла можно прочитать все записи и вывести их, например, на экран:

ReSet(f_int); открываем файл f_int для чтения

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

Begin

Read(f_int,n); читаем из него очередную запись в переменную n

Write(n:5); выводим прочитанное значение на экран

End;

WriteLn; текстовый курсор - в начало новой строки

на экране

Внимание! Оператор ReadLn при чтении типизированных файлов использовать нельзя.

Таким образом, типизированный файл читается с помощью цикла с предусловием While. Условие окончания цикла - чтение метки конца цикла EOF.

После окончания работы с файлом он должен быть закрыт оператором:

Close(файловая переменная);

Например,

Close(f_int);

Пример записать в целочисленный файл несколько чисел, вводимых с экрана. Конец ввода - число 0. Прочитать эти числа из файла и вывести их на экран в одну строку.

Интерфейс программы:

Введите число: 3

Введите число: -1

Введите число: 5

Введите число: 12

Введите число: -6

Введите число: 0

Введены числа:

3 -1 5 12 -6

Программа:

Program File_1;

Uses CRT;

Var n : Integer;

f_int : File Of Integer;

Begin

ClrScr;

Assign(f_int, `d:\User\f_int.dat');

ReWrite(f_int);

Repeat

Write(`Введите число:');

ReadLn(n);

If (n <> 0)

Then Write(f_int,n);

Until (n=0);

ReSet(f_int);

Схема алгоритма: While Not(EOF(f_int)) Do

Begin

Read(f_int, n);

Write(n:5);

End;

WriteLn;

Close(f_int);

ReadLn;

End.



Функции для работы с типизированными файлами

Для работы с типизированными файлами используются следующие

функции:

FileSize(файловая переменная) - текущий размер файла - количество записей в файле,

FilePos(файловая переменная) - номер текущей записи в файле - позиция указателя текущей записи (нумерация записей начинается с нуля, номер последней записи на единицу меньше текущего размера файла), и процедуры:

Seek(файловая переменная, номер) - перемещение указателя на запись с заданным номером (нумерация записей начинается с нуля),

Truncate(файловая переменная) - усечение файла после текущей записи: все записи в файле после текущей удаляются, и после нее ставится метка конца файла EOF,

Erase(файловая переменная) - уничтожение файла - стирание его с диска.

Пример: открыть файл, созданный предыдущей программой, определить его конечный размер, номер начальной записи, поставить указатель на третью запись (по номеру), вывести ее на экран, усечь файл, начиная с нее и вывести новый файл на экран:

Программа:

Program File_1;

Uses CRT;

Var n : Integer;

f_int : File Of Integer;

Begin

ClrScr;

Assign(f_int, `d:\User\f_int.dat');

ReSet(f_int); открываем файл для чтения

While Not(EOF(f_int)) Do пока не конец файла:

Begin

Read(f_int, n); читаем из него в n очередную запись

Write(n:5); и выводим значение n на экран

End;

WriteLn;

n := FileSize(f_int); n - размер файла- количество записей в нем

WriteLn(`Размер файла равен ', n);

ReSet(f_int); ставим указатель на начальную запись

n := FilePos(f_int); n - номер начальной записи в файле

WriteLn(`Номер начальной записи равен ', n);

Seek(f_int, 3); ставим указатель на запись с номером 3

Read(f_int, n); читаем из файла в переменную n текущую запись

WriteLn(`Запись с номером 3 равна ', n);

Truncate(f_int); удаляем из файла все записи после текущей

ReSet(f_int); открываем файл для чтения - ставим указатель

на начальную запись

While Not(EOF(f_int)) Do снова читаем файл и выводим его на экран

Begin

Read(f_int, n);

Write(n:5);

End;

WriteLn;

Close(f_int); закрываем файл

ReadLn;

End.

На экран будет выведено:

3 -1 5 12 -6

Ра...