Напишите программы для сложения и вычитания длинных чисел данные вводятся из текстового файла
Обновлено: 02.07.2024
Известно, что арифметические действия, выполняемые компьютером в ограниченном числе разрядов, не всегда позволяют получить точный результат. Более того, мы ограничены размером (величиной) чисел, с которыми можем работать.
Диапазон представления целых чисел (Integer, Word, LongInt) ограничен. Поэтому при решении задач всегда приходится действовать с оглядкой, — как бы не допустить возникновения ошибки выхода за диапазон или переполнения. Например, вычисляя факториал (n! = 1 * 2 * 3 * … * n), в диапазоне представления величин типа Integer удастся правильно получить только 7! = 5040, а в диапазоне представления типа LongInt — 12! = 479001600. Для больших значений, конечно, можно использовать действительные типы данных, но это уже не гарантирует точного результата.
А если нам необходимо выполнить арифметические действия над очень большими числами, например,
30! = 265252859812191058636308480000 000?
Поэтому полезно для получения точных значений при действиях с многозначными числами разработать другие способы представления таких чисел, алгоритмы выполнения арифметических и других операций, процедуры ввода и вывода результатов и т.д.
В таких случаях мы сами должны позаботиться о представлении чисел в машине и о точном выполнении арифметических операций над ними.
Числа, для представления которых в стандартных компьютерных типах данных не хватает количества двоичных разрядов, называются "длинными". Реализация арифметических операций над такими "длинными" числами получила название "длинной арифметики".
Организация работы с "длинными" числами во многом зависит от того, как мы представим в компьютере эти числа. "Длинное" число можно записать, например, с помощью массива десятичных цифр, количество элементов в таком массиве равно количеству значащих цифр в "длинном" числе. Но если мы будем реализовывать арифметические операции над этим числом, то размер массива должен быть достаточным, чтобы разместить в нем и результат, например, умножения.
Покажем реализацию решения такого рода задач на примере умножения одного многозначного числа на другое. Именно эта арифметическая операция наиболее часто используется при решении других задач.
Наиболее естественным способом представления многозначного числа является запись каждого его разряда в виде отдельного элемента линейного массива. Пусть (для удобства дальнейших действий) разряды "длинного" числа при записи в массив нумеруются с единицы, начиная с разряда единиц, т.е. цифра из разряда единиц — элемент массива с номером один, цифра из разряда десятков — элемент массива с номером два и т.д. Определим для работы с "длинными" неотрицательными числами тип данных:
Const MNax = 2000;
Dl_Ch = Array[1..Nmax] Of Digit;
Для решения поставленной задачи необходимо уметь выполнять следующие действия:
1) ввод "длинного" числа;
2) собственно умножение двух "длинных" чисел;
3) вывод "длинного" числа;
4) определение количества цифр в записи числа.
Каждую из подзадач реализуем в виде отдельной подпрограммы. Начнем с ввода. Ввести большое число целесообразно в виде строки, а в дальнейшем преобразовать в массив цифр (можно читать число из файла). В процедуре учтен указанный выше способ размещения "длинного" числа в массиве, т.е. с точки зрения пользователя число записывается как бы в обратном порядке.
Procedure Translate(S : String; Var A : Dl_Ch; Var F : Boolean);
Zero(A); I := Length(S); F := True;
While (I >= 1) And F Do
Then A[Length(S)- I + 1]:= Ord(S[I]) - 48
Прокомментируем эту процедуру на примере: S:='5678'
После выполнения процедуры Translate цифры в массиве А расположатся следующим образом:
В процедуре вызывается подпрограмма Zero(A) , назначение которой — запись нуля в каждый разряд длинного числа. Вот текст этой процедуры:
Procedure Zero(Var A : Dl_Ch);
For I := 1 To NMax Do A[I] := 0;
Таким образом, длинное число записано в массив, где впереди (в качестве элементов с большими номерами) стоят незначащие нули. При выполнении действий и выводе ответа они не учитываются.
Сейчас разработаем функцию определения количества значащих цифр в записи числа, поскольку она потребуется при реализации подпрограммы умножения.
Function Dlina(C : Dl_Ch) : Integer;
While (I > 1) And (C[I] = 0) Do I := I - 1;
При ее разработке было использовано следующее соображение: если число не равно нулю, то количество цифр в его записи равно номеру первой цифры, отличной от нуля, если просмотр числа осуществляется от старшего разряда к младшему. Если же длинное число равно нулю, то получается, что количество цифр в его записи равно одной, что и требовалось.
Ну и, наконец, главная процедура. При составлении алгоритма используется идея умножения "столбиком", хотя в нашем варианте сложение выполняется не по окончанию умножения, а по ходу его, т.е. перемножив очередные цифры, сразу же добавляем результирующую цифру в нужный разряд и формируем перенос в следующий разряд.
A, B — множители, C — произведение>
Procedure umn(A, B : Dl_Ch; Var C : Dl_Ch);
Var I, J : Integer; P : Digit; Rez : 0..99;
For I := 1 To Dlina(A) Do
For J := 1 To Dlina(B) Do
Rez := A[I] * B[J] + P + C[I + J - 1];
C[I + J - 1] := Rez Mod 10;
запишем его в пока ещё свободный разряд>
Сейчас приведем листинг программы целиком.
Const NMax = 2000;
Type Digit = 0..9; Dl_Ch = Array[1..Nmax] Of Digit;
Procedure Zero(Var A : Dl_Ch);
For I := 1 To NMax Do A[I] := 0;
Function Dlina(C : Dl_Ch) : Integer;
While (I > 1) And (C[I] = 0) Do I := I - 1;
Procedure Print(A : Dl_Ch);
For I := Dlina(A) DownTo 1 Do Write(A[I] : 1);
Procedure Translate(S : String; Var A : Dl_Ch;
Zero(A); I := Length(S); F := True;
While (I >= 1) And F Do
Then A[Length(S) - I+ 1] := Ord(S[I]) - 48
Procedure Umn(A, B : Dl_Ch; Var C : Dl_Ch);
Var I, J : Integer; P : Digit; Rez : 0..99;
For I := 1 To Dlina(A) Do
For J := 1 To Dlina(B) Do
Rez := A[I] * B[J] + P + C[I + J - 1];
C[I + J - 1] := Rez Mod 10;
Write('Введите первый множитель: ');
ReadLn(S); Translate(S, M, Logic)
Write('Введите второй множитель: ');
ReadLn(S); Translate(S, N, Logic)
Umn(M, N, R); Print(R)
В приведенном листинге Print — процедура вывода длинного числа.
Для того чтобы прочитать исходное число из файла и результат писать в файл, достаточно изменить следующие процедуры и аккуратно прочитать числа:
Procedure Print(A : Dl_Ch);
For I := Dlina(A) DownTo 1 Do Write(f2,A[I] : 1);
Procedure Translate(Var A : Dl_Ch;
Var I,j,z : Word;s:char;
While not eoln(f1) And F Do
Then A[I] := Ord(S) - 48
for j:=1 to (i-1) div 2 do
Процедура сложения двух "длинных» чисел может выглядить следующим образом:
Procedure Summa(A, B : Dl_Ch; Var C : Dl_Ch);
Var I, J,m : Integer; P : Digit; Rez : 0..99;
if Dlina (A)>Dlina(B) Then m:=Dlina(A)
For I := 1 To m Do
Rez := A[I] + B[I] + C[I];
В рассмотренных примерах для каждой цифры числа выделялось определенное место в таблице. Можно в каждой ячейке таблицы хранить по несколько цифр, например, по 3. Тогда основные процедуры обработки можно посмотреть в статье Окулова.
Известно, что арифметические действия, выполняемые компьютером в ограниченном числе разрядов, не всегда позволяют получить точный результат. Более того, мы ограничены размером (величиной) чисел, с которыми можем работать. А если нам необходимо выполнить арифметические действия над очень большими числами, например,
В таких случаях мы сами должны позаботиться о представлении чисел в машине и о точном выполнении арифметических операций над ними.
Числа, для представления которых в стандартных компьютерных типах данных не хватает количества двоичных разрядов, называются "длинными". Реализация арифметических операций над такими "длинными" числами получила название "длинной" арифметики.
Организация работы с "длинными" числами во многом зависит от того, как мы представим в компьютере эти числа. "Длинное" число можно записать, например, с помощью массива десятичных цифр, количество элементов в таком массиве равно количеству значащих цифр в "длинном" числе. Но если мы будем реализовывать арифметические операции над этим числом, то размер массива должен быть достаточным, чтобы разместить в нем и результат, например, умножения.
Существуют и другие представления "длинных" чисел. Рассмотрим одно из них.
Представим наше число
30! =2- (10 4 ) 8 +6525• (10 4 ) 7 +2859• (10 4 ) +
+ 8121- (10 4 ) 5 + 9105(10 4 ) 4 +
+ 8636- (10 4 ) 3 + 3084 • (10 4 ) 2 +
+ 8000- (10 4 ) 1 + 0000- (10 4 ) 0 .
Это представление наталкивает на мысль о массиве, представленном в табл. 1.
| Номер элемента в массиве А | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
| Значение | 9 | 0 | 8000 | 3084 | 8636 | 9105 | 8121 | 2859 | 6525 | 2 |
Мы можем считать, что наше "длинное" число представлено в 10000—10 системе счисления (десятитысячно-десятичная система счисления, приведите аналогию с восьмерично-десятичной системой счисления), а "цифрами" числа являются четырехзначные числа.
Возникают вопросы. Что за 9 в А [ 0 ] , почему число хранится "задом наперед" ? Ответы очевидны, но подождем с преждевременными объяснениями. Ответы на вопросы будут ясны из текста.
Примечание. Мы работаем с положительными числами!
Первая задача. Ввести "длинное" число из файла. Решение задачи начнем с описания данных.
Алгоритм ввода "длинного" числа из файла рассмотрим на конкретном примере.
Пусть в файле записано число 23851674 и основанием (Osn) является 1000 (храним по три цифры в элементе массива А). Изменение значений элементов массива А в процессе ввода (посимвольного в переменную ch) отражено в табл. 2
Проанализируем таблицу (и получим ответы на поставленные выше вопросы).
1. В А [ 0 ] храним количество задействованных (ненулевых) элементов массива А — это уже очевидно. 2. При обработке каждой очередной цифры входного числа старшая цифра элемента массива с номером i становится младшей цифрой числа в элементе i + 1, а вводимая цифра будет младшей цифрой числа из А [ 1 ] . В результате работы нашего алгоритма мы получили число, записанное "задом наперед".
Примечание (методическое): Можно ограничиться этим объяснением и разработку процедуры вынести на самостоятельное задание. Можно продолжить о бъяснение. Например, выписать фрагмент текста процедуры перенос старшей цифры из A[i]B младшую цифру А [ i + 1 ], т.е. сдвиг уже введенной части числа на одну позицию вправо:
For i:=A[0] DownTo 1 Do Begin
A[i+l]:=A[i+l]+(Longint(A[i])*10) Div Osn;
A[i]:=(LongInt(A[i])*10) Mod Osn;
End;
Пусть мы вводим число 238516 74 и первые 6 цифр уже разместили "задом наперед" в массиве А. В символьную переменную ch считали очередную цифру "длинного" числа — это "7". По нашему алгоритму эта цифра "7" должна быть размещена младшей цифрой в А [ 1 ] . Выписанный фрагмент программы "освобождает" место для этой цифры. В таблице отражены результаты работы этого фрагмента.
После этого остается только добавить текущую (считанную в ch ) цифру "длинного" числа к А [ 1 ] и изменить значение А [ 0 ].
В конечном итоге процедура должна иметь следующий вид:
Procedure ReadLong(Var A:Tlong);
Var ch : char ; i : Integer;
Begin
FillChar(A,SizeOf(A) , 0) ;
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+l]>
A[i+l]:=A[i+l]+(LongInt(A[i] )*10) Div Osn;
A[i]:=(LongInt(A[i] ) *10) Mod Osn;
End;
A[1]:=A[l]+Ord(ch)-Ord( '0' ) ;
If A[A[0]+1]>0 Then Inc(A[0]);
элементов массива А>
Read(ch) ;
End;
End;
Вторая задача. Вывод "длинного" числа в файл или на экран.
Казалось бы, нет проблем — выводи число за числом. Однако в силу выбранного нами представления "длинного" числа мы должны всегда помнить, что в каждом элементе массива хранится не последовательность цифр "длинного" числа, а значение числа, записанного этими цифрами. Пусть в элементах массива хранятся четырехзначные числа. Тогда "длинное" число 128400583274 будет в массиве А представлено следующим образом:
При выводе "длинного" числа из массива нам необходимо вывести 0058, иначе будет потеря цифр. Итак, незначащие нули также необходимо выводить. Процедура вывода имеет вид:
Procedure WriteLong(Const A:Tlong);
Var ls,s:String;
i : Integer;
Begin
Str (Osn Div 10, Is) ;
Write(A[A [0]];
For i:=A[0]-l DownTo 1 Do Begin
Str(A[i],s) ;
While Length(s)<Length(Is) Do s:='0'+s;
Write (s) ;
End;
Writein;
End;
Третья задача. Предварительная работа по описанию способа хранения, вводу и выводу "длинных" чисел выполнена.
У нас есть все необходимые "кирпичики", например, для написания программы сложения двух "длинных" положительных чисел. Исходные числа и результат храним в файлах. Назовем процедуру сложения SumLongTwo.
Тогда программа ввода двух "длинных" чисел и вывода результата их сложения будет иметь следующий вид:
Var A,B,C:Tlong;
Begin
Assign(Input, ' Input . txt '); Reset(Input) ;
ReadLong(A) ; ReadLong(B) ;
Close (Input) ;
SumLongTwo(A,B,C) ;]
Assign(Output, ' Output . txt ') ;
Rewrite(Output) ;
WriteLong(C) ;
Close(Output) ;
End.
Алгоритм процедуры сложения можно объяснить на простом примере. Пусть А = 870613029451, В = 3475912100517461.
Алгоритм имитирует привычное сложение столбиком, начиная с младших разрядов. И именно для простоты реализации арифметических операций над "длин ными числами используется машинное представление "задом наперед".
Результат: С = 3476782713546912.
Ниже приведен текст процедуры сложения двух "длинных" чисел.
Procedure SumLongTwo(A,B:Nlong; Var C:Tlong);
Var i,k:Integer;
Begin
FillChar(C,SizeOf (C) ,0) ;
If A[0]>B[0] Then k:=A[0] Else k:=B[0];
For i:=l To k Do
Begin С [i+1] := (C[i]+A[i]+B[i] ) Div Osn;
C[i]:=(C[i]+A[i]+B[i] ) Mod Osn;
End;
If C[k+l]=0 Then C[0]:=k Else C[0]:=k+l;
End;
Четвертая задача. Реализация операций сравнения для "длинных" чисел (А=В, А<В, А>В, А<В, А>В).
Function Eq(A,B:TLong):Boolean;
Var i:Integer;
Begin
Eq:=False;
If A[0]OB[0] Then Exit
Else Begin
i:=l;
While (i<=A[0]) And (A[i]=B[i]-) Do Inc(i);
Eq:==(i=A[0]+l) ;
End;
End;
Реализация функции А>В также прозрачна.
Остальные функции реализуются через функции Eq и More.
Function Less(A,B:Tlong) :Boolean;
Begin
Less:=Not(More(A,B) Or Eq(A,B));
End;
Function More_Eq(A,B:Tlong) :Boolean;
Begin
More_Eq:=More(A,B) Or Eq(A,B);
End;
И, наконец, последняя функция А<В.
Function Less_Eq (A, B:Tlong) : Boolean;
Begin
Less_Eq:-Not(More(A,B) ) ;
End;
Для самостоятельного решения может быть предложена следующая, более сложная, задача. Требуется разработать функцию, которая выдает 0, если А больше В, 1, если А меньше В, и 2 при равенстве чисел. Но сравнение должно быть выполнено с учетом сдвига. О чем идет речь? Поясним на примере. Пусть А равно 56784, а В — 634. При сдвиге числа В на 2 позиции влево функция должна сказать, что В больше А, без сдвига, что А больше В. Другой пример. При А равном 56700, а В — 567 и сдвиге 2 функция должна "сказать" , что числа равны. Решение может иметь следующий вид:
Пятая задача. Умножение длинного числа на короткое. Под коротким понимается целое число типа Longlnt.
Процедура очень походит на процедуру сложения двух длинных чисел.
Procedure Mul(Const A: TLong;Const К:
Longlnt;Var С: TLong) ;
Var i: Integer;
Begin
FillChar (С, SizeOf (С), 0) ;
If K=0 Then Inc (С[0])
Else Begin
For i:==l To A[0] Do Begin
C[i+l]:=(LongInt(A[i] ) *K+C[i] ) Div Osn;
C[i]:=(LongInt(A[i] ) *K +C[i]) Mod Osn;
End;
If C[A[0]+1]>0 Then C[0]:=A[0]+1
Else C[0]:=A[0] ;
End;
End;
Шестая задача. Вычитание двух длинных чисел с учетом сдвига.
Если понятие сдвига пока не понятно, то оставьте его в покое, на самом деле вычитание с учетом сдвига потребуется при реализации операции деления. В начале выясните логику работы процедуры при нулевом сдвиге.
Введем ограничение: число, из которого вычитают, больше числа, которое вычитается. Работать с "длинными" отрицательными числами мы не умеем.
Процедура была бы похожа на процедуры сложения и умножения, если бы не одно "но" — заимствование единицы из старшего разряда вместо переноса единицы в старший разряд. Например, в обычной системе счисления мы вычитаем 9 из 11 — идет заимствование 1 из разряда десятков, а если из 10000 вычитаем 9 — процесс заимствования несколько сложнее.
Procedure Sub (Var A: TLong;
Const B: TLong;
Const sp: Integer);
Var i,j: Integer;
while (A[j+sp]<0) and (j<=A[0>) Do
Begin
Inc(A[j+sp] , Osn) ;
Dec(A[j+sp+l] ) ;Inc(j) ;
end;
Если операторы, отмеченные *, заменить
на нижеприведенные операторы в фигурных скобках, то,
по понятным причинам, логика не будет работать
при всех исходных данных. Можно сознательно сделать
ошибку и предложить найти ее — принцип "обучение через ошибку">
Dec (A[i+sp+l] ) ;End; >
End;
i : =A [ 0 ] ;
While (i>l) And (A[i]=0) Do Dec(i);
A[0]:=i;
End;
Рекомендуется выполнить трассировку работы данной процедуры, например, для следующих исходных данных. Число А равно 100000001000000000000, число В - 2000073859998.
Седьмая задача. Деление двух длинных чисел, т.е. нахождение целой части частного и остатка.
Написать исходную (без уточнений) часть логики не составляет труда. Это:
Procedure Long_Div_Long(Const А, В: TLong;
Var Res, Ost: TLong);
Begin
FillChar(Res, SizeOf(Res), 0) ;Res [0] :=1;
FillChar(Ost, SizeOf(Ost), 0) ;0st [0] :=1 ;
Case More(A, B, 0) Of
0: Begin MakeDel(A, B, Res, Ost);
End;
А дальше? Дальше начинаются проблемы. Делить столбиком нас научили в школе. Например:
1000143123567 | 73859998
- 73859998 | 13541 (Целая часть частного)
261543143
- 221579994
399631495
- 369299990
303315056
- 295439992
78750647
- 73859998
4890649 (Остаток)
Что мы делали? На каждом этапе в уме подбирали цифру (1, 3, 5 и т.д.), такую, что произведение этой цифры на делитель дает число меньшее, но наиболее близкое к числу. Какому? Это трудно сказать словами, но из примера ясно. Зачем нам это делать в уме, пусть делает компьютер. Однако упростим пример, оставим его для тестирования окончательной логики процедуры, тем более что и числа "длинные". Пусть число А будет меньше В • 10, тогда в результате (целой части деления) будет одна цифра. Например, А равно 564, а В — 63 и простая десятичная система счисления. Попробуем подобрать цифру результата, но не методом прямого перебора, а методом деления отрезка пополам. Пусть Down — верхняя граница интервала изменения подбираемой цифры, Up — нижняя граница интервала, Ost равен делимому.
Первое, что нужно решить — это то, как хранить наше число. Я храню его в виде массива цифр, в обратном порядке (это позволяет проще реализовывать все операции), сразу по 9 цифр в одном элементе массива (что позволяет сэкономить память):
В моей реализации будет сразу два представления нуля — в виде пустого вектора и в виде вектора с одним-единственным нулём.
Создание числа
Первое, что нужно научиться делать — это создавать число. Вот так оно преобразуется из строки, содержащей цифры:
Код процедуры удаления ведущих нулей прост до безобразия:
Также нам нужно уметь преобразовывать обычные числа в длинные:
Код преобразования из остальных типов еще проще, я не стал приводить его здесь.
Вывод числа
Теперь нам нужно научиться печатать наше число в поток и преобразовывать его в строку:
Сравнение чисел
Теперь нам нужно научиться сравнивать два числа друг с другом. Теория говорит, что для этого достаточно всего двух операций, остальные могут быть выведены на их основе. Итак, сначала научимся сравнивать два числа на равенство:
Теперь проверим, меньше ли одно число другого:
Здесь мы используем унарное отрицание, чтобы сменить знак числа. Также я для симметрии ввел унарный плюс:
Знания о том, почему нужно возвращать const big_integer, а не просто big_integer, а также о правилах выбора между дружественной функцией-оператором и оператором-членом класса, я подчерпнул из этой статьи.
Дальше все совсем просто:
Арифметические операции
Сложение
Я не стал мудрить с операциями и реализовал обычное школьное сложение в столбик. Поскольку нам в любом случае нужно будет создать новое число как результат операции, я сразу копирую в стек левый операнд по значению и прибавляю числа непосредственно к нему:
Здесь я избежал «дорогой» операции деления в случае, когда получившаяся «цифра» больше основания, по которому я работаю, путем простого сравнения.
Вычитание
В принципе, вычитание аналогично сложению. Нужно лишь рассмотреть случай, когда уменьшаемое меньше вычитаемого:
Инкремент и декремент
Перед реализацией этих двух операций нам нужно реализовать сложение и вычитание с присвоением:
Тогда префиксные версии операций реализуются в одну строчку, а постфиксные — лишь немногим сложнее:
Умножение
Я не стал писать быстрое умножение Карацубы, а снова использовал «школьную» арифметику:
Деление
Поскольку я не нашел в Интернете быстрых способов деления, воспользуемся школьным делением уголком. Начнем делить со старших разрядов. Нам нужно уменьшить текущее значение делимого на максимально возможное число делимым. Это максимальное значение будем искать двоичным поиском. Но сначала нам нужно определить функцию «сдвига» числа вправо, которая позволит нам перебирать разряды последовательно:
Теперь опишем само деление:
Здесь big_integer::divide_by_zero это пустой класс, унаследованный от std::exception .
Взятие остатка
Вообще-то в предыдущей операции остаток фактически хранится в переменной current . Но я задался вопросом определения знака остатка. Википедия говорит, что остаток от деления всегда положителен. Поэтому я написал такую версию этой операции:
Возведение в степень
Я использовал алгоритм быстрого возведения в степень. Он требует проверки числа на нечетность. Поскольку вычислять остаток от деления на 2, мягко говоря, было бы затратно, введем такие операции:
Напишите программы для сложения и вычитания длинных чисел.
Файл приложен с кодом.
Сложение, вычитание и умножение двоичных чисел?
Сложение, вычитание и умножение двоичных чисел.
Проверьте, пожалуйста, правильно ли решены эти примеры?
Провести сложение, вычитание, умножение и деление двоичных чисел 1010 (в двоичной) и 10 (в двоичной)?
Провести сложение, вычитание, умножение и деление двоичных чисел 1010 (в двоичной) и 10 (в двоичной).
Составьте программу сложения ннатцральных чисел от 1 до 100?
Составьте программу сложения ннатцральных чисел от 1 до 100.
Даны два числа 29 и 17?
Даны два числа 29 и 17.
Перевести их в двоичную систему счисления, в которой выполнить сложение, вычитание и умножение этих чисел.
Задача составить программу которая печатает таблицу умножения и сложения чисел в шестнадцатиричной системе счисления?
Задача составить программу которая печатает таблицу умножения и сложения чисел в шестнадцатиричной системе счисления.
Надо составить программу , которая может выполнять над двумя числами сложение, вычитание, умножение, деление?
Надо составить программу , которая может выполнять над двумя числами сложение, вычитание, умножение, деление.
Написать программу, которая позволяет выполнить над двумя введенными числами сложение, умножение, вычитание и деление?
Написать программу, которая позволяет выполнить над двумя введенными числами сложение, умножение, вычитание и деление.
Напишите программу для ввода 3 чисел и вычитания в последствии?
Напишите программу для ввода 3 чисел и вычитания в последствии.
Напишите программу которая в последовательности целых чисел определяет максимальное из чисел?
Напишите программу которая в последовательности целых чисел определяет максимальное из чисел.
Напишите программу которая имитирует работу калькулятора для следующих арифметических операций : " + " сложение и " - " вычитание?
Напишите программу которая имитирует работу калькулятора для следующих арифметических операций : " + " сложение и " - " вычитание.
Схема метро (метрополитен), топографическая карта (участок местности) ; план эвакуации (здание). P. S. В скобках указаны объекты, информационными моделями которых являются данные схемы.
Средняя линия равна сумме оснований, деленной на 2 Т. Е. .
4. 5. В столбец A ввести 2 начальных значения (в моем примере - 15 и 13 ; в задании - 103 и 101), остальные значения получить протяжной на нужное количество ячеек. В ячейку B1 ввести формулу = 1 / A1, в ячейку B2 - формулу = 1 / (A2 + B1). Остальн..
11114444Бит = 0. 00129389Гигабайт.
> dir D : / d / D Вывод списка в нескольких столбцах с сортировкой по столбцам. Колво столбцов определяется автоматически от кол - ва папок и файлов. Нужно где - то 25 штук для 3 столбцов, и чтоб хватило ширины окна.
1101(2) = 1 * 2 ^ 3 + 1 * 2 ^ 2 + 1 * 2 ^ 0 = 8 + 4 + 1 = 13(10) 462(8) = 4 * 8 ^ 2 + 6 * 8 ^ 1 + 2 * 8 ^ 0 = 4 * 64 + 6 * 8 + 2 = 256 + 48 + 2 = 306(10) F05(16) = 15 * 16 ^ 2 + 5 * 16 ^ 0 = 15 * 256 + 5 = 3845(10).
Право повар лор вор пар.
Право вор ров лор пар лавр.
2. Здесь надо дерево составлять (если нужно решение) а ответ : СТАРТ - Б - А - В - Г - ФИНИШ.
Читайте также: