Здравствуйте, Юдин Евгений Сергеевич. Ответ на первый вопрос в Приложении. В варианте 1 "переворачивается" число целиком, в варианте 2 - побайтово. Turbo Pascal 7, ABC.


Приложение:
{ ============================== }
{ Дано целое неотрицательное число <2^16.
Получить число перестановкой битов каждого
байта данного числа в обратном порядке.
Вариант 1
}

program p177891a;
var
i: integer;
num: integer;
len: integer;
hi, lo: integer;

procedure PrintBinary(x: word);
{ печать беззнакового двухбайтового целого в битовой форме }
var
i: integer;
len: integer;
begin
len := sizeof(word)*8; { бит в числе }

for i:=len-1 downto 0 do
if (x and (1 shl i)=0) then
write('0')
else
write('1');
writeln;
end; { PrintBinary }

begin
len := sizeof(word)*8;

write('num=');
readln(num);

writeln('Введенное число');
PrintBinary(num);

for i:=0 to (len+1) div 2-1 do
begin
if (num and (1 shl (len-i-1)))<>0 then
hi:= 1
else
hi := 0;
if (num and (1 shl i))<>0 then
lo := 1
else
lo := 0;

{ если установлен левый бит, установить правый бит,
иначе сбросить правый бит }
if hi=0 then
num := num and not(1 shl i)
else
num := num or (1 shl i);

{если установлен правый бит, установить левый бит,
иначе сбросить левый бит }
if lo=0 then
num := num and not (1 shl (len-i-1))
else
num := num or (1 shl (len-i-1));
end;
writeln('Число с переставленными битами');
PrintBinary(num);

readln;
end.

{ ===============================
{2)Дано целое неотрицательное число <2^16.
Получить число перестановкой битов каждого
байта данного числа в обратном порядке.
Вариант 2 }

program p177891;
var
num1, num2: integer;
ch: byte;
hi, lo: byte;

procedure PrintBinary(x: word);
{ печать беззнакового двухбайтового целого в битовой форме }
var
i: integer;
len: integer;
begin
len := sizeof(word)*8; { бит в числе }

for i:=len-1 downto 0 do
if (x and (1 shl i)=0) then
write('0')
else
write('1');
writeln;
end; { PrintBinary }

function Reverse(x: byte): byte;
var
i: integer;
res: byte;
{ Перестановка битов байта }
begin
res := x and 1;
for i:=1 to 7 do
res := (res shl 1) or ((x shr i) and 1);
Reverse := res;
end; { Reverse }

begin
write('num1=');
readln(num1);

writeln('Введенное число');
PrintBinary(num1);

hi := $FF and (num1 shr 8); { левый байт }
lo := $FF and num1; { правый байт }

writeln('Число с переставленными битами');
num2 := (Reverse(hi) shl 8) or Reverse(lo);
PrintBinary(num2);

Readln;
end.

Здравствуйте, Юдин Евгений Сергеевич.
Вот (в приложении и в прикрепленном файле - архиве) решение третьей задачи
Разные варианты задания числа колонок и столбцов ничем не различаются, поскольку используется попрограмма
Пишите, ежели что

Приложение:
{$R-} {Отключаем выход за пределы диапазона}
TYPE
TMatrix = array[1..1, 1..1] of Integer;
PMatrix = ^TMatrix;

TRow = array[1..1] of Integer; {Нужно будет для упорядочения}
PRow = ^TRow;

function HeapFunc(Size: Word): Integer; far;
{Нужная для работы с динамической памятью = кучей}
begin
HeapFunc := 1;
end;

{Есть проблема в работе с таким массивом. Паскаль неправильно
вычисляет адрес элементов. Так, например, элемент с индексами
[2, 5] это тоже, что и элемент с индексами [5, 2]
Надо работать впрямую обращаясь к памяти, адрес которой надо вычислять
Для этого и используются две подпрограммы
С одномерными массивами такой проблемы нет}

VAR
m_seg, m_ofs: Word; {сегмент и смещение области, на которую указывает
матрица}
CONST
s_int = sizeof(Integer); {2 байта, но ...}
max_rand = 100;

function GetElement(r, c, aCols: Integer): Integer;
begin
GetElement := memw[m_seg: m_ofs + ((r-1)*aCols + (c-1))*s_Int]
{считать слово. Альтернатива - использовать MOVE}
end;

procedure PutElement(r, c, aCols, value: Integer);
{ r ряд, куда записать, c - колонка, aCols - всего колонок;
value - величина}
begin
memw[m_seg : m_ofs + ((r-1)*aCols + (c-1))*s_Int] := Value
end;

function DefineMatrix(aRows, aCols: Integer): PMatrix;
{Создание матрицы. Если не удается, то возвращает nil}
var ma: PMatrix;
i, j: Integer;
begin
DefineMatrix := nil;
ma := nil;
GetMem(ma, aRows*aCols*s_Int);
if ma = nil then Exit;
{заполнение}
m_seg := Seg(ma^);
m_ofs := Ofs(ma^);
for i:=1 to aRows do
for j:=1 to aCols do
PutElement(i, j, aCols, random(max_rand) {i*j + 20*(i-1)});
DefineMatrix := ma;
end;

procedure ShowMatrix(aMatrix: PMatrix; aRows, aCols: Integer);
var i, j: Integer;
begin
if aMatrix = nil then Exit;
for i:=1 to aRows do
begin
for j:=1 to aCols do
Write(GetElement(i, j, aCols):4);
WriteLn;
end;
end;



procedure SortMatrix(aMatrix: PMatrix; aRows, aCols: Integer);
var MinElements: PRow;
i, j, min: Integer;

{Локальная процедура для обмена столбцов}
procedure Swap(col1, col2: Integer); {Все остальное она знает}
var temp, k: Integer;
begin
for k:= 1 to aRows do begin
temp := GetElement(k, col1, aCols);
PutElement(k, col1, aCols, GetElement(k, col2, aCols));
PutElement(k, col2, aCols, temp);
end;
{Теперь не забыть поменять местами в массиве минимальных
элементов. А я, было, забыл}
temp := MinElements^[col1];
MinElements^[col1] := MinElements^[col2];
MinElements^[col2] := temp
end;

begin
if aMatrix = nil then Exit;
GetMem(MinElements, aCols*sizeof(Integer));
{Сначала найдем минимальные в каждом столбце}
for j :=1 to aCols do
begin
{Отслеживаем номер (ряд) минимального элемента в колонке}
MinElements^[j] := 1;
for i:=1 to aRows do
if GetElement(i, j, aCols) < GetElement(MinElements^[j], j, aCols)
then MinElements^[j] := i;
end;

{Для сортировки применим метод вставки: колонку с самым
большим значением минимального элемента ("отсюда" и до конца)
и ставим "сюда"
Здесь, как правило, потребуется меньше перестановок, чем в пузырьковом}
for i:=aCols-1 downto 2 do
begin
min := i;
{Номер ряда, где минимальный элемент самый маленький}
for j := i-1 downto 1 do
if GetElement(MinElements^[j], j, aCols) <=
GetElement(MinElements^[min], min, aCols)
then min := j;
if i <> min then Swap(i, min);
end;

FreeMem(MinElements, aCols*sizeof(Integer));
end;

function DisposeMatrix(var aMatrix: PMatrix; aRows, aCols: Integer): Boolean;
begin
DisposeMatrix := FALSE;
if aMatrix = nil then Exit;
FreeMem(aMatrix, aRows*aCols*s_Int);
m_seg := 0; m_ofs := 0;
DisposeMatrix := True
end;

procedure DoMatrix(aRows, aCols: Integer);
{Подпрограмма, которая все вызывает}
var
M: PMatrix;
begin
m_seg := 0; m_ofs := 0;
M := DefineMatrix(aRows, aCols);
if M = nil then
begin
WriteLn('Не удается создать матрицу размером ',aRows,' x ',aCols);
WriteLn('Скорее всего, заданы слишком большие количества строк и столбцов');
end
else
begin
WriteLn('Матрица до сортировки');
ShowMatrix(M, aRows, aCols);
SortMatrix(M, aRows, aCols);
WriteLn('Матрица после сортировки');
ShowMatrix(M, aRows, aCols);
DisposeMatrix(M, aRows, aCols);
end
end;

CONST
rows = 5;
cols = 10;
VAR
n_rows: Integer;
n_cols: Integer;

BEGIN
HeapError := @HeapFunc; {Назначаем свой обработчик ошибок}

DoMatrix(rows, cols);
(*
{С переменными нет никаких проблем - смотри ниже}
Write('Введите число строк: '); ReadLn(n_rows);
Write('Введите число колонок: '); ReadLn(n_cols);
DoMatrix(n_rows, n_cols); *)
END.