Зашифровать файл, выполнив циклическую замену каждой русской буквы, стоящей на K-й позиции строки

uses crt;
const s='9485273641';
var v: byte;
    f1,f2: text;
 
function Shifr(var str: string): string;
var k: byte; n,c: integer;
begin
for k:=1 to length(str) do
       begin
       if k mod 10=0 then val(s[10],n,c) else val(s[k mod 10],n,c);
       if str[k] in ['А'..'Я'] then
          if ord(str[k])+n>223 then str[k]:=chr(ord(str[k])+n-31)
             else str[k]:=chr(ord(str[k])+n);
       if str[k] in ['а'..'я'] then
          if ord(str[k])+n>255 then str[k]:=chr(ord(str[k])+n-31)
             else str[k]:=chr(ord(str[k])+n);
       end;
Shifr:=str;
end;
 
function DeShifr(var str: string): string;
var k: byte; n,c: integer;
begin
for k:=1 to length(str) do
       begin
       if k mod 10=0 then val(s[10],n,c) else val(s[k mod 10],n,c);
       if str[k] in ['А'..'Я'] then
          if ord(str[k])-n<192 then str[k]:=chr(ord(str[k])-n+31)
             else str[k]:=chr(ord(str[k])-n);
       if str[k] in ['а'..'я'] then
          if ord(str[k])-n<224 then str[k]:=chr(ord(str[k])-n+31)
             else str[k]:=chr(ord(str[k])-n);
       end;
DeShifr:=str;
end;
 
procedure ShifrFile;
var ss: string;
begin
assign(f1,'D:\in.txt');
assign(f2,'D:\temp.txt');
reset(f1);
rewrite(f2);
while not (eof(f1)) do
      begin
      readln(f1,ss);
      Shifr(ss);
      writeln(f2,ss);
      end;
close(f1);
close(f2);
erase(f1);
rename(f2,'D:\in.txt');
writeln('Файл зашифрован. Enter to continue...');
readln;
end;
 
procedure DeShifrFile;
var ss: string;
begin
assign(f1,'D:\in.txt');
assign(f2,'D:\temp.txt');
reset(f1);
rewrite(f2);
while not (eof(f1)) do
      begin
      readln(f1,ss);
      DeShifr(ss);
      writeln(f2,ss);
      end;
close(f1);
close(f2);
erase(f1);
rename(f2,'D:\in.txt');
writeln('Файл дешифрован. Enter to continue...');
readln;
end;
 
begin
repeat
writeln('0-закончить работу');
writeln('1-зашифровать файл');
writeln('2-дешифровать файл');
readln(v);
case v of
1: ShifrFile;
2: DeShifrFile;
else v:=0;
end;
until v=0;
end.

uses crt;
const s='9485273641';       //это строка-ключ, сюда - любые 10 цифр
var v: byte;                //переменная для выбора из меню
    f1,f2: text;            //файлы: основной и вспомогательный
 
procedure Shifr(var str: string);                    //процедура шифрования строки
var k: byte;                                                //переменная для счетчика
    n,c: integer;
begin
for k:=1 to length(str) do                                  //в цикле с параметром перебираем элементы шифруемой строки
       begin                                                //для каждого символа
       if k mod 10=0 then val(s[10],n,c) else val(s[k mod 10],n,c);    //если k кратно 10, то переводим в числовое значение последнюю (десятую) цифру строки-ключа
                                                                       //иначе вычисляем остаток от деления k на 10 и переводим в числовое значение цифру из строки-ключа под соответствующим номером
       if str[k] in ['А'..'Я'] then                                   //если символ - заглавная буква
          if ord(str[k])+n>223 then str[k]:=chr(ord(str[k])+n-31)     //и если добавление цифры сдвига приведет к выходу за пределы диапазона заглавных русских букв,
                                                                      //то отсчитываем нужное количество до 'Я', а потом продолжаем от 'А'
             else str[k]:=chr(ord(str[k])+n);                         //иначе просто отсчитываем нужный размер сдвига от символа и заменяем символ на новый
       if str[k] in ['а'..'я'] then                                   //то же самое для диапазона строчных букв
          if ord(str[k])+n>255 then str[k]:=chr(ord(str[k])+n-31)
             else str[k]:=chr(ord(str[k])+n);
       end;
end;
 
procedure DeShifr(var str: string);               //процедура дешифровки
var k: byte; n,c: integer;                               //переменные те же
begin
for k:=1 to length(str) do                               //действия те же
       begin
       if k mod 10=0 then val(s[10],n,c) else val(s[k mod 10],n,c);
       if str[k] in ['А'..'Я'] then
          if ord(str[k])-n<192 then str[k]:=chr(ord(str[k])-n+31) //только если во время шифрования сдвиг производился вперед (то есть вправо) по афавиту, расшифровка идет в обратную сторону - влево
             else str[k]:=chr(ord(str[k])-n);
       if str[k] in ['а'..'я'] then
          if ord(str[k])-n<224 then str[k]:=chr(ord(str[k])-n+31)
             else str[k]:=chr(ord(str[k])-n);
       end;
end;
 
procedure ShifrFile;                //процедура шифрования файла
var ss: string;                     //переменная для строки из файла
begin
assign(f1,'D:\in.txt');            //ассоциация переменной с исходным файлом
assign(f2,'D:\temp.txt');          //ассоциация переменной с вспомогательным файлом
reset(f1);                         //открываем исходный файл для чтения
rewrite(f2);                      //открываем вспомогательный файл для записи
while not (eof(f1)) do            //пока не достигнем конца исходного файла
      begin                       //повторяем
      readln(f1,ss);              //считываем строку из файла
      Shifr(ss);                  //инициализируем процедуру шифрования
      writeln(f2,ss);             //записываем полученную (зашифрованную) строку в файл
      end;
close(f1);                        //закрываем файлы
close(f2);
erase(f1);                        //уничтожаем исходный файл
rename(f2,'D:\in.txt');           //переименовываем итоговый файл в исходный
writeln('Файл зашифрован. Enter to continue...');
readln;
end;
 
procedure DeShifrFile;           //процедура дешифровки
var ss: string;                  //те же переменные и действия
begin
assign(f1,'D:\in.txt');
assign(f2,'D:\temp.txt');
reset(f1);
rewrite(f2);
while not (eof(f1)) do
      begin
      readln(f1,ss);
      DeShifr(ss);              //инициализируем процедуру дешифровки
      writeln(f2,ss);
      end;
close(f1);
close(f2);
erase(f1);
rename(f2,'D:\in.txt');
writeln('Файл дешифрован. Enter to continue...');
readln;
end;
 
begin
repeat                         //в цикле с постусловием
writeln('0-закончить работу');  //выводим варианты меню
writeln('1-зашифровать файл');
writeln('2-дешифровать файл');
readln(v);
case v of                     //оператор выбора - в зависимости от значения v
1: ShifrFile;                 //запускается процедура шифрования файла
2: DeShifrFile;               //запускается процедура дешифровки файла
else v:=0;                    //иначе v=0 и выход
end;
until v=0;
end.

if str[k] in ['А'..'Я'] then
          if ord(str[k])+n>223 then str[k]:=chr(ord(str[k])+n-31)
             else str[k]:=chr(ord(str[k])+n);
       if str[k] in ['а'..'я'] then
          if ord(str[k])+n>255 then str[k]:=chr(ord(str[k])+n-31)
             else str[k]:=chr(ord(str[k])+n);

if str[k] in ['А'..'Я']  //здесь мы определяем принадлежность шифруемого символа множеству заглавных русских букв, и если символ принадлежит этому множеству
     then                //тогда
 
//логическое отступление
{здесь надо напомнить, что шифрование осуществляется сдвигом вперед, то есть вправо по алфавиту на некое непостоянное (зависит от ключа) значение
если же символ находится в конце диапазона (А..Я), есть вероятность, что, добавив сдвиг, мы выйдем за пределы диапазона (например, если шифруемый символ "Э", а сдвиг больше 3, мы окажемся уже в диапазоне строчных букв,
а для строчных букв - можем оказаться вообще за пределами кодовой таблицы =))
следовательно, если диапазона вконце не хватает, необходимо вернуться к его началу и продолжить отсчет с А}
 
                                                   //итак, тогда
          if ord(str[k])+n>223                     //здесь проверка условия: если сдвиг-шифрование выходит за пределы диапазона
          then str[k]:=chr(ord(str[k])+n-31)       //то отсчитываем оставшийся сдвиг до конца диапазона заглавных букв, а потом продолжаем отсчет с начала диапазона заглавных букв (то есть с А), технически:
 
         {технически это так:
         str[k] - рассматрицаемый символ шифруемой строки под номером k
         := получает значение, сдвинутое внутри диапазона на n символов, для чего
         ord(str[k]) - узнаем номер символа в кодовой таблице
         ord(str[k])+n-31 - добавляем к нему нужное смещение и возвращаемся к отсчету от А (на 31 символ назад)
         chr(ord(str[k])+n-31) после чего по полученному коду символа определем символ-замену }
 
             else str[k]:=chr(ord(str[k])+n); //иначе, если сдвиг не приводит к выходу за пределы диапазона, просто
             
             {ord(str[k]) узнаем код шифруемого символа
             ord(str[k])+n добавляем к этому коду нужное смещение
             chr(ord(str[k])+n) и заменяем шифруемый символ символом с найденным кодом}
             
       if str[k] in ['а'..'я'] then                              //здесь то же самое, но для диапазона строчных русских букв...
          if ord(str[k])+n>255 then str[k]:=chr(ord(str[k])+n-31)
             else str[k]:=chr(ord(str[k])+n);