Ввод-вывод длинных чисел

3 167 385 2 4 7-й шаг: аналогично шагу 4

3 574 851 23

Проанализируем таблицу.

Итак, что хранится в элементе a[0]? В a[0] храним количество задействованных (ненулевых) элементов массива a - это уже очевидно.

Почему число записывается в массив в обратном порядке? При обработке каждой цифры входного числа старшая цифра элемента массива с номером i становится младшей цифрой числа в элементе i+1, а вводимая цифра будет младшей цифрой числа из a[1]. В результате работы нашего алгоритма мы получим число, записанное в обратном порядке.

Пусть мы вводим число 23851674 и первые шесть цифр уже разместили в обратном порядке в массиве a. В символьную переменную ch считали очередную цифру “длинного” числа - это “7”. По нашему алгоритму эта цифра “7” должна быть размещена младшей цифрой в a[1]. Как это сделать?

for i:=a[0] downto 1 do

begin

a[i+1]:=a[i+1]+(LongInt (a[i])*10) div Osn;

a[i]:=(LongInt (A[i])*10) mod Osn;

end;

Данный фрагмент программы “освобождает” место для этой цифры, т.е. происходит перенос старшей цифры из a[1] в младшую цифру a[i+1], получаем сдвиг уже введенной части числа на одну позицию вправо. В таблице 3 отражены результаты работы этого фрагмента.

Таблица 3.

i A[1] A[2] A[3] ch

2 516 238 0 7

2 516 380 2

1 160 385 2

После этого остается только добавить текущую (считанную в ch) цифру “длинного” числа к a[1] и изменить a[0].

Но для начала рассмотрим, что собой представляют входные и выходные данные. Входные данные удобнее представлять в файле во избежание ошибки при вводе длинного числа с клавиатуры. Входные данные хранятся в текстовом файле и имеют символьный тип. Результат же по текстовому файлу проще анализировать. Итак, приведем процедуру, реализующую алгоритм записи числа:

procedure ReadLong (var a: Tlong);

var ch: char;

i: integer;

begin

fillchar (a, sizeof (a), 0);

{заполнение массива a нулями, т.к. неиспользованные разряды заполняются нулями и обрабатываются наравне с использованными, чтобы не потерять цифру из числа}

read (ch);

while not (ch in [’0’..’9’]) do read (ch);

{пропуск не цифр во входном файле, во входном файле хранятся не цифры, а символы}

while ch in [’0’..’9’] do

begin

for i:=a[0] downto 1 do

begin

{"протаскивание" старшей цифры в числе из a[i]

в младшую цифру числа из a[i+1]}

a[i+1]:=a[i+1]+(longint (a[i])*10) div osn;

a[i]:=(longint (a[i])*10) mod osn;

end;

a[1]:= a[1]+Ord(ch)-Ord(’0’);

{добавляем младшую цифру к числу из a[1]}

If a[a[0]+1]>0 then inc (a[0]);

{изменяем длину, число задействованных элементов массива a}

read (ch);

end;

end;

Итак, одну из важных задач мы решили. Теперь мы можем ввести "длинное" число.

Вторая задача. Вывод “длинного” числа в файл или на экран.

Казалось бы, нет проблем - выводи число за числом. Однако в силу выбранного нами представления “длинного” числа мы должны всегда помнить, что в каждом элементе массива хранится не последовательность цифр “длинного” числа, а значение числа, записанного этими цифрами. Так как "длинное" число представлено в системе счисления с основанием 10 000. В таком массиве будет храниться текущая длина числа (количество 10000-ичных цифр).

Алгоритм вывода "длинного" числа рассмотрим на примере.

Пусть в элементах массива хранятся четырехзначные числа. Тогда “длинное” число 128400583274 будет в массиве a представлено следующим образом:

A[0] A[1] A[2] A[3]

3 3274 58 1284

Выясним, что будет выведено на экран? Будут ли отличаться исходное число и выведенное на экран? Что нам нужно вывести?

Этими вопросами мы ставим проблему вывода на экран нулей, которые присутствуют в числе. При выводе “длинного” числа из массива нам необходимо вывести 0058, иначе будет потеря цифр. Как решить эту проблему? Решаем проблему следующим образом:

Для начала мы возьмем две строковых переменных, в одной из которых хранится полная запись числа вместе с нулями (ls), и переменную которую выводим на экран (s). Зачем это нужно? Это нужно для того, чтобы при выводе "длинного" числа не были потеряны цифры, т.е. нули. Напишем процедуру, которая это будет выполнять. Процедура вывода имеет вид:

procedure WriteLong (const a:Tlong);

var ls, s: string;

i:Integer;

begin

str (Osn div 10, ls);

{преобразования максимального количества цифр

числа в строку символов ls }

write (a[a[0]]; {выводим старшие цифры числа}

for i:=a[0]-1 downto 1 do

begin

str (a[i], s);

{каждую цифру числа ставим как в исходном

числе и преобразовываем в строку символов s }

while length (s) < length (ls) do s:= ’0’+s;

{сравниваем длины строк до тех пор, пока они не

будут равными и дополняем незначащими нулями}

write (s);

end;

writeln;

end;

Итак, мы знаем, как вводить и выводить "длинные" числа. Знаем способы представления “длинных” целых чисел. Если же требуется получить точный результат при операциях с конечными дробными числами, то все их значащие цифры должны быть записаны в подобные описанные выше структуры данных.

После объяснения предлагаются следующие контрольные вопросы:

1. Что произойдет если "длинное" число окажется равным нулю?

2. Напишите алгоритм ввода "длинного" числа.

3. Напишите алгоритм вывода "длинного" числа.

4. Напишите процедуры ввода и вывода для "длинного" числа.