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

- ввод и вывод компонент вектора;

- определение минимальной (максимальной) компоненты вектора;
- вычисление скалярного произведения двух векторов;
- проверку на упорядоченность по возрастанию или убыванию последовательности компонент.
Даны три вектора X, Y, Z, каждый размерности n = 6. Используя составленный модуль, вычислить
minX * (A, A) + maxY * (B, C),
где А – тот из данных трех векторов, компоненты которого упорядочены по возрастанию (считать,
что такой вектор единственный), В и С – два других вектора; minX – минимальная компонента
вектора X, maxY – максимальная компонента вектора Y.

unit Vector;
interface functionSearchMin(const
uses SysUtils; K:Tkomp):real;
const n=6; //размерность n=6 var i:integer;
type begin
Tkomp=array[1..N] of real result:=K[1];
for i:=2 to n do
procedureInputKomp(var K:Tkomp); if K[i]<result then
procedureOutputKomp(const K:Tkomp); result:=K[i];
functionSearchMax(const end;//SearchMinPos
K:Tkomp):real;
functionSearchMin(const functionScalPr(const
K:Tkomp):real; X,Y:Tkomp):real;
functionScalPr(const vari:integer;
X,Y:Tkomp):real; begin
//проверканавозрастание result:=0;
functionIsRise(const for i:=1 to ndo
K:Tkomp):boolean; result:=result+X[i]*Y[i];
//проверканаубывание end;//ScalPr
functionIsWane(const
K:Tkomp):boolean; functionIsRise(const
K:Tkomp):boolean;
implementation vari:integer;
procedureInputKomp(var K:Tkomp); begin
var i:integer; result:=true;
begin for i:=1 to n-1 do
for i:=1 to ndo if result then
read(K[i]); result:=K[i]<=k[i+1];
readln; end;
end;//InputKomp
functionIsWane(const
procedureOutputKomp(const K:Tkomp); K:Tkomp):boolean;
vari:integer; vari:integer;
begin begin
for i:=1 to ndo result:=true;
write(K[i]:8:2,' '); for i:=1 to n-1 do
writeln; if result then
end;//OutputKomp result:=K[i]>=k[i+1];
end;
functionSearchMax(const
K:Tkomp):real; end.
vari:integer;
begin
result:=K[1];
for i:=2 to ndo
if K[i]>result then
result:=K[i];
end;//SearchMaxPos
program N1;
uses
SysUtils,Windows,
Vector in 'Vector.pas';
var
X,Y,Z:Tkomp;

//процедура Input осуществляет ввод

компонент векторов X и Y
procedure Input(var X,Y,Z:Tkomp);
begin
writeln('Введите ',n,' компонент
X');
InputKomp(X);
writeln('Введите ',n,' компонент
Y');
InputKomp(Y);
writeln('Введите ',n,' компонент
Z');
InputKomp(Z);
end;//Input

//процедура Output осуществляет

вывод компонент векторов X и Y
procedure Output(var X,Y,Z:Tkomp);
begin
writeln('Компонентывектора X');
OutputKomp(X);
writeln('Компонентывектора Y');
OutputKomp(Y);
writeln('Компонентывектора Z');
OutputKomp(Z);
end;//Output

//процедура Task решает указанное

задание
procedure Task(const A,B,C:Tkomp);
var
i:integer;
res:real;
begin
res:=SearchMin(X)*ScalPr(A,A)+
SearchMax(Y)*ScalPr(B,C);
Writeln('Результат выполнения
задания:',res:8:2)
end;//Task

begin
SetConsoleCP(1251);
SetConsoleOutputCP(1251);
Input(X,Y,Z);
ifIsRise(X) then
Task(X,Y,Z)
elseifIsRise(Y) then
Task(Y,X,Z)
else Task(Z,X,Y);
Readln;
end.
Билет №2. Задача: проверить правильность расстановки скобок трех видов: '(', '{', '[', ')', '}' //и
']'.

//функция для открывающей скобки _bracket возвращает

//соответствующуюзакрывающую
functionAccordingClosingBracket(_bracket: Char): Char;
begin
case _bracket of
'(': Result:= ')';
'{': Result:= '}';
'[': Result:= ']';
else
Result:= #0;
end;
end;//AccordingClosingBracket

//Функция определяет правильность расстановки скобок'(', '{', '[', ')', '}'и ']'
//в выражении _expr
functionRightBracketArrangement(_expr: string): boolean;
var
i, ExprLength: Integer;
OpeningBrackets, ClosingBrackets: set of Char;
bracket: Char;
stack: TStack;
begin
Result:= true;
Init(stack);
ExprLength:= length(_expr);
OpeningBrackets:= ['(', '{', '['];
ClosingBrackets:= [')', '}', ']'];
i:= 1;
bracket:= #0;
while Result and (i<= ExprLength) dobegin
if _expr[i] inOpeningBracketsthen
Push(stack, _expr[i])
elseif _expr[i] inClosingBracketsthen
ifnotTryPop(stack, bracket)
or (_expr[i] <>AccordingClosingBracket(bracket)) then
Result:= false;
inc(i);
end;
Result:= Result andIsEmpty(stack);
end;//RightBracketArrangement
Задача : проверить, является ли дерево деревом поиска.
//модульUNode
unitUNode;
interface
usesComCtrls, Math, SysUtils;
const
MinElem = 1;
MaxElem = 100;
type
TElem = MinElem..MaxElem;
TNode = class
private
FInfo : TElem;
FLeft, FRight :TNode;
protected
procedureSetInfo(const Value: Telem);
public
constructor Create(el : TElem);
procedureAddRandom (el : TElem);// AddOrder / AddRandom
procedureAddOrder(el:TElem);
procedure Show (TV : TTreeView; pn : TTreeNode);
functionIsSearch(var min, max : TElem):boolean;
property Info : Telem read FInfo write SetInfo;
property Left : TNode read FLeft write FLeft;
property Right : TNode read FRight write FRight;
destructor Destroy; override;
end;
implementation
constructorTNode.Create(el: TElem);
begin
FInfo:=el;
FLeft:=nil;
FRight:=nil;
end;

destructorTNode.Destroy;
begin
FLeft.Free;
FRight.Free;
inherited;
end;

procedureTNode.AddRandom(el: TElem);
varrand:Integer;
begin
rand:=RandomRange(1,3); //в каждом узле случайным образом определяем
ifrand=1 then //направление движения
ifFLeft=nilthen //кактолькопришливnil, создаемузел
FLeft:=TNode.Create(el)
else
FLeft.AddRandom(el)
else
ifFRight=nil then
FRight:=TNode.Create(el)
else
FRight.AddRandom(el);
end;

procedureTNode.AddOrder(el: TElem);
begin
if Info > el then
ifFLeft=nil then
FLeft:=TNode.Create(el)
else
FLeft.AddOrder(el)
else
ifFRight=nil then
FRight:=TNode.Create(el)
else
FRight.AddOrder(el);
end;

procedureTNode.SetInfo(const Value: Telem);

begin
if(Value>MaxElem) or (Value<MinElem) then
raiseException.Create('Значение находилось за границами диапазона');
FInfo := Value
end;

functionTNode.IsSearch(varmin,max:TElem):Boolean;
varmintmp,maxtmp:TElem;
begin
Result:=true;
min := Info;
max := Info;
ifFLeft<> nil then
if not FLeft.IsSearch(mintmp,maxtmp) or (maxtmp> Info) then
Result := false
else
min := mintmp;
if Result and (FRight<> nil) then
if not FRight.IsSearch(mintmp,maxtmp) or (info >mintmp) then
Result := false
else
max := maxtmp;
end;

procedureTNode.Show(TV: TTreeView; pn: TTreeNode);

var
node :TTreeNode;
begin
node:=TV.Items.AddChild(pn, IntToStr(FInfo));
if (FLeft<>nil) or (FRight<>nil) then
begin
ifFLeft = nil then
TV.Items.AddChild(node, 'x')
else
FLeft.Show(TV, node);
ifFRight = nil then
TV.Items.AddChild(node, 'x')
else
FRight.Show(TV, node);
end;
end;
end.

unitUTree;

interface

usesComCtrls, Math, SysUtils, UNode, Contnrs;

type
TTree = class
private
FRoot : TNode;
public
//создание нового дерева
constructorCreate;
//добавление в дерево элемента el
procedureAddRandom (el : TElem);
//добавление в дерево поиска элемента el
procedureAddOrder(el : TElem);
//проверкадереванапустоту
function IsEmpty : boolean;
//формирование случайного дерева из N элементов
procedureRandom (N :integer);
//формирование случайного дерева поиска из N элементов
procedureRandomSearchTree(N: integer);
//отображениедереванаформе
procedure Show (TV : TTreeView);
//проверяем является ли бинарное дерево деревом поиска
functionIsSearchTree:Boolean;
//очисткадерева
procedure Clear;
destructor Destroy; override;
end;

implementation

{ TTree }

//добавлениевдеревоэлемента el
procedureTTree.AddRandom(el: TElem);
begin
if IsEmpty then
FRoot :=TNode.Create(el)
else
FRoot.AddRandom(el);
end;

//добавление в дерево поиска элемента el

procedureTTree.AddOrder(el: TElem);
begin
if IsEmpty then
FRoot :=TNode.Create(el)
else
FRoot.AddOrder(el);
end;

//очисткадерева
procedureTTree.Clear;
begin
FreeAndNil(FRoot);
end;
//созданиедерева
constructorTTree.Create;
begin
FRoot:=nil
end;

destructorTTree.Destroy;
begin
Clear;
inherited;
end;
//проверканапустоту
functionTTree.IsEmpty: boolean;
begin
Result:=FRoot=nil;
end;

//формирование случайного дерева из N элементов

procedureTTree.Random(N: integer);
begin
Clear;
While N > 0 do
begin
AddRandom(RandomRange(MinElem, MaxElem));
dec(N)
end
end;

//формирование случайного дерева поиска из N элементов

procedureTTree.RandomSearchTree(N: integer);
begin
Clear;
While N > 0 do
begin
AddOrder(RandomRange(MinElem, MaxElem));
dec(N)
end
end;

//отображение дерева
procedureTTree.Show(TV: TTreeView);
begin
TV.Items.Clear;
if not IsEmpty then
FRoot.Show(TV, nil);
TV.FullExpand;
end;

//проверяем является ли бинарное дерево деревом поиска

functionTTree.IsSearchTree:Boolean;
varmin,max:TElem;
begin
Result:=true;
ifFRoot<>nil then
Result:=FRoot.IsSearch(min,max)
end;

end.
Составить модуль, реализующий следующие операции над векторами:
- ввод и вывод компонент вектора;
- определение порядкового номера минимальной (максимальной) компоненты вектора;
- определение минимальной (максимальной) компоненты вектора;
- вычисление скалярного произведения двух векторов.
Даны два вектора Х и Y размерности n = 6. Используя составленный модуль, вычислить
n∑ xi y i − ∑ xi ∑ y i

(k ∑ )(p∑ )
,
− (∑ xi ) − (∑ y i )
2 2
x i2 y i2
где k – порядковый номер максимальной компоненты вектора Х, p –порядковый номер
минимальной компоненты вектора Y.

unit Vector; ifvect[i]>=max then

interface begin
constn=6; max:=vect[i];
typeTVector=array [1..n] of Integer; result:=i;
procedure Input(txt : string; var
end;
vect:TVector);
procedure Output(txt : string;
end;
vect:TVector);
functionNumberMaxElem(vect:TVector):int functionNumberMinElem;
eger; vari,min:Integer;
functionNumberMinElem(vect:TVector):int begin
eger; min:=vect[1];
functionMinElem(vect:TVector):integer; result:=1;
functionMaxElem(vect:TVector):integer; for i:=2 to ndo
functionScalarP(Vect1,Vect2:TVector):in ifvect[i]<=min then
teger; begin
min:=vect[i];
implementation result:=i;
procedure Input; end;
var end;
i:Integer;
begin functionMinElem;
Write(txt); begin
for i:=1 to ndo result:=vect[NumberMinElem(vect)]
read(vect[i]); ;
Readln; end;
end;
functionMaxElem;
procedure Output; begin
vari:integer; result:=vect[NumberMaxElem(vect)]
begin ;
Write(txt, '('); end;
for i:=1 to n-1 do
write(vect[i],','); functionScalarP;
writeln(vect[i],') '); vari:Integer;
end; begin
result:=0;
functionNumberMaxElem; for i:=1 to n do
vari,max:Integer; result:=result+Vect1[i]*Vect2[i];
begin end;
max:=vect[1]; end.
result:=1;
for i:=2 to ndo
program n1C;
uses SysUtils, windows, Vector;
var
k,p,j:Integer;
X,Y,I:TVector;
begin
Input('Введите компоненты вектора X: ',X);
Input('Введите компоненты вектора Y: ',Y);

Output('Вектор X: ',X);
Output('Вектор Y: ',Y);

for j:=1 to ndo

I[j]:=1;
k:=NumberMaxElem(X);
p:=NumberMinElem(Y);

writeln('Формула=',(n*ScalarP(X,Y)-ScalarP(X,I)*ScalarP(Y,I))/
(Sqrt((k*ScalarP(X,X)- sqr(ScalarP(X,I)))*(p*ScalarP(Y,Y)-
sqr(ScalarP(Y,I))))));
end.
Задача:Описать процедуру или функцию, которая находит в непустом дереве 𝒕𝒕 количество
вершин уровня 𝒍𝒍𝒍𝒍𝒍𝒍𝒍𝒍𝒍𝒍. Корень взять за элемент 1-го уровня.

//UNode.pas
interface
const
MinElem = 0;
MaxElem = 20;
type
TElem = MinElem..MaxElem;
TNode = class
private
FInfo:TElem;
FLeft, Fright:TNode;
public
//поиск количества элементов на заданном уровне дерева
function CountOnLevel(depth:integer):integer;
property Info:TElem read FInfo write FInfo;
property Left:TNode read FLeft write FLeft;
property Right:TNode read FRight write FRight;
...
end;

implementation
...
//поиск количества элементов на заданном уровне дерева
function TNode.CountOnLevel(depth:integer):integer;
begin
if (depth = 1) then
result:=1
else
begin
result:=0;
if (Left <> nil) then
result:=result + Left.CountOnLevel(depth-1);
if (Right <> nil) then
result:=result + Right.CountOnLevel(depth-1);
end
end;

end.
//UTree.pas
interface
type
TTree = class
private
FRoot:TNode;
public
//рекурсивно
function CountOnLevel(level:integer):integer;
//итеративно
function CountOnLevelIteratively(level:Integer):integer;
end;

implementation
//рекурсивно
function TTree.CountOnLevel(level:integer):integer;
begin
result:=0;
if (FRoot<>nil) and (level>0) then
result:=FRoot.CountOnLevel(level);
end;
//итеративно
function TTree.CountOnLevelIteratively(level:Integer):integer;
var
queue:TQueue;
node:TNode;
cnt_cur, cnt_next , depth:integer;
i:integer;
begin
result:=0;
if (FRoot<>nil) then begin
queue:=TQueue.Create;
queue.Push(FRoot);
depth:=1; //глубина, на которую мы забрались
cnt_cur := 1; //число элементов на текущем уровне
while (queue.Count>0) and (depth<level) do begin
cnt_next:=0; //число элементов на следующем уровне
for i:=1 to cnt_cur do begin
node:=queue.Pop; //вытаскиваем первый элемент
из дерева
if (node.Left<>nil) then begin
queue.Push(node.Left);
inc(cnt_next);
end;
if (node.Right<>nil) then begin
queue.Push(node.Right);
inc(cnt_next)
end;
end;
Inc(depth);
cnt_cur:=cnt_next;
end;
result:=cnt_cur;
queue.Free;
end
end;
Задача: Разработать модуль для реализации операций с комплексными числами.
Вычислить значение комплексной функции в заданной комплексной точке z при
заданном значении n
unit Complex;

interface

type

TComplex = record //описание комплексного числа

re,im: real;

end;

//функция инициализации комплексного числа, заданного действительной

частью ARe и вещественной частью AIm

function InitComplex (ARe,AIm: real): TComplex;

//процедура ввода комплексного числа z

procedure ReadComplex (var z: TComplex);

//процедура вывода комплексного числа z

procedure WriteComplex (z: TComplex);

//функция сложения двух комплексных чисел x и y

function AddComplex (x,y: TComplex): TComplex;

//функция вычитания двух комплексных чисел x и y

function SubComplex (x,y: TComplex): TComplex;

//функция умножения двух комплексных чисел x и y

function MultComplex (x,y: TComplex): TComplex;

//функция деления комплексного числа z на целое число n

function DivComplexByNum (z: TComplex; n: integer): TComplex;

//функция модуля комплексного числа z

function AbsComplex (z: TComplex): real;

//функция вычисления значение комплексной функции в заданной

комплексной точке z с заданной точностью eps

function ExpComplex(z: TComplex; eps:real): TComplex; //можно в

главной
implementation

//функция инициализации комплексного числа, заданного действительной

частью ARe и вещественной частью AIm

function InitComplex;

begin

result.re := ARe;

result.im := AIm;

end;

//процедура ввода комплексного числа z

procedure ReadComplex;

begin

writeln ('введите действительную часть комплексного числа');

readln (z.re);

writeln('введите мнимую часть комплексного числа');

readln(z.im);

end;

//процедура вывода комплексного числа z

procedure WriteComplex;

begin

with z do

if (re=0) and (im=0) then

write('0')

else

begin

if re<>0 then

write(re:2:2);

if im<>0 then

begin

if (im>0) and (re<>0) then

write('+');
 write(im:2:2,'i')

end;

end;

writeln;

end;

//функция сложения двух комплексных чисел x и y

function AddComplex;

begin

result.re:=x.re+y.re;

result.im:=x.im+y.im;

end;

//функция вычитания двух комплексных чисел x и y

function SubComplex;

begin

result.re:=x.re-y.re;

result.im:=x.im-y.im;

end;

//функция умножения двух комплексных чисел x и y

function MultComplex;

begin

result.re:=x.re*y.re-x.im*y.im;

result.im:=x.re*y.im+x.im*y.re;

result:=result;

end;

//функция деления комплексного числа z на целое число n

function DivComplexByNum;

begin

if n<>0 then

begin

result.re:=z.re/n;
 result.im:=z.im/n;

end;

end;

//функция модуля комплексного числа z

function AbsComplex;

begin

result:=sqrt(z.re*z.re+z.im*z.im);

end;

//функция вычисления значение комплексной функции в заданной

комплексной точке z с заданной точностью eps

function ExpComplex;

var i: integer;

a,z2,sum:TComplex;

begin

i:=1;

sum:=InitComplex(1,0);

a:=InitComplex(1,0);

z2:=z;

while AbsComplex(a)>eps do

begin

a:=DivComplexByNum(MultComplex(a,z2),+i*i);

sum:=AddComplex(sum,a);

i:=i+1;

end;

result:=sum;

end;

end.
Задача:
В арифметическое выражение входят:
- переменные;
- целые числа;
- знаки '+', '–', '*', '/';
- скобки '(', ')'.
Вычислить значение арифметического выражения, хранящегося в постфиксной записи.

function getWord(s : string; var i : integer) : string;

var
start, len : integer;
begin
// Записать начало слова
start := i;
while (i < length(s)) AND (s[i] in ['0'..'9']) do
inc(i);
len := i - start;
// Скопировать слово
result := copy(s, start, len);
end;

// Выполнить операцию op с операндами left и right

function calcExpr(left : real; right : real; op : char) : real;
begin
case op of
'+':
result := left + right;
'-':
result := left - right;
'*':
result := left * right;
'/':
result := left / right;
end;
end;

function calculate(s : string) : real;

var
i, int : integer;
num : real;
stack : TStack;
sNum : string;
begin
i := 1;
init(stack);
while i <= length(s) do
case s[i] of
'0'..'9':
begin
sNum := getWord(s, i);
if TryStrToInt(sNum, int) then
push(stack, int)
 else
raise Exception.Create('Не корректное выражение');
end;
'+','-','/','*':
begin
num := calcExpr(pop(stack), pop(stack), s[i]);
push(stack, num);
inc(i);
end;
else
inc(i);
end;
result := pop(stack);
end;
Задача 8: в заданном дереве найти поддерево двоичного поиска с
максимальным количеством элементов.
functionTNode.MaxOrderTree(var Min, Max : TElem; varMaxCount :
integer;
varMaxNode : TNode) : Integer;
var
tmpMin, tmpMax : TElem;
tmpCount : Integer;
begin
Min := Info;
Max := info;
// считаем, что искомое дерево существует в виде любого
терминального эл-та
Result := 1;
// действия, если мы не можем двигаться влево или уже возврат из
рекурсии
ifleft<>nilthenbegin
// входим в рекурсию, запоминая максимальное на данный момент
количество
// элементов в поддереве поиска в локальную, временную
переменную
tmpCount := left.MaxOrderTree(tmpMin, tmpMax, MaxCount, MaxNode);
if (tmpCount = -1) or (info <tmpMax) then
// если поддерево не найдено или в левом поддереве существует
элемент,
// значение которого больше элемента в корне, то дерева не
существует (-1)
Result := -1
elsebegin
// прибавляем в результат количество элементов левого
поддерева
Result:=Result+tmpCount;
// считаем, что в левом поддереве не может быть значения
// меньше чем этот Min
min := tmpMin;
end;
end;
// действия, если мы не можем двигаться вправо или уже возврат
из рекурсии
if(right<>nil) thenbegin
// входим в рекурсию, запоминая максимальное на данный момент
количество
// элементов в правом поддереве поиска в локальную переменную
tmpCount := right.MaxOrderTree(tmpMin, tmpMax, MaxCount, MaxNode);
if (tmpCount = -1) or (info >tmpMin) or (Result = -1) then
// если поддерево поиска не найдено или в нем существует элемент,
// значение которого меньше элемента в корне, то дерева не
существует (-1)
Result := -1
elsebegin
// прибавляем в результат количество элементов правого
поддерева
Result:=Result+tmpCount;
// считаем, что в правом поддереве не может быть значения
// больше чем этот Min
max := tmpMax;
end;
end;
// если в результате рекурсии и обхода левого и правого
поддерева мы нашли
// поддерево поиска с большим числом элементов, чем мы запомнили
сейчас,
// то обновялем информацию о количестве элементов в максимальном
поддереве
// и становимся указателем на текущее звено
if Result >MaxCount then begin
MaxCount := Result;
MaxNode := self;
end;
end;
При этом вызов для класса дерева выглядит след образом:
function TTree.SearchMax : TTree;
var
min, max : TElem;
count : integer;
tmpNode : TNode;
begin
count := 0;
Result := TTree.Create;
if FRoot <> nil then
begin
FRoot.MaxOrderTree(min, max , count, tmpNode);
Result.FRoot:=tmpNode.Copy;
end;
end;
Задача: Проверить, является ли заданное двоичное дерево сбалансированным.

//метод IsBalancedописываетсяв модуле UTree

//он определяет, является ли дерево сбалансированным
function TTree.IsBalanced: boolean;
begin
result:=true;
if not IsEmpty then
result:=(FRoot.Height> 0)
end;

//метод Heightописывается в модуле UNode

//он подсчитывает высоту поддерева
functionTNode.Height;
varl,r:integer;
begin
if Left <> nil then
l:=Left.Height
else
l:=0;
if Right <> nil then
r:=Right.Height
else
r:=0;
if (l = -1) or (r = -1) or (abs(l-r) > 1) then
result:= -1
else
if (l > r) then
result:=l+1
else
result:=r+1;
end;
Задача:Дана очередь из слов (все слова различны). Удалить из нее все слова, содержащие
больше гласных, чем согласных. Не использовать дополнительные структуры данных, кроме
набора переменных.

//используется очередь на основе списка

// Проверка на отсутствие лишних символов в слове
functionCorrectWord(str: string): boolean;
var
i, len: integer;
begin
result := true;
len := Length(str);
i := 1;
while (i<= len) and result do
begin
ifnot(str[i] in ['a'..'z', 'A'..'Z']) then
result := false;
Inc(i);
end;
end;
functionReadWords(var Q: TQueue; str: string): boolean;
var
word: string;
i, len: integer;
begin
Init(Q);
str := Trim(str);
len := Length(str);
i := 1;
result := true;

while (i<=len) and result do

begin
word := NextWord(str, i);
// Проверканаправильныйввод
ifnot(CorrectWord(word)) then
result := false
else
Push(Q,word);
end;
ifnot Result then
ClearQueue(Q);
end;
// Возвращает true, если гласных больше, чем согласнх
functionConsonantsMoreThanVowels(str: string): boolean;
const
Vowels = ['A', 'E', 'I', 'O', 'U', 'Y', 'a', 'e', 'i', 'o', 'u', 'y'];
var
v, i: integer;
begin
v := 0;
for i:= 1 to Length(str) do
ifstr[i] in Vowels then
inc(v);
result := Length(str)-v > v;
end;

// Поискпервогоподходящегослова
functionSearchFirstWord(var Q: TQueue; varfirstWord: string): boolean;
begin
repeat
result := TryPop(Q, firstWord);
untilnotConsonantsMoreThanVowels(firstWord) or not result;
end;

// Берет из списка слова и возвращает их, если они удовлетворяют условию

proceduredelWord(var Q: TQueue; firstWord: string);
var
str: string;
begin
Push(Q,firstWord);
Push(Q,firstWord);
// Берет слова и возвращает нужные (первое слово оказывается в конце)
while (TryPop(Q,str) and (str<>firstWord)) do
ifnotConsonantsMoreThanVowels(str) then
Push(Q,str);
end;
//основная программа
Var
Q: TQueue;
firstWord, str: string;
begin
readln(str);
ifnotReadWords(Q, str) then
writeln('Ввод был осуществлен некорректно')
else
begin
ifSearchFirstWord(Q, firstWord) then
delWord(Q, firstWord);
Writeln(QueueToStringAndClear(Q));
End;
end;
Задача: Определить, процедуру или функцию, которая определяет число вхождений
заданного элемента в дерево (рекурсивно и итеративно).

//юнит для работы с узлом

unit UNode;

interface

uses ComCtrls, SysUtils, Contnrs;

const
MinElem = 0;
MaxElem = 10;

type
TElem = MinElem..MaxElem;
TNode = class
private
FInfo: TElem;
FLeft, FRight: TNode;
Public
constructor Create(el: TElem);
destructor Destroy; override;
procedure AddRnd(el: TElem);
procedure Show(TV: TTreeView; pn: TTreeNode);
function CountElem (el: TElem): Integer;

property Info: TElem read FInfo;

property Left: TNode read FLeft write FLeft;
property Right: TNode read FRight write FRight;

end;

implementation

//конструктор
constructor TNode.Create(el: TElem);
begin
FInfo := el;
FLeft := nil;
FRight := nil;
end;

//удаление узла
destructor TNode.Destroy;
begin
if FLeft <> nil then
FLeft.Destroy;
if FRight <> nil then
FRight.Destroy;

inherited;
end;

//добавить рандомный узел

procedure TNode.AddRnd(el: TElem);
begin
if System.Random(2) = 1 then
if FLeft = nil then
FLeft := TNode.Create(el)
else
 FLeft.AddRnd(el)
else
if FRight = nil then
FRight := TNode.Create(el)
else
FRight.AddRnd(el);
end;

//показ узла
procedure TNode.Show(TV: TTreeView; pn: TTreeNode);
var
node: TTreeNode;
begin
node := TV.Items.AddChild(pn, IntToStr(FInfo));
if (FLeft <> nil) or (FRight <> nil) then
begin
if FLeft = nil then
TV.Items.AddChild(node, 'x')
else
FLeft.Show(TV, node);
if FRight = nil then
TV.Items.AddChild(node, 'x')
else
FRight.Show(TV, node);
end;
end;

//подсчет количества вхождения элементов для одного узла

function TNode.CountElem (el: TElem): Integer;
begin
Result := Ord(self.Info = el);
if Self.Left<>nil then
Result := Result + Self.Left.CountElem(el);
if Self.Right <> nil then
Result := Result + Self.Right.CountElem(el);
end;

end.

//юнит для работы с деревом

unit UTree;

interface

uses ComCtrls, Math, SysUtils, UNode, Contnrs;

type
TTree = class
private
FRoot: TNode;
public
//конструктор
constructor Create;
//деструктор
destructor Destroy; override;
//очистка дерева
procedure Clear;
//проверка на пустоту
function IsEmpty: boolean;
//добавление узла
procedure AddRandom(el: TElem);
 //заполнение случайным образом
procedure Random (N: integer);
//показ дерева
procedure Show (TV: TTreeView);
//подсчет количества вхождений элемента в дерево
function CountElem (el: TElem): Integer;
function CountElemIter(el: TElem): Integer;
end;

implementation

//конструктор
constructor TTree.Create;
begin
FRoot := nil
end;

//деструктор
destructor TTree.Destroy;
begin
Clear;
inherited;
end;

//очистка
procedure TTree.Clear;
begin
FreeAndNil(FRoot)
end;

//проверка на пустоту
function TTree.IsEmpty: boolean;
begin
Result := FRoot = nil
end;

//добавление узла
procedure TTree.AddRandom(el: TElem);
begin
if IsEmpty then
FRoot := TNode.Create(el)
else
FRoot.AddRnd(el);
end;

//заполнение случайным образом

procedure TTree.Random(N: integer);
begin
Clear;
While N > 0 do
begin
AddRandom(RandomRange(MinElem, MaxElem));
dec(N)
end
end;

function TTree.CountElem (el: TElem): Integer;

begin
Result := 0;
if FRoot<>nil then
Result:=FRoot.CountElem(el);
end;

function TTree.CountElemIter(el: TElem): Integer;

var Q: TQueue; tmp: TNode;
begin
Result := 0;
if not IsEmpty then
begin
Q := TQueue.Create;
Q.Push(FRoot);
while Q.Count > 0 do
begin
tmp := Q.Pop;
if (tmp.Info = el) then Inc(Result);
if tmp.Left <> nil then Q.Push(tmp.Left);
if tmp.Right <> nil then Q.Push(tmp.Right);
end;
Q.Destroy;
end;
end;

// Показ дерева
procedure TTree.Show(TV: TTreeView);
begin
TV.Items.Clear;
if not IsEmpty then
FRoot.Show(TV, nil);
TV.FullExpand;
end;

end.

//основная функция (реализована на форме)

//подсчет количества вхождний элемента в дерево

procedure TFormMain.btnCountElemClick(Sender: TObject);
var res: string;
begin
if Tree.IsEmpty then MessageDlg('Ошибка! Дерево пусто!', mtWarning,
[mbOK], 0)
else
begin
if not CheckInput(EdtElemIn.Text) then MessageDlg('Ошибка! Некорректный
ввод!', mtWarning, [mbOK], 0)
else
begin
res := FloatToStr(Tree.CountElem(StrToInt(EdtElemIn.Text)));
MessageDlg('Количество вхождений элемента в дерево: ' + res,
mtInformation, [mbOK], 0)
end;
end;
end;
12. Даны 2 очереди из слов. Разместить в одной очереди слова с четной длиной, в другой - с
нечетной, не используя дополнительных структур данных, кроме набора переменных

//объявление очереди
type
TElem = string;
TPtr = ^TNote;
TNote = record
inf: TElem;
next: TPtr;
end;
TQueue = record
head, tail: TPtr;
end;

var Q1, Q2: TQueue;

//стандартно реализованные функции

procedure Init (var Q: TQueue);
function IsEmpty (var Q: TQueue): boolean;
procedure Push (var Q: TQueue; el: TElem);
function TryPop (var Q: TQueue;var el:TElem): boolean;
function MoveAll (var Q1,Q2: TQueue): integer;
procedure ClearQueue (var Q: TQueue);

//UQueueUtils - некоторые вспомогательные функции

//процедура кладёт слова с чётной длиной в Q1, а с нечётной в Q2

procedure Process(var Q1, Q2 : TQueue);
var
i,k: integer;
el: TElem;
begin
MoveAll(Q1,Q2);
k := MoveAll(Q2,Q1);
for i:=1 to k do
if TryPop(Q1,el) then
if odd(length(el)) then
Push(Q2,el)
else
Push(Q1,el);
end;

//где-то созданы и заполнены очереди Q1 и Q2

//основная задача
procedure Main(var Q1,Q2: TQueue);
begin
Process(Q1,Q2);
ClearQueue(Q1);
ClearQueue(Q2);
end;
Задача: Проверить, что элементы данного дерева встречаются в нем еще хотя бы
один раз.

Function find_other(var this, node :TPnt):Boolean

begin
if node=nil then
result:=false
else
if (this^.info=node^.info and this<>node) then
result:=true
else
result:=find_other(this, node^.right) or
(find_other(this, node^.left))
end;

function Task (node, root: TPnt):Boolean

begin
if node = nil then
result:=true
else
if not find_other(node, node) then
result:=false
else
result:= Task(node^.left, root) and
(node^.right, root);
end;
Задача:Преобразовать выражение из постфиксной формы в инфиксную

// Проверка, является ли символ цифрой

function IsDigit(ch: char): boolean;

begin

Result:=ch in ['0'..'9'];

end;

// Проверка, является ли символ буквой

function IsLetter(ch: char): boolean;

var letters: set of char;

begin

letters:=['a'..'z', 'A'..'Z'];

Result:=ch in letters;

end;

// Процедура пропуска пробелов

procedure SkipSpaces(const buf: string; var i: integer);

var len: integer;

begin

len:=Length(buf);

while (i <= len) and (buf[i] = ' ') do

inc(i);

end;

// Функция получения идентификатора

function GetIdent(const buf: string; var i: integer): string;

var len, exprPos: integer;

ok: boolean;

begin

len:=length(buf);

exprPos:=i;

ok:=true;

while (i <= len) and ok do

 begin

if not (IsLetter(buf[i]) or IsDigit(buf[i]) or (buf[i] = '_'))

then

ok:=false

else

inc(i);

end;

Result:=Copy(buf, exprPos, i-exprPos);

end;

// Функция получения числа

function GetNum(const buf: string; var i:integer): string;

var len, numPos: integer;

ok: boolean;

begin

len:=length(buf);

numPos:=i;

ok:=true;

while (i <= len) and ok do

begin

if not IsDigit(buf[i]) then

ok:=false

else

inc(i);

end;

Result:=Copy(buf, numPos, i-numPos);

end;

// Функция преобразования выражения из постфиксной формы в инфиксную

function PostfixToInfix(const buf: string; var infix: string):integer;

var len, i: integer;

ok: boolean;

fEl, lEl: TElem;

s: TStack;

begin

ok:=true;

len:=Length(buf);

i:=1;

Result:=-1;

Init(s);

While (i <= len) and ok do

begin

case buf[i] of

' ': SkipSpaces(buf, i);

'A'..'Z', 'a'..'z','_': Push(s, GetIdent(buf, i));

'0'..'9': Push(s, GetNum(buf, i));

'~':

if not (TryPop(s, lEl)) then

begin

Result:=i;

ok:=false;

end

else

begin

Push(s, '('+'-'+lEl+')');

inc(i);

end;
 '+', '-', '*', '/':

if not (TryPop(s, lEl) and TryPop(s, fEl)) then

begin

Result:=i;

ok:=false;

end

else

begin

Push(s, '('+fEl+buf[i]+lEl+')');

inc(i);

end;

else //case

if i <= len then

begin

Result:=i;

ok:=false;

end;

end;

end;

if Result = -1 then

if TryPop(s, lEl) and IsEmpty(s) then

infix:=lEl

else

Result:=i;

Clear(s);

end;

Вспомогательный модуль Ustack.

unit UStack;

interface

uses Dialogs;

const

MaxN=1000;

type

TElem=string;

TMas=array[1..MaxN] of TElem;

TStack=record

mas: TMas;

top: integer;

end;

{Инициализация стека}

procedure Init(var s: TStack);

{Проверка на пустоту}

function IsEmpty(var s: TStack): boolean;

{Проверка на заполненность}

function IsFull(var s: TStack): boolean;

{Поместить объект в стек}

procedure Push(var s: TStack; el: TElem);

{Достать элемент из стека}

function Pop(var s: TStack): TElem;

{Достать элемент из стека}

function TryPop(var s: TStack; var el: TElem): boolean;

{Очистить стек}

procedure Clear(var s:TStack);

implementation

{Инициализация стека}
procedure Init(var s: TStack);

begin

s.top:=0;

end;

{Проверка на пустоту}

function IsEmpty(var s: TStack): boolean;

begin

Result:=s.top=0;

end;

{Проверка на заполненность}

function IsFull(var s: TStack): boolean;

begin

Result:=s.top=MaxN;

end;

{Поместить объект в стек}

procedure Push(var s: TStack; el: TElem);

begin

if not IsFull(s) then

begin

inc(s.top);

s.mas[s.top]:=el;

end

else

MessageDLG('Error! Attempt to push element in full stack.',

mtError, [mbOK], 0);

end;

{Достать элемент из стека}

function Pop(var s: TStack): TElem;

begin

if not IsEmpty(s) then

 begin

Result:=s.mas[s.top];

dec(s.top);

end

else

MessageDLG('Error! Attempt to pop element from empty stack.',

mtError, [mbOK], 0);

end;

{Достать элемент из стека}

function TryPop(var s: TStack; var el: TElem): boolean;

begin

if not IsEmpty(s) then

begin

el:=s.mas[s.top];

dec(s.top);

Result:=true;

end

else

Result:=false;

end;

{Очистить стек}

procedure Clear(var s:TStack);

begin

while not IsEmpty(s) do

Pop(s);

end;

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

{
TElem=record
open_index:integer;
close_index:integer
end;
всеф-ииизмодуля UStack_list?
}
unitmain;
uses
UStack, SysUtils;
type
TKindError = (keNone, keOpen, keClose);
implementation
//проверка стека на сбалансированность скобок
functionisBracketMissed(s1,s2:TStack):TKindError;
var
el:TElem;
begin
result:=keNone;
whilenotIsEmpty(s1) and not ((result=keOpen) or (result=keClose)) do
begin
el:=Pop(s1);
ifel.open_index = 0 then result:=keOpen;
ifel.close_index = 0 then result:=keClose;
Push(s2,el)
end;
Move(s2,s1)
end;

//конвертация пар индексов в строку

functionPrintResultToStr(var s1,s2:TStack):string;
var
el:TElem;
begin
result:='';
Move(s1,s2);
whilenotIsEmpty(s2) dobegin
el:=Pop(s2);
result:=result + IntToStr(el.open_index)+ '-' +
IntToStr(el.close_index) + #13 + #10
end;
end;

//определение позиций скобок и сорт

functionOpenBracketIndex(str:string; var SL:string):TKindError;

var
s_main, s_help:TStack;
index:integer;
elem:TElem;
isFound:boolean;

begin
Init(s_main);
Init(s_help);
index:=1;
result:=keNone;
while (index <= length(str)) dobegin
isFound:=false;
while (index<=length(str)) and (str[index]<>'(') and (str[index]<>')')
do
inc(index);
ifstr[index]='(' thenbegin
Element(elem);
elem.open_index:=index;
Push(s_main,elem)
end;
ifstr[index]=')' thenbegin
repeat
ifnotTryPop(s_main,elem) then
result:=keOpen
elsebegin
ifelem.close_index=0 thenbegin
isFound:=true;
elem.close_index:=index;
Push(s_main,elem)
end
else
Push(s_help,elem)
end
untilIsEmpty(s_main) orisFound;
ifnotisFoundandIsEmpty(s_main) then
result:=keOpen;
Move(s_help,s_main);
end;
inc(index)
end;
if result<>keOpenthen
result:=isBracketMissed(s_main,s_help);
if result=keNonethen
SL:=PrintResultToStr(s_main,s_help)
end;
//где-то в главной процедуре (в лабах – btnOKClick)
error:=OpenBracketIndex(Text.Text,tmp);
case error of
keOpen: MessageDlg('Нехватаетоткрывающейскобки!', mtError, [mbOk], 0);
keClose: MessageDlg('Не хватает закрывающей скобки!', mtError, [mbOk],
0);
elseResultText.Text:=tmp
end
end.
Задача: Напечатать обращенные строки файла в обратном порядке.

procedurere versString (var s:string)

Var stack:TStackChar;//стек из символов
I, len:integer;
Begin
Len:=Length(s);
For i:=1 to len do
Push(stack,s[i]);
For i:=1 to len do
S[i]:=pop(stack);
End;

Procedure reversFile (var input, output:TextFile)

Var tmp:string;
S:TStackString;//стек из строк
Begin
While not eof(input) do
Begin
Readln(input,tmp);
reversString(tmp);
push(tmp, s);
end;
while not IsEmpty(s) do
writeln(output, pop(s));
end;
Задача: Дан текст, сбалансированный по круглым скобкам. Требуется для каждой
пары соответствующих открывающей и закрывающей скобок напечатать номера их
позиций в тексте, упорядочив пары номеров в порядке возрастания номеров позиций
закрывающих скобок.

uses
SysUtils,UStack_list, StackUtils;

{Типошибки}
type
TKindError=(keNone, keOpen, keClose);

{Расшифровкаошибки}
const
TextError :array[TKindError] ofstring = ('','Не хватает
открывающихся скобок','Не хватает закрывающихся скобок');

{Функция help получает на вход стеки S1 и S2 и номер скобки i

для поиска
открывающейся скобки. Возвращает true, если такая скобка была
найдена, false -
впротивномслучае.}
function Help (var S1, S2 : TStack; i : Integer) : Boolean;
var
el:TElem;
begin
Result:=False;
whilenot Result andnot IsEmpty(S1) dobegin
Pop(S1,el);
ifel.TOpen=0 thenbegin
Result:=True;
Push(S1,Elem(el.TClose,i));
end
else
push(S2,el)
end;
if result then
MoveAll(S2,S1)
else
ClearStack(S2);
end;{Help}

{Функция Process получает введенную строку Expression и пустой

список, состоящий из
строк - типа TStringList. Возвращает тип ошибки TKindError}
function Process(Expression:string; SL:TStrings):TKindError;
var
Stack, TmpStack:TStack;
len,i:integer;
el:TElem;
begin
 Result:=keNone;
Init(Stack);
Init(TmpStack);
len:=Length(Expression);
i:=len;
while (i<>0) and (Result = keNone) dobegin
case Expression[i] of
')': Push(Stack, Elem(i));
'(': if not Help(Stack, TmpStack, i) then
result:=keClose
end;
Dec(i);
end;

MoveAll(Stack,TmpStack);
MoveAll(TmpStack,Stack);
while (Result=keNone) and (not IsEmpty(Stack)) dobegin
Pop(Stack, el);
if (el.TOpen<>0) then
SL.Add(IntToStr(el.TOpen)+' - '+IntToStr(el.TClose))
elsebegin
result:=keOpen;
SL.Clear;
end;
end;

ClearStack(Stack);
ClearStack(TmpStack);
end;{Process}
Посчитать число листьев (терминальных end.
элементов) в заданном двоичном дереве

unit UNode;
interface unit UTree;
uses ComCtrls, Math, SysUtils, interface
Contnrs; uses ComCtrls, Math, SysUtils,
const UNode, Contnrs;
MinElem = 0; type
MaxElem = 20; TTree = class
private
type FRoot : TNode;
TElem = MinElem..MaxElem; public
TNode = class constructor Create;
public procedure Clear;
FInfo : TElem; //или в private со function IsEmpty : boolean;
свойствами procedure Random (N : integer);
FLeft, FRight : TNode; function FindLeaf():integer;
//создание с nil destructor Destroy; override;
constructorCreate(el : TElem = 0); end;
//создание очереди с N
элементов implementation
constructor Random (n : integer); constructor TTree.Create;
function FindLeaf():integer begin
destructor Destroy; override; FRoot:=nil
end; end;

implementation procedure TTree.Clear;

constructor TNode.Random(N: begin
integer); FreeAndNil(FRoot)
var end;
nl : integer;
begin function TTree.IsEmpty: boolean;
Create(RandomRange(MinElem, begin
MaxElem+1)); Result:=FRoot = nil
nl:=System.Random(N); end;
if nl>0 then
FLeft:=TNode.Random(nl); procedure TTree.Random(N: integer);
if N-nl-1>0 then begin
FRight:=TNode.Random(N-nl-1); Clear;
end; if N>0 then
FRoot:=TNode.Random(N);
function TNode.FindLeaf():integer; end;
begin
if self<>nil then function TTree.FindLeaf():integer;
begin begin
result:=0; result:=FRoot.findleaf();
if (left=nil) and (right=nil) end;
theninc(result)
elseresult:=result+left.FindLeaf() destructor TTree.Destroy;
+ right.FindLeaf(); begin
end;end; Clear;
inherited;
destructor TNode.Destroy; end;
begin
if FLeft<>nil then end.
FLeft.Destroy;
FRight.Free;
inherited;
end;
Задача №20. Задан массив Name [1..N], содержащий имена людей, и массив
Children [1..N, 1..N], в котором Children [i, j] = true, если человек
под номером j является ребенком человека под номером i. Для человека с
заданным номером k напечатать сначала имена всех его детей, затем – всех
его внуков, затем – всех правнуков и т.д.

const N = 100;
var
Name : array [1..N] of string;
Children : array [1..N, 1..N] of Boolean;
…
procedure GetAllChildren (k : integer);
var
q1, q2 : TQueue;
j : integer;
s : set of 1..N;
begin
Init(q1);
Init(q2);
writeln(Name[k]);
Push(q1, k);
s := [k];
while not IsEmpty(q1) do
begin
while not IsEmpty(q1) do
begin
k := Pop(q1);
for j:= 1 to N do
if Children[k, j] and not (j in s) then
begin
write (Name[j], ' ');
s := s + [j];
Push(q2, j);
end;
end;
writeln;
while not IsEmpty(q2) do
Push(q1, Pop(q2));
end;
end;
Задача №21. Определить высоту заданного двоичного дерева.

//рекурсивно
function TNode.Height : integer;
var
l, r: integer;
begin
if self= nil then
result:=0
else
begin
l:=Left.Height;
r:=Right.Height;
if l > r then
result := l + 1
else
result := r + 1
end
end;

function TTree.Height: integer;

begin
result := FRoot.Height
end;

//итеративно
function TTree.HeightIter : integer;
var Q: TQueue;
n, n_new: integer;
t: TNode;
begin
result:=0;
if FRoot<>nil then
begin
Q:=TQueue.Create;
Q.Push(FRoot);
n:=1;
while (Q.Count > 0) do
begin
inc(Result);
n_new:=0;
while (n>0) do
begin
t:=Q.Pop;
dec(n);
if t.Left <> nil then
begin
Q.Push(t.Left);
inc(n_new);
end;
 if t.Right <> nil then
begin
Q.Push(t.Right);
inc(n_new);
end;
end;
n:=n_new;
end;
Q.Free;
end;
end;
Задача:
Даны два стека, содержащие целые числа (считать, что все числа различны).
Напечатать максимальное и минимальное числа, восстановив при этом содержимое
стеков. Не использовать дополнительные структуры данных, кроме набора
переменных.

procedureMoveN(var source, dest: TStack; n: integer);

begin
while (n > 0) and not IsEmpty(source) do begin
Push(dest, Pop(source));
dec(n);
end;
end;

functionMoveAll(var source, dest: TStack): integer;

begin
Result := 0;
while not IsEmpty(source) do begin
Push(dest, Pop(source));
inc(Result);
end;
end;

functionTryFindMinMax(var s1, s2: TStack; var min, max: integer) :

boolean;
var
cntS1, cntAll: integer;
begin
cntS1 := MoveAll(s1, s2);
ifIsEmpty(s2) then result := false
else begin
max := Pop(s2);
min := max;
cntAll := 1;
MinMax(s2, s1, min, max, cntAll);
MoveN(s1, s2, cntAll - cntS1);
result := true;
end;
end;

procedureMinMax(var source, dest: TStack; var min, max, cnt: integer);

var el: TElem;
begin
while not IsEmpty(source) do begin
el := Pop(source);
if (el > max) then max := el;
if (el < min) then min := el;
Push(dest, el);
inc(cnt);
end;
end;
Задача №23 : Вычислить значение формулы:
<формула>::=<цифра> | M(<формула>,<формула>)| m(<формула>,<формула>)
<цифра>::=0|1|2|3|4|5|6|7|8|9, M обозначает функцию max, а m — min.

type
SetChar = set of Char;
…

//функция, возвращающая параметр в зависимости от операции

function GetOperand (op, param1, param2 : char) : Char;
begin
if op = 'M' then
if param1 > param2 then
Result := param1
else
Result := param2
else
if op = 'm' then
if param1 < param2 then
Result := param1
else
Result := param2;
end;

//функция, пытающаяся получить из стека элемент ch

//возвращает true, если ch находится в множестве s, false - в противном
случае
function TryPop(var stack : TStack; var ch : Char;
s : SetChar) : Boolean;
begin
Result := not IsEmpty(stack);
if Result then
begin
ch := Pop(stack);
Result := ch in S;
end;
end;

//функция возвращает true, если формула записана верно, false - в

противном случае
//str - формула, res - результат формулы
function CheckAndSolve(str : string; var res : Char) : Boolean;
var
stack : TStack;
i, len : Integer;
a, b, op : Char;
begin
Init (stack);
Result := True;
len := Length (str);
 i := 1;
while (i<=len) and Result do
begin
case str[i] of
'M','m','0'..'9' : Push(stack, str[i]);
'(', ' ', ',' : ;
')':
if TryPop(stack, a, ['0'..'9']) and TryPop(stack, b,
['0'..'9']) and TryPop(stack, op, ['M','m']) then
Push(stack, GetOperand(op, a, b))
else
Result := false;
else
Result:= false;
end; //case
end; //while
Result:= Result and TryPop(stack, res, ['0'..'9']) and IsEmpty(stack);
Clear (Stack);
end;
Дан текстовый файл A. Переписать его содержимое в файл B, перенося при этом в
конец каждой строки все входящие в нее знаки препинания.

{Решение задачи}
function ProcessStr (str : string) : string;
const
punkt_marks= [',','.','?','!','"'];
var
bufer: TQueue;
i : integer;
ch: char;
begin
Init(bufer);
Result:='';

for i:=1 to Length(str) do

if str[i] in punkt_marks then
TryPush(bufer,str[i])
else
Result:=Result+str[i];

while TryPop(bufer,ch) do
Result:=Result+ch;
end;

procedure TTask_2.btnPerfTaskClick(Sender: TObject);

var
j: integer;
begin
ResTxtbox.Clear;
for j:=0 to InputTxtbox.Lines.Count-1 do
ResTxtbox.Lines.Add(ProcessStr(InputTxtbox.Lines[j]));
end;
{конец решения}

Вспомогательный модуль UQueue;

unit UQueue;

interface

const
N=100;

type
TElem=Char;
TMas=array[0..N-1] of TElem;
TQueue=record
mas: TMas;
head, count: Integer;
end;

procedure Init(var Q: TQueue);

function IsEmpty(var Q: TQueue):Boolean;
function IsFull(var Q: TQueue):Boolean;
function TryPush(var Q: TQueue; el:TElem):Boolean;
function TryPop(var Q: TQueue; var el:TElem):Boolean;

implementation

procedure Init;
begin
Q.head:=0;
Q.count:=0;
end;

function IsEmpty;
begin
result:=Q.count=0;
end;

function IsFull;
begin
result:=Q.count=N;
end;

function TryPop;
begin
if not IsEmpty(Q) then
with Q do
begin
el:=mas[head];
head:=(head+1)mod N;
dec(count);
result:=true
end
else
result:=False;
end;

function TryPush;
var
tail: Integer;
begin
result:=not IsFull(Q);
if Result then
with Q do
begin
tail:=(head+count)mod N;
mas[tail]:=el;
inc(count);
end;
end;
end.