• You may assume all INTALs are at most 1000 digits long, hence using malloc function, declare a 1001 element character array. The 1 extra element will be for the null character \0.
• To avoid computing with garbage values, initialize all elements of the declared INTAL to 0.
• The aforementioned guidelines can be treated as a single function which returns 1001 digit INTAL initialized with zeros. This will be useful later on when trying to instantly create an INTAL.

//pseudo code
char* initializeINTAL()
startfunction
    //malloc syntax
    <datatype>* <pointer-name> = (<datatype>*)malloc(n*sizeof(<datatype>);
    // n is number of pointers required
    for i = 0 to 1000
        do
            <pointer-name>[i] = '0'
        endfor
    <pointer-name>[1000] = '\0'    
    return <pointer-name>
endfunction

• Write a function that accepts two INTALs as function parameters and returns 0 or -1 or 1 if both INTALs are equal or first INTAL is lesser than second INTAL or second INTAL is lesser than first INTAL respectively.
• The function must run in O(n) time (complexity), where n is the number of digits in INTAL or the number of characters in the array.
• INTALs passed to the comparator may be of unequal length and should be kept in mind while determining which INTAL is greater.

//pseudo code
int compareINTAL(intal_a, intal_b)
startfunction
    //intal_a = {'1','2','3','\0'}, intal_b = {'2','3','\0'}
    if length of intal_a > length of intal_b
        return 1
    //intal_a = {'2','3','\0'}, intal_b = {'1','2','3','\0'}
    if length of intal_a < length of intal_b
        return -1
    i = length of intal_a
    //intal_a = {'2','2','3','\0'}, intal_b = {'1','2','3','\0'}
    // equal length INTAL
    while i > -1:
        if intal_a[i] > intal_b[i]:
            return 1
        if intal_a[i] < intal_b[i]:
            return -1
        i-=1
    // all characters are equal
    return 0
endfunction

• Write a function that accepts two INTALs as function parameters and returns the sum of both INTALs.
• The function must run in O(n) time, where n is the number of digits in INTAL or the number of characters in the array.
• INTALs passed to the adder may be of unequal length and should be kept in mind while determining sum of INTALs.
• Use the same concept of elementary mathematical addition for adding the INTALs, i.e., basically in case the i^th element exceeds 9, a carry over needs to be made to the next element.
• Example:

A = {'9','9','9','\0'}
B = {'1','\0'}
Result = {'1','0','0','0','\0'}

• Try visualizing the Additions link provided in references.

• Write a function that accepts two INTALs as function parameters and returns the difference.
• The smaller INTAL must always be subtracted from the larger INTAL; so that the result INTAL is always greater than or equal to zero.
• The function must run in O(n) time, where n is the number of digits in INTAL or the number of characters in the array.
• Use the same concept of elementary mathematical subtraction, i.e., basically in case the i^th element of the subtrahend exceeds the i^th element of the minuend, use the concept of borrow from the neighbouring element of subtrahend. Keep borrowing until found.
• The result INTAL must not contain any preceding zeros in the result, unless the result is zero in which case the INTAL can contain only 1 zero.
• Example:

A = {'1','0','0','0','\0'}
B = {'1','\0'}
Result = {'9','9','9','\0'}
 
A = {'1','0','0','0','\0'}
B = {'1','0','0','0','\0'}
Result = {'0','\0'}

• Since our INTALs support a maximum of 1000 digits, the sum of digits of both multipliers must not exceed 1000.
• Write a function that accepts two INTALs as function parameters and returns the product.
• In case either of the INTALs are zero, return zero.
• In case either of the INTALs are 1, return the other INTAL.
• The function must run in O(n²) time, where n is number of digits in INTAL
• We assume intal_b is smaller than intal_a, then perform a check and pass the larger INTAL to a helper function for multiplication as parameter 1 and smaller INTAL as parameter 2.
• Visualize the multiplication of 3 digit numbers to understand the implementation better. Refer to the multiplication video in references.

char* multiplyINTAL(intal_a, intal_b):
startfunction
    initialize result
    if intal_a is zero or intal_a is one:
        copy intal_b to result
        return result
    if intal_b == 0 or intal_b is one:
        copy intal_a to result
        return result
    l2 = length of intal_b
    l1 = length of intal_a
    
    for i = l2-1 to 0:
    do
        sum = 0, carry = 0, ptr1 = 1
        ptr2 = l1+l2-ptr1
        for j = l1-1 to 0:
        do
            sum = (intal_a[j]-'0')*(intal_b[i]-'0') + (result[ptr2]-'0')+carry
            result[ptr2] = 48+sum%10
            carry = sum/10
            --ptr2
        endfor
        if carry:
            res[ptr2] += carry
        endif
    ++ptr1
    endfor
    return result
endfunction

• Write a function to take an unsigned int n as parameter and return the n^th Fibonacci INTAL.
• Refer to the algorithm to compute the n^th Fibonacci number. The only additional logic is required to deal with INTALs.
• Have 2 INTALs initialized to Zero and One respectively.
• Until n terms are generated, keep adding the previous 2 Fibonacci terms as is with the Fibonacci algorithm.
• It is recommended to compute the n^th Fibonacci INTAL in constant space because computing all intermediate results and not reusing them may deplete system memory. Refer Method 3 of Fibonacci in references.

char* FibonacciINTAL(unsigned int n):
startfunction
    initialize intal_a to zero
    if n is zero:
        return intal_a
    endif
    initialize intal_b to one:
    if n is one:
        free intal_a
        return intal_b
    endif
    initialize intal_temp to zero
    for i = 2 to n:
    do
        temp = addINTAL(intal_a, intal_b)
        free intal_a
        intal_a = intal_b
        intal_b = temp
    endfor
    free intal_a
    return intal_b
endfunction

• Write a function to take an unsigned int n as parameter and return the factorial represented as an INTAL.
• The concept of factorial of a number remains unchanged. Your part is to incorporate INTAL computations into the algorithm.
• It is recommended to compute the factorial INTAL in constant space because computing all intermediate results and not reusing them may deplete system memory and take longer than expected.

char* factorialINTAL(unsigned int n):
startfunction
    initialize intal_result to one
    if n is zero or one:
        return intal_result
    endif
    initialize intal_num to one
    create a temporary pointer temp
    for i = 2 to n:
    do
        temp = addINTAL(intal_num,"1")
        intal_num = temp
        temp = multiplyINTAL(intal_num, intal_result)
        free intal_result
        intal_result = temp
    endfor
    free intal_num
    return intal_result
endfunction