Умножение чисел в виде строк (искаженный размер и предыдущий размер)

Question

Я делаю вызов в кодовой войне, и я должен умножить два числа, заданные в виде строки, и вернуть результат в виде строки.здесь вы можете найти задачу:

https://www.codewars.com/kata/multiplying-numbers-as-strings/train/c

, поэтому мне удалось пройти все выборочные тесты, которые включают умножение больших чисел на 25+ цифр, как вы можете видеть на сайте.

, но когда я нажимаю кнопку «Попытка», я получаю эту ошибку:

*** Error in `./test': corrupted size vs. prev_size: 0x0000000001ec9918 ***
======= Backtrace: =========   

, вы можете скопировать мой код ниже, чтобы увидеть полный текст ошибки.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void zero(char *str,int len)   //this function fill my *str with 0s; 
{
  int i = 0;
  while (i <= len)
  {
        str[i] = '0';
        i++;
  }
}

//and this function below do multiplication that we learned when we were kids 
//you can do printf to see how this function work

char *multiply(char *a, char *b) {

  int l1 = strlen(a);
  int l2 = strlen(b);
  int index = l1 + l2;
  int new_i = index;
  int i = index;
  char *total = malloc(index);
  char *result = malloc(index);
  zero(total,index);
  int k = 0;
  int add = 0;
  int keep;

  while (l2 > 0)
  {
        l1 = strlen(a);
        k = 0;
        while (l1 > 0)
        {
              keep = total[i] - '0';
              total[i] = ((((total[i] - '0') + (( (b[l2 - 1] - '0') * (a[l1 - 1] - '0') + k ) % 10)) % 10) ) + '0';
              add =  ( ((keep) + (( (b[l2 - 1] - '0') * (a[l1 - 1] - '0') + k ) % 10)) / 10);
              k = (((b[l2 - 1] - '0') * (a[l1 - 1] - '0')) + k) / 10;
              if (k > 0 && l1 == 1)
                    total[i - 1] = k + '0'; 
              if (add > 0)
              {
                    if (total[i - 1] != '9')
                          total[i - 1] = ((total[i - 1] - '0') + add) + '0';
                    else
                    {
                          total[i - 1] = '0';
                          total[i - 2] = total[i - 2] + 1;
                    }
              }
              i--;
              l1--;
        }
        i = index - 1;
        index--;
        l2--;
  }

  i = 0;

  while (total[i] == '0')    //to avoid coping 0s into result
        i++;

  if (total[i] == '\0')      //in case of (0 * any positive number)
        i--;

  index = 0;      

  while (i <= new_i)
  {
        result[index] = total[i];
        i++;
        index++;
  }

  result[index] = '\0';

  return result;
}

IНе знаете, в чем проблема, это malloc или что-то еще?

Answer 1

Ваша проблема выглядит как крайний случай, и я комментирую "поврежденный размер ...", а не реальную логику умножения.

В функции multiply я заметил одну проблему.Вы рассчитываете ожидаемое количество символов в окончательном ответе как «index = l1 + l2».Однако, когда вы выполняете «malloc», вы должны выделить «index + 1» байтов, чтобы вы могли хранить «\ 0» в конце, даже если ваши входные данные генерируют максимально возможный ответ.

Лучший фронтВ тестовом примере будет использоваться большое число с "9999 ..." в качестве обоих входов.