Compare commits
No commits in common. "c495b7c47f944f0167667e16d03570a838ee7064" and "ab6732eded0a1883639bfc228a6b80a3669c46e7" have entirely different histories.
c495b7c47f
...
ab6732eded
4 changed files with 252 additions and 425 deletions
|
|
@ -1,6 +1,5 @@
|
|||
#include <iostream>
|
||||
#include <math.h>
|
||||
#include <cstdlib>
|
||||
#include "circle.h"
|
||||
#include "point.h"
|
||||
|
||||
|
|
@ -26,7 +25,7 @@ void Circle::setRadius(float radius) {
|
|||
mRadius = radius > 0 ? radius : 0;
|
||||
}
|
||||
float Circle::getArea() const {
|
||||
return abs(mRadius * mRadius * M_PI);
|
||||
return mRadius * mRadius * M_PI;
|
||||
}
|
||||
float Circle::getDistance(const Point& p) {
|
||||
return mCenter.distance(p) - mRadius;
|
||||
|
|
|
|||
|
|
@ -1,75 +0,0 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include "number.h"
|
||||
|
||||
Number fib(int n)
|
||||
{
|
||||
Number a = 0; // F0
|
||||
Number b = 1; // F1
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
if (i % 2) {
|
||||
a += b;
|
||||
} else {
|
||||
b += a;
|
||||
}
|
||||
}
|
||||
if (n % 2) {
|
||||
return b;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
Number factorial(int n)
|
||||
{
|
||||
Number result {
|
||||
1};
|
||||
for (int i = 2; i < n + 1; ++i) {
|
||||
result = Number(i) * result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void grad(Number n)
|
||||
{
|
||||
|
||||
std::cout << "n = " << n;
|
||||
Number max = n;
|
||||
unsigned long long int steps = 0;
|
||||
while (n != Number(1)) {
|
||||
if (n > max) {
|
||||
#ifdef _DEBUG_COMP
|
||||
std::cout << n << " is greater than " << max << std::endl;
|
||||
#endif
|
||||
max = n;
|
||||
}
|
||||
if (n.isEven()) {
|
||||
n.div2();
|
||||
} else {
|
||||
n = Number(3) * n + Number(1);
|
||||
}
|
||||
#ifdef _DEBUG_GRAD
|
||||
if (steps > 100) {
|
||||
std::cout << "break" << std::endl;
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
++steps;
|
||||
}
|
||||
std::cout << " steps = " << steps << " max = " << max << std::endl;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
std::cout << "===FIB===" << std::endl;
|
||||
std::cout << "F(1000) = " << fib(1000) << std::endl;
|
||||
std::cout << "===FAC===" << std::endl;
|
||||
std::cout << "1000! = " << factorial(1000) << std::endl;
|
||||
std::cout << "===GRAD===" << std::endl;
|
||||
grad(Number("7"));
|
||||
grad(Number("256"));
|
||||
grad(Number("1117065"));
|
||||
grad(Number("4761963248413673697"));
|
||||
grad(Number("90560792656972947582439785608972465789628974587264056284658721771"));
|
||||
}
|
||||
|
|
@ -1,341 +1,307 @@
|
|||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <cstring>
|
||||
#include "number.h"
|
||||
#include <iomanip>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
|
||||
Number::Number(int a)
|
||||
/*
|
||||
Класс Number -- класс положительных больших чисел
|
||||
|
||||
Большое число будет храниться в динамическом массиве data
|
||||
Каждый элемент этого массива содержит разряд числа в 100-ричной системе счисления
|
||||
(так как base = 100)
|
||||
По сути, каждый элемент data хранит две цифры числа в десятичной записи
|
||||
|
||||
Значение 100 для системы счисления выбрано как компромис между
|
||||
эффективностью и удобством написания программы.
|
||||
Если выбрать значения базы 10 - то программа будет не так эффективна по памяти
|
||||
Если выбрать значения базы 256 (максимально эффективное использование памяти для типа char),
|
||||
то алгоритм печати на экран сильно усложнится
|
||||
В качестве альтернативы, можно было выбрать базу 1e9,
|
||||
изменив при этом тип элементов c char на int
|
||||
|
||||
capacity - размер массива data
|
||||
size - сколько ячеек занимет число в массиве data
|
||||
size <= capacity
|
||||
|
||||
Для удобства разряды числа хранятся в обратном порядке
|
||||
Например, число 12345678 соответствует массиву
|
||||
data = {78, 56, 34, 12}
|
||||
(это упрощает многие алгоритмы с такими числами)
|
||||
*/
|
||||
|
||||
|
||||
class Number
|
||||
{
|
||||
private:
|
||||
static const int base = 100;
|
||||
std::size_t size;
|
||||
std::size_t capacity;
|
||||
char* data;
|
||||
|
||||
public:
|
||||
|
||||
Number(int a)
|
||||
{
|
||||
#ifdef _DEBUG_CONSTRUCTOR
|
||||
std::cout << "(Number constructor " << a << " -> ";
|
||||
std::cout << "(Number constructor " << a << " -> ";
|
||||
#endif
|
||||
// Находим размер необходимой памяти под это число
|
||||
int temp = a;
|
||||
capacity = 0;
|
||||
while (temp != 0) {
|
||||
temp /= base;
|
||||
capacity += 1;
|
||||
}
|
||||
// Находим размер необходимой памяти под это число
|
||||
int temp = a;
|
||||
capacity = 0;
|
||||
while (temp != 0)
|
||||
{
|
||||
temp /= base;
|
||||
capacity += 1;
|
||||
}
|
||||
|
||||
// Отдельно обрабатываем случай, когда число равно 0
|
||||
if (capacity == 0)
|
||||
capacity = 1;
|
||||
// Отдельно обрабатываем случай, когда число равно 0
|
||||
if (capacity == 0)
|
||||
capacity = 1;
|
||||
|
||||
// Выделяем память и записывем число a в массив data
|
||||
// Например, число 12345678 представится в виде массива [78, 56, 34, 12]
|
||||
// Выделяем память и записывем число a в массив data
|
||||
// Например, число 12345678 представится в виде массива [78, 56, 34, 12]
|
||||
|
||||
data = new char[capacity];
|
||||
data = new char[capacity];
|
||||
|
||||
for (int i = 0; i < capacity; ++i) {
|
||||
data[i] = a % base;
|
||||
a /= base;
|
||||
}
|
||||
for (int i = 0; i < capacity; ++i)
|
||||
{
|
||||
data[i] = a % base;
|
||||
a /= base;
|
||||
}
|
||||
|
||||
// В данном случае размер будет равен вместимости
|
||||
size = capacity;
|
||||
// В данном случае размер будет равен вместимости
|
||||
size = capacity;
|
||||
#ifdef _DEBUG_CONSTRUCTOR
|
||||
std::cout << *this << ")" << std::endl;
|
||||
std::cout << *this << ")" << std::endl;
|
||||
#endif
|
||||
}
|
||||
|
||||
// Конструктор по умолчанию
|
||||
Number::Number():Number(0){}
|
||||
|
||||
// Конструктор копирования
|
||||
Number::Number(const Number & n)
|
||||
{
|
||||
size = n.size;
|
||||
capacity = n.capacity;
|
||||
data = new char[capacity];
|
||||
for (int i = 0; i < size; i++) {
|
||||
data[i] = n.data[i];
|
||||
}
|
||||
}
|
||||
|
||||
Number::Number(const char *str)
|
||||
{
|
||||
int len = std::strlen(str);
|
||||
size = (len + len % 2) / 2;
|
||||
capacity = size;
|
||||
data = new char[capacity];
|
||||
char buf[2];
|
||||
for (int i = 0; i < size; i++) {
|
||||
buf[1] = str[len - 2 * i - 1];
|
||||
if (len - 2 * i - 1 > 0) {
|
||||
buf[0] = str[len - 2 * i - 2];
|
||||
} else {
|
||||
buf[0] = '0';
|
||||
}
|
||||
data[i] = std::stoi(buf);
|
||||
// Конструктор по умолчанию
|
||||
Number() : Number(0) {}
|
||||
// Конструктор копирования
|
||||
Number(const Number& n) {
|
||||
size = n.size;
|
||||
capacity = n.capacity;
|
||||
data = new char[capacity];
|
||||
for (int i = 0; i < size; i++) {
|
||||
data[i] = n.data[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Number::~Number()
|
||||
{
|
||||
delete[]data;
|
||||
}
|
||||
|
||||
Number & Number::operator=(const Number & right)
|
||||
{
|
||||
capacity = right.capacity;
|
||||
size = right.size;
|
||||
data = new char[capacity];
|
||||
for (int i = 0; i < size; i++) {
|
||||
data[i] = right.data[i];
|
||||
Number(const char* str) {
|
||||
int len = std::strlen(str);
|
||||
size = (len + len % 2) / 2;
|
||||
capacity = size;
|
||||
data = new char[capacity];
|
||||
char buf[2];
|
||||
for (int i = 0; i < size; i++) {
|
||||
buf[1] = str[len - 2 * i - 1];
|
||||
if (len - 2 * i - 1 > 0) {
|
||||
buf[0] = str[len - 2 * i - 2];
|
||||
}
|
||||
else {
|
||||
buf[0] = '0';
|
||||
}
|
||||
data[i] = std::stoi(buf);
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
Number Number::operator+(Number a)
|
||||
{
|
||||
#ifdef _DEBUG_ADD
|
||||
std::cout << "arg1=" << a << "capacity=" << a.
|
||||
capacity << ",size=" << a.size << std::endl;
|
||||
std::cout << "arg2=" << *this << "capacity=" << this->
|
||||
capacity << ",size=" << this->size << std::endl;
|
||||
|
||||
#endif
|
||||
Number result;
|
||||
Number temp;
|
||||
int i;
|
||||
int carry = 0;
|
||||
if (size < a.size) {
|
||||
temp = *this;
|
||||
*this = a;
|
||||
a = temp;
|
||||
~Number()
|
||||
{
|
||||
delete [] data;
|
||||
}
|
||||
result.capacity = size + 1;
|
||||
//result.data = new char[capacity];
|
||||
result.data = (char *) calloc(result.capacity, sizeof(char));
|
||||
for (i = 0; i < a.size; ++i) {
|
||||
result.data[i] = (data[i] + a.data[i] + carry) % base;
|
||||
carry = (data[i] + a.data[i] + carry) / base;
|
||||
Number& operator=(const Number& right) {
|
||||
capacity = right.capacity;
|
||||
size = right.size;
|
||||
data = new char[capacity];
|
||||
for (int i = 0; i < size; i++) {
|
||||
data[i] = right.data[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
for (; i < size; ++i) {
|
||||
result.data[i] = (data[i] + carry) % base;
|
||||
carry = (data[i] + carry) / base;
|
||||
}
|
||||
if (carry) {
|
||||
#ifdef _DEBUG_ADD
|
||||
std::cout << "applied carry" << std::endl;
|
||||
#endif
|
||||
result.data[i] = carry;
|
||||
result.size = size + 1;
|
||||
} else {
|
||||
result.size = size;
|
||||
}
|
||||
#ifdef _DEBUG_ADD
|
||||
std::cout << result << " capacity=" << result.
|
||||
capacity << ",size=" << result.size << std::endl;
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
void Number::operator+=(const Number & a)
|
||||
{
|
||||
*this = *this + a;
|
||||
}
|
||||
Number operator+(const Number& a) {
|
||||
Number result;
|
||||
int i;
|
||||
char carry = 0;
|
||||
int max_size = size > a.size ? size : a.size;
|
||||
|
||||
bool Number::isEven() const
|
||||
{
|
||||
if (data[0] % 2) {
|
||||
return false;
|
||||
result.capacity = max_size + 1;
|
||||
result.data = new char[capacity];
|
||||
|
||||
for (i = 0; i < max_size; ++i) {
|
||||
result.data[i] = (data[i] + a.data[i] + carry) % base;
|
||||
carry = (data[i] + a.data[i] + carry) / base;
|
||||
}
|
||||
|
||||
if (carry) {
|
||||
result.data[i] = carry;
|
||||
result.size = max_size + 1;
|
||||
}
|
||||
else {
|
||||
result.size = max_size;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
void operator+=(const Number& a) {
|
||||
*this = *this + a;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
Number Number::operator*(const Number & right) const
|
||||
{
|
||||
bool isEven() const {
|
||||
if (data[0] % 2) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
Number operator*(const Number& right) const {
|
||||
#ifdef _DEBUG_MUL
|
||||
std::
|
||||
cout << "arg1=" << *this << "(capacity=" << capacity << ",size=" <<
|
||||
size << ")" << " " << "arg2=" << right << "(capacity=" << right.
|
||||
capacity << ",size=" << right.size << ")" << std::endl;
|
||||
std::cout << "arg1=" << *this << "(capacity=" << capacity << ",size=" << size << ")" << " " << "arg2=" << right << "(capacity=" << right.capacity << ",size=" << right.size << ")"<< std::endl;
|
||||
#endif
|
||||
int i, j;
|
||||
int temp;
|
||||
Number result;
|
||||
int i, j;
|
||||
int temp;
|
||||
Number result;
|
||||
|
||||
result.capacity = capacity + right.capacity;
|
||||
int *carry = (int *) std::calloc(result.capacity, sizeof(int));
|
||||
result.capacity = capacity + right.capacity;
|
||||
int *carry = (int*)std::calloc(result.capacity, sizeof(int));
|
||||
|
||||
result.data = (char *) calloc(result.capacity, sizeof(char));
|
||||
result.data = (char*)calloc(result.capacity, sizeof(char));
|
||||
#ifdef _DEBUG_MUL
|
||||
std::cout << "carry:[" << carry[0];
|
||||
for (int k = 1; k < result.capacity; ++k) {
|
||||
std::cout << "," << carry[k];
|
||||
}
|
||||
std::cout << "]" << std::endl;
|
||||
std::cout << "carry:[" << carry[0];
|
||||
for (int k = 1; k < result.capacity; ++k) {
|
||||
std::cout << "," << carry[k];
|
||||
}
|
||||
std::cout << "]" << std::endl;
|
||||
#endif
|
||||
for (i = 0; i < size; ++i) {
|
||||
for (j = 0; j < right.size; ++j) {
|
||||
for (i = 0; i < size; ++i) {
|
||||
for (j = 0; j < right.size; ++j) {
|
||||
#ifdef _DEBUG_MUL
|
||||
std::cout << i + j << ":" << static_cast <
|
||||
int >(result.data[i + j]) << " + " << static_cast <
|
||||
int >(data[i]) << " * " << static_cast <
|
||||
int >(right.data[j]) << " + " << carry[i + j] << std::endl;
|
||||
std::cout << i + j << ":" << static_cast<int>(result.data[i + j]) << " + " << static_cast<int>(data[i]) << " * " << static_cast<int>(right.data[j]) << " + " << carry[i+j] << std::endl;
|
||||
#endif
|
||||
temp =
|
||||
(result.data[i + j] + data[i] * right.data[j] +
|
||||
carry[i + j]);
|
||||
result.data[i + j] = temp % base;
|
||||
carry[i + j + 1] += temp / base;
|
||||
carry[i + j] = 0;
|
||||
temp = (result.data[i + j] + data[i] * right.data[j] + carry[i + j]);
|
||||
result.data[i + j] = temp % base;
|
||||
carry[i + j + 1] += temp / base;
|
||||
carry[i + j] = 0;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef _DEBUG_MUL
|
||||
std::cout << "result before applying carry:" << result << std::endl;
|
||||
std::cout << "carry:[" << carry[0];
|
||||
for (int k = 1; k < result.capacity; ++k) {
|
||||
std::cout << "," << carry[k];
|
||||
}
|
||||
std::cout << "]" << std::endl;
|
||||
std::cout << "result before applying carry:" << result << std::endl;
|
||||
std::cout << "carry:[" << carry[0];
|
||||
for (int k = 1; k < result.capacity; ++k) {
|
||||
std::cout << "," << carry[k];
|
||||
}
|
||||
std::cout << "]" << std::endl;
|
||||
#endif
|
||||
if (carry[i + j - 1]) {
|
||||
result.data[i + j - 1] = carry[i + j - 1];
|
||||
result.size = i + j;
|
||||
} else {
|
||||
result.size = i + j - 1;
|
||||
}
|
||||
if (carry[i + j - 1]) {
|
||||
result.data[i + j - 1] = carry[i + j - 1];
|
||||
result.size = i + j;
|
||||
carry[i + j - 1] = 0;
|
||||
}
|
||||
else {
|
||||
result.size = i + j - 1;
|
||||
}
|
||||
|
||||
#ifdef _DEBUG_MUL
|
||||
std::cout << "before correcting capacity, result=" << result << std::
|
||||
endl;
|
||||
std::cout << "before correcting capacity, result=" << result << std::endl;
|
||||
#endif
|
||||
// correcting capacity
|
||||
/*char* temp_data = (char *)calloc(result.size, sizeof(char));
|
||||
for (i = 0; i < result.size; ++i) {
|
||||
temp_data[i] = result.data[i];
|
||||
}
|
||||
// correcting capacity
|
||||
/*char* temp_data = (char *)calloc(result.size, sizeof(char));
|
||||
for (i = 0; i < result.size; ++i) {
|
||||
temp_data[i] = result.data[i];
|
||||
}
|
||||
|
||||
free(result.data);
|
||||
result.capacity = result.size;
|
||||
result.data = (char*)calloc(result.size,sizeof(char));
|
||||
for (i = 0; i < result.size; ++i) {
|
||||
result.data[i] = temp_data[i];
|
||||
}
|
||||
free(result.data);
|
||||
result.capacity = result.size;
|
||||
result.data = (char*)calloc(result.size,sizeof(char));
|
||||
for (i = 0; i < result.size; ++i) {
|
||||
result.data[i] = temp_data[i];
|
||||
}
|
||||
|
||||
free(temp_data); */
|
||||
free(carry);
|
||||
free(temp_data);*/
|
||||
free(carry);
|
||||
#ifdef _DEBUG_MUL
|
||||
std::cout << "return value=" << result << "(capacity=" << result.
|
||||
capacity << ",size=" << result.
|
||||
size << ")" << std::endl << "======" << std::endl;
|
||||
std::cout << "return value=" << result << "(capacity=" << result.capacity << ",size=" << result.size << ")" << std::endl << "======" << std::endl;
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
void Number::operator*=(const Number & a)
|
||||
{
|
||||
*this = *this * a;
|
||||
}
|
||||
|
||||
bool Number::operator==(const Number & a) const
|
||||
{
|
||||
if (size != a.size) {
|
||||
return false;
|
||||
return result;
|
||||
}
|
||||
for (int i = 0; i < size; ++i) {
|
||||
if (data[i] != a.data[i]) {
|
||||
return false;
|
||||
}
|
||||
void operator*=(const Number& a) {
|
||||
*this = *this * a;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Number::operator!=(const Number & a) const
|
||||
{
|
||||
return not(*this == a);
|
||||
}
|
||||
|
||||
bool Number::operator>(const Number & a) const
|
||||
{
|
||||
#ifdef _DEBUG_COMP
|
||||
std::
|
||||
cout << "comp " << *this << "(size=" << size << ") and " << a <<
|
||||
"(size=" << a.size << ")" << std::endl;
|
||||
#endif
|
||||
if (size > a.size) {
|
||||
#ifdef _DEBUG_COMP
|
||||
std::cout << "size > a.size => true" << std::endl;
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
if (size < a.size) {
|
||||
#ifdef _DEBUG_COMP
|
||||
std::cout << "size < a.size => false" << std::endl;
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
for (int i = size - 1; i >= 0; --i) {
|
||||
if (data[i] > a.data[i]) {
|
||||
return true;
|
||||
#ifdef _DEBUG_COMP
|
||||
std::cout << static_cast <
|
||||
int >(data[i]) << ">" << static_cast <
|
||||
int >(a.data[i]) << std::endl;
|
||||
#endif
|
||||
}
|
||||
if (data[i] < a.data[i]) {
|
||||
#ifdef _DEBUG_COMP
|
||||
std::cout << static_cast <
|
||||
int >(data[i]) << "<" << static_cast <
|
||||
int >(a.data[i]) << std::endl;
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
#ifdef _DEBUG_COMP
|
||||
std::cout << "using final false" << std::endl;
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Number::operator<(const Number & a) const
|
||||
{
|
||||
return not(*this > a) and(*this != a);
|
||||
}
|
||||
|
||||
void Number::div2()
|
||||
{
|
||||
#ifdef _DEBUG_DIV2
|
||||
std::cout << "n = " << *this << std::endl;
|
||||
#endif
|
||||
int carry = 0;
|
||||
int temp;
|
||||
for (int i = size - 1; i >= 0; --i) {
|
||||
temp = data[i] + carry * base;
|
||||
data[i] = temp / 2;
|
||||
carry = temp % 2;
|
||||
}
|
||||
if (data[size - 1] == 0) {
|
||||
--size;
|
||||
}
|
||||
#ifdef _DEBUG_DIV2
|
||||
std::cout << "unstripped result " << *this << std::endl;
|
||||
#endif
|
||||
}
|
||||
friend std::ostream& operator<<(std::ostream& stream, const Number& right);
|
||||
friend int main();
|
||||
friend Number factorial(int n);
|
||||
};
|
||||
|
||||
|
||||
std::ostream & operator<<(std::ostream & stream, const Number & right)
|
||||
|
||||
std::ostream& operator<<(std::ostream& stream, const Number& right)
|
||||
{
|
||||
#ifdef _DEBUG_COUT
|
||||
stream << "[";
|
||||
for (std::size_t i = 0; i < right.size; ++i) {
|
||||
stream << static_cast <
|
||||
int >(right.data[right.size - 2 - i]) << ",";
|
||||
stream << static_cast<int>(right.data[right.size - 2 - i]) << ",";
|
||||
}
|
||||
stream << "]";
|
||||
#else
|
||||
// Печатаем самый большой разряд
|
||||
stream << (int) right.data[right.size - 1];
|
||||
// Печатаем самый большой разряд
|
||||
stream << (int)right.data[right.size - 1];
|
||||
|
||||
// Печатаем остальные разряды с заполнением нулями до 2-х цифр
|
||||
// setfill и setw это то же самое, что и в языке C спецификатор %02d
|
||||
for (std::size_t i = 0; i < right.size - 1; ++i)
|
||||
stream << std::setfill('0') << std::setw(2) << (int) right.
|
||||
data[right.size - 2 - i];
|
||||
stream << std::setfill('0') << std::setw(2) << (int)right.data[right.size - 2 - i];
|
||||
#endif
|
||||
return stream;
|
||||
}
|
||||
|
||||
Number fib(int n) {
|
||||
Number a = 0; // F0
|
||||
Number b = 1; // F1
|
||||
for (int i = 1; i <=n; ++i) {
|
||||
if (i % 2) {
|
||||
a += b;
|
||||
}
|
||||
else {
|
||||
b += a;
|
||||
}
|
||||
}
|
||||
if (n % 2) {
|
||||
return b;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
Number factorial(int n) {
|
||||
Number result{1};
|
||||
for (int i = 2; i < n + 1; ++i) {
|
||||
result = Number(i) * result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
Number x = Number("25852016738884976640000");
|
||||
Number y = Number("24");
|
||||
|
||||
//char s[3];
|
||||
//Number result = "1";
|
||||
//for (int i = 1; i < 26; ++i) {
|
||||
//s = std::to_string(i);
|
||||
//sprintf(s, "%d", i);
|
||||
// result = (Number{i} * result);
|
||||
//}
|
||||
//x += y;
|
||||
//Number z = x + y;
|
||||
//std::cout << fib(1000) << std::endl;
|
||||
//x = x * Number(24)*Number{25};
|
||||
//y = factorial(5);
|
||||
//std::cout << x << " " << x.capacity << " " << x.size << std::endl;
|
||||
//std::cout << y << " "<< y.capacity << " " << y.size << std::endl;
|
||||
// 90405070506200618121707-18-13-05-18-08
|
||||
//std::cout << "===" << std::endl << Number(2) * Number(3) << " "<< Number(3) * Number(2) << std::endl;
|
||||
//std::cout << "5! = " << Number(2) * Number(3) * Number(4) * Number(5) << std::endl;
|
||||
std::cout << factorial(1000) << std::endl;
|
||||
//std::cout << Number("620448401733239439360000") * Number(25) << std::endl;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,63 +0,0 @@
|
|||
#pragma once
|
||||
/*
|
||||
Класс Number -- класс положительных больших чисел
|
||||
|
||||
Большое число будет храниться в динамическом массиве data
|
||||
Каждый элемент этого массива содержит разряд числа в 100-ричной системе счисления
|
||||
(так как base = 100)
|
||||
По сути, каждый элемент data хранит две цифры числа в десятичной записи
|
||||
|
||||
Значение 100 для системы счисления выбрано как компромис между
|
||||
эффективностью и удобством написания программы.
|
||||
Если выбрать значения базы 10 - то программа будет не так эффективна по памяти
|
||||
Если выбрать значения базы 256 (максимально эффективное использование памяти для типа char),
|
||||
то алгоритм печати на экран сильно усложнится
|
||||
В качестве альтернативы, можно было выбрать базу 1e9,
|
||||
изменив при этом тип элементов c char на int
|
||||
|
||||
capacity - размер массива data
|
||||
size - сколько ячеек занимет число в массиве data
|
||||
size <= capacity
|
||||
|
||||
Для удобства разряды числа хранятся в обратном порядке
|
||||
Например, число 12345678 соответствует массиву
|
||||
data = {78, 56, 34, 12}
|
||||
(это упрощает многие алгоритмы с такими числами)
|
||||
*/
|
||||
|
||||
class Number {
|
||||
private:
|
||||
static const int base = 100;
|
||||
std::size_t size;
|
||||
std::size_t capacity;
|
||||
char *data;
|
||||
|
||||
public:
|
||||
|
||||
Number(int a);
|
||||
Number();
|
||||
// Конструктор копирования
|
||||
Number(const Number & n);
|
||||
Number(const char *str);
|
||||
~Number();
|
||||
Number & operator=(const Number & right);
|
||||
|
||||
Number operator+(Number a);
|
||||
void operator+=(const Number & a);
|
||||
|
||||
bool isEven() const;
|
||||
|
||||
Number operator*(const Number & right) const;
|
||||
void operator*=(const Number & a);
|
||||
|
||||
bool operator==(const Number & a) const;
|
||||
bool operator!=(const Number & a) const;
|
||||
bool operator>(const Number & a) const;
|
||||
bool operator<(const Number & a) const;
|
||||
void div2();
|
||||
|
||||
friend std::ostream & operator<<(std::ostream & stream,
|
||||
const Number & right);
|
||||
};
|
||||
|
||||
std::ostream & operator<<(std::ostream & stream, const Number & right);
|
||||
Reference in a new issue