Verified answer

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

typedef struct bigint

{

char *data;

size_t size;

int neg;

} bigint;

bigint createBigintFromUnsInt(unsigned long int *n)

{

bigint b = {0};

b.neg = 0;

b.size = 0;

b.data = malloc(sizeof(char));

if (*n == 0)

{

b.size = 1;

b.data[0] = 0;

return b;

}

while (*n > 0)

{

b.data = realloc(b.data, ++b.size*sizeof(char));

b.data[b.size - 1] = *n%10;

*n /= 10;

}

return b;

}

bigint createBigintFromInt(long int *n)

{

bigint b = {0};

if (*n < 0)

{

b = createBigintFromUnsInt((unsigned long int*)n);

b.neg = 1;

}

else

{

b = createBigintFromUnsInt((unsigned long int*)n);

}

return b;

}

bigint createBigintFromBI(bigint *bi)

{

bigint b = {0};

b.neg = bi->neg;

b.size = bi->size;

b.data = malloc(b.size * sizeof(char));

memcpy(b.data, bi->data, b.size * sizeof(char));

return b;

}

bigint createBigintFromChar(char *str)

{

bigint b = {0};

if (str[0]=='-')

{

b.neg = 1;

str++;

}

else

{

b.neg = 0;

}

b.size = strlen(str);

b.data = malloc(b.size * sizeof(char));

for (size_t i =0; i < b.size; i++)

{

b.data[i] = str[b.size - 1 - i] - '0';

}

return b;

}

bigint createBigint()

{

bigint b = {0};

b.neg = 0;

b.size = 1;

b.data = malloc(sizeof(char));

b.data[0] = 0;

return b;

}

bigint add(const bigint* left, const bigint* right) {

   bigint result = createBigint();

   result.neg = left->neg;

   if (left->neg == right->neg) {

       result.size = max(left->size, right->size) + 1;

       result.data = malloc(result.size * sizeof(char));

       int carry = 0;

       for (size_t i = 0; i < result.size; i++) {

           int left_digit = (i < left->size) ? left->data[i] : 0;

           int right_digit = (i < right->size) ? right->data[i] : 0;

           result.data[i] = (left_digit + right_digit + carry

-------------------------------------------------------------------
-------------------------------------------------------------------
Конечно, вот пример функции вывода, которую вы можете использовать для печати значений, хранящихся в bigint struct:

void output(const bigint* b) {

   if (b->neg) {

       printf("-");

   }

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

       printf("%d", b->data[i]);

   }

   printf("\n");

}

Эта функция принимает в качестве аргумента указатель на bigint struct и проверяет поле neg, чтобы узнать, является ли число отрицательным. Если да, то перед цифрами печатается знак минус. Затем он перебирает цифры в поле data, начиная с последней, и печатает каждую цифру. Наконец, она добавляет новую строку к выводу.

Эту функцию можно использовать, например, для вывода результата сложения:

bigint a = createBigintFromInt(5);

bigint b = createBigintFromInt(3);

bigint sum = add(&a, &b);

output(&sum);

Это выведет: "8"
--------------------------------------------------------------------
---------------------------------------------------------------------

Вот пример функции divide, которую можно использовать для деления двух структур bigint:

bigint divide(const bigint* left, const bigint* right) {

   bigint quotient = createBigint();

   quotient.neg = (left->neg != right->neg);

   bigint dividend = createBigintFromBI(left);

   bigint divisor = createBigintFromBI(right);

   if (divisor.size == 1 && divisor.data[0] == 0) {

     // обрабатывать деление на ноль

   }

   while (compare(&dividend, &divisor) >= 0) {

       bigint tmp = createBigint();

       tmp.size = dividend.size - divisor.size + 1;

       tmp.data = malloc(tmp.size * sizeof(char));

       for (size_t i = 0; i < tmp.size; i++) {

           tmp.data[i] = 0;

       }

       while (compare(&dividend, &divisor) >= 0) {

           dividend = subtract(&dividend, &divisor);

           tmp = add(&tmp, &one);

       }

       quotient = add(&quotient, &tmp);

   }

   return quotient;

}

Эта функция принимает в качестве аргументов два указателя на bigint-структуры и использует функцию createBigintFromBI для создания копий входных структур так, чтобы исходные значения не были изменены.

Затем она инициализирует делитель как bigint struct со значением 0 и полем neg, которое противоположно полю neg левого операнда.

Затем проверяется, равен ли делитель нулю, если да, то функция должна обработать деление на ноль.

Затем она выполняет алгоритм деления, который заключается в многократном вычитании делителя из делимого до тех пор, пока делимое не станет меньше делителя. При каждом вычитании делителя делимое увеличивается на 1.

Для сравнения величин двух bigint используется функция compare, а для вычитания двух bigint - функция subtract.

Функции сравнения и вычитания и один bigint также должны быть реализованы.

Также вы можете использовать функцию output для вывода на печать коэффициента после выполнения деления:

bigint a = createBigintFromInt(5);

bigint b = createBigintFromInt(3);

bigint quotient = divide(&a, &b);

output(&quotient);

Это приведет к выводу: "1"

----------------------