sol1.c File Reference

Problem 20 solution More...

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

Include dependency graph for sol1.c:

Data Structures
struct	_big_int

Typedefs
typedef struct _big_int	big_int

Functions
big_int *	add_digit (big_int *digit, char value)
char	remove_digits (big_int *digit, int N)
int	main (int argc, char **argv)

Detailed Description

Problem 20 solution

Author

Krishna Vedala

Implementation uses a custom big_int structure that can store arbitrarilty large integer numbers.

Typedef Documentation

big_int

typedef struct _big_int big_int

store arbitratily large integer values as a linked list of digits.

Function Documentation

add_digit()

big_int* add_digit	(	big_int *	digit,
		char	value
	)

Function that allocates memory to add another digit at the MSB

{
    if (digit == NULL)
    {
        digit = (big_int *)malloc(sizeof(big_int));
        if (!digit)
        {
            perror("Unable to allocate memory!");
            return NULL;
        }
        digit->value = value;
        digit->next_digit = NULL;
        digit->prev_digit = NULL;
 
        return digit;
    }
 
    if (digit->next_digit)
    {
        digit->next_digit->value = value;
        return digit->next_digit;
    }
 
    digit->next_digit = (big_int *)malloc(sizeof(big_int));
    if (digit->next_digit == NULL)
    {
        perror("Unable to allocate memory!");
        return NULL;
    }
    digit->next_digit->value = value;
    digit->next_digit->next_digit = NULL;
    digit->next_digit->prev_digit = digit;
    return digit->next_digit;
}

main()

int main	(	int	argc,
		char **	argv
	)

Main function

sum digits on the last iteration this avoid having another loop over all digits

Notice that in the loop above, we make sure that at the end of the loop, ptr is pointing to the last digit. Thus we can avoid using another loop.

{
    unsigned int N = 5;
    big_int *ptr = add_digit(NULL, 1); /* start with 1 */
    const big_int *ptr0 = ptr;         /* save the first location */
    unsigned long sum_digits = 0;
    unsigned long num_digits = 0;
 
    if (argc == 2)
        N = atoi(argv[1]);
 
    clock_t start_time = clock();
 
    for (unsigned int i = 1; i <= N; i++)
    {
        int carry = 0;
#ifdef DEBUG
        printf("%3d: ", i);
#endif
        ptr = (big_int *)ptr0; /* multiply every digit with i */
        while (ptr)
        {
#ifdef DEBUG
            printf("%p\t", ptr);
#endif
            unsigned int tmp = ptr->value * i + carry;
            if (tmp >= 10)
            {
                div_t tmp2 = div(tmp, 10);
                carry = tmp2.quot;
                tmp = tmp2.rem;
            }
            else
                carry = 0;
 
            if (carry > 0 && ptr->next_digit == NULL)
                add_digit(ptr, 0);
 
            ptr->value = tmp;
 
            if (i == N)
                /**
                 * sum digits on the last iteration
                 * this avoid having another loop over all digits
                 **/
                sum_digits += tmp;
 
            if (ptr->next_digit)
                /* more digits available */
                ptr = ptr->next_digit;
            else
                /* no more digits left - reached MSB */
                break;
        }
#ifdef DEBUG
        printf("\n");
#endif
    }
 
    clock_t end_time = clock();
 
#ifdef DEBUG
    printf("ptr = %p\n", ptr);
    printf("%d! = ", N);
#endif
 
    /** Notice that in the loop above, we make sure that at the end of the loop,
     * ptr is pointing to the last digit. Thus we can avoid using another loop.
     **/
    // ptr = &my_int;
    // /* move ptr to the MSB digit */
    // while (ptr->next_digit)
    //     ptr = ptr->next_digit;
    do
    {
        putchar(ptr->value + 0x30); /* convert digit to ASCII char */
        ptr = ptr->prev_digit;
        num_digits++;
    } while (ptr); /* after coming to units place, there will be no valid ptr */
 
    printf("\nTime taken: %.4g millisecond\n",
           1e3 * (end_time - start_time) / CLOCKS_PER_SEC);
    printf(
        "Digit Sum = %lu\tNumber of digits = %lu\tStorage space = %.3gkb\t \n",
        sum_digits, num_digits, num_digits * sizeof(big_int) / 1024.0);
 
    remove_digits((big_int *)ptr0, -1);
    return 0;
}

Here is the call graph for this function:

remove_digits()

char remove_digits	(	big_int *	digit,
		int	N
	)

Function to remove digits preceeding the current digit.

{
    if (digit == NULL)
        return 0;
 
    if (digit->next_digit == NULL)
    {
        free(digit);
        digit = NULL;
        return 0;
    }
 
    if (N > 0)
        return remove_digits(digit->next_digit, N - 1);
 
    return remove_digits(digit->next_digit, 0);
}