uses crt;
const
n=32;
type
TMass=string[n];
var a,b,c:TMass;
function HexToBin(d,e:integer):string;
begin
{корректируем под 16-е число}
{ dec(d,7*ord(d>9));}
if d>9 then dec(d,7);
HexToBin:='';
{рекурсивно формируем 16-е число ввиде строки}
if e>0 then HexToBin:=chr(ord('0') + d mod 2) + HexToBin(d div 2,e-1);
end;
procedure inputHex(var d:TMass;e:char);
begin{inputHex}
{вводим число в обратном порядке}
write('Enter number',e:2,':');
d:='';
repeat
e:=ReadKey;{символ без эхо}
case e of
'0'..'9','A'..'F','a'..'f':
begin
{ e:=chr(ord(e) - 32*ord(e>'Z'));{приводим число к единому регистру}
if e>'Z'then e:=chr(ord(e) - 32);
write(e);{выводим его}
d:=HexToBin(ord(e)-ord('0'),4)+d;{формируем двоичную строку}
end;
end;{case}
until (e=chr(13))or(length(d)=n);{}
writeln;
end;{inputHex}
procedure outputHex(d:TMass);
var
i,j:integer;
e:TMass;
begin{outputHex}
if length(d)>0 then
begin{if}
e:=copy(d,1,4);{получаем четыре бита}
{ delete(d,1,4);{удаляем их их числа}
outputHex(copy(d,5,length(d)-4));{рекурсивно вызываем себя}
i:=0;
j:=length(e);
while j>0 do{преобразовываем строку в число}
begin{while}
i:=i*2 + ord(e[j]) - ord('0');
dec(j);
end;{while}
if i>9 then inc(i,7);{*ord(i>9));{корректируем его с учетом 16-ой системы}
e:=chr(ord('0')+i);{формируем символ и выводим его}
write(e);
end;{if}
end;{outputHex}
procedure doSummaBin(var d,e:Tmass);
var
f:char;
i:integer;
begin{doSummaBin}
f:='0';{флаг переноса для старшего разряда}
for i:=1 to length(d) do
begin{for}
if (e[i]<>d[i])then
{обрабатываем ситуацию когда биты различны}
begin{ed=10,01}
if f='1'
then d[i]:='0' {edf=101,011}
else d[i]:='1';{edf=100,010}
end{10,01}
else
{обрабатываем ситуацию когда биты одинаковы}
begin{ed=00,11}
{edf=001,000,111,110}
d[i]:=f;
f:=e[i];
end;{00,11}
end;{for}
end;{doSummaBin}
procedure rangeBin(var d:Tmass);
begin{rangeBin}
while length(d)<n do
d:=d+'0';{}
end;{rangeBin}
procedure convertBin(var d:TMass;e:TMass);
var
i:integer;
begin{convertBin}
for i:=1 to length(d)do
{инвертируем биты}
case d[i]of{case}
'0':d[i]:='1';
'1':d[i]:='0';
end;{case}
rangeBin(e);{выравниваем строку}
doSummaBin(d,e);{суммируем}
end;{convertBin}
begin{main}
{вводим числа}
inputHex(a,'A');
inputHex(b,'B');
{выравниваем к одному размеру}
rangeBin(a);
rangeBin(b);
{переводим в дополнительный код}
convertBin(b,'1');
{суммируем А + Вд}
doSummaBin(a,b);
{выводим результат}
outputHex(a);
ReadKey;
end.{main}
Булевы типы
Имеются четыре предопределенных булевых типа:Boolean, WordBool, LongBool и ByteBool.
Синтаксис:
Type Boolean = (False, True);
WordBool = (False, True);
LongBool = (False, True);
ByteBool = (False, True);
Замечания:
Эти типы имеют следующие размеры:
- Boolean - Byte (8 бит)
- WordBool - Word (16 бит)
- LongBool - LongInt (32 бита)
- ByteBool - Byte (8 бит)
Поскольку данные типы являются перечислимыми порядковыми типами, то существуют следующие связи:
False < True
Ord(False) = 0
Ord(True) = 1
Succ(False) = True
Pred(True) = False
Тип Boolean является предпочтительным, так как он использует наименьшее количество памяти.
ByteBool, WordBool и LongBool существуют только для совместимости с Windows.
В выражениях, следующие операторы сравнения производят результат типа Boolean:
= <> > < >= <= IN
Для совместимости с Windows, булевы типы могут принимать порядковые значения не только 0 и 1.
Булево выражение является ложью (False), если его порядковое значение равно нулю и истиной (True), если его порядковое значение не равно нулю.
Булевы операторы Not, And, Or и Xor работают проверяя значения на 0 (False) или не 0 (True), но всегда возвращают результат с порядковым значением 0 или 1.
Если Вы уже зарегистрированы на Портале - войдите в систему, если Вы еще не регистрировались - пройдите простую процедуру регистрации.