inaccurate results with function to add an array of digits together

so i have this function:

``````        static int[] AddArrays(int[] a, int[] b)
{
int length1 = a.Length;
int length2 = b.Length;
int carry = 0;

int max_length = Math.Max(length1, length2) + 1;
int[] minimum_arr = new int[max_length - length1].Concat(a).ToArray();
int[] maximum_arr = new int[max_length - length2].Concat(b).ToArray();
int[] new_arr = new int[max_length];

for (int i = max_length - 1; i >= 0; i--)
{
int first_digit = maximum_arr[i];
int second_digit = i - (max_length - minimum_arr.Length) >= 0 ? minimum_arr[i - (max_length - minimum_arr.Length)] : 0;
if (second_digit + first_digit + carry > 9)
{
new_arr[i] = (second_digit + first_digit + carry) % 10;
carry = 1;
}
else
{
new_arr[i] = second_digit + first_digit + carry;
carry = 0;
}
}

if (carry == 1)
{
int[] result = new int[max_length + 1];
result[0] = 1;
Array.Copy(new_arr, 0, result, 1, max_length);
return result;
}
else
{
return new_arr;
}
}
``````

it basically takes 2 lists of digits and adds them together. the point of this is that each array of digits represent a number that is bigger then the integer limits. now this function is close to working the results get innacurate at certein places and i honestly have no idea why. for example if the function is given these inputs:

`"1481298410984109284109481491284901249018490849081048914820948019"` and
`"3475893498573573849739857349873498739487598"` (both of these are being turned into a array of integers before being sent to the function)

the expected output is:
`1,481,298,410,984,109,284,112,957,384,783,474,822,868,230,706,430,922,413,560,435,617`

and what i get is:

`1,481,298,410,984,109,284,457,070,841,142,258,634,158,894,233,092,241,356,043,561,7`

i would very much appreciate some help with this ive been trying to figure it out for hours and i cant seem to get it to work perfectly.

>Solution :

I suggest `Reverse` arrays `a` and `b` and use good old school algorithm:

``````static int[] AddArrays(int[] a, int[] b) {
Array.Reverse(a);
Array.Reverse(b);

int[] result = new int[Math.Max(a.Length, b.Length) + 1];

int carry = 0;
int value = 0;

for (int i = 0; i < Math.Max(a.Length, b.Length); ++i) {
value = (i < a.Length ? a[i] : 0) + (i < b.Length ? b[i] : 0) + carry;

result[i] = value % 10;
carry = value / 10;
}

if (carry > 0)
result[result.Length - 1] = carry;
else
Array.Resize(ref result, result.Length - 1);

// Let's restore a and b
Array.Reverse(a);
Array.Reverse(b);

Array.Reverse(result);

return result;
}
``````

Demo:

``````string a = "1481298410984109284109481491284901249018490849081048914820948019";
string b = "3475893498573573849739857349873498739487598";

``````1481298410984109284112957384783474822868230706430922413560435617