e-olymp 1290. Номерной знак

20/12/2019 by Таня Осипенко

Задача

Международный номерной регистрационный знак легкового автомобиля состоит из $A$ арабских цифр и $B$ больших букв латинского алфавита. Будем считать, что для обеспечения уникальности номера разрешено использовать любую последовательность букв и цифр.

Сколько существует различных таких номеров?

Входные данные

В единственной строке через пробел $2$ неотрицательных целых числа $B$ и $A$. Оба числа не превышают $26$.

Выходные данные

Единственное число — ответ к задаче.

Тесты

№	Входные данные	Выходные данные
1	3 3	17576000
2	2 5	67600000
3	7 1	80318101760
4	1 1	260
5	26 26	615611958020715731079667428840020377600000000000000000000000000

Код

#include <iostream>
#include <string.h>

using namespace std;

void print(char * x, int n) { // функция вывода массива чисел 
  for (int i = n - 1; i >= 0; i--) {
    cout << (int) x[i];
  }
}
int MULT(char * x, char * y, char * z, int n, int m) { // функция для перемножения больших чисел
  memset(z, 0, n + m); // обнуляем массив
  for (int i = 0; i < m; i++) {
    for (int j = 0; j < n; j++) {
      char w = x[j] * y[i] + z[i + j];
      z[i + j + 1] += w / 10;
      z[i + j] = w % 10;
    }
  }
  int res = (z[n + m - 1] == 0) ? (n + m - 1) : (n + m); //  кол-во разрядов
  return res;
}
const int N = 100; // кол-во элементов массивов с небольшим запасом
char acc[N] = {1};
int acc_size = 1;
char tmp[N] = {0};
char v_26[] = {6, 2}; // 26

int main() {
  int A, B; // входные данные
  cin >> B >> A;
  for (int i = 0; i < B; i++) { // возведение 26 в степень B
    memcpy(tmp, acc, acc_size);
    acc_size = MULT(tmp, v_26, acc, acc_size, 2); // 2 - число разрядов в 26
  }
  print(acc, acc_size); // вывод результата
  for (int i = 0; i < A; i++){ // домножение на 10 в степени A
    cout << "0";
  }
  return 0;
}

#include <iostream>

#include <string.h>

using namespace std;

void print(char * x, int n) { // функция вывода массива чисел

for (int i = n - 1; i >= 0; i--) {

cout << (int) x[i];

}

int MULT(char * x, char * y, char * z, int n, int m) { // функция для перемножения больших чисел

memset(z, 0, n + m); // обнуляем массив

for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {

char w = x[j] * y[i] + z[i + j];

z[i + j + 1] += w / 10;

z[i + j] = w % 10;

}

int res = (z[n + m - 1] == 0) ? (n + m - 1) : (n + m); // кол-во разрядов

return res;

}

const int N = 100; // кол-во элементов массивов с небольшим запасом

char acc[N] = {1};

int acc_size = 1;

char tmp[N] = {0};

char v_26[] = {6, 2}; // 26

int main() {

int A, B; // входные данные

cin >> B >> A;

for (int i = 0; i < B; i++) { // возведение 26 в степень B

memcpy(tmp, acc, acc_size);

acc_size = MULT(tmp, v_26, acc, acc_size, 2); // 2 - число разрядов в 26

}

print(acc, acc_size); // вывод результата

for (int i = 0; i < A; i++){ // домножение на 10 в степени A

cout << "0";

}

return 0;

}

Решение

Начнем с того, что к условию задачи прилагается картинка, на которой видно, что во всех номерных знаках буквы и цифры не перемешаны между собой произвольно, а имеют свои четко распределенные места, в примере это последовательность, в которой на первой позиции стоит буква, далее три цифры и на последних двух позициях снова буквы. Это важный момент, поскольку если бы действительно было разрешено использовать любую последовательность, возможных комбинаций было бы гораздо больше. Поскольку в латинском алфавите $26$ букв, для выбора буквы на первое место существует $26$ возможных вариантов, на второе тоже $26$, как и на третье, четвертое и т. д. То есть для того чтобы найти все комбинации из букв для $B$ мест, нужно умножить $26$ на $26$ $B$ раз. Точно так же это работает с арабскими цифрами. Их всего $10$, соответственно, умножаем $10$ на $10$ $A$ раз, где $A$ — количество мест в номерном знаке для цифр. Поэтому, чтобы найти количество возможных комбинаций букв и цифр, перемножаем полученные результаты. Отсюда получаем формулу $26^B\cdot 10^A$.

Сложность задачи заключается скорее не в формуле вычисления, а в реализации кода, поскольку большинство значений уже на этапе возведения в степень не помещаются даже в самые большие типы данных. Именно поэтому код состоит не из пяти строк и встроенной операции возведения в степень, а из более сложных операций, подходящих для работы с большими числами. По сути, у нас возникает проблема, связанная с перемножением больших чисел, которые не помещаются в стандартные типы данных С++. Для решения этой проблемы я выбрала модель представления, в которой числа записываются в виде массивов в десятичной системе, и каждая цифра числа является элементом массива. Младший разряд числа находится в нулевом элементе массива, а старший в $n-1$-ом соответственно. Далее была реализована функция «MULT», которая фактически осуществляет алгоритм умножения поэлементно с сохранением остатка от деления на $10$ в соответствующем элементе массива и добавлением частного от деления на $10$ к следующему элементу массива. Следует отметить, что данная функция принимает два числа, записанные в выше указанной модели представления (в виде массивов), и характеристиками этих чисел является пара: сам массив и количество разрядов в числе (размер массивов иными словами). На выходе функция возвращает количество разрядов полученного произведения. Сам же результат умножения сохраняется в виде массива, который является одним из параметров функции. В коде данная функция внесена в цикл для многократного перемножения чисел, то есть для возведения в нужную степень. Домножение на $10^A$ осуществляется в последнем цикле приписыванием A нулей к полученному результату.

Ссылки

Задача на сайте e-olymp
Код решения на ideone

Related Images:

e-olymp 1327. Ладьи на шахматной доске

14/12/2019 by Эвелина Алексютенко

Задача

Ещё в детстве маленького Гарика заинтересовал вопрос: а сколькими способами на шахматной доске размером [latex]n \times n[/latex] можно расставить [latex] n [/latex] ладей так, чтобы они не били друг друга. Он очень долго решал эту задачку для каждого варианта, а когда решил — бросил шахматы.

А как быстро Вы управитесь с этой задачкой?

Входные данные

Размер шахматной доски — натуральное число, не превышающее [latex] 1000 [/latex].

Выходные данные

Выведите ответ, найденный Гариком.

Тесты

Входные данные	Выходные данные
2	2
10	3628800
500	122013682599111006870123878542304692625357434280319284219241 358838584537315388199760549644750220328186301361647714820358 416337872207817720048078520515932928547790757193933060377296 085908627042917454788242491272634430567017327076946106280231 045264421887878946575477714986349436778103764427403382736539 747138647787849543848959553753799042324106127132698432774571 554630997720278101456108118837370953101635632443298702956389 662891165897476957208792692887128178007026517450776841071962 439039432253642260523494585012991857150124870696156814162535 905669342381300885624924689156412677565448188650659384795177 536089400574523894033579847636394490531306232374906644504882 466507594673586207463792518420045936969298102226397195259719 094521782333175693458150855233282076282002340262690789834245 171200620771464097945611612762914595123722991334016955236385 094288559201872743379517301458635757082835578015873543276888 868012039988238470215146760544540766353598417443048012893831 389688163948746965881750450692636533817505547812864000000000 000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000
999	402387260077093773543702433923003985719374864210714632543799 910429938512398629020592044208486969404800479988610197196058 631666872994808558901323829669944590997424504087073759918823 627727188732519779505950995276120874975462497043601418278094 646496291056393887437886487337119181045825783647849977012476 632889835955735432513185323958463075557409114262417474349347 553428646576611667797396668820291207379143853719588249808126 867838374559731746136085379534524221586593201928090878297308 431392844403281231558611036976801357304216168747609675871348 312025478589320767169132448426236131412508780208000261683151 027341827977704784635868170164365024153691398281264810213092 761244896359928705114964975419909342221566832572080821333186 116811553615836546984046708975602900950537616475847728421889 679646244945160765353408198901385442487984959953319101723355 556602139450399736280750137837615307127761926849034352625200 015888535147331611702103968175921510907788019393178114194545 257223865541461062892187960223838971476088506276862967146674 697562911234082439208160153780889893964518263243671616762179 168909779911903754031274622289988005195444414282012187361745 992642956581746628302955570299024324153181617210465832036786 906117260158783520751516284225540265170483304226143974286933 061690897968482590125458327168226458066526769958652682272807 075781391858178889652208164348344825993266043367660176999612 831860788386150279465955131156552036093988180612138558600301 435694527224206344631797460594682573103790084024432438465657 245014402821885252470935190620929023136493273497565513958720 559654228749774011413346962715422845862377387538230483865688 976461927383814900140767310446640259899490222221765904339901 886018566526485061799702356193897017860040811889729918311021 171229845901641921068884387121855646124960798722908519296819 372388642614839657382291123125024186649353143970137428531926 649875337218940694281434118520158014123344828015051399694290 153483077644569099073152433278288269864602789864321139083506 217095002597389863554277196742822248757586765752344220207573 630569498825087968928162753848863396909959826280956121450994 871701244516461260379029309120889086942028510640182154399457 156805941872748998094254742173582401063677404595741785160829 230135358081840096996372524230560855903700624271243416909004 153690105933983835777939410970027753472000000000000000000000 000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000

Программный код

#include <iostream>
#include <vector>
#include <iomanip>
using namespace std;
vector<int> multiply (const vector<int> &s, int b, int base) {
  vector<int> c;
  int carry = 0;
  for (int i = 0; i < s.size(); i++) {
    long long res = (long long)s[i] * b + carry;
    carry = res / 1000;
    c.push_back(res % base);    
  }
  if (carry > 0) { // если в разряде переноса все еще остались цифры
    c.push_back(carry);
  }
  return c;
}
int main() {
  int n;
  int base = 1000;
  cin >> n;
  vector<int> res;
  res.push_back(0);
  res.push_back(1);
  for (int i = 1; i < n; i++) {
    res = multiply(res, i + 1, base);
  }
  cout << res[res.size() - 1];
  for (int i = res.size() - 2; i >= 1; i--) {
    cout << setw(3) << setfill('0') << res[i];
  }
}

#include <iostream>

#include <vector>

#include <iomanip>

using namespace std;

vector<int> multiply (const vector<int> &s, int b, int base) {

vector<int> c;

int carry = 0;

for (int i = 0; i < s.size(); i++) {

long long res = (long long)s[i] * b + carry;

carry = res / 1000;

c.push_back(res % base);

}

if (carry > 0) { // если в разряде переноса все еще остались цифры

c.push_back(carry);

}

return c;

}

int main() {

int n;

int base = 1000;

cin >> n;

vector<int> res;

res.push_back(0);

res.push_back(1);

for (int i = 1; i < n; i++) {

res = multiply(res, i + 1, base);

}

cout << res[res.size() - 1];

for (int i = res.size() - 2; i >= 1; i--) {

cout << setw(3) << setfill('0') << res[i];

}

#include <iostream>
#include <string>
using namespace std;

string multiplication (string x, int y) { 
    int carry = 0, temporary = 0;
    string answer = "";
    for (int i = x.size() - 1; i >= 0; i--) {
    temporary = int(x[i] - '0') * y + carry;
    carry = temporary / 10;
    answer = char(temporary % 10 + '0') + answer;
}
while (carry) {
    answer = char(carry % 10 + '0') + answer;
    carry /= 10;
}
return answer;
}
int main() {
    int n;
    string s = "1";
    cin >> n;
    for (int i = 2; i <= n; i++) {
         s = multiplication(s, i);
    } 
    cout << s << endl;
}

#include <iostream>

#include <string>

using namespace std;

string multiplication (string x, int y) {

int carry = 0, temporary = 0;

string answer = "";

for (int i = x.size() - 1; i >= 0; i--) {

temporary = int(x[i] - '0') * y + carry;

carry = temporary / 10;

answer = char(temporary % 10 + '0') + answer;

}

while (carry) {

answer = char(carry % 10 + '0') + answer;

carry /= 10;

}

return answer;

}

int main() {

int n;

string s = "1";

cin >> n;

for (int i = 2; i <= n; i++) {

s = multiplication(s, i);

}

cout << s << endl;

}

Алгоритм решения

Алгоритм решения данной задачи заключается в том, что нужно вычислить [latex]n! = 1\times 2\times 3\times \cdots\times n [/latex] , используя длинную арифметику ( умножение длинного числа на короткое ).
Иллюстрация для восьми ладей:

В коде № 1 разбиваем вектор на ячейки по три цифры. Но, некоторые ячейки могут иметь менее чем три цифры. С учетом того, что перенос может состоять не из трех цифр, следует выводить результат так: cout << setw(3) << setfill('0') << res[i];.
В коде № 2 разбиваем строку посимвольно.

Детали реализации

Безусловно, для использования векторов и строк нам понадобятся соответствующие библиотеки: #include <vector> и #include <string>.
Для вывода данных в коде № 1 стоит подключить библиотеку #include <iomanip>.

Ссылки :
Задача на e-olymp
Код № 1 на ideone
Код № 2 на ideone
Засчитанное решение № 1
Засчитанное решение № 2

Related Images:

М3

26/11/2014 by Ілларіонова Марія Валеріївна

Big Summa. Заданы две текстовые строки, состоящие исключительно из цифр и не более чем одной точки.
Предполагается, что строки задают представление чисел в q-ричной системе счисления. Построить строку, являющуюся их суммой.

q	A	B	A+B	Комментарий.
10	126740	546.967	127286.967	Тест пройден.
8	2360	7521	12101	Тест пройден.
2	1011001	1101	100110	Тест пройден.
3	1210.012	1112.1	10022.112	Тест пройден.
10	4356.98	67.975	4424.955	Тест пройден.

Код программы (string):

#include <iostream>
#include <string>
using namespace std;

unsigned int dot_position (const string &a, const string &b) {
	unsigned int dota=0, dotb=0;
	for (unsigned int i=0; a[i]; i++) {
		if (a[i]=='.') dota=i;
	}
	if (dota==0) dota=a.length();
	for (unsigned int i=0; b[i]; i++) {
		if (b[i]=='.') dotb=i;
	}
	if (dotb==0) dotb=b.length();
	return max (dota, dotb);
}

unsigned int length_before_dot (const string &a) {
	unsigned int i=0;
	for (; a[i]; i++) {
		if (a[i]=='.') break;
	}
	return i;
}

int length_after_dot (const string &a) {
	return a.length()-length_before_dot(a)-1;
}

int main() {
	const int d='0';
	int q;
	cin >> q;
	string a, b, c;
	cin >> a >> b;
	if (length_after_dot(a)<0) a.insert(a.length(),"."); // Если число без точки, то условно ставим её.
	if (length_after_dot(b)<0) b.insert(b.length(),".");
	if (length_after_dot(a)>length_after_dot(b)) {
		for (unsigned int i=a.length()-1; i>length_before_dot(a)+length_after_dot(b); i--) {
			c.insert(c.begin(),a[i]);
		}
	}
	else if (length_after_dot(a)<length_after_dot(b)) {
		for (unsigned int i=b.length()-1; i>length_before_dot(b)+length_after_dot(a); i--) {
			c.insert(c.begin(),b[i]);
		}
	}
	if (length_before_dot(a)<dot_position(a,b)) {
		a.insert(0,dot_position(a,b)-length_before_dot(a),'0');
	}
	else if (length_before_dot(b)<dot_position(a,b)) {
		b.insert(0,dot_position(a,b)-length_before_dot(b),'0');
	}
	int p=0;
	for (int i=min(a.length(),b.length())-1; i>=0; i--) {
		string k;
		if (a[i]=='.') {
			c.insert(0,"."); --i;
		}
		if (a[i]+b[i]-2*d+p-q<0) {
			k=to_string(a[i]+b[i]-2*d+p);
			p=0;
		}
		else {
			k=to_string(a[i]+b[i]-2*d+p-q);
			p=1;
		}
		c.insert(0,k);
	}
	if (p==1) { 
		c.insert(0,"1");
	}
	if (c.back()=='.') c.pop_back();
	cout << c << endl;
	return 0;
}

#include <iostream>

#include <string>

using namespace std;

unsigned int dot_position (const string &a, const string &b) {

unsigned int dota=0, dotb=0;

for (unsigned int i=0; a[i]; i++) {

if (a[i]=='.') dota=i;

}

if (dota==0) dota=a.length();

for (unsigned int i=0; b[i]; i++) {

if (b[i]=='.') dotb=i;

}

if (dotb==0) dotb=b.length();

return max (dota, dotb);

}

unsigned int length_before_dot (const string &a) {

unsigned int i=0;

for (; a[i]; i++) {

if (a[i]=='.') break;

}

return i;

}

int length_after_dot (const string &a) {

return a.length()-length_before_dot(a)-1;

}

int main() {

const int d='0';

int q;

cin >> q;

string a, b, c;

cin >> a >> b;

if (length_after_dot(a)<0) a.insert(a.length(),"."); // Если число без точки, то условно ставим её.

if (length_after_dot(b)<0) b.insert(b.length(),".");

if (length_after_dot(a)>length_after_dot(b)) {

for (unsigned int i=a.length()-1; i>length_before_dot(a)+length_after_dot(b); i--) {

c.insert(c.begin(),a[i]);

}

else if (length_after_dot(a)<length_after_dot(b)) {

for (unsigned int i=b.length()-1; i>length_before_dot(b)+length_after_dot(a); i--) {

c.insert(c.begin(),b[i]);

}

if (length_before_dot(a)<dot_position(a,b)) {

a.insert(0,dot_position(a,b)-length_before_dot(a),'0');

}

else if (length_before_dot(b)<dot_position(a,b)) {

b.insert(0,dot_position(a,b)-length_before_dot(b),'0');

}

int p=0;

for (int i=min(a.length(),b.length())-1; i>=0; i--) {

string k;

if (a[i]=='.') {

c.insert(0,"."); --i;

}

if (a[i]+b[i]-2*d+p-q<0) {

k=to_string(a[i]+b[i]-2*d+p);

p=0;

}

else {

k=to_string(a[i]+b[i]-2*d+p-q);

p=1;

}

c.insert(0,k);

}

if (p==1) {

c.insert(0,"1");

}

if (c.back()=='.') c.pop_back();

cout << c << endl;

return 0;

}

Программа выполнена с помощью методов класса <string>. Для работы мне понадобилось написать несколько вспомогательных функций, задачей которых является дополнить числа нулями таким образом, чтобы точки чисел оказались на одинаковых позициях.

Функция dot_position. Эта функция находит места точек в обеих строках, а если таковых нет, то им присваивается значение длины строки. Возвращает функция наибольшую по значению позицию точки.

Функции length_before_dot и length_after_dot возвращают количество цифр до и после точки соответственно.

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

После этого программа готова вычислить сумму двух чисел. Сложность реализации алгоритма сложения состояла лишь в том, что записать в строку элемент типа int — невозможно, а следовательно, его нужно было преобразовать в строку. Для этого потребовалась функция to_string() из класса <string>. Но при этом элементы a[i] и b[i] воспринимались как коды символов, поэтому каждый из них нужно было уменьшить на ‘0’.

Ещё одна сложность — это десятки, которые мы держим «в уме», а в моём случае — во вспомогательной переменной p.

Код можно посмотреть здесь.

Код программы (cstring):

#include <iostream>
#include <cstring>
#include <stdio.h>
using namespace std;
 
unsigned int dot_position (const char *a, const char *b) {
	unsigned int dota=0, dotb=0;
	for (unsigned int i=0; a[i]; i++) {
		if (a[i]=='.') dota=i;
	}
	if (dota==0) dota=strlen(a);
	for (unsigned int i=0; b[i]; i++) {
		if (b[i]=='.') dotb=i;
	}
	if (dotb==0) dotb=strlen(b);
	return max (dota, dotb);
}
 
unsigned int length_before_dot (const char *a) {
	unsigned int i=0;
	for (; a[i]; i++) {
		if (a[i]=='.') break;
	}
	return i;
}
 
int length_after_dot (const char *a) {
	return strlen(a)-length_before_dot(a)-1;
}
 
void insert (char *a, size_t position, char c) {
	for (unsigned int i=strlen(a); i>position; i--) {
		a[i]=a[i-1];
	}	
	a[position]=c;
}
 
 
int main() {
	const int d='0';
	int q;
	cin >> q;
	char *a;
	a = new char [100];
	char *b;
	b = new char [100];
	char *c;
	c = new char [101];
	cin >> a >> b;
	if (length_after_dot(a)<0) insert(a,strlen(a),'.'); // Если число без точки, то условно ставим её.
	if (length_after_dot(b)<0) insert(b,strlen(b),'.');
	if (length_after_dot(a)>length_after_dot(b)) {
		for (unsigned int i=strlen(a)-1; i>length_before_dot(a)+length_after_dot(b); i--) {
			insert(c,0,a[i]);
		}
	}
	else if (length_after_dot(a)<length_after_dot(b)) {
		for (unsigned int i=strlen(b)-1; i>length_before_dot(b)+length_after_dot(a); i--) {
			insert(c,0,b[i]);
		}
	}
	if (length_before_dot(a)<dot_position(a,b)) {
		for (unsigned int i=dot_position(a,b)-length_before_dot(a); i>0; i--) { 
			insert(a,0,'0');
		}
	}
	else if (length_before_dot(b)<dot_position(a,b)) {
		for (unsigned int i=dot_position(a,b)-length_before_dot(b); i>0; i--) {
			insert(b,0,'0');
		}
	}
	int p=0;
	for (int i=min(strlen(a),strlen(b))-1; i>=0; i--) {
		char *k;
		k = new char [1];
		if (a[i]=='.') {
			insert(c,0,'.'); --i;
		}
		if (a[i]+b[i]-2*d+p-q<0) {
			sprintf(k,"%d",a[i]+b[i]-2*d+p);
			p=0;
		}
		else {
			sprintf(k,"%d",a[i]+b[i]-2*d+p-q);
			p=1;
		}
		insert(c,0,k[0]);
	}
	if (p==1) { 
		insert(c,0,'1');
	}
	if (c[strlen(c)-1]=='.') c[strlen(c)-1]='';
	cout << c << endl;
	return 0;
}

#include <iostream>

#include <cstring>

#include <stdio.h>

using namespace std;

unsigned int dot_position (const char *a, const char *b) {

unsigned int dota=0, dotb=0;

for (unsigned int i=0; a[i]; i++) {

if (a[i]=='.') dota=i;

}

if (dota==0) dota=strlen(a);

for (unsigned int i=0; b[i]; i++) {

if (b[i]=='.') dotb=i;

}

if (dotb==0) dotb=strlen(b);

return max (dota, dotb);

}

unsigned int length_before_dot (const char *a) {

unsigned int i=0;

for (; a[i]; i++) {

if (a[i]=='.') break;

}

return i;

}

int length_after_dot (const char *a) {

return strlen(a)-length_before_dot(a)-1;

}

void insert (char *a, size_t position, char c) {

for (unsigned int i=strlen(a); i>position; i--) {

a[i]=a[i-1];

}

a[position]=c;

}

int main() {

const int d='0';

int q;

cin >> q;

char *a;

a = new char [100];

char *b;

b = new char [100];

char *c;

c = new char [101];

cin >> a >> b;

if (length_after_dot(a)<0) insert(a,strlen(a),'.'); // Если число без точки, то условно ставим её.

if (length_after_dot(b)<0) insert(b,strlen(b),'.');

if (length_after_dot(a)>length_after_dot(b)) {

for (unsigned int i=strlen(a)-1; i>length_before_dot(a)+length_after_dot(b); i--) {

insert(c,0,a[i]);

}

else if (length_after_dot(a)<length_after_dot(b)) {

for (unsigned int i=strlen(b)-1; i>length_before_dot(b)+length_after_dot(a); i--) {

insert(c,0,b[i]);

}

if (length_before_dot(a)<dot_position(a,b)) {

for (unsigned int i=dot_position(a,b)-length_before_dot(a); i>0; i--) {

insert(a,0,'0');

}

else if (length_before_dot(b)<dot_position(a,b)) {

for (unsigned int i=dot_position(a,b)-length_before_dot(b); i>0; i--) {

insert(b,0,'0');

}

int p=0;

for (int i=min(strlen(a),strlen(b))-1; i>=0; i--) {

char *k;

k = new char [1];

if (a[i]=='.') {

insert(c,0,'.'); --i;

}

if (a[i]+b[i]-2*d+p-q<0) {

sprintf(k,"%d",a[i]+b[i]-2*d+p);

p=0;

}

else {

sprintf(k,"%d",a[i]+b[i]-2*d+p-q);

p=1;

}

insert(c,0,k[0]);

}

if (p==1) {

insert(c,0,'1');

}

if (c[strlen(c)-1]=='.') c[strlen(c)-1]='';

cout << c << endl;

return 0;

}

Из-за отсутствия функции insert() в классе <cstring> я была вынуждена написать её самостоятельно. В остальном работа заключалась лишь в «переводе» кода из одного класса в другой.

Код можно посмотреть здесь.