read(f,n,k);
for i:=1 to n do
  read(f,massiv[i]);

var i : extended;
begin
i := 0.99;
writeln(i);
readln;
end.

var
f:text;
stroka,p,k,h:string;
r,i,n,ch,l,errcode,err:integer;
begin
assign(f,'p.in');
reset(f);
read(f,stroka);
p:='';
h:='';
for i:=1 to length(stroka) do
if stroka[i] in ['1'..'9'] then begin
if stroka[i+1] in ['1'..'9'] then
k:=stroka[i]+stroka[i+1];
val(k,l,err);
for r:=1 to l do
h:=h+stroka[i];
delete(stroka,l,2);
insert(h,stroka,l);
end
else
val(stroka[i],ch,errcode);
for n:=1 to ch do
p:=p+stroka[i];
delete(stroka,ch,1);
insert(p,stroka,ch);
close(f);
writeln('otvet',stroka);
ну тут запись в файл и так далее
readln;
end.

 

Распаковка

Итак, файл открыт, строка s прочитана
num : string;         /*число символов*/
res   : string;         /*преобразованная строка*/
i : integer ;            /*счётчик*/
ind : integer ;        /*счётчик*/
i = 1; /*индексация в строке от 1*/
пока(i<длина(s))
( /*лишние проверки на цифры делать можно, но надо ли?*/
  если(s[i] в '0'..'9')
  ( num:='';
    пока (s[i] в '0'..'9')
    ( num:= num + s[i];
      /*сдвиг по строке*/
      i:= i+1;
    )
  )
  /*из строки в число*/
  len := число(num);
  //символ из алфавита?
  если(s[i] в 'A'..'Z')
     /*добавление в результат
     для ind от 1 до len делать
     ( res:=res+ s[i];
     )
)/*конец цикла пока */
/*Запись строки res в файл.*/
/*Обнуление res*/

Упаковка
Итак, файл опять же открыт :), строка s прочитана

res   : string;         /*преобразованная строка*/
i : integer ;            /*счётчик*/
counter : integer ;  /*счётчик повторов*/

ind : integer ;        /*счётчик*/
i = 1; /*индексация в строке от 1*/
counter = 1; /*символ уже однажды встретился*/

пока(i<длина(s))
( /*по-моему в Паскале последующее сравнение реализуется с помощью ord или chr, забыл уже*/
  если(s[i] == s[i+1])
  {i:=i+1;
   counter:=counter+1;
  }
  иначе
  (  res:= res + строка(counter);
     res:= res + s[i];
     i:=i+1;
  )
)
/*Запись строки res в файл.*/
/*Обнуление res*/

Function UnpackStr(S:string):string;
Const
    ResultStr :string ='';
    counterS  :string ='';
    counterB  :word   =0;
    j         :word   =0;
    res       :integer=0;
    i         :byte   =0;

Begin

for i:=1 to length(s) do
begin
  case s[i] of
  '0'..'9':counterS:=counterS+s[i];
  'A'..'Z':
          begin
            val(counterS,counterB,res);
            if  counterS='' then counterB:=1;
            for j:=1 to counterB do ResultStr:=ResultStr+s[i];
            counterS:='';
          end;
  else writeln('ERROR!!! Недопустимый символ!: ',s[i]);
  end;{case}
end;

UnpackStr:=ResultStr;

End; {UnpackStr}

{==================================================================}

Function PackStr(S:string):string;
Const     i:byte=0 ;
    counter:byte=1 ;
    prevCh :char  =#32;
    ResultS:string='';
   counterS:string='';

    procedure AddNCh;
    begin
      str(counter,counterS);
      if counter=1 then counterS:='';
      ResultS:=ResultS+counterS+prevCh;
      counter :=1;
      counterS:='';
      prevCh:=s[i];
    end;

Begin
  PrevCh:=s[1];
  for i:=2 to length(S) do
    if PrevCh=s[i]
    then inc(counter)
    else AddNCh;
  AddNCh;

  PackStr:=ResultS;
End; {PackStr}

{==================================================================}

Const PackedS:string='1B3A33';

BEGIN
{ writeln('Введите упакованную строку ');
  readln (PackedS);}
  writeln('  Packed string: ',PackedS);
  writeln('Unpacked string: ',UnpackStr(PackedS));
  writeln('Repacked string: ',PackStr(UnpackStr(PackedS)));
END.

program NSolve;
var Symbol:array[1..100] of char;
    RepeatsCount:array[1..100] of integer;
    N:integer;                {
    S:string;                }
procedure Init;
var ch:char;
    C:integer;
begin                 {
  if paramcount=0 then
    begin              }
      assign(input,'g.in'); {
    end
  else
    begin
      s:=paramstr(1);
      assign(input,s);
    end;                     }
  reset(input);
  N:=0;
  while not seekeoln(input) do
    begin
      inc(N);
      read(ch);
      if ch in ['0'..'9'] then
        begin
          C:=0;
          while ch in ['0'..'9'] do
            begin
              C:=C*10+ord(ch)-48;
              read(ch);
            end;
        end
      else
        C:=1;
      Symbol[N]:=ch;
      RepeatsCount[N]:=C;
    end;
  close(input);
end;
procedure Run;
var i,j:integer;
begin
  j:=0;
  for i:=1 to N do
    While RepeatsCount[i]>0 do
      begin
        inc(j);
        if j>40 then
          begin
            writeln;
            j:=1;
          end;
        write(Symbol[i]);
        dec(RepeatsCount[i]);
      end;
  writeln;
end;
begin
  Init;                       {
  if paramcount=0 then
    begin                    }
      assign(output,'g.out');  {
    end
  else
    begin
      delete(s,length(s)-2,3);
      s:=s+'res';
      assign(output,s)
    end;                        }
  rewrite(output);
  Run;
  close(output);
end.

type
s=array[1..32000] of integer;
var
m:s;
i,buf,k,n:integer;
f1,f2:text;
begin
assign(f1,'input.txt');
assign(f2,'output.txt');
reset(f1);
rewrite(f2);
read(f1,n);
for k:=1 to n do read(f1,m[k]);
for i:=1 to n-1 do
begin
for k:=1 to n-1 do
begin
if m[k]>m[k+1] then
begin
buf:=m[k];
m[k]:=m[k+1];
m[k+1]:=buf
end;
end;
end;
for k:=1 to n do
write(f2,m[k],' ');
close(f1);
close(f2);
end.

{$I C:\programS\TP\_common\byte2xxx.inc}
{byte2xxx.inc содержит Word2hex,DWord2hex -- простые функции, выводящие число в шестнадцатиричном виде.}

Const ArrSz=$1000; {количество элементов во вспомогательном массиве}
      myArrNum=4; {число вспомогательных массивов}

Type DynArr=array[1..ArrSz] of longint; {тип вспомогательного массива}
     DynArrT=^DynArr;

Var index:longint;
    myArray:array [1..myArrNum] of DynArrT;
 {собственно ПСЕВДОмассив повышенной вместимости,
 к его элементам необходимо обращаться через GetArray/SetArray}

    i:byte;

{--------------------------------------------------------------------------}

Function GetArray(idx:longint):longint;
Var diapazon:byte;
Begin
  diapazon:=((idx-1) div ArrSz);
  if diapazon<(myArrNum)
   then GetArray:=MyArray[diapazon+1]^[idx-ArrSz*diapazon];
End;

{--------------------------------------------------------------------------}

Procedure SetArray(idx:longint;data:longint);
Var diapazon:byte;
Begin
  diapazon:=((idx-1) div ArrSz);
  if diapazon<(myArrNum)
   then MyArray[diapazon+1]^[idx-ArrSz*diapazon]:=data;
End;

{--------------------------------------------------------------------------}

Procedure ShowFreeMem;
Begin
  writeln('MemAvail=',Dword2hex(MemAvail),'h');
  writeln('MaxAvail=',Dword2hex(MaxAvail),'h');
End;

{--------------------------------------------------------------------------}

BEGIN

if MaxAvail{MemAvail}>myArrNum*SizeOf(DynArr) then
begin

   ShowFreeMem;

   for i:= 1 to myArrNum do New(MyArray[i]);

   for i:= 1 to myArrNum do
       writeln(i,': segment = ',word2hex(Seg(MyArray[i]^)),
                 ';  offset = ',word2hex(Ofs(MyArray[i]^)));

   ShowFreeMem;

   {----------Работа с ПСЕВДОмассивом-------------------------------}
     for index:=1 to ArrSz*myArrNum do SetArray(index,index);
     for index:=1 to ArrSz*myArrNum do
        if GetArray(index)<>index then
        begin
          writeln('Error!!! index=',index);
          readln;
        end;
   {-----------------------------------------}

   for i:= myArrNum downto 1 do Dispose(MyArray[i]);
end
else writeln('Error!!! Не хватает памяти !');

ShowFreeMem;

END.
для удобства использования лучше организовать это дело в виде объекта