Задачи_Pas

начало
Вывод сообщения
Ввод В
( B <> 3 ) and ( B <> -3 )
K : = 3 , 15
Q : = Q * SQRT ( k + 4 ) / ( 9 – SQR ( В ) )
Q : = 1
Вывод Q
конец
Введите целое число, кроме 3 и -3
+
-

Program Primer ;
Uses CRT ;
Var B : integer ;
k : byte ;
Q : real ;
BEGIN
Repeat { начало цикла }
ClrScr ;
Write ( ‘ Введите целое число, кроме 3 и -3 : ‘ ) ;
ReadLN ( B ) ;
Until ( B <> 3 ) and ( B <> -3 ) ; { критерий выхода из цикла }
Q : = 1 ;
For K : = 3 to 15 do
Q : = Q * SQRT ( k + 4 ) / ( 9 – SQR ( В ) ) ;
WriteLN ( ‘ Q = ‘ , Q : 10 : 2 ) ; { форматный вывод }
ReadKey ; { задержка выполнения программы }
END.

Задание: Разработать алгоритм в виде блок-схемы
и написать текст программы, для нахождения суммы:
N =
суммирование производить при условии, если

начало
Вывод сообщения
Ввод M
M > = 0
N : = N + SQR ( Y - A )
N : = 0
Вывод N
конец
Введите целое положительное число
+
-
Y : = - 8
Y < = SQRT ( M )
Вывод сообщения
Ввод A
Y : = Y + 1
+
-
Введите
целое число

Program Primer ;
Var Y , A , N : integer ;
M : word ;
BEGIN
Repeat { начало цикла }
Write ( ‘ Введите целое положительное число : ‘ ) ;
ReadLN ( M ) ;
Until M > = 0 ; { критерий выхода из цикла }
Y : = - 8 ; N : = 0 ;
Write ( ‘ Введите целое число : ‘ ) ;
ReadLN ( A ) ;
While Y < = SQRT ( M ) do { начало цикла }
begin
N : = N + SQR ( Y - A ) ;
Y : = Y + 1 ;
end ;
WriteLN ( ‘ N = ‘ , N ) ;
ReadLn ; { задержка выполнения программы }
END.

Пример: Установить, имеется ли в введенном
тексте баланс открывающихся и
закрывающихся скобок.

Вывод сообщения
Введите любое предложение
Ввод S
L : = 0
P : = 0
D : = length ( S )
i : = 1, D
S[ i ] = ‘ ) ’
P : = P + 1
S [ i ] = ‘ ( ‘
L : = L + 1
Начало
+
+
-
-

( L = 0 ) and
( P = 0 )
Вывод
сообщения
В предложе-
нии скобок нет!
P = L
Вывод
сообщения
Имеется баланс скобок
Вывод
сообщения
Нет
баланса
скобок
Конец
+
-
+
-

Program Stroka1;
Uses CRT ; { подключение модуля для управления экраном }
Var S : string ; { исходная строка }
P : byte ; { количество правых скобок в строке S }
L : byte ; { количество левых скобок в строке S }
i : byte ; { индексы элементов строки S }
D : byte ; { длина введённой строки }
Begin
CLrScr ; { очистка экрана }
WriteLn ( ' Введите любое предложение: ' ) ;
ReadLn ( S ) ;

L : = 0 ;
P : = 0 ;
D : = Length ( S ) ; { определили длину введённой строки }
For i : = 1 to D do
iF S[ i ] = ‘ ) ' then p : = p + 1 eLse
iF S[ i ] = ‘ ( ' then L : = L + 1 ;

iF ( L = 0 ) and ( P = 0 ) THEN
WriteLn ( ' В ведённом предложении скобок нет! ' )
ELSE
iF L = P THEN
Writeln ( ' В введённой строке имеется баланс скобок ' )
ELSE
Writeln ( ' В введённой строке нет баланса скобок ' ) ;
ReadKey ; { задержка выполнения программы }
End.

Задача:
Заменить в веденном тексте
все вопросительные знаки
на восклицательные

начало
Вывод сообщения
Ввод S
Введите предложение
-
конец
+
D := Length (S)
S[i] := ‘!’
Вывод S
i : = 1, D
S[i] = ‘?’

Задача:
Удалить в веденном тексте
все вопросительные знаки

начало
Вывод сообщения
Ввод S
Введите предложение
-
Pos(‘?’, S) <> 0
конец
+
i := pos (‘?’,S)
DeLete(S, i, 1)
Вывод S

Задача:
Организовать ручное заполнение
целочисленного вектора М,
размерностью 10.
Вывести на экран элементы вектора,
а также сумму всех отрицательных
его элементов и количество
элементов, больших числа 5.

- 8
9
3
5
8
1
7
4
3
- 2
М =
Сумма отрицательных элементов равна - 15
Количество элементов больших 5, равно 3

Вывод сообщения
Введите
элемент
вектора
Ввод M [ i ]
S : = 0
K : = 0
i : = 1, 10
Начало
i : = 1, 10
Вывод M [ i ]
Вывод
сообщения
Исходный
вектор

S : = S + M [ i ]
K : = K + 1
i : = 1, 10
Конец
i : = 1, 10
Вывод K
Вывод S
M [ i ] < 0
+
-
M [ i ] > 5
+
-

Program Vektor ;
Var
M : array [ 1 . . 10 ] of integer ; { вектор }
i : byte ; { индекс элементов вектора }
K : byte ; { количество элементов, больших числа 5 }
S : integer ; { сумма отрицательных элементов }
BEGIN
FOR i : = 1 to 10 do { заполнение вектора }
begin
Write ( ‘ Введите элемент вектора : ‘ ) ;
ReadLn ( M [ i ] ) ;
end ;
S : = 0 ; { первоначальное значение суммы }
K : = 0 ; { первоначальное значение количества }
Writeln ( ‘ Исходный вектор ‘ ) ;
FOR i : = 1 to 10 do { вывод вектора на экран }
Write ( M [ i ] : 7 ) ; { форматный вывод }
WriteLn ; { переход на новую строку }

FOR i : = 1 to 10 do { поиск суммы }
IF M [ i ] < 0 THEN S : = S + M [ i ] ;
Writeln ( ‘ Сумма отрицательных элементов вектора равна ‘ , S ) ;
WriteLn ; { переход на новую строку }
FOR i : = 1 to 10 do { поиск количества }
IF M [ i ] > 5 THEN K : = K + 1 ;
Writeln ( ‘ Количество элементов удовлетворяющих условию = ‘ , К ) ;
ReadLn; { задержка выполнения программы }
END.

Задача:
Организовать ручное заполнение
целочисленного одномерного массива
А, размерностью N.
Заменить все отрицательные элементы
на число Р.
Вывести на экран элементы вектора ДО
и ПОСЛЕ изменения.

- 8
9
3
5
8
1
7
4
3
- 2
Р =
44
44
9
3
44
8
1
7
4
3
44
А =
А =

Вывод сообщения
Введите размерность
вектора ( max = 15 )
Ввод A [ i ]
i : = 1, N
Начало
A
Ввод N
Вывод
сообщения
Введите
элемент
вектора
(N>=1) and
(N <=15)
+
-

Вывод A [ i ]
i : = 1, N
B
i : = 1, N
Вывод сообщения
Исходный
вектор
A
Вывод
сообщения
Введите
число для
замены
Ввод Р
А [ i ] < 0
А [ i ] : = P
+
-

Вывод A [ i ]
i : = 1, N
Вывод сообщения
Вектор ПОСЛЕ
замены элементов
B
Конец

Program Vektor ;
Var
A : array [ 1 . . 15 ] of integer ; { вектор }
i : byte ; { индекс элементов вектора }
N : byte ; { количество элементов в векторе }
P : integer ; { число для замены }
BEGIN
REPEAT { проверка корректности ввода размерности }
Write ( ‘ Введите размерность вектора : ‘ ) ;
ReadLn ( N ) ;
UNTIL ( N >= 1 ) and ( N <= 15 ) ;
FOR i : = 1 to N do { заполнение вектора }
begin
Write ( ‘ Введите элемент вектора : ‘ ) ;
ReadLn ( A [ i ] ) ;
end ;
Writeln ( ‘ Исходный вектор ‘ ) ;
FOR i : = 1 to N do { вывод вектора на экран }
Write ( A [ i ] : 5 ) ; { форматный вывод }

WriteLn ; { переход на новую строку }
Write ( ‘ Введите число для замены : ‘ ) ;
ReadLn ( P ) ;
FOR i : = 1 to N do { замена отрицательных элементов }
IF A [ i ] < 0 THEN A [ i ] : = P ;
Writeln ( ‘ Вектор ПОСЛЕ замены элементов ‘ ) ;
FOR i : = 1 to N do { вывод вектора на экран }
Write ( A [ i ] : 5 ) ; { форматный вывод }
ReadLn; { задержка выполнения программы }
END.

Задача:
Организовать заполнение
целочисленного вектора Y ,
размерностью 10, случайным образом. Найти в массиве минимальный элемент
и вывести его на экран.

8
9
-8
7
4
-3
Y =
Min =
-2
1
-2
i := 1
Y [ i ] < Min
i := 2
i := 3
i := 4
i := 5
-8
i := 6
i := 7
i := 8

Randomize
Y [ i ] : = Random ( 99 )
i : = 1, 10
Начало
i : = 1, 10
Вывод Y [ i ]
Вывод
сообщения
Исходный
вектор

i : = 1, 10
Min : = Y [ 1 ]
Y [ i ] < Min
Min : = Y [ i ]
+
-
Вывод Min
Конец

Program Vektor ;
Uses CRT ;
Var
Y : array [ 1 . . 10 ] of integer ; { вектор }
i : byte ; { индекс элементов вектора }
Min : integer ; { минимальный элемент }
BEGIN
CLrScr ;
Randomize ; { инициализация генератора случайных чисел }
FOR i : = 1 to 10 do { заполнение вектора }
Y [ i ] : = RANDOM ( 99 ) ;
WriteLn ( ‘ Исходный вектор ‘ ) ;
FOR i : = 1 to 10 do { вывод вектора на экран }
Write ( Y [ i ] : 5 ) ; { форматный вывод }

WriteLn ; { переход на новую строку }
Min : = Y [ 1 ] ;
FOR i : = 1 to 10 do { поиск минимального элемента }
IF Y [ i ] < Min THEN Min : = Y [ i ] ;
WriteLn ( ‘ Минимальный элемент вектора = ‘ , Min ) ;
ReadLn; { задержка выполнения программы }
END.

Задача:
Организовать ручное заполнение
одномерного массива Z,
размерностью 8, вещественными числами.
Переставить местами первый элемент
массива и элемент массива, равный числу Х.
Вывести на экран массив ДО и ПОСЛЕ
перестановки.

8.1
9.7
1.1
-8.2
7.9
4.3
-3.1
-2.3
X =
1.1
Z =
Z =
8.1
9.7
-2.3
-8.2
7.9
4.3
-3.1
1.1

8.1
9.7
-8.2
7.9
4.3
-3.1
X =
1.1
Z =
A =
Index =
4
-2.3
1.1

Вывод сообщения
Введите
элемент
вектора
Ввод Z [ i ]
i : = 1, 8
Начало
A
i : = 1, 8
Вывод Z [ i ]
Вывод
сообщения
Исходный
вектор

B
i : = 1, 8
A
Вывод
сообщения
Введите
число для перестановки
Ввод Х
Z [ i ] = Х
index : = i
+
-

i : = 1, 8
B
Вывод
сообщения
Массив не
изменился
Index = 0
А : = Z [ 1 ]
+
-
Z [ 1 ] : = Z [ index ]
Z [ index ] : = A
Вывод сообщения
Массив
ПОСЛЕ
замены
Вывод Z [ i ]
Конец

Program Vektor ;
Var
Z : array [ 1 . . 8 ] of REAL ; { вектор }
i : byte ; { индекс элементов вектора }
A : reaL ; { для перестановки элементов }
X : reaL ; { число для сравнения }
index : byte ; { индекс переставляемого элемента }
BEGIN
FOR i : = 1 to 8 do { заполнение вектора }
begin
Write ( ‘ Введите элемент вектора : ‘ ) ;
ReadLn ( Z [ i ] ) ;
end ;
WriteLn ( ‘ Исходный вектор ‘ ) ;
FOR i : = 1 to 8 do { вывод вектора на экран }
Write ( Z [ i ] : 6 : 1 ) ; { форматный вывод }
WriteLn ; { переход на новую строку }

Write ( ‘ Введите число для ПЕРЕСТАНОВКИ : ‘ ) ;
ReadLn ( Х ) ;
FOR i : = 1 to 8 do { поиск индекса переставляемого элемента }
IF Z [ i ] = X THEN index : = i ;
IF index = 0 THEN WriteLn ( ‘ Вектор НЕ изменился ‘ )
ELSE
begin
A : = Z [ 1 ] ;
Z [ 1 ] : = Z [ index ] ;
Z [ index ] : = A ;
WriteLn ( ‘ Вектор ПОСЛЕ перестановки элементов ‘ ) ;
FOR i : = 1 to 8 do { вывод вектора на экран }
Write ( Z [ i ] : 6 : 1 ) ; { форматный вывод }
end ;
ReadLn; { задержка выполнения программы }
END.

Задача:
Организовать ручное заполнение
одномерного массива В,
размерностью 10, целыми числами. Найти и вывести на экран произведение
чётных элементов массива.

Вывод сообщения
Введите
элемент
вектора
Ввод В [ i ]
i : = 1, 10
Начало
A
i : = 1, 10
Вывод В [ i ]
Вывод
сообщения
Исходный
вектор

B
i : = 1, 10
A
Pr : = 1
ODD ( B [ i ] ) = False
F : = 7
+
-
F : = 5
Pr : = Pr * B [ i ]

B
Вывод
сообщения
В массиве нет
чётных
элементов
F = 5
+
-
Вывод Pr
Конец

Program Vektor ;
Var
B : array [ 1 . . 10 ] of integer ; { вектор }
i : byte ; { индекс элементов вектора }
F : byte ; { переключатель }
Pr : integer ; { произведение чётных элементов }
BEGIN
FOR i : = 1 to 10 do { заполнение вектора }
begin
Write ( ‘ Введите элемент вектора : ‘ ) ;
ReadLn ( B [ i ] ) ;
end ;
WriteLn ( ‘ Исходный вектор ‘ ) ;
FOR i : = 1 to 10 do { вывод вектора на экран }
Write ( B [ i ] : 6 ) ; { форматный вывод }
WriteLn ; { переход на новую строку }

F : = 5 ;
Pr : = 1 ; { первоначальное значение произведения }
FOR i : = 1 to 10 do { поиск произведения чётных элементов }
IF ODD ( B [ i ] ) = FALSE THEN begin
F : = 7 ;
Pr : = Pr * B [ i ] ;
end ;
IF F = 5
THEN WriteLn ( ‘ В массиве НЕТ чётных элементов ‘ )
ELSE
WriteLn ( ‘ Произведение чётных элементов равно ‘ , Pr ) ;
ReadLn; { задержка выполнения программы }
END.

Задача:
Организовать ручное заполнение
символьного одномерного массива А,
размерностью 5.
Определить и вывести на экран сообщение
о наличии в массиве символа «!».

Вывод сообщения
Введите
элемент
вектора
Ввод А [ i ]
i : = 1, 5
Начало
A
i : = 1, 5
Вывод А [ i ]
Вывод
сообщения
Исходный
вектор

B
i : = 1, 5
A
А [ i ] = ‘ ! ‘
F : = 200
+
-
F : = 100

B
Вывод
сообщения
В массиве нет
символа «!»
F = 100
+
-
Вывод
сообщения
Конец
В массиве есть
символ «!»

Program Vektor ;
Var
А : array [ 1 . . 5 ] of char ; { символьный вектор }
i : byte ; { индекс элементов вектора }
F : byte ; { переключатель }
BEGIN
FOR i : = 1 to 5 do { заполнение вектора }
begin
Write ( ‘ Введите элемент вектора : ‘ ) ;
ReadLn ( А [ i ] ) ;
end ;
WriteLn ( ‘ Исходный вектор ‘ ) ;
FOR i : = 1 to 5 do { вывод вектора на экран }
Write ( А [ i ] : 6 ) ; { форматный вывод }
WriteLn ; { переход на новую строку }

F : = 100 ;
FOR i : = 1 to 5 do { поиск символа «!» }
IF A [ i ] = ‘ ! ‘ THEN F : = 200 ;
IF F = 100
THEN WriteLn ( ‘ В массиве НЕТ символа «!» ‘ )
ELSE WriteLn ( ‘ В массиве ЕСТЬ символ «!» ‘ ) ;
ReadLn; { задержка выполнения программы }
END.

Задача:
Организовать ручное заполнение
двумерного массива В, размерностью
5 х 7, целыми числами.
Найти и вывести на экран количество
чётных элементов массива и максимальный
элемент матрицы.

Вывод сообщения
Введите
элемент
матрицы
Ввод В [ i , j ]
i : = 1, 5
Начало
A
j : = 1, 7

Исходная
матрица
Вывод В [ i , j ]
i : = 1, 5
A
j : = 1, 7
Вывод сообщения
Переход на
новую строку
В

i : = 1, 5
В
j : = 1, 7
Kol : = 0
Вывод
Kol
C
ODD ( B [ i , j ] ) =
false
Kol : = Kol + 1
+
-

i : = 1, 5
C
j : = 1, 7
Max : = B [ 1, 1 ]
Вывод
Max
B [ i , j ] > Max
Max : = B [ i , j ]
+
-
Конец

Program Matrica ;
Var
B : array [ 1 . . 5 , 1 . . 7 ] of integer ; { матрица }
i , j : byte ; { индексы элементов матрицы }
KoL : byte; { кол-во чётных элементов }
Max : integer ; { максимальный элемент }
BEGIN
FOR i : = 1 to 5 do { заполнение матрицы }
FOR j : = 1 to 7 do
begin
Write ( ‘ Введите элемент матрицы ->… ‘ ) ;
ReadLn ( В [ i , j ] ) ;
end ;

WriteLn ( ‘ Исходная матрица ‘ ) ;
FOR i : = 1 to 5 do { вывод матрицы на экран }
begin
FOR j : = 1 to 7 do
Write ( B [ i , j ] : 6 ) ; { форматный вывод }
WriteLn ; { переход на новую строку }
end ;
KoL : = 0 ;
FOR i : = 1 to 5 do { поиск кол-ва чётных эл-ов }
FOR j : = 1 to 7 do
IF ODD ( B [ i , j ] ) = faLse THEN KoL : = KoL + 1 ;
WriteLn ( ‘ Кол-во чётных элементов равно ‘ , KoL) ;

Max : = B [ 1 , 1 ] ;
FOR i : = 1 to 5 do { поиск max элемента }
FOR j : = 1 to 7 do
IF B [ i , j ] > Max THEN Max : = B [ i , j ] ;
WriteLn ( ‘ Максимальный элемент равен ‘ , Мах ) ;
ReadLn ;
END.

Задача:
Организовать случайное заполнение
двумерного массива А, размерностью
3 х 5, целыми числами.
Найти и вывести на экран произведение
нечётных элементов массива в столбце Т.

Randomize
A [ i , j ] : = Random ( 99 )
i : = 1, 3
Начало
A
j : = 1, 5

Исходная
матрица
Вывод A [ i , j ]
i : = 1, 3
A
j : = 1, 5
Вывод сообщения
Переход на
новую строку
В

Введите номер
столбца
C
Ввод Т
Вывод
сообщения
( Т >= 1 ) and
( Т <= 5 )
+
-
B

i : = 1, 3
C
P : = 1
D
ODD ( A [ i , Т ] ) =
true
P : = P * A [ i , Т ]
+
-
F : = 2
F : = 7

D
F = 7
Вывод
сообщения
+
-
Вывод Р
В столбце Т
нет нечётных
элементов
Конец

Program Matrica ;
Var
A : array [ 1 . . 3 , 1 . . 5 ] of integer ; { матрица }
i , j : byte ; { индексы элементов матрицы }
P : integer ; { произведение нечётных эл-ов }
Т : integer ; { номер столбца }
F : integer ; { переключатель }
BEGIN
Randomize ; { инициализация генератора случайных чисел }
FOR i : = 1 to 3 do { заполнение матрицы }
FOR j : = 1 to 5 do
A [ i , j ] : = Random (99) ;

WriteLn ( ‘ Исходная матрица ‘ ) ;
FOR i : = 1 to 3 do { вывод матрицы на экран }
begin
FOR j : = 1 to 5 do
Write ( А [ i , j ] : 6 ) ; { форматный вывод }
WriteLn ; { переход на новую строку }
end ;
REPEAT { проверка корректности ввода столбца }
WriteLn ( ‘ Введите номер столбца ‘ ) ;
ReadLn ( T ) ;
UNTiL ( T > = 1 ) and ( T < = 5 ) ;
Р : = 1 ;
F : = 2 ;

FOR i : = 1 to 3 do { поиск произведения }
IF ODD ( A [ i , T ] ) = true THEN begin
F : = 7 ;
P : = P * A [ i , T ] ;
end ;
IF F = 7 THEN
WriteLn ( ‘ Произведение нечётных элементов = ‘ , Р )
ELSE
WriteLn ( ‘ В столбце Т нет нечётных элементов ‘ ) ;
ReadLn ;
END .

A =
2 5 7
8 - 3 4
1 9 - 2
3 x 3
5 A [ 1 , 2 ]
7 A [ 1 , 3 ]
4 A [ 2 , 3 ]
i j
<

Задача:
Организовать ручное заполнение
двумерного массива В, размерностью
9 х 9, целыми числами.
Увеличить все элементы главной диагонали
в два раза.
Вывести на экран массив В ДО и ПОСЛЕ
изменения.

Вывод сообщения
Введите
элемент
матрицы
Ввод В [ i , j ]
i : = 1, 9
Начало
A
j : = 1, 9

Матрица
ДО изменения
Вывод В [ i , j ]
i : = 1, 9
A
j : = 1, 9
Вывод сообщения
Переход на
новую строку
В

В [ i , i ] : = B [ i , i ] * 2
i : = 1, 9
В
С

Матрица
ПОСЛЕ изменений
Вывод В [ i , j ]
i : = 1, 9
С
j : = 1, 9
Вывод сообщения
Переход на
новую строку
Конец

Program Matrica ;
Var
B : array [ 1 . . 9 , 1 . . 9 ] of integer ; { матрица }
i , j : byte ; { индексы элементов матрицы }
BEGIN
FOR i : = 1 to 9 do { заполнение матрицы }
FOR j : = 1 to 9 do
begin
Write ( ‘ Введите элемент матрицы : ‘ ) ;
ReadLn ( В [ i , j ] ) ;
end ;

WriteLn ( ‘ Mатрица ДО изменения ‘ ) ;
FOR i : = 1 to 9 do { вывод матрицы на экран }
begin
FOR j : = 1 to 9 do
Write ( B [ i , j ] : 6 ) ;
WriteLn ;
end ;
FOR i : = 1 to 9 do { замена элементов диагонали }
B [ i , i ] : = B [ i , i ] * 2 ;

WriteLn ( ‘ Mатрица ПОСЛЕ изменения ‘ ) ;
FOR i : = 1 to 9 do { вывод матрицы на экран }
begin
FOR j : = 1 to 9 do
Write ( B [ i , j ] : 6 ) ;
WriteLn ;
end ;
ReadLn ;
END .

Задача:
Организовать случайное заполнение
двумерного массива М, размерностью
Т х Т, целыми числами.
Заменить все элементы выше главной
диагонали на первый элемент матрицы.
Вывести на экран массив М ДО и ПОСЛЕ
изменения.

Вывод
сообщения
Введите размерность
квадратной матрицы
( max = 10 )
Начало
A
Ввод Т
Вывод
сообщения
Размерность
введена не верно !
(Т < 2) or
(Т > 10)
+
-
(Т>=2) and
(Т <=10)
+
-

Randomize
М [ i , j ] : = Random ( 99 )
i : = 1, Т
В
j : = 1, Т
A

Матрица
ДО изменения
Вывод М [ i , j ]
i : = 1, Т
В
j : = 1, Т
Вывод сообщения
Переход на
новую строку
С

i : = 1, T
С
j : = 1, T
D
i < j
M [ i , j ] : = M [ 1 , 1 ]
+
-

Матрица
ПОСЛЕ изменений
Вывод M [ i , j ]
i : = 1, T
D
j : = 1, T
Вывод сообщения
Переход на
новую строку
Конец

Program Matrica ;
Var
М : array [ 1 . . 10 , 1 . . 10 ] of integer ; { матрица }
i , j : byte ; { индексы элементов матрицы }
Т : integer ; { размерность квадратной матрицы }
BEGIN
REPEAT { проверка корректности ввода размерности }
WriteLn ( ‘ Введите размерность квадратной матрицы ‘ ) ;
ReadLn ( T ) ;
IF ( T < 2 ) OR ( T > 10 ) THEN
WriteLn ( ‘ Размерность введена НЕ верно… ’ ) ;
UNTiL ( T > = 2 ) and ( T < = 10 ) ;

Randomize ; { инициализация генератора случайных чисел }
FOR i : = 1 to Т do { заполнение матрицы }
FOR j : = 1 to Т do
М [ i , j ] : = Random (99) ;
WriteLn ( ‘ Матрица ДО изменения ‘ ) ;
FOR i : = 1 to Т do { вывод матрицы на экран }
begin
FOR j : = 1 to Т do
Write ( М [ i , j ] : 6 ) ; { форматный вывод }
WriteLn ; { переход на новую строку }
end ;

FOR i : = 1 to Т do { замена элементов }
FOR j : = 1 to Т do
IF i < j THEN М [ i , j ] : = M [ 1 , 1 ] ;
WriteLn ( ‘ Матрица ПОСЛЕ изменений ‘ ) ;
FOR i : = 1 to Т do { вывод матрицы на экран }
begin
FOR j : = 1 to Т do
Write ( М [ i , j ] : 6 ) ;
WriteLn ;
end ;
ReadLn ;
END .