Multiplication of two large numbers of strlen 40 each

#include <stdio.h>
#include <string.h>
#include <math.h>
#define MAX_LEN 200
int checkValidInputNum(char*);
int main() {
char first_num[MAX_LEN];
char second_num[MAX_LEN];
printf("Please Enter your first number:\n");
scanf("%s", first_num);
checkValidInputNum(first_num);
printf("Please Enter your second number:\n");
scanf("%s", second_num);
checkValidInputNum(second_num);
int output_num_len = strlen(first_num) +strlen(second_num);
int shifting, inputDataRemainder, inputDataQuotient;
int output_num[output_num_len];
for (int i = 0; i < output_num_len; i++)
{
output_num[i]=0; //Fill output string of output_num_len with zeroes
//printf("%i", output[i]);
}
for(int i = 0 ; i <strlen(first_num) ; i++)
{
for (int j= 0 ; j < strlen(second_num); j++)
{
shifting = (strlen(first_num) -1 - i) +(strlen(second_num) -1 - j);
inputDataRemainder = ((first_num[i]-48) * (second_num[j]-48)) % 10;
inputDataQuotient = floor((first_num[i]-48) * (second_num[j]-48)/10);
if (output_num[0+shifting] + inputDataRemainder > 9)
{
output_num[1+shifting] += floor((inputDataRemainder + output_num[0+shifting]) / 10);
output_num[0+shifting] = (output_num[0+shifting] + inputDataRemainder)%10;
//printf("Check1");
}
else
{
output_num[0+shifting] += inputDataRemainder;
//printf("Check2");
}
if (output_num[1+shifting] + inputDataQuotient > 9)
{
output_num[2+shifting] += floor((inputDataQuotient + output_num[1+shifting]) / 10);
output_num[1+shifting] = (output_num[1+shifting] + inputDataQuotient)%10;
//printf("Check3");
}
else
{
output_num[1+shifting] += inputDataQuotient;
//printf("Check4");
}
}
}
if (output_num[output_num_len-1] != 0) printf("%i", output_num[output_num_len - 1]);
printf("The answer is:");
for (int i = output_num_len - 2; i > -1  ; i--)
{
printf("%i", output_num[i]);
}
printf("\n");
}
int checkValidInputNum(char* text)
{
for(int i = 0 ; i <strlen(text) ; i++)
{
if (text[i] < 48 || text[i] > 57)
{
printf("Please Enter your input again:\n");
scanf("%s", text);
return checkValidInputNum(text);
}
}
return 0;
}

I am trying to multiple two large numbers to determine the output. Each number is smaller than 200-digits in length. The output should be a single integer.

Input params:
first_num: 2312730179961343894238242938502761288775
second_num: 8783549656928600320634308588114585640082

Expected output: 20313980378767882242186765287491308230145683219100946334095285964698734616679550
Observed output:
110313971037876788224218676528749130822101456832190100946334095285964698734616679550

I am assuming that my calculation is wrong with output_num buffer string shifting. Could anyone please confirm and help? Is my inputDataRemainder and Quotient are ok?

You are not checking if output_num[2+shifting] exceeds 9 after this line:

output_num[2+shifting] += floor((inputDataQuotient + output_num[1+shifting]) / 10);

As a simpler example, an input 9909 101 results in an output 9100809 while the correct answer is 1000809.

This is because the top digit has the value 9 and the second top digit has the value 10, so they are concatenated and printed as 910.

To resolve this issue, you shold check if each digits exceeds 9 and deal with carry if yes.

This can be done like this:

for (int i = 0; i < output_num_len - 1; i++)
{
if (output_num[i] > 9)
{
output_num[i] %= 10;
output_num[i + 1]++;
}
}

Also note that the line

if (output_num[output_num_len-1] != 0) printf("%i", output_num[output_num_len - 1]);

has a wrong position, so the top digit may be printed before the message "The answer is:".

To summarize, your code works by multiplying each pair of digits and adding them all up with shifting to get a final answer.

E.g. 12 x 45 works by multiplying 1x4 (shift 2), 1x5 (shift 1), 2x4 (shift 1) and 2x5 (shift 0).

The bug seems to be that when you add the shifted numbers into the answer you don't make carries happen more than one digit in the answer. For example, let's say that inputDataRemainder is 8 20 times in a row with the same shifting (let's say it's 30), and let's look at output_num[32], [31] and [30]. The first time, you add 8 onto output_num[30], so these 3 are 0,0,8. Then you detect adding another 8 would make it bigger than 9, so you carry over onto output_num[31] and now you have 0,1,6. That's correct. But you don't carry over from output_num[31] onto output_num[32], so after adding a whole bunch of 8's, you get 0,10,4 instead of 1,0,4.

In your test you expected to get an output starting with 20313 but you got 110313 instead. That's because it's not 1,1,0,3,1,3 but actually 1,10,3,1,3. The 10 did not carry to the first digit in the output like it should have.

You could fix this by making the carrying into a loop, so it carries as many times as it needs to. You wouldn't need to do the inputDataRemainder and inputDataQuotient separately - you could just treat it all as remainder, then do the carry loop.

Or you can just let the digits get too high, then fix it at the end. You can just ignore the carrying when you add up the shifted numbers, and then before you print the number (or when you print it), you can see if the digit is bigger than 9, and then you take the quotient and remainder and add the quotient onto the next digit, and if that digit is bigger than 9 you do the same thing again, etc.