У меня есть две структуры, которые имеют int для длины числа Фибоначчи и самого Фибоначчи в целочисленном массиве.Проблема заключается в том, что функция сложения для чисел Фибоначчи (largeAdd) зависит от целочисленного значения длины в структуре Фибоначчи.Я могу вызвать 'malloc' и перевернуть всю память, необходимую для массива, но, пытаясь автоматически увеличить переменную длины, чтобы сказать добавляющей функции (огромный_добавок) продолжать добавлять больше целых чисел, я не могу понять это.Вот список вещей, которые я попробовал.
Привязка длины Фибоначчи к циклу for, как она называется огромнымAdd.
Видим ли обамои цифры Фибоначчи в позиции 'x' больше 5 и увеличиваются на длину (тогда этот вид работает, но я не могу понять его реализацию, потому что мне нужно жестко кодировать, какую цифру проверять).
Попытка установки длины Фибоначчи в целое число, которое говорит, сколько времени для запуска цикла. (Работает в течение нескольких раундов добавления, но затем я получаю ошибку сегмента в моей функции для удаления структур (огромныйDestory)).
Есть идеи?
Fibonacci.h (Это заголовочный файл, содержащий struct def и т. Д.)
#ifndef __FIBONACCI_H
#define __FIBONACCI_H
typedef struct HugeInteger
{
// a dynamically allocated array to hold the digits of a huge integer
int *digits;
// the number of digits in the huge integer (approx. equal to arraylength)
int length;
} HugeInteger;
// Functional Prototypes
HugeInteger *hugeAdd(HugeInteger *p, HugeInteger *q);
HugeInteger *hugeDestroyer(HugeInteger *p);
HugeInteger *parseString(char *str);
HugeInteger *parseInt(unsigned int n);
unsigned int *toUnsignedInt(HugeInteger *p);
HugeInteger *fib(int n);
double difficultyRating(void);
double hoursSpent(void);
#endif
Testcase4.c Class (Содержит основную функцию и контрольный пример для проверки функции)
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include "Fibonacci.h"
// print a HugeInteger (followed by a newline character)
void hugePrint(HugeInteger *p)
{
int i;
if (p == NULL || p->digits == NULL)
{
printf("(null pointer)\n");
return;
}
for (i = p->length - 1; i >= 0; i--)
printf("%d", p->digits[i]);
printf("\n");
}
int main(void)
{
int i;
HugeInteger *p;
for (i = 0; i <= 1000; i++)
{
printf("F(%d) = ", i);
hugePrint(p = fib(i));
hugeDestroyer(p);
}
return 0;
}
Класс Fibonacci.c (Этот класс имеет все функции для запуска testcase4.c)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <math.h>
#include "Fibonacci.h"
HugeInteger *hugeAdd(HugeInteger *p, HugeInteger *q)
{
HugeInteger *hugerInt = malloc(sizeof(HugeInteger));
int overhead=1,i,j,results=0;
int *resultArray = NULL;
if(p == NULL || q == NULL || hugerInt == NULL)
{
return NULL;
}
if(p->length > q->length)
{
resultArray = calloc(((p->length)+ overhead), sizeof(int));
hugerInt->length = p->length;
hugerInt->digits = malloc(sizeof(int) * (p->length + overhead));
if(resultArray == NULL)
{
return NULL;
}
for(int k=0; k < p->length; k++)
{
if(k >= q->length)
{
results=p->digits[k]; //check for not skipping smaller int
resultArray[k] = results + resultArray[k];
}
else{
results = p->digits[k] + q->digits[k];
if(results > 9 )
{
if(p->digits[k+1] == 0)
{
hugerInt->digits[k+1] = 1;
}
resultArray[k+1] = resultArray[k+1] + 1;
results = results - 10;
printf("length of resultArray is %d\n",p->length+1);
}
resultArray[k] = results;
}
}
}
else
{
resultArray = calloc(((p->length)+ overhead)+ 1, sizeof(int));
hugerInt->length = q->length;
hugerInt->digits = malloc(sizeof(int) * (q->length)+ overhead);
if(resultArray == NULL)
{
return NULL;
}
for(i=0; i < q->length; i++)
{
// printf("q length %d", q->length);
if(i >= p->length) // Check if second struct passed is smaller then first one passed
{
results=q->digits[i]; //check for not skipping smaller int
resultArray[i] = results;
}
else{
results = q->digits[i] + p->digits[i];
if(results > 9 )
{
printf("I is in larger then 9 check %d", i);
if(p->digits[i+1] == 0)
{
hugerInt->digits[i+1] = 1;
}
printf("i is %d\n",i);
printf("Assigning 1 to %d in resultarray\n", i);
resultArray[i+1] = 1; // if value is greater then 9 the 1 carries and gets added to the result.(This is the part i think is going wrong)
results = results - 10;
printf("length of resultArray is %d\n",p->length+1);
printf("results:$d\n", results);
}
resultArray[i] = results; // Throws added values into array
}
}
}
printf("\n=================\n");
for(i=0; i < hugerInt->length; i++)
{
hugerInt->digits[i] = resultArray[i];
}
free(resultArray);
return hugerInt;
}
HugeInteger *fib(int n)
{
HugeInteger *fibInt = malloc(sizeof(HugeInteger));
HugeInteger *fatherFib = malloc(sizeof(HugeInteger));
HugeInteger *grandfatherFib = malloc(sizeof(HugeInteger));
int j=1,fatherLength=0,grandfatherLength=0,fibLength=0,result, overhead=1;
unsigned int father, grandFather, fib, tempFather, tempGrandfather, tempFib;
fatherFib->digits = calloc((n + overhead),sizeof(int) );
fibInt->digits = calloc((n+overhead),sizeof(int));
grandfatherFib->digits = calloc((n + overhead),sizeof(int) );
fatherFib->length = 1;
grandfatherFib->length = 1;
fibInt->length = 1;
if(n == 0)
{
fibInt->digits[0] = 0;
return fibInt;
}
for(int i=0; i < n; i++)
{
if(i >= 1)
{
if(fatherFib->digits[0] >= 5 && grandfatherFib->digits[0] >= 5)
{
fibInt->length = 2;
}
else if(fatherFib->digits[1] >= 5 && grandfatherFib->digits[1] >= 5)
{
fibInt->length = 3;
}
}
if(i == 0)
{
fatherFib->digits[0]= 0;
grandfatherFib->digits[0]=1;
}
fibInt = hugeAdd(fatherFib,grandfatherFib);
grandfatherFib = fatherFib;
if(fibInt->length == 2)
{
printf("tens value in father fib %d\n", fatherFib->digits[1]);
}
fatherFib = fibInt;
}
free(grandfatherFib->digits);
free(grandFatherFib);
return fatherFib;
}
HugeInteger *hugeDestroyer(HugeInteger *p)
{
if(p == NULL)
{
return; // Null check
}
free(p->digits);
free(p->length);
free(p);
return NULL;
}
int power(int base, int numTimes)
{
int result=1,i=0;
if(numTimes == 1)
{
return base;
}
for(;i < numTimes; i++)
{
result = result * base;
}
return result;
}